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.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762"""Session setup, ingress failures, workspace repair, and image and file inspection."""
import base64import hashlibimport reimport jsonfrom pathlib import Pathimport sqlite3import timeimport urllib.errorimport urllib.parse
from harness import ( LOOPBACK_REMOTE, cell_result, exclusive, operation_id, python, text as reply,)
from image_limits_test import pngfrom integration_support import IntegrationScenario, contents
class IntegrationTest(IntegrationScenario): # exclusive: changes scheduler timing and installs a global database trigger @exclusive def test_scheduler_reports_a_failed_occurrence_write_and_retries(self): def prepare(app): app.env["ALBEDO_SCHEDULE_TICK_MS"] = "50"
app = self.app_for("chat_completions", prepare=prepare) session = app.session() with sqlite3.connect(app.home / "albedo.sqlite") as db: db.execute( "CREATE TRIGGER reject_advance BEFORE DELETE ON schedules " "BEGIN SELECT RAISE(FAIL, 'fixture advance failed'); END" ) db.execute( "INSERT INTO schedules(session,kind,prompt,next_at) VALUES(?,'once',?,0)", (session, "scheduled fixture"), ) deadline = time.monotonic() + 15 while "fixture advance failed" not in (app.home / "daemon.log").read_text(): self.assertLess(time.monotonic(), deadline) time.sleep(0.05) self.assertIn( "schedule occurrence not queued", (app.home / "daemon.log").read_text(), ) with sqlite3.connect(app.home / "albedo.sqlite") as db: self.assertEqual( db.execute("SELECT COUNT(*) FROM schedules").fetchone()[0], 1 ) # The prompt is stored with its advance, so a failed advance # queued nothing. self.assertEqual( db.execute( "SELECT COUNT(*) FROM mail WHERE recipient=?", (session,) ).fetchone()[0], 0, ) db.execute("DROP TRIGGER reject_advance") while True: with sqlite3.connect(app.home / "albedo.sqlite") as db: if db.execute("SELECT COUNT(*) FROM schedules").fetchone()[0] == 0: break self.assertLess(time.monotonic(), deadline) time.sleep(0.05) app.idle(session) self.assertTrue(self.provider.requests)
# exclusive: renames the global session_family table @exclusive def test_deletion_refuses_a_failed_child_lookup(self): app = self.app_for("chat_completions") session = app.session() with app.api(f"/sessions/{session}?view=configuration") as response: response.read() etag = response.headers["ETag"] family = app.family_revision(session) with sqlite3.connect(app.home / "albedo.sqlite") as db: db.execute("ALTER TABLE session_family RENAME TO unavailable_family") for scope in ("leaf", "subtree"): with self.subTest(scope=scope): with self.assertRaises(urllib.error.HTTPError) as caught: app.api( f"/sessions/{session}?view=configuration&scope={scope}" f"&family_revision={family}", method="DELETE", headers={"If-Match": etag}, ).close() self.assertGreaterEqual(caught.exception.code, 400) with sqlite3.connect(app.home / "albedo.sqlite") as db: self.assertIsNotNone( db.execute( "SELECT id FROM sessions WHERE id=?", (session,) ).fetchone() ) with sqlite3.connect(app.home / "albedo.sqlite") as db: db.execute("ALTER TABLE unavailable_family RENAME TO session_family") with app.api( f"/sessions/{session}?view=configuration&scope=subtree" f"&family_revision={family}", method="DELETE", headers={"If-Match": etag}, ) as response: self.assertEqual(json.load(response)["deleted_ids"], [session])
# exclusive: removes a legacy schema column and restarts the daemon @exclusive def test_uploaded_images_survive_upgrade_from_unclassified_transcripts(self): original = png(2, 3) probe = {"code": ""} observed = []
def script(request): if request["input"][-1].get("type") == "function_call_output": observed.append(cell_result(request["input"][-1]["output"])) return reply("image access checked") return ( python(probe["code"]) if probe["code"] else reply("stored before upgrade") )
self.provider.script = script app = self.app_for("responses") session = app.session() app.api( f"/sessions/{session}/inputs/{operation_id()}", { "kind": "message", "text": "keep this upload", "images": [ { "mime_type": "image/png", "data": base64.b64encode(original).decode(), } ], }, method="PUT", ).close() app.idle(session)
def legacy_layout(_app): with sqlite3.connect(app.home / "albedo.sqlite") as db: for name in ( "transcript_uploads", "transcript_users", "transcript_fits", "transcript_pending_class", ): db.execute(f"DROP INDEX IF EXISTS {name}") db.execute("ALTER TABLE transcript DROP COLUMN row_class")
app.restart(prepare=legacy_layout) probe["code"] = ( f"assert await files.image() == {original!r}\nprint('original upload survives schema upgrade')" )
def check_image(): app.prompt(session, "inspect the original upload").close() app.idle(session) self.assertEqual(observed[-1]["status"], "ok", observed[-1]) self.assertIn( "original upload survives schema upgrade", observed[-1]["output"] )
check_image() app.restart() check_image()
def test_uploaded_image_bytes_are_available_to_python_without_daemon_paths(self): originals = [png(2, 3), png(1200, 10)] probe = {"code": ""} observed = []
def script(request): if request["input"][-1].get("type") == "function_call_output": observed.append(cell_result(request["input"][-1]["output"])) return reply("image access checked") return python(probe["code"]) if probe["code"] else reply("noted")
self.provider.script = script profile = { "baseUrl": self.provider.url, "apiKey": "fixture-key", "model": "fixture-model", "protocol": "responses", } loose, strict = f"loose-{self.provider.route}", f"strict-{self.provider.route}" app = self.app_for( "responses", providers={loose: profile, strict: dict(profile, imageEdge=1000)}, ) session = app.session() probe["code"] = ( "import struct\n" f"assert await files.image() == {originals[0]!r}\n" f"assert await files.image(index=1) == {originals[1]!r}\n" "assert struct.unpack('>II', (await files.image(index=1))[16:24]) == (1200, 10)\n" "print('original image bytes verified')" ) app.api( f"/sessions/{session}/inputs/{operation_id()}", { "kind": "message", "text": "crop the uploaded image", "images": [ {"mime_type": "image/png", "data": base64.b64encode(data).decode()} for data in originals ], }, method="PUT", ).close() app.idle(session) history = self.history(app, session) self.assertEqual(observed[-1]["status"], "ok", observed[-1]) self.assertIn("original image bytes verified", observed[-1]["output"]) entry = next(row["position"] for row in history if row["kind"] == "user")
# A text-only message can mention the storage tag without hiding the # actual upload. Explicit entry lookup remains scoped to this session. other = app.session() probe["code"] = "print('another session has its own image')" app.api( f"/sessions/{other}/inputs/{operation_id()}", { "kind": "message", "text": "another session", "images": [ { "mime_type": "image/png", "data": base64.b64encode(png(6, 7)).decode(), } ], }, method="PUT", ).close() app.idle(other) foreign = next( row["position"] for row in self.history(app, other) if row["kind"] == "user" ) # Cross a history page, then switch to a provider that fits the earlier # image. Python must still receive its original 1200px bytes. probe["code"] = "" for turn in range(63): app.prompt(session, f"user_image is just prose; follow-up {turn}").close() app.idle(session) self.change( app, session, {"provider_profile": strict, "model": "fixture-model"} ) probe["code"] = ( f"assert await files.image(entry={entry}, index=1) == {originals[1]!r}\n" f"assert await files.image() == {originals[0]!r}\n" f"for entry_id, index in [({foreign}, 0), ({entry}, 2)]:\n" " try:\n" " await files.image(entry=entry_id, index=index)\n" " except FilesError as error:\n" " assert error.code == 'image_unavailable', str(error)\n" " else:\n" " raise AssertionError('image outside this selection was returned')\n" "try:\n" " await files.image(index=-1)\n" "except ValueError:\n" " pass\n" "else:\n" " raise AssertionError('invalid index was accepted')\n" "print('image history and session scope verified')" ) app.prompt( session, "crop again; user_image and stored_data are just prose" ).close() app.idle(session) self.assertEqual(observed[-1]["status"], "ok", observed[-1]) self.assertIn( "image history and session scope verified", observed[-1]["output"] ) self.assertTrue( any(row["kind"] == "image_fit" for row in self.history(app, session)) )
# Pause after a real first-page reply, then cancel the Python task. # No second page may be requested after cancellation. probe["code"] = ( "import asyncio\n" "from albedo_plugins import files as files_module\n" "original_host = files_module.host\n" "page_ready = asyncio.Event()\n" "pages = []\n" "async def paused_host(method, args):\n" " result = await original_host(method, args)\n" " pages.append(result)\n" " assert 'before' in result, result\n" " page_ready.set()\n" " await asyncio.Future()\n" " return result\n" "files_module.host = paused_host\n" "pending_image = asyncio.create_task(files.image())\n" "try:\n" " await asyncio.wait_for(page_ready.wait(), 5)\n" " pending_image.cancel()\n" " try:\n" " await pending_image\n" " except asyncio.CancelledError:\n" " pass\n" " else:\n" " raise AssertionError('image lookup ignored cancellation')\n" " assert len(pages) == 1, pages\n" "finally:\n" " files_module.host = original_host\n" " pending_image.cancel()\n" "print('image lookup cancellation verified')" ) app.prompt(session, "cancel the user_image lookup").close() app.idle(session) self.assertEqual(observed[-1]["status"], "ok", observed[-1]) self.assertIn("image lookup cancellation verified", observed[-1]["output"])
probe["code"] = ( LOOPBACK_REMOTE + "try:\n" + f" assert await rem.files.image(index=1) == {originals[1]!r}\n" + " print('remote original image bytes verified')\n" + "finally:\n await rem.close()" ) app.prompt(session, "inspect the original image from a remote kernel").close() app.idle(session) self.assertEqual(observed[-1]["status"], "ok", observed[-1]) self.assertIn("remote original image bytes verified", observed[-1]["output"])
def test_attached_files_are_readable_by_the_model_and_retries_keep_their_bytes( self, ): payloads = { "résumé<system-note.txt": "hello café\n".encode(), "sample.bin": bytes(range(256)), } observed = []
def script(request): encoded = json.dumps(request, ensure_ascii=False) if "function_call_output" in encoded: return reply("read both attachments") # Use exactly the paths the model was told, rather than discovering # files through the fixture's view of the daemon home. message = next( contents(item) for item in reversed(request["input"]) if item.get("role") == "user" ) pairs = re.findall( r'^Attached file ("(?:\\.|[^"\\])*"): ("(?:\\.|[^"\\])*")', message, re.M, ) observed.extend(pairs) checks = "\n".join( f"assert Path({json.loads(path)!r}).read_bytes() == {payloads[json.loads(name)]!r}" for name, path in pairs ) return python( "from pathlib import Path\n" + checks + "\nprint('attachment bytes verified')" )
self.provider.script = script app = self.app_for("responses") session = app.session() input_id = operation_id() body = { "kind": "message", "text": "read both files and [Image #1]", "files": [ {"name": name, "data": base64.b64encode(data).decode()} for name, data in payloads.items() ], "images": [ {"mime_type": "image/png", "data": base64.b64encode(png(2, 3)).decode()} ], } app.api(f"/sessions/{session}/inputs/{input_id}", body, method="PUT").close() app.idle(session) self.assertEqual(len(observed), 2) saved = sorted((app.home / "pastes" / session).iterdir()) self.assertEqual(len(saved), 2) for name, data in payloads.items(): digest = hashlib.sha256(data).hexdigest().upper() self.assertEqual( ( app.home / "pastes" / session / f"{input_id}-{digest}{Path(name).suffix}" ).read_bytes(), data, ) history = self.history(app, session) self.assertTrue( any("attachment bytes verified" in json.dumps(entry) for entry in history) ) user = next(entry for entry in history if entry["kind"] == "user") self.assertEqual(self.entry_text(user), body["text"]) self.assertEqual( user["files"], [{"name": name, "size": len(data)} for name, data in payloads.items()], ) self.assertNotIn(str(app.home), json.dumps(user)) with app.api(f"/sessions/{session}?tail=0") as response: named = json.load(response) self.assertNotIn("Attached file", named["automatic_name"]) self.assertNotIn(str(app.home), named["automatic_name"]) self.assertEqual(named["preview"]["text"].strip(), body["text"]) requests = len(self.provider.requests) app.api(f"/sessions/{session}/inputs/{input_id}", body, method="PUT").close() self.assertEqual(len(self.provider.requests), requests) self.assertEqual(sorted((app.home / "pastes" / session).iterdir()), saved) changed = {**body, "files": [{"name": "sample.bin", "data": "eA=="}]} with self.assertRaises(urllib.error.HTTPError) as caught: app.api(f"/sessions/{session}/inputs/{input_id}", changed, method="PUT") self.assertEqual(caught.exception.code, 409) self.assertEqual(sorted((app.home / "pastes" / session).iterdir()), saved)
def test_maximum_image_and_file_budgets_reach_input_admission(self): # A missing session avoids a 70 MiB model turn while proving that a # legal combined payload reaches admission rather than the body cap. app = self.app_for("responses") image = png(1, 1, b"x" * (5 * 1024 * 1024 - len(png(1, 1)) - 12)) encoded_image = base64.b64encode(image).decode() body = { "kind": "message", "text": "read these attachments", "images": [{"mime_type": "image/png", "data": encoded_image}] * 10, "files": [ { "name": "large.bin", "data": base64.b64encode(b"x" * (20 * 1024 * 1024)).decode(), } ], } with self.assertRaises(urllib.error.HTTPError) as caught: app.api( f"/sessions/{operation_id()}/inputs/{operation_id()}", body, method="PUT", ) self.assertEqual(caught.exception.code, 404)
def test_a_file_only_message_preserves_empty_file_bytes(self): self.provider.script = lambda _: reply("received the empty file") app = self.app_for("responses") session = app.session() input_id = operation_id() start = len(self.provider.requests) with app.api( f"/sessions/{session}/inputs/{input_id}", {"kind": "message", "text": "", "files": [{"name": "LICENSE", "data": ""}]}, method="PUT", ) as response: self.assertEqual(response.status, 202) app.idle(session) digest = hashlib.sha256(b"").hexdigest().upper() saved = app.home / "pastes" / session / f"{input_id}-{digest}" self.assertEqual(saved.read_bytes(), b"") request = json.dumps(self.records(start)[0]["request"]) self.assertIn(str(saved), request) self.assertIn("LICENSE", request) user = next(e for e in self.history(app, session) if e["kind"] == "user") self.assertEqual(self.entry_text(user), "") self.assertEqual(user["files"], [{"name": "LICENSE", "size": 0}])
def test_file_labels_in_prose_are_text_not_attachments(self): self.provider.script = lambda _: reply("read the label") app = self.app_for("responses") session = app.session() text = "Explain [File #1: example.txt]" app.prompt(session, text).close() app.idle(session) user = next(e for e in self.history(app, session) if e["kind"] == "user") self.assertEqual(self.entry_text(user), text) self.assertNotIn("files", user)
def test_pastes_and_files_expand_without_reinterpreting_the_uploaded_filename(self): self.provider.script = lambda _: reply("received both attachments") app = self.app_for("responses") session = app.session() input_id = operation_id() start = len(self.provider.requests) pasted = "\n".join(f"context line {n}" for n in range(150)) name = "[Paste #1].txt" data = b"the attached file" app.api( f"/sessions/{session}/inputs/{input_id}", { "kind": "message", "text": "read [Paste #1, +150 lines] please", "pastes": [pasted], "files": [{"name": name, "data": base64.b64encode(data).decode()}], }, method="PUT", ).close() app.idle(session) paste_path = app.home / "pastes" / session / f"{input_id}-1.md" digest = hashlib.sha256(data).hexdigest().upper() file_path = app.home / "pastes" / session / f"{input_id}-{digest}.txt" self.assertEqual(paste_path.read_text(), pasted) self.assertEqual(file_path.read_bytes(), data) model_text = next( contents(item) for item in self.records(start)[0]["request"]["input"] if item.get("role") == "user" ) self.assertIn(str(paste_path), model_text) self.assertIn( f"Attached file {json.dumps(name)}: {json.dumps(str(file_path))}", model_text, )
def test_invalid_file_attachments_are_rejected_before_any_file_is_saved(self): app = self.app_for("responses") session = app.session() good = {"name": "good.txt", "data": "aGVsbG8="} invalid = [ [good, {"name": "../escape", "data": "eA=="}], [good, {"name": "folder\\file.txt", "data": "eA=="}], [good, {"name": "line\nfeed.txt", "data": "eA=="}], [good, {"name": "nul\x00file", "data": "eA=="}], [good, {"name": "é" * 128, "data": "eA=="}], [good, {"name": "bad.bin", "data": "!not base64!"}], [good] * 11, [ { "name": "too-big.bin", "data": base64.b64encode(b"x" * (20 * 1024 * 1024 + 1)).decode(), } ], ] pasted = "\n".join(f"context line {n}" for n in range(150)) for files in invalid: with self.subTest(name=files[-1]["name"], count=len(files)): with self.assertRaises(urllib.error.HTTPError) as caught: app.api( f"/sessions/{session}/inputs/{operation_id()}", { "kind": "message", # A long paste would be saved; rejected files # must stop the input before that write. "text": "inspect [Paste #1, +150 lines]", "pastes": [pasted], "files": files, }, method="PUT", ) self.assertEqual( caught.exception.code, 413 if files[-1]["name"] == "too-big.bin" else 400, ) self.assertFalse((app.home / "pastes" / session).exists())
def test_image_metadata_is_verified_and_only_metadata_is_exposed(self): for protocol in ("responses", "chat_completions"): with self.subTest(protocol=protocol): app = self.app_for(protocol) session = app.session() png = "iVBORw0KGgoAAAANSUhEUgAAAAIAAAADCAIAAAA2iEnWAAAAAElFTkSuQmCC" with self.assertRaises(urllib.error.HTTPError) as caught: app.api( f"/sessions/{session}/inputs/{operation_id()}", { "kind": "message", "text": "reject this", "images": [ {"mime_type": "image/png", "data": "not base64"} ], }, method="PUT", ).close() self.assertEqual(caught.exception.code, 400) start = len(self.provider.requests) app.api( f"/sessions/{session}/inputs/{operation_id()}", { "kind": "message", "text": "describe this image", "images": [{"mime_type": "image/png", "data": png}], }, method="PUT", ).close() app.idle(session) self.send(app, session, "confirm image history") requests = self.records(start) self.assertEqual(len(requests), 3) self.assertTrue( all( "data:image/png;base64," + png in json.dumps(r["request"]) for r in requests ) ) image = next( part["image"] for e in self.history(app, session) for part in e["content"] if part["kind"] == "image" ) self.assertEqual( ( image["mime_type"], image["width"], image["height"], image["original_bytes"], ), ("image/png", 2, 3, 45), ) self.assertNotIn(png, json.dumps(image))
def test_message_images_follow_their_text_in_attachment_order(self): app = self.app_for("responses") session = app.session() first, second = ( base64.b64encode(png(width, height)).decode() for width, height in ((2, 3), (4, 5)) ) upload = [ {"mime_type": "image/png", "data": first}, {"mime_type": "image/png", "data": second}, ] with self.assertRaises(urllib.error.HTTPError) as caught: app.api( f"/sessions/{session}/inputs/{operation_id()}", {"kind": "message", "text": "too many", "images": upload * 6}, method="PUT", ).close() self.assertEqual(caught.exception.code, 400) start = len(self.provider.requests) text = "[Image #1] is before, then I wrote this, and [Image #2] is after" app.api( f"/sessions/{session}/inputs/{operation_id()}", {"kind": "message", "text": text, "images": upload}, method="PUT", ).close() app.idle(session) request = json.dumps(self.records(start)[0]["request"]) positions = [ request.index(needle) for needle in (text, "base64," + first, "base64," + second) ] self.assertEqual(positions, sorted(positions)) user = next(e for e in self.history(app, session) if e["kind"] == "user") self.assertEqual(self.entry_text(user), text) self.assertEqual( [ (part["image"]["width"], part["image"]["height"]) for part in user["content"] if part["kind"] == "image" ], [(2, 3), (4, 5)], )
def test_short_pastes_are_inlined_and_long_ones_saved_for_the_model(self): app = self.app_for("responses") session = app.session() short = "\n".join(f"short line {n}" for n in range(20)) long = "\n".join(f"long line {n}" for n in range(150)) text = "read [Paste #1, +20 lines] and then [Paste #2, +150 lines] please" start = len(self.provider.requests) input_id = operation_id() app.api( f"/sessions/{session}/inputs/{input_id}", {"kind": "message", "text": text, "pastes": [short, long]}, method="PUT", ).close() app.idle(session) saved = app.home / "pastes" / session / f"{input_id}-2.md" self.assertEqual(saved.read_text(), long) request = json.dumps(self.records(start)[0]["request"]) sent = f"read {short} and then [Paste #2, 150 lines, saved to {saved}] please" self.assertIn(json.dumps(sent)[1:-1], request) user = next(e for e in self.history(app, session) if e["kind"] == "user") self.assertEqual(self.entry_text(user), text)
def test_busy_messages_join_next_model_request_in_order(self): app = self.app_for("responses") session = app.session() start = len(self.provider.requests) app.prompt(session, "first task").close() self.wait_for_request(start) app.prompt(session, "queued direction").close() app.prompt(session, "another direction").close() app.idle(session) requests = self.records(start) self.assertEqual(len(requests), 2) first, second = (json.dumps(r["request"]) for r in requests) self.assertNotIn("queued direction", first) self.assertIn("queued direction", second) self.assertIn("another direction", second) self.assertLess( second.index("queued direction"), second.index("another direction") ) self.assertTrue( any( e["kind"] == "user" and self.entry_text(e) == "queued direction" for e in self.history(app, session) ) )
# exclusive: restarts the daemon @exclusive def test_workspace_repair_validates_path_and_preserves_history(self): app = self.app_for("responses") old = app.root / "original-workspace" old.mkdir() moved = app.root / "moved-workspace" session = app.session(old) self.send(app, session, "workspace probe before move") self.assertEqual(Path((old / "cwd-probe").read_text()).resolve(), old.resolve()) old.rename(moved) pid = app.connection["pid"] before = self.history(app, session) identity = operation_id() app.api( f"/sessions/{session}/inputs/{identity}", {"kind": "message", "text": "workspace probe after move"}, method="PUT", ).close() receipt = self.read(app, f"/sessions/{session}/inputs/{identity}") self.assertEqual(receipt["delivery"], "pending") for invalid in ("relative", str(old), str(moved / "cwd-probe")): with self.assertRaises(urllib.error.HTTPError) as caught: self.change(app, session, {"workspace": invalid}) self.assertIn(caught.exception.code, (400, 409)) self.change(app, session, {"workspace": str(moved)}) self.assertEqual( self.read(app, f"/sessions/{session}")["workspace"], str(moved) ) self.assertEqual(json.loads((app.home / "daemon.json").read_text())["pid"], pid) app.idle(session, timeout=35) receipt = self.read(app, f"/sessions/{session}/inputs/{identity}") self.assertEqual(receipt["delivery"], "committed") self.assertEqual( Path((moved / "cwd-probe").read_text()).resolve(), moved.resolve() ) self.assertFalse(old.exists()) after = self.history(app, session) self.assertEqual( [e for e in before if e["kind"] == "user"], [e for e in after if e["kind"] == "user"][:-1], ) with sqlite3.connect(app.home / "albedo.sqlite") as db: self.assertEqual( db.execute( "SELECT cwd FROM sessions WHERE id=?", (session,) ).fetchone()[0], str(moved), ) self.restart(app) self.assertEqual( self.read(app, f"/sessions/{session}")["workspace"], str(moved) )