import importlib.util import json import os from pathlib import Path import sys import tempfile import time import unittest from unittest.mock import Mock, patch ROOT = Path(__file__).resolve().parents[2] sys.path[:0] = [str(ROOT / 'scripts'), str(ROOT / 'deploy/macos')] def module(name, path): spec = importlib.util.spec_from_file_location(name, path) result = importlib.util.module_from_spec(spec); spec.loader.exec_module(result) return result app = module('container_app', Path(__file__).with_name('app.py')) manage = module('container_manage', Path(__file__).with_name('manage.py')) import backup import backup_retention as br class ContainerOperationsTests(unittest.TestCase): def test_database_unavailable_does_not_block_expired_candidate_recovery(self): worker = module('container_worker', ROOT / 'deploy/docker/worker.py') with tempfile.TemporaryDirectory() as directory: root=Path(directory).resolve();folder=root/'output/backups/20261108T010000Z-12345678';folder.mkdir(parents=True) (folder/'database.sql.gz').write_bytes(b'interrupted dump');br.register_candidate(folder,root) value=json.loads((folder/'.owner.json').read_text());value.update({'createdAt':time.time()-3*86400,'ownerPid':2000000000,'ownerCreated':1.0}) br.atomic(folder/'.owner.json',value);os.utime(folder,(time.time()-3*86400,)*2) br.atomic(root/'.runtime/local-config.json',{'mysqlDatabase':'quality_current'}) br.atomic(root/'.runtime/operations/policy.json',worker.operations.DEFAULTS) with patch.object(worker,'ROOT',root),patch.object(worker.operations,'snapshot',worker.operations.snapshot), \ patch('builtins.print') as output, \ patch.object(backup,'client',side_effect=RuntimeError('Database unavailable')): with self.assertRaises(RuntimeError):worker.once('monitor') self.assertFalse(folder.exists()) self.assertEqual(json.loads(output.call_args.args[0])['incompleteBackupsRemoved'],1) def test_retirement_rename_stays_on_the_backup_volume_and_resumes_cleanup(self): with tempfile.TemporaryDirectory() as directory: root=Path(directory).resolve();folder=root/'output/backups/20261110T010000Z-12345678' folder.mkdir(parents=True);(folder/'snapshot').write_bytes(b'old backup') keep=folder.parent/'unrelated';keep.mkdir() br.retire_folder(root,folder,'backup') self.assertFalse(folder.exists()) record=next((root/'.runtime/retention/retired').glob('*.json')) value=json.loads(record.read_text());self.assertEqual(value['storage'],'backup-volume') self.assertTrue((root/'output/backups/.retired'/value['target']).is_dir()) self.assertEqual(br.clean_retired(root),1);self.assertTrue(keep.is_dir()) self.assertFalse(record.exists()) def test_secret_initialization_is_private_idempotent_and_not_in_command_arguments(self): with tempfile.TemporaryDirectory() as directory: root = Path(directory); (root / 'deploy/docker').mkdir(parents=True) (root / 'deploy/docker/.env.example').write_text('HTTP_BIND=127.0.0.1\n') base = manage.initialize(root) before = {p.name: p.read_bytes() for p in (base / 'secrets').iterdir()} manage.initialize(root) self.assertEqual(before, {p.name: p.read_bytes() for p in (base / 'secrets').iterdir()}) for path in (base / 'secrets').iterdir(): self.assertEqual(path.stat().st_mode & 0o077, 0) env = manage.environment(root) self.assertEqual(len(set(env[k] for k in manage.SECRET_NAMES.values())), 3) args = manage.command('up') for value in before.values(): self.assertNotIn(value.decode().strip(), str(args)) self.assertNotIn('-v', manage.command('stop')) def test_config_uses_tcp_and_refuses_uncoordinated_secret_changes(self): with tempfile.TemporaryDirectory() as directory: root = Path(directory) with patch.object(app, 'secret', return_value='a' * 32), patch.dict(os.environ, {}, clear=True): first = app.prepare(root) self.assertEqual(first['mysqlHost'], 'mysql'); self.assertFalse(first['binaryLogEnabled']) self.assertEqual((root / '.runtime/local-config.json').stat().st_mode & 0o077, 0) env = app.backend_environment(first) self.assertIn('jdbc:mysql://mysql:3306/', env['MYSQL_URL']) self.assertEqual(env['SERVER_ADDRESS'], '0.0.0.0') with patch.object(app, 'secret', return_value='b' * 32): with self.assertRaises(ValueError): app.prepare(root) def test_backend_exit_causes_container_failure_instead_of_leaving_a_dead_api(self): with tempfile.TemporaryDirectory() as directory: root = Path(directory); (root / '.runtime').mkdir() child = Mock(pid=777); child.poll.return_value = 2 with patch.object(app, 'ROOT', root), patch.object(app, 'prepare', return_value={}), \ patch.object(app, 'backend_environment', return_value={}), patch.object(br, 'accepted_backend'), \ patch.object(app.subprocess, 'Popen', return_value=child), patch.object(app.signal, 'signal'): self.assertEqual(app.serve(), 1) child.wait.assert_called_once() def test_shutdown_signals_backend_and_workers_before_waiting(self): with tempfile.TemporaryDirectory() as directory: root = Path(directory); (root / '.runtime').mkdir() children = [Mock(pid=100 + i) for i in range(3)] for child in children: child.poll.return_value = None handlers = {} def register(signum, handler): handlers[signum] = handler def tick(_): handlers[app.signal.SIGTERM](app.signal.SIGTERM, None) with patch.object(app, 'ROOT', root), patch.object(app, 'prepare', return_value={}), \ patch.object(app, 'backend_environment', return_value={}), patch.object(br, 'accepted_backend'), \ patch.object(app.subprocess, 'Popen', side_effect=children), patch.object(app.signal, 'signal', side_effect=register), \ patch.object(app, 'ready', return_value=True), patch.object(app, 'review_retention'), \ patch.object(app.time, 'sleep', side_effect=tick), patch.object(app.os, 'killpg') as kill: self.assertEqual(app.serve(), 0) self.assertEqual(kill.call_count, 3) for child in children: child.wait.assert_called_once() def test_container_pinned_jar_rejects_corruption(self): with tempfile.TemporaryDirectory() as directory, patch.dict(os.environ, {'QUALITY_CONTAINER': '1'}): root = Path(directory); (root / 'app').mkdir() jar = root / 'app/backend.jar'; jar.write_bytes(b'accepted') (root / 'app/backend.sha256').write_text(br.sha(jar)) self.assertEqual(br.accepted_backend(root)[0], jar.resolve()) jar.write_bytes(b'changed') with self.assertRaises(ValueError): br.accepted_backend(root) def test_backup_uses_owned_private_instance_for_container_and_owns_temporary_files(self): from contextlib import contextmanager import backup_verifier configuration = Path('/tmp/owned-verifier/client.cnf') @contextmanager def instance(root): yield configuration seen = [] def verify(folder): seen.append((backup.client_config(), backup.verification_temp_root())) return 'verified' with tempfile.TemporaryDirectory() as directory, patch.object(backup, 'ROOT', Path(directory)), \ patch.dict(os.environ, {'QUALITY_CONTAINER': '1'}), patch.object(backup_verifier, 'instance', instance), \ patch.object(backup, '_verify', side_effect=verify): self.assertEqual(backup.verify('unused'), 'verified') self.assertEqual(seen, [(configuration, configuration.parent)]) self.assertIsNone(backup.CLIENT_CONFIG_OVERRIDE.get()) def test_compose_preserves_volumes_bounded_logs_secrets_and_private_networks(self): try: import yaml except ImportError: self.skipTest('Install PyYAML for Compose contract checks') compose = yaml.safe_load((ROOT / 'deploy/docker/compose.yaml').read_text()) services = compose['services'] self.assertNotIn('ports', services['mysql']); self.assertNotIn('ports', services['app']) self.assertEqual(services['mysql']['command'][0], '--skip-log-bin') self.assertEqual(len(compose['volumes']), 5) self.assertEqual(services['app']['depends_on']['mysql']['condition'], 'service_healthy') for service in services.values(): self.assertEqual(service['restart'], 'unless-stopped') self.assertEqual(service['logging']['options']['max-size'], '10m') self.assertTrue(services['app']['read_only']) self.assertNotIn('docker.sock', json.dumps(compose)) self.assertFalse((ROOT / '.gitea/workflows').exists()) def test_build_context_excludes_live_data_and_private_baseline(self): ignore = (ROOT / '.dockerignore').read_text() self.assertEqual(next(line for line in ignore.splitlines() if line and not line.startswith('#')), '**') for allowed in ('!.runtime', '!runtimedata', '!output', '!质量数据', '!apikey.txt'): self.assertNotIn(allowed, ignore) self.assertIn('**/original-workbook-acceptance.json', ignore) nginx = (ROOT / 'deploy/docker/nginx.conf').read_text() self.assertIn('proxy_buffering off', nginx) self.assertIn('resolver 127.0.0.11', nginx) if __name__ == '__main__': unittest.main()