@raketa-cloud/admin 0.0.102 → 0.0.103

package/src/tests/handlers/pages/TranslationHandler.test/create.test.js

@@ -0,0 +1,290 @@
+import PageRevisions from "../../../../cloud/PageRevisions";
+import Pages from "../../../../cloud/Pages";
+import TranslationsHandler from "../../../../handlers/pages/TranslationsHandler";
+import Factory from "../../../support/factory";
+
+function buildCtx(params, page) {
+  return {
+    client: {
+      pages: new Pages(() => ({}), "token"),
+      pageRevisions: new PageRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: page.id },
+    resourceParams: {
+      resource: params,
+    },
+    locale: "en",
+    resourceConfig: {
+      pageType: "page",
+      pageTypePlural: "pages",
+    },
+  };
+}
+
+describe("Pages Translation Handler", () => {
+  test("create fails with translation errors", async () => {
+    const page = Factory.build("page", {
+      translations: {},
+      categories: [{ id: "cat1" }],
+    });
+    const params = {
+      languages: ["fr"],
+    };
+
+    const ctx = buildCtx(params, page);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const translationErrors = [{ key: "title", message: "cannot be blank" }];
+    const mockTranslateBatch = jest
+      .spyOn(ctx.client.pages, "translateBatch")
+      .mockImplementation((parentId, locales) =>
+        locales.map((locale) => ({
+          page: null,
+          errors: translationErrors,
+        }))
+      );
+
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.pages, "formatErrors")
+      .mockImplementation(() => ({ title: "cannot be blank" }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+    expect(mockTranslateBatch).toHaveBeenCalled();
+    expect(mockFormatErrors).toHaveBeenCalledWith(translationErrors);
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          title: page.title,
+          tags: [],
+          visibility: "private",
+          slug: page.slug,
+          settings: page.settings,
+          widgets: page.widgets,
+          categories: ["cat1"],
+          translations: {},
+          languages: ["fr"],
+        },
+        blueprint: page,
+        targetLocale: "fr",
+        errors: { resource: { title: "cannot be blank" } },
+      },
+    });
+  });
+
+  test("create successfully multiple translations with already one is existing", async () => {
+    const page = Factory.build("page", {
+      translations: { de: "de-id" },
+      categories: [{ id: "cat1" }],
+    });
+
+    const params = {
+      languages: ["fr", "es", "de"],
+    };
+
+    const ctx = buildCtx(params, page);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const mockTranslateBatch = jest
+      .spyOn(ctx.client.pages, "translateBatch")
+      .mockImplementation((parentId, locales) =>
+        locales.map((locale) => ({
+          page: { id: `translated-page-${locale}` },
+          errors: null,
+        }))
+      );
+
+    const mockCreateRevisionBatch = jest
+      .spyOn(ctx.client.pageRevisions, "createBatch")
+      .mockImplementation((revisionInputs) =>
+        revisionInputs.map(({ locale }) => ({
+          revision: { id: `revision-${locale}` },
+          errors: null,
+        }))
+      );
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+    expect(mockTranslateBatch).toHaveBeenCalledWith(
+      page.id,
+      ["fr", "es"],
+      expect.objectContaining({
+        title: page.title,
+        tags: [],
+        visibility: "private",
+        slug: page.slug,
+      })
+    );
+
+    expect(mockCreateRevisionBatch).toHaveBeenCalledWith([
+      { pageId: "translated-page-fr", locale: "fr" },
+      { pageId: "translated-page-es", locale: "es" },
+    ]);
+
+    expect(result).toEqual({
+      redirect: `/en/pages/${page.id}/translations?translations=fr:translated-page-fr;es:translated-page-es`,
+    });
+  });
+
+  test("create translations if any translation fails", async () => {
+    const page = Factory.build("page", {
+      translations: {},
+      categories: [{ id: "some-category-uno" }],
+    });
+
+    const params = {
+      languages: ["fr", "es"],
+    };
+
+    const ctx = buildCtx(params, page);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const mockTranslateBatch = jest
+      .spyOn(ctx.client.pages, "translateBatch")
+      .mockImplementation((parentId, locales) => [
+        {
+          page: {
+            id: "translated-page-fr",
+            slug: "page-revision",
+            visibility: "public",
+          },
+          errors: null,
+        },
+        {
+          page: null,
+          errors: [{ key: "title", message: "invalid for spanish" }],
+        },
+      ]);
+
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.pages, "formatErrors")
+      .mockImplementation(() => ({
+        title: "invalid for spanish",
+      }));
+
+    const mockCreateRevision = jest
+      .spyOn(ctx.client.pageRevisions, "create")
+      .mockImplementation(() => ({ errors: null }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+    expect(mockTranslateBatch).toHaveBeenCalledWith(
+      page.id,
+      ["fr", "es"],
+      expect.objectContaining({
+        title: page.title,
+        tags: [],
+        visibility: "private",
+        slug: page.slug,
+      })
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          title: page.title,
+          tags: [],
+          visibility: "private",
+          slug: page.slug,
+          settings: page.settings,
+          widgets: page.widgets,
+          categories: ["some-category-uno"],
+          translations: {
+            fr: {
+              id: "translated-page-fr",
+              slug: page.slug,
+              visibility: page.visibility,
+            },
+          },
+          languages: ["fr", "es"],
+        },
+        blueprint: page,
+        targetLocale: "es",
+        errors: { resource: { title: "invalid for spanish" } },
+      },
+    });
+  });
+
+  test("create translation fails with revision errors", async () => {
+    const page = Factory.build("page", {
+      translations: {},
+      categories: [{ id: "cat1" }],
+    });
+    const params = {
+      languages: ["fr"],
+    };
+
+    const ctx = buildCtx(params, page);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const mockTranslateBatch = jest
+      .spyOn(ctx.client.pages, "translateBatch")
+      .mockImplementation(() => [
+        {
+          page: {
+            id: "translated-page-fr",
+            slug: "page-revision",
+            visibility: "public",
+          },
+          errors: null,
+        },
+      ]);
+
+    const revisionErrors = [{ key: "base", message: "something went wrong" }];
+    const mockCreateRevisionBatch = jest
+      .spyOn(ctx.client.pageRevisions, "createBatch")
+      .mockImplementation(() => [{ errors: revisionErrors }]);
+
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.pages, "formatErrors")
+      .mockImplementation(() => ({ base: "something went wrong" }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockCreateRevisionBatch).toHaveBeenCalledWith([
+      { pageId: "translated-page-fr", locale: "fr" },
+    ]);
+    expect(mockFormatErrors).toHaveBeenCalledWith(revisionErrors);
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          title: page.title,
+          tags: [],
+          visibility: "private",
+          slug: page.slug,
+          settings: page.settings,
+          widgets: page.widgets,
+          categories: ["cat1"],
+          translations: {
+            fr: {
+              id: "translated-page-fr",
+              slug: page.slug,
+              visibility: page.visibility,
+            },
+          },
+          languages: ["fr"],
+        },
+        blueprint: page,
+        targetLocale: "fr",
+        errors: { resource: { base: "something went wrong" } },
+      },
+    });
+  });
+});

