@raketa-cloud/admin 1.8.17 → 1.8.19

package/src/tests/handlers/categories/update_defaults.test.js

@@ -0,0 +1,35 @@
+import CategoriesHandler from "../../../handlers/categories";
+import Categories from "../../../cloud/Categories";
+
+function buildCtx(id, resource) {
+  return {
+    client: { categories: new Categories(() => ({}), "token") },
+    params: { id },
+    resourceParams: { resource },
+    locale: "en",
+    resourceConfig: {
+      categoryType: "cat",
+      categoryTypePlural: "cats",
+    },
+  };
+}
+
+describe("Categories update defaults", () => {
+  test("update sends empty settings when the form carries none", async () => {
+    const ctx = buildCtx("42", { name: "Movie", slug: "movie" });
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.categories, "update")
+      .mockImplementation(() => ({ errors: null }));
+
+    const result = await CategoriesHandler.update(ctx);
+
+    expect(mockUpdate).toHaveBeenCalledWith(
+      "42",
+      { name: "Movie", slug: "movie", settings: {} },
+      "en",
+      "cat",
+    );
+    expect(result).toEqual({ redirect: "/en/cats" });
+  });
+});

package/src/tests/handlers/content_tasks/ContentTasksHandler.test/editors.test.js

@@ -0,0 +1,29 @@
+import ContentTasks from "../../../../cloud/ContentTasks";
+import ContentTasksHandler from "../../../../handlers/content_tasks/ContentTasksHandler";
+
+function buildCtx() {
+  return {
+    client: { contentTasks: new ContentTasks(() => ({}), "token") },
+    query: { "f:locale": "en" },
+    locale: "en",
+  };
+}
+
+describe("ContentTasksHandler editors", () => {
+  test("index falls back to an empty editor list", async () => {
+    const ctx = buildCtx();
+
+    const mockList = jest
+      .spyOn(ctx.client.contentTasks, "list")
+      .mockImplementation(() => ({ list: [], pagination: {} }));
+    const mockEditors = jest
+      .spyOn(ctx.client.contentTasks, "editors")
+      .mockImplementation(() => ({}));
+
+    const result = await ContentTasksHandler.index(ctx);
+
+    expect(mockList).toHaveBeenCalledWith(ctx.query);
+    expect(mockEditors).toHaveBeenCalled();
+    expect(result.assigns.editors).toEqual([]);
+  });
+});

package/src/tests/handlers/resource_revisions/PublishesHandler.test/schedule.test.js

