@raketa-cloud/admin 1.10.12 → 1.10.13

package/src/tests/handlers/resources/DiscussionsHandler.test/index.test.js

@@ -0,0 +1,195 @@
+import Comments from "../../../../cloud/Comments";
+import Editors from "../../../../cloud/Editors";
+import ResourceRevisions from "../../../../cloud/ResourceRevisions";
+import Resources from "../../../../cloud/Resources";
+import DiscussionsHandler from "../../../../handlers/resources/DiscussionsHandler";
+import Factory from "../../../support/factory";
+
+describe("Resources Discussions Handler index", () => {
+  const editor = {
+    id: "5",
+    name: "Jane Doe",
+    email: "jane@example.com",
+    avatar: "https://example.com/jane.png",
+  };
+  const editors = [
+    editor,
+    { id: "6", name: "John Smith", email: "john@example.com", avatar: "" },
+  ];
+  const revisions = [
+    { id: "200", title: "Homepage", meta: { title: "Hero update" } },
+  ];
+
+  function buildCtx(params = {}) {
+    const ctx = {
+      client: {
+        resources: new Resources(() => ({}), "token"),
+        comments: new Comments(() => ({}), "token"),
+        editors: new Editors(() => ({}), "token"),
+        resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+      },
+      authentication: {
+        user: { name: "Jane", email: "jane@example.com", avatar: "" },
+      },
+      query: { page: "2" },
+      locale: "en",
+      locales: { en: {}, de: {}, fr: {} },
+      params: { parent_id: "123", ...params },
+      resourceConfig: {
+        resourceType: "article",
+        resourceTypePlural: "articles",
+      },
+    };
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => ({
+      ...Factory.build("resource"),
+      translations: { en: { id: "123" }, de: { id: "456" } },
+    }));
+    jest
+      .spyOn(ctx.client.comments, "list")
+      .mockImplementation(() => ({ list: [], pagination: {} }));
+    jest.spyOn(ctx.client.editors, "current").mockResolvedValue(editor);
+    jest.spyOn(ctx.client.editors, "website").mockResolvedValue(editors);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "all")
+      .mockResolvedValue({ list: revisions });
+
+    return ctx;
+  }
+
+  test("returns the general discussion of the resource", async () => {
+    const ctx = buildCtx();
+    const comments = { list: [{ id: "1", body: "Hello" }], pagination: {} };
+    ctx.client.comments.list.mockImplementation(() => comments);
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(ctx.client.resources.find).toHaveBeenCalledWith(
+      "123",
+      "en",
+      "article",
+    );
+    expect(ctx.client.comments.list).toHaveBeenCalledWith(
+      { page: "2" },
+      "123",
+      "en",
+      "article",
+      null,
+    );
+    expect(ctx.client.resourceRevisions.all).toHaveBeenCalledWith(
+      "123",
+      "en",
+      "article",
+    );
+    expect(result.assigns).toEqual({
+      resource: expect.objectContaining({ id: expect.anything() }),
+      comments,
+      currentEditor: editor,
+      editors,
+      revisions,
+      discussion: {
+        revisionId: null,
+        revision: null,
+        archived: false,
+        path: "/en/articles/123/discussions",
+      },
+      _translations: [
+        { locale: "en", path: "/en/articles/123/discussions" },
+        { locale: "de", path: "/de/articles/456/discussions" },
+      ],
+    });
+  });
+
+  test("returns the discussion of an open revision", async () => {
+    const ctx = buildCtx({ revision_id: "200" });
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(ctx.client.comments.list).toHaveBeenCalledWith(
+      { page: "2" },
+      "123",
+      "en",
+      "article",
+      "200",
+    );
+    expect(result.assigns.discussion).toEqual({
+      revisionId: "200",
+      revision: revisions[0],
+      archived: false,
+      path: "/en/articles/123/discussions/200",
+    });
+  });
+
+  test("returns the discussion of a published revision as archived", async () => {
+    const ctx = buildCtx({ revision_id: "150" });
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(result.assigns.discussion).toEqual({
+      revisionId: "150",
+      revision: null,
+      archived: true,
+      path: "/en/articles/123/discussions/150",
+    });
+  });
+
+  test("handles resources without revisions", async () => {
+    const ctx = buildCtx({ revision_id: "150" });
+    ctx.client.resourceRevisions.all.mockResolvedValue(null);
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(result.assigns.revisions).toEqual([]);
+    expect(result.assigns.discussion.archived).toBe(true);
+  });
+
+  test("throws for invalid revision ids", async () => {
+    const ctx = buildCtx({ revision_id: "abc" });
+
+    await expect(DiscussionsHandler.index(ctx)).rejects.toThrow(
+      "Missing discussion for revision #abc",
+    );
+  });
+
+  test("falls back to the login token user when the editor cannot be fetched", async () => {
+    const ctx = buildCtx();
+    const logError = jest.spyOn(console, "error").mockImplementation(() => {});
+    ctx.client.editors.current.mockRejectedValue(new Error("Network error"));
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(result.assigns.currentEditor).toEqual(ctx.authentication.user);
+    expect(logError).toHaveBeenCalled();
+    logError.mockRestore();
+  });
+
+  test("returns no editors to mention when they cannot be fetched", async () => {
+    const ctx = buildCtx();
+    const logError = jest.spyOn(console, "error").mockImplementation(() => {});
+    ctx.client.editors.website.mockRejectedValue(new Error("Network error"));
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(result.assigns.editors).toEqual([]);
+    expect(logError).toHaveBeenCalled();
+    logError.mockRestore();
+  });
+
+  test("defaults the current editor when there is no user", async () => {
+    const ctx = { ...buildCtx(), authentication: {} };
+    ctx.client.editors.current.mockResolvedValue(null);
+
+    const result = await DiscussionsHandler.index(ctx);
+
+    expect(result.assigns.currentEditor).toEqual({});
+  });
+
+  test("throws error when resource is not found", async () => {
+    const ctx = buildCtx();
+    ctx.client.resources.find.mockImplementation(() => null);
+
+    await expect(DiscussionsHandler.index(ctx)).rejects.toThrow(
+      "Missing article #123",
+    );
+  });
+});

