@raketa-cloud/admin 1.8.4 → 1.8.7

package/src/tests/routeStandard.test.js

@@ -0,0 +1,70 @@
+import routeStandard from "../routeStandard";
+import routeCollection from "../routeCollection";
+import routeSettings from "../routeSettings";
+import routePagesModule from "../routePagesModule";
+import routeArticlesModule from "../routeArticlesModule";
+import routeEventsModule from "../routeEventsModule";
+
+import DashboardsHandler from "../handlers/DashboardsHandler";
+import RedirectsHandler from "../handlers/RedirectsHandler";
+import TagsHandler from "../handlers/TagsHandler";
+import TagsAPIHandler from "../handlers/TagsAPIHandler";
+
+jest.mock("../routeCollection", () => jest.fn());
+jest.mock("../routeSettings", () => jest.fn());
+jest.mock("../routePagesModule", () => jest.fn());
+jest.mock("../routeArticlesModule", () => jest.fn());
+jest.mock("../routeEventsModule", () => jest.fn());
+
+describe("routeStandard", () => {
+  beforeEach(() => {
+    routeCollection.mockClear();
+    routeSettings.mockClear();
+    routePagesModule.mockClear();
+    routeArticlesModule.mockClear();
+    routeEventsModule.mockClear();
+  });
+
+  test("registers dashboard mapping via adapter.routeCollection", () => {
+    const adapter = { routeCollection: jest.fn() };
+
+    routeStandard(adapter);
+
+    expect(adapter.routeCollection).toHaveBeenCalledWith(
+      [
+        [
+          "GET",
+          "",
+          "dashboard",
+          "dashboard",
+          "index",
+          DashboardsHandler.index,
+          undefined,
+          undefined,
+        ],
+      ],
+      {}
+    );
+  });
+
+  test("registers redirects, tags, api/tags via routeCollection helper", () => {
+    const adapter = { routeCollection: jest.fn() };
+
+    routeStandard(adapter);
+
+    expect(routeCollection).toHaveBeenCalledWith(adapter, "redirects", RedirectsHandler);
+    expect(routeCollection).toHaveBeenCalledWith(adapter, "tags", TagsHandler);
+    expect(routeCollection).toHaveBeenCalledWith(adapter, "api/tags", TagsAPIHandler);
+  });
+
+  test("delegates to module-specific route registrars", () => {
+    const adapter = { routeCollection: jest.fn() };
+
+    routeStandard(adapter);
+
+    expect(routeSettings).toHaveBeenCalledWith(adapter);
+    expect(routePagesModule).toHaveBeenCalledWith(adapter);
+    expect(routeArticlesModule).toHaveBeenCalledWith(adapter);
+    expect(routeEventsModule).toHaveBeenCalledWith(adapter);
+  });
+});

package/src/tests/setGlobalContext.test.js

@@ -0,0 +1,12 @@
+import setGlobalContext from "../setGlobalContext";
+
+describe("setGlobalContext", () => {
+  test("delegates to adapter.setGlobalContext", () => {
+    const adapter = { setGlobalContext: jest.fn() };
+    const fn = () => ({});
+
+    setGlobalContext(adapter, fn);
+
+    expect(adapter.setGlobalContext).toHaveBeenCalledWith(fn);
+  });
+});

package/src/tests/setupAuthentication.test.js

