@tribe-nest/forge 3.59.0 → 3.61.0

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

@@ -0,0 +1,389 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  buildPollPayload,
+  emptyPollDraft,
+  pollHiddenReason,
+  pollOptionPercent,
+  pollVoteErrorCode,
+  sameAnswer,
+  useCommunityPoll,
+  useCommunityPollDraft,
+  validatePollDraft,
+  type CommunityPollDraft,
+} from "../community/communityPoll";
+import { useCommunitySpaceFeed } from "../community/useCommunitySpaceFeed";
+import { wikiUnlockParts } from "../communities/useCommunityWiki";
+import { useCommunitySpacePosts, type CommunityPollView, type CommunityPost } from "../../../data/queries/useCommunity";
+import { COMMUNITY, calls, get, installAdapter, post, restoreAdapter, wrapper } from "./communityHarness";
+
+/**
+ * Polls on community posts and the level locks, headless: the composer's
+ * checks (the server's limits, so a draft that passes is not refused for its
+ * shape), the body the draft becomes, the vote request and the caches it
+ * patches, and a level-locked space that is never asked for.
+ */
+
+afterEach(restoreAdapter);
+
+const NOW = new Date("2026-09-30T12:00:00Z").getTime();
+
+const draft = (overrides: Partial<CommunityPollDraft> = {}): CommunityPollDraft => ({
+  ...emptyPollDraft(),
+  question: "Which day works?",
+  options: ["Monday", "Tuesday"],
+  ...overrides,
+});
+
+describe("validatePollDraft (the composer's checks)", () => {
+  it("passes a complete draft", () => {
+    const errors = validatePollDraft(draft(), NOW);
+    expect(errors.valid).toBe(true);
+    expect(errors).toMatchObject({ question: null, options: [null, null], optionsList: null, closesAt: null });
+  });
+
+  it("needs a question, and at most 200 characters of it", () => {
+    expect(validatePollDraft(draft({ question: "   " }), NOW)).toMatchObject({ question: "question_required", valid: false });
+    expect(validatePollDraft(draft({ question: "x".repeat(201) }), NOW).question).toBe("question_too_long");
+    expect(validatePollDraft(draft({ question: "x".repeat(200) }), NOW).question).toBeNull();
+  });
+
+  it("needs 2 to 10 options", () => {
+    expect(validatePollDraft(draft({ options: ["Only"] }), NOW)).toMatchObject({ optionsList: "options_too_few", valid: false });
+    const eleven = Array.from({ length: 11 }, (_, i) => `Option ${i}`);
+    expect(validatePollDraft(draft({ options: eleven }), NOW).optionsList).toBe("options_too_many");
+    const ten = eleven.slice(0, 10);
+    expect(validatePollDraft(draft({ options: ten }), NOW).valid).toBe(true);
+  });
+
+  it("marks each empty, overlong or repeated option where it is", () => {
+    const errors = validatePollDraft(draft({ options: ["Yes", " ", "x".repeat(121), " yes ", "x".repeat(120)] }), NOW);
+    expect(errors.options).toEqual([null, "option_empty", "option_too_long", "option_duplicate", null]);
+    expect(errors.valid).toBe(false);
+  });
+
+  it("wants a close time in the future, or none", () => {
+    expect(validatePollDraft(draft({ closesAt: "2026-09-29T10:00" }), NOW).closesAt).toBe("closes_in_past");
+    expect(validatePollDraft(draft({ closesAt: "not a date" }), NOW).closesAt).toBe("closes_invalid");
+    expect(validatePollDraft(draft({ closesAt: "2026-10-02T10:00" }), NOW).closesAt).toBeNull();
+  });
+
+  it("needs a close time when the results wait for the close", () => {
+    expect(validatePollDraft(draft({ resultsVisibility: "after_close" }), NOW).closesAt).toBe("closes_required");
+    expect(
+      validatePollDraft(draft({ resultsVisibility: "after_close", closesAt: "2026-10-02T10:00" }), NOW).valid,
+    ).toBe(true);
+  });
+});
+
+describe("buildPollPayload (what the create-post call carries)", () => {
+  it("sends the trimmed question as the title and the poll beside it", () => {
+    const payload = buildPollPayload(
+      draft({
+        question: "  Which day works?  ",
+        options: [" Monday ", "Tuesday "],
+        multipleChoice: true,
+        closesAt: "2026-10-02T10:00",
+        resultsVisibility: "always",
+      }),
+    );
+    expect(payload).toEqual({
+      title: "Which day works?",
+      poll: {
+        options: ["Monday", "Tuesday"],
+        multipleChoice: true,
+        closesAt: new Date("2026-10-02T10:00").toISOString(),
+        resultsVisibility: "always",
+      },
+    });
+  });
+
+  it("no close time is null, and the default visibility is after_vote", () => {
+    expect(buildPollPayload(draft()).poll).toEqual({
+      options: ["Monday", "Tuesday"],
+      multipleChoice: false,
+      closesAt: null,
+      resultsVisibility: "after_vote",
+    });
+  });
+});
+
+describe("useCommunityPollDraft", () => {
+  it("keeps between 2 and 10 options", () => {
+    const { result } = renderHook(() => useCommunityPollDraft());
+    expect(result.current.draft.options).toHaveLength(2);
+    expect(result.current.canRemoveOption).toBe(false);
+    act(() => result.current.removeOption(0));
+    expect(result.current.draft.options).toHaveLength(2);
+    for (let i = 0; i < 12; i++) act(() => result.current.addOption());
+    expect(result.current.draft.options).toHaveLength(10);
+    expect(result.current.canAddOption).toBe(false);
+    act(() => result.current.removeOption(3));
+    expect(result.current.draft.options).toHaveLength(9);
+  });
+
+  it("shows errors only once a submit was tried", () => {
+    const { result } = renderHook(() => useCommunityPollDraft());
+    expect(result.current.showErrors).toBe(false);
+    let ok = true;
+    act(() => {
+      ok = result.current.attempt();
+    });
+    expect(ok).toBe(false);
+    expect(result.current.showErrors).toBe(true);
+    expect(result.current.errors.question).toBe("question_required");
+  });
+});
+
+describe("reading a poll", () => {
+  const poll = (overrides: Partial<CommunityPollView> = {}): CommunityPollView => ({
+    id: "poll-1",
+    multipleChoice: false,
+    closesAt: null,
+    closed: false,
+    resultsVisibility: "after_vote",
+    resultsVisible: false,
+    totalVoters: null,
+    myVotes: [],
+    options: [],
+    ...overrides,
+  });
+
+  it("percentages are of the voters, and hidden counts stay hidden", () => {
+    expect(pollOptionPercent(1, 3)).toBe(33);
+    expect(pollOptionPercent(0, 0)).toBe(0);
+    expect(pollOptionPercent(null, null)).toBeNull();
+  });
+
+  it("says why the counts are hidden", () => {
+    expect(pollHiddenReason(poll())).toBe("after_vote");
+    expect(pollHiddenReason(poll({ resultsVisibility: "after_close" }))).toBe("after_close");
+    expect(pollHiddenReason(poll({ resultsVisible: true }))).toBeNull();
+  });
+
+  it("names a failed vote by its status", () => {
+    const err = (status: number) => ({ response: { status } });
+    expect(pollVoteErrorCode(err(409))).toBe("closed");
+    expect(pollVoteErrorCode(err(400))).toBe("invalid");
+    expect(pollVoteErrorCode(err(403))).toBe("forbidden");
+    expect(pollVoteErrorCode(new Error("network"))).toBe("generic");
+  });
+
+  it("an answer is the same answer in any order", () => {
+    expect(sameAnswer(["a", "b"], ["b", "a"])).toBe(true);
+    expect(sameAnswer(["a"], ["a", "b"])).toBe(false);
+  });
+});
+
+// ── Voting, against the real data hooks ──────────────────────────────────────
+
+const OPTION_A = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+const OPTION_B = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+
+const openPoll = (overrides: Partial<CommunityPollView> = {}): CommunityPollView => ({
+  id: "poll-1",
+  multipleChoice: false,
+  closesAt: null,
+  closed: false,
+  resultsVisibility: "after_vote",
+  resultsVisible: false,
+  totalVoters: null,
+  myVotes: [],
+  options: [
+    { id: OPTION_A, label: "Monday", position: 0, votes: null },
+    { id: OPTION_B, label: "Tuesday", position: 1, votes: null },
+  ],
+  ...overrides,
+});
+
+const feedPost = (poll: CommunityPollView): CommunityPost => ({
+  id: "post-1",
+  profileId: "profile-1",
+  spaceId: "space-1",
+  authorAccountId: "acct-2",
+  title: "Which day works?",
+  body: null,
+  bodyText: "",
+  isPinned: false,
+  isLocked: false,
+  replyCount: 0,
+  reactionCount: 0,
+  lastActivityAt: null,
+  createdAt: "2026-09-30T10:00:00.000Z",
+  author: null,
+  media: [],
+  reactions: [],
+  poll,
+});
+
+const page = (posts: CommunityPost[]) => ({
+  data: posts,
+  total: posts.length,
+  page: 1,
+  pageSize: 20,
+  hasNextPage: false,
+  nextPage: null,
+});
+
+/** The feed and a poll on its first post, sharing one query client. */
+function useFeedAndPoll() {
+  const feed = useCommunitySpacePosts("space-1");
+  const first = feed.data?.pages[0]?.data[0];
+  const poll = useCommunityPoll(first ?? { id: "post-1", spaceId: "space-1", poll: null });
+  return { feed, first, poll };
+}
+
+describe("useCommunityPoll voting", () => {
+  it("sends the member's whole answer and puts the answer the server gives into the feed", async () => {
+    const answered = openPoll({
+      resultsVisible: true,
+      totalVoters: 4,
+      myVotes: [OPTION_B],
+      options: [
+        { id: OPTION_A, label: "Monday", position: 0, votes: 1 },
+        { id: OPTION_B, label: "Tuesday", position: 1, votes: 3 },
+      ],
+    });
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll())])),
+      post("/public/community/posts/post-1/poll/vote", () => answered),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.first?.poll?.id).toBe("poll-1"));
+    expect(result.current.poll.choosing).toBe(true);
+
+    // Single choice: picking another option replaces the first.
+    act(() => result.current.poll.toggle(OPTION_A));
+    act(() => result.current.poll.toggle(OPTION_B));
+    expect(result.current.poll.selection).toEqual([OPTION_B]);
+    await act(async () => {
+      await result.current.poll.submit();
+    });
+
+    expect(calls("post", "/public/community/posts/post-1/poll/vote").map((c) => c.body)).toEqual([
+      { profileId: "profile-1", communityId: COMMUNITY.id, optionIds: [OPTION_B] },
+    ]);
+    // The feed cache now holds the server's answer: counts shown, the vote on record.
+    await waitFor(() => expect(result.current.first?.poll).toEqual(answered));
+    expect(result.current.poll.hasVoted).toBe(true);
+    expect(result.current.poll.choosing).toBe(false);
+  });
+
+  it("withdrawing sends an empty answer", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () =>
+        page([feedPost(openPoll({ myVotes: [OPTION_A], resultsVisible: true, totalVoters: 1 }))]),
+      ),
+      post("/public/community/posts/post-1/poll/vote", () => openPoll()),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.hasVoted).toBe(true));
+    await act(async () => {
+      await result.current.poll.withdraw();
+    });
+    expect(calls("post", "/public/community/posts/post-1/poll/vote")[0].body).toMatchObject({ optionIds: [] });
+    await waitFor(() => expect(result.current.first?.poll?.myVotes).toEqual([]));
+  });
+
+  it("a multiple-choice poll collects several options", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll({ multipleChoice: true }))])),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.poll?.multipleChoice).toBe(true));
+    act(() => result.current.poll.toggle(OPTION_A));
+    act(() => result.current.poll.toggle(OPTION_B));
+    expect(result.current.poll.selection).toEqual([OPTION_A, OPTION_B]);
+    act(() => result.current.poll.toggle(OPTION_A));
+    expect(result.current.poll.selection).toEqual([OPTION_B]);
+  });
+
+  it("a 409 reads as closed, and the feed keeps the old poll", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll())])),
+      post("/public/community/posts/post-1/poll/vote", () => {
+        throw { status: 409, message: "This poll has closed." };
+      }),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.poll).not.toBeNull());
+    act(() => result.current.poll.toggle(OPTION_A));
+    await act(async () => {
+      await result.current.poll.submit();
+    });
+    expect(result.current.poll.error).toBe("closed");
+    expect(result.current.first?.poll?.myVotes).toEqual([]);
+  });
+
+  it("a closed poll takes no vote", async () => {
+    installAdapter([
+      get("/public/community/spaces/space-1/posts", () => page([feedPost(openPoll({ closed: true }))])),
+    ]);
+    const { result } = renderHook(() => useFeedAndPoll(), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.poll.closed).toBe(true));
+    expect(result.current.poll.canVote).toBe(false);
+    expect(result.current.poll.choosing).toBe(false);
+    act(() => result.current.poll.toggle(OPTION_A));
+    expect(result.current.poll.selection).toEqual([]);
+  });
+});
+
+// ── Level locks ──────────────────────────────────────────────────────────────
+
+const space = (overrides: Record<string, unknown> = {}) => ({
+  id: "space-1",
+  profileId: "profile-1",
+  name: "Inner circle",
+  slug: "inner-circle",
+  description: null,
+  type: "feed",
+  courseId: null,
+  order: 0,
+  archivedAt: null,
+  createdAt: "2026-09-01T00:00:00.000Z",
+  tiers: [],
+  postCount: 3,
+  memberCount: 2,
+  isJoined: false,
+  minLevel: 1,
+  levelLocked: false,
+  ...overrides,
+});
+
+describe("useCommunitySpaceFeed and a level-locked space", () => {
+  it("is resolved from the list but its posts are never asked for", async () => {
+    installAdapter([get("/public/community/spaces", () => [space({ minLevel: 3, levelLocked: true })])]);
+    const { result } = renderHook(() => useCommunitySpaceFeed("inner-circle"), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.space?.id).toBe("space-1"));
+    expect(result.current.levelLocked).toBe(true);
+    expect(result.current.minLevel).toBe(3);
+    expect(calls("get", /\/posts$/)).toHaveLength(0);
+  });
+
+  it("an open space loads its posts", async () => {
+    installAdapter([
+      get("/public/community/spaces", () => [space()]),
+      get("/public/community/spaces/space-1/posts", () => page([])),
+    ]);
+    const { result } = renderHook(() => useCommunitySpaceFeed("space-1"), { wrapper: wrapper() });
+    await waitFor(() => expect(calls("get", "/public/community/spaces/space-1/posts")).toHaveLength(1));
+    expect(result.current.levelLocked).toBe(false);
+  });
+});
+
+describe("wikiUnlockParts", () => {
+  it("names the level, the tiers, or both", () => {
+    expect(wikiUnlockParts({ unlockLevel: 4, unlockTiers: [] })).toEqual({ level: 4, tiers: "" });
+    expect(wikiUnlockParts({ unlockLevel: 4, unlockTiers: [{ id: "t", name: "Gold" }] })).toEqual({
+      level: 4,
+      tiers: "Gold",
+    });
+    expect(wikiUnlockParts({ unlockLevel: null, unlockTiers: [{ id: "t", name: "Gold" }] })).toEqual({
+      level: null,
+      tiers: "Gold",
+    });
+    // An older server sends no unlockLevel at all.
+    expect(wikiUnlockParts({ unlockTiers: [] })).toEqual({ level: null, tiers: "" });
+  });
+});

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