package/src/tests/handlers/resources/DiscussionsHandler.test/update.test.js

@@ -0,0 +1,87 @@
+import Comments from "../../../../cloud/Comments";
+import DiscussionsHandler from "../../../../handlers/resources/DiscussionsHandler";
+
+describe("Resources Discussions Handler update", () => {
+  function buildCtx(comment) {
+    return {
+      client: {
+        comments: new Comments(() => ({}), "token"),
+      },
+      resourceParams: { comment },
+      locale: "en",
+      params: { id: "9", parent_id: "123" },
+      resourceConfig: {
+        resourceType: "article",
+        resourceTypePlural: "articles",
+      },
+    };
+  }
+
+  test("updates the comment and redirects back to the discussions page", async () => {
+    const ctx = buildCtx({ body: "  Edited  " });
+    const update = jest
+      .spyOn(ctx.client.comments, "update")
+      .mockImplementation(() => ({ comment: { id: "9" }, errors: null }));
+
+    const result = await DiscussionsHandler.update(ctx);
+
+    expect(update).toHaveBeenCalledWith("9", { body: "Edited" });
+    expect(result).toEqual({
+      headers: { "HX-Redirect": "/en/articles/123/discussions" },
+      json: {},
+    });
+  });
+
+  test("redirects back to the revision discussion", async () => {
+    const ctx = buildCtx({ body: "Edited" });
+    ctx.resourceParams.revision_id = "200";
+    jest
+      .spyOn(ctx.client.comments, "update")
+      .mockImplementation(() => ({ comment: { id: "9" }, errors: null }));
+
+    const result = await DiscussionsHandler.update(ctx);
+
+    expect(result.headers["HX-Redirect"]).toEqual(
+      "/en/articles/123/discussions/200",
+    );
+  });
+
+  test("redirects with an error for a blank body", async () => {
+    const ctx = buildCtx({ body: " " });
+    const update = jest.spyOn(ctx.client.comments, "update");
+
+    const result = await DiscussionsHandler.update(ctx);
+
+    expect(update).not.toHaveBeenCalled();
+    expect(result.headers["HX-Redirect"]).toEqual(
+      `/en/articles/123/discussions?comment_error=${encodeURIComponent("Comment can't be blank.")}`,
+    );
+  });
+
+  test("redirects with an error when there are no params", async () => {
+    const ctx = { ...buildCtx(), resourceParams: {} };
+
+    const result = await DiscussionsHandler.update(ctx);
+
+    expect(result.headers["HX-Redirect"]).toContain("comment_error=");
+  });
+
+  test("redirects with the API errors", async () => {
+    const ctx = buildCtx({ body: "Edited" });
+    jest.spyOn(ctx.client.comments, "update").mockImplementation(() => ({
+      comment: null,
+      errors: [
+        {
+          key: "generalError",
+          message: "Comments of published revisions cannot be changed",
+        },
+      ],
+    }));
+
+    const result = await DiscussionsHandler.update(ctx);
+
+    expect(result.headers["HX-Redirect"]).toEqual(
+      `/en/articles/123/discussions?comment_error=${encodeURIComponent("Comments of published revisions cannot be changed")}`,
+    );
+  });
+});