@@ -0,0 +1,137 @@
+import PublishesHandler from "../../../../handlers/resource_revisions/PublishesHandler";
+import ResourceRevisions from "../../../../cloud/ResourceRevisions";
+import Resources from "../../../../cloud/Resources";
+
+import Factory from "../../../support/factory";
+
+function buildCtx(revision, resourceParams) {
+  return {
+    client: {
+      resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+      resources: new Resources(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    resourceParams,
+    locale: "en",
+    resourceConfig: {
+      resourceType: "article",
+      resourceTypePlural: "articles",
+    },
+  };
+}
+
+// "Publish later" schedules the merge instead of publishing straight away.
+describe("Schedule a resource revision", () => {
+  test("create schedules the revision for the given date", async () => {
+    const revision = Factory.build("resource_revision");
+    const publishing = {
+      title: "Campaign launch",
+      description: "Goes live with the campaign",
+      visibility: "public",
+      type: "later",
+      mergeAt: "2026-09-01T10:30",
+    };
+
+    const ctx = buildCtx(revision, { publishing });
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    const mockSchedule = jest
+      .spyOn(ctx.client.resourceRevisions, "schedule")
+      .mockImplementation(() => ({ errors: null }));
+    const mockPublish = jest.spyOn(ctx.client.resourceRevisions, "publish");
+
+    const result = await PublishesHandler.create(ctx);
+
+    expect(mockPublish).not.toHaveBeenCalled();
+    expect(mockSchedule).toHaveBeenCalledWith(
+      revision.id,
+      "en",
+      {
+        title: publishing.title,
+        description: publishing.description,
+        mergeAt: expect.stringContaining("2026-09-01"),
+      },
+      { visibility: "public" },
+      "article",
+    );
+    expect(result).toEqual({
+      redirect: `/en/articles/${revision.originalId}`,
+    });
+  });
+
+  test("create schedules a protected revision with its credentials", async () => {
+    const revision = Factory.build("resource_revision");
+    const publishing = {
+      visibility: "protected",
+      username: "admin",
+      password: "admin123!@#",
+      type: "later",
+      mergeAt: "2026-09-01T10:30",
+    };
+
+    const ctx = buildCtx(revision, { publishing });
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    const mockSchedule = jest
+      .spyOn(ctx.client.resourceRevisions, "schedule")
+      .mockImplementation(() => ({ errors: null }));
+
+    await PublishesHandler.create(ctx);
+
+    const [, , scheduleParams, resourceParams] = mockSchedule.mock.calls[0];
+
+    // Title and description are optional on the form.
+    expect(scheduleParams.title).toEqual("");
+    expect(scheduleParams.description).toEqual("");
+    expect(JSON.parse(resourceParams.settings).credentials).toEqual({
+      user: "admin",
+      password: "admin123!@#",
+    });
+  });
+
+  test("create publishes now when the date is missing", async () => {
+    const revision = Factory.build("resource_revision");
+    const ctx = buildCtx(revision, {
+      publishing: { type: "later", visibility: "public" },
+    });
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    const mockSchedule = jest.spyOn(ctx.client.resourceRevisions, "schedule");
+    const mockPublish = jest
+      .spyOn(ctx.client.resourceRevisions, "publish")
+      .mockImplementation(() => ({ errors: null }));
+
+    await PublishesHandler.create(ctx);
+
+    expect(mockSchedule).not.toHaveBeenCalled();
+    expect(mockPublish).toHaveBeenCalled();
+  });
+
+  test("create re-renders the form with the resource errors", async () => {
+    const revision = Factory.build("resource_revision");
+    const ctx = buildCtx(revision, {
+      publishing: { type: "later", mergeAt: "2026-09-01T10:30" },
+    });
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "schedule")
+      .mockImplementation(() => ({
+        resourceErrors: [{ field: "mergeAt", message: "is invalid" }],
+      }));
+
+    const result = await PublishesHandler.create(ctx);
+
+    expect(result.assigns.errors).toBeNull();
+    expect(result.assigns.resourceErrors).toBeDefined();
+    expect(result.assigns.publishing.id).toEqual(revision.id);
+  });
+});

package/src/tests/handlers/resource_revisions/TagHandler.test/default_locale_tags.test.js

@@ -0,0 +1,162 @@
+import TagHandler from "../../../../handlers/resource_revisions/TagHandler";
+import ResourceRevisions from "../../../../cloud/ResourceRevisions";
+import Resources from "../../../../cloud/Resources";
+import Tags from "../../../../cloud/Tags";
+
+import Factory from "../../../support/factory";
+
+// Translated revisions show the tags of their default locale original as a
+// reference, so the handler resolves them through the original record.
+function buildCtx(revision) {
+  return {
+    client: {
+      resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+      resources: new Resources(() => ({}), "token"),
+      tags: new Tags(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "de",
+    defaultLocale: "en",
+    locales: {
+      en: { name: "English", code: "en-gb" },
+      de: { name: "German", code: "de-de" },
+    },
+    resourceConfig: {
+      resourceType: "article",
+      resourceTypePlural: "articles",
+    },
+  };
+}
+
+describe("Resource revision tags in a translated locale", () => {
+  const tags = [
+    Factory.build("tag", { id: "42", name: "News" }),
+    Factory.build("tag", { id: "69", name: "Sports" }),
+  ];
+
+  function mockClient(ctx, { original, defaultLocalePage }) {
+    jest
+      .spyOn(ctx.client.tags, "all")
+      .mockImplementation(() => ({ list: tags }));
+
+    return jest
+      .spyOn(ctx.client.resources, "find")
+      .mockImplementation((id) =>
+        id === original?.id ? original : defaultLocalePage,
+      );
+  }
+
+  test("edit_form exposes the default locale tags", async () => {
+    const revision = Factory.build("resource_revision", {
+      originalId: "7",
+      tags: [tags[1]],
+    });
+    const original = Factory.build("resource", {
+      id: "7",
+      translations: { en: { id: "3" } },
+    });
+    const defaultLocalePage = Factory.build("resource", {
+      id: "3",
+      tags: [tags[0]],
+    });
+
+    const ctx = buildCtx(revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    const mockFind = mockClient(ctx, { original, defaultLocalePage });
+
+    const result = await TagHandler.edit_form(ctx);
+
+    expect(mockFind).toHaveBeenNthCalledWith(1, "7", "de", "article");
+    expect(mockFind).toHaveBeenNthCalledWith(2, "3", "en", "article");
+    expect(result.assigns.defaultLocaleName).toEqual("English");
+    expect(result.assigns.defaultLocaleTags).toEqual([tags[0]]);
+  });
+
+  test("edit_form falls back to no tags when the original has no translations", async () => {
+    const revision = Factory.build("resource_revision", { originalId: "7" });
+    const original = Factory.build("resource", { id: "7", translations: {} });
+
+    const ctx = buildCtx(revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    const mockFind = mockClient(ctx, { original });
+
+    const result = await TagHandler.edit_form(ctx);
+
+    expect(mockFind).toHaveBeenCalledTimes(1);
+    expect(result.assigns.defaultLocaleName).toEqual("");
+    expect(result.assigns.defaultLocaleTags).toEqual([]);
+  });
+
+  test("edit_form falls back to no tags when the default locale is not translated", async () => {
+    const revision = Factory.build("resource_revision", { originalId: "7" });
+    const original = Factory.build("resource", {
+      id: "7",
+      translations: { fr: { id: "9" } },
+    });
+
+    const ctx = buildCtx(revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    mockClient(ctx, { original });
+
+    const result = await TagHandler.edit_form(ctx);
+
+    expect(result.assigns.defaultLocaleTags).toEqual([]);
+  });
+
+  test("edit_form copes with a default locale page that has no tags", async () => {
+    const revision = Factory.build("resource_revision", { originalId: "7" });
+    const original = Factory.build("resource", {
+      id: "7",
+      translations: { en: { id: "3" } },
+    });
+
+    const ctx = buildCtx(revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    mockClient(ctx, { original, defaultLocalePage: null });
+
+    const result = await TagHandler.edit_form(ctx);
+
+    expect(result.assigns.defaultLocaleName).toEqual("English");
+    expect(result.assigns.defaultLocaleTags).toEqual([]);
+  });
+
+  test("update re-renders with the default locale tags when the update fails", async () => {
+    const revision = Factory.build("resource_revision", {
+      originalId: "7",
+      tags: [],
+    });
+    const original = Factory.build("resource", {
+      id: "7",
+      translations: { en: { id: "3" } },
+    });
+    const defaultLocalePage = Factory.build("resource", {
+      id: "3",
+      tags: [tags[0]],
+    });
+
+    const ctx = buildCtx(revision);
+    ctx.resourceParams = { resource: { tags: ["42"] } };
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "update")
+      .mockImplementation(() => ({ errors: [{ field: "tags" }] }));
+    mockClient(ctx, { original, defaultLocalePage });
+
+    const result = await TagHandler.update(ctx);
+
+    expect(result.assigns.defaultLocaleName).toEqual("English");
+    expect(result.assigns.defaultLocaleTags).toEqual([tags[0]]);
+    expect(result.assigns.errors.resource).toBeDefined();
+  });
+});

package/src/tests/handlers/resource_revisions/WidgetHandler.test/defaults.test.js

@@ -0,0 +1,61 @@
+import WidgetHandler from "../../../../handlers/resource_revisions/WidgetHandler";
+import ResourceRevisions from "../../../../cloud/ResourceRevisions";
+import Settings from "../../../../cloud/Settings";
+
+import Factory from "../../../support/factory";
+
+function buildCtx(revision, resourceParams = {}) {
+  return {
+    client: {
+      resourceRevisions: new ResourceRevisions(() => ({}), "token"),
+      settings: new Settings(() => ({}), "token"),
+    },
+    params: { parent_id: revision.id },
+    resourceParams,
+    locale: "en",
+    resourceConfig: {
+      resourceType: "article",
+      resourceTypePlural: "articles",
+    },
+  };
+}
+
+describe("Resource revision WidgetHandler defaults", () => {
+  test("update sends an empty widget list when the request carries none", async () => {
+    const revision = Factory.build("resource_revision");
+    const ctx = buildCtx(revision);
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    const mockUpdate = jest
+      .spyOn(ctx.client.resourceRevisions, "updateWidgets")
+      .mockImplementation(() => ({ revision, errors: null }));
+    jest
+      .spyOn(ctx.client.settings, "find")
+      .mockImplementation(() => Factory.build("settings"));
+
+    await WidgetHandler.update(ctx);
+
+    expect(mockUpdate).toHaveBeenCalledWith(revision.id, "en", [], "article");
+  });
+
+  test("update skips the website settings when the update returned errors", async () => {
+    const revision = Factory.build("resource_revision");
+    const ctx = buildCtx(revision, { widgets: [] });
+    const errors = [{ field: "widgets", message: "is invalid" }];
+
+    jest
+      .spyOn(ctx.client.resourceRevisions, "find")
+      .mockImplementation(() => revision);
+    jest
+      .spyOn(ctx.client.resourceRevisions, "updateWidgets")
+      .mockImplementation(() => ({ errors }));
+    const mockSettings = jest.spyOn(ctx.client.settings, "find");
+
+    const result = await WidgetHandler.update(ctx);
+
+    expect(mockSettings).not.toHaveBeenCalled();
+    expect(result).toEqual({ json: { errors } });
+  });
+});

package/src/tests/handlers/resources/DeletesHandler.test/no_redirect.test.js

@@ -0,0 +1,55 @@
+import DeletesHandler from "../../../../handlers/resources/DeletesHandler";
+import Resources from "../../../../cloud/Resources";
+import Factory from "../../../support/factory";
+import { remoteConfig } from "../../../support/handlersHelper";
+
+function buildCtx(resource, params) {
+  return {
+    client: { resources: new Resources(() => ({}), "token") },
+    params: { parent_id: resource.id },
+    resourceParams: { resource: params },
+    locale: "en",
+    remoteConfig: remoteConfig(),
+    resourceConfig: {
+      resourceType: "article",
+      resourceTypePlural: "articles",
+    },
+  };
+}
+
+describe("Resource delete without a redirect", () => {
+  test("create deletes the resource and leaves no redirect behind", async () => {
+    const resource = Factory.build("resource");
+    const ctx = buildCtx(resource, { redirect: "" });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    const mockDelete = jest
+      .spyOn(ctx.client.resources, "delete")
+      .mockImplementation(() => ({ resource, errors: null }));
+
+    const result = await DeletesHandler.create(ctx);
+
+    expect(mockDelete).toHaveBeenCalledWith(resource.id, "en", "article", null);
+    expect(result).toEqual({ redirect: "/en/articles" });
+  });
+
+  test("create_form throws for a missing resource", async () => {
+    const ctx = buildCtx({ id: "42" }, {});
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => null);
+
+    await expect(DeletesHandler.create_form(ctx)).rejects.toThrow(
+      "Missing article #42",
+    );
+  });
+
+  test("create throws for a missing resource", async () => {
+    const ctx = buildCtx({ id: "42" }, { redirect: "" });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => null);
+
+    await expect(DeletesHandler.create(ctx)).rejects.toThrow(
+      "Missing article #42",
+    );
+  });
+});

package/src/tests/handlers/resources/ReportsAPIHandler.test/show.test.js

@@ -0,0 +1,156 @@
+import Resources from "../../../../cloud/Resources";
+import localCache from "../../../../localCache";
+
+jest.mock("../../../../helpers/reports/cwv", () => ({
+  ...jest.requireActual("../../../../helpers/reports/cwv"),
+  pageWebVitals: jest.fn(),
+}));
+jest.mock("../../../../helpers/reports/quick-insights", () => ({
+  pageInsights: jest.fn(),
+}));
+
+import { pageWebVitals } from "../../../../helpers/reports/cwv";
+import { pageInsights } from "../../../../helpers/reports/quick-insights";
+import ReportsAPIHandler from "../../../../handlers/resources/ReportsAPIHandler";
+
+import Factory from "../../../support/factory";
+
+const SERVICE_ACCOUNT_PATH = "/tmp/service-account.json";
+
+describe("Reports API Handler", () => {
+  function buildCtx(resource, { ga, reports = true } = {}) {
+    return {
+      client: { resources: new Resources(() => ({}), "token") },
+      params: { id: resource.id },
+      locale: "en",
+      query: {},
+      globalConfig: { ga },
+      remoteConfig: {
+        resourcePath: () => "/some-page",
+        resourceUrl: () => "https://example.com/some-page",
+      },
+      resourceConfig: {
+        resourceType: "article",
+        resourceTypePlural: "articles",
+        reports,
+      },
+    };
+  }
+
+  const insights = {
+    error: null,
+    pagePath: "/some-page",
+    summary: { views: { value: 10, trend: 5 } },
+    dateRange: { startDate: "2026-07-05", endDate: "2026-08-03" },
+    series: { dates: ["2026-08-01"], labels: ["August 1"], data: [5] },
+    publishDates: [],
+  };
+
+  const vitals = {
+    scope: "url",
+    assessment: "good",
+    metrics: [{ key: "lcp", p75: 1200, rating: "good" }],
+    collectionPeriod: null,
+  };
+
+  beforeEach(() => {
+    localCache.clear();
+    jest.clearAllMocks();
+  });
+
+  test("returns both reports as JSON", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource, {
+      ga: {
+        propertyId: "1234",
+        serviceAccountPath: SERVICE_ACCOUNT_PATH,
+        apiKey: "crux-key",
+      },
+    });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+
+    pageInsights.mockResolvedValue({
+      summary: insights.summary,
+      rows: [{ date: "2026-08-01", views: 5 }],
+      dateRange: insights.dateRange,
+    });
+    pageWebVitals.mockResolvedValue(vitals);
+
+    const result = await ReportsAPIHandler.show(ctx);
+
+    expect(result.json.insights.error).toBeNull();
+    expect(result.json.insights.summary).toEqual(insights.summary);
+    expect(result.json.insights.series).toEqual({
+      dates: ["2026-08-01"],
+      labels: ["August 1"],
+      data: [5],
+    });
+    expect(result.json.webVitals).toEqual({
+      pageUrl: "https://example.com/some-page",
+      ...vitals,
+      error: null,
+    });
+  });
+
+  // Caching belongs to pageInsights / pageWebVitals (3h per page); the handler
+  // assembles the payload fresh so publish dates aren't held back with it.
+  test("does not cache the assembled payload", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource, {
+      ga: { propertyId: "1234", serviceAccountPath: SERVICE_ACCOUNT_PATH },
+    });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    pageInsights.mockResolvedValue({
+      summary: insights.summary,
+      rows: [],
+      dateRange: insights.dateRange,
+    });
+
+    await ReportsAPIHandler.show(ctx);
+    await ReportsAPIHandler.show(ctx);
+
+    expect(pageInsights).toHaveBeenCalledTimes(2);
+  });
+
+  test("passes a failed side through as an error", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource, {
+      ga: { propertyId: "1234", serviceAccountPath: SERVICE_ACCOUNT_PATH },
+    });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+    pageInsights.mockRejectedValue(new Error("GA is down"));
+
+    const result = await ReportsAPIHandler.show(ctx);
+
+    expect(result.json).toEqual({
+      insights: { error: "GA is down" },
+      webVitals: null,
+    });
+  });
+
+  test("returns nulls when no report source is configured", async () => {
+    const resource = Factory.build("resource", { translations: {} });
+    const ctx = buildCtx(resource);
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => resource);
+
+    const result = await ReportsAPIHandler.show(ctx);
+
+    expect(pageInsights).not.toHaveBeenCalled();
+    expect(pageWebVitals).not.toHaveBeenCalled();
+    expect(result.json).toEqual({ insights: null, webVitals: null });
+  });
+
+  test("throws for a missing resource", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    jest.spyOn(ctx.client.resources, "find").mockImplementation(() => null);
+
+    await expect(ReportsAPIHandler.show(ctx)).rejects.toThrow(
+      "Missing article #42",
+    );
+  });
+});

package/src/tests/handlers/resources/ResourcesHandler.test/show.test.js

@@ -85,6 +85,14 @@ describe("Resources Handler", () => {
     expect(result).toEqual({
       assigns: {
         resource,
+        // Nothing is prefetched — the page fetches the JSON feed client-side —
+        // and with no credentials there's no feed to point at either.
+        reports: {
+          insights: false,
+          webVitals: false,
+          path: null,
+          vitalsMeta: [],
+        },
         revisions: [revision],
         changes: { list: [change] },
         _translations: [