350 lines
17 KiB
Python
350 lines
17 KiB
Python
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()
|