@tribe-nest/forge 3.60.0 → 3.61.0

package/src/ui/styled/community/_tests/CommunityLinkPreview.spec.tsx

@@ -0,0 +1,167 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { ForgeThemeProvider } from "../../../theme/ForgeThemeProvider";
+import { CommunityLinkPreview } from "../CommunityLinkPreview";
+import { CommunityPostCard } from "../CommunityPostCard";
+import type { CommunityLinkPreview as Preview, CommunityPost } from "../../../../data/queries/useCommunity";
+import { linkPreviewDisplay, safeEmbedUrl, safeHttpUrl } from "../../../headless/community/linkPreview";
+import { account, installAdapter, restoreAdapter, wrapper } from "../../../headless/_tests/communityHarness";
+
+/**
+ * Link cards on posts: a plain link card that leaves the site without a
+ * referrer or an opener, a video that loads NO player until pressed, and a
+ * video from an origin we do not allow shown as a plain link card instead.
+ */
+
+beforeEach(() => installAdapter([]));
+
+afterEach(() => {
+  cleanup();
+  restoreAdapter();
+});
+
+const theme = { colors: { text: "#111111", background: "#ffffff", primary: "#6d28d9" }, cornerRadius: 8 };
+
+function mount(node: ReactNode) {
+  const Wrapper = wrapper({ user: account() });
+  return render(
+    <Wrapper>
+      <ForgeThemeProvider theme={theme}>{node}</ForgeThemeProvider>
+    </Wrapper>,
+  );
+}
+
+const linkCard = (overrides: Partial<Preview> = {}): Preview => ({
+  url: "https://news.example.com/story",
+  kind: "link",
+  provider: null,
+  siteName: "Example News",
+  title: "Shared article",
+  description: "Worth a read",
+  imageUrl: "https://news.example.com/og.jpg",
+  embedUrl: null,
+  ...overrides,
+});
+
+const video = (overrides: Partial<Preview> = {}): Preview => ({
+  url: "https://www.youtube.com/watch?v=abc123",
+  kind: "video",
+  provider: "youtube",
+  siteName: "YouTube",
+  title: "Studio session",
+  description: null,
+  imageUrl: "https://i.ytimg.com/vi/abc123/hqdefault.jpg",
+  embedUrl: "https://www.youtube-nocookie.com/embed/abc123",
+  ...overrides,
+});
+
+describe("link preview helpers", () => {
+  it("allows only http(s) links", () => {
+    expect(safeHttpUrl("https://example.com/a")).toBe("https://example.com/a");
+    expect(safeHttpUrl("javascript:alert(1)")).toBeNull();
+    expect(safeHttpUrl("data:text/html,hi")).toBeNull();
+    expect(safeHttpUrl("not a url")).toBeNull();
+  });
+
+  it("plays only from the allowed embed origins", () => {
+    expect(safeEmbedUrl(video())).toBe("https://www.youtube-nocookie.com/embed/abc123");
+    expect(safeEmbedUrl(video({ embedUrl: "https://player.vimeo.com/video/42" }))).toBe("https://player.vimeo.com/video/42");
+    expect(safeEmbedUrl(video({ embedUrl: "https://www.loom.com/embed/xyz" }))).toBe("https://www.loom.com/embed/xyz");
+    expect(safeEmbedUrl(video({ embedUrl: "https://www.youtube.com/embed/abc123" }))).toBeNull();
+    expect(safeEmbedUrl(video({ embedUrl: "https://evil.example/embed" }))).toBeNull();
+    expect(safeEmbedUrl(video({ embedUrl: "http://player.vimeo.com/video/42" }))).toBeNull();
+    expect(safeEmbedUrl(linkCard({ embedUrl: "https://player.vimeo.com/video/42" }))).toBeNull();
+  });
+
+  it("renders nothing for a preview with no safe link", () => {
+    expect(linkPreviewDisplay(linkCard({ url: "javascript:alert(1)" }))).toBeNull();
+    expect(linkPreviewDisplay(null)).toBeNull();
+  });
+});
+
+describe("CommunityLinkPreview", () => {
+  it("shows a link card that opens in a new tab with no referrer or opener", () => {
+    mount(<CommunityLinkPreview preview={linkCard()} />);
+    const card = screen.getByTestId("community-link-card");
+    expect(card.getAttribute("href")).toBe("https://news.example.com/story");
+    expect(card.getAttribute("target")).toBe("_blank");
+    expect(card.getAttribute("rel")).toBe("noopener noreferrer nofollow ugc");
+    expect(card.textContent).toContain("Example News");
+    expect(card.textContent).toContain("Shared article");
+    expect(card.textContent).toContain("Worth a read");
+    const image = card.querySelector("img")!;
+    expect(image.getAttribute("src")).toBe("https://news.example.com/og.jpg");
+    expect(image.getAttribute("referrerpolicy")).toBe("no-referrer");
+    expect(image.getAttribute("loading")).toBe("lazy");
+  });
+
+  it("does not load the video player until play is pressed", () => {
+    const { container } = mount(<CommunityLinkPreview preview={video()} />);
+    expect(container.querySelector("iframe")).toBeNull();
+    const thumbnail = container.querySelector("img")!;
+    expect(thumbnail.getAttribute("referrerpolicy")).toBe("no-referrer");
+    fireEvent.click(screen.getByRole("button", { name: "Play Studio session" }));
+    const frame = screen.getByTestId("community-link-video-frame");
+    expect(frame.getAttribute("src")).toBe("https://www.youtube-nocookie.com/embed/abc123?autoplay=1");
+    expect(frame.getAttribute("allow")).toBe("autoplay; fullscreen; picture-in-picture");
+    expect(frame.getAttribute("referrerpolicy")).toBe("strict-origin-when-cross-origin");
+    expect(frame.getAttribute("loading")).toBe("lazy");
+    expect(frame.getAttribute("title")).toBe("Studio session");
+  });
+
+  it("shows a video from an origin we do not allow as a link card", () => {
+    const { container } = mount(<CommunityLinkPreview preview={video({ embedUrl: "https://evil.example/embed/abc" })} />);
+    expect(screen.queryByTestId("community-link-video")).toBeNull();
+    expect(screen.getByTestId("community-link-card").getAttribute("href")).toBe("https://www.youtube.com/watch?v=abc123");
+    expect(container.querySelector("iframe")).toBeNull();
+  });
+
+  it("renders nothing while the post has no card yet", () => {
+    const { container } = mount(<CommunityLinkPreview preview={null} />);
+    expect(screen.queryByTestId("community-link-card")).toBeNull();
+    expect(screen.queryByTestId("community-link-video")).toBeNull();
+    expect(container.querySelector("a, iframe, img")).toBeNull();
+  });
+});
+
+describe("link cards on posts", () => {
+  const post = (overrides: Partial<CommunityPost> = {}): CommunityPost => ({
+    id: "post-1",
+    profileId: "profile-1",
+    spaceId: "space-1",
+    authorAccountId: "a-2",
+    title: "Look at this",
+    body: null,
+    bodyText: "Look at this https://news.example.com/story",
+    isPinned: false,
+    isLocked: false,
+    replyCount: 0,
+    reactionCount: 0,
+    lastActivityAt: null,
+    createdAt: "2026-09-01T00:00:00.000Z",
+    author: null,
+    media: [],
+    reactions: [],
+    linkPreview: linkCard(),
+    ...overrides,
+  });
+
+  it("shows the card under a feed post", () => {
+    mount(<CommunityPostCard post={post()} variant="feed" />);
+    expect(screen.getByTestId("community-link-card")).toBeTruthy();
+    expect(screen.queryByTestId("community-post-link-icon")).toBeNull();
+  });
+
+  it("shows only a small link mark on a compact forum row", () => {
+    mount(<CommunityPostCard post={post()} variant="forum" />);
+    expect(screen.queryByTestId("community-link-card")).toBeNull();
+    expect(screen.getByTestId("community-post-link-icon")).toBeTruthy();
+  });
+
+  it("shows no mark on a forum row without a card", () => {
+    mount(<CommunityPostCard post={post({ linkPreview: null })} variant="forum" />);
+    expect(screen.queryByTestId("community-post-link-icon")).toBeNull();
+  });
+});

