GuestOps asible playbook

This commit is contained in:
2026-10-21 11:55:33 +01:00
parent c5c6ec1453
commit db8422afda
61 changed files with 108 additions and 4417 deletions
+1 -1
View File
@@ -72,7 +72,7 @@ else:
hotel["signature"] = "Persisted across container restart"
request("/api/hotel", "PUT", hotel)
invite = request("/api/team/invite", "POST", {"name": "Deployment Staff", "email": "deployment-staff@example.invalid"})
assert invite["link"].startswith("https://sandbox-guestops.futuresens.co.uk/account#token=")
assert invite["link"].startswith("https://guestops-sandbox.futuresens.co.uk/account#token=")
request("/api/auth/logout", "POST")
request("/api/hotel", expected=401)
print("Production smoke checks passed: built UI, secure cookies, owner login, persisted settings and staff invitation, onboarding and logout.")
-53
View File
@@ -1,53 +0,0 @@
from pathlib import Path
import unittest
ROOT = Path(__file__).resolve().parents[1]
PLAYBOOK = ROOT / "deploy" / "ansible" / "guestops.yml"
class AnsibleHandoffTests(unittest.TestCase):
def test_release_is_verified_before_build_and_start(self):
text = PLAYBOOK.read_text(encoding="utf-8")
controller_verify = text.index("Verify source package on the Ansible controller")
target_verify = text.index("Verify transferred package and record on the target")
api_build = text.index("Build API image from the verified source")
preflight = text.index("Run offline deployment preflight")
compose_start = text.index("Start the verified release without rebuilding")
readiness = text.index("Wait for loopback readiness")
public_readiness = text.index("Verify public HTTPS readiness and certificate trust")
current = text.index("Select the current successful release")
self.assertLess(controller_verify, target_verify)
self.assertLess(target_verify, api_build)
self.assertLess(api_build, preflight)
self.assertLess(preflight, compose_start)
self.assertLess(compose_start, readiness)
self.assertLess(readiness, public_readiness)
self.assertLess(public_readiness, current)
def test_playbook_uses_safe_release_controls(self):
text = PLAYBOOK.read_text(encoding="utf-8")
for required in (
"guestops_release_commit is match('^[0-9a-f]{40}$')",
"checksum_algorithm: sha256",
"deploy/verify_source_package.py",
"deploy/release_record.py",
"deploy/ops.py",
"--offline",
"--no-build",
"GOOGLE_ENABLE_SENDING",
"AUTO_REPLY_ENABLE_LIVE",
"no_log: true",
"http://127.0.0.1:8080/health/ready",
"Reject public API or MongoDB listeners",
"Validate Nginx configuration",
"validate_certs: true",
"enabled: true",
):
self.assertIn(required, text)
self.assertNotIn("ansible.builtin.shell", text)
self.assertNotIn("password=", text.lower())
if __name__ == "__main__":
unittest.main()
-53
View File
@@ -1,53 +0,0 @@
from pathlib import Path
import unittest
ROOT = Path(__file__).resolve().parents[1]
PLAYBOOK = ROOT / "deploy" / "ansible" / "guestops-operations.yml"
class AnsibleOperationsTests(unittest.TestCase):
def test_operations_require_release_and_private_inputs(self):
text = PLAYBOOK.read_text(encoding="utf-8")
for required in (
"/srv/guestops/current",
"guestops_release_commit is match('^[0-9a-f]{40}$')",
"guestops_backup_recipient is match('^[A-Fa-f0-9]{40}$')",
"guestops_durable_logs_configured | bool",
"/etc/guestops/backup.env",
"/etc/guestops/backup-transfer.env",
"/etc/guestops/backup-transfer.key",
"/etc/guestops/backup-known-hosts",
"no_log: true",
):
self.assertIn(required, text)
def test_public_key_units_monitoring_and_evidence_are_integrated(self):
text = PLAYBOOK.read_text(encoding="utf-8")
ordered = (
"Import recovery public key only",
"Verify installed systemd units",
"Enable transfer retry and monitoring timers",
"Install restricted Zabbix status item",
"Generate initial non-sensitive monitoring status",
"Retain monitoring status on the Ansible controller",
)
positions = [text.index(item) for item in ordered]
self.assertEqual(positions, sorted(positions))
self.assertIn("guestops_enable_backup_schedule: false", text)
self.assertNotIn("ansible.builtin.shell", text)
self.assertNotIn("PRIVATE KEY", text)
def test_systemd_units_follow_selected_release(self):
for name in (
"guestops-backup.service",
"guestops-backup-transfer.service",
"guestops-monitor-status.service",
):
text = (ROOT / "deploy" / "systemd" / name).read_text(encoding="utf-8")
self.assertIn("/srv/guestops/current", text)
self.assertNotIn("WorkingDirectory=/srv/guestops\n", text)
if __name__ == "__main__":
unittest.main()
-129
View File
@@ -1,129 +0,0 @@
import importlib.util
from pathlib import Path
import unittest
spec = importlib.util.spec_from_file_location(
"backup_restore_acceptance",
Path(__file__).resolve().parents[1] / "deploy" / "backup_restore_acceptance.py")
acceptance = importlib.util.module_from_spec(spec)
spec.loader.exec_module(acceptance)
COMMIT = "a" * 40
RELEASE_SHA = "b" * 64
def valid_record():
return {
"schemaVersion": 1,
"system": "guestops-backup-recovery",
"evidenceId": "backup-restore",
"dataClassification": "synthetic-only",
"releaseVersion": "0.2.1",
"releaseCommit": COMMIT,
"releaseRecordSha256": RELEASE_SHA,
"archiveSha256": "c" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk",
"hostIdentifier": "guestops-sandbox-01",
"images": {
"api": {"reference": f"guestops-api:{COMMIT}", "id": "sha256:" + "d" * 64},
"worker": {"reference": f"guestops-worker:{COMMIT}", "id": "sha256:" + "e" * 64},
"mongo": {"reference": "mongo:8.0", "id": "sha256:" + "f" * 64},
},
"owners": {
"backup": "Backup owner",
"monitoring": "Monitoring owner",
"recoveryOperator": "Recovery operator",
"technicalEscalation": "Technical owner",
"retention": "Retention owner",
"independentReviewer": "Independent reviewer",
},
"startedAt": "2026-10-01T09:00:00Z",
"endedAt": "2026-10-01T12:00:00Z",
"reviewedAt": "2026-10-01T13:00:00Z",
"recoveryObjectives": {
"targetRpoHours": 24, "observedRpoHours": 1,
"targetRtoMinutes": 240, "observedRtoMinutes": 180,
},
"retention": {
"localVerifiedDays": 7, "offHostDaily": 35,
"offHostMonthly": 12, "legalHoldOverrideTested": True,
},
"backup": {
"createdAt": "2026-10-01T08:00:00Z",
"sha256": "1" * 64,
"transferredSha256": "1" * 64,
"privateKeyPresentOnHost": False,
},
"rollback": {
"previousReleaseCommit": "2" * 40,
"previousArchiveSha256": "3" * 64,
"previousImages": {
"api": {"reference": "guestops-api:" + "2" * 40, "id": "sha256:" + "4" * 64},
"worker": {"reference": "guestops-worker:" + "2" * 40, "id": "sha256:" + "5" * 64},
},
"persistentVolumesReplaced": False,
"restoredReleaseCommit": COMMIT,
"unresolvedOperations": 0,
"finalControls": {
"googleSending": "disabled", "faqLiveMode": "disabled",
"pmsWrites": "disabled", "paymentCreation": "disabled",
},
},
"monitoringState": "healthy",
"unresolvedCriticalFindings": 0,
"scenarios": [
{"id": scenario, "status": "pass", "evidence": [f"restricted-{index}"]}
for index, scenario in enumerate(sorted(acceptance.SCENARIOS), 1)
],
}
class BackupRestoreAcceptanceTests(unittest.TestCase):
def test_complete_record_passes(self):
acceptance.validate(valid_record(), COMMIT, RELEASE_SHA)
def test_release_identity_and_images_are_bound(self):
record = valid_record(); record["releaseCommit"] = "9" * 40
with self.assertRaisesRegex(ValueError, "approved candidate"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["images"]["api"]["reference"] = "guestops-api:latest"
with self.assertRaisesRegex(ValueError, "full approved commit"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["rollback"]["previousImages"]["worker"]["id"] = "mutable"
with self.assertRaisesRegex(ValueError, "retained previous release identity"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
def test_recovery_objectives_and_checksums_must_pass(self):
record = valid_record(); record["recoveryObjectives"]["observedRtoMinutes"] = 241
with self.assertRaisesRegex(ValueError, "four-hour"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["backup"]["transferredSha256"] = "9" * 64
with self.assertRaisesRegex(ValueError, "checksums must match"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["recoveryObjectives"]["observedRpoHours"] = 2
with self.assertRaisesRegex(ValueError, "match the backup"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
def test_independent_review_retention_and_final_state_are_required(self):
record = valid_record(); record["owners"]["independentReviewer"] = record["owners"]["backup"]
with self.assertRaisesRegex(ValueError, "different"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["retention"]["legalHoldOverrideTested"] = False
with self.assertRaisesRegex(ValueError, "Retention"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["rollback"]["persistentVolumesReplaced"] = True
with self.assertRaisesRegex(ValueError, "must not replace"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
def test_exact_passed_scenarios_and_monitoring_are_required(self):
record = valid_record(); record["scenarios"].pop()
with self.assertRaisesRegex(ValueError, "exact backup/recovery scenario"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
record = valid_record(); record["monitoringState"] = "degraded"
with self.assertRaisesRegex(ValueError, "Monitoring must be healthy"):
acceptance.validate(record, COMMIT, RELEASE_SHA)
if __name__ == "__main__":
unittest.main()
-81
View File
@@ -1,81 +0,0 @@
import importlib.util
import json
import os
from pathlib import Path
import tempfile
import time
import unittest
from unittest.mock import patch
spec = importlib.util.spec_from_file_location(
"backup_transfer", Path(__file__).resolve().parents[1] / "deploy" / "backup_transfer.py")
transfer = importlib.util.module_from_spec(spec)
spec.loader.exec_module(transfer)
class BackupTransferTests(unittest.TestCase):
def backup(self, directory: Path, name="guestops-20261001T021700Z.tar.gpg") -> Path:
path = directory / name
path.write_bytes(b"encrypted-backup")
return path
def config(self, directory: Path):
return {
"directory": directory, "host": "store.example.invalid", "user": "guestops_upload",
"remote": "/restricted/guestops", "identity": Path("/safe/key"),
"known_hosts": Path("/safe/known_hosts"),
}
def test_existing_matching_remote_is_marked_without_upload(self):
with tempfile.TemporaryDirectory() as folder:
backup = self.backup(Path(folder)); checksum = transfer.digest(backup)
with patch.object(transfer, "remote_digest", return_value=checksum), \
patch.object(transfer, "run") as run:
transfer.transfer_one(self.config(Path(folder)), backup)
run.assert_not_called()
marker = json.loads(transfer.marker_path(backup).read_text(encoding="utf-8"))
self.assertEqual(marker["sha256"], checksum)
def test_existing_mismatched_remote_is_never_overwritten(self):
with tempfile.TemporaryDirectory() as folder:
backup = self.backup(Path(folder))
with patch.object(transfer, "remote_digest", return_value="9" * 64), \
patch.object(transfer, "run") as run:
with self.assertRaisesRegex(RuntimeError, "different checksum"):
transfer.transfer_one(self.config(Path(folder)), backup)
run.assert_not_called()
self.assertFalse(transfer.marker_path(backup).exists())
def test_new_remote_is_uploaded_verified_and_marked(self):
with tempfile.TemporaryDirectory() as folder:
backup = self.backup(Path(folder)); checksum = transfer.digest(backup)
with patch.object(transfer, "remote_digest", side_effect=[None, checksum, checksum]), \
patch.object(transfer, "run", return_value=b"") as run, \
patch.object(transfer.subprocess, "run"):
transfer.transfer_one(self.config(Path(folder)), backup)
self.assertTrue(any(call.args[0][0] == "rsync" for call in run.call_args_list))
self.assertTrue(transfer.marker_path(backup).exists())
def test_prune_removes_only_old_checksum_verified_backups(self):
with tempfile.TemporaryDirectory() as folder:
directory = Path(folder)
verified = self.backup(directory)
checksum = transfer.digest(verified)
transfer.write_marker(verified, checksum)
unverified = self.backup(directory, "guestops-20261002T021700Z.tar.gpg")
old = time.time() - 8 * 86400
os.utime(verified, (old, old)); os.utime(unverified, (old, old))
removed = transfer.prune_verified(self.config(directory), 7, now=time.time())
self.assertEqual(removed, 1)
self.assertFalse(verified.exists())
self.assertTrue(unverified.exists())
def test_retention_bounds_are_enforced(self):
with tempfile.TemporaryDirectory() as folder:
with self.assertRaisesRegex(RuntimeError, "between 1 and 365"):
transfer.prune_verified(self.config(Path(folder)), 0)
if __name__ == "__main__":
unittest.main()
-26
View File
@@ -1,26 +0,0 @@
import importlib.util
from pathlib import Path
import unittest
spec = importlib.util.spec_from_file_location("capacity_probe", Path(__file__).resolve().parents[1] / "deploy" / "capacity_probe.py")
probe = importlib.util.module_from_spec(spec)
spec.loader.exec_module(probe)
class CapacityProbeTests(unittest.TestCase):
def test_summary_reports_failures_and_nearest_rank_latency(self):
report = probe.summarize([(True, 10), (True, 20), (False, 30), (True, 40), (True, 100)], 2)
self.assertEqual(report["requests"], 5)
self.assertEqual(report["successes"], 4)
self.assertEqual(report["failures"], 1)
self.assertEqual(report["errorRate"], 0.2)
self.assertEqual(report["latencyMs"], {"median": 30, "p95": 100, "maximum": 100})
def test_summary_rejects_empty_results(self):
with self.assertRaisesRegex(ValueError, "At least one"):
probe.summarize([], 1)
if __name__ == "__main__":
unittest.main()
-113
View File
@@ -1,113 +0,0 @@
import importlib.util
from pathlib import Path
import unittest
spec = importlib.util.spec_from_file_location(
"debian_acceptance", Path(__file__).resolve().parents[1] / "deploy" / "debian_acceptance.py")
acceptance = importlib.util.module_from_spec(spec)
spec.loader.exec_module(acceptance)
COMMIT = "a" * 40
RELEASE_SHA = "b" * 64
def common(system):
return {
"schemaVersion": 1,
"system": system,
"evidenceId": acceptance.SYSTEMS[system]["evidenceId"],
"releaseVersion": "0.2.1",
"releaseCommit": COMMIT,
"releaseRecordSha256": RELEASE_SHA,
"archiveSha256": "c" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk",
"hostIdentifier": "guestops-sandbox-01",
"images": {
"api": {"reference": f"guestops-api:{COMMIT}", "id": "sha256:" + "d" * 64},
"worker": {"reference": f"guestops-worker:{COMMIT}", "id": "sha256:" + "e" * 64},
},
"operator": "Deployment operator",
"reviewedBy": "Independent reviewer",
"startedAt": "2026-09-30T09:00:00Z",
"endedAt": "2026-09-30T10:00:00Z",
"reviewedAt": "2026-09-30T11:00:00Z",
"unresolvedCriticalFindings": 0,
"scenarios": [
{"id": scenario, "status": "pass", "evidence": [f"restricted-{index}"]}
for index, scenario in enumerate(sorted(acceptance.SYSTEMS[system]["scenarios"]), 1)
],
}
def valid_records():
host = common("guestops-debian-host")
host["hostFacts"] = {
"debianMajor": 12,
"cpuCores": 4,
"memoryBytes": 8_140_382_208,
"freeDiskBytes": 14_275_686_400,
"publicTcpPorts": [80, 443],
}
host["featureControls"] = {
"googleSending": "disabled",
"faqLiveMode": "disabled",
"pmsWrites": "disabled",
"paymentCreation": "disabled",
}
persistence = common("guestops-persistence")
persistence["drillCommand"] = "python3 deploy/ops.py persistence-drill --confirm-restart"
return host, persistence
class DebianAcceptanceTests(unittest.TestCase):
def test_complete_matching_records_pass(self):
acceptance.validate_pair(*valid_records(), COMMIT, RELEASE_SHA)
def test_expected_release_identity_is_required(self):
host, persistence = valid_records()
host["releaseCommit"] = "f" * 40
with self.assertRaisesRegex(ValueError, "approved candidate"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
host, persistence = valid_records()
persistence["releaseRecordSha256"] = "f" * 64
with self.assertRaisesRegex(ValueError, "retained release record"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
def test_exact_images_and_cross_record_identity_are_required(self):
host, persistence = valid_records()
host["images"]["api"]["reference"] = "guestops-api:latest"
with self.assertRaisesRegex(ValueError, "full approved commit"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
host, persistence = valid_records()
persistence["archiveSha256"] = "f" * 64
with self.assertRaisesRegex(ValueError, "same archiveSha256"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
def test_host_capacity_ports_and_disabled_controls_are_required(self):
host, persistence = valid_records()
host["hostFacts"]["publicTcpPorts"] = [80, 443, 8080]
with self.assertRaisesRegex(ValueError, "Only TCP ports"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
host, persistence = valid_records()
host["featureControls"]["googleSending"] = "enabled"
with self.assertRaisesRegex(ValueError, "must remain disabled"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
def test_independent_review_scenarios_and_findings_are_required(self):
host, persistence = valid_records()
host["reviewedBy"] = host["operator"]
with self.assertRaisesRegex(ValueError, "different people"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
host, persistence = valid_records()
persistence["scenarios"][0]["status"] = "not-run"
with self.assertRaisesRegex(ValueError, "has not passed"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
host, persistence = valid_records()
host["unresolvedCriticalFindings"] = 1
with self.assertRaisesRegex(ValueError, "critical findings"):
acceptance.validate_pair(host, persistence, COMMIT, RELEASE_SHA)
if __name__ == "__main__":
unittest.main()
+1 -1
View File
@@ -16,7 +16,7 @@ def valid_record():
"desktopBaselineCommit": acceptance.DESKTOP_BASELINE,
"releaseCommit": "a" * 40,
"releaseRecordSha256": "b" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk",
"environment": "https://guestops-sandbox.futuresens.co.uk",
"browser": {"name": "Microsoft Edge", "version": "140.0.0.0", "operatingSystem": "Windows 11"},
"viewport": {"width": 1440, "height": 900, "deviceScaleFactor": 1},
"hotelTimeZone": "Europe/London",
+1 -1
View File
@@ -21,7 +21,7 @@ def base(system):
return {
"schemaVersion": 1, "system": system, "targetGate": "B",
"releaseCommit": "a" * 40, "releaseRecordSha256": "b" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk",
"environment": "https://guestops-sandbox.futuresens.co.uk",
"operator": "Acceptance operator", "reviewedBy": "Independent reviewer",
"startedAt": "2026-10-01T09:00:00Z", "endedAt": "2026-10-01T10:00:00Z", "reviewedAt": "2026-10-01T11:00:00Z",
}
-141
View File
@@ -1,141 +0,0 @@
import contextlib
import hashlib
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location("gate_b_bundle", ROOT / "deploy" / "gate_b_bundle.py")
bundle = importlib.util.module_from_spec(spec)
spec.loader.exec_module(bundle)
COMMIT = "a" * 40
API = {"reference": f"guestops-api:{COMMIT}", "id": "sha256:" + "b" * 64}
WORKER = {"reference": f"guestops-worker:{COMMIT}", "id": "sha256:" + "c" * 64}
ORIGIN = "https://sandbox-guestops.futuresens.co.uk"
class GateBBundleTests(unittest.TestCase):
def fixture(self, directory: str):
root = Path(directory)
archive = root / "GuestOps-0.2.1-aaaaaaaaaaaa.tar.gz"
source = root / "GuestOps-0.2.1-aaaaaaaaaaaa.source.json"
release = root / "release-record.json"
metrics = root / "host-metrics.json"
archive.write_bytes(b"approved source")
artifact = {
"name": archive.name,
"size": archive.stat().st_size,
"sha256": hashlib.sha256(archive.read_bytes()).hexdigest(),
}
source.write_text(json.dumps({"schemaVersion": 1, "version": "0.2.1", "commit": COMMIT, "artifact": artifact}), encoding="utf-8")
release.write_text(json.dumps({
"schemaVersion": 1, "version": "0.2.1", "commit": COMMIT,
"artifact": artifact, "images": {"api": API, "worker": WORKER},
}), encoding="utf-8")
release_sha = hashlib.sha256(release.read_bytes()).hexdigest()
metrics.write_bytes(b'{"cpu":40,"memory":35}')
values = {}
paths = {}
for name in bundle.RECORD_KEYS:
value = {"releaseCommit": COMMIT, "releaseRecordSha256": release_sha}
if name in {
"debian-host", "persistence", "backup-restore", "google-mailbox",
"automation", "identity-privacy", "inbox-usability", "incident-support",
"pilot-findings",
}:
value["environment"] = ORIGIN
if name in {"debian-host", "persistence", "backup-restore"}:
value["archiveSha256"] = artifact["sha256"]
value["images"] = {"api": API, "worker": WORKER}
values[name] = value
values["capacity"].update({
"schemaVersion": 1, "kind": "guestops-read-only-capacity",
"originHost": "sandbox-guestops.futuresens.co.uk",
"paths": ["/health/ready", "/api/hotel", "/api/conversations/page"],
"concurrency": 10, "requests": 100, "successes": 100, "failures": 0,
"errorRate": 0.0, "latencyMs": {"median": 100, "p95": 250, "maximum": 300},
})
pilot_path = root / "pilot-findings.json"
pilot_path.write_text(json.dumps(values["pilot-findings"]), encoding="utf-8")
paths["pilot-findings"] = pilot_path
capacity_path = root / "capacity.json"
capacity_path.write_text(json.dumps(values["capacity"]), encoding="utf-8")
paths["capacity"] = capacity_path
values["pilot-approval"].update({
"capacity": {
"reportSha256": hashlib.sha256(capacity_path.read_bytes()).hexdigest(),
"hostMetricsSha256": hashlib.sha256(metrics.read_bytes()).hexdigest(),
"observedConcurrency": 10, "observedP95Ms": 250, "observedErrorRate": 0.0,
},
"pilot": {"recordSha256": hashlib.sha256(pilot_path.read_bytes()).hexdigest()},
})
for name in bundle.RECORD_KEYS - paths.keys():
path = root / f"{name}.json"
path.write_text(json.dumps(values[name]), encoding="utf-8")
paths[name] = path
records = {name: (paths[name], values[name]) for name in bundle.RECORD_KEYS}
return archive, source, release, metrics, records
@contextlib.contextmanager
def mocked_individual_validators(self):
patches = [
patch.object(bundle.debian_acceptance, "validate_pair"),
patch.object(bundle.backup_restore_acceptance, "validate"),
patch.object(bundle.google_acceptance, "validate"),
patch.object(bundle.automation_acceptance, "validate"),
patch.object(bundle.identity_privacy_acceptance, "validate"),
patch.object(bundle.desktop_acceptance, "validate"),
patch.object(bundle.incident_exercise, "validate"),
patch.object(bundle.pilot_run, "validate"),
patch.object(bundle.pilot_approval, "validate"),
]
with contextlib.ExitStack() as stack:
for item in patches:
stack.enter_context(item)
yield
def test_complete_bundle_is_bound_to_one_release(self):
with tempfile.TemporaryDirectory() as directory, self.mocked_individual_validators():
archive, source, release, metrics, records = self.fixture(directory)
result = bundle.validate_bundle(archive, source, release, records, metrics)
self.assertTrue(result["validated"])
self.assertEqual(result["releaseCommit"], COMMIT)
self.assertEqual(set(result["records"]), bundle.RECORD_KEYS)
def test_different_environment_or_checksum_is_rejected(self):
with tempfile.TemporaryDirectory() as directory, self.mocked_individual_validators():
archive, source, release, metrics, records = self.fixture(directory)
records["google-mailbox"][1]["environment"] = "https://other.example.invalid"
with self.assertRaisesRegex(ValueError, "different environments"):
bundle.validate_bundle(archive, source, release, records, metrics)
with tempfile.TemporaryDirectory() as directory, self.mocked_individual_validators():
archive, source, release, metrics, records = self.fixture(directory)
records["pilot-approval"][1]["capacity"]["reportSha256"] = "0" * 64
with self.assertRaisesRegex(ValueError, "capacity report checksum"):
bundle.validate_bundle(archive, source, release, records, metrics)
def test_capacity_counts_and_latency_are_checked(self):
report = {
"schemaVersion": 1, "kind": "guestops-read-only-capacity",
"releaseCommit": COMMIT, "releaseRecordSha256": "d" * 64,
"paths": ["/health/ready", "/api/hotel", "/api/conversations/page"],
"concurrency": 10, "requests": 10, "successes": 9, "failures": 1,
"errorRate": 0.1, "latencyMs": {"median": 10, "p95": 20, "maximum": 30},
}
bundle.validate_capacity(report, COMMIT, "d" * 64)
report["failures"] = 2
with self.assertRaisesRegex(ValueError, "do not match requests"):
bundle.validate_capacity(report, COMMIT, "d" * 64)
if __name__ == "__main__":
unittest.main()
+1 -1
View File
@@ -14,7 +14,7 @@ def valid_report():
"system": "google-mailbox",
"releaseCommit": "a" * 40,
"releaseRecordSha256": "b" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk",
"environment": "https://guestops-sandbox.futuresens.co.uk",
"mailboxLabel": "sandbox mailbox A",
"operator": "Test operator",
"startedAt": "2026-09-29T10:00:00Z",
+1 -1
View File
@@ -17,7 +17,7 @@ def valid_record(gate="B"):
"dataClassification": "synthetic-only",
"releaseCommit": "a" * 40,
"releaseRecordSha256": "b" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk",
"environment": "https://guestops-sandbox.futuresens.co.uk",
"operator": "Exercise operator",
"incidentCommander": "Incident commander",
"reviewedBy": "Independent reviewer",
-75
View File
@@ -1,75 +0,0 @@
import datetime as dt
import importlib.util
import json
import os
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
spec = importlib.util.spec_from_file_location(
"monitor_status", Path(__file__).resolve().parents[1] / "deploy" / "monitor_status.py")
monitor = importlib.util.module_from_spec(spec)
spec.loader.exec_module(monitor)
class MonitorStatusTests(unittest.TestCase):
def test_compose_json_is_reduced_to_safe_state(self):
value = json.dumps([
{"Service": "api", "State": "running", "Health": "healthy", "Publishers": "secret"},
{"Service": "worker", "State": "running", "Health": ""},
{"Service": "mongo", "State": "running", "Health": "healthy"},
]).encode()
self.assertEqual(monitor.parse_compose(value)["api"], {"state": "running", "health": "healthy"})
self.assertNotIn("Publishers", monitor.parse_compose(value)["api"])
def test_age_ignores_symlinks_and_unexpected_files(self):
with tempfile.TemporaryDirectory() as folder:
directory = Path(folder)
backup = directory / "guestops-20261001T021700Z.tar.gpg"
backup.write_bytes(b"fixture")
moment = dt.datetime(2026, 10, 1, 3, 17, tzinfo=dt.timezone.utc)
os.utime(backup, (moment.timestamp() - 3600, moment.timestamp() - 3600))
(directory / "secret.txt").write_text("ignored", encoding="utf-8")
self.assertEqual(monitor.age_seconds(directory, monitor.BACKUP_NAME, moment), 3600)
def test_build_status_contains_only_aggregate_health(self):
now = dt.datetime(2026, 10, 1, 12, tzinfo=dt.timezone.utc)
compose = json.dumps([
{"Service": name, "State": "running", "Health": "healthy"}
for name in ("api", "worker", "mongo")
]).encode()
usage = type("Usage", (), {"total": 1000, "used": 500, "free": 500})()
with tempfile.TemporaryDirectory() as folder, \
patch.object(monitor, "https_status", return_value={"ready": True, "certificateDaysRemaining": 60}), \
patch.object(monitor, "run", return_value=compose), \
patch.object(monitor, "worker_heartbeat_age", return_value=30), \
patch.object(monitor.shutil, "disk_usage", return_value=usage):
status, errors = monitor.build_status(Path(folder), Path(folder), "https://example.invalid", now)
self.assertEqual(errors, [])
self.assertEqual(status["workerHeartbeatAgeSeconds"], 30)
self.assertEqual(status["diskFreePercent"], 50)
self.assertNotIn("credentials", json.dumps(status).lower())
def test_failed_probes_write_categories_not_exception_details(self):
now = dt.datetime(2026, 10, 1, 12, tzinfo=dt.timezone.utc)
usage = type("Usage", (), {"total": 1000, "used": 500, "free": 500})()
with tempfile.TemporaryDirectory() as folder, \
patch.object(monitor, "https_status", side_effect=RuntimeError("secret value")), \
patch.object(monitor, "run", side_effect=RuntimeError("secret value")), \
patch.object(monitor, "worker_heartbeat_age", side_effect=RuntimeError("secret value")), \
patch.object(monitor.shutil, "disk_usage", return_value=usage):
status, errors = monitor.build_status(Path(folder), Path(folder), "https://example.invalid", now)
self.assertGreaterEqual(len(errors), 3)
self.assertNotIn("secret value", json.dumps(status))
def test_status_output_is_atomic_json(self):
with tempfile.TemporaryDirectory() as folder:
path = Path(folder) / "status.json"
monitor.write_status(path, {"schemaVersion": 1, "errors": []})
self.assertEqual(json.loads(path.read_text(encoding="utf-8"))["schemaVersion"], 1)
if __name__ == "__main__":
unittest.main()
-186
View File
@@ -1,186 +0,0 @@
import contextlib
import hashlib
import importlib.util
import io
import json
import os
from pathlib import Path
import tarfile
import tempfile
import unittest
from unittest.mock import patch
spec = importlib.util.spec_from_file_location("ops", Path(__file__).resolve().parents[1] / "deploy" / "ops.py")
ops = importlib.util.module_from_spec(spec)
spec.loader.exec_module(ops)
class ArchiveTests(unittest.TestCase):
def test_persistence_layout_resolves_shared_keys_and_database(self):
config = {
"services": {
"api": {"volumes": [{"type": "volume", "source": "app-keys", "target": "/var/lib/guestops/keys"}]},
"worker": {"volumes": [{"type": "volume", "source": "app-keys", "target": "/var/lib/guestops/keys"}]},
"mongo": {"volumes": [{"type": "volume", "source": "mongo-data", "target": "/data/db"}]},
},
"volumes": {
"app-keys": {"name": "guestops_app-keys"},
"mongo-data": {"name": "guestops_mongo-data"},
},
}
self.assertEqual(ops.persistence_layout(config), {"keys": "guestops_app-keys", "database": "guestops_mongo-data"})
def test_persistence_layout_rejects_anonymous_or_split_keys(self):
config = {
"services": {
"api": {"volumes": [{"type": "volume", "source": "api-keys", "target": "/var/lib/guestops/keys"}]},
"worker": {"volumes": [{"type": "volume", "source": "worker-keys", "target": "/var/lib/guestops/keys"}]},
"mongo": {"volumes": [{"type": "volume", "source": "mongo-data", "target": "/data/db"}]},
},
"volumes": {"api-keys": {}, "worker-keys": {}, "mongo-data": {}},
}
with self.assertRaisesRegex(RuntimeError, "key volumes differ"):
ops.persistence_layout(config)
config["services"]["worker"]["volumes"][0] = {"type": "volume", "target": "/var/lib/guestops/keys"}
with self.assertRaisesRegex(RuntimeError, "named persistent volume"):
ops.persistence_layout(config)
def test_persistence_drill_requires_explicit_restart_confirmation(self):
with self.assertRaisesRegex(RuntimeError, "confirm-restart"):
ops.persistence_drill(type("Args", (), {"confirm_restart": False})())
def test_persistence_drill_restarts_then_recreates_stateless_services(self):
compose_calls = []
inventory = json.dumps({"bytes": 1, "collections": {"hotels": {"count": 1, "indexes": []}}}).encode()
def compose(*args, **kwargs):
compose_calls.append(args)
return b"a" * 30 if args[-1] == "--backup-probe" else b""
def mongo(script):
return inventory if "storageSize" in script else b""
with patch.object(ops, "configuration", return_value={}), \
patch.object(ops, "persistence_layout", return_value={"keys": "keys", "database": "data"}), \
patch.object(ops, "volume_identity", side_effect=lambda name: {"name": name, "driver": "local", "scope": "local"}), \
patch.object(ops, "compose", side_effect=compose), \
patch.object(ops, "mongo", side_effect=mongo), \
patch.object(ops, "wait_for", side_effect=lambda action, message: action()), \
patch.object(ops, "readiness"):
ops.persistence_drill(type("Args", (), {"confirm_restart": True})())
self.assertIn(("restart", "-t", "150", "mongo"), compose_calls)
self.assertIn(("restart", "-t", "150", "api", "worker"), compose_calls)
self.assertIn(("up", "-d", "--no-build", "--force-recreate", "api", "worker"), compose_calls)
self.assertTrue(any("--verify-backup-probe" in call for call in compose_calls))
def test_empty_provider_templates_are_not_secret_configuration(self):
for section, target in (("Pms", "/run/guestops/pms.json"), ("Payments", "/run/guestops/payments.json")):
self.assertFalse(ops.provider_configured({section: {"Hotels": {}}}, target))
self.assertTrue(ops.provider_configured({section: {"Hotels": {"fixture": {"Key": "fixture"}}}}, target))
self.assertTrue(ops.provider_configured({section: {"Unknown": "fixture"}}, target))
def bundle(self, root, change=None):
files = {name: b"fixture backup data" for name in ops.FILES - {"manifest.json"}}
files["manifest.json"] = json.dumps({"format": 1, "sha256": {name: hashlib.sha256(data).hexdigest() for name, data in files.items()}}).encode()
target = root / "bundle.tar"
with tarfile.open(target, "w") as archive:
for name, data in files.items():
member = tarfile.TarInfo(name); member.size = len(data)
if change:
change(member)
archive.addfile(member, io.BytesIO(data) if member.isfile() else None)
return target
def test_checked_archive_roundtrip(self):
with tempfile.TemporaryDirectory() as temp:
root = Path(temp); dest = root / "dest"; dest.mkdir()
self.assertEqual(ops.unpack(self.bundle(root), dest)["format"], 1)
def test_path_escape_rejected(self):
with tempfile.TemporaryDirectory() as temp:
root = Path(temp); dest = root / "dest"; dest.mkdir()
def corrupt(member):
if member.name == "configuration.json": member.name = "../outside"
with self.assertRaisesRegex(RuntimeError, "Unexpected backup members"):
ops.unpack(self.bundle(root, corrupt), dest)
self.assertFalse((root / "outside").exists())
def test_symlink_rejected(self):
with tempfile.TemporaryDirectory() as temp:
root = Path(temp); dest = root / "dest"; dest.mkdir()
def corrupt(member):
if member.name == "configuration.json": member.type = tarfile.SYMTYPE; member.linkname = "/etc/passwd"; member.size = 0
with self.assertRaisesRegex(RuntimeError, "Invalid or oversized"):
ops.unpack(self.bundle(root, corrupt), dest)
def test_checksum_mismatch_rejected(self):
with tempfile.TemporaryDirectory() as temp:
root = Path(temp); dest = root / "dest"; dest.mkdir()
with patch.object(ops, "digest", return_value="changed"):
with self.assertRaisesRegex(RuntimeError, "checksum"):
ops.unpack(self.bundle(root), dest)
def test_backup_requires_explicit_maintenance(self):
with self.assertRaisesRegex(RuntimeError, "confirm-maintenance"):
ops.backup(type("Args", (), {"confirm_maintenance": False})())
def test_scheduled_backup_requires_explicit_maintenance(self):
with self.assertRaisesRegex(RuntimeError, "confirm-maintenance"):
ops.scheduled_backup(type("Args", (), {"confirm_maintenance": False})())
@unittest.skipUnless(os.name == "posix", "Linux file permission semantics")
def test_scheduled_backup_uses_private_external_directory_and_environment(self):
with tempfile.TemporaryDirectory() as parent:
directory = Path(parent) / "backups"
directory.mkdir(mode=0o700)
captured = []
with patch.dict(os.environ, {"BACKUP_RECIPIENT": "A" * 40, "BACKUP_DIRECTORY": str(directory)}), \
patch.object(ops, "ROOT", Path(parent) / "checkout"), \
patch.object(ops, "backup", side_effect=lambda args: captured.append(args)), \
patch.object(ops.time, "strftime", return_value="20260929T020000Z"):
ops.scheduled_backup(type("Args", (), {"confirm_maintenance": True})())
self.assertEqual(captured[0].recipient, "A" * 40)
self.assertEqual(Path(captured[0].output), directory / "guestops-20260929T020000Z.tar.gpg")
self.assertTrue(captured[0].confirm_maintenance)
@unittest.skipUnless(os.name == "posix", "Linux file permission semantics")
def test_scheduled_backup_rejects_checkout_directory(self):
with tempfile.TemporaryDirectory() as parent:
checkout = Path(parent) / "checkout"
directory = checkout / "backups"
directory.mkdir(parents=True, mode=0o700)
with patch.dict(os.environ, {"BACKUP_RECIPIENT": "A" * 40, "BACKUP_DIRECTORY": str(directory)}), \
patch.object(ops, "ROOT", checkout):
with self.assertRaisesRegex(RuntimeError, "outside the application checkout"):
ops.scheduled_backup(type("Args", (), {"confirm_maintenance": True})())
@unittest.skipUnless(os.name == "posix", "Linux file permission semantics")
def test_dump_failure_restarts_services_and_ttl(self):
with tempfile.TemporaryDirectory() as temp:
calls = []
def compose(*args, **kwargs):
calls.append(args)
if args[0] == "ps": return b"a" * 64
if "sh" in args: raise RuntimeError("Simulated dump failure")
return b""
def mongo(script):
calls.append((script,))
if "getParameter" in script: return b"true"
if "storageSize" in script: return b'{"bytes":1,"collections":{}}'
return b""
def run(args, **kwargs):
return b'[{"Image":"sha256:fixture"}]' if "inspect" in args else b""
args = type("Args", (), {"confirm_maintenance": True, "recipient": "A" * 40, "output": str(Path(temp) / "backup.gpg")})()
with patch.object(ops, "configuration", return_value={}), patch.object(ops, "run", side_effect=run), patch.object(ops, "compose", side_effect=compose), patch.object(ops, "mongo", side_effect=mongo), patch.object(ops, "maintenance_lock", return_value=contextlib.nullcontext()):
with self.assertRaisesRegex(RuntimeError, "Simulated dump failure"):
ops.backup(args)
self.assertIn(("start", "api", "worker"), calls)
self.assertTrue(any("ttlMonitorEnabled:true" in call[0] for call in calls))
self.assertFalse(Path(args.output).exists())
if __name__ == "__main__":
unittest.main()
+7 -10
View File
@@ -1,4 +1,3 @@
import hashlib
import importlib.util
import json
from pathlib import Path
@@ -44,20 +43,18 @@ class PackageSourceTests(unittest.TestCase):
run(repository, "commit", "-m", "fixture")
return repository, run(repository, "rev-parse", "HEAD")
def test_packages_only_the_selected_commit_and_records_identity(self):
def test_packages_only_the_selected_commit_with_version_name(self):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
repository, commit = self.repository(root)
(repository / "application.txt").write_text("uncommitted change\n", encoding="utf-8")
archive, record_path, record = package_source.build_package(repository, commit, root / "output")
archive, details = package_source.build_package(repository, commit, root / "output")
self.assertEqual(record["commit"], commit)
self.assertEqual(record["version"], "1.2.3")
self.assertEqual(record["artifact"]["sha256"], hashlib.sha256(archive.read_bytes()).hexdigest())
self.assertEqual(json.loads(record_path.read_text(encoding="utf-8")), record)
self.assertEqual(archive.name, "guestops_1.2.3.tar.gz")
self.assertEqual(details, {"commit": commit, "version": "1.2.3"})
with tarfile.open(archive, "r:gz") as package:
member = package.extractfile("GuestOps-1.2.3/application.txt")
member = package.extractfile("guestops_1.2.3/application.txt")
self.assertIsNotNone(member)
self.assertEqual(member.read().decode("utf-8").strip(), "committed application")
@@ -65,8 +62,8 @@ class PackageSourceTests(unittest.TestCase):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
repository, commit = self.repository(root)
first, _, _ = package_source.build_package(repository, commit, root / "first")
second, _, _ = package_source.build_package(repository, commit, root / "second")
first, _ = package_source.build_package(repository, commit, root / "first")
second, _ = package_source.build_package(repository, commit, root / "second")
self.assertEqual(first.read_bytes(), second.read_bytes())
def test_rejects_mismatched_versions_and_existing_output(self):
+1 -1
View File
@@ -13,7 +13,7 @@ def valid_record():
return {
"schemaVersion": 1, "system": "guestops-supervised-pilot", "targetGate": "B",
"releaseCommit": "a" * 40, "releaseRecordSha256": "b" * 64,
"environment": "https://sandbox-guestops.futuresens.co.uk", "hotelLabel": "pilot-hotel-a",
"environment": "https://guestops-sandbox.futuresens.co.uk", "hotelLabel": "pilot-hotel-a",
"hotelCount": 1, "plannedBusinessDays": 5,
"owners": {"hotelOwner": "Hotel owner", "technicalOwner": "Technical owner", "rollbackDecisionMaker": "Technical owner"},
"startedOn": days[0], "endedOn": days[-1],
-82
View File
@@ -1,82 +0,0 @@
import hashlib
import json
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
class ReleaseRecordTests(unittest.TestCase):
def test_writes_versions_checksum_and_immutable_image_ids(self):
with tempfile.TemporaryDirectory() as directory:
artifact = Path(directory) / "GuestOps-0.2.1.tar.gz"
output = Path(directory) / "release-record.json"
artifact.write_bytes(b"reviewed image archive")
subprocess.run(
[
sys.executable,
str(ROOT / "deploy" / "release_record.py"),
"--artifact",
str(artifact),
"--commit",
"a" * 40,
"--api-image",
"guestops-api:" + "a" * 40,
"--api-id",
"sha256:api",
"--worker-image",
"guestops-worker:" + "a" * 40,
"--worker-id",
"sha256:worker",
"--output",
str(output),
],
check=True,
)
record = json.loads(output.read_text(encoding="utf-8"))
self.assertEqual(record["version"], "0.2.1")
self.assertEqual(record["commit"], "a" * 40)
self.assertEqual(record["images"]["api"]["id"], "sha256:api")
self.assertEqual(
record["artifact"]["sha256"],
hashlib.sha256(artifact.read_bytes()).hexdigest(),
)
def test_rejects_abbreviated_commit(self):
with tempfile.TemporaryDirectory() as directory:
artifact = Path(directory) / "images.tar.gz"
artifact.write_bytes(b"fixture")
result = subprocess.run(
[
sys.executable,
str(ROOT / "deploy" / "release_record.py"),
"--artifact",
str(artifact),
"--commit",
"abc123",
"--api-image",
"api:test",
"--api-id",
"sha256:api",
"--worker-image",
"worker:test",
"--worker-id",
"sha256:worker",
"--output",
str(Path(directory) / "record.json"),
],
capture_output=True,
text=True,
)
self.assertNotEqual(result.returncode, 0)
self.assertIn("full 40-character Git SHA", result.stderr)
if __name__ == "__main__":
unittest.main()
-87
View File
@@ -1,87 +0,0 @@
import hashlib
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location("verify_release", ROOT / "deploy" / "verify_release.py")
verify_release = importlib.util.module_from_spec(spec)
spec.loader.exec_module(verify_release)
COMMIT = "a" * 40
API_ID = "sha256:" + "b" * 64
WORKER_ID = "sha256:" + "c" * 64
class VerifyReleaseTests(unittest.TestCase):
def fixture(self, directory: str):
root = Path(directory)
archive = root / "GuestOps-0.2.1.tar.gz"
record = root / "release-record.json"
archive.write_bytes(b"reviewed image archive")
release = {
"schemaVersion": 1,
"version": "0.2.1",
"commit": COMMIT,
"artifact": {
"name": archive.name,
"size": archive.stat().st_size,
"sha256": hashlib.sha256(archive.read_bytes()).hexdigest(),
},
"images": {
"api": {"reference": f"guestops-api:{COMMIT}", "id": API_ID},
"worker": {"reference": f"guestops-worker:{COMMIT}", "id": WORKER_ID},
},
}
record.write_text(json.dumps(release), encoding="utf-8")
return archive, record, release
def test_verifies_candidate_archive_record_and_record_checksum(self):
with tempfile.TemporaryDirectory() as directory:
archive, record, _ = self.fixture(directory)
result = verify_release.validate(archive, record, COMMIT, "0.2.1")
self.assertTrue(result["verified"])
self.assertEqual(result["archive"]["sha256"], hashlib.sha256(archive.read_bytes()).hexdigest())
self.assertEqual(result["releaseRecord"]["sha256"], hashlib.sha256(record.read_bytes()).hexdigest())
self.assertFalse(result["loadedImageIdsVerified"])
def test_rejects_changed_archive(self):
with tempfile.TemporaryDirectory() as directory:
archive, record, _ = self.fixture(directory)
archive.write_bytes(b"changed")
with self.assertRaisesRegex(ValueError, "size does not match"):
verify_release.validate(archive, record, COMMIT, "0.2.1")
def test_rejects_wrong_commit_version_reference_and_mutable_id(self):
cases = [
(lambda value: value.update(commit="d" * 40), "commit does not match"),
(lambda value: value.update(version="0.3.0"), "version does not match"),
(lambda value: value["images"]["api"].update(reference="guestops-api:latest"), "full candidate SHA"),
(lambda value: value["images"]["worker"].update(id="worker-image"), "immutable SHA-256"),
]
for mutate, message in cases:
with self.subTest(message=message), tempfile.TemporaryDirectory() as directory:
archive, record, release = self.fixture(directory)
mutate(release)
record.write_text(json.dumps(release), encoding="utf-8")
with self.assertRaisesRegex(ValueError, message):
verify_release.validate(archive, record, COMMIT, "0.2.1")
def test_loaded_image_ids_must_match(self):
with tempfile.TemporaryDirectory() as directory:
archive, record, _ = self.fixture(directory)
with patch.object(verify_release, "loaded_image_id", side_effect=[API_ID, WORKER_ID]):
result = verify_release.validate(archive, record, COMMIT, "0.2.1", True)
self.assertTrue(result["loadedImageIdsVerified"])
with patch.object(verify_release, "loaded_image_id", return_value="sha256:" + "d" * 64):
with self.assertRaisesRegex(ValueError, "Loaded api image ID"):
verify_release.validate(archive, record, COMMIT, "0.2.1", True)
if __name__ == "__main__":
unittest.main()
-72
View File
@@ -1,72 +0,0 @@
import hashlib
import importlib.util
import json
from pathlib import Path
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location(
"verify_source_package", ROOT / "deploy" / "verify_source_package.py"
)
verify_source_package = importlib.util.module_from_spec(spec)
spec.loader.exec_module(verify_source_package)
COMMIT = "a" * 40
VERSION = "0.2.1"
class VerifySourcePackageTests(unittest.TestCase):
def fixture(self, directory: str):
root = Path(directory)
archive = root / "GuestOps-0.2.1-aaaaaaaaaaaa.tar.gz"
record = root / "GuestOps-0.2.1-aaaaaaaaaaaa.source.json"
archive.write_bytes(b"committed source package")
payload = {
"artifact": {
"name": archive.name,
"sha256": hashlib.sha256(archive.read_bytes()).hexdigest(),
"size": archive.stat().st_size,
},
"commit": COMMIT,
"schemaVersion": 1,
"version": VERSION,
}
record.write_text(json.dumps(payload), encoding="utf-8")
return archive, record, payload
def test_verifies_archive_record_and_expected_identity(self):
with tempfile.TemporaryDirectory() as directory:
archive, record, _ = self.fixture(directory)
result = verify_source_package.validate(archive, record, COMMIT, VERSION)
self.assertTrue(result["verified"])
self.assertEqual(result["commit"], COMMIT)
self.assertEqual(result["artifact"]["sha256"], hashlib.sha256(archive.read_bytes()).hexdigest())
self.assertEqual(result["sourceRecord"]["sha256"], hashlib.sha256(record.read_bytes()).hexdigest())
def test_rejects_changed_archive(self):
with tempfile.TemporaryDirectory() as directory:
archive, record, _ = self.fixture(directory)
archive.write_bytes(b"changed source package")
with self.assertRaisesRegex(ValueError, "size does not match"):
verify_source_package.validate(archive, record, COMMIT, VERSION)
def test_rejects_wrong_commit_version_and_filename(self):
cases = [
(lambda value: value.update(commit="b" * 40), "commit does not match"),
(lambda value: value.update(version="0.3.0"), "version does not match"),
(lambda value: value["artifact"].update(name="other.tar.gz"), "filename does not match"),
]
for mutate, message in cases:
with self.subTest(message=message), tempfile.TemporaryDirectory() as directory:
archive, record, payload = self.fixture(directory)
mutate(payload)
record.write_text(json.dumps(payload), encoding="utf-8")
with self.assertRaisesRegex(ValueError, message):
verify_source_package.validate(archive, record, COMMIT, VERSION)
if __name__ == "__main__":
unittest.main()