@tribe-nest/forge 3.59.0 → 3.61.0

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

@@ -0,0 +1,179 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { communityDowngradeTiers, communityMembershipBilling, useCommunityMembership } from "../communities/useCommunityMembership";
+import { account, calls, detailRoute, installAdapter, meRoute, post, restoreAdapter, tier, viewer, wrapper } from "./communityHarness";
+
+/**
+ * The Membership menu: cancel keeps the paid period and is two-step, a
+ * downgrade waits for period end and can be withdrawn, and every action is
+ * addressed to THIS community.
+ */
+
+afterEach(restoreAdapter);
+
+const free = tier({ id: "tier-free", name: "Free" });
+const basic = tier({ id: "tier-basic", name: "Basic", priceMonthly: 5 });
+const gold = tier({ id: "tier-gold", name: "Gold", priceMonthly: 20 });
+const yearlyCheap = tier({ id: "tier-yearly", name: "Yearly", priceYearly: 60 });
+const apply = tier({ id: "tier-apply", name: "Apply", priceMonthly: 1, joinMode: "application" });
+
+let state = viewer();
+const onGold = (patch: Record<string, unknown> = {}) =>
+  viewer({
+    state: "member",
+    membership: {
+      id: "m-1",
+      tierId: "tier-gold",
+      tierName: "Gold",
+      status: "active",
+      cancelAtPeriodEnd: false,
+      currentPeriodEnd: "2026-10-27T00:00:00.000Z",
+      pendingDowngradeTierId: null,
+      ...patch,
+    },
+  });
+
+function install() {
+  installAdapter([
+    post("/public/communities/fan-club/membership/cancel", () => {
+      state = onGold({ cancelAtPeriodEnd: true });
+      return {};
+    }),
+    post("/public/communities/fan-club/membership/downgrade", (req) => {
+      state = onGold({ pendingDowngradeTierId: req.body?.membershipTierId });
+      return {};
+    }),
+    post("/public/communities/fan-club/membership/undo-downgrade", () => {
+      state = onGold();
+      return {};
+    }),
+    meRoute(() => state),
+    detailRoute(() => ({ tiers: [free, basic, gold, yearlyCheap, apply] })),
+  ]);
+}
+
+describe("communityDowngradeTiers", () => {
+  it("lists cheaper tiers of this community, on a monthly footing, never an application tier or an upgrade", () => {
+    const tiers = [free, basic, gold, yearlyCheap, apply];
+    expect(communityDowngradeTiers(tiers, "tier-gold", []).map((t) => t.id)).toEqual(["tier-free", "tier-basic", "tier-yearly"]);
+    expect(communityDowngradeTiers(tiers, "tier-gold", ["tier-basic"]).map((t) => t.id)).toEqual(["tier-free", "tier-yearly"]);
+    expect(communityDowngradeTiers(tiers, "tier-free", [])).toEqual([]);
+    expect(communityDowngradeTiers(tiers, null, [])).toEqual([]);
+  });
+});
+
+describe("communityMembershipBilling", () => {
+  it("reads the member's own subscription: amount, currency and cycle", () => {
+    expect(communityMembershipBilling({ amount: 12.5, currency: "EUR", billingCycle: "year" }, basic)).toEqual({
+      isPaid: true,
+      amount: 12.5,
+      currency: "EUR",
+      cycle: "year",
+    });
+  });
+
+  it("no price on the row is a free membership, whatever the tier says", () => {
+    expect(communityMembershipBilling({ amount: null, currency: null, billingCycle: null }, gold)).toEqual({
+      isPaid: false,
+      amount: null,
+      currency: null,
+      cycle: null,
+    });
+    expect(communityMembershipBilling({ amount: 0, currency: "USD", billingCycle: "month" }, gold).isPaid).toBe(false);
+  });
+
+  it("until the row arrives, the tier's own price decides paid or free, with no amount shown", () => {
+    expect(communityMembershipBilling(null, gold)).toEqual({ isPaid: true, amount: null, currency: null, cycle: null });
+    expect(communityMembershipBilling(null, free).isPaid).toBe(false);
+    expect(communityMembershipBilling(null, yearlyCheap).isPaid).toBe(true);
+    expect(communityMembershipBilling(undefined, null).isPaid).toBe(false);
+  });
+});
+
+describe("useCommunityMembership", () => {
+  it("shows the tier, the renewal date and what it can move down to", async () => {
+    state = onGold();
+    install();
+    const { result } = renderHook(() => useCommunityMembership(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.hasMembership).toBe(true));
+    expect(result.current.membership?.tierName).toBe("Gold");
+    expect(result.current.periodEnd).toBe("2026-10-27T00:00:00.000Z");
+    await waitFor(() => expect(result.current.downgradeTiers.map((t) => t.id)).toEqual(["tier-free", "tier-basic", "tier-yearly"]));
+  });
+
+  it("cancel asks first, then cancels in this community and keeps the period", async () => {
+    state = onGold();
+    install();
+    const { result } = renderHook(() => useCommunityMembership(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.hasMembership).toBe(true));
+    act(() => result.current.requestCancel());
+    expect(result.current.cancelRequested).toBe(true);
+    expect(calls("post", /cancel$/)).toHaveLength(0);
+
+    await act(async () => {
+      await result.current.confirmCancel();
+    });
+    expect(calls("post", "/public/communities/fan-club/membership/cancel")[0].body).toEqual({ profileId: "profile-1" });
+    await waitFor(() => expect(result.current.isCancelling).toBe(true));
+    expect(result.current.cancelRequested).toBe(false);
+  });
+
+  it("abort leaves the membership alone", async () => {
+    state = onGold();
+    install();
+    const { result } = renderHook(() => useCommunityMembership(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.hasMembership).toBe(true));
+    act(() => result.current.requestCancel());
+    act(() => result.current.abortCancel());
+    expect(result.current.cancelRequested).toBe(false);
+    expect(calls("post", /cancel$/)).toHaveLength(0);
+  });
+
+  it("downgrade waits for period end and shows as pending; undo withdraws it", async () => {
+    state = onGold();
+    install();
+    const { result } = renderHook(() => useCommunityMembership(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.hasMembership).toBe(true));
+
+    await act(async () => {
+      await result.current.downgrade("tier-basic");
+    });
+    expect(calls("post", "/public/communities/fan-club/membership/downgrade")[0].body).toEqual({
+      profileId: "profile-1",
+      membershipTierId: "tier-basic",
+    });
+    await waitFor(() => expect(result.current.pendingDowngradeTier?.name).toBe("Basic"));
+
+    await act(async () => {
+      await result.current.undoDowngrade();
+    });
+    expect(calls("post", "/public/communities/fan-club/membership/undo-downgrade")).toHaveLength(1);
+    await waitFor(() => expect(result.current.pendingDowngradeTier).toBeNull());
+  });
+
+  it("a refused action is reported, not swallowed", async () => {
+    state = onGold();
+    installAdapter([
+      post("/public/communities/fan-club/membership/cancel", () => {
+        throw { status: 400, message: "Already cancelled." };
+      }),
+      meRoute(() => state),
+      detailRoute(() => ({ tiers: [gold] })),
+    ]);
+    const { result } = renderHook(() => useCommunityMembership(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.hasMembership).toBe(true));
+    await act(async () => {
+      await result.current.cancel();
+    });
+    expect(result.current.error).toBe("Already cancelled.");
+  });
+
+  it("has nothing to manage for a non-member", async () => {
+    state = viewer();
+    install();
+    const { result } = renderHook(() => useCommunityMembership(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.hasMembership).toBe(false);
+  });
+});

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

@@ -0,0 +1,420 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  communityMuteUntil,
+  describeHoldReason,
+  describeModerationNotification,
+  moderationErrorMessage,
+  restorableLogEntries,
+  useCommunityModeration,
+  useCommunityModeratorActions,
+} from "../community/useCommunityModeration";
+import { useMemberHomeNav } from "../memberHome/useMemberHomeNav";
+import type { CommunityModerationLogEntry } from "../../../data/queries/useCommunityModeration";
+import {
+  COMMUNITY,
+  PROFILE_ID,
+  account,
+  calls,
+  get,
+  installAdapter,
+  post,
+  restoreAdapter,
+  wrapper,
+} from "./communityHarness";
+
+/**
+ * Moderation from the site. The server decides who may moderate; these pin
+ * what the site SENDS (every body names the profile, a mute names the
+ * community), that nothing is asked for until the viewer is known to moderate
+ * this community, and the small readings a renderer depends on: hold reasons
+ * in words, which log entries can still be undone, and which notifications
+ * carry a moderation outcome.
+ */
+
+afterEach(restoreAdapter);
+
+const me = (canModerate: boolean) =>
+  get("/public/community/me", () => ({
+    accountId: "account-1",
+    role: canModerate ? "moderator" : "member",
+    canModerate,
+  }));
+
+const QUEUE = {
+  reports: {
+    data: [
+      {
+        id: "rep-1",
+        entityType: "community_post",
+        entityId: "post-9",
+        reason: "spam",
+        reporterFirstName: "Ada",
+        reporterLastName: "L",
+        contentPreview: "buy now",
+        contentHidden: false,
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+    total: 1,
+  },
+  pending: {
+    posts: [
+      {
+        id: "post-1",
+        spaceId: "space-1",
+        spaceName: "General",
+        title: "Hello",
+        bodyText: "first post",
+        authorAccountId: "account-2",
+        authorName: "New Fan",
+        moderationReason: "approval_new_member",
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+    replies: [
+      {
+        id: "reply-1",
+        postId: "post-5",
+        postTitle: "Tour",
+        bodyText: "a reply",
+        authorAccountId: "account-3",
+        authorName: "Other Fan",
+        moderationReason: "keyword:spoiler",
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+  },
+};
+
+const logEntry = (overrides: Partial<CommunityModerationLogEntry>): CommunityModerationLogEntry => ({
+  id: "log-x",
+  action: "remove",
+  entityType: "community_post",
+  entityId: "post-1",
+  actorAccountId: "account-1",
+  targetAccountId: "account-2",
+  reason: null,
+  createdAt: "2026-09-01T00:00:00.000Z",
+  actorName: "Mod",
+  targetName: "Fan",
+  ...overrides,
+});
+
+describe("describeHoldReason", () => {
+  it("reads the three reasons the server writes", () => {
+    expect(describeHoldReason("approval_new_member")).toEqual({ kind: "new_member" });
+    expect(describeHoldReason("approval_all")).toEqual({ kind: "all_posts" });
+    expect(describeHoldReason("keyword:spoiler alert")).toEqual({ kind: "keyword", word: "spoiler alert" });
+  });
+
+  it("passes an unknown reason through, and nothing for none", () => {
+    expect(describeHoldReason("something_new")).toEqual({ kind: "other", raw: "something_new" });
+    expect(describeHoldReason(null)).toBeNull();
+    expect(describeHoldReason("")).toBeNull();
+  });
+});
+
+describe("communityMuteUntil", () => {
+  it("adds whole days to now", () => {
+    const now = new Date("2026-09-29T12:00:00.000Z");
+    expect(communityMuteUntil(1, now)).toBe("2026-09-30T12:00:00.000Z");
+    expect(communityMuteUntil(7, now)).toBe("2026-10-06T12:00:00.000Z");
+    expect(communityMuteUntil(30, now)).toBe("2026-10-29T12:00:00.000Z");
+  });
+});
+
+describe("moderationErrorMessage", () => {
+  it("returns the server's message, or null", () => {
+    const banned = { response: { status: 403, data: { message: "You can no longer take part in this community." } } };
+    expect(moderationErrorMessage(banned)).toBe("You can no longer take part in this community.");
+    expect(moderationErrorMessage(new Error("network"))).toBeNull();
+    expect(moderationErrorMessage({ response: { data: { message: "  " } } })).toBeNull();
+  });
+});
+
+describe("describeModerationNotification", () => {
+  it("reads an outcome on a post or reply", () => {
+    expect(
+      describeModerationNotification({
+        type: "mod",
+        entityType: "community_post",
+        data: { outcome: "approved", reason: null },
+      }),
+    ).toEqual({ outcome: "approved", subject: "post", reason: null });
+    expect(
+      describeModerationNotification({
+        type: "mod",
+        entityType: "community_reply",
+        data: { outcome: "rejected", reason: " off topic " },
+      }),
+    ).toEqual({ outcome: "rejected", subject: "reply", reason: "off topic" });
+  });
+
+  it("leaves the mute notice (about the community, no data) and other types alone", () => {
+    expect(describeModerationNotification({ type: "mod", entityType: "community", data: null })).toBeNull();
+    expect(describeModerationNotification({ type: "mod", entityType: "community", entityId: "c" } as never)).toBeNull();
+    expect(
+      describeModerationNotification({ type: "reply", entityType: "community_post", data: { outcome: "approved" } }),
+    ).toBeNull();
+    expect(
+      describeModerationNotification({ type: "mod", entityType: "community_post", data: { outcome: "maybe" } }),
+    ).toBeNull();
+  });
+});
+
+describe("restorableLogEntries", () => {
+  it("offers restore on a removal nothing newer has restored", () => {
+    const entries = [
+      logEntry({ id: "log-3", action: "remove", entityId: "post-2" }),
+      logEntry({ id: "log-2", action: "restore", entityId: "post-1" }),
+      logEntry({ id: "log-1", action: "remove", entityId: "post-1" }),
+    ];
+    const restorable = restorableLogEntries(entries);
+    expect([...restorable.keys()]).toEqual(["log-3"]);
+    expect(restorable.get("log-3")).toEqual({ type: "post", id: "post-2" });
+  });
+
+  it("covers a report resolved by hiding, and replies, and only the newest removal of one thing", () => {
+    const entries = [
+      logEntry({ id: "log-3", action: "report_resolved_hidden", entityType: "community_reply", entityId: "reply-1" }),
+      logEntry({ id: "log-2", action: "remove", entityType: "community_reply", entityId: "reply-1" }),
+      logEntry({ id: "log-1", action: "pin", entityId: "post-1" }),
+      logEntry({ id: "log-0", action: "mute", entityType: null, entityId: null }),
+    ];
+    const restorable = restorableLogEntries(entries);
+    expect([...restorable.keys()]).toEqual(["log-3"]);
+    expect(restorable.get("log-3")).toEqual({ type: "reply", id: "reply-1" });
+  });
+});
+
+describe("useCommunityModeration", () => {
+  it("asks for nothing and says so when the viewer does not moderate", async () => {
+    installAdapter([me(false)]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.isChecking).toBe(false));
+    expect(result.current.canModerate).toBe(false);
+    expect(calls("get", "/public/community-moderation/queue")).toHaveLength(0);
+    expect(calls("get", "/public/community-moderation/log")).toHaveLength(0);
+  });
+
+  it("asks for nothing when signed out", async () => {
+    installAdapter([me(true)]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper() });
+    expect(result.current.canModerate).toBe(false);
+    expect(calls("get", "/public/community/me")).toHaveLength(0);
+  });
+
+  it("loads the queue and the log for THIS community", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => QUEUE),
+      get("/public/community-moderation/log", () => ({
+        data: [logEntry({ id: "log-1" })],
+        total: 21,
+        page: 1,
+        pageSize: 20,
+        hasNextPage: true,
+      })),
+    ]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.reports).toHaveLength(1));
+    expect(result.current.pendingPosts[0].id).toBe("post-1");
+    expect(result.current.pendingReplies[0].id).toBe("reply-1");
+    expect(calls("get", "/public/community-moderation/queue")[0].params).toEqual({
+      profileId: PROFILE_ID,
+      communityId: COMMUNITY.id,
+    });
+
+    await waitFor(() => expect(result.current.log.entries).toHaveLength(1));
+    expect(result.current.log.hasNextPage).toBe(true);
+    expect(result.current.log.restorable.has("log-1")).toBe(true);
+    expect(calls("get", "/public/community-moderation/log")[0].params).toEqual({
+      profileId: PROFILE_ID,
+      communityId: COMMUNITY.id,
+      page: 1,
+      limit: 20,
+    });
+
+    act(() => result.current.log.nextPage());
+    await waitFor(() =>
+      expect(calls("get", "/public/community-moderation/log").some((r) => r.params?.page === 2)).toBe(true),
+    );
+  });
+
+  it("sends each queue action with the profile, and the reason where one is given", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => QUEUE),
+      get("/public/community-moderation/log", () => ({
+        data: [],
+        total: 0,
+        page: 1,
+        pageSize: 20,
+        hasNextPage: false,
+      })),
+      post("/public/community-moderation/reports/rep-1/resolve", () => ({ success: true })),
+      post("/public/community-moderation/posts/post-1/approve", () => ({ id: "post-1" })),
+      post("/public/community-moderation/posts/post-1/reject", () => ({ success: true })),
+      post("/public/community-moderation/replies/reply-1/reject", () => ({ success: true })),
+    ]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.reports).toHaveLength(1));
+
+    await act(async () => {
+      expect(await result.current.resolveReport("rep-1", "resolve_and_hide")).toBe(true);
+    });
+    expect(calls("post", "/public/community-moderation/reports/rep-1/resolve")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      action: "resolved",
+      hideContent: true,
+    });
+
+    await act(async () => {
+      await result.current.resolveReport("rep-1", "dismiss");
+    });
+    expect(calls("post", "/public/community-moderation/reports/rep-1/resolve")[1].body).toMatchObject({
+      action: "dismissed",
+      hideContent: false,
+    });
+
+    await act(async () => {
+      await result.current.approvePost({ id: "post-1" });
+      await result.current.rejectPost({ id: "post-1" }, "  off topic  ");
+      await result.current.rejectReply({ id: "reply-1", postId: "post-5" }, "");
+    });
+    expect(calls("post", "/public/community-moderation/posts/post-1/approve")[0].body).toEqual({
+      profileId: PROFILE_ID,
+    });
+    expect(calls("post", "/public/community-moderation/posts/post-1/reject")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      reason: "off topic",
+    });
+    // A blank reason is not sent at all.
+    expect(calls("post", "/public/community-moderation/replies/reply-1/reject")[0].body).toEqual({
+      profileId: PROFILE_ID,
+    });
+  });
+
+  it("keeps the server's refusal on the row it happened to (approving twice is a 409)", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => QUEUE),
+      get("/public/community-moderation/log", () => ({
+        data: [],
+        total: 0,
+        page: 1,
+        pageSize: 20,
+        hasNextPage: false,
+      })),
+      post("/public/community-moderation/posts/post-1/approve", () => {
+        throw { status: 409, message: "This is not waiting for approval." };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityModeration(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.pendingPosts).toHaveLength(1));
+    await act(async () => {
+      expect(await result.current.approvePost({ id: "post-1" })).toBe(false);
+    });
+    expect(result.current.error).toEqual({ id: "post-1", message: "This is not waiting for approval." });
+    expect(result.current.busyId).toBeNull();
+  });
+});
+
+describe("useCommunityModeratorActions", () => {
+  it("is not a moderator until /me says so", async () => {
+    installAdapter([me(false)]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(calls("get", "/public/community/me")).toHaveLength(1));
+    expect(result.current.canModerate).toBe(false);
+  });
+
+  it("pins, removes with a reason, and mutes the author in THIS community", async () => {
+    installAdapter([
+      me(true),
+      post("/public/community-moderation/posts/post-1/pin", () => ({ id: "post-1", isPinned: true })),
+      post("/public/community-moderation/posts/post-1/remove", () => ({ success: true })),
+      post("/public/community-moderation/replies/reply-1/remove", () => ({ success: true })),
+      post("/public/community-moderation/members/account-2/mute", () => ({ success: true })),
+    ]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.canModerate).toBe(true));
+    expect(result.current.currentAccountId).toBe("account-1");
+
+    const before = Date.now();
+    await act(async () => {
+      await result.current.pinPost({ id: "post-1" });
+      await result.current.removePost({ id: "post-1" }, "spam");
+      await result.current.removeReply({ id: "reply-1", postId: "post-1" });
+      await result.current.muteMember("account-2", 7);
+    });
+    expect(calls("post", "/public/community-moderation/posts/post-1/pin")[0].body).toEqual({ profileId: PROFILE_ID });
+    expect(calls("post", "/public/community-moderation/posts/post-1/remove")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      reason: "spam",
+    });
+    expect(calls("post", "/public/community-moderation/replies/reply-1/remove")[0].body).toEqual({
+      profileId: PROFILE_ID,
+    });
+
+    const mute = calls("post", "/public/community-moderation/members/account-2/mute")[0].body!;
+    expect(mute.profileId).toBe(PROFILE_ID);
+    expect(mute.communityId).toBe(COMMUNITY.id);
+    const until = new Date(mute.mutedUntil as string).getTime();
+    expect(until - before).toBeGreaterThanOrEqual(7 * 24 * 3600 * 1000 - 1000);
+    expect(until - before).toBeLessThan(7 * 24 * 3600 * 1000 + 60_000);
+  });
+
+  it("unmutes with a null time", async () => {
+    installAdapter([me(true), post("/public/community-moderation/members/account-2/mute", () => ({ success: true }))]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.canModerate).toBe(true));
+    await act(async () => {
+      await result.current.unmuteMember("account-2");
+    });
+    expect(calls("post", "/public/community-moderation/members/account-2/mute")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      communityId: COMMUNITY.id,
+      mutedUntil: null,
+    });
+  });
+
+  it("surfaces a refusal as the server worded it", async () => {
+    installAdapter([
+      me(true),
+      post("/public/community-moderation/posts/post-1/lock", () => {
+        throw { status: 404, message: "Post not found" };
+      }),
+    ]);
+    const { result } = renderHook(() => useCommunityModeratorActions(), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(result.current.canModerate).toBe(true));
+    await act(async () => {
+      expect(await result.current.lockPost({ id: "post-1" })).toBe(false);
+    });
+    expect(result.current.failed).toBe(true);
+    expect(result.current.error).toBe("Post not found");
+  });
+});
+
+describe("the Moderation tab in the member home nav", () => {
+  it("shows only to a moderator of this community", async () => {
+    installAdapter([me(true)]);
+    const { result } = renderHook(() => useMemberHomeNav({ currentPath: "/i/communities/fan-club/home/moderation" }), {
+      wrapper: wrapper({ user: account() }),
+    });
+    await waitFor(() => expect(result.current.visibleItems.map((i) => i.key)).toContain("moderation"));
+    expect(result.current.activeKey).toBe("moderation");
+    expect(result.current.items.find((i) => i.key === "moderation")?.href).toBe(
+      "/i/communities/fan-club/home/moderation",
+    );
+  });
+
+  it("stays hidden for a member who does not moderate", async () => {
+    installAdapter([me(false)]);
+    const { result } = renderHook(() => useMemberHomeNav({}), { wrapper: wrapper({ user: account() }) });
+    await waitFor(() => expect(calls("get", "/public/community/me")).toHaveLength(1));
+    await waitFor(() => expect(result.current.isReady).toBe(true));
+    expect(result.current.visibleItems.map((i) => i.key)).not.toContain("moderation");
+  });
+});