@@ -0,0 +1,407 @@
+import setupAuthentication from "../setupAuthentication";
+import AuthHelper from "../helpers/AuthHelper";
+import cipher from "../cipher";
+import ejs from "ejs";
+import * as honoCookie from "hono/cookie";
+
+jest.mock("../helpers/AuthHelper", () => ({
+  cookie_key: "raketa_token",
+  isAuthenticated: jest.fn(),
+  parseJWT: jest.fn(),
+  verifyJWT: jest.fn(),
+  getGoogleURL: jest.fn(),
+}));
+
+jest.mock("../cipher", () => ({
+  encrypt: jest.fn(),
+  decrypt: jest.fn(),
+}));
+
+jest.mock("ejs", () => ({
+  renderFile: jest.fn(),
+}));
+
+jest.mock("hono/cookie", () => ({
+  getCookie: jest.fn(),
+  setCookie: jest.fn(),
+  deleteCookie: jest.fn(),
+}));
+
+function makeApp() {
+  const handlers = {};
+  return {
+    use: jest.fn((fn) => {
+      handlers.use = fn;
+    }),
+    get: jest.fn((path, fn) => {
+      handlers[`GET ${path}`] = fn;
+    }),
+    post: jest.fn((path, fn) => {
+      handlers[`POST ${path}`] = fn;
+    }),
+    handlers,
+  };
+}
+
+function makeCtx(overrides = {}) {
+  return {
+    req: {
+      header: jest.fn().mockReturnValue(""),
+      path: "/en/pages",
+      url: "https://example.com/en/pages",
+      query: jest.fn().mockReturnValue({}),
+      json: jest.fn().mockResolvedValue({}),
+      ...overrides.req,
+    },
+    redirect: jest.fn().mockReturnValue("redirected"),
+    json: jest.fn().mockReturnValue("jsoned"),
+    html: jest.fn().mockReturnValue("htmled"),
+    set: jest.fn(),
+    ...overrides,
+  };
+}
+
+const config = {
+  cloud: {
+    gateway_url: "https://gw",
+    gateway_project: "proj",
+    gateway_user_pool: "pool",
+    auth_callback_url: "https://example.com/cb",
+  },
+  remoteConfig: {
+    remoteLogin: "https://remote/login",
+    remoteLogout: "https://remote/logout",
+  },
+};
+
+describe("setupAuthentication", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("registers use + get + post handlers", () => {
+    const app = makeApp();
+    setupAuthentication(app, config);
+
+    expect(app.use).toHaveBeenCalledTimes(1);
+    expect(app.get).toHaveBeenCalledWith("/login", expect.any(Function));
+    expect(app.get).toHaveBeenCalledWith(
+      "/auth/google/callback",
+      expect.any(Function)
+    );
+    expect(app.get).toHaveBeenCalledWith("/logout", expect.any(Function));
+    expect(app.get).toHaveBeenCalledWith("/profile", expect.any(Function));
+    expect(app.get).toHaveBeenCalledWith("/remote/login", expect.any(Function));
+    expect(app.post).toHaveBeenCalledWith("/remote/verify", expect.any(Function));
+  });
+
+  describe("use middleware", () => {
+    test("redirects to /login when not authenticated", async () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      honoCookie.getCookie.mockReturnValue(null);
+      AuthHelper.isAuthenticated.mockReturnValue(false);
+
+      const ctx = makeCtx();
+      const next = jest.fn();
+
+      const result = await app.handlers.use(ctx, next);
+
+      expect(ctx.redirect).toHaveBeenCalledWith("/login");
+      expect(result).toBe("redirected");
+      expect(next).not.toHaveBeenCalled();
+    });
+
+    test("sets authentication when token present", async () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      honoCookie.getCookie.mockReturnValue("cookie-token");
+      AuthHelper.isAuthenticated.mockReturnValue(true);
+      AuthHelper.parseJWT.mockReturnValue({ info: { user: "jane" } });
+
+      const ctx = makeCtx();
+      const next = jest.fn();
+
+      await app.handlers.use(ctx, next);
+
+      expect(ctx.set).toHaveBeenCalledWith("authentication", {
+        token: "cookie-token",
+        user: { user: "jane" },
+      });
+      expect(next).toHaveBeenCalled();
+    });
+
+    test("falls back to Authorization header bearer when no cookie", async () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      honoCookie.getCookie.mockReturnValue(null);
+      AuthHelper.isAuthenticated.mockReturnValue(true);
+      AuthHelper.parseJWT.mockReturnValue({ info: {} });
+
+      const ctx = makeCtx({
+        req: {
+          header: jest.fn().mockReturnValue("Bearer header-token"),
+          path: "/en/pages",
+          url: "x",
+          query: jest.fn(),
+          json: jest.fn(),
+        },
+      });
+      const next = jest.fn();
+
+      await app.handlers.use(ctx, next);
+
+      expect(ctx.set).toHaveBeenCalledWith(
+        "authentication",
+        expect.objectContaining({ token: "header-token" })
+      );
+    });
+  });
+
+  describe("/login", () => {
+    test("renders login template with googleURL and error", async () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.getGoogleURL.mockReturnValue("https://google");
+      ejs.renderFile.mockResolvedValue("<html>login</html>");
+
+      const ctx = makeCtx({
+        req: {
+          header: jest.fn(),
+          query: jest.fn().mockReturnValue("expired"),
+        },
+      });
+
+      const result = await app.handlers["GET /login"](ctx);
+
+      expect(ejs.renderFile).toHaveBeenCalledWith(
+        expect.stringContaining("/views/_auth/login.ejs"),
+        { googleURL: "https://google", error: "expired" }
+      );
+      expect(ctx.html).toHaveBeenCalledWith("<html>login</html>");
+      expect(result).toBe("htmled");
+    });
+  });
+
+  describe("/auth/google/callback", () => {
+    test("redirects to /login?err=expired when token invalid", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.parseJWT.mockReturnValue({ info: { active: true } });
+      AuthHelper.verifyJWT.mockReturnValue(false);
+
+      const ctx = makeCtx({
+        req: {
+          query: jest.fn().mockReturnValue("bad-token"),
+          url: "https://example.com",
+        },
+      });
+
+      const result = app.handlers["GET /auth/google/callback"](ctx);
+
+      expect(ctx.redirect).toHaveBeenCalledWith("/login?err=expired");
+      expect(result).toBe("redirected");
+    });
+
+    test("redirects to /login?err=not_activated when user inactive", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.parseJWT.mockReturnValue({ info: { active: false } });
+      AuthHelper.verifyJWT.mockReturnValue(true);
+
+      const ctx = makeCtx({
+        req: {
+          query: jest.fn().mockReturnValue("ok-token"),
+          url: "https://example.com",
+        },
+      });
+
+      app.handlers["GET /auth/google/callback"](ctx);
+
+      expect(ctx.redirect).toHaveBeenCalledWith("/login?err=not_activated");
+    });
+
+    test("sets cookie and redirects to /remote/login on success", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.parseJWT.mockReturnValue({ info: { active: true } });
+      AuthHelper.verifyJWT.mockReturnValue(true);
+
+      const ctx = makeCtx({
+        req: {
+          query: jest.fn().mockReturnValue("token"),
+          url: "http://localhost:3000/cb",
+        },
+      });
+
+      app.handlers["GET /auth/google/callback"](ctx);
+
+      expect(honoCookie.setCookie).toHaveBeenCalledWith(
+        ctx,
+        "raketa_token",
+        "token",
+        { path: "/", httpOnly: true, secure: false }
+      );
+      expect(ctx.redirect).toHaveBeenCalledWith("/remote/login");
+    });
+
+    test("sets secure cookie when not localhost", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.parseJWT.mockReturnValue({ info: { active: true } });
+      AuthHelper.verifyJWT.mockReturnValue(true);
+
+      const ctx = makeCtx({
+        req: {
+          query: jest.fn().mockReturnValue("token"),
+          url: "https://prod.example.com/cb",
+        },
+      });
+
+      app.handlers["GET /auth/google/callback"](ctx);
+
+      expect(honoCookie.setCookie).toHaveBeenCalledWith(
+        ctx,
+        "raketa_token",
+        "token",
+        { path: "/", httpOnly: true, secure: true }
+      );
+    });
+  });
+
+  describe("/logout", () => {
+    test("deletes cookie and redirects to remoteLogout", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      const ctx = makeCtx();
+
+      app.handlers["GET /logout"](ctx);
+
+      expect(honoCookie.deleteCookie).toHaveBeenCalledWith(ctx, "raketa_token");
+      expect(ctx.redirect).toHaveBeenCalledWith("https://remote/logout");
+    });
+  });
+
+  describe("/profile", () => {
+    test("returns OK json when JWT valid", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.verifyJWT.mockReturnValue(true);
+
+      const ctx = makeCtx({
+        req: {
+          header: jest.fn().mockReturnValue("Bearer profile-token"),
+        },
+      });
+
+      app.handlers["GET /profile"](ctx);
+
+      expect(ctx.json).toHaveBeenCalledWith({ message: "OK" });
+    });
+
+    test("returns 401 Response when JWT invalid", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      AuthHelper.verifyJWT.mockReturnValue(false);
+
+      const ctx = makeCtx({
+        req: {
+          header: jest.fn().mockReturnValue("Bearer bad"),
+        },
+      });
+
+      const result = app.handlers["GET /profile"](ctx);
+
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(401);
+    });
+  });
+
+  describe("/remote/login", () => {
+    test("redirects to /login when JWT invalid", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      honoCookie.getCookie.mockReturnValue("bad");
+      AuthHelper.verifyJWT.mockReturnValue(false);
+
+      const ctx = makeCtx();
+
+      app.handlers["GET /remote/login"](ctx);
+
+      expect(ctx.redirect).toHaveBeenCalledWith("/login");
+    });
+
+    test("redirects to remoteLogin URL with snapshot when valid", () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      honoCookie.getCookie.mockReturnValue("good");
+      AuthHelper.verifyJWT.mockReturnValue(true);
+      cipher.encrypt.mockReturnValue("encrypted");
+
+      const ctx = makeCtx({
+        req: {
+          query: jest.fn().mockReturnValue({ redirect_to: "/somewhere" }),
+        },
+      });
+
+      app.handlers["GET /remote/login"](ctx);
+
+      const target = ctx.redirect.mock.calls[0][0];
+      expect(target).toContain("https://remote/login");
+      expect(target).toContain("redirect_to=/somewhere");
+      expect(target).toContain("&snapshot=");
+    });
+  });
+
+  describe("/remote/verify", () => {
+    test("returns token json when extract succeeds", async () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      const futureTs = Date.now() + 60000;
+      cipher.decrypt.mockReturnValue(`extracted-token,${futureTs}`);
+
+      const ctx = makeCtx({
+        req: {
+          json: jest.fn().mockResolvedValue({ credentials: "creds" }),
+        },
+      });
+
+      await app.handlers["POST /remote/verify"](ctx);
+
+      expect(ctx.json).toHaveBeenCalledWith({ token: "extracted-token" });
+    });
+
+    test("returns 401 when token expired", async () => {
+      const app = makeApp();
+      setupAuthentication(app, config);
+
+      const pastTs = Date.now() - 60000;
+      cipher.decrypt.mockReturnValue(`extracted-token,${pastTs}`);
+
+      const ctx = makeCtx({
+        req: {
+          json: jest.fn().mockResolvedValue({ credentials: "creds" }),
+        },
+      });
+
+      const result = await app.handlers["POST /remote/verify"](ctx);
+
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(401);
+    });
+  });
+});

