@raketa-cloud/admin 1.2.0 → 1.4.0

package/src/tests/filters.test.js

@@ -0,0 +1,97 @@
+import { setBeforeFilter, setAfterFilter } from "../filters";
+import HonoAdapter from "../HonoAdapter";
+
+class MockHonoAdapter {
+  constructor() {
+    this.globalBeforeFilters = [];
+    this.globalAfterFilters = [];
+  }
+  
+  setBeforeFilter(pattern, filter) {
+    this.globalBeforeFilters.push({ pattern, filter });
+  }
+  
+  setAfterFilter(pattern, filter) {
+    this.globalAfterFilters.push({ pattern, filter });
+  }
+}
+
+describe("filters", () => {
+  let adapter;
+  
+  beforeEach(() => {
+    adapter = new MockHonoAdapter();
+  });
+  
+  describe("setBeforeFilter", () => {
+    test("adds before filter to adapter", () => {
+      const pattern = /\/settings\/content/;
+      const filter = () => ({ assigns: { foo: "bar" } });
+      
+      setBeforeFilter(adapter, pattern, filter);
+      
+      expect(adapter.globalBeforeFilters).toHaveLength(1);
+      expect(adapter.globalBeforeFilters[0]).toEqual({
+        pattern,
+        filter
+      });
+    });
+    
+    test("can add multiple before filters", () => {
+      const pattern1 = /\/settings\/content/;
+      const filter1 = () => ({ assigns: { foo: "bar" } });
+      
+      const pattern2 = /\/pages/;
+      const filter2 = () => ({ assigns: { baz: "qux" } });
+      
+      setBeforeFilter(adapter, pattern1, filter1);
+      setBeforeFilter(adapter, pattern2, filter2);
+      
+      expect(adapter.globalBeforeFilters).toHaveLength(2);
+      expect(adapter.globalBeforeFilters[0]).toEqual({
+        pattern: pattern1,
+        filter: filter1
+      });
+      expect(adapter.globalBeforeFilters[1]).toEqual({
+        pattern: pattern2,
+        filter: filter2
+      });
+    });
+  });
+  
+  describe("setAfterFilter", () => {
+    test("adds after filter to adapter", () => {
+      const pattern = /\/settings\/content/;
+      const filter = () => ({ assigns: { foo: "bar" } });
+      
+      setAfterFilter(adapter, pattern, filter);
+      
+      expect(adapter.globalAfterFilters).toHaveLength(1);
+      expect(adapter.globalAfterFilters[0]).toEqual({
+        pattern,
+        filter
+      });
+    });
+    
+    test("can add multiple after filters", () => {
+      const pattern1 = /\/settings\/content/;
+      const filter1 = () => ({ assigns: { foo: "bar" } });
+      
+      const pattern2 = /\/pages/;
+      const filter2 = () => ({ assigns: { baz: "qux" } });
+      
+      setAfterFilter(adapter, pattern1, filter1);
+      setAfterFilter(adapter, pattern2, filter2);
+      
+      expect(adapter.globalAfterFilters).toHaveLength(2);
+      expect(adapter.globalAfterFilters[0]).toEqual({
+        pattern: pattern1,
+        filter: filter1
+      });
+      expect(adapter.globalAfterFilters[1]).toEqual({
+        pattern: pattern2,
+        filter: filter2
+      });
+    });
+  });
+});

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

@@ -1,12 +1,13 @@
-import ArticleRevisionsHandler from "../../../../handlers/article_revisions/ArticleRevisionsHandler";
 import ArticleRevisions from "../../../../cloud/ArticleRevisions";