package/src/tests/handlers/pages/TranslationHandler.test/create_form.test.js

@@ -0,0 +1,71 @@
+import Pages from "../../../../cloud/Pages";
+import TranslationsHandler from "../../../../handlers/pages/TranslationsHandler";
+import Factory from "../../../support/factory";
+
+function buildCtx(page) {
+  return {
+    client: {
+      pages: new Pages(() => ({}), "token"),
+    },
+    params: { parent_id: page.id },
+    query: { target_locale: "" },
+    locale: "en",
+    resourceConfig: {
+      pageType: "page",
+      pageTypePlural: "pages",
+    },
+  };
+}
+
+describe("Page translation form", () => {
+  test("create_form when a page exists with target locale", async () => {
+    const page = Factory.build("page");
+    const ctx = buildCtx(page);
+    ctx.query.target_locale = "fr";
+
+    const mockFindPage = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const result = await TranslationsHandler.create_form(ctx);
+
+    expect(mockFindPage).toHaveBeenCalledWith(page.id, "en");
+
+    const expectedResource = structuredClone(page);
+
+    expect(result).toEqual({
+      assigns: {
+        resource: expectedResource,
+        blueprint: page,
+        targetLocale: "fr",
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("create_form when a page exists without target locale", async () => {
+    const page = Factory.build("page");
+    const ctx = buildCtx(page);
+
+    const mockFindPage = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const result = await TranslationsHandler.create_form(ctx);
+
+    expect(mockFindPage).toHaveBeenCalledWith(page.id, "en");
+
+    const expectedResource = structuredClone(page);
+
+    expect(result).toEqual({
+      assigns: {
+        resource: expectedResource,
+        blueprint: page,
+        targetLocale: "",
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/pages/TranslationHandler.test/index.test.js

@@ -0,0 +1,87 @@
+import PageRevisions from "../../../../cloud/PageRevisions";
+import Pages from "../../../../cloud/Pages";
+import TranslationsHandler from "../../../../handlers/pages/TranslationsHandler";
+import Factory from "../../../support/factory";
+
+describe("Translations Handler", () => {
+  function buildCtx() {
+    const originalPage = Factory.build("page", {
+      id: "original-page-id",
+      title: "Test Page Title",
+    });
+
+    return {
+      client: {
+        pages: new Pages(() => ({}), "token"),
+        pageRevisions: new PageRevisions(() => ({}), "token"),
+      },
+      params: { parent_id: originalPage.id },
+      query: { translations: "fr:fr-page-id;es:es-page-id" },
+      locale: "en",
+      resourceConfig: {
+        pageType: "page",
+        pageTypePlural: "pages",
+      },
+      originalPage,
+    };
+  }
+
+  test("index", async () => {
+    const frPage = Factory.build("page", { id: "fr-page-id" });
+    const esPage = Factory.build("page", { id: "es-page-id" });
+    const esRevision = Factory.build("page_revision", { id: "es-revision-id" });
+    const frRevision = Factory.build("page_revision", { id: "fr-revision-id" });
+    const ctx = buildCtx();
+
+    const mockedFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation((id, locale) => {
+        if (locale === "fr") return frPage;
+        if (locale === "es") return esPage;
+        if (id === "original-page-id") return ctx.originalPage;
+      });
+
+    const mockedRevisions = jest
+      .spyOn(ctx.client.pageRevisions, "all")
+      .mockImplementation((id, locale) => ({
+        list: locale === "fr" ? [frRevision] : [esRevision],
+      }));
+
+    const mockedList = jest
+      .spyOn(ctx.client.pages, "list")
+      .mockImplementation(() => ({}));
+
+    const result = await TranslationsHandler.index(ctx);
+
+    expect(mockedFind).toHaveBeenCalledWith("fr-page-id", "fr");
+    expect(mockedFind).toHaveBeenCalledWith("es-page-id", "es");
+    expect(mockedRevisions).toHaveBeenCalledWith("fr-page-id", "fr");
+    expect(mockedRevisions).toHaveBeenCalledWith("es-page-id", "es");
+    expect(mockedList).toHaveBeenCalledWith(
+      { translations: "fr:fr-page-id;es:es-page-id" },
+      "en",
+      "page"
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        items: {},
+        visibilityOptions: ctx.client.pages.visibilityOptions(),
+        translations: [
+          {
+            ...frPage,
+            translationLocale: "fr",
+            revisionId: "fr-revision-id",
+          },
+          {
+            ...esPage,
+            translationLocale: "es",
+            revisionId: "es-revision-id",
+          },
+        ],
+        parent_id: "original-page-id",
+        pageTitle: "Test Page Title",
+      },
+    });
+  });
+});

package/src/tests/handlers/pages/URLsHandler.test/create.test.js

@@ -0,0 +1,160 @@
+import URLsHandler from "../../../../handlers/pages/URLsHandler";
+import Pages from "../../../../cloud/Pages";
+import Factory from "../../../support/factory";
+import { remoteConfig } from "../../../support/handlersHelper";
+
+function buildCtx(page, updateSettings) {
+  return {
+    client: {
+      pages: new Pages(() => ({}), "token"),
+    },
+    params: { parent_id: page.id },
+    resourceParams: {
+      resource: updateSettings,
+    },
+    locale: "en",
+    remoteConfig: remoteConfig(),
+    resourceConfig: {
+      pageType: "page",
+      pageTypePlural: "pages",
+    },
+  };
+}
+
+describe("Page change url", () => {
+  test("create successful", async () => {
+    const page = Factory.build("page");
+    const updateSettings = {
+      slug: "new-slug",
+      redirect: "1",
+    };
+    const ctx = buildCtx(page, updateSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const mockChange = jest
+      .spyOn(ctx.client.pages, "updateSlug")
+      .mockImplementation(() => ({ page, errors: null }));
+
+    const result = await URLsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+    expect(mockChange).toHaveBeenCalledWith(
+      page.id,
+      updateSettings.slug,
+      "en",
+      {
+        url: `/en/${page.slug}`,
+        destination: `/en/${updateSettings.slug}`,
+        httpResponseCode: 301,
+        note: "Created with changed URL for a page",
+      }
+    );
+
+    expect(result).toEqual({
+      redirect: `/en/pages/${page.id}`,
+    });
+  });
+
+  test("create failed due to slug error", async () => {
+    const page = Factory.build("page");
+    const updateSettings = {
+      slug: "new-slug",
+    };
+    const ctx = buildCtx(page, updateSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const mockChange = jest
+      .spyOn(ctx.client.pages, "updateSlug")
+      .mockImplementation(() => ({
+        page: null,
+        errors: [{ codes: [], key: "slug", message: "has already been taken" }],
+      }));
+
+    const result = await URLsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+    expect(mockChange).toHaveBeenCalledWith(
+      page.id,
+      updateSettings.slug,
+      "en",
+      null
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        resource: { ...updateSettings, id: page.id },
+        errors: { resource: { slug: "has already been taken" } },
+        _translations: [],
+      },
+    });
+  });
+
+  test("create failed due to redirect create", async () => {
+    const page = Factory.build("page");
+    const updateSettings = {
+      slug: "new-slug",
+      redirect: "1",
+    };
+    const ctx = buildCtx(page, updateSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const mockChange = jest
+      .spyOn(ctx.client.pages, "updateSlug")
+      .mockImplementation(() => ({
+        page: null,
+        errors: [
+          {
+            codes: [],
+            key: "generalError",
+            message: "url: has already been taken",
+          },
+        ],
+      }));
+
+    const result = await URLsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+    expect(mockChange).toHaveBeenCalledWith(
+      page.id,
+      updateSettings.slug,
+      "en",
+      {
+        url: `/en/${page.slug}`,
+        destination: `/en/${updateSettings.slug}`,
+        httpResponseCode: 301,
+        note: "Created with changed URL for a page",
+      }
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        resource: { ...updateSettings, id: page.id },
+        errors: { resource: { redirect: "url: has already been taken" } },
+        _translations: [],
+      },
+    });
+  });
+
+  test("create for non existing page", async () => {
+    const ctx = buildCtx({ id: "42" }, {});
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await URLsHandler.create(ctx);
+    }).rejects.toThrow("Cannot find page with id 42");
+
+    expect(mockFind).toHaveBeenCalledWith("42", "en");
+  });
+});

package/src/tests/handlers/pages/URLsHandler.test/create_form.test.js

@@ -0,0 +1,58 @@
+import URLsHandler from "../../../../handlers/pages/URLsHandler";
+import Pages from "../../../../cloud/Pages";
+import Factory from "../../../support/factory";
+
+function buildCtx(page) {
+  return {
+    client: {
+      pages: new Pages(() => ({}), "token"),
+    },
+    params: { parent_id: page.id },
+    locale: "en",
+    resourceConfig: {
+      pageType: "page",
+      pageTypePlural: "pages",
+    },
+  };
+}
+
+describe("Page change url", () => {
+  test("create_form for existing page", async () => {
+    const page = Factory.build("page");
+    const ctx = buildCtx(page);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => page);
+
+    const result = await URLsHandler.create_form(ctx, {
+      pageType: "page",
+      pageTypePlural: "pages",
+    });
+
+    expect(mockFind).toHaveBeenCalledWith(page.id, "en");
+
+    expect(result).toEqual({
+      assigns: {
+        page,
+        resource: { slug: page.slug, id: page.id, redirect: null },
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("create_form for non existing page", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockFind = jest
+      .spyOn(ctx.client.pages, "find")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await URLsHandler.create_form(ctx);
+    }).rejects.toThrow("Cannot find page with id 42");
+
+    expect(mockFind).toHaveBeenCalledWith("42", "en");
+  });
+});