// Real account credentials, SQLite persistence and request lifecycle. Only the // HTTP transport is synthetic; server access rules have separate HTTP tests. #import, file "../src/apps/lists_network.zi"; #import, file "../src/apps/lists_command.zi"; #import, file "../src/apps/lists_types.zi"; #import, file "../src/apps/lists_ui_types.zi"; #import, file "../src/storage/lists_shared_storage.zi"; #import, file "../src/storage/storage_elist.zi"; #import, file "../src/storage/sync_state.zi"; #import, file "../src/storage/storage_settings.zi"; #import, file "../src/storage/sync_account.zi"; #import, file "../src/storage/account_types.zi"; #import, file "../src/storage/sync_async.zi"; #import, file "../src/storage/db.zi"; #import, file "../src/app/app_types.zi"; #import, file "../src/app/text_buffers.zi"; #import, file "../src/screens/elist_types.zi"; #import, file "../src/apps/package_files.zi"; #import, file "../apps/lists/sharing.zi"; #import, file "../apps/lists/task_title.zi"; #import, file "storage_test_support.zi"; #import "keys" #import "async_client" #import "net_http" #import "wire" #import "transaction" #import "text_buffer" #import "json_scan" #import "vec" c :: #system_library "c"; Now :: (out: *s64) -> s64 #foreign c "time"; account: AccountKeys; app: InnerBreeze; status_code: s32 = 200; accepted: bool; calls: s32; last_body: [262144]u8; sender :: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ContainsBytes :: (value: string, needle: string) -> bool { if needle.count == 0 { return true } if needle.count > value.count { return false } start := 0 while start <= value.count - needle.count { index := 0 same := true while index < needle.count { if value[start + index] != needle[index] { same = false break } index += 1 } if same { return true } start += 1 } return false } Reply :: (output: []u8) -> bool { writer := Writer.{output, 0, true} writer = WriteText(writer, "{\"lists\":[") if accepted { // Shared lists have UUID ids; other apps' shared records are not lists. writer = WriteText(writer, "{\"id\":\"5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6\",\"owner\":\"") writer = WriteText(writer, sender) writer = WriteText(writer, "\",\"title\":\"Weekend\",\"revision\":1,\"items\":[{\"id\":\"shared-task\",\"title\":\"Pack bag\",\"comment\":\"For Saturday\",\"done\":0}]}") } writer = WriteText(writer, "],\"invitations\":[") if !accepted { writer = WriteText(writer, "{\"id\":\"invitation-1\",\"list_id\":\"5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6\",\"owner\":\"") writer = WriteText(writer, sender) writer = WriteText(writer, "\",\"target\":\"") writer = WriteText(writer, TextUntilNul(account.public_id[:])) writer = WriteText(writer, "\",\"title\":\"Weekend\",\"alias\":\"alice\",\"status\":\"pending\"}") } // The node ends every JSON reply with a newline. writer = WriteText(writer, "]}\n") return writer.valid } FakeStart :: (context: *void, request: HttpRequest, output: []u8) -> bool { unused context challenge := "https://lists.test/api/v1/sync/challenge?user_id=" if request.url.count == challenge.count + 64 && request.url[:challenge.count] == challenge { return AppCopyText("{\"nonce\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}", output) } if request.url == "https://lists.test/api/v1/sync/login" { writer := Writer.{output, 0, true} writer = WriteText(writer, "{\"auth_token\":\"synthetic-lists-token\",\"expires_in_seconds\":3600,\"server_time\":") writer = WriteDecimal(writer, Now(null)) writer = WriteText(writer, "}") return writer.valid } check_true("Lists uses only its endpoint", request.url == "https://lists.test/api/v1/lists") calls += 1 unused AppCopyText(request.body, last_body[:]) return Reply(output) } FakePoll :: (context: *void, status: *s32) -> s32 { unused context status.* = ifx lists_operation.request.stage == 3 then status_code else 200 return 1 } FakeCancel :: (context: *void) { unused context } #program_export ListsTestTransport :: () -> AsyncTransport { return AsyncTransport.{null, FakeStart, FakePoll, FakeCancel} } Finish :: () { for step: cast(s32)0..39 { ListsNetworkTick(*app, 2.0, false) if !ListsNetworkBusy() { return } } check_true("Lists request completes", false) } #program_export Check :: () -> s32 { check_true("fixture transport ready", ListsTestTransport().start != null) check_int("todo.txt priority is recognized", ListsPriorityForTitle("(B) Pack @home +trip due:2026-11-10"), 2) check_true("todo.txt metadata stays in the task", ListsTitleWithoutPriority("(B) Pack @home +trip due:2026-11-10") == "Pack @home +trip due:2026-11-10") check_true("priority can be removed", ListsTitleForPriority("(A) Pack", 0) == "Pack") check_true("priority is canonicalized", ListsTitleForPriority("Pack", 2) == "(B) Pack") check_int("lowercase text is not a priority", ListsPriorityForTitle("(a) Pack"), 0) long_title: [32765]u8 for index: cast(s32)0..32762 { long_title[index] = cast(u8)#char "x" } long_title[32763] = cast(u8)0 check_true("a priority fits at the saved title limit", ListsTitlePriorityFits(TextUntilNul(long_title[:]), 1, LISTS_TEXT_LIMIT)) long_title[32763] = cast(u8)#char "x" long_title[32764] = cast(u8)0 check_true("a priority cannot exceed the saved title limit", !ListsTitlePriorityFits(TextUntilNul(long_title[:]), 1, LISTS_TEXT_LIMIT)) guard := support_begin("/tmp/inbe-lists-test/") if guard != 0 { return guard } check_true("database opens", storage_init("/tmp/inbe-lists-test/data") != 0) ListsNetworkTick(*app, 1.0, true) check_int("offline never requests", calls, 0) check_true("account created", CreateAccountKeys(*account) != 0) check_true("account saved", sync_account_save(*account, cast(SyncAccountLocalDataChoice)SyncAccountLocalDataChoice.SYNC_ACCOUNT_LOCAL_DATA_MERGE) == cast(SyncAccountSaveResult)SyncAccountSaveResult.SYNC_ACCOUNT_SAVE_OK) storage_set_setting_text("sync_server_url", "https://lists.test") storage_set_sync_enabled(1) ListsNetworkTick(*app, 1.0, true) Finish() check_int("authenticated refresh completes", lists_operation.result, 0) check_int("one refresh", calls, 1) cache := ListsSharedCache() check_int("pending invitation is cached", ArrayCount(cache, FieldAt(cache, 0, "invitations")), 1) check_int("no shared content before acceptance", ArrayCount(cache, FieldAt(cache, 0, "lists")), 0) message := ListsMessage.{.action = LISTS_ACCEPT} frame := ListsUiFrame.{.next_id = "accept-request"} list := ListsUiRow.{.id = "5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6", .title = "Weekend", .revision = 1} rows: [2]ListsUiRow rows[0] = ListsUiRow.{.id = "shared-task", .parent_id = "5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6", .title = "Pack bag", .comment = "For Saturday"} rows[1] = ListsUiRow.{.id = "private-task", .parent_id = "private-list", .title = "Private"} message.request_body = ListsBuildCommand(message, frame, list, rows[:], "", "invitation-1") accepted = true ListsNetworkStart(message) Finish() check_true("confirmed acceptance clears its attempt", !ListsNetworkPending()) check_true("shared records load with private records", storage_elist_load(cast(*void)*app.elist) != 0) found: bool for index: cast(s32)0..app.elist.list_count - 1 { if AppTextFromCString(*app.elist.lists[index].id[0], 37) == "5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6" { found = app.elist.lists[index].shared && !app.elist.lists[index].owner && !app.elist.lists[index].incomplete } } check_true("accepted list is a complete collaborator observation", found) check_true("shared content is not a private DB copy", read_db_count("SELECT COUNT(*) FROM elist_lists WHERE id='5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6'") == 0) check_true("old private projection fixture", elist_exec_sql("INSERT INTO elist_lists(id,user_id,title,sort_order,deleted_at,updated_at) SELECT '5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6',id,'Original',9,0,1 FROM users LIMIT 1") != 0) check_true("old private item fixture", elist_exec_sql("INSERT INTO elist_items(id,user_id,list_id,title,comment,done,sort_order,deleted_at,updated_at) SELECT 'old-task',id,'5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6','Original task','',0,0,0,1 FROM users LIMIT 1") != 0) check_int("private writer cannot rename a shared projection", storage_elist_update_list("5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6", "Stale rename", 0), 0) check_int("private writer cannot add to a shared projection", storage_elist_create_item("5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6", "Stale task", "", null), 0) check_int("private writer cannot edit a shared projection", storage_elist_update_item("old-task", "Stale task", "", 1, 0), 0) check_int("private writer cannot delete a shared item", storage_elist_delete_item("old-task"), 0) check_int("private writer cannot delete a shared list", storage_elist_delete_list("5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6"), 0) frame.next_id = "save-request" frame.value = "A \"quoted\" task\n二" message.action = LISTS_COMMIT message.editing_item = 0 message.title = frame.value message.comment = "Bring snacks and chargers" message.request_body = ListsBuildCommand(message, frame, list, rows[:]) json := message.request_body check_true("serializer produces complete JSON", ValueEnd(json, 0, 0) == cast(s32)json.count) document := FieldAt(json, 0, "list") items := FieldAt(json, document, "items") check_int("other private list stays out of sharing", ArrayCount(json, items), 1) value: [128]u8 unused ReadStringText(json, FieldAt(json, ElementAt(json, items, 0), "title"), value[:]) check_true("quoted Unicode text round trips", TextUntilNul(value[:]) == frame.value) unused ReadStringText(json, FieldAt(json, ElementAt(json, items, 0), "comment"), value[:]) check_true("shared edits carry the description", TextUntilNul(value[:]) == message.comment) long_document: Vec(u8) BuilderPrint(*long_document, "{\"request_id\":\"large-request\",\"padding\":\"") for index: cast(s32)0..11999 { BuilderPrint(*long_document, "x") } BuilderPrint(*long_document, "\"}") long_json := BuilderFinish(long_document) check_true("large collaboration cache saves", ListsCacheWrite("lists.cache-test", long_json) != 0) long_copy: [16384]u8 check_true("large collaboration cache is not truncated at 8 KB", ListsCacheRead("lists.cache-test", *long_copy[0], 16384) != 0 && TextUntilNul(long_copy[:]) == long_json) PackageFree(long_json) unused AppCopyText("Keep my draft", app.elist.input[:]) status_code = 503 ListsNetworkStart(message) Finish() check_true("uncertain save is retained", ListsNetworkPending()) check_true("failure retains the draft", AppTextFromCString(*app.elist.input[0], ELIST_TITLE_SIZE) == "Keep my draft") attempt: [262144]u8 = lists_attempt lists_identity[0] = cast(u8)0 ListsNetworkContext() check_true("uncertain request survives restart", TextUntilNul(attempt[:]) == TextUntilNul(lists_attempt[:])) ListsNetworkTick(*app, 2.0, false) unused AppCopyText("Keep my draft", app.elist.input[:]) retry := ListsMessage.{.action = LISTS_RETRY} ListsNetworkStart(retry) Finish() check_true("retry sends the original request", TextUntilNul(last_body[:]) == TextUntilNul(attempt[:])) check_true("failure retains the draft", AppTextFromCString(*app.elist.input[0], ELIST_TITLE_SIZE) == "Keep my draft") status_code = 409 ListsNetworkStart(retry) Finish() check_true("definite conflict clears the attempt", !ListsNetworkPending() && lists_status == 4) check_true("conflict preserves the draft", AppTextFromCString(*app.elist.input[0], ELIST_TITLE_SIZE) == "Keep my draft") // A failed refresh keeps the confirmed lists and says nothing. status_code = 503 lists_status = 0 ListsNetworkStart(ListsMessage.{.action = LISTS_REFRESH}) Finish() check_true("a failed refresh stays silent", lists_status == 0 && !ListsNetworkPending()) // An uncertain change goes again by itself; only repeated failures ask. frame.next_id = "quiet-request" message.request_body = ListsBuildCommand(message, frame, list, rows[:]) before := calls ListsNetworkStart(message) Finish() check_true("a first failure is quiet", ListsNetworkPending() && lists_status == 1 && !ListsNetworkNeedsRetry()) ListsNetworkTick(*app, 4.0, false) check_true("a quiet retry waits first", !ListsNetworkBusy() && calls == before + 1) ListsNetworkTick(*app, 100.0, false) Finish() ListsNetworkTick(*app, 100.0, false) Finish() check_int("each quiet retry sends the same change", calls, before + 3) check_true("repeated failures ask for Retry", ListsNetworkNeedsRetry() && lists_status == 1) status_code = 200 ListsNetworkTick(*app, 200.0, false) Finish() check_true("a later retry confirms the change", !ListsNetworkPending() && lists_status == 2 && !ListsNetworkNeedsRetry()) // A change made while a refresh is on its way follows it. ListsNetworkStart(ListsMessage.{.action = LISTS_REFRESH}) frame.next_id = "follow-request" message.request_body = ListsBuildCommand(message, frame, list, rows[:]) ListsNetworkStart(message) check_true("a change during a refresh waits for it", ListsNetworkPending() && lists_status == 1) Finish() check_true("the waiting change is sent after the refresh", !ListsNetworkPending() && lists_status == 2) // Each device seeds the same starter Inbox, so syncing devices share one. check_int("the starter Inbox has the shared ID", read_db_count( "SELECT COUNT(*) FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001' AND updated_at=1 AND deleted_at=0"), 1) check_int("the starter tasks have shared IDs", read_db_count( "SELECT COUNT(*) FROM elist_items WHERE list_id='00000000-0000-4000-8000-00000000a001' AND updated_at=1"), 3) // A copy an older version seeded on another device goes once synced here. check_true("another device's starter Inbox", elist_exec_sql("INSERT INTO elist_lists(id,user_id,title,sort_order,deleted_at,updated_at) SELECT 'other-starter',user_id,title,5,0,99 FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001'") != 0) check_true("its starter tasks", elist_exec_sql("INSERT INTO elist_items(id,user_id,list_id,title,comment,done,sort_order,deleted_at,updated_at) SELECT 'other-'||sort_order,user_id,'other-starter',title,'',0,sort_order,0,99 FROM elist_items WHERE list_id='00000000-0000-4000-8000-00000000a001'") != 0) check_true("lists reload", storage_elist_load(cast(*void)*app.elist) != 0) check_int("one starter Inbox remains", read_db_count( "SELECT COUNT(*) FROM elist_lists WHERE id IN ('other-starter','00000000-0000-4000-8000-00000000a001') AND deleted_at=0"), 1) check_int("the shared starter is the one kept", read_db_count( "SELECT COUNT(*) FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001' AND deleted_at=0"), 1) // A copy whose starter tasks are still arriving is not mistaken for a used // Inbox, so every device keeps the same one and never removes them all. check_true("a copy still syncing", elist_exec_sql("INSERT INTO elist_lists(id,user_id,title,sort_order,deleted_at,updated_at) SELECT 'partial-starter',user_id,title,0,0,1 FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001'") != 0) check_true("with part of its tasks", elist_exec_sql("INSERT INTO elist_items(id,user_id,list_id,title,comment,done,sort_order,deleted_at,updated_at) SELECT 'partial-'||sort_order,user_id,'partial-starter',title,'',0,sort_order,0,1 FROM elist_items WHERE list_id='00000000-0000-4000-8000-00000000a001' AND sort_order<2") != 0) check_true("lists reload with the partial copy", storage_elist_load(cast(*void)*app.elist) != 0) check_int("the shared starter stays beside a partial copy", read_db_count( "SELECT COUNT(*) FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001' AND deleted_at=0"), 1) check_int("the partial copy waits for its tasks", read_db_count( "SELECT COUNT(*) FROM elist_lists WHERE id='partial-starter' AND deleted_at=0"), 1) check_true("the partial copy leaves", elist_exec_sql("UPDATE elist_lists SET deleted_at=2 WHERE id='partial-starter'") != 0) // A used Inbox is never removed; an untouched starter beside it is. check_true("a used Inbox", elist_exec_sql("INSERT INTO elist_lists(id,user_id,title,sort_order,deleted_at,updated_at) SELECT 'used-inbox',user_id,title,6,0,100 FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001'") != 0) check_true("with its own task", elist_exec_sql("INSERT INTO elist_items(id,user_id,list_id,title,comment,done,sort_order,deleted_at,updated_at) SELECT 'used-task',user_id,'used-inbox','Call mum','',0,0,0,100 FROM elist_lists WHERE id='used-inbox'") != 0) check_true("lists reload again", storage_elist_load(cast(*void)*app.elist) != 0) check_int("the used Inbox stays", read_db_count("SELECT COUNT(*) FROM elist_lists WHERE id='used-inbox' AND deleted_at=0"), 1) check_int("the untouched starter beside it goes", read_db_count( "SELECT COUNT(*) FROM elist_lists WHERE id='00000000-0000-4000-8000-00000000a001' AND deleted_at=0"), 0) ListsNetworkStart(ListsMessage.{.action = LISTS_REFRESH}) storage_set_setting_text("sync_server_url", "https://different.test") ListsNetworkTick(*app, 3.0, false) check_true("server switch cancels old delivery", !ListsNetworkBusy()) check_true("server switch hides the old cache", ListsSharedCache() == "{\"lists\":[],\"invitations\":[]}") check_int("server switch clears old visible rows", app.elist.list_count, 0) // A bounded screen must not turn a save into a replacement by its visible subset. storage_set_setting_text("sync_server_url", "https://lists.test") snapshot: Vec(u8) BuilderPrint(*snapshot, "{\"lists\":[{\"id\":\"5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6\",\"title\":\"Weekend\",\"revision\":7,\"owner\":\"%\",\"items\":[", sender) for index: cast(s32)0..299 { if index > 0 { BuilderPrint(*snapshot, ",") } BuilderPrint(*snapshot, "{\"id\":\"task-%\",\"title\":\"Task %\",\"comment\":\"Keep every comment\",\"done\":0}", index, index) } BuilderPrint(*snapshot, "]}],\"invitations\":[]}") snapshot_text := BuilderFinish(snapshot) check_true("large shared snapshot is stored", ListsCacheWrite("lists.shared", snapshot_text) != 0) PackageFree(snapshot_text) check_int("large shared snapshot loads", storage_elist_load(cast(*void)*app.elist), 1) selected: s32 = -1 editing: s32 = -1 for index: cast(s32)0..app.elist.list_count - 1 { if TextUntilNul(app.elist.lists[index].id[:]) == "5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6" { selected = index } } for index: cast(s32)0..app.elist.item_count - 1 { if TextUntilNul(app.elist.items[index].id[:]) == "task-0" { editing = index } } check_true("large document exceeds the screen projection", selected >= 0 && editing >= 0 && app.elist.lists[selected].incomplete) request := ListsUiRequest.{.action = LISTS_COMMIT, .editing_item = editing, .selected_list = selected, .value = "Updated first task", .next_id = "complete-save", .comment = "Updated first description", .list_id = "5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6"} complete := ListsPrepareCommand(*app.elist, request) check_int("editing a partial screen preserves all 300 tasks", ArrayCount(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items")), 300) unused ReadStringText(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "title"), value[:]) check_true("shared editing preserves the list title", TextUntilNul(value[:]) == "Weekend") complete_items := FieldAt(complete, FieldAt(complete, 0, "list"), "items") edited_item: s32 = -1 for item_index: cast(s32)0..ArrayCount(complete, complete_items) - 1 { unused ReadStringText(complete, FieldAt(complete, ElementAt(complete, complete_items, item_index), "id"), value[:]) if TextUntilNul(value[:]) == "task-0" { edited_item = item_index } } check_true("the edited full-document row is found", edited_item >= 0) unused ReadStringText(complete, FieldAt(complete, ElementAt(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items"), edited_item), "title"), value[:]) check_true("shared editing carries the task title", TextUntilNul(value[:]) == request.value) unused ReadStringText(complete, FieldAt(complete, ElementAt(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items"), edited_item), "comment"), value[:]) check_true("shared editing carries the description", TextUntilNul(value[:]) == request.comment) check_true("the hidden final task and its comment survive", ContainsBytes(complete, "task-299") && ContainsBytes(complete, "Keep every comment")) PackageFree(complete) request.editing_item = -1 request.value = "New complete task" request.comment = "New complete description" complete = ListsPrepareCommand(*app.elist, request) check_int("shared creation preserves all 300 tasks", ArrayCount(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items")), 301) unused ReadStringText(complete, FieldAt(complete, ElementAt(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items"), 300), "title"), value[:]) check_true("shared creation carries the task title", TextUntilNul(value[:]) == request.value) unused ReadStringText(complete, FieldAt(complete, ElementAt(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items"), 300), "comment"), value[:]) check_true("shared creation carries the description", TextUntilNul(value[:]) == request.comment) PackageFree(complete) request.action = LISTS_RESTORE_ITEM request.editing_item = editing request.item_id = "deleted-task" request.value = "Restored task" request.comment = "Restored comment" request.done = 1 complete = ListsPrepareCommand(*app.elist, request) check_int("shared undo keeps existing tasks", ArrayCount(complete, FieldAt(complete, FieldAt(complete, 0, "list"), "items")), 301) check_true("shared undo preserves identity, title, comment and completion", ContainsBytes(complete, "deleted-task") && ContainsBytes(complete, "Restored task") && ContainsBytes(complete, "Restored comment") && ContainsBytes(complete, "\"done\":1")) PackageFree(complete) // Cached roles govern all outgoing edits, including stale editor input. app.elist.lists[selected].read_only = true request.action = LISTS_COMMIT check_true("a viewer cannot submit task changes", ListsPrepareCommand(*app.elist, request).count == 0) request.action = LISTS_INVITE check_true("a viewer cannot invite", ListsPrepareCommand(*app.elist, request).count == 0) request.action = LISTS_SET_ACCESS request.target = sender request.access = "owner" check_true("an editor cannot grant ownership", ListsPrepareCommand(*app.elist, request).count == 0) app.elist.lists[selected].read_only = false app.elist.lists[selected].owner = true complete = ListsPrepareCommand(*app.elist, request) check_true("an owner can grant full ownership", ContainsBytes(complete, "\"access\":\"owner\"")) check_true("permission changes never replace the list's tasks", FieldAt(complete, FieldAt(complete, 0, "list"), "items") < 0) PackageFree(complete) request.action = LISTS_REMOVE_ACCESS complete = ListsPrepareCommand(*app.elist, request) check_true("an owner can remove access", ContainsBytes(complete, "\"action\":\"remove\"")) PackageFree(complete) check_true("viewer snapshot saved", ListsCacheWrite("lists.shared", "{\"lists\":[{\"id\":\"5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6\",\"owner\":\"another-account\",\"alias\":\"Alice\",\"title\":\"Read me\",\"access\":\"viewer\",\"items\":[]}],\"invitations\":[]}") != 0) check_int("viewer snapshot loads", storage_elist_load(cast(*void)*app.elist), 1) for index: cast(s32)0..app.elist.list_count - 1 { if app.elist.lists[index].shared { check_true("viewer role disables writes", app.elist.lists[index].read_only && !app.elist.lists[index].owner) check_true("the original owner's name is retained", TextUntilNul(app.elist.lists[index].owner_alias[:]) == "Alice") } } check_true("coowner snapshot saved", ListsCacheWrite("lists.shared", "{\"lists\":[{\"id\":\"5ad0e7f2-3b1c-4d6e-9f80-a1b2c3d4e5f6\",\"owner\":\"another-account\",\"title\":\"Manage me\",\"access\":\"owner\",\"items\":[]}],\"invitations\":[]}") != 0) check_int("coowner snapshot loads", storage_elist_load(cast(*void)*app.elist), 1) for index: cast(s32)0..app.elist.list_count - 1 { if app.elist.lists[index].shared { check_true("coowner receives full local controls", app.elist.lists[index].owner && !app.elist.lists[index].read_only) } } private_id: [37]u8 task_id: [37]u8 check_int("undo list fixture", storage_elist_create_list("Undo fixture", *private_id[0]), 1) check_int("undo item fixture", storage_elist_create_item(TextUntilNul(private_id[:]), "Keep identity", "Keep comment", *task_id[0]), 1) check_int("undo completed fixture", storage_elist_update_item(TextUntilNul(task_id[:]), "Keep identity", "Keep comment", 1, 9), 1) check_int("delete original item", storage_elist_delete_item(TextUntilNul(task_id[:])), 1) check_int("restore original item", storage_elist_restore_item(TextUntilNul(task_id[:])), 1) check_int("undo preserves the full original row", read_db_count("SELECT COUNT(*) FROM elist_items WHERE title='Keep identity' AND comment='Keep comment' AND done=1 AND sort_order=9 AND deleted_at=0"), 1) storage_close() remove_tree("/tmp/inbe-lists-test/") return failures }