package/src/tests/setupCloud.test.js

@@ -0,0 +1,51 @@
+import setupCloud from "../setupCloud";
+import Categories from "../cloud/Categories";
+import Redirects from "../cloud/Redirects";
+import ResourceChanges from "../cloud/ResourceChanges";
+import ResourceRevisions from "../cloud/ResourceRevisions";
+import Resources from "../cloud/Resources";
+import Settings from "../cloud/Settings";
+import Tags from "../cloud/Tags";
+
+describe("setupCloud", () => {
+  test("returns early when no authentication token", () => {
+    const ctx = {};
+
+    setupCloud(ctx, () => ({}));
+
+    expect(ctx.client).toBeUndefined();
+  });
+
+  test("returns early when authentication is empty", () => {
+    const ctx = { authentication: null };
+
+    setupCloud(ctx, () => ({}));
+
+    expect(ctx.client).toBeUndefined();
+  });
+
+  test("attaches cloud clients to ctx when token is present", () => {
+    const getConfig = () => ({});
+    const ctx = { authentication: { token: "jwt" } };
+
+    setupCloud(ctx, getConfig);
+
+    expect(ctx.client.redirects).toBeInstanceOf(Redirects);
+    expect(ctx.client.settings).toBeInstanceOf(Settings);
+    expect(ctx.client.tags).toBeInstanceOf(Tags);
+    expect(ctx.client.resources).toBeInstanceOf(Resources);
+    expect(ctx.client.resourceRevisions).toBeInstanceOf(ResourceRevisions);
+    expect(ctx.client.resourceChanges).toBeInstanceOf(ResourceChanges);
+    expect(ctx.client.categories).toBeInstanceOf(Categories);
+  });
+
+  test("clients receive token and config from ctx", () => {
+    const getConfig = () => ({ cloud: "yes" });
+    const ctx = { authentication: { token: "jwt-token" } };
+
+    setupCloud(ctx, getConfig);
+
+    expect(ctx.client.tags.token).toBe("jwt-token");
+    expect(ctx.client.tags.getConfig).toBe(getConfig);
+  });
+});

