Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

test(shared): exercise SQLite paging and rollback (#1193)

Gener07f4f20401ba
diff --git a/src/shared/test/queries/community-forum-message-pagination.test.ts b/src/shared/test/queries/community-forum-message-pagination.test.ts
index 3d3508229..bfc5a3818 100644
--- a/src/shared/test/queries/community-forum-message-pagination.test.ts
+++ b/src/shared/test/queries/community-forum-message-pagination.test.ts
@@ -63,6 +63,7 @@ describe("forum opener message pagination against real SQLite", () => {
afterEach(() => sqlite.close())
it("preserves each reader's exact columns while sharing body and parsed embeds", async () => {
+ sqlite.prepare("UPDATE user SET avatarVersion = 9 WHERE id = 'u1'").run()
sqlite.prepare("UPDATE community_message SET embeds = ?, client_nonce = ?, friendship_id = ? WHERE id = ?")
.run('[{"title":"Native"}]', "nonce", "friendship", "m1")
const reads = [
@@ -78,7 +79,7 @@ describe("forum opener message pagination against real SQLite", () => {
for (const { row, extra } of reads) {
if (!row) throw new Error("Expected native fixture message")
expect(Object.keys(row).sort()).toEqual([...common, ...extra].sort())
- expect(row).toMatchObject({ id: "m1", channelId: "c1", content: "message 1", authorName: "Alice", authorImage: null, authorAvatarVersion: 0, embeds: [{ title: "Native" }] })
+ expect(row).toMatchObject({ id: "m1", channelId: "c1", content: "message 1", authorName: "Alice", authorImage: null, authorAvatarVersion: 9, embeds: [{ title: "Native" }] })
}
expect(await messageQueries.getMessageInScope(db as never, "m1", { channelId: "c2" })).toBeNull()
expect(await messageQueries.getMessagesByIdsInChannels(db as never, ["m1"], ["c2"])).toEqual([])
@@ -90,6 +91,10 @@ describe("forum opener message pagination against real SQLite", () => {
})
it("pages the tagged tuple cursor without overlap or omission", async () => {
+ sqlite.prepare("UPDATE community_message SET created_at = ? WHERE id = ?")
+ .run("2026-01-01T00:00:04.000Z", "m5")
+ sqlite.prepare("INSERT INTO community_message_tag (id, message_id, tag) VALUES (?, ?, ?)")
+ .run("tag-m5-bug", "m5", "bug")
const first = await messageQueries.listMessages(db as never, { channelId: "c1", tag: "bug", limit: 2 })
const second = await messageQueries.listMessages(db as never, {
channelId: "c1",
@@ -97,9 +102,8 @@ describe("forum opener message pagination against real SQLite", () => {
limit: 2,
cursor: { createdAt: first[1]!.createdAt, id: first[1]!.id },
})
- expect(first.map((row) => row.id)).toEqual(["m6", "m4"])
- expect(second.map((row) => row.id)).toEqual(["m2"])
- expect(new Set([...first, ...second].map((row) => row.id)).size).toBe(3)
+ expect(first.map((row) => row.id)).toEqual(["m6", "m5"])
+ expect(second.map((row) => row.id)).toEqual(["m4", "m2"])
})
it("applies the same tagged set to anchor and since windows", async () => {
diff --git a/src/shared/test/queries/community-invite.test.ts b/src/shared/test/queries/community-invite.test.ts
index 68f82de04..7878488cb 100644
--- a/src/shared/test/queries/community-invite.test.ts
+++ b/src/shared/test/queries/community-invite.test.ts
@@ -90,13 +90,42 @@ describe("community invite quota consumption", () => {
.toEqual([{ user_id: "u1" }]);
});
- it("rolls the counter back when the membership UNIQUE constraint rejects", async () => {
+ it("preserves duplicate capacity and rolls back earlier writes after a late analytics failure", async () => {
seedInvite(null);
- await useInvite(db as never, "token1", "u1");
+ sqlite.prepare("INSERT INTO user (id, name, discriminator) VALUES (?, ?, ?)")
+ .run("owner", "Owner", "0009");
+ const first = await useInvite(db as never, "token1", "u1");
+ expect(first).not.toBeNull();
+ const beforeMembers = sqlite.prepare("SELECT * FROM community_server_member ORDER BY id").all();
+ const beforeEvents = sqlite.prepare("SELECT * FROM community_funnel_analytics_event ORDER BY id").all();
+ expect(beforeMembers).toHaveLength(1);
+ expect(beforeMembers[0]).toMatchObject({ server_id: "s1", user_id: "u1", role: "member" });
+ const memberId = (beforeMembers[0] as { id: string }).id;
+ expect(first!.member.id).toBe(memberId);
+ expect(beforeEvents).toHaveLength(1);
+ expect(beforeEvents[0]).toMatchObject({
+ owner_user_id: "owner", event_name: "invited_human_joined", source_id: memberId,
+ });
+ expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
+ .toEqual({ uses: 1 });
+
await expect(useInvite(db as never, "token1", "u1")).rejects.toThrow();
+ expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
+ .toEqual({ uses: 1 });
+ expect(sqlite.prepare("SELECT * FROM community_server_member ORDER BY id").all()).toEqual(beforeMembers);
+ expect(sqlite.prepare("SELECT * FROM community_funnel_analytics_event ORDER BY id").all()).toEqual(beforeEvents);
+ sqlite.exec(`
+ CREATE TRIGGER reject_late_invite_event
+ BEFORE INSERT ON community_funnel_analytics_event
+ WHEN NEW.event_name = 'invited_human_joined'
+ BEGIN SELECT RAISE(ABORT, 'late analytics insertion rejected'); END;
+ `);
+ await expect(useInvite(db as never, "token1", "u2")).rejects.toThrow("late analytics insertion rejected");
expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
.toEqual({ uses: 1 });
+ expect(sqlite.prepare("SELECT * FROM community_server_member ORDER BY id").all()).toEqual(beforeMembers);
+ expect(sqlite.prepare("SELECT * FROM community_funnel_analytics_event ORDER BY id").all()).toEqual(beforeEvents);
});
it("admits a legacy invite without inventing a funnel owner", async () => {
diff --git a/src/shared/test/queries/community-member-rail-cleanup.test.ts b/src/shared/test/queries/community-member-rail-cleanup.test.ts
index c9d2d6a43..29543c822 100644
--- a/src/shared/test/queries/community-member-rail-cleanup.test.ts
+++ b/src/shared/test/queries/community-member-rail-cleanup.test.ts
@@ -10,186 +10,212 @@ import {
function createDatabase() {
const sqlite = new Sqlite(":memory:");
- sqlite.exec(`
- PRAGMA foreign_keys = ON;
- CREATE TABLE community_server (id TEXT PRIMARY KEY);
- CREATE TABLE community_server_rail (user_id TEXT PRIMARY KEY, entries TEXT NOT NULL);
- CREATE TABLE community_server_member (
- id TEXT PRIMARY KEY,
- server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
- user_id TEXT NOT NULL,
- role TEXT DEFAULT 'member',
- rail_order INTEGER DEFAULT 0,
- joined_at TEXT NOT NULL
- );
- CREATE TABLE community_server_folder (
- id TEXT PRIMARY KEY,
- user_id TEXT NOT NULL,
- name TEXT NOT NULL,
- position INTEGER DEFAULT 0
- );
- CREATE TABLE community_server_folder_item (
- folder_id TEXT NOT NULL REFERENCES community_server_folder(id) ON DELETE CASCADE,
- server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
- position INTEGER DEFAULT 0,
- PRIMARY KEY(folder_id, server_id)
- );
- CREATE TABLE community_channel (
- id TEXT PRIMARY KEY,
- server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
- category_id TEXT,
- type TEXT NOT NULL DEFAULT 'text',
- parent_channel_id TEXT,
- creator_id TEXT
- );
- CREATE TABLE community_category (
- id TEXT PRIMARY KEY,
- server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
- private INTEGER DEFAULT 0
- );
- CREATE TABLE community_channel_member (
- id TEXT PRIMARY KEY,
- channel_id TEXT NOT NULL REFERENCES community_channel(id) ON DELETE CASCADE,
- user_id TEXT NOT NULL,
- relation TEXT NOT NULL,
- source TEXT NOT NULL DEFAULT 'added',
- added_by TEXT,
- added_at TEXT NOT NULL DEFAULT '2026-01-01T00:00:00.000Z'
- );
- `);
- const db = drizzle(sqlite) as any;
- let lastBatchParamCounts: number[] = [];
- db.batch = async (statements: any[]) => {
- lastBatchParamCounts = statements.map((statement) => statement.toSQL().params.length);
- return sqlite.transaction(() =>
- statements.map((statement, index) => index === 4 ? statement.all() : statement.run()),
- )();
- };
- return { sqlite, db, getLastBatchParamCounts: () => lastBatchParamCounts };
+ try {
+ sqlite.exec(`
+ PRAGMA foreign_keys = ON;
+ CREATE TABLE community_server (id TEXT PRIMARY KEY);
+ CREATE TABLE community_server_rail (user_id TEXT PRIMARY KEY, entries TEXT NOT NULL);
+ CREATE TABLE community_server_member (
+ id TEXT PRIMARY KEY,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ user_id TEXT NOT NULL,
+ role TEXT DEFAULT 'member',
+ rail_order INTEGER DEFAULT 0,
+ joined_at TEXT NOT NULL
+ );
+ CREATE TABLE community_server_folder (
+ id TEXT PRIMARY KEY,
+ user_id TEXT NOT NULL,
+ name TEXT NOT NULL,
+ position INTEGER DEFAULT 0
+ );
+ CREATE TABLE community_server_folder_item (
+ folder_id TEXT NOT NULL REFERENCES community_server_folder(id) ON DELETE CASCADE,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ position INTEGER DEFAULT 0,
+ PRIMARY KEY(folder_id, server_id)
+ );
+ CREATE TABLE community_channel (
+ id TEXT PRIMARY KEY,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ category_id TEXT,
+ type TEXT NOT NULL DEFAULT 'text',
+ parent_channel_id TEXT,
+ creator_id TEXT
+ );
+ CREATE TABLE community_category (
+ id TEXT PRIMARY KEY,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ private INTEGER DEFAULT 0
+ );
+ CREATE TABLE community_channel_member (
+ id TEXT PRIMARY KEY,
+ channel_id TEXT NOT NULL REFERENCES community_channel(id) ON DELETE CASCADE,
+ user_id TEXT NOT NULL,
+ relation TEXT NOT NULL,
+ source TEXT NOT NULL DEFAULT 'added',
+ added_by TEXT,
+ added_at TEXT NOT NULL DEFAULT '2026-01-01T00:00:00.000Z'
+ );
+ `);
+ const db = drizzle(sqlite) as any;
+ let lastBatchParamCounts: number[] = [];
+ db.batch = async (statements: any[]) => {
+ lastBatchParamCounts = statements.map((statement) => statement.toSQL().params.length);
+ return sqlite.transaction(() =>
+ statements.map((statement) => {
+ const query = statement.toSQL();
+ return sqlite.prepare(query.sql).reader ? statement.all() : statement.run();
+ }),
+ )();
+ };
+ return { sqlite, db, getLastBatchParamCounts: () => lastBatchParamCounts };
+ } catch (error) {
+ sqlite.close();
+ throw error;
+ }
}
describe("member removal server rail cleanup", () => {
- it("removes unique-item folders for the target and owner bots before the next rail mutation", async () => {
+ it("cleans the provided users and persists the next rail mutation", async () => {
const { sqlite, db } = createDatabase();
- sqlite.exec(`
- INSERT INTO community_server (id) VALUES ('gone'), ('keep');
- INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
- VALUES
- ('target-gone', 'gone', 'target', 'member', 0, '2026-01-01T00:00:00.000Z'),
- ('target-keep', 'keep', 'target', 'member', 1, '2026-01-01T00:00:01.000Z'),
- ('bot-gone', 'gone', 'bot', 'member', 0, '2026-01-01T00:00:00.000Z'),
- ('other-gone', 'gone', 'other', 'member', 0, '2026-01-01T00:00:00.000Z');
- INSERT INTO community_server_folder (id, user_id, name, position)
- VALUES
- ('target-folder', 'target', 'Target', 0),
- ('bot-folder', 'bot', 'Bot', 0),
- ('other-folder', 'other', 'Other', 0);
- INSERT INTO community_server_folder_item (folder_id, server_id, position)
- VALUES
- ('target-folder', 'gone', 0),
- ('bot-folder', 'gone', 0),
- ('other-folder', 'gone', 0);
- INSERT INTO community_channel (id, server_id)
- VALUES ('gone-channel', 'gone'), ('keep-channel', 'keep');
- INSERT INTO community_channel_member (id, channel_id, user_id, relation)
- VALUES
- ('target-gone-access', 'gone-channel', 'target', 'access'),
- ('bot-gone-notify', 'gone-channel', 'bot', 'notify'),
- ('other-gone-access', 'gone-channel', 'other', 'access'),
- ('target-keep-access', 'keep-channel', 'target', 'access'),
- ('bot-keep-notify', 'keep-channel', 'bot', 'notify');
- `);
+ try {
+ sqlite.exec(`
+ INSERT INTO community_server (id) VALUES ('gone'), ('keep');
+ INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
+ VALUES
+ ('target-gone', 'gone', 'target', 'member', 0, '2026-01-01T00:00:00.000Z'),
+ ('target-keep', 'keep', 'target', 'member', 1, '2026-01-01T00:00:01.000Z'),
+ ('bot-gone', 'gone', 'bot', 'member', 0, '2026-01-01T00:00:00.000Z'),
+ ('other-gone', 'gone', 'other', 'member', 0, '2026-01-01T00:00:00.000Z');
+ INSERT INTO community_server_folder (id, user_id, name, position)
+ VALUES
+ ('target-folder', 'target', 'Target', 0),
+ ('bot-folder', 'bot', 'Bot', 0),
+ ('other-folder', 'other', 'Other', 0);
+ INSERT INTO community_server_folder_item (folder_id, server_id, position)
+ VALUES
+ ('target-folder', 'gone', 0),
+ ('bot-folder', 'gone', 0),
+ ('other-folder', 'gone', 0);
+ INSERT INTO community_channel (id, server_id)
+ VALUES ('gone-channel', 'gone'), ('keep-channel', 'keep');
+ INSERT INTO community_channel_member (id, channel_id, user_id, relation)
+ VALUES
+ ('target-gone-access', 'gone-channel', 'target', 'access'),
+ ('bot-gone-notify', 'gone-channel', 'bot', 'notify'),
+ ('other-gone-access', 'gone-channel', 'other', 'access'),
+ ('target-keep-access', 'keep-channel', 'target', 'access'),
+ ('bot-keep-notify', 'keep-channel', 'bot', 'notify');
+ `);
- await expect(removeMemberAndOwnerBots(
- db,
- "target-gone",
- "gone",
- "target",
- ["bot"],
- )).resolves.toMatchObject({ id: "target-gone" });
+ await expect(removeMemberAndOwnerBots(
+ db,
+ "target-gone",
+ "gone",
+ "target",
+ ["bot"],
+ )).resolves.toMatchObject({ id: "target-gone" });
- expect(sqlite.prepare(`
- SELECT id FROM community_server_folder ORDER BY id
- `).all()).toEqual([{ id: "other-folder" }]);
- expect(sqlite.prepare(`
- SELECT folder_id AS folderId, server_id AS serverId
- FROM community_server_folder_item
- `).all()).toEqual([{ folderId: "other-folder", serverId: "gone" }]);
- expect(sqlite.prepare(`
- SELECT id, channel_id AS channelId, user_id AS userId, relation
- FROM community_channel_member
- ORDER BY id
- `).all()).toEqual([
- { id: "bot-keep-notify", channelId: "keep-channel", userId: "bot", relation: "notify" },
- { id: "other-gone-access", channelId: "gone-channel", userId: "other", relation: "access" },
- { id: "target-keep-access", channelId: "keep-channel", userId: "target", relation: "access" },
- ]);
+ expect(sqlite.prepare(`
+ SELECT id FROM community_server_folder ORDER BY id
+ `).all()).toEqual([{ id: "other-folder" }]);
+ expect(sqlite.prepare(`
+ SELECT folder_id AS folderId, server_id AS serverId
+ FROM community_server_folder_item
+ `).all()).toEqual([{ folderId: "other-folder", serverId: "gone" }]);
+ expect(sqlite.prepare(`
+ SELECT id, channel_id AS channelId, user_id AS userId, relation
+ FROM community_channel_member
+ ORDER BY id
+ `).all()).toEqual([
+ { id: "bot-keep-notify", channelId: "keep-channel", userId: "bot", relation: "notify" },
+ { id: "other-gone-access", channelId: "gone-channel", userId: "other", relation: "access" },
+ { id: "target-keep-access", channelId: "keep-channel", userId: "target", relation: "access" },
+ ]);
- db.batch = async (statements: any[]) => statements.map((statement) => statement.all());
- const snapshot = await readServerRailSnapshot(db, "target");
- expect(snapshot).toEqual({ serverIds: ["keep"], folderIds: [], folders: {}, topOrder: [{ kind: "server", id: "keep" }] });
- const next = projectServerRailCommit(snapshot, {
- commands: [{
- kind: "create-folder",
- clientId: "next",
- name: "Next",
+ const snapshot = await readServerRailSnapshot(db, "target");
+ expect(snapshot).toEqual({ serverIds: ["keep"], folderIds: [], folders: {}, topOrder: [{ kind: "server", id: "keep" }] });
+ const next = projectServerRailCommit(snapshot, {
+ commands: [{
+ kind: "create-folder",
+ clientId: "next",
+ name: "Next",
+ serverIds: ["keep"],
+ }],
+ }, () => "next-folder");
+ expect(next.ok).toBe(true);
+ if (!next.ok) throw new Error(next.error);
+ const statements = buildServerRailWriteStatements(db, "target", next.value);
+ expect(() => sqlite.transaction(() => statements.forEach((statement) => statement.run()))())
+ .not.toThrow();
+ expect(await readServerRailSnapshot(db, "target")).toEqual({
serverIds: ["keep"],
- }],
- }, () => "next-folder");
- expect(next.ok).toBe(true);
- if (!next.ok) throw new Error(next.error);
- const statements = buildServerRailWriteStatements(db, "target", next.value);
- expect(() => sqlite.transaction(() => statements.forEach((statement) => statement.run()))())
- .not.toThrow();
+ folderIds: ["next-folder"],
+ folders: { "next-folder": { id: "next-folder", name: "Next", serverIds: ["keep"] } },
+ topOrder: [{ kind: "folder", id: "next-folder" }],
+ });
+ expect(sqlite.prepare("SELECT id FROM community_server_folder WHERE user_id='other'").all())
+ .toEqual([{ id: "other-folder" }]);
+ expect(sqlite.prepare(`
+ SELECT folder_id AS folderId, server_id AS serverId
+ FROM community_server_folder_item WHERE folder_id='other-folder'
+ `).all()).toEqual([{ folderId: "other-folder", serverId: "gone" }]);
+ } finally {
+ sqlite.close();
+ }
});
it("cleans more than 100 removed users with bounded binds and preserves other scopes", async () => {
const { sqlite, db, getLastBatchParamCounts } = createDatabase();
- sqlite.exec(`
- INSERT INTO community_server (id) VALUES ('gone'), ('keep');
- INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
- VALUES ('target-gone', 'gone', 'target', 'member', 0, '2026-01-01T00:00:00.000Z');
- INSERT INTO community_channel (id, server_id)
- VALUES ('gone-channel', 'gone'), ('keep-channel', 'keep');
- INSERT INTO community_channel_member (id, channel_id, user_id, relation)
- VALUES ('other-gone', 'gone-channel', 'other', 'access');
- `);
+ try {
+ sqlite.exec(`
+ INSERT INTO community_server (id) VALUES ('gone'), ('keep');
+ INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
+ VALUES ('target-gone', 'gone', 'target', 'member', 0, '2026-01-01T00:00:00.000Z');
+ INSERT INTO community_channel (id, server_id)
+ VALUES ('gone-channel', 'gone'), ('keep-channel', 'keep');
+ INSERT INTO community_channel_member (id, channel_id, user_id, relation)
+ VALUES ('other-gone', 'gone-channel', 'other', 'access');
+ `);
- const botIds = Array.from({ length: 120 }, (_, index) => `bot-${index}`);
- const insertMember = sqlite.prepare(`
- INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
- VALUES (?, 'gone', ?, 'member', 0, '2026-01-01T00:00:00.000Z')
- `);
- const insertChannelMember = sqlite.prepare(`
- INSERT INTO community_channel_member (id, channel_id, user_id, relation)
- VALUES (?, ?, ?, 'access')
- `);
- sqlite.transaction(() => {
- for (const botId of botIds) {
- insertMember.run(`member-${botId}`, botId);
- insertChannelMember.run(`gone-${botId}`, "gone-channel", botId);
- insertChannelMember.run(`keep-${botId}`, "keep-channel", botId);
- }
- })();
+ const botIds = Array.from({ length: 120 }, (_, index) => `bot-${index}`);
+ const insertMember = sqlite.prepare(`
+ INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
+ VALUES (?, 'gone', ?, 'member', 0, '2026-01-01T00:00:00.000Z')
+ `);
+ const insertChannelMember = sqlite.prepare(`
+ INSERT INTO community_channel_member (id, channel_id, user_id, relation)
+ VALUES (?, ?, ?, 'access')
+ `);
+ sqlite.transaction(() => {
+ for (const botId of botIds) {
+ insertMember.run(`member-${botId}`, botId);
+ insertChannelMember.run(`gone-${botId}`, "gone-channel", botId);
+ insertChannelMember.run(`keep-${botId}`, "keep-channel", botId);
+ }
+ })();
- await expect(removeMemberAndOwnerBots(
- db,
- "target-gone",
- "gone",
- "target",
- botIds,
- )).resolves.toMatchObject({ id: "target-gone" });
+ await expect(removeMemberAndOwnerBots(
+ db,
+ "target-gone",
+ "gone",
+ "target",
+ botIds,
+ )).resolves.toMatchObject({ id: "target-gone" });
- expect(getLastBatchParamCounts().every((count) => count <= 100)).toBe(true);
- expect(getLastBatchParamCounts()[3]).toBeLessThanOrEqual(2);
- expect(sqlite.prepare(`
- SELECT id FROM community_channel_member
- WHERE channel_id = 'gone-channel'
- ORDER BY id
- `).all()).toEqual([{ id: "other-gone" }]);
- expect(sqlite.prepare(`
- SELECT COUNT(*) AS count FROM community_channel_member
- WHERE channel_id = 'keep-channel'
- `).get()).toEqual({ count: 120 });
+ expect(getLastBatchParamCounts().every((count) => count <= 100)).toBe(true);
+ expect(sqlite.prepare(`
+ SELECT id FROM community_channel_member
+ WHERE channel_id = 'gone-channel'
+ ORDER BY id
+ `).all()).toEqual([{ id: "other-gone" }]);
+ expect(sqlite.prepare(`
+ SELECT COUNT(*) AS count FROM community_channel_member
+ WHERE channel_id = 'keep-channel'
+ `).get()).toEqual({ count: 120 });
+ } finally {
+ sqlite.close();
+ }
});
});
diff --git a/src/shared/test/queries/community-message-new-target-sqlite.test.ts b/src/shared/test/queries/community-message-new-target-sqlite.test.ts
index ea5f07c74..1c992bd58 100644
--- a/src/shared/test/queries/community-message-new-target-sqlite.test.ts
+++ b/src/shared/test/queries/community-message-new-target-sqlite.test.ts
@@ -17,7 +17,7 @@ it("returns the first peer ID in the exact scoped sequence interval, with gaps a
] as const) insert.run(id, author, channel, seq)
const target = { channelId: "channel", viewerId: "author", afterSeq: 5, throughSeq: 20 }
await expect(getFirstPeerMessageAfterSeq(store.db, { ...target, afterSeq: 0, throughSeq: 5 })).resolves.toEqual({ id: "already-read", channelId: "channel", seq: 4, authorId: "peer" })
- await expect(getFirstPeerMessageAfterSeq(store.db, target)).resolves.toEqual({ id: "first-peer", channelId: "channel", seq: 9, authorId: "peer" })
+ await expect(getFirstPeerMessageAfterSeq(store.db, { ...target, throughSeq: 9 })).resolves.toEqual({ id: "first-peer", channelId: "channel", seq: 9, authorId: "peer" })
await expect(getFirstPeerMessageAfterSeq(store.db, { ...target, throughSeq: 8 })).resolves.toBeNull()
await expect(getFirstPeerMessageAfterSeq(store.db, { ...target, afterSeq: 9 })).resolves.toEqual({ id: "later-peer", channelId: "channel", seq: 15, authorId: "peer" })
await expect(getFirstPeerMessageAfterSeq(store.db, { ...target, channelId: "empty" })).resolves.toBeNull()