-
+import Articles from "../../../../cloud/Articles";
+import ArticleRevisionsHandler from "../../../../handlers/article_revisions/ArticleRevisionsHandler";
 import Factory from "../../../support/factory";
 
 function buildCtx(articleID) {
   return {
     client: {
       articleRevisions: new ArticleRevisions(() => ({}), "token"),
+      articles: new Articles(() => ({}), "token"),
     },
     params: { parent_id: articleID },
     locale: "en",
@@ -14,66 +15,73 @@ function buildCtx(articleID) {
       articleType: "article",
       articleTypePlural: "articles",
     },
+    maxOpenRevisions: 1,
   };
 }
 
 describe("Article revisions", () => {
   test("create successful", async () => {
+    const article = Factory.build("article", { id: 1, revisionsCount: 0 });
     const revision = Factory.build("article_revision", { originalId: 1 });
-    const ctx = buildCtx(revision.originalId);
+    const ctx = buildCtx(article.id);
+
+    jest.spyOn(ctx.client.articles, "find").mockResolvedValue(article);
 
-    const mockCreate = jest
+    jest
       .spyOn(ctx.client.articleRevisions, "create")
-      .mockImplementation(() => ({
-        revision,
-        errors: null,
-        articleErrors: null,
-      }));
+      .mockResolvedValue({ revision, errors: null, articleErrors: null });
 
     const result = await ArticleRevisionsHandler.create(ctx);
 
-    expect(mockCreate).toHaveBeenCalledWith(revision.originalId, "en");
+    expect(result).toEqual({
+      redirect: `/en/articles/${article.id}`,
+    });
+  });
+
+  test("create failed when there is an opened revision for the article", async () => {
+    const article = Factory.build("article", { id: 1, revisionsCount: 2 });
+    const ctx = buildCtx(article.id);
+
+    jest.spyOn(ctx.client.articles, "find").mockResolvedValue(article);
+
+    const result = await ArticleRevisionsHandler.create(ctx);
 
     expect(result).toEqual({
-      redirect: `/en/articles/${revision.originalId}`,
+      redirect: `/en/articles/${article.id}?revisions_count_error=1`,
     });
   });
 
   test("create failed with errors", async () => {
-    const ctx = buildCtx(1);
+    const article = Factory.build("article", { id: 1, revisionsCount: 0 });
     const errors = [{ key: "generalError", message: "something went wrong" }];
+    const ctx = buildCtx(article.id);
 
-    const mockCreate = jest
-      .spyOn(ctx.client.articleRevisions, "create")
-      .mockImplementation(() => ({
-        revision: null,
-        errors,
-        articleErrors: null,
-      }));
+    jest.spyOn(ctx.client.articles, "find").mockResolvedValue(article);
 
-    expect(async () => {
-      await ArticleRevisionsHandler.create(ctx);
-    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+    jest
+      .spyOn(ctx.client.articleRevisions, "create")
+      .mockResolvedValue({ revision: null, errors, articleErrors: null });
 
-    expect(mockCreate).toHaveBeenCalledWith(1, "en");
+    await expect(ArticleRevisionsHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(errors)}`
+    );
   });
 
   test("create failed with article errors", async () => {
-    const ctx = buildCtx(1);
+    const article = Factory.build("article", { id: 1, revisionsCount: 0 });
     const errors = [{ key: "generalError", message: "something went wrong" }];
+    const ctx = buildCtx(article.id);
 
-    const mockCreate = jest
-      .spyOn(ctx.client.articleRevisions, "create")
-      .mockImplementation(() => ({
-        revision: null,
-        errors: null,
-        articleErrors: errors,
-      }));
+    jest.spyOn(ctx.client.articles, "find").mockResolvedValue(article);
 
-    expect(async () => {
-      await ArticleRevisionsHandler.create(ctx);
-    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+    jest.spyOn(ctx.client.articleRevisions, "create").mockResolvedValue({
+      revision: null,
+      errors: null,
+      articleErrors: errors,
+    });
 
-    expect(mockCreate).toHaveBeenCalledWith(1, "en");
+    await expect(ArticleRevisionsHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(errors)}`
+    );
   });
 });

package/src/tests/handlers/articles/ArticlesHandler.test/show.test.js

@@ -72,7 +72,18 @@ describe("Articles Handler", () => {
 
     expect(mockedArticleFind).toHaveBeenCalledWith(article.id, "en");
     expect(mockedArticleRevisions).toHaveBeenCalledWith(article.id, "en");
-    expect(mockedArticleChanges).toHaveBeenCalledWith({}, article.id, "en");
+    expect(mockedArticleChanges).toHaveBeenCalledWith(
+      {
+        "f:change_type": [
+          "revision_publish",
+          "revision_lock",
+          "revision_unlock",
+          "update",
+        ],
+      },
+      article.id,
+      "en"
+    );
 
     expect(result).toEqual({
       assigns: {

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

@@ -1,4 +1,6 @@
+import Events from "../../../../cloud/Events";
 import EventRevisionsHandler from "../../../../handlers/event_revisions/EventRevisionsHandler";
+
 import EventRevisions from "../../../../cloud/EventRevisions";
 
 import Factory from "../../../support/factory";
@@ -7,6 +9,7 @@ function buildCtx(eventID) {
   return {
     client: {
       eventRevisions: new EventRevisions(() => ({}), "token"),
+      events: new Events(() => ({}), "token"),
     },
     params: { parent_id: eventID },
     locale: "en",
@@ -14,66 +17,71 @@ function buildCtx(eventID) {
       eventType: "event",
       eventTypePlural: "events",
     },
+    maxOpenRevisions: 1,
   };
 }
 
 describe("Event revisions", () => {
   test("create successful", async () => {
+    const event = Factory.build("event", { id: 1, revisionsCount: 0 });
     const revision = Factory.build("event_revision", { originalId: 1 });
-    const ctx = buildCtx(revision.originalId);
+    const ctx = buildCtx(event.id);
+
+    jest.spyOn(ctx.client.events, "find").mockResolvedValue(event);
 
-    const mockCreate = jest
+    jest
       .spyOn(ctx.client.eventRevisions, "create")
-      .mockImplementation(() => ({
-        revision,
-        errors: null,
-        eventErrors: null,
-      }));
+      .mockResolvedValue({ revision, errors: null, eventErrors: null });
 
     const result = await EventRevisionsHandler.create(ctx);
 
-    expect(mockCreate).toHaveBeenCalledWith(revision.originalId, "en");
+    expect(result).toEqual({
+      redirect: `/en/events/${event.id}`,
+    });
+  });
+
+  test("create failed when there is an opened revision for the event", async () => {
+    const event = Factory.build("event", { id: 1, revisionsCount: 2 });
+    const ctx = buildCtx(event.id);
+
+    jest.spyOn(ctx.client.events, "find").mockResolvedValue(event);
+
+    const result = await EventRevisionsHandler.create(ctx);
 
     expect(result).toEqual({
-      redirect: `/en/events/${revision.originalId}`,
+      redirect: `/en/events/${event.id}?revisions_count_error=1`,
     });
   });
 
   test("create failed with errors", async () => {
-    const ctx = buildCtx(1);
+    const event = Factory.build("event", { id: 1, revisionsCount: 0 });
     const errors = [{ key: "generalError", message: "something went wrong" }];
+    const ctx = buildCtx(event.id);
 
-    const mockCreate = jest
-      .spyOn(ctx.client.eventRevisions, "create")
-      .mockImplementation(() => ({
-        revision: null,
-        errors,
-        eventErrors: null,
-      }));
+    jest.spyOn(ctx.client.events, "find").mockResolvedValue(event);
 
-    expect(async () => {
-      await EventRevisionsHandler.create(ctx);
-    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+    jest
+      .spyOn(ctx.client.eventRevisions, "create")
+      .mockResolvedValue({ revision: null, errors, eventErrors: null });
 
-    expect(mockCreate).toHaveBeenCalledWith(1, "en");
+    await expect(EventRevisionsHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(errors)}`
+    );
   });
 
   test("create failed with event errors", async () => {
-    const ctx = buildCtx(1);
+    const event = Factory.build("event", { id: 1, revisionsCount: 0 });
     const errors = [{ key: "generalError", message: "something went wrong" }];
+    const ctx = buildCtx(event.id);
 
-    const mockCreate = jest
-      .spyOn(ctx.client.eventRevisions, "create")
-      .mockImplementation(() => ({
-        revision: null,
-        errors: null,
-        eventErrors: errors,
-      }));
+    jest.spyOn(ctx.client.events, "find").mockResolvedValue(event);
 
-    expect(async () => {
-      await EventRevisionsHandler.create(ctx);
-    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+    jest
+      .spyOn(ctx.client.eventRevisions, "create")
+      .mockResolvedValue({ revision: null, errors: null, eventErrors: errors });
 
-    expect(mockCreate).toHaveBeenCalledWith(1, "en");
+    await expect(EventRevisionsHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(errors)}`
+    );
   });
 });

package/src/tests/handlers/events/EventsHandler.test/show.test.js

@@ -72,7 +72,18 @@ describe("Events Handler", () => {
 
     expect(mockedeventFind).toHaveBeenCalledWith(event.id, "en");
     expect(mockedEventRevisions).toHaveBeenCalledWith(event.id, "en");
-    expect(mockedEventChanges).toHaveBeenCalledWith({}, event.id, "en");
+    expect(mockedEventChanges).toHaveBeenCalledWith(
+      {
+        "f:change_type": [
+          "revision_publish",
+          "revision_lock",
+          "revision_unlock",
+          "update",
+        ],
+      },
+      event.id,
+      "en"
+    );
 
     expect(result).toEqual({
       assigns: {

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

@@ -1,12 +1,13 @@
-import PageRevisionsHandler from "../../../../handlers/page_revisions/PageRevisionsHandler";
 import PageRevisions from "../../../../cloud/PageRevisions";
-
+import Pages from "../../../../cloud/Pages";
+import PageRevisionsHandler from "../../../../handlers/page_revisions/PageRevisionsHandler";
 import Factory from "../../../support/factory";
 
 function buildCtx(pageID) {
   return {
     client: {
       pageRevisions: new PageRevisions(() => ({}), "token"),
+      pages: new Pages(() => ({}), "token"),
     },
     params: { parent_id: pageID },
     locale: "en",
@@ -14,58 +15,71 @@ function buildCtx(pageID) {
       pageType: "page",
       pageTypePlural: "pages",
     },
+    maxOpenRevisions: 1,
   };
 }
 
 describe("Page revisions", () => {
   test("create successful", async () => {
+    const page = Factory.build("page", { id: 1, revisionsCount: 0 });
     const revision = Factory.build("page_revision", { originalId: 1 });
-    const ctx = buildCtx(revision.originalId);
+    const ctx = buildCtx(page.id);
+
+    jest.spyOn(ctx.client.pages, "find").mockResolvedValue(page);
 
-    const mockCreate = jest
+    jest
       .spyOn(ctx.client.pageRevisions, "create")
-      .mockImplementation(() => ({ revision, errors: null, pageErrors: null }));
+      .mockResolvedValue({ revision, errors: null, pageErrors: null });
 
     const result = await PageRevisionsHandler.create(ctx);
 
-    expect(mockCreate).toHaveBeenCalledWith(revision.originalId, "en");
+    expect(result).toEqual({
+      redirect: `/en/pages/${page.id}`,
+    });
+  });
+
+  test("create failed when there is an opened revision for the page", async () => {
+    const page = Factory.build("page", { id: 1, revisionsCount: 2 });
+    const ctx = buildCtx(page.id);
+
+    jest.spyOn(ctx.client.pages, "find").mockResolvedValue(page);
+
+    const result = await PageRevisionsHandler.create(ctx);
 
     expect(result).toEqual({
-      redirect: `/en/pages/${revision.originalId}`,
+      redirect: `/en/pages/${page.id}?revisions_count_error=1`,
     });
   });
 
   test("create failed with errors", async () => {
-    const ctx = buildCtx(1);
+    const page = Factory.build("page", { id: 1, revisionsCount: 0 });
     const errors = [{ key: "generalError", message: "something went wrong" }];
+    const ctx = buildCtx(page.id);
 
-    const mockCreate = jest
-      .spyOn(ctx.client.pageRevisions, "create")
-      .mockImplementation(() => ({ revision: null, errors, pageErrors: null }));
+    jest.spyOn(ctx.client.pages, "find").mockResolvedValue(page);
 
-    expect(async () => {
-      await PageRevisionsHandler.create(ctx);
-    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+    jest
+      .spyOn(ctx.client.pageRevisions, "create")
+      .mockResolvedValue({ revision: null, errors, pageErrors: null });
 
-    expect(mockCreate).toHaveBeenCalledWith(1, "en");
+    await expect(PageRevisionsHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(errors)}`
+    );
   });
 
   test("create failed with page errors", async () => {
-    const ctx = buildCtx(1);
+    const page = Factory.build("page", { id: 1, revisionsCount: 0 });
     const errors = [{ key: "generalError", message: "something went wrong" }];
+    const ctx = buildCtx(page.id);
 
-    const mockCreate = jest
-      .spyOn(ctx.client.pageRevisions, "create")
-      .mockImplementation(() => ({
-        revision: null,
-        errors: null,
-        pageErrors: errors,
-      }));
+    jest.spyOn(ctx.client.pages, "find").mockResolvedValue(page);
 
-    expect(async () => {
-      await PageRevisionsHandler.create(ctx);
-    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+    jest
+      .spyOn(ctx.client.pageRevisions, "create")
+      .mockResolvedValue({ revision: null, errors: null, pageErrors: errors });
 
-    expect(mockCreate).toHaveBeenCalledWith(1, "en");
+    await expect(PageRevisionsHandler.create(ctx)).rejects.toThrow(
+      `Failed to start revision: ${JSON.stringify(errors)}`
+    );
   });
 });

package/src/tests/handlers/pages/PagesHandler.test/show.test.js

@@ -70,7 +70,18 @@ describe("Pages Handler", () => {
 
     expect(mockedPageFind).toHaveBeenCalledWith(page.id, "en");
     expect(mockedPageRevisions).toHaveBeenCalledWith(page.id, "en");
-    expect(mockedPageChanges).toHaveBeenCalledWith({}, page.id, "en");
+    expect(mockedPageChanges).toHaveBeenCalledWith(
+      {
+        "f:change_type": [
+          "revision_publish",
+          "revision_lock",
+          "revision_unlock",
+          "update",
+        ],
+      },
+      page.id,
+      "en"
+    );
 
     expect(result).toEqual({
       assigns: {

package/src/tests/routeCollection.test.js

@@ -10,18 +10,6 @@ const UsersHandler = {
   destroy: () => {},
 };
 
-const UsersHandlerWithFilters = {
-  before_filter: () => {},
-  after_filter: () => {},
-  index: () => {},
-  show: () => {},
-  create_form: () => {},
-  edit_form: () => {},
-  create: () => {},
-  update: () => {},
-  destroy: () => {},
-};
-
 const honoAdapter = {
   routeCollection: (_mapping) => {},
 };
@@ -80,84 +68,4 @@ describe("routeCollection", () => {
       {}
     );
   });
-
-  test("Valid handler mapping is passed to router with filters", () => {
-    routeCollection(honoAdapter, "users", UsersHandlerWithFilters);
-
-    expect(adapterSpy).toHaveBeenCalledWith(
-      [
-        [
-          "GET",
-          "/users",
-          "users",
-          "users",
-          "index",
-          UsersHandlerWithFilters.index,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-        [
-          "GET",
-          "/users/new",
-          "users",
-          "users",
-          "create_form",
-          UsersHandlerWithFilters.create_form,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-        [
-          "GET",
-          "/users/:id",
-          "users",
-          "users",
-          "show",
-          UsersHandlerWithFilters.show,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-        [
-          "GET",
-          "/users/:id/edit",
-          "users",
-          "users",
-          "edit_form",
-          UsersHandlerWithFilters.edit_form,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-        [
-          "POST",
-          "/users",
-          "users",
-          "users",
-          "create_form",
-          UsersHandlerWithFilters.create,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-        [
-          "POST",
-          "/users/:id",
-          "users",
-          "users",
-          "edit_form",
-          UsersHandlerWithFilters.update,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-        [
-          "DELETE",
-          "/users/:id",
-          "users",
-          "users",
-          "destroy",
-          UsersHandlerWithFilters.destroy,
-          UsersHandlerWithFilters.before_filter,
-          UsersHandlerWithFilters.after_filter,
-        ],
-      ],
-      {}
-    );
-  });
 });

package/src/tests/routeMember.test.js

@@ -67,8 +67,6 @@ describe("routeMember", () => {
           "profile",
           "show",
           ProfileHandWithFiltersWithFilters.show,
-          ProfileHandWithFiltersWithFilters.before_filter,
-          ProfileHandWithFiltersWithFilters.after_filter,
         ],
         [
           "GET",
@@ -77,8 +75,6 @@ describe("routeMember", () => {
           "profile",
           "edit_form",
           ProfileHandWithFiltersWithFilters.edit_form,
-          ProfileHandWithFiltersWithFilters.before_filter,
-          ProfileHandWithFiltersWithFilters.after_filter,
         ],
         [
           "POST",
@@ -87,8 +83,6 @@ describe("routeMember", () => {
           "profile",
           "edit_form",
           ProfileHandWithFiltersWithFilters.update,
-          ProfileHandWithFiltersWithFilters.before_filter,
-          ProfileHandWithFiltersWithFilters.after_filter,
         ],
       ],
       {}