Files

166 lines
9.7 KiB
Python

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