@@ -0,0 +1,151 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { render, renderHook, waitFor } from "@testing-library/react";
+import { useCommunitySpaces, useCommunityLeaderboard } from "../../../data/queries/useCommunity";
+import { useChatChannels } from "../../../data/queries/useChat";
+import { useGetPosts, useGetSavedPosts } from "../../../data/queries/usePosts";
+import { useGetPostCollection, useGetPostCollections } from "../../../data/queries/usePostCollections";
+import { useMyMembershipCalls } from "../../../data/queries/useMembershipCalls";
+import type { ReactNode } from "react";
+import { CommunityProvider, useCommunityContext } from "../../../contexts/CommunityContext";
+import { useMemberHomeNav } from "../memberHome/useMemberHomeNav";
+import { useCommunityJoin } from "../communities/useCommunityJoin";
+import { COMMUNITY, OTHER_COMMUNITY, calls, detailRoute, get, installAdapter, restoreAdapter, wrapper } from "./communityHarness";
+
+/**
+ * `<CommunityProvider>` is how every member-content hook learns WHICH community
+ * it is reading. A profile runs several, each fully isolated, so a hook outside
+ * a provider must refuse (a developer error naming the provider) rather than
+ * fetch "the profile's" content, and inside one it must send the community and
+ * key its cache by it.
+ */
+
+afterEach(restoreAdapter);
+
+const PROVIDER_ERROR = /must be used inside <CommunityProvider/;
+
+describe("outside a provider, every member-content hook refuses", () => {
+  const cases: Array<[string, () => unknown]> = [
+    ["useCommunitySpaces", () => useCommunitySpaces()],
+    ["useCommunityLeaderboard", () => useCommunityLeaderboard()],
+    ["useChatChannels", () => useChatChannels()],
+    ["useGetPosts", () => useGetPosts()],
+    ["useGetSavedPosts", () => useGetSavedPosts()],
+    ["useGetPostCollections", () => useGetPostCollections()],
+    ["useMyMembershipCalls", () => useMyMembershipCalls()],
+    ["useMemberHomeNav", () => useMemberHomeNav()],
+    ["useCommunityJoin", () => useCommunityJoin()],
+    ["useCommunityContext", () => useCommunityContext()],
+  ];
+  for (const [name, hook] of cases) {
+    it(`${name} throws a developer error that names the provider and the hook`, () => {
+      installAdapter([]);
+      expect(() => renderHook(hook, { wrapper: wrapper({ community: null }) })).toThrow(PROVIDER_ERROR);
+      expect(() => renderHook(hook, { wrapper: wrapper({ community: null }) })).toThrow(name);
+      // Nothing was fetched on the way to the error.
+      expect(calls("get", /\/public\/(community|chat|posts|post-collections|scheduled-calls)/)).toHaveLength(0);
+    });
+  }
+
+  it("a course-scoped call read needs no provider: a course belongs to no community", async () => {
+    installAdapter([get("/public/scheduled-calls/mine", () => [])]);
+    const { result } = renderHook(() => useMyMembershipCalls({ courseId: "course-1" }), { wrapper: wrapper({ community: null }) });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    const [req] = calls("get", "/public/scheduled-calls/mine");
+    expect(req.params).toMatchObject({ courseId: "course-1" });
+    expect(req.params?.communityId).toBeUndefined();
+  });
+});
+
+describe("inside a provider, the community is sent and keys the cache", () => {
+  it("sends communityId with every member-content read", async () => {
+    installAdapter([
+      get("/public/community/spaces", () => []),
+      get("/public/chat/channels", () => []),
+      get("/public/posts", () => ({ data: [], total: 0, page: 1, pageSize: 10, hasNextPage: false })),
+      get("/public/post-collections", () => ({ data: [], total: 0, page: 1, pageSize: 10 })),
+      get("/public/scheduled-calls/mine", () => []),
+    ]);
+    const { result } = renderHook(
+      () => ({
+        spaces: useCommunitySpaces(),
+        channels: useChatChannels(),
+        posts: useGetPosts(),
+        collections: useGetPostCollections(),
+        calls: useMyMembershipCalls(),
+      }),
+      { wrapper: wrapper() },
+    );
+    await waitFor(() => expect(Object.values(result.current).every((q) => q.isSuccess)).toBe(true));
+    for (const path of ["/public/community/spaces", "/public/chat/channels", "/public/posts", "/public/post-collections", "/public/scheduled-calls/mine"]) {
+      const [req] = calls("get", path);
+      expect(req?.params, path).toMatchObject({ profileId: "profile-1", communityId: COMMUNITY.id });
+    }
+  });
+
+  it("two communities on one page (one query cache) never share a cache entry", async () => {
+    installAdapter([
+      get("/public/community/spaces", (req) => [
+        { id: `space-of-${String(req.params?.communityId)}`, name: "Space", tiers: [] },
+      ]),
+    ]);
+    const seen: Record<string, string | undefined> = {};
+    function Spaces({ label }: { label: string }) {
+      seen[label] = useCommunitySpaces().data?.[0]?.id;
+      return null;
+    }
+    const Wrapper = wrapper({ community: null });
+    render(
+      <Wrapper>
+        <CommunityProvider community={COMMUNITY.slug} initialData={COMMUNITY}>
+          <Spaces label="a" />
+        </CommunityProvider>
+        <CommunityProvider community={OTHER_COMMUNITY.slug} initialData={OTHER_COMMUNITY}>
+          <Spaces label="b" />
+        </CommunityProvider>
+      </Wrapper>,
+    );
+    await waitFor(() => expect(seen.a && seen.b).toBeTruthy());
+    expect(seen.a).toBe(`space-of-${COMMUNITY.id}`);
+    expect(seen.b).toBe(`space-of-${OTHER_COMMUNITY.id}`);
+    expect(calls("get", "/public/community/spaces")).toHaveLength(2);
+  });
+
+  it("resolves a slug to the community's id before any member read goes out", async () => {
+    installAdapter([detailRoute(() => ({})), get("/public/community/spaces", () => [])]);
+    const Wrapper = wrapper({ community: null });
+    const { result } = renderHook(
+      () => {
+        const context = useCommunityContext();
+        const spaces = useCommunitySpaces();
+        return { context, spaces };
+      },
+      {
+        wrapper: ({ children }) => (
+          <Wrapper>
+            <ProviderBySlug>{children}</ProviderBySlug>
+          </Wrapper>
+        ),
+      },
+    );
+    expect(result.current.context.slug).toBe("fan-club");
+    await waitFor(() => expect(result.current.context.communityId).toBe(COMMUNITY.id));
+    await waitFor(() => expect(result.current.spaces.isSuccess).toBe(true));
+    expect(calls("get", "/public/community/spaces")[0].params).toMatchObject({ communityId: COMMUNITY.id });
+  });
+
+  it("a collection that is not in this community reads as not found, not as a crash", async () => {
+    installAdapter([
+      get(/^\/public\/post-collections\//, () => {
+        throw { status: 404 };
+      }),
+    ]);
+    const { result } = renderHook(() => useGetPostCollection("col-elsewhere"), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toBeNull();
+  });
+});
+
+function ProviderBySlug({ children }: { children: ReactNode }) {
+  return <CommunityProvider community="fan-club">{children}</CommunityProvider>;
+}

