@tribe-nest/forge 3.60.0 → 3.63.0

package/src/ui/headless/_tests/communityAgent.spec.tsx

@@ -0,0 +1,519 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { QueryClient } from "@tanstack/react-query";
+import type { Socket } from "socket.io-client";
+
+import {
+  COMMUNITY,
+  PROFILE_ID,
+  account,
+  calls,
+  get,
+  installAdapter,
+  meRoute,
+  post,
+  restoreAdapter,
+  viewer,
+  wrapper,
+  type Route,
+} from "./communityHarness";
+import {
+  isCommunityAgentDm,
+  useCommunityAgent,
+  useCommunityAgentRatings,
+  useOpenCommunityAgentDm,
+} from "../../../data/queries/useCommunityAgent";
+import {
+  applyCommunityContentHeld,
+  communityKeys,
+  type CommunityPost,
+  type CommunityReply,
+} from "../../../data/queries/useCommunity";
+import {
+  AGENT_THINKING_TIMEOUT_MS,
+  useCommunityAgentAnswerRatings,
+  linkifyText,
+  useChatAgentThinking,
+  useCommunityAgentAnswerFeedback,
+  useCommunityAgentThinking,
+  useCommunityCatchUp,
+} from "../community/useCommunityAgent";
+import { useRichMentionComposer } from "../community/useRichMentionComposer";
+import { serializeRichToLexical, isRichEmpty } from "../community/richLexical";
+
+/**
+ * The member side of the community AI (community parity §8.1, §8.2, §8.5),
+ * driven through the real data hooks over a stub adapter so each test asserts
+ * what is SENT, plus the pure helpers and the socket-driven thinking state.
+ */
+
+const AGENT = { enabled: true, id: "agent-1", name: "Assistant", avatarUrl: null, dmEnabled: true };
+const ME = account();
+
+const agentRoute = (info: unknown = AGENT): Route => get("/public/community-agent", () => info);
+const memberRoutes = (info: unknown = AGENT): Route[] => [meRoute(() => viewer({ state: "member" })), agentRoute(info)];
+
+afterEach(() => restoreAdapter());
+
+// ── A fake socket: the hooks only ever call on/off/emit. ─────────────────────
+type Listener = (envelope: unknown) => void;
+function fakeSocket() {
+  const listeners = new Set<Listener>();
+  const socket = {
+    connected: true,
+    on: (event: string, fn: Listener) => event === "message" && listeners.add(fn),
+    off: (event: string, fn: Listener) => event === "message" && listeners.delete(fn),
+    emit: vi.fn(),
+  };
+  const deliver = (event: string, data: unknown) => act(() => listeners.forEach((fn) => fn({ event, data })));
+  return { socket: socket as unknown as Socket, deliver };
+}
+
+describe("useCommunityAgent: the agent info query", () => {
+  it("asks for the agent with the profile and community once the viewer is a signed-in member", async () => {
+    installAdapter(memberRoutes());
+    const { result } = renderHook(() => useCommunityAgent(), { wrapper: wrapper({ user: ME }) });
+    await waitFor(() => expect(result.current.agent).not.toBeNull());
+    expect(result.current.agent).toEqual(AGENT);
+    expect(calls("get", "/public/community-agent")[0].params).toEqual({ profileId: PROFILE_ID, communityId: COMMUNITY.id });
+  });
+
+  it("asks for nothing when signed out", async () => {
+    installAdapter(memberRoutes());
+    const { result } = renderHook(() => useCommunityAgent(), { wrapper: wrapper() });
+    await new Promise((r) => setTimeout(r, 20));
+    expect(result.current.agent).toBeNull();
+    expect(calls("get", "/public/community-agent")).toHaveLength(0);
+  });
+
+  it("asks for nothing for a signed-in viewer who is not a member", async () => {
+    installAdapter([meRoute(() => viewer({ state: "none" })), agentRoute()]);
+    const { result } = renderHook(() => useCommunityAgent(), { wrapper: wrapper({ user: ME }) });
+    await waitFor(() => expect(calls("get", /\/me$/)).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(result.current.agent).toBeNull();
+    expect(calls("get", "/public/community-agent")).toHaveLength(0);
+  });
+
+  it("reads a switched-off agent as no agent", async () => {
+    installAdapter(memberRoutes({ enabled: false }));
+    const { result } = renderHook(() => useCommunityAgent(), { wrapper: wrapper({ user: ME }) });
+    await waitFor(() => expect(result.current.data).toEqual({ enabled: false }));
+    expect(result.current.agent).toBeNull();
+  });
+});
+
+describe("useOpenCommunityAgentDm", () => {
+  it("posts the profile and community and answers the channel", async () => {
+    installAdapter([post("/public/community-agent/dm", () => ({ channelId: "chan-ai", agent: AGENT }))]);
+    const { result } = renderHook(() => useOpenCommunityAgentDm(), { wrapper: wrapper({ user: ME }) });
+    let answer: unknown;
+    await act(async () => {
+      answer = await result.current.mutateAsync();
+    });
+    expect(answer).toEqual({ channelId: "chan-ai", agent: AGENT });
+    expect(calls("post", "/public/community-agent/dm")[0].body).toEqual({ profileId: PROFILE_ID, communityId: COMMUNITY.id });
+  });
+
+  it("recognises the agent DM by its key, and nothing else", () => {
+    expect(isCommunityAgentDm({ type: "dm", dmKey: "agent:agent-1:account-1" })).toBe(true);
+    expect(isCommunityAgentDm({ type: "dm", dmKey: null })).toBe(false);
+    expect(isCommunityAgentDm({ type: "dm", dmKey: "a:b" })).toBe(false);
+    expect(isCommunityAgentDm({ type: "public", dmKey: "agent:x" })).toBe(false);
+  });
+});
+
+describe("the mention picker lists the agent first and inserts an agent mention", () => {
+  const MEMBERS = [
+    { accountId: "acct-ada", displayName: "Ada", firstName: "Ada", lastName: null, avatarUrl: null, level: 2, points: 5 },
+    { accountId: "acct-asa", displayName: "Asa", firstName: "Asa", lastName: null, avatarUrl: null, level: 1, points: 1 },
+  ];
+
+  function mountComposer() {
+    installAdapter([...memberRoutes(), get("/public/community/members", () => ({ data: MEMBERS }))]);
+    const editor = document.createElement("div");
+    document.body.appendChild(editor);
+    const hook = renderHook(
+      () => {
+        const composer = useRichMentionComposer();
+        composer.editorRef.current = editor;
+        return composer;
+      },
+      { wrapper: wrapper({ user: ME }) },
+    );
+    return { editor, hook };
+  }
+
+  /** Type `text` into the editor with the caret at its end, as the member does. */
+  function typeAt(editor: HTMLDivElement, text: string, onChange: () => void) {
+    editor.textContent = text;
+    const node = editor.firstChild as Text;
+    const range = document.createRange();
+    range.setStart(node, text.length);
+    range.collapse(true);
+    const sel = window.getSelection()!;
+    sel.removeAllRanges();
+    sel.addRange(range);
+    act(() => onChange());
+  }
+
+  it("puts the agent above every member, with its id and no account", async () => {
+    const { editor, hook } = mountComposer();
+    await waitFor(() => expect(hook.result.current.agent).not.toBeNull());
+    typeAt(editor, "Hi @A", hook.result.current.onEditorChange);
+    await waitFor(() => expect(hook.result.current.suggestions.length).toBe(3));
+    const [first, ...rest] = hook.result.current.suggestions;
+    expect(first).toMatchObject({ agentId: "agent-1", name: "Assistant", accountId: "" });
+    expect(rest.map((s) => s.accountId)).toEqual(["acct-ada", "acct-asa"]);
+    editor.remove();
+  });
+
+  it("leaves the agent out when the typed name does not match it", async () => {
+    const { editor, hook } = mountComposer();
+    await waitFor(() => expect(hook.result.current.agent).not.toBeNull());
+    typeAt(editor, "@Ad", hook.result.current.onEditorChange);
+    await waitFor(() => expect(hook.result.current.suggestions.length).toBeGreaterThan(0));
+    expect(hook.result.current.suggestions.some((s) => s.agentId)).toBe(false);
+    editor.remove();
+  });
+
+  it("inserts { type: mention, agentId, mentionName } and never an accountId", async () => {
+    const { editor, hook } = mountComposer();
+    await waitFor(() => expect(hook.result.current.agent).not.toBeNull());
+    typeAt(editor, "Hey @Ass", hook.result.current.onEditorChange);
+    await waitFor(() => expect(hook.result.current.suggestions[0]?.agentId).toBe("agent-1"));
+    act(() => hook.result.current.insertMention(hook.result.current.suggestions[0]));
+
+    const body = hook.result.current.getBody() as { root: { children: { children: Record<string, unknown>[] }[] } };
+    const mention = body.root.children[0].children.find((n) => n.type === "mention")!;
+    expect(mention).toMatchObject({ type: "mention", agentId: "agent-1", mentionName: "Assistant", text: "@Assistant" });
+    expect(mention).not.toHaveProperty("accountId");
+    expect(mention).not.toHaveProperty("id");
+    expect(mention).not.toHaveProperty("mentionId");
+    // The agent is not a member: it is never in the mentioned accounts.
+    expect(hook.result.current.getMentionedAccountIds()).toEqual([]);
+    editor.remove();
+  });
+
+  it("serializes an agent chip on its own, and counts it as content", () => {
+    const root = document.createElement("div");
+    root.innerHTML = '<p><span data-agent-id="agent-1" data-mention-name="Assistant" contenteditable="false">@Assistant</span></p>';
+    expect(isRichEmpty(root)).toBe(false);
+    const state = serializeRichToLexical(root) as { root: { children: { children: unknown[] }[] } };
+    expect(state.root.children[0].children[0]).toMatchObject({ type: "mention", agentId: "agent-1", mentionName: "Assistant" });
+  });
+});
+
+describe("thinking indicators", () => {
+  beforeEach(() => vi.useRealTimers());
+
+  it("community: on with thinking, off with done", () => {
+    const { socket, deliver } = fakeSocket();
+    const { result } = renderHook(() => useCommunityAgentThinking(socket));
+    expect(result.current.isThinking("post-1")).toBe(false);
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "thinking" });
+    expect(result.current.isThinking("post-1")).toBe(true);
+    expect(result.current.isThinking("post-2")).toBe(false);
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "done" });
+    expect(result.current.isThinking("post-1")).toBe(false);
+  });
+
+  it("community: off when the answer arrives, even before done", () => {
+    const { socket, deliver } = fakeSocket();
+    const { result } = renderHook(() => useCommunityAgentThinking(socket));
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "thinking" });
+    // A member's reply does not clear it.
+    deliver("communityNewReply", { postId: "post-1", reply: { id: "r1", agentAuthor: null } });
+    expect(result.current.isThinking("post-1")).toBe(true);
+    deliver("communityNewReply", { postId: "post-1", reply: { id: "r2", agentAuthor: { id: "agent-1", name: "A", avatarUrl: null } } });
+    expect(result.current.isThinking("post-1")).toBe(false);
+  });
+
+  it("community: only the posts the caller accepts", () => {
+    const { socket, deliver } = fakeSocket();
+    const { result } = renderHook(() => useCommunityAgentThinking(socket, (id) => id === "post-1"));
+    deliver("communityAgentThinking", { postId: "post-9", agentId: "agent-1", state: "thinking" });
+    expect(result.current.isThinking("post-9")).toBe(false);
+  });
+
+  it("community: clears itself if done never arrives", () => {
+    vi.useFakeTimers();
+    const { socket, deliver } = fakeSocket();
+    const { result } = renderHook(() => useCommunityAgentThinking(socket));
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "thinking" });
+    expect(result.current.isThinking("post-1")).toBe(true);
+    act(() => vi.advanceTimersByTime(AGENT_THINKING_TIMEOUT_MS + 1));
+    expect(result.current.isThinking("post-1")).toBe(false);
+    vi.useRealTimers();
+  });
+
+  it("chat: keyed by channel and thread, cleared by done or the agent's message", () => {
+    const { socket, deliver } = fakeSocket();
+    const { result } = renderHook(() => useChatAgentThinking(socket));
+    deliver("chatAgentThinking", { channelId: "c1", parentMessageId: "m1", agentId: "agent-1", state: "thinking" });
+    expect(result.current.isThinking("c1", "m1")).toBe(true);
+    expect(result.current.isThinking("c1", null)).toBe(false);
+    deliver("chatAgentThinking", { channelId: "c1", parentMessageId: "m1", agentId: "agent-1", state: "done" });
+    expect(result.current.isThinking("c1", "m1")).toBe(false);
+
+    // The DM: no thread. A member's message does not clear it; the agent's does.
+    deliver("chatAgentThinking", { channelId: "dm", parentMessageId: null, agentId: "agent-1", state: "thinking" });
+    expect(result.current.isThinking("dm", null)).toBe(true);
+    deliver("chatNewMessage", { channelId: "dm", message: { id: "x", parentMessageId: null, senderAgentId: null } });
+    expect(result.current.isThinking("dm", null)).toBe(true);
+    deliver("chatNewMessage", { channelId: "dm", message: { id: "y", parentMessageId: null, senderAgentId: "agent-1" } });
+    expect(result.current.isThinking("dm", null)).toBe(false);
+  });
+});
+
+describe("thumbs up / down", () => {
+  it("sends the entity and value, optimistically, and a second press clears it", async () => {
+    installAdapter([post("/public/community-agent/feedback", (req) => ({ id: "ans-1", feedback: req.body?.value || null }))]);
+    const { result } = renderHook(() => useCommunityAgentAnswerFeedback("community_reply", "reply-ai"), {
+      wrapper: wrapper({ user: ME }),
+    });
+    act(() => result.current.rate(1));
+    expect(result.current.value).toBe(1);
+    await waitFor(() => expect(calls("post", "/public/community-agent/feedback")).toHaveLength(1));
+    expect(calls("post", "/public/community-agent/feedback")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      entityType: "community_reply",
+      entityId: "reply-ai",
+      value: 1,
+    });
+    act(() => result.current.rate(1));
+    expect(result.current.value).toBeNull();
+    await waitFor(() => expect(calls("post", "/public/community-agent/feedback")).toHaveLength(2));
+    expect(calls("post", "/public/community-agent/feedback")[1].body?.value).toBe(0);
+  });
+
+  it("rolls back and hides itself on a 404 (not the member who asked)", async () => {
+    installAdapter([
+      post("/public/community-agent/feedback", () => {
+        throw { status: 404 };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityAgentAnswerFeedback("chat_message", "msg-ai"), {
+      wrapper: wrapper({ user: ME }),
+    });
+    act(() => result.current.rate(-1));
+    expect(result.current.value).toBe(-1);
+    await waitFor(() => expect(result.current.hidden).toBe(true));
+    expect(result.current.value).toBeNull();
+  });
+
+  it("starts from the saved rating, so a reload keeps it", async () => {
+    installAdapter([post("/public/community-agent/feedback", () => ({ id: "ans", feedback: null }))]);
+    const { result } = renderHook(() => useCommunityAgentAnswerFeedback("community_reply", "reply-ai", -1), {
+      wrapper: wrapper({ user: ME }),
+    });
+    expect(result.current.value).toBe(-1);
+    // Pressing the saved thumb clears it.
+    act(() => result.current.rate(-1));
+    expect(result.current.value).toBeNull();
+    await waitFor(() => expect(calls("post", "/public/community-agent/feedback")).toHaveLength(1));
+    expect(calls("post", "/public/community-agent/feedback")[0].body?.value).toBe(0);
+  });
+});
+
+describe("the member's own ratings: hydration and who sees thumbs", () => {
+  const ratingsPath = "/public/community-agent/feedback";
+  const ratingsRoute = (rows: { entityId: string; feedback: 1 | -1 | null }[]): Route =>
+    get(ratingsPath, (req) => {
+      const asked = String(req.params?.entityIds ?? "").split(",");
+      return { data: rows.filter((r) => asked.includes(r.entityId)) };
+    });
+
+  it("reads once per list with the sorted ids, and only returned answers are ratable", async () => {
+    installAdapter([...memberRoutes(), ratingsRoute([{ entityId: "a-2", feedback: 1 }])]);
+    const { result } = renderHook(() => useCommunityAgentAnswerRatings("community_reply", ["a-3", "a-2", "a-1"]), {
+      wrapper: wrapper({ user: ME }),
+    });
+    await waitFor(() => expect(result.current.canRate("a-2")).toBe(true));
+    expect(result.current.ratingOf("a-2")).toBe(1);
+    // Someone else's answers are absent from the read, so no thumbs.
+    expect(result.current.canRate("a-1")).toBe(false);
+    expect(result.current.canRate("a-3")).toBe(false);
+    const reads = calls("get", ratingsPath);
+    expect(reads).toHaveLength(1);
+    expect(reads[0].params).toEqual({ profileId: PROFILE_ID, entityType: "community_reply", entityIds: "a-1,a-2,a-3" });
+  });
+
+  it("keys by the sorted ids: the same answers in another order cost no second read", async () => {
+    installAdapter([...memberRoutes(), ratingsRoute([])]);
+    const { result } = renderHook(
+      () => ({
+        one: useCommunityAgentRatings("chat_message", ["m-2", "m-1"]),
+        two: useCommunityAgentRatings("chat_message", ["m-1", "m-2", "m-1"]),
+      }),
+      { wrapper: wrapper({ user: ME }) },
+    );
+    await waitFor(() => expect(result.current.one.isSuccess && result.current.two.isSuccess).toBe(true));
+    expect(calls("get", ratingsPath)).toHaveLength(1);
+  });
+
+  it("splits more than 100 answers into batches of 100", async () => {
+    installAdapter([...memberRoutes(), ratingsRoute([{ entityId: "id-150", feedback: -1 }])]);
+    const ids = Array.from({ length: 150 }, (_, i) => `id-${i}`);
+    const { result } = renderHook(() => useCommunityAgentAnswerRatings("chat_message", ids), { wrapper: wrapper({ user: ME }) });
+    await waitFor(() => expect(calls("get", ratingsPath)).toHaveLength(2));
+    expect(calls("get", ratingsPath).map((r) => String(r.params?.entityIds).split(",").length)).toEqual([100, 50]);
+    // id-150 was not in the list, so nothing is ratable here.
+    await waitFor(() => expect(result.current.canRate("id-1")).toBe(false));
+  });
+
+  it("asks nothing when signed out", async () => {
+    installAdapter([...memberRoutes(), ratingsRoute([])]);
+    renderHook(() => useCommunityAgentRatings("community_reply", ["a-1"]), { wrapper: wrapper() });
+    await new Promise((r) => setTimeout(r, 30));
+    expect(calls("get", ratingsPath)).toHaveLength(0);
+  });
+
+  it("asks nothing when the AI is off", async () => {
+    installAdapter([...memberRoutes({ enabled: false }), ratingsRoute([])]);
+    renderHook(() => useCommunityAgentRatings("community_reply", ["a-1"]), { wrapper: wrapper({ user: ME }) });
+    await waitFor(() => expect(calls("get", "/public/community-agent")).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 30));
+    expect(calls("get", ratingsPath)).toHaveLength(0);
+  });
+
+  it("asks nothing with no answers in view", async () => {
+    installAdapter([...memberRoutes(), ratingsRoute([])]);
+    renderHook(() => useCommunityAgentRatings("community_reply", []), { wrapper: wrapper({ user: ME }) });
+    await waitFor(() => expect(calls("get", "/public/community-agent")).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 30));
+    expect(calls("get", ratingsPath)).toHaveLength(0);
+  });
+
+  it("a saved rating updates the cached read, and an unasked answer is never added", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      ratingsRoute([{ entityId: "a-1", feedback: null }]),
+      post(ratingsPath, (req) => ({ id: "ans", feedback: req.body?.value })),
+    ]);
+    const { result } = renderHook(
+      () => ({
+        ratings: useCommunityAgentAnswerRatings("community_reply", ["a-1", "a-9"]),
+        feedback: useCommunityAgentAnswerFeedback("community_reply", "a-1"),
+      }),
+      { wrapper: wrapper({ user: ME }) },
+    );
+    await waitFor(() => expect(result.current.ratings.canRate("a-1")).toBe(true));
+    act(() => result.current.feedback.rate(1));
+    await waitFor(() => expect(result.current.ratings.ratingOf("a-1")).toBe(1));
+    expect(result.current.ratings.canRate("a-9")).toBe(false);
+    expect(calls("get", ratingsPath)).toHaveLength(1);
+  });
+});
+
+describe("catch me up", () => {
+  const summaryPath = "/public/community-agent/posts/post-1/summary";
+
+  it("posts the profile and community and keeps the summary until dismissed", async () => {
+    installAdapter([post(summaryPath, () => ({ summary: "Three people agreed on Berlin.", agentName: "Assistant" }))]);
+    const { result } = renderHook(() => useCommunityCatchUp("post-1"), { wrapper: wrapper({ user: ME }) });
+    act(() => result.current.ask());
+    await waitFor(() => expect(result.current.summary).not.toBeNull());
+    expect(result.current.summary).toEqual({ summary: "Three people agreed on Berlin.", agentName: "Assistant" });
+    expect(calls("post", summaryPath)[0].body).toEqual({ profileId: PROFILE_ID, communityId: COMMUNITY.id });
+    act(() => result.current.dismiss());
+    expect(result.current.summary).toBeNull();
+  });
+
+  it.each([
+    [409, "daily_limit"],
+    [400, "unavailable"],
+    [500, "failed"],
+  ])("maps a %s to %s", async (status, error) => {
+    installAdapter([
+      post(summaryPath, () => {
+        throw { status };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityCatchUp("post-1"), { wrapper: wrapper({ user: ME }) });
+    act(() => result.current.ask());
+    await waitFor(() => expect(result.current.error).toBe(error));
+    expect(result.current.summary).toBeNull();
+  });
+});
+
+describe("linkifyText", () => {
+  it("makes the Sources addresses links and keeps everything else as text", () => {
+    const text = "Yes.\n\nSources:\n- Refunds: https://fans.example.com/c/fan-club/wiki/refunds.\n- Tour (no link)";
+    const segments = linkifyText(text);
+    const links = segments.filter((s) => s.kind === "link");
+    expect(links).toEqual([
+      { kind: "link", text: "https://fans.example.com/c/fan-club/wiki/refunds", url: "https://fans.example.com/c/fan-club/wiki/refunds" },
+    ]);
+    expect(segments.map((s) => s.text).join("")).toBe(text);
+  });
+
+  it("never links a non-http scheme", () => {
+    expect(linkifyText("javascript:alert(1) and ftp://x").every((s) => s.kind === "text")).toBe(true);
+  });
+
+  it("shows a titled source as its title, linking to its address", () => {
+    const text = "Yes.\n\nSources:\n- [How it works](https://fans.example.com/c/fan-club/wiki/how-it-works)\n- [FAQ](https://fans.example.com/c/fan-club/wiki/faq)\n- Tour";
+    expect(linkifyText(text)).toEqual([
+      { kind: "text", text: "Yes.\n\nSources:\n- " },
+      { kind: "link", text: "How it works", url: "https://fans.example.com/c/fan-club/wiki/how-it-works" },
+      { kind: "text", text: "\n- " },
+      { kind: "link", text: "FAQ", url: "https://fans.example.com/c/fan-club/wiki/faq" },
+      { kind: "text", text: "\n- Tour" },
+    ]);
+  });
+
+  it("never turns a titled link with a non-http address into a link", () => {
+    const segments = linkifyText("[Click me](javascript:alert(1)) and [Data](data:text/html,x)");
+    expect(segments.every((s) => s.kind === "text")).toBe(true);
+    expect(segments.map((s) => s.text).join("")).toBe("[Click me](javascript:alert(1)) and [Data](data:text/html,x)");
+  });
+});
+
+describe("communityContentHeld: held content leaves open feeds and threads", () => {
+  const SPACE = "space-1";
+  const feedPost = (id: string, authorAccountId: string): CommunityPost =>
+    ({ id, spaceId: SPACE, authorAccountId, replyCount: 2, status: "published" }) as CommunityPost;
+  const reply = (id: string, authorAccountId: string): CommunityReply =>
+    ({ id, postId: "p1", authorAccountId, parentReplyId: null, status: "published" }) as CommunityReply;
+  const page = <T,>(data: T[]) => ({ pages: [{ data, total: data.length, page: 1, pageSize: 20, hasNextPage: false }], pageParams: [1] });
+
+  it("drops another member's held post from the feed and the open post", () => {
+    const qc = new QueryClient();
+    qc.setQueryData(communityKeys.posts(SPACE), page([feedPost("p1", "someone"), feedPost("p2", "someone")]));
+    qc.setQueryData(communityKeys.post("p1"), feedPost("p1", "someone"));
+    applyCommunityContentHeld(qc, { spaceId: SPACE, entityType: "community_post", postId: "p1", replyId: null }, ME.id);
+    const feed = qc.getQueryData<any>(communityKeys.posts(SPACE));
+    expect(feed.pages[0].data.map((p: CommunityPost) => p.id)).toEqual(["p2"]);
+    expect(feed.pages[0].total).toBe(1);
+    expect(qc.getQueryData(communityKeys.post("p1"))).toBeNull();
+  });
+
+  it("keeps its author's own held post, marked as waiting", () => {
+    const qc = new QueryClient();
+    qc.setQueryData(communityKeys.posts(SPACE), page([feedPost("p1", ME.id)]));
+    applyCommunityContentHeld(qc, { spaceId: SPACE, entityType: "community_post", postId: "p1", replyId: null }, ME.id);
+    const feed = qc.getQueryData<any>(communityKeys.posts(SPACE));
+    expect(feed.pages[0].data).toEqual([expect.objectContaining({ id: "p1", status: "pending" })]);
+  });
+
+  it("drops a held reply from the thread and lowers the reply counts", () => {
+    const qc = new QueryClient();
+    qc.setQueryData(communityKeys.replies("p1"), page([reply("r1", "someone"), reply("r2", "someone")]));
+    qc.setQueryData(communityKeys.post("p1"), feedPost("p1", "someone"));
+    qc.setQueryData(communityKeys.posts(SPACE), page([feedPost("p1", "someone")]));
+    applyCommunityContentHeld(qc, { spaceId: SPACE, entityType: "community_reply", postId: "p1", replyId: "r1" }, ME.id);
+    const replies = qc.getQueryData<any>(communityKeys.replies("p1"));
+    expect(replies.pages[0].data.map((r: CommunityReply) => r.id)).toEqual(["r2"]);
+    expect(qc.getQueryData<CommunityPost>(communityKeys.post("p1"))?.replyCount).toBe(1);
+    expect(qc.getQueryData<any>(communityKeys.posts(SPACE)).pages[0].data[0].replyCount).toBe(1);
+  });
+
+  it("is a no-op for a reply that is not loaded", () => {
+    const qc = new QueryClient();
+    qc.setQueryData(communityKeys.post("p1"), feedPost("p1", "someone"));
+    applyCommunityContentHeld(qc, { spaceId: SPACE, entityType: "community_reply", postId: "p1", replyId: "nope" }, ME.id);
+    expect(qc.getQueryData<CommunityPost>(communityKeys.post("p1"))?.replyCount).toBe(2);
+  });
+});