package/src/tests/support/factory.js

@@ -28,12 +28,13 @@ const REVISION_SCHEDULE = {
   },
 };
 
-const PAGE = {
+const RESOURCE = {
   id: "2",
-  slug: "page-revision",
-  title: "Page Revision",
+  slug: "resource-slug",
+  title: "Resource Title",
   widgets: [],
   settings: {
+    layout: "default",
     meta: {
       title: "Open graph",
       description: "Open graph???",
@@ -44,90 +45,20 @@ const PAGE = {
   originalId: null,
   insertedAt: "2024-08-30T19:05:00Z",
   tags: [],
-  pageType: { slug: "page" },
   categories: [],
+  translations: {},
 };
 
-const ARTICLE = {
-  id: "2",
-  slug: "article-revision",
-  publishAt: "2024-08-30T19:05:00Z",
-  title: "Article Revision",
-  widgets: [],
-  settings: {
-    meta: {
-      title: "Open graph",
-      description: "Open graph???",
-      image: {},
-    },
-  },
-  visibility: "public",
-  originalId: null,
-  insertedAt: "2024-08-30T19:05:00Z",
-  tags: [],
-  articleType: { slug: "article" },
-  categories: [],
-};
-
-const EVENT = {
-  id: "2",
-  slug: "event-revision",
-  publishAt: "2024-08-30T19:05:00Z",
-  startsAt: "2024-08-30T19:10:00Z",
-  endshAt: "2024-08-30T19:15:00Z",
-  title: "Event Revision",
-  widgets: [],
-  settings: {
-    meta: {
-      title: "Open graph",
-      description: "Open graph???",
-      image: {},
-    },
-  },
-  visibility: "public",
-  originalId: null,
-  insertedAt: "2024-08-30T19:05:00Z",
-  tags: [],
-  eventType: { slug: "event" },
-  categories: [],
-};
-
-const PAGE_CHANGE = {
-  version: "1",
-  title: "A cool page change",
-  operator: "some-operator-id",
-  operatorMeta: {
-    id: "some-operator-id",
-    email: "john@example.com",
-    name: "John DOe",
-  },
-  description: "A cool page change description",
-  insertedAt: "2024-08-30T19:05:00Z",
-};
-
-const ARTICLE_CHANGE = {
+const RESOURCE_CHANGE = {
   version: "1",
-  title: "A cool article change",
+  title: "A cool resource change",
   operator: "some-operator-id",
   operatorMeta: {
     id: "some-operator-id",
     email: "john@example.com",
     name: "John DOe",
   },
-  description: "A cool article change description",
-  insertedAt: "2024-08-30T19:05:00Z",
-};
-
-const EVENT_CHANGE = {
-  version: "1",
-  title: "A cool article change",
-  operator: "some-operator-id",
-  operatorMeta: {
-    id: "some-operator-id",
-    email: "john@example.com",
-    name: "John DOe",
-  },
-  description: "A cool article change description",
+  description: "A cool resource change description",
   insertedAt: "2024-08-30T19:05:00Z",
 };
 
@@ -156,15 +87,13 @@ const FIXTURES = {
   },
   revision_meta: { ...REVISION_META },
   revision_schedule: { ...REVISION_SCHEDULE },
-  page: { ...PAGE },
-  page_revision: { ...PAGE, meta: { ...REVISION_META }, originalId: "1" },
-  page_change: { ...PAGE_CHANGE },
-  article: { ...ARTICLE },
-  article_revision: { ...ARTICLE, meta: { ...REVISION_META }, originalId: "1" },
-  article_change: { ...ARTICLE_CHANGE },
-  event: { ...EVENT },
-  event_revision: { ...EVENT, meta: { ...REVISION_META }, originalId: "1" },
-  event_change: { ...EVENT_CHANGE },
+  resource: { ...RESOURCE },
+  resource_revision: {
+    ...RESOURCE,
+    meta: { ...REVISION_META },
+    originalId: "1",
+  },
+  resource_change: { ...RESOURCE_CHANGE },
   settings: { value: {} },
   tag: Tag,
   category: { ...CATEGORY },