123 lines
6.1 KiB
Python
123 lines
6.1 KiB
Python
"""Sync is opt-in, target-bound and protects unrelated/server-generated files."""
|
|
import base64
|
|
import contextlib
|
|
import hashlib
|
|
import io
|
|
import json
|
|
from pathlib import Path
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from scripts import sync_patch as sync
|
|
|
|
|
|
class ScopedSyncTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.tmp.cleanup)
|
|
self.root = Path(self.tmp.name)
|
|
(self.root / 'harness').mkdir()
|
|
(self.root / 'harness/one.py').write_bytes(b'old')
|
|
(self.root / 'registry').mkdir()
|
|
(self.root / 'registry/models.csv').write_bytes(b'generated')
|
|
(self.root / 'state').mkdir()
|
|
(self.root / 'state/keep').write_bytes(b'business')
|
|
|
|
def payload(self):
|
|
view = sync.snapshot(self.root, for_sync=True)
|
|
raw = b'changed'
|
|
return {'operation': 'apply', 'root': str(self.root), 'expected': view,
|
|
'id': 'a' * 32, 'files': [{'path': 'harness/one.py',
|
|
'data': base64.b64encode(raw).decode(), 'sha256': hashlib.sha256(raw).hexdigest(), 'mode': 0o644}]}
|
|
|
|
def apply(self, payload):
|
|
return subprocess.run([sys.executable, '-c', sync.REMOTE_PROGRAM], input=json.dumps(payload),
|
|
text=True, capture_output=True)
|
|
|
|
def test_local_preview_has_no_transport_or_writes(self):
|
|
with patch.object(sync, 'remote_call') as call, contextlib.redirect_stdout(io.StringIO()):
|
|
self.assertEqual(sync.main(['--root', str(self.root)]), 0)
|
|
call.assert_not_called()
|
|
self.assertFalse((self.root / '.sync').exists())
|
|
|
|
def test_apply_requires_target_and_existing_baseline(self):
|
|
with patch.object(sync, 'remote_call') as call:
|
|
for args in (['--apply'], ['--apply', '--remote', 'user@host', '--remote-dir', '/opt/bench']):
|
|
with self.assertRaisesRegex(ValueError, 'target|baseline'):
|
|
sync.main(['--root', str(self.root), *args])
|
|
call.assert_not_called()
|
|
|
|
def test_target_and_local_bytes_must_match_preview(self):
|
|
local = sync.snapshot(self.root, for_sync=True)
|
|
plan = {'schema': sync.PLAN_SCHEMA, 'target': {'remote': 'user@host', 'port': 22, 'root': '/opt/bench'},
|
|
'local': local, 'remote': local, 'selected': None}
|
|
with self.assertRaisesRegex(ValueError, 'target'):
|
|
sync.validate_plan(plan, {'remote': 'other@host', 'port': 22, 'root': '/opt/bench'}, local, None)
|
|
(self.root / 'harness/one.py').write_bytes(b'new local edit')
|
|
with self.assertRaisesRegex(ValueError, 'local'):
|
|
sync.validate_plan(plan, plan['target'], sync.snapshot(self.root, for_sync=True), None)
|
|
|
|
def test_remote_drift_rejects_before_any_source_write(self):
|
|
payload = self.payload()
|
|
(self.root / 'harness/one.py').write_bytes(b'concurrent edit')
|
|
result = self.apply(payload)
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn('remote drift', result.stderr)
|
|
self.assertEqual((self.root / 'harness/one.py').read_bytes(), b'concurrent edit')
|
|
self.assertFalse((self.root / '.sync').exists())
|
|
|
|
def test_apply_preserves_generated_registry_state_and_backup(self):
|
|
payload = self.payload()
|
|
(self.root / 'registry/models.csv').write_bytes(b'newly generated')
|
|
result = self.apply(payload)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual((self.root / 'harness/one.py').read_bytes(), b'changed')
|
|
self.assertEqual((self.root / 'registry/models.csv').read_bytes(), b'newly generated')
|
|
self.assertEqual((self.root / 'state/keep').read_bytes(), b'business')
|
|
self.assertEqual((self.root / '.sync'/payload['id']/'harness/one.py').read_bytes(), b'old')
|
|
self.assertTrue((self.root / '.sync'/payload['id']/'receipt.json').is_file())
|
|
|
|
def test_symlink_parent_and_generated_destination_rejected(self):
|
|
for name in ('registry/models.csv', '../outside.py', 'state/keep'):
|
|
payload = self.payload(); payload['files'][0]['path'] = name
|
|
result = self.apply(payload)
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertFalse((self.root / '.sync').exists())
|
|
elsewhere = self.root / 'outside'; elsewhere.mkdir()
|
|
(self.root / 'harness/alias').symlink_to(elsewhere, target_is_directory=True)
|
|
payload = self.payload(); payload['files'][0]['path'] = 'harness/alias/new.py'
|
|
result = self.apply(payload)
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertFalse((elsewhere / 'new.py').exists())
|
|
|
|
def test_snapshot_includes_locks_docker_and_excludes_generated(self):
|
|
for name in ('agent/package-lock.json', 'Dockerfile', 'constraints.txt', 'docker/config.yaml'):
|
|
p = self.root / name; p.parent.mkdir(exist_ok=True); p.write_text('content')
|
|
files = sync.snapshot(self.root, for_sync=True)['files']
|
|
for name in ('agent/package-lock.json', 'Dockerfile', 'constraints.txt', 'docker/config.yaml'):
|
|
self.assertIn(name, files)
|
|
self.assertNotIn('registry/models.csv', files)
|
|
self.assertIn('registry/models.csv', sync.snapshot(self.root)['files'])
|
|
self.assertNotIn('state/keep', files)
|
|
|
|
def test_full_apply_refuses_unhandled_source_deletion(self):
|
|
local = sync.snapshot(self.root, for_sync=True)
|
|
remote = json.loads(json.dumps(local)); remote['files']['harness/removed.py'] = {'sha256': 'a' * 64, 'mode': 0o644}
|
|
with self.assertRaisesRegex(ValueError, 'delet'):
|
|
sync.uploads(self.root, local, remote, None)
|
|
|
|
def test_mode_drift_and_bad_payload_are_not_accepted(self):
|
|
payload = self.payload()
|
|
(self.root / 'harness/one.py').chmod(0o755)
|
|
self.assertNotEqual(self.apply(payload).returncode, 0)
|
|
payload = self.payload(); payload['files'][0]['sha256'] = 'b' * 64
|
|
self.assertNotEqual(self.apply(payload).returncode, 0)
|
|
self.assertFalse((self.root / '.sync').exists())
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|