package/src/ui/styled/community/_tests/CommunityMembers.spec.tsx

@@ -0,0 +1,137 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { ForgeThemeProvider } from "../../../theme/ForgeThemeProvider";
+import { CommunityMembers } from "../CommunityMembers";
+import { CommunityMemberProfile } from "../CommunityMemberProfile";
+import {
+  account,
+  calls,
+  get,
+  installAdapter,
+  restoreAdapter,
+  wrapper,
+} from "../../../headless/_tests/communityHarness";
+
+/**
+ * The directory's markup side: member cards linking to profiles with where the
+ * member says they are, the members-only notice, the map's country list, and
+ * the member's own directory and map settings.
+ */
+
+afterEach(() => {
+  cleanup();
+  restoreAdapter();
+});
+
+const theme = { colors: { text: "#111111", background: "#ffffff", primary: "#6d28d9" }, cornerRadius: 8 };
+
+function mount(node: ReactNode) {
+  const Wrapper = wrapper({ user: account() });
+  return render(
+    <Wrapper>
+      <ForgeThemeProvider theme={theme}>{node}</ForgeThemeProvider>
+    </Wrapper>,
+  );
+}
+
+const member = (overrides: Record<string, unknown> = {}) => ({
+  accountId: "a-2",
+  displayName: "Ada",
+  avatarUrl: null,
+  bio: null,
+  level: 3,
+  points: 120,
+  role: "moderator",
+  city: "Berlin",
+  countryCode: "DE",
+  lastActiveAt: null,
+  joinedAt: null,
+  firstName: null,
+  lastName: null,
+  ...overrides,
+});
+
+describe("CommunityMembers", () => {
+  it("shows member cards that open the profile", async () => {
+    installAdapter([
+      get("/public/community/members", () => ({
+        data: [member()],
+        total: 1,
+        page: 1,
+        pageSize: 24,
+        hasNextPage: false,
+      })),
+    ]);
+    const went: string[] = [];
+    mount(<CommunityMembers getProfileHref={(id) => `/profile/${id}`} navigate={(href) => went.push(href)} />);
+    const card = await screen.findByTestId("community-member-card");
+    expect(card.textContent).toContain("Ada");
+    expect(card.textContent).toContain("Moderator");
+    expect(card.textContent).toContain("Berlin, Germany");
+    fireEvent.click(within(card).getByRole("link"));
+    expect(went).toEqual(["/profile/a-2"]);
+  });
+
+  it("tells a non-member the directory is for members", async () => {
+    installAdapter([
+      get("/public/community/members", () => {
+        throw { status: 403, message: "Forbidden" };
+      }),
+    ]);
+    mount(<CommunityMembers getProfileHref={(id) => `/profile/${id}`} />);
+    expect(await screen.findByText("The member directory is for members of this community.")).toBeTruthy();
+  });
+
+  it("switches to the map and lists the countries with their counts", async () => {
+    installAdapter([
+      get("/public/community/members", () => ({ data: [], total: 0, page: 1, pageSize: 24, hasNextPage: false })),
+      get("/public/community/members/map", () => [
+        { countryCode: "NG", members: 4 },
+        { countryCode: "DE", members: 1 },
+      ]),
+    ]);
+    mount(<CommunityMembers getProfileHref={(id) => `/profile/${id}`} />);
+    fireEvent.click(await screen.findByRole("button", { name: "Map" }));
+    const rows = await screen.findAllByTestId("community-member-map-country");
+    expect(rows.map((row) => row.textContent)).toEqual(["Nigeria4", "Germany1"]);
+    expect(screen.getByText("5 members in 2 countries")).toBeTruthy();
+  });
+});
+
+describe("the member's own directory and map settings", () => {
+  it("saves the map switch and the country", async () => {
+    installAdapter([
+      get("/public/community/me", () => ({
+        id: "cp-1",
+        accountId: "account-1",
+        displayName: "Fan",
+        bio: null,
+        avatarUrl: null,
+        points: 0,
+        level: 1,
+        role: "member",
+        digestCadence: "daily",
+        showInDirectory: true,
+        showOnMap: false,
+        city: null,
+        countryCode: null,
+        canModerate: false,
+      })),
+    ]);
+    mount(<CommunityMemberProfile accountId="account-1" />);
+    const settings = await screen.findByTestId("community-profile-directory-settings");
+    const directory = within(settings).getByRole("switch", { name: "Show me in the member directory" });
+    expect(directory.getAttribute("aria-checked")).toBe("true");
+
+    fireEvent.change(within(settings).getByRole("combobox"), { target: { value: "NG" } });
+    fireEvent.click(within(settings).getByRole("switch", { name: "Show me on the member map" }));
+    await waitFor(() => expect(calls("put", "/public/community/me")).toHaveLength(1));
+    expect(calls("put", "/public/community/me")[0].body).toMatchObject({
+      showOnMap: true,
+      countryCode: "NG",
+      city: null,
+    });
+  });
+});

