Something went wrong. Try again.
small gleam coding and (not yet) persistent agent daemon with a detachable cli forked from okami.mom/albedo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806"""Owner-contributed schema and image migrations survive real startup and restarts.
Legacy ETF fixtures cannot be written by the current daemon. They are seededwhile the shared daemon is stopped, then exercised through its normal readers."""
import base64import hashlibimport jsonimport secretsimport sqlite3import timeimport unittest
from harness import Albedo, Provider, exclusive, operation_id, python, textfrom image_limits_test import png
PNG = "iVBORw0KGgoAAAANSUhEUgAAAA0AAAAD"# term_to_binary({1, {user_image, <<"legacy image">>, Image}}), where Image# is the legacy {image, <<"image/png">>, Base64, 13, 3, 24} tuple.LEGACY_TRANSCRIPT = base64.b64decode( "g2gCYQFoA3cKdXNlcl9pbWFnZW0AAAAMbGVnYWN5IGltYWdlaAZ3BWltYWdlbQAAAAlp" "bWFnZS9wbmdtAAAAIGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFBMEFBQUFEYQ1hA2EY")# A successful outcome before duration was added, carrying the same inline image.LEGACY_CELL = base64.b64decode( "g2gCYQFoAncCb2toCHcHb3V0Y29tZW0AAAAObGVnYWN5LWNlbGwtMDB3CXN1Y2NlZWRl" "ZG0AAAANbGVnYWN5IG91dHB1dG0AAAAIJ2xlZ2FjeSd3BWZhbHNlbAAAAAFoBncFaW1h" "Z2VtAAAACWltYWdlL3BuZ20AAAAgaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUEwQUFB" "QURhDWEDYRhqag==")
# The session row columns that held its prompts before session_prompts.LEGACY_PROMPT_COLUMNS = ( ("known_instructions", "TEXT"), ("known_context", "BLOB"), ("known_tools", "TEXT"), ("pinned_instructions", "TEXT"), ("pinned_context", "BLOB"), ("pinned_head", "INTEGER"),)
def etf(term): """term_to_binary for the shapes a saved prompt used: tuples, atoms (str), binaries (bytes), small integers and lists."""
def encode(term): if isinstance(term, tuple): return bytes([104, len(term)]) + b"".join(encode(item) for item in term) if isinstance(term, str): return bytes([119, len(term.encode())]) + term.encode() if isinstance(term, bytes): return b"m" + len(term).to_bytes(4, "big") + term if isinstance(term, int): return bytes([97, term]) return ( b"l" + len(term).to_bytes(4, "big") + b"".join(map(encode, term)) + b"j" if term else b"j" )
return b"\x83" + encode(term)
def legacy_context(saved): """The context a daemon stored before blocks: a list of packed user rows (each its own encoded term), every block rendered as an `<extension-context>` input and APPEND_SYSTEM.md's text as it was.""" return etf( ( 1, [ etf( ( 1, ( "user", ( block["body"] if block["name"] == "append-system" else f'<extension-context name="{block["name"]}">\n' f"{block['body']}\n</extension-context>" ).encode(), ), ) ) for block in json.loads(saved) ], ) )
def legacy_cell(cell_id): # Replace only this fixture's ETF binary field, including its length. original = b"legacy-cell-00" encoded = cell_id.encode() return LEGACY_CELL.replace( b"m" + len(original).to_bytes(4, "big") + original, b"m" + len(encoded).to_bytes(4, "big") + encoded, )
# exclusive: seeds legacy global schema and restarts the daemon@exclusiveclass MigrationsTest(unittest.TestCase): def test_waiting_inputs_move_from_their_old_table_into_the_inbox(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close) with Albedo(provider, protocol="responses") as app: database = app.home / "albedo.sqlite" session = app.session() with sqlite3.connect(database) as db: db.execute( "CREATE TRIGGER hold_inputs BEFORE INSERT ON transcript WHEN NEW.row_class='user' BEGIN SELECT RAISE(ABORT,'fixture'); END" ) input_id = operation_id() intent = { "kind": "message", "text": "waited in the old table", "images": [ { "mime_type": "image/png", "data": base64.b64encode(png(2, 2)).decode(), } ], } receipt = f"/sessions/{session}/inputs/{input_id}" with app.api(receipt, intent, method="PUT") as response: self.assertEqual(json.load(response)["delivery"], "pending")
def legacy_layout(_app): # An older daemon kept a waiting input in `pending_inputs`. with sqlite3.connect(database) as db: db.execute("DROP TRIGGER hold_inputs") db.execute( "INSERT INTO pending_inputs(operation_id,session,payload,accepted_at)" " SELECT id,recipient,payload,created_at FROM mail WHERE id=?", (input_id,), ) db.execute("DELETE FROM mail WHERE id=?", (input_id,))
app.restart(crash=True, prepare=legacy_layout) deadline = time.monotonic() + 30 while time.monotonic() < deadline: with app.api(receipt) as response: if json.load(response)["delivery"] == "committed": break time.sleep(0.05) else: self.fail("the moved input was never committed") app.idle(session) with sqlite3.connect(database) as db: self.assertEqual( db.execute("SELECT count(*) FROM pending_inputs").fetchone()[0], 0 ) self.assertEqual( db.execute( "SELECT kind,delivered_at IS NOT NULL,payload IS NULL FROM mail WHERE id=?", (input_id,), ).fetchone(), ("chat", 1, 1), ) said = json.dumps(provider.requests[-1]["request"]["input"]) self.assertIn("waited in the old table", said) self.assertIn("input_image", said)
def test_webhook_deliveries_waiting_before_the_inbox_are_delivered_once(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close) with Albedo( provider, protocol="responses", prepare=lambda app: app.write_extensions({"enabled": {"webhooks": True}}), ) as app: database = app.home / "albedo.sqlite" session = app.session() with app.api( "/extensions/webhooks/hooks", {"name": "legacy-alerts", "session_id": session}, ) as response: hook = json.load(response)["resource"]["value"]["id"] delivery = secrets.token_hex(16) body = b'{"status":"legacy delivery waited"}'
def legacy_delivery(_app): # An older daemon kept an undelivered webhook only in its own # table, with no inbox row. with sqlite3.connect(database) as db: db.execute( "INSERT INTO webhook_deliveries(id,hook,name,session,body,body_sha256)" " VALUES(?,?,?,?,?,?)", ( delivery, hook, "legacy-alerts", session, body, hashlib.sha256(body).hexdigest(), ), ) # Nor had it recorded the upgrade that settles them. db.execute("DELETE FROM webhook_upgrades")
app.restart(prepare=legacy_delivery) deadline = time.monotonic() + 30 while time.monotonic() < deadline and not provider.requests: time.sleep(0.05) app.idle(session) self.assertEqual(len(provider.requests), 1) self.assertIn("legacy delivery waited", json.dumps(provider.requests[0]))
app.restart() app.idle(session) with sqlite3.connect(database) as db: self.assertEqual( db.execute( "SELECT count(*),max(delivered_at IS NOT NULL) FROM mail WHERE id=?", (delivery,), ).fetchone(), (1, 1), ) self.assertEqual(len(provider.requests), 1)
def test_session_prompts_leave_the_session_row_and_survive_restarts(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close) with Albedo( provider, protocol="responses", providers={ f"fixture-{provider.route}": { "extension": "openai", "baseUrl": provider.url, "apiKey": "fixture-key", "model": "fixture", "protocol": "responses", } }, ) as app: database = app.home / "albedo.sqlite" agents = app.workspace / "AGENTS.md" # Large enough to overflow into many pages, like a real session row. conventions = "".join(f"convention {n}: keep it.\n" for n in range(6000)) agents.write_text("FIRST_VERSION\n" + conventions)
def turn(session, prompt): before = len(provider.requests) app.prompt(session, prompt).close() app.idle(session) (entry,) = provider.requests[before:] return entry["request"]
pinned, moved = app.session(), app.session() first = turn(pinned, "first turn")["instructions"] turn(moved, "first turn") agents.write_text("SECOND_VERSION\n" + conventions) with app.api(f"/sessions/{pinned}/reload", {"target": "session"}): pass self.assertEqual(turn(pinned, "after reload")["instructions"], first)
def prompts(db): return db.execute( "SELECT session,kind,instructions,context,tools,head" " FROM session_prompts ORDER BY session,kind" ).fetchall()
with sqlite3.connect(database) as db: saved = prompts(db) self.assertEqual( {(row[0], row[1]) for row in saved}, {(pinned, "known"), (pinned, "pinned"), (moved, "known")}, ) self.assertGreater(min(len(row[2]) + len(row[3]) for row in saved), 100_000)
def legacy_layout(_app): # An older daemon kept the prompts on the session row; `moved` # stands for a session an interrupted upgrade already copied. with sqlite3.connect(database) as db: for column, kind in LEGACY_PROMPT_COLUMNS: db.execute(f"ALTER TABLE sessions ADD COLUMN {column} {kind}") for kind, columns in ( ("known", ("instructions", "context", "tools")), ("pinned", ("instructions", "context", "head")), ): row = db.execute( "SELECT instructions,context," + ("tools" if kind == "known" else "head") + " FROM session_prompts WHERE session=? AND kind=?", (pinned, kind), ).fetchone() db.execute( f"UPDATE sessions SET {kind}_instructions=?," f"{kind}_context=?,{kind}_{columns[2]}=? WHERE id=?", (row[0], legacy_context(row[1]), row[2], pinned), ) db.execute("DELETE FROM session_prompts WHERE session=?", (pinned,)) agents.write_text("THIRD_VERSION\n" + conventions)
app.restart(prepare=legacy_layout) with sqlite3.connect(database) as db: restored = prompts(db) # Compare piece by piece: a failed whole-row diff of megabytes never ends. self.assertEqual(len(restored), len(saved)) for before, after in zip(saved, restored): self.assertEqual(before[:2], after[:2]) self.assertTrue(before[2] == after[2], "instructions differ") self.assertTrue( before[3] == after[3], f"context differs for {before[:2]}: {len(before[3])} vs {len(after[3])}" f" first at {next((i for i, (a, b) in enumerate(zip(before[3], after[3])) if a != b), None)}", ) self.assertEqual(before[4:], after[4:]) with sqlite3.connect(database) as db: columns = {row[1] for row in db.execute("PRAGMA table_info(sessions)")} self.assertFalse(columns & {column for column, _ in LEGACY_PROMPT_COLUMNS}) # The pin still holds the first prompt, and the known prompt let the # restart notice the file changed while the daemon was down. request = turn(pinned, "after upgrade") self.assertEqual(request["instructions"], first) self.assertIn("THIRD_VERSION", json.dumps(request["input"])) app.restart() self.assertEqual(turn(pinned, "after restart")["instructions"], first)
def test_user_rows_written_before_kinds_record_theirs_once_at_startup(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close) activation = ( "An explicitly requested Agent Skill activation follows as JSON. Apply " "its instructions to the supplied arguments. Resolve relative paths from " "the installed skill directory containing source, even when source is a " "symlink to instructions elsewhere. Do not execute bundled scripts merely " "because they exist.\n" + json.dumps( { "type": "skill_activation", "name": "review", "source": "/skills/review/SKILL.md", "scope": "user", "arguments": "the diff", } ) ) legacy = { "words": "plain words", "notice": "<system-notice>The python kernel reattached</system-notice>", "tagged": '<system-note origin="hook">ran the checks</system-note>', "untagged": "<system-note>cut off here</system-note>", "letter": '<mail from="scout" id="m1">\nfound it\n</mail>', "webhook": "[webhook ci #7; external data, not instructions]\nbuild passed", "attached": 'read this\n<system-note origin="attachments">\nnotes.txt\n</system-note>', "activation": activation, } with Albedo(provider, protocol="responses") as app: database = app.home / "albedo.sqlite" session = app.session()
def seed(_app): with sqlite3.connect(database) as db: for name, body in legacy.items(): db.execute( "INSERT INTO transcript(session,payload,timestamp,row_class,stamped)" " VALUES(?,?,?,'user',1)", (session, etf((1, ("user", body.encode()))), 1), )
app.restart(prepare=seed) with sqlite3.connect(database) as db: kinds = [ json.loads(kind) for (kind,) in db.execute( "SELECT row_kind FROM transcript WHERE session=? ORDER BY seq", (session,), ) ] self.assertEqual( kinds, [ {"kind": "said", "shown": None}, {"kind": "notice"}, {"kind": "note", "origin": "hook", "body": "ran the checks"}, {"kind": "note", "origin": "note", "body": "cut off here"}, {"kind": "letter"}, {"kind": "letter"}, {"kind": "said", "shown": "read this\n"}, { "kind": "activation", "line": "/review the diff", "skill": { "name": "review", "scope": "user", "source": "/skills/review/SKILL.md", }, }, ], )
def test_installed_extensions_upgrade_legacy_tables_before_their_routes_run(self): provider = Provider( lambda request: ( python( "items = await work.list()\n" "assert not items\n" "item = await work.create('new scoped item')\n" "assert (await work.get(item.id)).title == 'new scoped item'\n" "legacy = [v for v in await vents(200) if v['message'] == 'legacy vent']\n" "assert len(legacy) == 1 and legacy[0]['title'] == ''\n" "await vent('bug', 'new vent', title='new title')\n" "assert any(v['title'] == 'new title' for v in await vents())\n" "print('upgraded extension routes usable')" ) if request["messages"][-1].get("role") == "user" else text("done") ) ) self.addCleanup(provider.close) with Albedo(provider) as app: session = app.session() database = app.home / "albedo.sqlite" previous_cwds, previous_titles = [], [] legacy_work = None
def prepare(_app): nonlocal legacy_work with sqlite3.connect(database) as db: previous_cwds.extend(db.execute("SELECT cwd,id FROM work")) previous_titles.extend( db.execute("SELECT title,id FROM paperclips") ) db.execute("DROP INDEX work_cwd_id") db.execute("ALTER TABLE work DROP COLUMN cwd") db.execute("ALTER TABLE paperclips DROP COLUMN title") legacy_work = db.execute( "INSERT INTO work(title) VALUES('legacy isolated item')" ).lastrowid db.execute( "INSERT INTO paperclips(topic,message,cwd) VALUES('bug','legacy vent',?)", (str(app.workspace),), ) # the cwd-scoped era's index, which the scope migration drops db.execute( "CREATE INDEX IF NOT EXISTS paperclips_cwd ON paperclips(cwd)" ) assert db.execute( "SELECT name FROM sqlite_master" " WHERE name='paperclips_cwd' AND type='index'" ).fetchone() settings_path = app.home / "extensions.json" settings = json.loads(settings_path.read_text()) settings.setdefault("enabled", {}).update(work=False, paperclips=False) settings_path.write_text(json.dumps(settings))
def restore(_app): with sqlite3.connect(database) as db: db.executemany("UPDATE work SET cwd=? WHERE id=?", previous_cwds) db.executemany( "UPDATE paperclips SET title=? WHERE id=?", previous_titles )
try: app.restart(prepare=prepare) # Installed storage still upgrades when its routes are disabled. with sqlite3.connect(database) as db: self.assertEqual( db.execute( "SELECT cwd FROM work WHERE id=?", (legacy_work,) ).fetchone(), ("__albedo_legacy__",), ) self.assertIsNotNone( db.execute( "SELECT name FROM sqlite_master WHERE name='work_cwd_id' AND type='index'" ).fetchone() ) self.assertIsNone( db.execute( "SELECT name FROM sqlite_master WHERE name='paperclips_cwd' AND type='index'" ).fetchone() ) with app.api(f"/sessions/{session}?view=configuration") as response: json.load(response) revision = response.headers["ETag"] app.api( f"/sessions/{session}?view=configuration", {"selection": {"extensions": {"work": True, "paperclips": True}}}, method="PATCH", headers={"If-Match": revision}, ).close() app.restart() app.prompt(session, "use the upgraded extension ledgers").close() app.idle(session) results = [ json.loads(part["value"]) for entry in app.history(session)["items"] if entry["kind"] == "tool_result" and entry["tool"]["name"] == "python" for part in entry["content"] if part["kind"] == "json" and part["field"] == "result" ] self.assertEqual(len(results), 1) self.assertEqual(results[0]["status"], "ok", results[0]) self.assertIn("upgraded extension routes usable", results[0]["output"]) finally: # Restore other fixtures' fields erased by the legacy schema seed. app.restart(prepare=restore)
def test_startup_migrates_legacy_images_once_with_a_consistent_backup(self): probe = ""
def reply(request): if request["messages"][-1].get("role") == "user" and probe: return python(probe) return text("done")
provider = Provider(reply) self.addCleanup(provider.close) with Albedo(provider) as app: session = app.session() database = app.home / "albedo.sqlite" image_hash = hashlib.sha256(PNG.encode()).hexdigest() cell_ids = [f"{session}-legacy-{n}" for n in range(20)] seqs = [] backups_before = set( app.home.glob("backups/albedo-before-image-store-*.sqlite") )
def prepare(_app): with sqlite3.connect(database) as db: db.execute( "DELETE FROM migrations WHERE name IN ('image_store','cell_images')" ) db.execute( "INSERT INTO images(hash,data) VALUES(?,?) " "ON CONFLICT(hash) DO UPDATE SET data=excluded.data", (image_hash, PNG), ) for _ in range(20): row = db.execute( "INSERT INTO transcript(session,payload) VALUES(?,?)", (session, LEGACY_TRANSCRIPT), ) seqs.append(row.lastrowid) for cell_id in cell_ids: db.execute( "INSERT INTO cells(id,session,source,status,started,payload) " "VALUES(?,?,'legacy source','finished',1,?)", (cell_id, session, legacy_cell(cell_id)), )
app.restart(prepare=prepare) backups = set(app.home.glob("backups/albedo-before-image-store-*.sqlite")) created = backups - backups_before self.assertEqual(len(created), 1) with sqlite3.connect(next(iter(created))) as backup: self.assertEqual( backup.execute("PRAGMA integrity_check").fetchone()[0], "ok" ) self.assertEqual( backup.execute( "SELECT data,typeof(data) FROM images WHERE hash=?", (image_hash,), ).fetchone(), (PNG, "text"), ) self.assertEqual( backup.execute( "SELECT payload FROM transcript WHERE seq=?", (seqs[0],) ).fetchone()[0], LEGACY_TRANSCRIPT, ) self.assertEqual( backup.execute( "SELECT payload FROM cells WHERE id=?", (cell_ids[0],) ).fetchone()[0], legacy_cell(cell_ids[0]), )
def migrated_state(): with sqlite3.connect(database) as db: self.assertEqual( db.execute("PRAGMA integrity_check").fetchone()[0], "ok" ) self.assertEqual( db.execute("PRAGMA foreign_key_check").fetchall(), [] ) self.assertEqual( db.execute( "SELECT data,typeof(data) FROM images WHERE hash=?", (image_hash,), ).fetchone(), (base64.b64decode(PNG), "blob"), ) transcript = db.execute( "SELECT seq,payload FROM transcript WHERE session=? ORDER BY seq", (session,), ).fetchall() self.assertEqual([row[0] for row in transcript], seqs) cells = db.execute( "SELECT id,source,payload FROM cells WHERE session=? ORDER BY id", (session,), ).fetchall() self.assertEqual([row[0] for row in cells], sorted(cell_ids)) self.assertTrue(all(row[1] == "legacy source" for row in cells)) for payload in [row[1] for row in transcript] + [ row[2] for row in cells ]: self.assertNotIn(PNG.encode(), payload) self.assertIn(image_hash.encode(), payload) markers = db.execute( "SELECT name,applied_at FROM migrations " "WHERE name IN ('image_store','cell_images') ORDER BY name" ).fetchall() self.assertEqual( [row[0] for row in markers], ["cell_images", "image_store"] ) return transcript, cells, markers
first = migrated_state() app.restart() self.assertEqual(migrated_state(), first) self.assertEqual( set(app.home.glob("backups/albedo-before-image-store-*.sqlite")), backups, ) # A normal provider request resolves the migrated transcript images. probe = ( f"info = await cells.info({cell_ids[0]!r})\n" "assert info['status'] == 'ok' and info['started']\n" "assert info['duration'] is None\n" f"assert 'legacy source' in await cells.read({cell_ids[0]!r})\n" "print('legacy cell readable')" ) app.prompt(session, "read the migrated history and cell").close() app.idle(session) serialized = json.dumps(provider.requests[-1]["request"]) self.assertIn("legacy image", serialized) self.assertIn(PNG, serialized) self.assertIn("legacy cell readable", serialized)
def test_saved_extra_low_efforts_become_minimal(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close)
def catalog(app): listed = { "fixture-cloud": { "api": provider.url, "models": { "fixture": { "id": "fixture", "reasoning_options": [ {"type": "effort", "values": ["minimal", "high"]} ], } }, } } (app.home / "models.json").write_text(json.dumps(listed)) app.write_extensions({"models": {"refreshHours": 0}})
with Albedo( provider, prepare=catalog, providers={ "fixture": { "extension": "openai", "baseUrl": provider.url, "apiKey": "fixture-key", "model": "fixture", "protocol": "responses", } }, ) as app: database = app.home / "albedo.sqlite" config_path = app.home / "config.json" session = app.session() app.patch_session(session, {"effort": "high"})
def legacy_layout(_app): # Antigravity named its lowest tier extra-low, and sessions and # profiles saved that name before efforts were typed. with sqlite3.connect(database) as db: db.execute( "UPDATE sessions SET effort='extra-low' WHERE id=?", (session,) ) db.execute("DELETE FROM migrations WHERE name='effort_names'") config = json.loads(config_path.read_text()) config["providers"]["fixture"]["effort"] = "extra-low" config_path.write_text(json.dumps(config))
app.restart(prepare=legacy_layout) with app.api(f"/sessions/{session}?view=configuration") as response: self.assertEqual(json.load(response)["effort"], "minimal") profile = json.loads(config_path.read_text())["providers"]["fixture"] self.assertEqual(profile["effort"], "minimal") app.prompt(session, "after the upgrade").close() app.idle(session) self.assertEqual( provider.requests[-1]["request"]["reasoning"]["effort"], "minimal" )
def test_session_preferences_import_once_without_removing_global_fields(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close) with Albedo(provider) as app: session = app.session() database = app.home / "albedo.sqlite" picker_path = app.home / "picker.json" caps_path = app.home / "capabilities.json" originals = {}
def prepare(_app): with sqlite3.connect(database) as db: db.execute("DELETE FROM session_preferences_import") for path in (picker_path, caps_path): originals[path] = ( json.loads(path.read_text()) if path.exists() else {} ) picker = { **originals[picker_path], "pinned": [session], "archived": [session], "opens": {session: 7}, } caps = { **originals[caps_path], "sessions": {session: {"skills": {"missing-legacy-skill": False}}}, } picker_path.write_text(json.dumps(picker)) caps_path.write_text(json.dumps(caps))
app.restart(prepare=prepare) with app.api(f"/sessions/{session}") as response: preferences = json.load(response)["preferences"] self.assertTrue(preferences["pinned"]) self.assertTrue(preferences["archived"]) self.assertEqual(preferences["opens"], 7) self.assertEqual( json.loads(picker_path.read_text()), originals[picker_path] ) self.assertEqual(json.loads(caps_path.read_text()), originals[caps_path])
def imported_state(): with sqlite3.connect(database) as db: self.assertEqual( db.execute( "SELECT version FROM session_preferences_import" ).fetchall(), [(1,)], ) return db.execute( "SELECT kind,preference_key,enabled FROM session_selection WHERE session=?", (session,), ).fetchall()
first = imported_state() self.assertEqual(first, [("skills", "missing-legacy-skill", 0)]) app.restart() self.assertEqual(imported_state(), first) with app.api(f"/sessions/{session}") as response: self.assertEqual(json.load(response)["preferences"], preferences)
def test_failed_preferences_import_keeps_legacy_files_for_retry(self): provider = Provider(lambda _request: text("done")) self.addCleanup(provider.close) with Albedo(provider) as app: session = app.session() database = app.home / "albedo.sqlite" picker_path = app.home / "picker.json" original = picker_path.read_bytes() if picker_path.exists() else b"{}" legacy = json.dumps({"pinned": [session], "opens": {session: 7}}).encode()
def prepare(_app): with sqlite3.connect(database) as db: db.execute("DELETE FROM session_preferences_import") db.execute( "CREATE TRIGGER reject_preference_import BEFORE UPDATE OF pinned ON sessions BEGIN SELECT RAISE(ABORT, 'import fixture failure'); END" ) picker_path.write_bytes(legacy)
def restore(_app): with sqlite3.connect(database) as db: db.execute("DROP TRIGGER IF EXISTS reject_preference_import") picker_path.write_bytes(original)
try: with self.assertRaises(AssertionError): app.restart(prepare=prepare) self.assertEqual(picker_path.read_bytes(), legacy) with sqlite3.connect(database) as db: self.assertEqual( db.execute( "SELECT version FROM session_preferences_import" ).fetchall(), [], ) self.assertEqual( db.execute( "SELECT pinned,opens FROM sessions WHERE id=?", (session,) ).fetchone(), (0, 0), ) finally: app.restart(prepare=restore)