@raketa-cloud/admin 1.8.18 → 1.8.19

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

@@ -0,0 +1,94 @@
+import ResourceChanges from "../../../../cloud/ResourceChanges";
+import ResourceRevisions from "../../../../cloud/ResourceRevisions";
+import Resources from "../../../../cloud/Resources";
+import { CWV_METRICS } from "../../../../helpers/reports/cwv";
+import ResourcesHandler from "../../../../handlers/resources/ResourcesHandler";
+
+import Factory from "../../../support/factory";
+
+jest.mock("../../../../helpers/reports/googleAuth", () => ({
+  serviceAccountConfigured: jest.fn(() => true),
+}));
+
+// The Settings page only renders report skeletons for the sources that are
+// actually configured, and hands the client the endpoint to fetch.
+describe("Resources Handler show reports section", () => {
+  function buildCtx(resource, ga) {
+    return {
+      client: {
+        resources: new Resources(() => ({}), "token"),
+        resourceChanges: new ResourceChanges(() => ({}), "token"),
+        resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+      },
+      params: { id: resource.id },
+      locale: "en",
+      locales: { en: { name: "English", code: "en-gb" } },
+      globalConfig: { ga },
+      resourceConfig: {
+        resourceType: "article",
+        resourceTypePlural: "articles",
+        reports: true,
+      },
+    };
+  }
+
+  function mockClient(ctx, resource) {
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "all")
+      .mockImplementation(() => ({ list: [] }));
+    jest
+      .spyOn(ctx.client.resourceChanges, "list")
+      .mockImplementation(() => ({ list: [] }));
+  }
+
+  test("advertises the reports endpoint and the vitals scale once both are configured", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource, {
+      propertyId: "1234",
+      serviceAccountPath: "/tmp/service-account.json",
+      apiKey: "crux-key",
+    });
+    mockClient(ctx, resource);
+
+    const { assigns } = await ResourcesHandler.show(ctx);
+
+    expect(assigns.reports).toEqual({
+      insights: true,
+      webVitals: true,
+      path: `/en/report/articles/${resource.id}`,
+      vitalsMeta: CWV_METRICS,
+    });
+  });
+
+  test("still advertises the endpoint with only GA configured", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource, {
+      propertyId: "1234",
+      serviceAccountPath: "/tmp/service-account.json",
+    });
+    mockClient(ctx, resource);
+
+    const { assigns } = await ResourcesHandler.show(ctx);
+
+    expect(assigns.reports.insights).toBe(true);
+    expect(assigns.reports.webVitals).toBe(false);
+    expect(assigns.reports.path).toEqual(`/en/report/articles/${resource.id}`);
+    expect(assigns.reports.vitalsMeta).toEqual([]);
+  });
+
+  test("drops the endpoint when nothing is configured", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource, {});
+    mockClient(ctx, resource);
+
+    const { assigns } = await ResourcesHandler.show(ctx);
+
+    expect(assigns.reports).toEqual({
+      insights: false,
+      webVitals: false,
+      path: null,
+      vitalsMeta: [],
+    });
+  });
+});

package/src/tests/handlers/resources/TranslationsHandler.test/edge_cases.test.js

