import json import pathlib import subprocess import sys import tempfile import unittest ROOT = pathlib.Path(__file__).resolve().parents[1] SCRIPT = ROOT / 'installer.py' class InstallerTest(unittest.TestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() self.addCleanup(self.tmp.cleanup) self.home = pathlib.Path(self.tmp.name) / 'home' self.home.mkdir() (self.home / 'config.yaml').write_text('untouched: true\n') (self.home / 'cron').mkdir() (self.home / 'cron/jobs.json').write_text('{"jobs":[]}') def run_cli(self, action, *extra): return subprocess.run([sys.executable, str(SCRIPT), action, '--target-home', str(self.home), *extra], capture_output=True, text=True) def test_install_is_idempotent_and_verify_is_read_only(self): result = self.run_cli('install') self.assertEqual(result.returncode, 0, result.stderr) first = {str(p.relative_to(self.home)): (p.read_bytes(), p.stat().st_mtime_ns) for p in self.home.rglob('*') if p.is_file()} self.assertEqual(self.run_cli('install').returncode, 0) self.assertEqual(self.run_cli('verify').returncode, 0) second = {str(p.relative_to(self.home)): (p.read_bytes(), p.stat().st_mtime_ns) for p in self.home.rglob('*') if p.is_file()} self.assertEqual(first, second) self.assertEqual((self.home / 'config.yaml').read_text(), 'untouched: true\n') self.assertEqual((self.home / 'cron/jobs.json').read_text(), '{"jobs":[]}') skills = list((self.home / 'profiles/pmo/skills').rglob('SKILL.md')) self.assertTrue(skills) status = json.loads((self.home / 'editorial-v4/status.json').read_text()) self.assertEqual(status['stage'], 'blocked') self.assertFalse(status['cron_activation_allowed']) def test_verified_previous_payload_can_upgrade_without_losing_rollback(self): import hashlib path = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path.parent.mkdir(parents=True) path.write_text('original owned content') path.chmod(0o600) self.assertEqual(self.run_cli('install').returncode, 0) journal = self.home / 'editorial-v4/.installer/transaction.json' state = json.loads(journal.read_text()) original_before = state['before'] # CI1285: live payload exactly matches the previous journal, while # the incoming reviewed package changes the PMO skill only. path.write_text('previous reviewed PMO skill') state['installed'][str(path.relative_to(self.home))] = hashlib.sha256(path.read_bytes()).hexdigest() journal.write_text(json.dumps(state)) result = self.run_cli('install') self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual(self.run_cli('verify').returncode, 0) self.assertEqual(json.loads(journal.read_text())['before'], original_before) snapshot = {str(p.relative_to(self.home)): (p.read_bytes(), p.stat().st_mtime_ns, p.stat().st_uid, p.stat().st_gid, p.stat().st_mode) for p in self.home.rglob('*') if p.is_file()} self.assertEqual(self.run_cli('install').returncode, 0) self.assertEqual(snapshot, {str(p.relative_to(self.home)): (p.read_bytes(), p.stat().st_mtime_ns, p.stat().st_uid, p.stat().st_gid, p.stat().st_mode) for p in self.home.rglob('*') if p.is_file()}) self.assertEqual(self.run_cli('rollback').returncode, 0) self.assertEqual(path.read_text(), 'original owned content') self.assertEqual(path.stat().st_mode & 0o777, 0o600) def test_failed_upgrade_restores_previous_payload_and_exact_journal(self): import hashlib import importlib.util from unittest.mock import patch spec = importlib.util.spec_from_file_location('installer', SCRIPT) installer = importlib.util.module_from_spec(spec) spec.loader.exec_module(installer) installer.execute('install', self.home) path = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path.write_text('previous reviewed version') journal = self.home / 'editorial-v4/.installer/transaction.json' state = json.loads(journal.read_text()) state['installed'][str(path.relative_to(self.home))] = hashlib.sha256(path.read_bytes()).hexdigest() journal.write_text(json.dumps(state)) original = journal.read_bytes() real_atomic = installer.atomic failed = False def fail_once(destination, data): nonlocal failed if destination == path and not failed: failed = True raise OSError('injected write failure') return real_atomic(destination, data) with patch.object(installer, 'atomic', side_effect=fail_once): with self.assertRaisesRegex(OSError, 'injected write failure'): installer.execute('install', self.home) self.assertEqual(path.read_text(), 'previous reviewed version') self.assertTrue(journal.exists(), 'rollback history must survive a failed upgrade') self.assertEqual(journal.read_bytes(), original) def test_upgrade_refuses_drift_partial_and_invalid_journal_without_writes(self): self.assertEqual(self.run_cli('install').returncode, 0) journal = self.home / 'editorial-v4/.installer/transaction.json' original = journal.read_bytes() path = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' payload = path.read_bytes() for failure in ('drift', 'missing', 'allowlist', 'rollback_data'): with self.subTest(failure=failure): path.write_bytes(payload) journal.write_bytes(original) state = json.loads(original) if failure == 'drift': path.write_text('external change') elif failure == 'missing': path.unlink() elif failure == 'allowlist': path.write_text('previous version') state['installed'].pop('editorial-v4/status.json') journal.write_text(json.dumps(state)) else: path.write_text('previous version') state['before']['editorial-v4/status.json'] = {'data': '!!!!', 'mode': 420} journal.write_text(json.dumps(state)) before = {str(p.relative_to(self.home)): (p.read_bytes(), p.stat().st_mtime_ns) for p in self.home.rglob('*') if p.is_file()} self.assertNotEqual(self.run_cli('install').returncode, 0) self.assertEqual(before, {str(p.relative_to(self.home)): (p.read_bytes(), p.stat().st_mtime_ns) for p in self.home.rglob('*') if p.is_file()}) def test_rollback_restores_previous_files_and_modes(self): path = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path.parent.mkdir(parents=True) path.write_text('previous owned version') path.chmod(0o600) self.assertEqual(self.run_cli('install').returncode, 0) self.assertEqual(self.run_cli('rollback').returncode, 0) self.assertEqual(path.read_text(), 'previous owned version') self.assertEqual(path.stat().st_mode & 0o777, 0o600) self.assertFalse((self.home / 'editorial-v4/status.json').exists()) self.assertEqual(self.run_cli('rollback').returncode, 0) def test_refuses_symlink_escape_before_copy(self): outside = pathlib.Path(self.tmp.name) / 'outside' outside.mkdir() (self.home / 'profiles').symlink_to(outside, target_is_directory=True) self.assertNotEqual(self.run_cli('install').returncode, 0) self.assertEqual(list(outside.iterdir()), []) self.assertFalse((self.home / 'editorial-v4/status.json').exists()) def test_verify_detects_drift_and_rollback_refuses_external_edits(self): self.assertEqual(self.run_cli('install').returncode, 0) path = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path.write_text('external change') self.assertNotEqual(self.run_cli('verify').returncode, 0) self.assertNotEqual(self.run_cli('rollback').returncode, 0) self.assertEqual(path.read_text(), 'external change') def test_interrupted_upgrade_multi_file_safe_recovery_and_install(self): import hashlib path_pmo = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path_pmo.parent.mkdir(parents=True, exist_ok=True) path_pmo.write_text('original owned baseline') path_pmo.chmod(0o600) self.assertEqual(self.run_cli('install').returncode, 0) # Verified previous installed state modifying status.json and pmo SKILL.md path_status = self.home / 'editorial-v4/status.json' v1_status = '{"stage": "blocked", "cron_activation_allowed": false, "v": "1"}' v1_pmo = 'reviewed pmo v1 content' path_status.write_text(v1_status) path_pmo.write_text(v1_pmo) journal = self.home / 'editorial-v4/.installer/transaction.json' state = json.loads(journal.read_text()) rel_status = str(path_status.relative_to(self.home)) rel_pmo = str(path_pmo.relative_to(self.home)) state['installed'][rel_status] = hashlib.sha256(v1_status.encode()).hexdigest() state['installed'][rel_pmo] = hashlib.sha256(v1_pmo.encode()).hexdigest() journal.write_text(json.dumps(state)) # Crash midway during install: status.json is written, but process dies before pmo SKILL.md crash_code = f""" import os, sys, importlib.util, pathlib spec = importlib.util.spec_from_file_location('installer', '{SCRIPT}') m = importlib.util.module_from_spec(spec) spec.loader.exec_module(m) real_atomic = m.atomic def crash_atomic(p, data): res = real_atomic(p, data) if str(p).endswith('editorial-v4/status.json'): os._exit(42) return res m.atomic = crash_atomic m.execute('install', pathlib.Path('{self.home}')) """ proc = subprocess.run([sys.executable, '-c', crash_code]) self.assertEqual(proc.returncode, 42) # Confirm mixed state on disk: status.json updated to incoming, pmo SKILL.md still v1 self.assertNotEqual(path_status.read_text(), v1_status) self.assertEqual(path_pmo.read_text(), v1_pmo) # Rerun install: must safely recover from interrupted transaction and finish upgrade res = self.run_cli('install') self.assertEqual(res.returncode, 0, f"install recovery failed: {res.stderr}") self.assertEqual(self.run_cli('verify').returncode, 0) # Rollback should still restore original owned baseline self.assertEqual(self.run_cli('rollback').returncode, 0) self.assertEqual(path_pmo.read_text(), 'original owned baseline') self.assertEqual(path_pmo.stat().st_mode & 0o777, 0o600) def test_interrupted_upgrade_multi_file_rollback_restores_original(self): import hashlib path_pmo = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path_pmo.parent.mkdir(parents=True, exist_ok=True) path_pmo.write_text('original owned baseline') path_pmo.chmod(0o600) self.assertEqual(self.run_cli('install').returncode, 0) path_status = self.home / 'editorial-v4/status.json' v1_status = '{"stage": "blocked", "cron_activation_allowed": false, "v": "1"}' v1_pmo = 'reviewed pmo v1 content' path_status.write_text(v1_status) path_pmo.write_text(v1_pmo) journal = self.home / 'editorial-v4/.installer/transaction.json' state = json.loads(journal.read_text()) rel_status = str(path_status.relative_to(self.home)) rel_pmo = str(path_pmo.relative_to(self.home)) state['installed'][rel_status] = hashlib.sha256(v1_status.encode()).hexdigest() state['installed'][rel_pmo] = hashlib.sha256(v1_pmo.encode()).hexdigest() journal.write_text(json.dumps(state)) crash_code = f""" import os, sys, importlib.util, pathlib spec = importlib.util.spec_from_file_location('installer', '{SCRIPT}') m = importlib.util.module_from_spec(spec) spec.loader.exec_module(m) real_atomic = m.atomic def crash_atomic(p, data): res = real_atomic(p, data) if str(p).endswith('editorial-v4/status.json'): os._exit(42) return res m.atomic = crash_atomic m.execute('install', pathlib.Path('{self.home}')) """ proc = subprocess.run([sys.executable, '-c', crash_code]) self.assertEqual(proc.returncode, 42) # Rollback on interrupted state must safely recover and restore original owned baseline res = self.run_cli('rollback') self.assertEqual(res.returncode, 0, f"rollback recovery failed: {res.stderr}") self.assertEqual(path_pmo.read_text(), 'original owned baseline') self.assertEqual(path_pmo.stat().st_mode & 0o777, 0o600) self.assertFalse(journal.exists()) def test_interrupted_upgrade_rejects_external_drift(self): import hashlib self.assertEqual(self.run_cli('install').returncode, 0) path_status = self.home / 'editorial-v4/status.json' path_pmo = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' v1_status = '{"stage": "blocked", "cron_activation_allowed": false, "v": "1"}' v1_pmo = 'reviewed pmo v1 content' path_status.write_text(v1_status) path_pmo.write_text(v1_pmo) journal = self.home / 'editorial-v4/.installer/transaction.json' state = json.loads(journal.read_text()) rel_status = str(path_status.relative_to(self.home)) rel_pmo = str(path_pmo.relative_to(self.home)) state['installed'][rel_status] = hashlib.sha256(v1_status.encode()).hexdigest() state['installed'][rel_pmo] = hashlib.sha256(v1_pmo.encode()).hexdigest() journal.write_text(json.dumps(state)) crash_code = f""" import os, sys, importlib.util, pathlib spec = importlib.util.spec_from_file_location('installer', '{SCRIPT}') m = importlib.util.module_from_spec(spec) spec.loader.exec_module(m) real_atomic = m.atomic def crash_atomic(p, data): res = real_atomic(p, data) if str(p).endswith('editorial-v4/status.json'): os._exit(42) return res m.atomic = crash_atomic m.execute('install', pathlib.Path('{self.home}')) """ proc = subprocess.run([sys.executable, '-c', crash_code]) self.assertEqual(proc.returncode, 42) # External drift on path_pmo path_pmo.write_text('tampered external edit') res_install = self.run_cli('install') self.assertNotEqual(res_install.returncode, 0) self.assertEqual(path_pmo.read_text(), 'tampered external edit') res_rollback = self.run_cli('rollback') self.assertNotEqual(res_rollback.returncode, 0) self.assertEqual(path_pmo.read_text(), 'tampered external edit') def test_failed_upgrade_restoration_failure_preserves_journal(self): import hashlib, importlib.util from unittest.mock import patch spec = importlib.util.spec_from_file_location('installer', SCRIPT) installer = importlib.util.module_from_spec(spec) spec.loader.exec_module(installer) installer.execute('install', self.home) path = self.home / 'profiles/pmo/skills/canina-editorial-v4/SKILL.md' path.write_text('previous reviewed version') journal = self.home / 'editorial-v4/.installer/transaction.json' state = json.loads(journal.read_text()) rel = str(path.relative_to(self.home)) state['installed'][rel] = hashlib.sha256(path.read_bytes()).hexdigest() journal.write_text(json.dumps(state)) real_atomic = installer.atomic fail_target = path def fail_pmo(dest, data): if dest == fail_target: raise OSError('injected write failure on pmo') return real_atomic(dest, data) def fail_restore(paths, before): raise OSError('injected restoration failure') with patch.object(installer, 'atomic', side_effect=fail_pmo): with patch.object(installer, 'restore', side_effect=fail_restore): with self.assertRaisesRegex(OSError, 'injected write failure on pmo'): installer.execute('install', self.home) # Journal must not be lost or unlinked, and must retain previous rollback metadata self.assertTrue(journal.exists()) jdata = json.loads(journal.read_text()) self.assertIn('before', jdata) # Previous installed metadata must be preserved prev = jdata.get('previous_installed') or jdata.get('installed') self.assertEqual(prev[rel], hashlib.sha256(b'previous reviewed version').hexdigest()) if __name__ == '__main__': unittest.main()