@raketa-cloud/admin 1.8.18 → 1.8.19

package/src/tests/helpers/reports/reportsUtils.test.js

@@ -0,0 +1,425 @@
+import {
+  reportsAvailability,
+  resourceReports,
+} from "../../../helpers/reports/reportsUtils";
+
+import {
+  cruxApiKeyConfigured,
+  pageWebVitals,
+} from "../../../helpers/reports/cwv";
+import { serviceAccountConfigured } from "../../../helpers/reports/googleAuth";
+import { pageInsights } from "../../../helpers/reports/quick-insights";
+
+jest.mock("../../../helpers/reports/cwv", () => ({
+  cruxApiKeyConfigured: jest.fn(),
+  pageWebVitals: jest.fn(),
+}));
+
+jest.mock("../../../helpers/reports/googleAuth", () => ({
+  serviceAccountConfigured: jest.fn(),
+}));
+
+jest.mock("../../../helpers/reports/quick-insights", () => ({
+  pageInsights: jest.fn(),
+}));
+
+const RESOURCE = { id: "42", slug: "some-page" };
+
+function buildCtx({ ga = {}, reports = true, changes = { list: [] } } = {}) {
+  return {
+    locale: "en",
+    // Publish markers are read off the resource's own change log.
+    client: {
+      resourceChanges: {
+        list: jest.fn(() =>
+          changes instanceof Error
+            ? Promise.reject(changes)
+            : Promise.resolve(changes),
+        ),
+      },
+    },
+    resourceConfig: {
+      resourceType: "page",
+      resourceTypePlural: "pages",
+      reports,
+    },
+    globalConfig: { ga },
+    remoteConfig: {
+      resourcePath: jest.fn((resource) => `/${resource.slug}`),
+      resourceUrl: jest.fn(
+        (resource) => `https://www.example.com/${resource.slug}`,
+      ),
+    },
+  };
+}
+
+// GA needs a property plus a service account, CrUX needs an API key.
+function enableGa() {
+  serviceAccountConfigured.mockReturnValue(true);
+}
+
+function enableCwv() {
+  cruxApiKeyConfigured.mockReturnValue(true);
+}
+
+const INSIGHTS = {
+  summary: { views: { value: 10 } },
+  dateRange: { startDate: "2026-07-01", endDate: "2026-07-28" },
+  rows: [
+    { date: "2026-07-01", views: 4 },
+    { date: "2026-07-02", views: 6 },
+  ],
+};
+
+const WEB_VITALS = { assessment: "good", metrics: [] };
+
+describe("reportsUtils", () => {
+  beforeEach(() => {
+    serviceAccountConfigured.mockReturnValue(false);
+    cruxApiKeyConfigured.mockReturnValue(false);
+    pageInsights.mockResolvedValue(INSIGHTS);
+    pageWebVitals.mockResolvedValue(WEB_VITALS);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("reportsAvailability", () => {
+    test("reports each side independently", () => {
+      enableCwv();
+
+      expect(reportsAvailability(buildCtx())).toEqual({
+        insights: false,
+        webVitals: true,
+      });
+    });
+
+    test("reports both when everything is configured", () => {
+      enableGa();
+      enableCwv();
+
+      expect(
+        reportsAvailability(buildCtx({ ga: { propertyId: "123" } })),
+      ).toEqual({ insights: true, webVitals: true });
+      expect(serviceAccountConfigured).toHaveBeenCalledWith({
+        propertyId: "123",
+      });
+    });
+
+    test("skips insights when the property id is missing", () => {
+      enableGa();
+
+      expect(reportsAvailability(buildCtx()).insights).toBe(false);
+    });
+
+    test("skips insights when the service account is missing", () => {
+      expect(
+        reportsAvailability(buildCtx({ ga: { propertyId: "123" } })).insights,
+      ).toBe(false);
+    });
+
+    test("hides both sides when the resource has reports switched off", () => {
+      enableGa();
+      enableCwv();
+      const ctx = buildCtx({ ga: { propertyId: "123" }, reports: false });
+
+      expect(reportsAvailability(ctx)).toEqual({
+        insights: false,
+        webVitals: false,
+      });
+    });
+  });
+
+  describe("resourceReports", () => {
+    test("returns null for a side that is not configured", async () => {
+      expect(await resourceReports(buildCtx(), RESOURCE, "page")).toEqual({
+        insights: null,
+        webVitals: null,
+      });
+
+      expect(pageInsights).not.toHaveBeenCalled();
+      expect(pageWebVitals).not.toHaveBeenCalled();
+    });
+
+    test("fetches insights with the resource path and builds the chart series", async () => {
+      enableGa();
+      const ctx = buildCtx({ ga: { propertyId: "123" } });
+
+      const { insights } = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(pageInsights).toHaveBeenCalledWith(
+        "/some-page",
+        { propertyId: "123" },
+        { cacheKey: "page:42" },
+      );
+      expect(ctx.remoteConfig.resourcePath).toHaveBeenCalledWith(
+        RESOURCE,
+        "page",
+        "en",
+      );
+      expect(insights).toEqual({
+        pagePath: "/some-page",
+        summary: INSIGHTS.summary,
+        dateRange: INSIGHTS.dateRange,
+        series: {
+          dates: ["2026-07-01", "2026-07-02"],
+          labels: ["July 1", "July 2"],
+          data: [4, 6],
+        },
+        publishDates: [],
+        error: null,
+      });
+    });
+
+    test("marks the days a revision was published", async () => {
+      enableGa();
+      const ctx = buildCtx({
+        ga: { propertyId: "123" },
+        changes: {
+          list: [
+            {
+              changeType: "revision_publish",
+              insertedAt: "2026-07-02T09:12:33Z",
+            },
+            // Same day twice, and a publish outside the plotted window.
+            {
+              changeType: "revision_publish",
+              insertedAt: "2026-07-02T18:40:00Z",
+            },
+            {
+              changeType: "revision_publish",
+              insertedAt: "2026-06-11T08:00:00Z",
+            },
+          ],
+        },
+      });
+
+      const { insights } = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(ctx.client.resourceChanges.list).toHaveBeenCalledWith(
+        { "f:change_type": ["revision_publish"] },
+        "42",
+        "en",
+        "page",
+      );
+      expect(insights.publishDates).toEqual(["2026-07-02"]);
+    });
+
+    test("reads the day off a timestamp that carries no zone", async () => {
+      enableGa();
+      const ctx = buildCtx({
+        ga: { propertyId: "123" },
+        changes: { list: [{ insertedAt: "2026-07-01T23:45:00" }] },
+      });
+
+      const { insights } = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(insights.publishDates).toEqual(["2026-07-01"]);
+    });
+
+    test("drops changes with an unusable timestamp", async () => {
+      enableGa();
+      const ctx = buildCtx({
+        ga: { propertyId: "123" },
+        changes: { list: [{ insertedAt: "whenever" }, { insertedAt: null }] },
+      });
+
+      const { insights } = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(insights.publishDates).toEqual([]);
+    });
+
+    test("still reports when the change log fails", async () => {
+      enableGa();
+      const ctx = buildCtx({
+        ga: { propertyId: "123" },
+        changes: new Error("history unavailable"),
+      });
+
+      const { insights } = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(insights.error).toBeNull();
+      expect(insights.publishDates).toEqual([]);
+    });
+
+    test("asks GA about the site root for the homepage", async () => {
+      enableGa();
+      const ctx = buildCtx({ ga: { propertyId: "123" } });
+
+      await resourceReports(ctx, { id: "1", slug: "homepage" }, "page");
+
+      expect(pageInsights).toHaveBeenCalledWith(
+        "/",
+        expect.anything(),
+        expect.anything(),
+      );
+      expect(ctx.remoteConfig.resourcePath).not.toHaveBeenCalled();
+    });
+
+    test("honours a project specific homepage slug", async () => {
+      enableGa();
+      const ctx = buildCtx({
+        ga: { propertyId: "123", homepageSlug: "start" },
+      });
+
+      await resourceReports(ctx, { id: "1", slug: "start" }, "page");
+
+      expect(pageInsights).toHaveBeenCalledWith(
+        "/",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+
+    test("copes with an insights payload that has no rows", async () => {
+      enableGa();
+      pageInsights.mockResolvedValue({ summary: {}, dateRange: {} });
+
+      const { insights } = await resourceReports(
+        buildCtx({ ga: { propertyId: "123" } }),
+        RESOURCE,
+        "page",
+      );
+
+      expect(insights.series).toEqual({ dates: [], labels: [], data: [] });
+    });
+
+    test("returns an error when GA has no data", async () => {
+      enableGa();
+      pageInsights.mockResolvedValue(null);
+
+      const { insights } = await resourceReports(
+        buildCtx({ ga: { propertyId: "123" } }),
+        RESOURCE,
+        "page",
+      );
+
+      expect(insights).toEqual({
+        error: "No analytics data (check GA config / server logs)",
+      });
+    });
+
+    test("returns the error message when GA throws", async () => {
+      enableGa();
+      pageInsights.mockRejectedValue(new Error("GA exploded"));
+
+      const { insights } = await resourceReports(
+        buildCtx({ ga: { propertyId: "123" } }),
+        RESOURCE,
+        "page",
+      );
+
+      expect(insights).toEqual({ error: "GA exploded" });
+    });
+
+    test("stringifies a non-error GA rejection", async () => {
+      enableGa();
+      pageInsights.mockRejectedValue("plain string");
+
+      const { insights } = await resourceReports(
+        buildCtx({ ga: { propertyId: "123" } }),
+        RESOURCE,
+        "page",
+      );
+
+      expect(insights).toEqual({ error: "plain string" });
+    });
+
+    test("builds the CrUX url from the configured public url", async () => {
+      enableCwv();
+      const ctx = buildCtx({ ga: { publicUrl: "https://www.example.com" } });
+
+      const { webVitals } = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(pageWebVitals).toHaveBeenCalledWith(
+        "https://www.example.com/some-page",
+        ctx.globalConfig.ga,
+        { cacheKey: "page:42" },
+      );
+      expect(webVitals).toEqual({
+        pageUrl: "https://www.example.com/some-page",
+        ...WEB_VITALS,
+        error: null,
+      });
+    });
+
+    test("asks CrUX about the origin root for the homepage", async () => {
+      enableCwv();
+      const ctx = buildCtx({ ga: { publicUrl: "https://www.example.com" } });
+
+      await resourceReports(ctx, { id: "1", slug: "homepage" }, "page");
+
+      expect(pageWebVitals).toHaveBeenCalledWith(
+        "https://www.example.com/",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+
+    test("falls back to the resource url without a public url", async () => {
+      enableCwv();
+      const ctx = buildCtx();
+
+      await resourceReports(ctx, RESOURCE, "page");
+
+      expect(ctx.remoteConfig.resourceUrl).toHaveBeenCalledWith(
+        RESOURCE,
+        "page",
+        "en",
+      );
+      expect(pageWebVitals).toHaveBeenCalledWith(
+        "https://www.example.com/some-page",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+
+    test("collapses the homepage resource url down to the origin", async () => {
+      enableCwv();
+      const ctx = buildCtx();
+      ctx.remoteConfig.resourceUrl.mockReturnValue(
+        "https://www.example.com/homepage?preview=1#top",
+      );
+
+      await resourceReports(ctx, { id: "1", slug: "homepage" }, "page");
+
+      expect(pageWebVitals).toHaveBeenCalledWith(
+        "https://www.example.com/",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+
+    test("returns an error when CrUX has no data", async () => {
+      enableCwv();
+      pageWebVitals.mockResolvedValue(null);
+
+      const { webVitals } = await resourceReports(buildCtx(), RESOURCE, "page");
+
+      expect(webVitals).toEqual({
+        error: "No Core Web Vitals data (check server logs)",
+      });
+    });
+
+    test("returns the error message when CrUX throws", async () => {
+      enableCwv();
+      pageWebVitals.mockRejectedValue(new Error("CrUX exploded"));
+
+      const { webVitals } = await resourceReports(buildCtx(), RESOURCE, "page");
+
+      expect(webVitals).toEqual({ error: "CrUX exploded" });
+    });
+
+    test("fetches both sides together when both are configured", async () => {
+      enableGa();
+      enableCwv();
+      const ctx = buildCtx({ ga: { propertyId: "123" } });
+
+      const result = await resourceReports(ctx, RESOURCE, "page");
+
+      expect(result.insights.error).toBeNull();
+      expect(result.webVitals.error).toBeNull();
+    });
+  });
+});

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

@@ -24,6 +24,43 @@ describe("includedInCollection", () => {
   it("returns false when the given collection undefined", () => {
     expect(utils.includedInCollection("key", undefined)).toEqual(false);
   });
+
+  it("throws when the given collection is neither a string nor an array", () => {
+    expect(() => utils.includedInCollection("key", { key: true })).toThrow(
+      "Invalid input for collection. Expected a string or an array.",
+    );
+  });
+});
+
+describe("formattedDateTime", () => {
+  it("formats an ISO timestamp as a short date and time", () => {
+    expect(utils.formattedDateTime("2026-08-30T19:05:00Z")).toEqual(
+      new Date("2026-08-30T19:05:00Z").toLocaleString("en-GB", {
+        dateStyle: "short",
+        timeStyle: "short",
+      }),
+    );
+  });
+
+  it("returns an invalid marker for an unparsable value", () => {
+    expect(utils.formattedDateTime("not a date")).toEqual("Invalid Date");
+  });
+});
+
+describe("formattedDate", () => {
+  it("formats an ISO timestamp as a short date", () => {
+    expect(utils.formattedDate("2026-08-30T19:05:00Z")).toEqual(
+      new Date("2026-08-30T19:05:00Z").toLocaleString("en-GB", {
+        dateStyle: "short",
+      }),
+    );
+  });
+
+  it("returns an empty string for a missing value", () => {
+    expect(utils.formattedDate(null)).toEqual("");
+    expect(utils.formattedDate(undefined)).toEqual("");
+    expect(utils.formattedDate("")).toEqual("");
+  });
 });
 
 describe("feature", () => {

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

@@ -0,0 +1,87 @@
+import form_for from "../../helpers/form_for";
+import pagination_helper from "../../helpers/pagination_helper";
+import sort_button from "../../helpers/sort_button";
+
+// The thin wrappers handed to the EJS views — each builds its helper and
+// returns rendered markup.
+describe("form_for", () => {
+  test("yields a form builder bound to the object", () => {
+    const helper = form_for();
+
+    const result = helper({ resource: { title: "Hello" } }, {}, (form) =>
+      form.field("resource.title"),
+    );
+
+    expect(result).toContain('name="resource[title]"');
+    expect(result).toContain('value="Hello"');
+    expect(result).toContain("Title");
+  });
+
+  test("passes the errors through to the builder", () => {
+    const helper = form_for();
+
+    const result = helper(
+      { resource: { title: "" } },
+      { resource: { title: "Can't be blank" } },
+      (form) => form.field("resource.title"),
+    );
+
+    expect(result).toContain("has-error");
+    expect(result).toContain("Can't be blank");
+  });
+
+  test("hands the view helpers config to the builder", () => {
+    const config = { imagePickerUrl: "/en/images" };
+    const helper = form_for(config);
+
+    const result = helper({}, {}, (form) => form.config);
+
+    expect(result).toEqual(config);
+  });
+
+  test("defaults every argument", () => {
+    expect(form_for()()).toBeUndefined();
+  });
+});
+
+describe("pagination_helper", () => {
+  const router = { path: "/en/pages", query: { q: "news" } };
+
+  test("renders the pagination element", () => {
+    const result = pagination_helper({ currentPage: 2, pagesCount: 5 }, router);
+
+    expect(result).toContain('class="pagination"');
+    expect(result).toContain("of  5");
+    expect(result).toContain("q=news&page=1");
+    expect(result).toContain("q=news&page=3");
+  });
+
+  test("renders nothing for a single page", () => {
+    expect(
+      pagination_helper({ currentPage: 1, pagesCount: 1 }, router),
+    ).toEqual("");
+  });
+});
+
+describe("sort_button", () => {
+  test("renders an unsorted button", () => {
+    const result = sort_button("Title", "title", {
+      path: "/en/pages",
+      query: {},
+    });
+
+    expect(result).toContain("Title");
+    expect(result).toContain("order_direction=ASC&order_by=title");
+    expect(result).toContain('class="btn-sort"');
+  });
+
+  test("flips the direction of the sorted column", () => {
+    const result = sort_button("Title", "title", {
+      path: "/en/pages",
+      query: { order_by: "title", order_direction: "ASC" },
+    });
+
+    expect(result).toContain("order_direction=DESC");
+    expect(result).toContain("btn-sort is-active");
+  });
+});

package/src/tests/index.test.js

@@ -0,0 +1,74 @@
+import * as adminPackage from "../index";
+
+// The barrel is the package's public surface — a missing or renamed file here
+// breaks consumers at import time rather than at first use.
+describe("@raketa-cloud/admin entry point", () => {
+  const EXPECTED_EXPORTS = [
+    "HonoAdapter",
+    "routeCollection",
+    "routeNestedCollection",
+    "routeMember",
+    "routeNestedMember",
+    "setGlobalContext",
+    "routeResourceModule",
+    "routeSettings",
+    "setupCloud",
+    "routeStandard",
+    "routeCategoriesModule",
+    "buildResourcePath",
+    "setBeforeFilter",
+    "setAfterFilter",
+    "RaketaClient",
+    "Redirects",
+    "Tags",
+    "Settings",
+    "ResourceChanges",
+    "ResourceRevisions",
+    "Resources",
+    "Categories",
+    "localCache",
+    "pageInsights",
+    "runPageReport",
+    "runSummary",
+    "pageWebVitals",
+    "ContentTasksHandler",
+    "RedirectsHandler",
+    "TagsHandler",
+    "SettingsHandler",
+    "ResourcesHandler",
+    "ResourcesAPIHandler",
+    "ResourceChangeHandler",
+    "ResourceClonesHandler",
+    "ResourceDeletesHandler",
+    "ResourceExportsHandler",
+    "ResourceHistoryHandler",
+    "ResourceTranslationsHandler",
+    "ResourceURLsHandler",
+    "ResourceRevisionsHandler",
+    "ResourceRevisionsGeneralHandler",
+    "ResourceRevisionsVisualHandler",
+    "ResourceRevisionsCodeHandler",
+    "ResourceRevisionsMetaHandler",
+    "ResourceRevisionsTagHandler",
+    "ResourceRevisionsLocksHandler",
+    "ResourceRevisionsUnlocksHandler",
+    "ResourceRevisionsPublishesHandler",
+    "ResourceRevisionsRevertsHandler",
+    "ResourceRevisionsWidgetHandler",
+    "getResourceUpdateDestination",
+    "Factory",
+    "Logger",
+  ];
+
+  test.each(EXPECTED_EXPORTS)("exports %s", (name) => {
+    expect(adminPackage[name]).toBeDefined();
+  });
+
+  test("exports nothing undefined", () => {
+    const undefinedExports = Object.keys(adminPackage).filter(
+      (name) => adminPackage[name] === undefined,
+    );
+
+    expect(undefinedExports).toEqual([]);
+  });
+});