@@ -0,0 +1,211 @@
+import ResourceRevisions from "../../../../cloud/ResourceRevisions";
+import Resources from "../../../../cloud/Resources";
+import TranslationsHandler from "../../../../handlers/resources/TranslationsHandler";
+import Factory from "../../../support/factory";
+
+function buildCtx({ query = {}, resourceParams, resource } = {}) {
+  return {
+    client: {
+      resources: new Resources(() => ({}), "token"),
+      resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: resource?.id ?? "original-resource-id" },
+    query,
+    resourceParams,
+    locale: "en",
+    resourceConfig: {
+      resourceType: "article",
+      resourceTypePlural: "articles",
+    },
+  };
+}
+
+describe("Resource Translations Handler index", () => {
+  test("skips the lookups when the query carries no translations", async () => {
+    const resource = Factory.build("resource");
+    const ctx = buildCtx({ resource });
+
+    const mockFind = jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => resource);
+    const mockRevisions = jest.spyOn(ctx.client.resourceRevisions, "all");
+    jest.spyOn(ctx.client.resources, "list").mockImplementation(() => ({}));
+
+    const result = await TranslationsHandler.index(ctx);
+
+    // Only the original record is fetched.
+    expect(mockFind).toHaveBeenCalledTimes(1);
+    expect(mockRevisions).not.toHaveBeenCalled();
+    expect(result.assigns.translations).toEqual([]);
+  });
+
+  test("leaves the revision id blank for a translation with no open revision", async () => {
+    const resource = Factory.build("resource");
+    const translated = Factory.build("resource", { id: "fr-resource-id" });
+    const ctx = buildCtx({
+      resource,
+      query: { translations: "fr:fr-resource-id" },
+    });
+
+    jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation((id) =>
+        id === "fr-resource-id" ? translated : resource,
+      );
+    jest
+      .spyOn(ctx.client.resourceRevisions, "all")
+      .mockImplementation(() => ({ list: [] }));
+    jest.spyOn(ctx.client.resources, "list").mockImplementation(() => ({}));
+
+    const result = await TranslationsHandler.index(ctx);
+
+    expect(result.assigns.translations).toEqual([
+      { ...translated, translationLocale: "fr", revisionId: undefined },
+    ]);
+  });
+
+  test("throws when a translated record is gone", async () => {
+    const ctx = buildCtx({ query: { translations: "fr:fr-resource-id" } });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => null);
+    jest.spyOn(ctx.client.resources, "list").mockImplementation(() => ({}));
+
+    await expect(TranslationsHandler.index(ctx)).rejects.toThrow(
+      "Cannot find translated record with id fr-resource-id and locale fr",
+    );
+  });
+});
+
+describe("Resource Translations Handler create_form", () => {
+  test("defaults the target locale when the query has none", async () => {
+    const resource = Factory.build("resource");
+    const ctx = buildCtx({ resource });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+
+    const result = await TranslationsHandler.create_form(ctx);
+
+    expect(result.assigns.targetLocale).toEqual("");
+    expect(result.assigns.resource).toEqual(resource);
+    expect(result.assigns.resource).not.toBe(resource);
+  });
+
+  test("throws for a missing blueprint", async () => {
+    const ctx = buildCtx({});
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => null);
+
+    await expect(TranslationsHandler.create_form(ctx)).rejects.toThrow(
+      "Cannot find article with id original-resource-id",
+    );
+  });
+});
+
+describe("Resource Translations Handler create", () => {
+  test("accepts a single language sent as a plain string", async () => {
+    // A one-checkbox form posts a string rather than an array.
+    const resource = Factory.build("resource", {
+      translations: {},
+      categories: [{ id: "cat1" }],
+    });
+    const ctx = buildCtx({
+      resource,
+      resourceParams: { resource: { languages: "fr" } },
+    });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    const mockBatch = jest
+      .spyOn(ctx.client.resources, "translateBatch")
+      .mockImplementation(() => [{ resource: { id: "fr-1" }, errors: null }]);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "createBatch")
+      .mockImplementation(() => [{ errors: null }]);
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockBatch).toHaveBeenCalledWith(
+      resource.id,
+      ["fr"],
+      expect.anything(),
+      "article",
+      undefined,
+    );
+    expect(result).toEqual({
+      redirect: `/en/articles/${resource.id}/translations?translations=fr:fr-1`,
+    });
+  });
+
+  test("leaves revision creation to the workflow when one is selected", async () => {
+    const blueprint = Factory.build("resource", { categories: [] });
+    delete blueprint.translations;
+
+    const ctx = buildCtx({
+      resource: blueprint,
+      resourceParams: { resource: { languages: ["fr"], workflow: "lokalise" } },
+    });
+
+    jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => blueprint);
+    jest
+      .spyOn(ctx.client.resources, "translateBatch")
+      .mockImplementation(() => [{ resource: { id: "fr-1" }, errors: null }]);
+    const mockRevisions = jest.spyOn(
+      ctx.client.resourceRevisions,
+      "createBatch",
+    );
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockRevisions).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      redirect: `/en/articles/${blueprint.id}/translations?translations=fr:fr-1`,
+    });
+  });
+
+  test("re-renders with an error when a blueprint without translations fails", async () => {
+    const blueprint = Factory.build("resource", { categories: [] });
+    delete blueprint.translations;
+
+    const ctx = buildCtx({ resource: blueprint, resourceParams: {} });
+
+    jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation(() => blueprint);
+    jest
+      .spyOn(ctx.client.resources, "formatErrors")
+      .mockImplementation(() => ({ languages: "select at least one" }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(result.assigns.resource.translations).toEqual({});
+  });
+
+  test("re-renders with an error when the batch request comes back empty", async () => {
+    const resource = Factory.build("resource", {
+      translations: { de: { id: "3" } },
+      categories: [{ id: "cat1" }],
+    });
+    const ctx = buildCtx({
+      resource,
+      resourceParams: { resource: { languages: ["fr"] } },
+    });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    jest
+      .spyOn(ctx.client.resources, "translateBatch")
+      .mockImplementation(() => null);
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.resources, "formatErrors")
+      .mockImplementation(() => ({ languages: "translation failed" }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFormatErrors).toHaveBeenCalled();
+    expect(result.assigns.targetLocale).toEqual("en");
+    expect(result.assigns.resource.translations).toEqual(resource.translations);
+    expect(result.assigns.errors.resource).toEqual({
+      languages: "translation failed",
+    });
+  });
+});

