import json import os from pathlib import Path import shutil import sys import tempfile import time import unittest from unittest.mock import patch ROOT = Path(__file__).resolve().parents[1] sys.path[:0] = [str(ROOT / 'scripts'), str(ROOT / 'deploy/macos')] import backup import backup_retention as br import backup_verifier import operations import retention from test_retention import good_backup class CandidateRecoveryTests(unittest.TestCase): def setUp(self): self.temporary = tempfile.TemporaryDirectory(); self.root = Path(self.temporary.name).resolve() def tearDown(self): self.temporary.cleanup() def candidate(self, suffix='22222222', dead=True, age=3 * 86400): folder = self.root / 'output/backups' / ('20261108T010000Z-' + suffix) folder.mkdir(parents=True); (folder / 'database.sql.gz').write_bytes(b'partial dump') br.register_candidate(folder, self.root) owner = json.loads((folder / '.owner.json').read_text()); owner['createdAt'] -= age if dead: owner.update({'ownerPid': 2000000000, 'ownerCreated': 1.0}) br.atomic(folder / '.owner.json', owner); os.utime(folder, (time.time() - age,) * 2) return folder def test_expired_dead_candidate_is_cleaned_without_a_new_backup(self): current = good_backup(self.root, '11111111'); br.rotate(self.root, current) orphan = self.candidate() result = br.clean_incomplete(self.root) self.assertEqual(result['incompleteBackupsRemoved'], 1) self.assertGreater(result['incompleteBackupBytesRemoved'], 0) self.assertFalse(orphan.exists()); self.assertEqual(br.latest(self.root)[0], current) def test_live_parent_live_child_pending_and_unknown_records_are_preserved(self): parent = self.candidate('11111111', dead=False) child = self.candidate('22222222'); br.candidate_child(parent, os.getpid()) value = json.loads((parent / '.owner.json').read_text()) child_owner = json.loads((child / '.owner.json').read_text()); child_owner['children'] = value['children'] br.atomic(child / '.owner.json', child_owner); os.utime(child, (time.time() - 3 * 86400,) * 2) pending = self.candidate('33333333'); owner = json.loads((pending / '.owner.json').read_text()) owner['childPending'] = True; br.atomic(pending / '.owner.json', owner); os.utime(pending, (time.time() - 3 * 86400,) * 2) unknown = self.candidate('44444444'); owner = json.loads((unknown / '.owner.json').read_text()) owner.pop('ownerCreated'); br.atomic(unknown / '.owner.json', owner); os.utime(unknown, (time.time() - 3 * 86400,) * 2) result = br.clean_incomplete(self.root) self.assertEqual(result['incompleteBackupsRemoved'], 0) self.assertGreaterEqual(result['incompleteBackupsDeferred'], 3) for folder in (parent, child, pending, unknown): self.assertTrue(folder.exists()) def test_latest_pointer_valid_candidate_fresh_and_symlink_contents_are_protected(self): pointed = self.candidate('11111111'); br.atomic(self.root / '.runtime/retention/latest.json', {'id': pointed.name}) valid = good_backup(self.root, '55555555') fresh = self.candidate('22222222', age=10) linked = self.candidate('33333333'); outside = self.root / 'business.xlsx'; outside.write_bytes(b'keep') (linked / 'link').symlink_to(outside) old = time.time() - 3 * 86400; os.utime(linked, (old, old)) result = br.clean_incomplete(self.root) self.assertEqual(result['incompleteBackupsRemoved'], 0) for p in (pointed, valid, fresh, linked, outside): self.assertTrue(p.exists()) def test_monitor_cleanup_precedes_database_access(self): orphan = self.candidate() with patch.object(retention, 'Database', side_effect=RuntimeError('Database unavailable')): with self.assertRaises(RuntimeError): operations.janitor(self.root, self.root / 'support', operations.DEFAULTS) self.assertFalse(orphan.exists()) def test_low_disk_recovery_removes_orphan_before_deferring_new_backup(self): current = good_backup(self.root, '11111111'); br.rotate(self.root, current); orphan = self.candidate() class Reply: def __enter__(self): return self def __exit__(self, *_): return False def read(self, *_): return b'{"status":"UP"}' class Opener: def open(self, *_args, **_kwargs): return Reply() class Database: def __init__(self, root): self.root = root; self.name = 'synthetic'; self.conn = self def close(self): pass def clean_owned_scratch(self, *_): return 0 def current(self): return 'current' def busy(self): return False def rows(self, *_): return [{'size': 1}] with patch.object(retention.urllib.request, 'build_opener', return_value=Opener()), \ patch.object(retention, 'Database', Database), patch.object(backup_verifier, 'clean_abandoned', return_value=0), \ patch.object(retention.shutil, 'disk_usage', return_value=shutil._ntuple_diskusage(100, 99, 1)), \ patch.object(backup, 'create') as create: with self.assertRaises(retention.Busy): retention.run(self.root) self.assertFalse(orphan.exists()); self.assertFalse(create.called) self.assertEqual(br.latest(self.root)[0], current) def test_unreadable_process_identity_defers_cleanup(self): import psutil orphan = self.candidate() with patch.object(psutil, 'Process', side_effect=psutil.AccessDenied()): result = br.clean_incomplete(self.root) self.assertEqual(result['incompleteBackupsRemoved'], 0); self.assertTrue(orphan.exists()) if __name__ == '__main__': unittest.main()