Files
quality_analyse/scripts/test_retention_recovery.py

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()