@raketa-cloud/admin 0.0.33 → 0.0.36

package/src/tests/handlers/article_revisions/LocksHandler.test/create_form.test.js

@@ -0,0 +1,55 @@
+import Factory from "../../../support/factory";
+import ArticleRevisions from "../../../../cloud/ArticleRevisions";
+import LocksHandler from "../../../../handlers/article_revisions/LocksHandler";
+
+function buildCtx(revision) {
+  return {
+    client: {
+      articleRevisions: new ArticleRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "en",
+  };
+}
+
+describe("New article revision lock", () => {
+  test("create_form for locking article revision", async () => {
+    const revision = Factory.build("article_revision");
+    const ctx = buildCtx(revision);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const result = await LocksHandler.create_form(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          id: revision.id,
+          originalId: revision.originalId,
+          message: "",
+        },
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("create_form for non existing article revision", async () => {
+    const nonExistentRevision = Factory.build("article_revision");
+    const ctx = buildCtx(nonExistentRevision);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => null);
+
+    await expect(LocksHandler.create_form(ctx)).rejects.toThrow(
+      `Missing revision #${nonExistentRevision.id}`
+    );
+
+    expect(mockFind).toHaveBeenCalledWith(nonExistentRevision.id, "en");
+  });
+});

package/src/tests/handlers/article_revisions/UnlocksHandler.test/create.test.js

@@ -0,0 +1,84 @@
+import Factory from "../../../support/factory";
+import ArticleRevisions from "../../../../cloud/ArticleRevisions";
+import UnlocksHandler from "../../../../handlers/article_revisions/UnlocksHandler";
+
+function buildCtx(revision) {
+  return {
+    client: {
+      articleRevisions: new ArticleRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "en",
+    resourceConfig: {
+      articleType: "article",
+      articleTypePlural: "articles",
+    },
+  };
+}
+
+describe("Article revision unlock", () => {
+  test("unlock successful", async () => {
+    const revision = Factory.build("article_revision");
+    const ctx = buildCtx(revision);
+
+    const mockUnlock = jest
+      .spyOn(ctx.client.articleRevisions, "unlock")
+      .mockImplementation(() => ({
+        revision: revision,
+        errors: null,
+        articleErrors: null,
+      }));
+
+    const result = await UnlocksHandler.create(ctx);
+
+    expect(mockUnlock).toHaveBeenCalledWith(revision.id, "en");
+
+    expect(result).toEqual({
+      redirect: `/en/articles/${revision.originalId}`,
+    });
+  });
+
+  test("unlock failed with errors", async () => {
+    const revision = Factory.build("article_revision");
+    const ctx = buildCtx(revision);
+    const errors = [
+      { key: "generalError", message: "Failed to unlock revision" },
+    ];
+
+    const mockUnlock = jest
+      .spyOn(ctx.client.articleRevisions, "unlock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors,
+        articleErrors: null,
+      }));
+
+    await expect(UnlocksHandler.create(ctx)).rejects.toThrow(
+      `Failed to unlock revision: ${JSON.stringify(errors)}`
+    );
+
+    expect(mockUnlock).toHaveBeenCalledWith(revision.id, "en");
+  });
+
+  test("unlock failed with article errors", async () => {
+    const revision = Factory.build("article_revision");
+    const ctx = buildCtx(revision);
+    const articleErrors = [
+      { key: "generalError", message: "Failed to start revision" },
+    ];
+
+    const mockUnlock = jest
+      .spyOn(ctx.client.articleRevisions, "unlock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors: null,
+        articleErrors,
+      }));
+
+    await expect(UnlocksHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(articleErrors)}`
+    );
+
+    expect(mockUnlock).toHaveBeenCalledWith(revision.id, "en");
+  });
+});

package/src/tests/handlers/event_revisions/CodesHandler.test/update.test.js

@@ -32,7 +32,7 @@ describe("Event revision code settings", () => {
       settings: {
         codes: {
           scripts: JSON.stringify([{ type: "bla" }]),
-          structured_data: JSON.stringify({ type: "event" }),
+          structured_json: JSON.stringify({ type: "event" }),
         },
       },
     };
@@ -67,7 +67,7 @@ describe("Event revision code settings", () => {
         ...revision.settings,
         codes: {
           scripts: [{ type: "bla" }],
-          structured_data: { type: "event" },
+          structured_json: { type: "event" },
         },
       },
     });
@@ -88,7 +88,7 @@ describe("Event revision code settings", () => {
       settings: {
         codes: {
           scripts: JSON.stringify([{ type: "bla" }]),
-          structured_data: JSON.stringify({ type: "event" }),
+          structured_json: JSON.stringify({ type: "event" }),
         },
       },
     };
@@ -123,7 +123,7 @@ describe("Event revision code settings", () => {
         ...revision.settings,
         codes: {
           scripts: [{ type: "bla" }],
-          structured_data: { type: "event" },
+          structured_json: { type: "event" },
         },
       },
     });
@@ -139,7 +139,7 @@ describe("Event revision code settings", () => {
             ...revision.settings,
             codes: {
               scripts: [{ type: "bla" }],
-              structured_data: { type: "event" },
+              structured_json: { type: "event" },
             },
           },
         },

package/src/tests/handlers/event_revisions/LocksHandler.test/create.test.js

@@ -0,0 +1,142 @@
+import Factory from "../../../support/factory";
+import EventRevisions from "../../../../cloud/EventRevisions";
+import LocksHandler from "../../../../handlers/event_revisions/LocksHandler";
+
+function buildCtx(revision, lockSettings) {
+  return {
+    client: {
+      eventRevisions: new EventRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    resourceParams: {
+      resource: lockSettings,
+    },
+    locale: "en",
+    resourceConfig: {
+      eventType: "event",
+      eventTypePlural: "events",
+    },
+  };
+}
+
+describe("Event revision lock ", () => {
+  test("lock successful", async () => {
+    const revision = Factory.build("event_revision");
+    const lockSettings = { message: "Some lock message" };
+    const ctx = buildCtx(revision, lockSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.eventRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockLock = jest
+      .spyOn(ctx.client.eventRevisions, "lock")
+      .mockImplementation(() => ({
+        revision,
+        errors: null,
+        eventErrors: null,
+      }));
+
+    const result = await LocksHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockLock).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      lockSettings.message
+    );
+
+    expect(result).toEqual({
+      redirect: `/en/events/${revision.originalId}`,
+    });
+  });
+
+  test("lock failed with errors", async () => {
+    const revision = Factory.build("event_revision");
+    const lockSettings = { message: "" };
+    const ctx = buildCtx(revision, lockSettings);
+    const errors = [{ key: "message", message: "Cannot be blank" }];
+
+    const mockFind = jest
+      .spyOn(ctx.client.eventRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockLock = jest
+      .spyOn(ctx.client.eventRevisions, "lock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors,
+        eventErrors: null,
+      }));
+
+    const result = await LocksHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockLock).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      lockSettings.message
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          id: revision.id,
+          originalId: revision.originalId,
+          message: lockSettings.message,
+        },
+        errors: {
+          resource: { message: "Cannot be blank" },
+        },
+        _translations: [],
+      },
+    });
+  });
+
+  test("lock failed with event errors", async () => {
+    const revision = Factory.build("event_revision");
+    const lockSettings = { message: "Some lock message" };
+    const ctx = buildCtx(revision, lockSettings);
+    const eventErrors = [
+      { key: "generalError", message: "Failed to lock revision" },
+    ];
+
+    const mockFind = jest
+      .spyOn(ctx.client.eventRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockLock = jest
+      .spyOn(ctx.client.eventRevisions, "lock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors: null,
+        eventErrors,
+      }));
+
+    await expect(LocksHandler.create(ctx)).rejects.toThrow(
+      `Failed to lock revision: ${JSON.stringify(eventErrors)}`
+    );
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockLock).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      lockSettings.message
+    );
+  });
+
+  test("create for non existing event revision", async () => {
+    const lockSettings = { message: "Some lock message" };
+    const ctx = buildCtx({ id: 42 }, lockSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.eventRevisions, "find")
+      .mockImplementation(() => null);
+
+    await expect(LocksHandler.create(ctx)).rejects.toThrow(
+      `Missing revision #42`
+    );
+
+    expect(mockFind).toHaveBeenCalledWith(42, "en");
+  });
+});

