@raketa-cloud/admin 0.0.88 → 0.0.90

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

@@ -38,12 +38,14 @@ describe("Pages Translation Handler", () => {
       .mockImplementation(() => page);
 
     const translationErrors = [{ key: "title", message: "cannot be blank" }];
-    const mockTranslate = jest
-      .spyOn(ctx.client.pages, "translate")
-      .mockImplementation(() => ({
-        page: null,
-        errors: translationErrors,
-      }));
+    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")
@@ -52,7 +54,7 @@ describe("Pages Translation Handler", () => {
     const result = await TranslationsHandler.create(ctx);
 
     expect(mockFind).toHaveBeenCalledWith(page.id, "en");
-    expect(mockTranslate).toHaveBeenCalled();
+    expect(mockTranslateBatch).toHaveBeenCalled();
     expect(mockFormatErrors).toHaveBeenCalledWith(translationErrors);
 
     expect(result).toEqual({
@@ -91,35 +93,30 @@ describe("Pages Translation Handler", () => {
       .spyOn(ctx.client.pages, "find")
       .mockImplementation(() => page);
 
-    const mockTranslate = jest
-      .spyOn(ctx.client.pages, "translate")
-      .mockImplementation((parentId, locale) => ({
-        page: { id: `translated-page-${locale}` },
-        errors: null,
-      }));
-
-    const mockCreateRevision = jest
-      .spyOn(ctx.client.pageRevisions, "create")
-      .mockImplementation(() => ({ errors: null }));
+    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(mockTranslate).toHaveBeenCalledTimes(2);
-    expect(mockTranslate).toHaveBeenCalledWith(
+    expect(mockTranslateBatch).toHaveBeenCalledWith(
       page.id,
-      "fr",
-      expect.objectContaining({
-        title: page.title,
-        tags: [],
-        visibility: "private",
-        slug: page.slug,
-      })
-    );
-    expect(mockTranslate).toHaveBeenCalledWith(
-      page.id,
-      "es",
+      ["fr", "es"],
       expect.objectContaining({
         title: page.title,
         tags: [],
@@ -128,16 +125,17 @@ describe("Pages Translation Handler", () => {
       })
     );
 
-    expect(mockCreateRevision).toHaveBeenCalledTimes(2);
-    expect(mockCreateRevision).toHaveBeenCalledWith("translated-page-fr", "fr");
-    expect(mockCreateRevision).toHaveBeenCalledWith("translated-page-es", "es");
+    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 fails if any translation fails", async () => {
+  test("create translations if any translation fails", async () => {
     const page = Factory.build("page", {
       translations: {},
       categories: [{ id: "some-category-uno" }],
@@ -153,17 +151,22 @@ describe("Pages Translation Handler", () => {
       .spyOn(ctx.client.pages, "find")
       .mockImplementation(() => page);
 
-    const translationResponses = {
-      fr: { page: { id: "translated-page-fr" }, errors: null },
-      es: {
-        page: null,
-        errors: [{ key: "title", message: "invalid for spanish" }],
-      },
-    };
-
-    const mockTranslate = jest
-      .spyOn(ctx.client.pages, "translate")
-      .mockImplementation((parentId, locale) => translationResponses[locale]);
+    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")
@@ -178,21 +181,9 @@ describe("Pages Translation Handler", () => {
     const result = await TranslationsHandler.create(ctx);
 
     expect(mockFind).toHaveBeenCalledWith(page.id, "en");
-
-    expect(mockTranslate).toHaveBeenCalledWith(
+    expect(mockTranslateBatch).toHaveBeenCalledWith(
       page.id,
-      "fr",
-      expect.objectContaining({
-        title: page.title,
-        tags: [],
-        visibility: "private",
-        slug: page.slug,
-      })
-    );
-
-    expect(mockTranslate).toHaveBeenCalledWith(
-      page.id,
-      "es",
+      ["fr", "es"],
       expect.objectContaining({
         title: page.title,
         tags: [],
@@ -211,7 +202,13 @@ describe("Pages Translation Handler", () => {
           settings: page.settings,
           widgets: page.widgets,
           categories: ["some-category-uno"],
-          translations: {},
+          translations: {
+            fr: {
+              id: "translated-page-fr",
+              slug: page.slug,
+              visibility: page.visibility,
+            },
+          },
           languages: ["fr", "es"],
         },
         blueprint: page,
@@ -236,17 +233,23 @@ describe("Pages Translation Handler", () => {
       .spyOn(ctx.client.pages, "find")
       .mockImplementation(() => page);
 
-    const mockTranslate = jest
-      .spyOn(ctx.client.pages, "translate")
-      .mockImplementation(() => ({
-        page: { id: "translated-page-id" },
-        errors: null,
-      }));
+    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 mockCreateRevision = jest
-      .spyOn(ctx.client.pageRevisions, "create")
-      .mockImplementation(() => ({ errors: revisionErrors }));
+    const mockCreateRevisionBatch = jest
+      .spyOn(ctx.client.pageRevisions, "createBatch")
+      .mockImplementation(() => [{ errors: revisionErrors }]);
 
     const mockFormatErrors = jest
       .spyOn(ctx.client.pages, "formatErrors")
@@ -254,7 +257,9 @@ describe("Pages Translation Handler", () => {
 
     const result = await TranslationsHandler.create(ctx);
 
-    expect(mockCreateRevision).toHaveBeenCalledWith("translated-page-id", "fr");
+    expect(mockCreateRevisionBatch).toHaveBeenCalledWith([
+      { pageId: "translated-page-fr", locale: "fr" },
+    ]);
     expect(mockFormatErrors).toHaveBeenCalledWith(revisionErrors);
 
     expect(result).toEqual({
@@ -267,7 +272,13 @@ describe("Pages Translation Handler", () => {
           settings: page.settings,
           widgets: page.widgets,
           categories: ["cat1"],
-          translations: {},
+          translations: {
+            fr: {
+              id: "translated-page-fr",
+              slug: page.slug,
+              visibility: page.visibility,
+            },
+          },
           languages: ["fr"],
         },
         blueprint: page,

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

@@ -0,0 +1,169 @@
+import AuthHelper from "../../helpers/AuthHelper";
+
+describe("AuthHelper", () => {
+  describe("parseJWT", () => {
+    test("parses JWT token correctly", () => {
+      const payload = { user: "test", exp: 1735689600 };
+      const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(
+        "base64"
+      );
+      const mockToken = `header.${encodedPayload}.signature`;
+
+      const result = AuthHelper.parseJWT(mockToken);
+      expect(result).toEqual(payload);
+    });
+  });
+
+  describe("verifyJWT", () => {
+    test("returns true for valid non-expired token", () => {
+      const futureTime = Math.floor(Date.now() / 1000) + 3600;
+      const payload = { exp: futureTime };
+      const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(
+        "base64"
+      );
+      const mockToken = `header.${encodedPayload}.signature`;
+
+      const result = AuthHelper.verifyJWT(mockToken);
+      expect(result).toBe(true);
+    });
+
+    test("returns false for expired token", () => {
+      const pastTime = Math.floor(Date.now() / 1000) - 3600;
+      const payload = { exp: pastTime };
+      const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(
+        "base64"
+      );
+      const mockToken = `header.${encodedPayload}.signature`;
+
+      const result = AuthHelper.verifyJWT(mockToken);
+      expect(result).toBe(false);
+    });
+
+    test("returns false for token without exp", () => {
+      const payload = { user: "test" };
+      const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(
+        "base64"
+      );
+      const mockToken = `header.${encodedPayload}.signature`;
+
+      const result = AuthHelper.verifyJWT(mockToken);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("isAuthenticated", () => {
+    test("returns true for allowed paths", () => {
+      expect(AuthHelper.isAuthenticated({ path: "/login" })).toBe(true);
+      expect(
+        AuthHelper.isAuthenticated({ path: "/auth/google/callback" })
+      ).toBe(true);
+      expect(AuthHelper.isAuthenticated({ path: "/remote/verify" })).toBe(true);
+    });
+
+    test("returns true for valid token", () => {
+      const futureTime = Math.floor(Date.now() / 1000) + 3600;
+      const payload = { exp: futureTime };
+      const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(
+        "base64"
+      );
+      const mockToken = `header.${encodedPayload}.signature`;
+
+      expect(
+        AuthHelper.isAuthenticated({
+          path: "/protected",
+          token: mockToken,
+        })
+      ).toBe(true);
+    });
+
+    test("returns false for invalid token", () => {
+      const pastTime = Math.floor(Date.now() / 1000) - 3600;
+      const payload = { exp: pastTime };
+      const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(
+        "base64"
+      );
+      const mockToken = `header.${encodedPayload}.signature`;
+
+      expect(
+        AuthHelper.isAuthenticated({
+          path: "/protected",
+          token: mockToken,
+        })
+      ).toBe(false);
+    });
+
+    test("returns false for protected path without token", () => {
+      expect(
+        AuthHelper.isAuthenticated({
+          path: "/protected",
+        })
+      ).toBe(false);
+    });
+  });
+
+  describe("getGoogleURL", () => {
+    test("returns correct URL with valid params", () => {
+      const params = {
+        gateway_url: "https://gateway.example.com",
+        gateway_project: "project1",
+        gateway_user_pool: "pool1",
+        auth_callback_url: "https://app.example.com/callback",
+      };
+
+      const expectedURL =
+        "https://gateway.example.com/users/auth/project1/pool1/google?return_to=https://app.example.com/callback";
+
+      expect(AuthHelper.getGoogleURL(params)).toBe(expectedURL);
+    });
+
+    test("throws error when any of the required params is missing or blank - auth_callback_url", () => {
+      const params = {
+        gateway_url: "https://gateway.example.com",
+        gateway_project: "project1",
+        gateway_user_pool: "pool1",
+        auth_callback_url: "",
+      };
+
+      expect(() => {
+        AuthHelper.getGoogleURL(params);
+      }).toThrow("Invalid ENVs for authentication configuration");
+    });
+
+    test("throws error when any of the required params is missing or blank - gateway_user_pool", () => {
+      const params = {
+        gateway_url: "https://gateway.example.com",
+        gateway_project: "project1",
+        auth_callback_url: "https://app.example.com/callback",
+      };
+
+      expect(() => {
+        AuthHelper.getGoogleURL(params);
+      }).toThrow("Invalid ENVs for authentication configuration");
+    });
+
+    test("throws error when any of the required params is missing or blank - gateway_project", () => {
+      const params = {
+        gateway_url: "https://gateway.example.com",
+        gateway_project: "",
+        gateway_user_pool: "pool1",
+        auth_callback_url: "https://app.example.com/callback",
+      };
+
+      expect(() => {
+        AuthHelper.getGoogleURL(params);
+      }).toThrow("Invalid ENVs for authentication configuration");
+    });
+
+    test("throws error when any of the required params is missing or blank - gateway_url", () => {
+      const params = {
+        gateway_project: "project1",
+        gateway_user_pool: "pool1",
+        auth_callback_url: "https://app.example.com/callback",
+      };
+
+      expect(() => {
+        AuthHelper.getGoogleURL(params);
+      }).toThrow("Invalid ENVs for authentication configuration");
+    });
+  });
+});