You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
256 lines
10 KiB
Python
256 lines
10 KiB
Python
"""Offline checks for the private-repository update safety boundary."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
from virsh_panel.updater import REPOSITORY_URL, UpdateError, Updater
|
|
|
|
|
|
class MemoryStore:
|
|
def __init__(self):
|
|
self.secrets: dict[str, str] = {}
|
|
self.values: dict[str, str] = {}
|
|
|
|
def get_secret(self, name):
|
|
return self.secrets.get(name)
|
|
|
|
def set_secret(self, name, value):
|
|
self.secrets[name] = value
|
|
|
|
def delete_secret(self, name):
|
|
self.secrets.pop(name, None)
|
|
|
|
def get_value(self, name):
|
|
return self.values.get(name)
|
|
|
|
def set_value(self, name, value):
|
|
self.values[name] = value
|
|
|
|
|
|
def git(path: Path, *args: str) -> str:
|
|
result = subprocess.run(
|
|
["git", *args], cwd=path, capture_output=True, text=True, check=True,
|
|
)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def make_repo(tmp_path: Path) -> Path:
|
|
source = tmp_path / "source"
|
|
source.mkdir()
|
|
git(source, "init", "-b", "main")
|
|
git(source, "config", "user.name", "Updater Test")
|
|
git(source, "config", "user.email", "updater@example.test")
|
|
(source / "README.md").write_text("old\n", encoding="utf-8")
|
|
(source / "requirements.txt").write_text("example-package==1.0\n", encoding="utf-8")
|
|
git(source, "add", "README.md", "requirements.txt")
|
|
git(source, "commit", "-m", "initial")
|
|
checkout = tmp_path / "panel"
|
|
subprocess.run(
|
|
["git", "clone", "--branch", "main", str(source), str(checkout)],
|
|
capture_output=True, text=True, check=True,
|
|
)
|
|
git(checkout, "remote", "set-url", "origin", REPOSITORY_URL)
|
|
return checkout
|
|
|
|
|
|
def advance_source(source: Path, *, filename: str = "README.md") -> str:
|
|
(source / filename).parent.mkdir(parents=True, exist_ok=True)
|
|
(source / filename).write_text("new\n", encoding="utf-8")
|
|
git(source, "add", filename)
|
|
git(source, "commit", "-m", "next")
|
|
return git(source, "rev-parse", "HEAD")
|
|
|
|
|
|
def local_fetch(updater: Updater, source: Path):
|
|
def fetch() -> str:
|
|
git(updater.repo_dir, "fetch", "--no-tags", str(source), "refs/heads/main")
|
|
return git(updater.repo_dir, "rev-parse", "FETCH_HEAD")
|
|
|
|
updater._fetch_remote = fetch
|
|
updater._install_requirements = lambda _target: None
|
|
|
|
|
|
class UpdaterTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory(prefix="virsh-panel-updater-test-")
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.tmp_path = Path(self.temp.name)
|
|
|
|
def test_settings_and_token_never_reveal_secret(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
store = MemoryStore()
|
|
updater = Updater(checkout, store)
|
|
updater.set_token("a-test-access-token-123")
|
|
settings = updater.settings()
|
|
self.assertEqual(settings["repository"], REPOSITORY_URL)
|
|
self.assertTrue(settings["token_configured"])
|
|
self.assertTrue(settings["checkout_ready"])
|
|
self.assertIsNone(settings["active_job_id"])
|
|
self.assertIsNone(settings["last_job_id"])
|
|
self.assertNotIn("a-test-access-token-123", repr(settings))
|
|
with updater._git_auth() as env:
|
|
self.assertEqual(env["VIRSH_PANEL_GIT_TOKEN"], "a-test-access-token-123")
|
|
self.assertNotIn("a-test-access-token-123", Path(env["GIT_ASKPASS"]).read_text())
|
|
updater.clear_token()
|
|
self.assertFalse(updater.settings()["token_configured"])
|
|
|
|
def test_check_is_read_only_and_reports_new_version(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
updater = Updater(checkout, MemoryStore())
|
|
current = git(checkout, "rev-parse", "HEAD")
|
|
updater._remote_head = lambda: current
|
|
self.assertEqual(updater.check()["status"], "current")
|
|
updater._remote_head = lambda: "a" * 40
|
|
self.assertEqual(updater.check()["status"], "update_available")
|
|
self.assertEqual(git(checkout, "rev-parse", "HEAD"), current)
|
|
|
|
def test_zip_or_dirty_checkout_is_rejected(self):
|
|
plain = self.tmp_path / "plain"
|
|
plain.mkdir()
|
|
with self.assertRaisesRegex(UpdateError, "Git"):
|
|
Updater(plain, MemoryStore()).check()
|
|
|
|
checkout = make_repo(self.tmp_path)
|
|
(checkout / "README.md").write_text("user changes\n", encoding="utf-8")
|
|
updater = Updater(checkout, MemoryStore())
|
|
with self.assertRaisesRegex(UpdateError, "未提交"):
|
|
updater.create_job()
|
|
with self.assertRaisesRegex(UpdateError, "未提交"):
|
|
updater.apply()
|
|
|
|
def test_fast_forward_job_is_persisted_and_calls_restart(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
source = self.tmp_path / "source"
|
|
old = git(checkout, "rev-parse", "HEAD")
|
|
target = advance_source(source)
|
|
store = MemoryStore()
|
|
updater = Updater(checkout, store)
|
|
updater.set_token("a-test-access-token-123")
|
|
local_fetch(updater, source)
|
|
queued = updater.create_job()
|
|
self.assertEqual(updater.settings()["active_job_id"], queued["job_id"])
|
|
restarted = []
|
|
result = updater.run_pending_job(restart=lambda: restarted.append(True))
|
|
self.assertEqual(result["status"], "succeeded")
|
|
self.assertEqual(result["old_commit"], old)
|
|
self.assertEqual(result["new_commit"], target)
|
|
self.assertTrue(result["rollback_ref"].startswith("refs/virsh-panel/rollback/"))
|
|
self.assertEqual(updater.get_job(queued["job_id"]), result)
|
|
self.assertEqual(updater.settings()["last_job_id"], queued["job_id"])
|
|
self.assertIsNone(updater.settings()["active_job_id"])
|
|
self.assertEqual(restarted, [True])
|
|
self.assertEqual(git(checkout, "rev-parse", "HEAD"), target)
|
|
self.assertEqual(git(checkout, "rev-parse", result["rollback_ref"]), old)
|
|
|
|
def test_remote_history_rewrite_never_overwrites_local_code(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
source = self.tmp_path / "source"
|
|
target = advance_source(source)
|
|
git(checkout, "config", "user.name", "Updater Test")
|
|
git(checkout, "config", "user.email", "updater@example.test")
|
|
(checkout / "README.md").write_text("local fork\n", encoding="utf-8")
|
|
git(checkout, "add", "README.md")
|
|
git(checkout, "commit", "-m", "local fork")
|
|
local = git(checkout, "rev-parse", "HEAD")
|
|
updater = Updater(checkout, MemoryStore())
|
|
local_fetch(updater, source)
|
|
with self.assertRaisesRegex(UpdateError, "分叉"):
|
|
updater.apply()
|
|
self.assertEqual(git(checkout, "rev-parse", "HEAD"), local)
|
|
self.assertNotEqual(local, target)
|
|
|
|
def test_failed_dependency_sync_leaves_code_unchanged(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
source = self.tmp_path / "source"
|
|
advance_source(source)
|
|
updater = Updater(checkout, MemoryStore())
|
|
local_fetch(updater, source)
|
|
old = git(checkout, "rev-parse", "HEAD")
|
|
|
|
def fail_install(_target):
|
|
raise UpdateError("依赖失败", 502)
|
|
|
|
updater._install_requirements = fail_install
|
|
with self.assertRaisesRegex(UpdateError, "依赖失败"):
|
|
updater.apply()
|
|
self.assertEqual(git(checkout, "rev-parse", "HEAD"), old)
|
|
|
|
def test_git_url_rewrite_is_rejected_before_sending_token(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
git(checkout, "config", "url.https://evil.example/.insteadOf", "https://g.luoli.live/")
|
|
updater = Updater(checkout, MemoryStore())
|
|
updater.set_token("a-test-access-token-123")
|
|
with self.assertRaisesRegex(UpdateError, "URL 重写"):
|
|
updater.check()
|
|
|
|
def test_new_code_cannot_track_private_data_or_submodules(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
source = self.tmp_path / "source"
|
|
target = advance_source(source, filename="data/master.key")
|
|
updater = Updater(checkout, MemoryStore())
|
|
local_fetch(updater, source)
|
|
old = git(checkout, "rev-parse", "HEAD")
|
|
with self.assertRaisesRegex(UpdateError, "数据目录"):
|
|
updater.apply()
|
|
self.assertEqual(git(checkout, "rev-parse", "HEAD"), old)
|
|
self.assertNotEqual(old, target)
|
|
|
|
def test_failed_restart_is_persisted_without_hiding_applied_commit(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
source = self.tmp_path / "source"
|
|
target = advance_source(source)
|
|
updater = Updater(checkout, MemoryStore())
|
|
updater.set_token("a-test-access-token-123")
|
|
local_fetch(updater, source)
|
|
job = updater.create_job()
|
|
|
|
def fail_restart():
|
|
raise UpdateError("重启失败", 500)
|
|
|
|
with self.assertRaisesRegex(UpdateError, "重启失败"):
|
|
updater.run_pending_job(restart=fail_restart)
|
|
stored = updater.get_job(job["job_id"])
|
|
self.assertEqual(stored["status"], "failed")
|
|
self.assertEqual(stored["new_commit"], target)
|
|
self.assertTrue(stored["rollback_ref"])
|
|
self.assertIn("代码可能已切换", stored["error"])
|
|
|
|
def test_checked_remote_commit_is_pinned_through_worker_execution(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
source = self.tmp_path / "source"
|
|
old = git(checkout, "rev-parse", "HEAD")
|
|
checked = advance_source(source)
|
|
store = MemoryStore()
|
|
updater = Updater(checkout, store)
|
|
updater.set_token("a-test-access-token-123")
|
|
updater._remote_head = lambda: checked
|
|
local_fetch(updater, source)
|
|
queued = updater.create_job(
|
|
expected_current_commit=old,
|
|
expected_remote_commit=checked,
|
|
)
|
|
advance_source(source, filename="VERSION")
|
|
with self.assertRaisesRegex(UpdateError, "main 分支已变化"):
|
|
updater.run_pending_job(restart=lambda: None)
|
|
self.assertEqual(git(checkout, "rev-parse", "HEAD"), old)
|
|
self.assertEqual(updater.get_job(queued["job_id"])["status"], "failed")
|
|
|
|
def test_create_job_rejects_changed_remote_since_check(self):
|
|
checkout = make_repo(self.tmp_path)
|
|
updater = Updater(checkout, MemoryStore())
|
|
updater.set_token("a-test-access-token-123")
|
|
updater._remote_head = lambda: "b" * 40
|
|
with self.assertRaisesRegex(UpdateError, "main 分支已变化"):
|
|
updater.create_job(
|
|
expected_current_commit=git(checkout, "rev-parse", "HEAD"),
|
|
expected_remote_commit="a" * 40,
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|