package/src/tests/handlers/event_revisions/LocksHandler.test/create_form.test.js

@@ -0,0 +1,55 @@
+import Factory from "../../../support/factory";
+import EventRevisions from "../../../../cloud/EventRevisions";
+import LocksHandler from "../../../../handlers/event_revisions/LocksHandler";
+
+function buildCtx(revision) {
+  return {
+    client: {
+      eventRevisions: new EventRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "en",
+  };
+}
+
+describe("New event revision lock", () => {
+  test("create_form for locking event revision", async () => {
+    const revision = Factory.build("event_revision");
+    const ctx = buildCtx(revision);
+
+    const mockFind = jest
+      .spyOn(ctx.client.eventRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const result = await LocksHandler.create_form(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          id: revision.id,
+          originalId: revision.originalId,
+          message: "",
+        },
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("create_form for non existing event revision", async () => {
+    const nonExistentRevision = Factory.build("event_revision");
+    const ctx = buildCtx(nonExistentRevision);
+
+    const mockFind = jest
+      .spyOn(ctx.client.eventRevisions, "find")
+      .mockImplementation(() => null);
+
+    await expect(LocksHandler.create_form(ctx)).rejects.toThrow(
+      `Missing revision #${nonExistentRevision.id}`
+    );
+
+    expect(mockFind).toHaveBeenCalledWith(nonExistentRevision.id, "en");
+  });
+});

package/src/tests/handlers/event_revisions/UnlocksHandler.test/create.test.js

@@ -0,0 +1,84 @@
+import Factory from "../../../support/factory";
+import EventRevisions from "../../../../cloud/EventRevisions";
+import UnlocksHandler from "../../../../handlers/event_revisions/UnlocksHandler";
+
+function buildCtx(revision) {
+  return {
+    client: {
+      eventRevisions: new EventRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "en",
+    resourceConfig: {
+      eventType: "event",
+      eventTypePlural: "events",
+    },
+  };
+}
+
+describe("Event revision unlock", () => {
+  test("unlock successful", async () => {
+    const revision = Factory.build("event_revision");
+    const ctx = buildCtx(revision);
+
+    const mockUnlock = jest
+      .spyOn(ctx.client.eventRevisions, "unlock")
+      .mockImplementation(() => ({
+        revision: revision,
+        errors: null,
+        eventErrors: null,
+      }));
+
+    const result = await UnlocksHandler.create(ctx);
+
+    expect(mockUnlock).toHaveBeenCalledWith(revision.id, "en");
+
+    expect(result).toEqual({
+      redirect: `/en/events/${revision.originalId}`,
+    });
+  });
+
+  test("unlock failed with errors", async () => {
+    const revision = Factory.build("event_revision");
+    const ctx = buildCtx(revision);
+    const errors = [
+      { key: "generalError", message: "Failed to unlock revision" },
+    ];
+
+    const mockUnlock = jest
+      .spyOn(ctx.client.eventRevisions, "unlock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors,
+        eventErrors: null,
+      }));
+
+    await expect(UnlocksHandler.create(ctx)).rejects.toThrow(
+      `Failed to unlock revision: ${JSON.stringify(errors)}`
+    );
+
+    expect(mockUnlock).toHaveBeenCalledWith(revision.id, "en");
+  });
+
+  test("unlock failed with event errors", async () => {
+    const revision = Factory.build("event_revision");
+    const ctx = buildCtx(revision);
+    const eventErrors = [
+      { key: "generalError", message: "Failed to start revision" },
+    ];
+
+    const mockUnlock = jest
+      .spyOn(ctx.client.eventRevisions, "unlock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors: null,
+        eventErrors,
+      }));
+
+    await expect(UnlocksHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(eventErrors)}`
+    );
+
+    expect(mockUnlock).toHaveBeenCalledWith(revision.id, "en");
+  });
+});

package/src/tests/handlers/page_revisions/CodesHandler.test/edit_form.test.js

@@ -18,7 +18,7 @@ describe("Page revision code settings", () => {
     const revision = Factory.build("page_revision", {
       settings: {
         codes: {
-          structured_data: {},
+          structured_json: {},
           scripts: [],
         },
       },

package/src/tests/handlers/page_revisions/CodesHandler.test/update.test.js

@@ -28,7 +28,7 @@ describe("Page revision code settings", () => {
       settings: {
         codes: {
           scripts: JSON.stringify([{ type: "bla" }]),
-          structured_data: JSON.stringify({ type: "article" }),
+          structured_json: JSON.stringify({ type: "article" }),
         },
       },
     };
@@ -60,7 +60,7 @@ describe("Page revision code settings", () => {
         ...revision.settings,
         codes: {
           scripts: [{ type: "bla" }],
-          structured_data: { type: "article" },
+          structured_json: { type: "article" },
         },
       },
     });
@@ -77,7 +77,7 @@ describe("Page revision code settings", () => {
       settings: {
         codes: {
           scripts: JSON.stringify([{ type: "bla" }]),
-          structured_data: JSON.stringify({ type: "article" }),
+          structured_json: JSON.stringify({ type: "article" }),
         },
       },
     };
@@ -109,7 +109,7 @@ describe("Page revision code settings", () => {
         ...revision.settings,
         codes: {
           scripts: [{ type: "bla" }],
-          structured_data: { type: "article" },
+          structured_json: { type: "article" },
         },
       },
     });
@@ -122,7 +122,7 @@ describe("Page revision code settings", () => {
             ...revision.settings,
             codes: {
               scripts: [{ type: "bla" }],
-              structured_data: { type: "article" },
+              structured_json: { type: "article" },
             },
           },
         },

package/src/tests/handlers/page_revisions/LocksHandler.test/create.test.js

@@ -0,0 +1,138 @@
+import Factory from "../../../support/factory";
+import PageRevisions from "../../../../cloud/PageRevisions";
+import LocksHandler from "../../../../handlers/page_revisions/LocksHandler";
+
+function buildCtx(revision, lockSettings) {
+  return {
+    client: {
+      pageRevisions: new PageRevisions(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    resourceParams: {
+      resource: lockSettings,
+    },
+    locale: "en",
+    resourceConfig: {
+      pageType: "page",
+      pageTypePlural: "pages",
+    },
+  };
+}
+
+describe("Page revision lock ", () => {
+  test("lock successful", async () => {
+    const revision = Factory.build("page_revision");
+    const lockSettings = { message: "Some lock message" };
+    const ctx = buildCtx(revision, lockSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pageRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockLock = jest
+      .spyOn(ctx.client.pageRevisions, "lock")
+      .mockImplementation(() => ({
+        revision,
+        errors: null,
+        pageErrors: null,
+      }));
+
+    const result = await LocksHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockLock).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      lockSettings.message
+    );
+
+    expect(result).toEqual({
+      redirect: `/en/pages/${revision.originalId}`,
+    });
+  });
+
+  test("lock failed with errors", async () => {
+    const revision = Factory.build("page_revision");
+    const lockSettings = { message: "" };
+    const ctx = buildCtx(revision, lockSettings);
+    const errors = [{ key: "message", message: "Cannot be blank" }];
+
+    const mockFind = jest
+      .spyOn(ctx.client.pageRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockLock = jest
+      .spyOn(ctx.client.pageRevisions, "lock")
+      .mockImplementation(() => ({ revision: null, errors, pageErrors: null }));
+
+    const result = await LocksHandler.create(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockLock).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      lockSettings.message
+    );
+
+    expect(result).toEqual({
+      assigns: {
+        resource: {
+          id: revision.id,
+          originalId: revision.originalId,
+          message: lockSettings.message,
+        },
+        errors: {
+          resource: { message: "Cannot be blank" },
+        },
+        _translations: [],
+      },
+    });
+  });
+
+  test("lock failed with page errors", async () => {
+    const revision = Factory.build("page_revision");
+    const lockSettings = { message: "Some lock message" };
+    const ctx = buildCtx(revision, lockSettings);
+    const pageErrors = [
+      { key: "generalError", message: "Failed to lock revision" },
+    ];
+
+    const mockFind = jest
+      .spyOn(ctx.client.pageRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockLock = jest
+      .spyOn(ctx.client.pageRevisions, "lock")
+      .mockImplementation(() => ({
+        revision: null,
+        errors: null,
+        pageErrors,
+      }));
+
+    await expect(LocksHandler.create(ctx)).rejects.toThrow(
+      `Failed to lock revision: ${JSON.stringify(pageErrors)}`
+    );
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockLock).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      lockSettings.message
+    );
+  });
+
+  test("create for non existing page revision", async () => {
+    const lockSettings = { message: "Some lock message" };
+    const ctx = buildCtx({ id: 42 }, lockSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.pageRevisions, "find")
+      .mockImplementation(() => null);
+
+    await expect(LocksHandler.create(ctx)).rejects.toThrow(
+      `Missing revision #42`
+    );
+
+    expect(mockFind).toHaveBeenCalledWith(42, "en");
+  });
+});