GuestOps asible playbook
This commit is contained in:
@@ -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.")
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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",
|
||||
|
||||
@@ -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",
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
@@ -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",
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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],
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user