mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
182 lines
9.0 KiB
Python
182 lines
9.0 KiB
Python
#!/usr/bin/env python3
|
|
"""python3 scripts/seed-issue-21397.test.py — runs the seeder against synthetic SQLite files only."""
|
|
import datetime
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import pathlib
|
|
import sqlite3
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
SCRIPT = pathlib.Path(__file__).resolve().with_name('seed-issue-21397.py')
|
|
FIXTURE = json.loads(SCRIPT.with_name('fixtures').joinpath('issue-21397.json').read_text())
|
|
# Windows cannot delete a file SQLite still holds open, so cleanup must close connections first.
|
|
OPEN_DB_PROBE = '''
|
|
import runpy, shutil, sqlite3, sys
|
|
opened, connect, rmtree = [], sqlite3.connect, shutil.rmtree
|
|
def tracked(*args, **kwargs):
|
|
opened.append(connect(*args, **kwargs))
|
|
return opened[-1]
|
|
def checked(*args, **kwargs):
|
|
for db in opened:
|
|
try:
|
|
db.total_changes
|
|
except sqlite3.ProgrammingError:
|
|
continue
|
|
sys.exit('rmtree ran while a SQLite connection was open')
|
|
return rmtree(*args, **kwargs)
|
|
sqlite3.connect, shutil.rmtree = tracked, checked
|
|
sys.argv = sys.argv[1:]
|
|
runpy.run_path(sys.argv[0], run_name='__main__')
|
|
'''
|
|
|
|
|
|
def snapshot(directory):
|
|
return {
|
|
str(p.relative_to(directory)): hashlib.sha256(p.read_bytes()).hexdigest() if p.is_file() else 'dir'
|
|
for p in sorted(directory.rglob('*'))
|
|
}
|
|
|
|
|
|
class SeederTest(unittest.TestCase):
|
|
def setUp(self):
|
|
temp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(temp.cleanup)
|
|
self.tmp = pathlib.Path(temp.name)
|
|
self.fake_home = self.tmp / 'user'
|
|
(self.fake_home / '.hanzo-dev/userdata').mkdir(parents=True)
|
|
self.source_home = self.tmp / 'worktree/.hanzo-dev/userdata'
|
|
self.source_home.mkdir(parents=True)
|
|
self.source = self.source_home / 'statev2.sqlite'
|
|
db = sqlite3.connect(self.source)
|
|
db.execute('PRAGMA journal_mode=WAL')
|
|
for table, rows in FIXTURE.items():
|
|
db.execute(f'CREATE TABLE "{table}" ({",".join(sorted({k for r in rows for k in r}))})')
|
|
db.execute(f'INSERT INTO "{table}" (thread_id) VALUES (?)' if table != 'projection_projects'
|
|
else f'INSERT INTO "{table}" (project_id) VALUES (?)', ['sentinel'])
|
|
db.execute('CREATE TABLE orchestration_v2_projection_metadata (key)')
|
|
db.execute("INSERT INTO orchestration_v2_projection_metadata VALUES ('kept')")
|
|
db.execute('CREATE TABLE projection_thread_messages (id)')
|
|
db.execute("INSERT INTO projection_thread_messages VALUES ('sentinel')")
|
|
db.execute('CREATE TABLE orchestration_v2_effect_outbox (status)')
|
|
db.executemany('INSERT INTO orchestration_v2_effect_outbox VALUES (?)', [('pending',), ('done',)])
|
|
db.commit()
|
|
db.close()
|
|
(self.source_home / 'settings.json').write_text('{"sentinel": true}\n')
|
|
self.before = snapshot(self.source_home)
|
|
|
|
def run_seeder(self, *args, probe=()):
|
|
env = {**os.environ, 'HOME': str(self.fake_home)}
|
|
return subprocess.run([sys.executable, '-I', *probe, str(SCRIPT), '--source', str(self.source), *args],
|
|
env=env, capture_output=True, text=True)
|
|
|
|
def assertSourceUnchanged(self):
|
|
self.assertEqual(snapshot(self.source_home), self.before)
|
|
|
|
def thread_payload(self, home):
|
|
with sqlite3.connect(home / 'userdata/statev2.sqlite') as db:
|
|
self.assertEqual(db.execute('SELECT count(*) FROM projection_thread_messages').fetchone(), (0,))
|
|
self.assertEqual(db.execute('SELECT key FROM orchestration_v2_projection_metadata').fetchall(), [('kept',)])
|
|
self.assertEqual(db.execute('SELECT status FROM orchestration_v2_effect_outbox ORDER BY 1').fetchall(),
|
|
[('cancelled',), ('done',)])
|
|
rows = db.execute('SELECT thread_id, payload_json FROM orchestration_v2_projection_threads').fetchall()
|
|
self.assertEqual(len(rows), 1)
|
|
self.assertNotEqual(rows[0][0], 'sentinel')
|
|
return json.loads(rows[0][1])
|
|
|
|
def test_seeds_a_fresh_copy_for_every_mode_and_clock(self):
|
|
snooze = json.loads(FIXTURE['orchestration_v2_projection_threads'][0]['payload_json'])['snoozedUntil']
|
|
clocks = [([], datetime.timedelta(), '2026-10-22T19:00:00Z'),
|
|
(['--now', '2026-11-01T12:30:00+02:00'], datetime.timedelta(days=9, hours=15, minutes=30),
|
|
'2026-11-01T10:30:00Z'),
|
|
(['--now'], None, None)]
|
|
for mode in ('matching', 'absent', 'unrelated'):
|
|
for clock_args, delta, logged in clocks:
|
|
with self.subTest(mode=mode, clock=clock_args):
|
|
home = self.tmp / 'fixtures' / f'{mode}-{len(clock_args)}'
|
|
started = datetime.datetime.now(datetime.timezone.utc)
|
|
result = self.run_seeder('--home', str(home), mode, *clock_args)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertSourceUnchanged()
|
|
if delta is None:
|
|
delta = started.replace(microsecond=0) - datetime.datetime(
|
|
2026, 10, 22, 19, tzinfo=datetime.timezone.utc)
|
|
logged = None
|
|
if logged:
|
|
self.assertIn(f'(limit hit at {logged})', result.stdout)
|
|
self.assertIn(f'Run: vp run dev --home-dir {home}', result.stdout)
|
|
expected = {'matching': snooze, 'absent': None, 'unrelated': '2026-10-24T08:50:00.000Z'}[mode]
|
|
actual = self.thread_payload(home)['snoozedUntil']
|
|
if expected is None:
|
|
self.assertIsNone(actual)
|
|
else:
|
|
moved = datetime.datetime.fromisoformat(actual.replace('Z', '+00:00')) - delta
|
|
original = datetime.datetime.fromisoformat(expected.replace('Z', '+00:00'))
|
|
self.assertLess(abs(moved - original), datetime.timedelta(seconds=2))
|
|
self.assertEqual(json.loads((home / 'userdata/settings.json').read_text()),
|
|
{'snoozeLimitedThreads': False, 'autoResumeLimitedThreads': False})
|
|
|
|
def test_refuses_unsafe_destinations_without_touching_anything(self):
|
|
existing_dir = self.tmp / 'existing'
|
|
existing_dir.mkdir()
|
|
(existing_dir / 'keep').write_text('keep')
|
|
existing_file = self.tmp / 'file'
|
|
existing_file.write_text('keep')
|
|
link_to_dir = self.tmp / 'link-dir'
|
|
link_to_dir.symlink_to(existing_dir)
|
|
dangling = self.tmp / 'dangling'
|
|
dangling.symlink_to(self.tmp / 'missing')
|
|
live_link = self.tmp / 'live-link'
|
|
live_link.symlink_to(self.fake_home / '.hanzo-dev')
|
|
cases = {
|
|
'existing directory': existing_dir,
|
|
'existing file': existing_file,
|
|
'symlink to directory': link_to_dir,
|
|
'dangling symlink': dangling,
|
|
'source home': self.source_home.parent,
|
|
'live home': self.fake_home / '.hanzo-dev',
|
|
'inside live home': self.fake_home / '.hanzo-dev/fixture',
|
|
'through symlink into live home': live_link / 'fixture',
|
|
}
|
|
for name, home in cases.items():
|
|
with self.subTest(name):
|
|
listing = sorted(str(p) for p in self.tmp.rglob('*'))
|
|
result = self.run_seeder('--home', str(home))
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn('Refusing', result.stderr)
|
|
self.assertSourceUnchanged()
|
|
self.assertEqual(sorted(str(p) for p in self.tmp.rglob('*')), listing)
|
|
self.assertEqual((existing_dir / 'keep').read_text(), 'keep')
|
|
self.assertFalse((self.tmp / 'missing').exists())
|
|
|
|
def test_refuses_missing_or_symlinked_source(self):
|
|
link = self.tmp / 'linked.sqlite'
|
|
link.symlink_to(self.source)
|
|
for source in (self.tmp / 'absent.sqlite', link):
|
|
with self.subTest(str(source)):
|
|
env = {**os.environ, 'HOME': str(self.fake_home)}
|
|
result = subprocess.run([sys.executable, '-I', str(SCRIPT), '--source', str(source),
|
|
'--home', str(self.tmp / 'new')], env=env, capture_output=True, text=True)
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertFalse((self.tmp / 'new').exists())
|
|
self.assertSourceUnchanged()
|
|
|
|
def test_failed_seed_removes_only_its_new_home(self):
|
|
with sqlite3.connect(self.source) as db:
|
|
db.execute('DROP TABLE orchestration_v2_effect_outbox')
|
|
db.close()
|
|
self.before = snapshot(self.source_home)
|
|
home = self.tmp / 'broken'
|
|
result = self.run_seeder('--home', str(home), probe=('-c', OPEN_DB_PROBE))
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertIn('orchestration_v2_effect_outbox', result.stderr)
|
|
self.assertFalse(home.exists(), result.stderr)
|
|
self.assertSourceUnchanged()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|