package/src/tests/handlers/resources/HistoryHandler.test/index.test.js

@@ -1,3 +1,4 @@
+import Comments from "../../../../cloud/Comments";
 import ResourceChanges from "../../../../cloud/ResourceChanges";
 import Resources from "../../../../cloud/Resources";
 import HistoryHandler from "../../../../handlers/resources/HistoryHandler";
@@ -9,6 +10,7 @@ describe("Resources History Handler", () => {
       client: {
         resources: new Resources(() => ({}), "token"),
         resourceChanges: new ResourceChanges(() => ({}), "token"),
+        comments: new Comments(() => ({}), "token"),
       },
       query: { foo: "bar" },
       locale: "en",
@@ -17,6 +19,7 @@ describe("Resources History Handler", () => {
       },
       resourceConfig: {
         resourceType: "article",
+        comments: true,
       },
     };
   }
@@ -40,13 +43,19 @@ describe("Resources History Handler", () => {
       .spyOn(ctx.client.resourceChanges, "all_editors")
       .mockImplementation(() => ["John Travolta", "Generic Jane Smith"]);
 
+    const counts = jest
+      .spyOn(ctx.client.comments, "counts")
+      .mockResolvedValue({ 7: 2 });
+
     const result = await HistoryHandler.index(ctx);
 
+    expect(counts).toHaveBeenCalledWith("123", "en", "article");
     expect(result).toEqual({
       assigns: {
         resource,
         changes,
         editors: ["John Travolta", "Generic Jane Smith"],
+        commentCounts: { 7: 2 },
       },
     });
   });

package/src/tests/handlers/resources/ResourcesHandler.test/show.test.js

@@ -1,3 +1,4 @@
+import Comments from "../../../../cloud/Comments";
 import ResourceChanges from "../../../../cloud/ResourceChanges";
 import ResourceRevisions from "../../../../cloud/ResourceRevisions";
 import Resources from "../../../../cloud/Resources";
@@ -12,6 +13,7 @@ describe("Resources Handler", () => {
         resources: new Resources(() => ({}), "token"),
         resourceChanges: new ResourceChanges(() => ({}), "token"),
         resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+        comments: new Comments(() => ({}), "token"),
       },
       params: { id: resource.id },
       locale: "en",
@@ -35,6 +37,7 @@ describe("Resources Handler", () => {
       resourceConfig: {
         resourceType: "article",
         resourceTypePlural: "articles",
+        comments: true,
       },
     };
   }
@@ -64,8 +67,14 @@ describe("Resources Handler", () => {
       .spyOn(ctx.client.resourceChanges, "list")
       .mockImplementation(() => ({ list: [change] }));
 
+    const mockedCounts = jest
+      .spyOn(ctx.client.comments, "counts")
+      .mockResolvedValue({ [revision.id]: 3 });
+
     const result = await ResourcesHandler.show(ctx);
 
+    expect(mockedCounts).toHaveBeenCalledWith(resource.id, "en", "article");
+
     expect(mockedFind).toHaveBeenCalledWith(resource.id, "en", "article");
     expect(mockedRevisions).toHaveBeenCalledWith(resource.id, "en", "article");
     expect(mockedChanges).toHaveBeenCalledWith(
@@ -94,6 +103,7 @@ describe("Resources Handler", () => {
           vitalsMeta: [],
         },
         revisions: [revision],
+        commentCounts: { [revision.id]: 3 },
         changes: { list: [change] },
         _translations: [
           { locale: "bg", path: "/bg/articles/69" },
@@ -103,6 +113,29 @@ describe("Resources Handler", () => {
     });
   });
 
+  test("show renders without the comment counts when they fail", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource);
+    const logError = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "all")
+      .mockImplementation(() => ({ list: [] }));
+    jest
+      .spyOn(ctx.client.resourceChanges, "list")
+      .mockImplementation(() => ({ list: [] }));
+    jest
+      .spyOn(ctx.client.comments, "counts")
+      .mockRejectedValue(new Error("Unknown field"));
+
+    const result = await ResourcesHandler.show(ctx);
+
+    expect(result.assigns.commentCounts).toEqual({});
+    expect(logError).toHaveBeenCalled();
+    logError.mockRestore();
+  });
+
   test("show for non existing resource", async () => {
     const ctx = buildCtx({ id: "42" });
 

package/src/tests/handlers/resources/ResourcesHandler.test/show_reports.test.js

@@ -1,3 +1,4 @@
+import Comments from "../../../../cloud/Comments";
 import ResourceChanges from "../../../../cloud/ResourceChanges";
 import ResourceRevisions from "../../../../cloud/ResourceRevisions";
 import Resources from "../../../../cloud/Resources";
@@ -19,6 +20,7 @@ describe("Resources Handler show reports section", () => {
         resources: new Resources(() => ({}), "token"),
         resourceChanges: new ResourceChanges(() => ({}), "token"),
         resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+        comments: new Comments(() => ({}), "token"),
       },
       params: { id: resource.id },
       locale: "en",
@@ -34,6 +36,7 @@ describe("Resources Handler show reports section", () => {
 
   function mockClient(ctx, resource) {
     jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    jest.spyOn(ctx.client.comments, "counts").mockResolvedValue({});
     jest
       .spyOn(ctx.client.resourceRevisions, "all")
       .mockImplementation(() => ({ list: [] }));

package/src/tests/helpers/commentMarkdown.test.js

@@ -0,0 +1,166 @@
+import commentMarkdown, {
+  commentMentionIds,
+  commentMentionsText,
+} from "../../helpers/commentMarkdown";
+
+describe("commentMarkdown", () => {
+  test("renders bold and italics", () => {
+    expect(commentMarkdown("**bold** *italic* _also italic_")).toEqual(
+      "<p><strong>bold</strong> <em>italic</em> <em>also italic</em></p>\n",
+    );
+  });
+
+  test("renders unordered and ordered lists", () => {
+    const rendered = commentMarkdown("- one\n- two\n\n1. first\n2. second");
+
+    expect(rendered).toContain("<ul>\n<li>one</li>\n<li>two</li>\n</ul>");
+    expect(rendered).toContain("<ol>\n<li>first</li>\n<li>second</li>\n</ol>");
+  });
+
+  test("renders quotes", () => {
+    expect(commentMarkdown("> quoted\n\nafter")).toEqual(
+      "<blockquote>\n<p>quoted</p>\n</blockquote>\n<p>after</p>\n",
+    );
+  });
+
+  test("keeps single line breaks", () => {
+    expect(commentMarkdown("first\nsecond")).toEqual(
+      "<p>first<br>\nsecond</p>\n",
+    );
+  });
+
+  test("turns URLs and domains into links opening in a new tab", () => {
+    const rendered = commentMarkdown(
+      "see https://raketa.cloud, www.example.io and example.com",
+    );
+
+    expect(rendered).toContain(
+      '<a href="https://raketa.cloud" target="_blank" rel="noopener noreferrer">https://raketa.cloud</a>',
+    );
+    expect(rendered).toContain(
+      '<a href="http://www.example.io" target="_blank" rel="noopener noreferrer">www.example.io</a>',
+    );
+    expect(rendered).toContain(
+      '<a href="http://example.com" target="_blank" rel="noopener noreferrer">example.com</a>',
+    );
+  });
+
+  test("links bare domains with newer TLDs and any URL with a protocol", () => {
+    const rendered = commentMarkdown(
+      "raketa.cloud, raketa.design and https://example.unknowntld",
+    );
+
+    expect(rendered).toContain('href="http://raketa.cloud"');
+    expect(rendered).toContain('href="http://raketa.design"');
+    expect(rendered).toContain('href="https://example.unknowntld"');
+  });
+
+  test("does not link emails or file names", () => {
+    expect(commentMarkdown("mail me@example.com about file.js")).toEqual(
+      "<p>mail me@example.com about file.js</p>\n",
+    );
+  });
+
+  test("keeps the markdown link syntax as text", () => {
+    expect(commentMarkdown("[click](javascript:alert(1))")).toEqual(
+      "<p>[click](javascript:alert(1))</p>\n",
+    );
+  });
+
+  test("escapes HTML", () => {
+    expect(
+      commentMarkdown('<script>alert(1)</script> <img src=x onerror="x">'),
+    ).toEqual(
+      "<p>&lt;script&gt;alert(1)&lt;/script&gt; &lt;img src=x onerror=&quot;x&quot;&gt;</p>\n",
+    );
+  });
+
+  test("leaves other markdown as text", () => {
+    expect(commentMarkdown("# heading\n`code` ![img](a.png)")).toEqual(
+      "<p># heading<br>\n`code` ![img](a.png)</p>\n",
+    );
+  });
+
+  test("handles empty bodies", () => {
+    expect(commentMarkdown(null)).toEqual("");
+    expect(commentMarkdown("")).toEqual("");
+  });
+
+  describe("mentions", () => {
+    const mentions = [
+      { editorId: "12", name: "Jane Doe", email: "jane@example.com" },
+      { editorId: "13", name: " ", email: "ops@example.com" },
+      { editorId: "14", name: "<b>Bold</b>", email: "bold@example.com" },
+    ];
+    const mention = (name) => `<span class="comment-mention">@${name}</span>`;
+    const unknown =
+      '<span class="comment-mention-unknown">@Unknown editor</span>';
+
+    test("renders the mentions with the names of the editors", () => {
+      expect(
+        commentMarkdown("Hey @editor-12 and @editor-13!", { mentions }),
+      ).toEqual(
+        `<p>Hey ${mention("Jane Doe")} and ${mention("ops@example.com")}!</p>\n`,
+      );
+    });
+
+    test("renders mentions inside formatting and lists", () => {
+      const rendered = commentMarkdown("**@editor-12**\n\n- @editor-12", {
+        mentions,
+      });
+
+      expect(rendered).toContain(`<strong>${mention("Jane Doe")}</strong>`);
+      expect(rendered).toContain(`<li>${mention("Jane Doe")}</li>`);
+    });
+
+    test("renders unknown editors", () => {
+      expect(commentMarkdown("cc @editor-99", { mentions })).toEqual(
+        `<p>cc ${unknown}</p>\n`,
+      );
+      expect(commentMarkdown("@editor-12")).toEqual(`<p>${unknown}</p>\n`);
+    });
+
+    test("ignores tokens inside words, emails and paths", () => {
+      expect(
+        commentMarkdown("mail@editor-12 x/@editor-12 @editor-12abc @Jane", {
+          mentions,
+        }),
+      ).toEqual("<p>mail@editor-12 x/@editor-12 @editor-12abc @Jane</p>\n");
+    });
+
+    test("escapes the names and the text", () => {
+      expect(commentMarkdown("<i>@editor-14</i>", { mentions })).toEqual(
+        `<p>&lt;i&gt;${mention("&lt;b&gt;Bold&lt;/b&gt;")}&lt;/i&gt;</p>\n`,
+      );
+    });
+  });
+
+  describe("commentMentionsText", () => {
+    test("writes the known mentions with their names", () => {
+      expect(
+        commentMentionsText("**@editor-12** @editor-13 @editor-99", [
+          { editorId: "12", name: "Jane Doe" },
+          { editorId: "13", name: "", email: "ops@example.com" },
+        ]),
+      ).toEqual("**@Jane Doe** @ops@example.com @editor-99");
+    });
+
+    test("handles missing text and mentions", () => {
+      expect(commentMentionsText(null)).toEqual("");
+      expect(commentMentionsText("@editor-1", undefined)).toEqual("@editor-1");
+    });
+  });
+
+  describe("commentMentionIds", () => {
+    test("maps the names to the editor ids", () => {
+      expect(
+        commentMentionIds([
+          { editorId: 12, name: "Jane Doe" },
+          { editorId: "13", name: null, email: "ops@example.com" },
+          { editorId: "14", name: "", email: "" },
+        ]),
+      ).toEqual({ "Jane Doe": "12", "ops@example.com": "13" });
+      expect(commentMentionIds()).toEqual({});
+    });
+  });
+});

package/src/tests/helpers/fetchCommentCounts.test.js

@@ -0,0 +1,42 @@
+import Comments from "../../cloud/Comments";
+import fetchCommentCounts from "../../helpers/fetchCommentCounts";
+
+describe("fetchCommentCounts", () => {
+  function buildCtx() {
+    return {
+      client: { comments: new Comments(() => ({}), "token") },
+      locale: "en",
+      resourceConfig: { comments: true },
+    };
+  }
+
+  test("returns the comment counts of the resource", async () => {
+    const ctx = buildCtx();
+    const counts = jest
+      .spyOn(ctx.client.comments, "counts")
+      .mockResolvedValue({ 7: 2 });
+
+    expect(await fetchCommentCounts(ctx, "42", "page")).toEqual({ 7: 2 });
+    expect(counts).toHaveBeenCalledWith("42", "en", "page");
+  });
+
+  test("returns no counts when they cannot be fetched", async () => {
+    const ctx = buildCtx();
+    const logError = jest.spyOn(console, "error").mockImplementation(() => {});
+    jest
+      .spyOn(ctx.client.comments, "counts")
+      .mockRejectedValue(new Error("Unknown field"));
+
+    expect(await fetchCommentCounts(ctx, "42", "page")).toEqual({});
+    expect(logError).toHaveBeenCalled();
+    logError.mockRestore();
+  });
+
+  test("skips the request when comments are disabled", async () => {
+    const ctx = { ...buildCtx(), resourceConfig: { comments: false } };
+    const counts = jest.spyOn(ctx.client.comments, "counts");
+
+    expect(await fetchCommentCounts(ctx, "42", "page")).toEqual({});
+    expect(counts).not.toHaveBeenCalled();
+  });
+});

package/src/tests/helpers/historyUtils.test.js

@@ -105,3 +105,29 @@ describe("isChangeRevertable", () => {
     testReversableForMaxVersion("update", false);
   });
 });
+
+describe("hasDiscussion", () => {
+  const change = { changeType: "revision_publish", revisionId: 7 };
+
+  it("is true for published revisions with comments", () => {
+    expect(history.hasDiscussion(change, { 7: 2 })).toBe(true);
+  });
+
+  it("is false for published revisions without comments", () => {
+    expect(history.hasDiscussion(change, { 8: 2 })).toBe(false);
+    expect(history.hasDiscussion(change)).toBe(false);
+    expect(history.hasDiscussion(change, null)).toBe(false);
+  });
+
+  it("is false for other changes and changes without a revision", () => {
+    expect(
+      history.hasDiscussion(
+        { changeType: "revision_delete", revisionId: 7 },
+        { 7: 2 },
+      ),
+    ).toBe(false);
+    expect(
+      history.hasDiscussion({ changeType: "revision_publish" }, { 7: 2 }),
+    ).toBe(false);
+  });
+});

package/src/tests/helpers/utils.test.js

@@ -111,3 +111,24 @@ describe("feature", () => {
     expect(utils.feature("contentTasks", null)).toEqual(false);
   });
 });
+
+describe("initials", () => {
+  it("uses the first letters of the first two words of the name", () => {
+    expect(utils.initials("Jane van Doe", "jane@example.com")).toEqual("JV");
+    expect(utils.initials("  todor   argirov ")).toEqual("TA");
+  });
+
+  it("uses a single letter for single word names", () => {
+    expect(utils.initials("Jane")).toEqual("J");
+  });
+
+  it("falls back to the email when the name is blank", () => {
+    expect(utils.initials(" ", "jane@example.com")).toEqual("J");
+    expect(utils.initials(null, "jane@example.com")).toEqual("J");
+  });
+
+  it("falls back to a question mark without a name and email", () => {
+    expect(utils.initials()).toEqual("?");
+    expect(utils.initials("", "")).toEqual("?");
+  });
+});