package/src/tests/helpers/CSVExportHelper.branches.test.js

@@ -0,0 +1,57 @@
+import CSVExportHelper from "../../helpers/CSVExportHelper";
+
+const remoteConfig = {
+  resourceUrl: (item, type, locale) => `/${locale}/${type}/${item.slug}`,
+};
+
+// Exports mix resources coming from different endpoints, so the type and the
+// locale each fall back through a few shapes.
+describe("standardFieldMapping", () => {
+  const mapping = CSVExportHelper.standardFieldMapping(
+    remoteConfig,
+    "en",
+    "article",
+  );
+
+  test("prefers the resourceType carried by the item", () => {
+    expect(mapping.type({ resourceType: "page", type: "movie" })).toEqual(
+      "page",
+    );
+  });
+
+  test("falls back to the item type", () => {
+    expect(mapping.type({ type: "movie" })).toEqual("movie");
+  });
+
+  test("falls back to the requested type", () => {
+    expect(mapping.type({})).toEqual("article");
+  });
+
+  test("prefers the locale carried by the item", () => {
+    expect(mapping.locale({ locale: "de" })).toEqual("de");
+  });
+
+  test("falls back to the request locale", () => {
+    expect(mapping.locale({})).toEqual("en");
+  });
+
+  test("builds the URL through the remote config", () => {
+    expect(mapping.URL({ slug: "some-page" })).toEqual("/en/article/some-page");
+  });
+
+  test("joins translations and tags", () => {
+    expect(mapping.translations({ translations: { de: {}, bg: {} } })).toEqual(
+      "de;bg",
+    );
+    expect(
+      mapping.tags({ tags: [{ name: "News" }, { name: "Sports" }] }),
+    ).toEqual("News;Sports");
+  });
+
+  test("copes with items that carry neither", () => {
+    expect(mapping.translations({})).toEqual("");
+    expect(mapping.tags({})).toEqual("");
+    expect(mapping.translations(null)).toEqual("");
+    expect(mapping.tags(null)).toEqual("");
+  });
+});

package/src/tests/helpers/FormBuilder.branches.test.js

@@ -0,0 +1,151 @@
+import FormBuilder from "../../helpers/FormBuilder";
+
+describe("FormBuilder options", () => {
+  test("renders a hidden field without a label", () => {
+    const form = new FormBuilder({ resource: { id: "42" } });
+
+    const result = form.field("resource.id", { type: "hidden", value: "42" });
+
+    expect(result).toContain('type="hidden"');
+    expect(result).toContain('name="resource[id]"');
+    expect(result).not.toContain("<label");
+  });
+
+  test("renders a hint next to a field", () => {
+    const form = new FormBuilder({ resource: { title: "Hi" } });
+
+    const result = form.field("resource.title", { hint: "Keep it short" });
+
+    expect(result).toContain("help-block");
+    expect(result).toContain("Keep it short");
+  });
+
+  test("renders an explicit empty label", () => {
+    const form = new FormBuilder({ resource: { title: "Hi" } });
+
+    const result = form.field("resource.title", { label: "" });
+
+    // An empty label renders as a void tag rather than the humanized default.
+    expect(result).toContain('<label  for="f_resource_title" />');
+    expect(result).not.toContain(">Title<");
+  });
+
+  test("submits with extra attributes", () => {
+    const form = new FormBuilder();
+
+    expect(form.submit("Save", { class: "btn" })).toContain('class="btn"');
+  });
+
+  test("groups children under an extra class", () => {
+    const form = new FormBuilder();
+
+    expect(form.group("child", { class: "no-margin" })).toContain(
+      'class="mb-4 no-margin"',
+    );
+  });
+
+  describe("checkbox", () => {
+    test("checks the box when the stored value matches", () => {
+      const form = new FormBuilder({ resource: { featured: "1" } });
+
+      const result = form.field("resource.featured", {
+        as: "checkbox",
+        value: "1",
+      });
+
+      expect(result).toContain('checked="checked"');
+      expect(result).toContain("checkbox-wrapper");
+    });
+
+    test("leaves the box unchecked when the value differs", () => {
+      const form = new FormBuilder({ resource: { featured: "0" } });
+
+      const result = form.field("resource.featured", {
+        as: "checkbox",
+        value: "1",
+      });
+
+      expect(result).not.toContain('checked="checked"');
+    });
+
+    test("adds a hidden complement so unchecking submits a value", () => {
+      const form = new FormBuilder({ resource: { featured: "1" } });
+
+      const result = form.field("resource.featured", {
+        as: "checkbox",
+        value: "1",
+        default_value: "0",
+      });
+
+      expect(result).toContain('type="hidden"');
+      expect(result).toContain('value="0"');
+    });
+
+    test("renders a hint and an error", () => {
+      const form = new FormBuilder(
+        { resource: { featured: "1" } },
+        { resource: { featured: "must be accepted" } },
+      );
+
+      const result = form.field("resource.featured", {
+        as: "checkbox",
+        value: "1",
+        hint: "Shows on the homepage",
+      });
+
+      expect(result).toContain("help-block");
+      expect(result).toContain("has-error");
+      expect(result).toContain("must be accepted");
+    });
+  });
+
+  describe("button and link groups", () => {
+    test("renders a button group with a hint", () => {
+      const form = new FormBuilder({ resource: { cta: { label: "Buy" } } });
+
+      const result = form.field("resource.cta", {
+        as: "button",
+        label: "Call to action",
+        hint: "Optional",
+      });
+
+      expect(result).toContain("button-group");
+      expect(result).toContain("<legend >Call to action</legend>");
+      expect(result).toContain("help-block");
+      expect(result).toContain('value="Buy"');
+    });
+
+    test("falls back to a humanized legend", () => {
+      const form = new FormBuilder({ resource: { cta: {} } });
+
+      const result = form.field("resource.cta", { as: "button", label: "" });
+
+      expect(result).toContain("<legend >Cta</legend>");
+    });
+
+    test("prefers the configured button options", () => {
+      const form = new FormBuilder(
+        {},
+        {},
+        {
+          buttons: { typeOptions: [["ghost", "Ghost"]] },
+        },
+      );
+
+      const result = form.field("resource.cta", { as: "button" });
+
+      expect(result).toContain('value="ghost"');
+      expect(result).toContain("Ghost");
+      expect(result).not.toContain('value="secondary"');
+    });
+
+    test("renders a link group", () => {
+      const form = new FormBuilder({ resource: { more: { link: "/more" } } });
+
+      const result = form.field("resource.more", { as: "link" });
+
+      expect(result).toContain('value="/more"');
+      expect(result).toContain("CSS Class");
+    });
+  });
+});

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