package/src/ui/styled/community/_tests/CommunityModeration.spec.tsx

@@ -0,0 +1,291 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { ForgeThemeProvider } from "../../../theme/ForgeThemeProvider";
+import { CommunityModeration } from "../CommunityModeration";
+import { CommunityNotificationsInbox } from "../CommunityNotifications";
+import { CommunityPostCard } from "../CommunityPostCard";
+import type { CommunityPost } from "../../../../data/queries/useCommunity";
+import {
+  PROFILE_ID,
+  account,
+  calls,
+  get,
+  installAdapter,
+  post,
+  restoreAdapter,
+  wrapper,
+} from "../../../headless/_tests/communityHarness";
+
+/**
+ * The site's moderation surfaces are their headless hooks plus markup. These
+ * pin the markup's side: the Moderation tab puts hold reasons into words and
+ * asks for a reason on reject; the post card shows the author their held post
+ * without reply or react, and gives a moderator the actions menu (with no ban);
+ * the inbox words a moderation outcome and leaves the mute notice as it was.
+ */
+
+afterEach(() => {
+  cleanup();
+  restoreAdapter();
+});
+
+const theme = { colors: { text: "#111111", background: "#ffffff", primary: "#6d28d9" }, cornerRadius: 8 };
+
+function mount(node: ReactNode, opts: Parameters<typeof wrapper>[0] = { user: account() }) {
+  const Wrapper = wrapper(opts);
+  return render(
+    <Wrapper>
+      <ForgeThemeProvider theme={theme}>{node}</ForgeThemeProvider>
+    </Wrapper>,
+  );
+}
+
+const me = (canModerate: boolean) => get("/public/community/me", () => ({ accountId: "account-1", canModerate }));
+const emptyLog = get("/public/community-moderation/log", () => ({
+  data: [],
+  total: 0,
+  page: 1,
+  pageSize: 20,
+  hasNextPage: false,
+}));
+
+const queue = {
+  reports: {
+    data: [
+      {
+        id: "rep-1",
+        entityType: "community_post",
+        entityId: "post-9",
+        reason: "spam",
+        reporterFirstName: "Ada",
+        reporterLastName: null,
+        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",
+      },
+      {
+        id: "post-2",
+        spaceId: "space-1",
+        spaceName: "General",
+        title: null,
+        bodyText: "spoilers ahead",
+        authorAccountId: "account-3",
+        authorName: "Other Fan",
+        moderationReason: "keyword:spoiler",
+        createdAt: "2026-09-01T00:00:00.000Z",
+      },
+    ],
+    replies: [],
+  },
+};
+
+const postFixture = (overrides: Partial<CommunityPost> = {}): CommunityPost => ({
+  id: "post-1",
+  profileId: PROFILE_ID,
+  spaceId: "space-1",
+  authorAccountId: "account-2",
+  title: "Hello",
+  body: { root: { type: "root", children: [{ type: "paragraph", children: [{ type: "text", text: "hi all" }] }] } },
+  bodyText: "hi all",
+  isPinned: false,
+  isLocked: false,
+  replyCount: 0,
+  reactionCount: 0,
+  lastActivityAt: null,
+  createdAt: "2026-09-01T00:00:00.000Z",
+  author: {
+    accountId: "account-2",
+    firstName: "Fan",
+    lastName: null,
+    displayName: "Fan",
+    avatarUrl: null,
+    level: 1,
+    role: "member",
+  },
+  media: [],
+  reactions: [],
+  ...overrides,
+});
+
+describe("CommunityModeration (the tab)", () => {
+  it("tells a non-moderator this page is not for them, and loads nothing", async () => {
+    installAdapter([me(false)]);
+    mount(<CommunityModeration />);
+    expect(await screen.findByText("This page is for the community's moderators.")).toBeTruthy();
+    expect(calls("get", "/public/community-moderation/queue")).toHaveLength(0);
+  });
+
+  it("lists reports and held posts, with the hold reason in words", async () => {
+    installAdapter([me(true), get("/public/community-moderation/queue", () => queue), emptyLog]);
+    mount(<CommunityModeration />);
+    const report = await screen.findByTestId("community-moderation-report");
+    expect(report.textContent).toContain("buy now");
+    expect(report.textContent).toContain("Reported by Ada");
+    expect(report.textContent).toContain("Reason: spam");
+
+    const reasons = (await screen.findAllByTestId("community-moderation-hold-reason")).map((el) => el.textContent);
+    expect(reasons).toEqual(["New member", "Blocked word: spoiler"]);
+    expect(await screen.findByText("No moderation actions yet.")).toBeTruthy();
+  });
+
+  it("asks for an optional reason before rejecting", async () => {
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => queue),
+      emptyLog,
+      post("/public/community-moderation/posts/post-1/reject", () => ({ success: true })),
+    ]);
+    mount(<CommunityModeration />);
+    const [first] = await screen.findAllByTestId("community-moderation-held-item");
+    fireEvent.click(within(first).getByRole("button", { name: "Reject" }));
+    fireEvent.change(within(first).getByRole("textbox"), { target: { value: "Please keep it on topic" } });
+    fireEvent.click(within(first).getByRole("button", { name: "Reject" }));
+    await waitFor(() => expect(calls("post", "/public/community-moderation/posts/post-1/reject")).toHaveLength(1));
+    expect(calls("post", "/public/community-moderation/posts/post-1/reject")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      reason: "Please keep it on topic",
+    });
+  });
+
+  it("opens a reported reply's post, and not a hidden reported post", async () => {
+    const report = queue.reports.data[0];
+    const reports = [
+      { ...report, id: "rep-reply", entityType: "community_reply", entityId: "reply-7", postId: "post-7" },
+      { ...report, id: "rep-hidden", entityId: "post-8", postId: "post-8", contentHidden: true },
+    ];
+    installAdapter([
+      me(true),
+      get("/public/community-moderation/queue", () => ({ ...queue, reports: { data: reports, total: 2 } })),
+      emptyLog,
+    ]);
+    const opened: string[] = [];
+    mount(<CommunityModeration onOpenPost={(postId) => opened.push(postId)} />);
+    const [replyReport, hiddenReport] = await screen.findAllByTestId("community-moderation-report");
+    fireEvent.click(within(replyReport).getByRole("button", { name: "Open post" }));
+    expect(opened).toEqual(["post-7"]);
+    expect(within(hiddenReport).queryByRole("button", { name: "Open post" })).toBeNull();
+  });
+});
+
+describe("CommunityPostCard moderation states", () => {
+  it("shows the author their held post, with no way to reply or react", async () => {
+    installAdapter([me(false)]);
+    mount(
+      <CommunityPostCard post={postFixture({ status: "pending", moderationReason: "approval_all" })} variant="feed" />,
+    );
+    expect((await screen.findByTestId("community-pending-badge")).textContent).toContain("Waiting for approval");
+    expect(screen.queryByRole("button", { name: /reply/i })).toBeNull();
+  });
+
+  it("gives a moderator the actions menu, and it has no ban", async () => {
+    installAdapter([
+      me(true),
+      post("/public/community-moderation/posts/post-1/lock", () => ({ id: "post-1", isLocked: true })),
+    ]);
+    mount(<CommunityPostCard post={postFixture()} variant="feed" />);
+    fireEvent.click(await screen.findByRole("button", { name: "Moderator actions" }));
+    const menu = screen.getByRole("menu");
+    const labels = within(menu)
+      .getAllByRole("menuitem")
+      .map((el) => el.textContent);
+    expect(labels).toEqual(["Pin", "Lock replies", "Remove post", "Mute author"]);
+    expect(menu.textContent?.toLowerCase()).not.toContain("ban");
+
+    fireEvent.click(within(menu).getByRole("menuitem", { name: "Mute author" }));
+    expect(
+      within(screen.getByRole("menu"))
+        .getAllByRole("menuitem")
+        .map((el) => el.textContent),
+    ).toEqual(["1 day", "7 days", "30 days"]);
+  });
+
+  it("shows no menu to a member who does not moderate", async () => {
+    installAdapter([me(false)]);
+    mount(<CommunityPostCard post={postFixture()} variant="feed" />);
+    await waitFor(() => expect(calls("get", "/public/community/me")).toHaveLength(1));
+    expect(screen.queryByRole("button", { name: "Moderator actions" })).toBeNull();
+  });
+
+  it("leaves mute off a moderator's own post", async () => {
+    installAdapter([me(true)]);
+    mount(<CommunityPostCard post={postFixture({ authorAccountId: "account-1" })} variant="forum" />);
+    fireEvent.click(await screen.findByRole("button", { name: "Moderator actions" }));
+    const labels = within(screen.getByRole("menu"))
+      .getAllByRole("menuitem")
+      .map((el) => el.textContent);
+    expect(labels).not.toContain("Mute author");
+  });
+
+  it("collapses a just-removed post to an undo", async () => {
+    installAdapter([me(true), post("/public/community-moderation/posts/post-1/restore", () => ({ success: true }))]);
+    mount(<CommunityPostCard post={postFixture({ archivedAt: "2026-09-29T00:00:00.000Z" })} variant="feed" />);
+    const notice = await screen.findByTestId("community-removed-notice");
+    expect(notice.textContent).toContain("Post removed");
+    fireEvent.click(await within(notice).findByRole("button", { name: "Restore" }));
+    await waitFor(() => expect(calls("post", "/public/community-moderation/posts/post-1/restore")).toHaveLength(1));
+  });
+});
+
+describe("CommunityNotificationsInbox moderation outcomes", () => {
+  it("words the outcome, and keeps the mute notice as it was", async () => {
+    installAdapter([
+      get("/public/community/notifications", () => ({
+        unreadCount: 0,
+        data: [
+          {
+            id: "n1",
+            type: "mod",
+            entityType: "community_post",
+            entityId: "post-1",
+            data: { outcome: "rejected", reason: "off topic" },
+            readAt: "2026-09-01T00:00:00.000Z",
+            createdAt: "2026-09-01T00:00:00.000Z",
+          },
+          {
+            id: "n2",
+            type: "mod",
+            entityType: "community_reply",
+            entityId: "reply-1",
+            data: { outcome: "approved", reason: null },
+            readAt: "2026-09-01T00:00:00.000Z",
+            createdAt: "2026-09-01T00:00:00.000Z",
+          },
+          {
+            id: "n3",
+            type: "mod",
+            entityType: "community",
+            entityId: "c-1",
+            data: null,
+            readAt: "2026-09-01T00:00:00.000Z",
+            createdAt: "2026-09-01T00:00:00.000Z",
+          },
+        ],
+      })),
+    ]);
+    mount(<CommunityNotificationsInbox onOpenPost={() => {}} />);
+    await waitFor(() => expect(screen.getAllByTestId("community-notification-title")).toHaveLength(3));
+    expect(screen.getAllByTestId("community-notification-title").map((el) => el.textContent)).toEqual([
+      "Your post wasn't approved: off topic",
+      "Your reply was approved",
+      "A moderator updated your account",
+    ]);
+  });
+});