@raketa-cloud/admin 0.0.69 → 0.0.71

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

@@ -0,0 +1,297 @@
+import EventRevisions from "../../../../cloud/EventRevisions";
+import Events from "../../../../cloud/Events";
+import TranslationsHandler from "../../../../handlers/events/TranslationsHandler";
+import Factory from "../../../support/factory";
+
+function buildCtx(params, event) {
+  return {
+    client: {
+      events: new Events(() => ({}), "token"),
+      eventRevisions: new EventRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: event.id },
+    resourceParams: {
+      resource: params,
+    },
+    locale: "en",
+    resourceConfig: {
+      eventType: "event",
+      eventTypePlural: "events",
+    },
+  };
+}
+
+describe("Events Translation Handler", () => {
+  test("create fails with translation errors", async () => {
+    const event = Factory.build("event", {
+      translations: {},
+      categories: [{ id: "cat1" }],
+    });
+    const params = {
+      languages: ["fr"],
+    };
+
+    const ctx = buildCtx(params, event);
+
+    const mockFind = jest
+      .spyOn(ctx.client.events, "find")
+      .mockImplementation(() => event);
+
+    const translationErrors = [{ key: "title", message: "cannot be blank" }];
+    const mockTranslate = jest
+      .spyOn(ctx.client.events, "translate")
+      .mockImplementation(() => ({
+        event: null,
+        errors: translationErrors,
+      }));
+
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.events, "formatErrors")
+      .mockImplementation(() => ({ title: "cannot be blank" }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(event.id, "en");
+    expect(mockTranslate).toHaveBeenCalled();
+    expect(mockFormatErrors).toHaveBeenCalledWith(translationErrors);
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          title: event.title,
+          tags: [],
+          visibility: "private",
+          slug: event.slug,
+          settings: event.settings,
+          widgets: event.widgets,
+          categories: ["cat1"],
+          publishAt: event.publishAt,
+          startsAt: event.startsAt,
+          endsAt: event.endsAt,
+          translations: {},
+          languages: ["fr"],
+        },
+        blueprint: event,
+        targetLocale: "fr",
+        errors: { resource: { title: "cannot be blank" } },
+      },
+    });
+  });
+
+  test("create successfully multiple translations with already one is existing", async () => {
+    const event = Factory.build("event", {
+      translations: { de: "de-id" },
+      categories: [{ id: "cat1" }],
+    });
+
+    const params = {
+      languages: ["fr", "es", "de"],
+    };
+
+    const ctx = buildCtx(params, event);
+
+    const mockFind = jest
+      .spyOn(ctx.client.events, "find")
+      .mockImplementation(() => event);
+
+    const mockTranslate = jest
+      .spyOn(ctx.client.events, "translate")
+      .mockImplementation((parentId, locale) => ({
+        event: { id: `translated-event-${locale}` },
+        errors: null,
+      }));
+
+    const mockCreateRevision = jest
+      .spyOn(ctx.client.eventRevisions, "create")
+      .mockImplementation(() => ({ errors: null }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(event.id, "en");
+
+    expect(mockTranslate).toHaveBeenCalledTimes(2);
+    expect(mockTranslate).toHaveBeenCalledWith(
+      event.id,
+      "fr",
+      expect.objectContaining({
+        title: event.title,
+        tags: [],
+        visibility: "private",
+        slug: event.slug,
+      })
+    );
+    expect(mockTranslate).toHaveBeenCalledWith(
+      event.id,
+      "es",
+      expect.objectContaining({
+        title: event.title,
+        tags: [],
+        visibility: "private",
+        slug: event.slug,
+      })
+    );
+
+    expect(mockCreateRevision).toHaveBeenCalledTimes(2);
+    expect(mockCreateRevision).toHaveBeenCalledWith(
+      "translated-event-fr",
+      "fr"
+    );
+    expect(mockCreateRevision).toHaveBeenCalledWith(
+      "translated-event-es",
+      "es"
+    );
+
+    expect(result).toEqual({
+      redirect: `/en/events/${event.id}/translations?translations=fr:translated-event-fr;es:translated-event-es`,
+    });
+  });
+
+  test("create translations fails if any translation fails", async () => {
+    const event = Factory.build("event", {
+      translations: {},
+      categories: [{ id: "some-category-uno" }],
+    });
+
+    const params = {
+      languages: ["fr", "es"],
+    };
+
+    const ctx = buildCtx(params, event);
+
+    const mockFind = jest
+      .spyOn(ctx.client.events, "find")
+      .mockImplementation(() => event);
+
+    const translationResponses = {
+      fr: { event: { id: "translated-event-fr" }, errors: null },
+      es: {
+        event: null,
+        errors: [{ key: "title", message: "invalid for spanish" }],
+      },
+    };
+
+    const mockTranslate = jest
+      .spyOn(ctx.client.events, "translate")
+      .mockImplementation((parentId, locale) => translationResponses[locale]);
+
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.events, "formatErrors")
+      .mockImplementation(() => ({
+        title: "invalid for spanish",
+      }));
+
+    const mockCreateRevision = jest
+      .spyOn(ctx.client.eventRevisions, "create")
+      .mockImplementation(() => ({ errors: null }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(event.id, "en");
+
+    expect(mockTranslate).toHaveBeenCalledWith(
+      event.id,
+      "fr",
+      expect.objectContaining({
+        title: event.title,
+        tags: [],
+        visibility: "private",
+        slug: event.slug,
+      })
+    );
+
+    expect(mockTranslate).toHaveBeenCalledWith(
+      event.id,
+      "es",
+      expect.objectContaining({
+        title: event.title,
+        tags: [],
+        visibility: "private",
+        slug: event.slug,
+      })
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          title: event.title,
+          tags: [],
+          visibility: "private",
+          slug: event.slug,
+          settings: event.settings,
+          widgets: event.widgets,
+          categories: ["some-category-uno"],
+          publishAt: event.publishAt,
+          startsAt: event.startsAt,
+          endsAt: event.endsAt,
+          translations: {},
+          languages: ["fr", "es"],
+        },
+        blueprint: event,
+        targetLocale: "es",
+        errors: { resource: { title: "invalid for spanish" } },
+      },
+    });
+  });
+
+  test("create translation fails with revision errors", async () => {
+    const event = Factory.build("event", {
+      translations: {},
+      categories: [{ id: "cat1" }],
+    });
+    const params = {
+      languages: ["fr"],
+    };
+
+    const ctx = buildCtx(params, event);
+
+    const mockFind = jest
+      .spyOn(ctx.client.events, "find")
+      .mockImplementation(() => event);
+
+    const mockTranslate = jest
+      .spyOn(ctx.client.events, "translate")
+      .mockImplementation(() => ({
+        event: { id: "translated-event-id" },
+        errors: null,
+      }));
+
+    const revisionErrors = [{ key: "base", message: "something went wrong" }];
+    const mockCreateRevision = jest
+      .spyOn(ctx.client.eventRevisions, "create")
+      .mockImplementation(() => ({ errors: revisionErrors }));
+
+    const mockFormatErrors = jest
+      .spyOn(ctx.client.events, "formatErrors")
+      .mockImplementation(() => ({ base: "something went wrong" }));
+
+    const result = await TranslationsHandler.create(ctx);
+
+    expect(mockCreateRevision).toHaveBeenCalledWith(
+      "translated-event-id",
+      "fr"
+    );
+    expect(mockFormatErrors).toHaveBeenCalledWith(revisionErrors);
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          title: event.title,
+          tags: [],
+          visibility: "private",
+          slug: event.slug,
+          settings: event.settings,
+          widgets: event.widgets,
+          categories: ["cat1"],
+          publishAt: event.publishAt,
+          startsAt: event.startsAt,
+          endsAt: event.endsAt,
+          translations: {},
+          languages: ["fr"],
+        },
+        blueprint: event,
+        targetLocale: "fr",
+        errors: { resource: { base: "something went wrong" } },
+      },
+    });
+  });
+});

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

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

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

