107 lines
5.7 KiB
Python
107 lines
5.7 KiB
Python
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()
|