@@ -41,4 +41,55 @@ describe("HTMLBuilder", () => {
       );
     });
   });
+
+  describe("escape", () => {
+    test("escapes double quotes in attribute values", () => {
+      const builder = new HTMLBuilder();
+
+      expect(builder.escape('a "quoted" value')).toEqual(
+        'a \\"quoted\\" value',
+      );
+    });
+
+    test("stringifies non-string values", () => {
+      const builder = new HTMLBuilder();
+
+      expect(builder.escape(42)).toEqual("42");
+    });
+  });
+
+  // Any unknown property is treated as a tag name, so builder.div(...) works
+  // without every element being declared.
+  describe("dynamic tag methods", () => {
+    test("renders a void element from a single argument", () => {
+      const builder = new HTMLBuilder();
+
+      expect(normalizeHTML(builder.hr({ class: "divider" }))).toEqual(
+        normalizeHTML('<hr class="divider" />'),
+      );
+    });
+
+    test("renders an element with children", () => {
+      const builder = new HTMLBuilder();
+
+      expect(normalizeHTML(builder.span("Hello", { class: "label" }))).toEqual(
+        normalizeHTML('<span class="label">Hello</span>'),
+      );
+    });
+
+    test("honours the nonVoid option", () => {
+      const builder = new HTMLBuilder();
+
+      expect(
+        normalizeHTML(builder.div(null, { id: "empty" }, { nonVoid: true })),
+      ).toEqual(normalizeHTML('<div id="empty"></div>'));
+    });
+
+    test("still reaches the real methods on the instance", () => {
+      const builder = new HTMLBuilder();
+
+      expect(typeof builder.tag).toEqual("function");
+      expect(typeof builder.escape).toEqual("function");
+    });
+  });
 });

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

@@ -0,0 +1,36 @@
+import historyUtils from "../../helpers/historyUtils";
+
+describe("changeAction", () => {
+  test("drops the revision reference when the change has no revision", () => {
+    expect(
+      historyUtils.changeAction(
+        { changeType: "revision_publish", revisionId: null },
+        "article",
+      ),
+    ).toEqual("Article updated by revision ");
+  });
+
+  test("includes the revision reference when there is one", () => {
+    expect(
+      historyUtils.changeAction(
+        { changeType: "revision_publish", revisionId: "7" },
+        "article",
+      ),
+    ).toEqual("Article updated by revision #7");
+  });
+
+  test("marks a change made by a revert", () => {
+    expect(
+      historyUtils.changeAction(
+        { changeType: "update", source: "revert" },
+        "page",
+      ),
+    ).toEqual("Page updated by revert");
+  });
+
+  test("falls back to the raw change type when it is unknown", () => {
+    expect(
+      historyUtils.changeAction({ changeType: "something_else" }, "page"),
+    ).toEqual("something_else");
+  });
+});