@@ -0,0 +1,91 @@
+import EventRevisions from "../../../../cloud/EventRevisions";
+import Events from "../../../../cloud/Events";
+import TranslationsHandler from "../../../../handlers/events/TranslationsHandler";
+import Factory from "../../../support/factory";
+
+function buildCtx() {
+  const originalEvent = Factory.build("event", {
+    id: "original-event-id",
+    title: "Test Event Title",
+  });
+
+  return {
+    client: {
+      events: new Events(() => ({}), "token"),
+      eventRevisions: new EventRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: originalEvent.id },
+    query: { translations: "fr:fr-event-id;es:es-event-id" },
+    locale: "en",
+    resourceConfig: {
+      eventType: "event",
+      eventTypePlural: "events",
+    },
+    originalEvent,
+  };
+}
+
+describe("Translations Handler", () => {
+  test("index", async () => {
+    const frEvent = Factory.build("event", { id: "fr-event-id" });
+    const esEvent = Factory.build("event", { id: "es-event-id" });
+    const esRevision = Factory.build("event_revision", {
+      id: "es-revision-id",
+    });
+    const frRevision = Factory.build("event_revision", {
+      id: "fr-revision-id",
+    });
+    const ctx = buildCtx();
+
+    const mockedFind = jest
+      .spyOn(ctx.client.events, "find")
+      .mockImplementation((id, locale) => {
+        if (locale === "fr") return frEvent;
+        if (locale === "es") return esEvent;
+        if (id === "original-event-id") return ctx.originalEvent;
+      });
+
+    const mockedRevisions = jest
+      .spyOn(ctx.client.eventRevisions, "all")
+      .mockImplementation((id, locale) => ({
+        list: locale === "fr" ? [frRevision] : [esRevision],
+      }));
+
+    const mockedList = jest
+      .spyOn(ctx.client.events, "list")
+      .mockImplementation(() => ({}));
+
+    const result = await TranslationsHandler.index(ctx);
+
+    expect(mockedFind).toHaveBeenCalledWith("fr-event-id", "fr");
+    expect(mockedFind).toHaveBeenCalledWith("es-event-id", "es");
+    expect(mockedRevisions).toHaveBeenCalledWith("fr-event-id", "fr");
+    expect(mockedRevisions).toHaveBeenCalledWith("es-event-id", "es");
+    expect(mockedList).toHaveBeenCalledWith(
+      { translations: "fr:fr-event-id;es:es-event-id" },
+      "en",
+      "event"
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        items: {},
+        visibilityOptions: ctx.client.events.visibilityOptions(),
+        translations: [
+          {
+            ...frEvent,
+            translationLocale: "fr",
+            revisionId: "fr-revision-id",
+          },
+          {
+            ...esEvent,
+            translationLocale: "es",
+            revisionId: "es-revision-id",
+          },
+        ],
+        parent_id: "original-event-id",
+        eventTitle: "Test Event Title",
+      },
+    });
+  });
+});

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

@@ -21,7 +21,7 @@ function buildCtx(params, page) {
   };
 }
 
-describe("Translation Handler", () => {
+describe("Pages Translation Handler", () => {
   test("create fails with translation errors", async () => {
     const page = Factory.build("page", {
       translations: {},