package/src/ui/headless/_tests/memberHomeBar.spec.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { buildMemberHomeBar } from "../memberHome/memberHomeBar";
+import type { MemberHomeNavKey } from "../memberHome/useMemberHomeNav";
+
+/**
+ * The phone's bottom bar: four slots in a fixed priority (Feed, Spaces, Chat,
+ * Alerts), filled from the fallback order when one of those is not shown, then
+ * "More" with everything else, grouped. Every shown item is in exactly one
+ * place.
+ */
+
+const items = (...keys: MemberHomeNavKey[]) => keys.map((key) => ({ key }));
+const keys = (list: Array<{ key: MemberHomeNavKey }>) => list.map((i) => i.key);
+const ALL: MemberHomeNavKey[] = [
+  "posts",
+  "collections",
+  "spaces",
+  "calendar",
+  "classroom",
+  "chat",
+  "leaderboard",
+  "notifications",
+  "members",
+  "wiki",
+  "moderation",
+];
+
+describe("buildMemberHomeBar", () => {
+  it("everything shown: Feed, Spaces, Chat, Alerts in the bar; the rest grouped under More", () => {
+    const model = buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "posts" });
+    expect(keys(model.bar)).toEqual(["posts", "spaces", "chat", "notifications"]);
+    expect(model.more.map((g) => g.group)).toEqual(["community", "you"]);
+    expect(keys(model.more[0]!.items)).toEqual(["collections", "calendar", "classroom", "wiki", "members", "leaderboard"]);
+    expect(keys(model.more[1]!.items)).toEqual(["moderation"]);
+    expect(model.moreActive).toBe(false);
+  });
+
+  it("no chat: the next item in the fallback order (calendar) takes its slot", () => {
+    const visible = items("posts", "spaces", "calendar", "classroom", "notifications", "members");
+    const model = buildMemberHomeBar({ visibleItems: visible, activeKey: null });
+    expect(keys(model.bar)).toEqual(["posts", "spaces", "notifications", "calendar"]);
+    expect(keys(model.more[0]!.items)).toEqual(["classroom", "members"]);
+  });
+
+  it("no spaces (so no alerts either): calendar, classroom fill in, in that order", () => {
+    const model = buildMemberHomeBar({ visibleItems: items("posts", "chat", "calendar", "classroom", "members", "wiki"), activeKey: null });
+    expect(keys(model.bar)).toEqual(["posts", "chat", "calendar", "classroom"]);
+    expect(keys(model.more[0]!.items)).toEqual(["wiki", "members"]);
+  });
+
+  it("the fallback reaches collections, leaderboard and moderation only when nothing ahead is shown", () => {
+    const model = buildMemberHomeBar({ visibleItems: items("posts", "collections", "moderation"), activeKey: null });
+    expect(keys(model.bar)).toEqual(["posts", "collections", "moderation"]);
+    expect(model.more).toEqual([]);
+  });
+
+  it("the active page under More highlights More, not a bar item", () => {
+    const model = buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "wiki" });
+    expect(model.moreActive).toBe(true);
+    expect(buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "chat" }).moreActive).toBe(false);
+    expect(buildMemberHomeBar({ visibleItems: items(...ALL), activeKey: "moderation" }).moreActive).toBe(true);
+  });
+
+  it("an active key that is not shown highlights nothing", () => {
+    const model = buildMemberHomeBar({ visibleItems: items("posts", "spaces"), activeKey: "wiki" });
+    expect(model.moreActive).toBe(false);
+  });
+
+  it("every shown item is in exactly one place, and nothing hidden appears", () => {
+    for (let n = 1; n <= ALL.length; n++) {
+      const visible = items(...ALL.slice(0, n));
+      const model = buildMemberHomeBar({ visibleItems: visible, activeKey: null });
+      const placed = [...keys(model.bar), ...model.more.flatMap((g) => keys(g.items))];
+      expect(placed.sort()).toEqual(keys(visible).sort());
+      expect(model.bar.length).toBeLessThanOrEqual(4);
+    }
+  });
+
+  it("keeps the caller's item objects, so hrefs and active flags pass through", () => {
+    const posts = { key: "posts" as const, href: "/i/communities/x/home", active: true };
+    const model = buildMemberHomeBar({ visibleItems: [posts], activeKey: "posts" });
+    expect(model.bar[0]).toBe(posts);
+  });
+});