@raketa-cloud/admin 1.8.17 → 1.8.19

package/src/tests/helpers/reports/quick-insights.test.js

@@ -0,0 +1,593 @@
+import { generateKeyPairSync } from "node:crypto";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  clearAuthCache,
+  serviceAccountConfigured,
+} from "../../../helpers/reports/googleAuth";
+import {
+  pageInsights,
+  runPageReport,
+  runSummary,
+} from "../../../helpers/reports/quick-insights";
+import localCache from "../../../localCache";
+
+// One throwaway RSA key written to a temp file — the module reads the key from
+// ga.serviceAccountPath, exactly like it does in the app.
+const { privateKey } = generateKeyPairSync("rsa", {
+  modulusLength: 2048,
+  privateKeyEncoding: { type: "pkcs8", format: "pem" },
+  publicKeyEncoding: { type: "spki", format: "pem" },
+});
+
+const dir = mkdtempSync(join(tmpdir(), "quick-insights-"));
+const keyPath = join(dir, "service-account.json");
+const missingPath = join(dir, "nope.json");
+const brokenPath = join(dir, "broken.json");
+
+writeFileSync(
+  keyPath,
+  JSON.stringify({
+    type: "service_account",
+    client_email: "reports@project.iam.gserviceaccount.com",
+    private_key_id: "key-1",
+    private_key: privateKey,
+  }),
+);
+writeFileSync(brokenPath, JSON.stringify({ client_email: "a@b.c" }));
+
+const GA = { propertyId: "1234", serviceAccountPath: keyPath };
+
+const reportBody = {
+  rows: [
+    {
+      dimensionValues: [{ value: "20260701" }],
+      metricValues: [{ value: "4" }],
+    },
+  ],
+};
+
+// First call is the token exchange, the rest are runReport calls.
+function mockGoogle({ tokenStatus = 200, reportStatus = 200 } = {}) {
+  global.fetch = jest.fn().mockImplementation(async (url) => {
+    const isToken = String(url).includes("oauth2.googleapis.com");
+    const status = isToken ? tokenStatus : reportStatus;
+    const body = isToken
+      ? { access_token: "at-1", expires_in: 3600 }
+      : reportBody;
+
+    return {
+      ok: status === 200,
+      status,
+      json: async () => body,
+      text: async () => JSON.stringify(body),
+    };
+  });
+}
+
+const decode = (segment) =>
+  JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+
+describe("quick-insights auth", () => {
+  beforeEach(() => {
+    clearAuthCache();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+  });
+
+  test("serviceAccountConfigured follows the key path", () => {
+    expect(serviceAccountConfigured(GA)).toBe(true);
+    expect(serviceAccountConfigured({})).toBe(false);
+    expect(serviceAccountConfigured()).toBe(false);
+  });
+
+  test("signs a JWT from the key file and calls the Data API with it", async () => {
+    mockGoogle();
+
+    const result = await runPageReport({
+      pagePath: "/pricing",
+      startDate: "2026-07-01",
+      endDate: "2026-07-01",
+      ga: GA,
+    });
+
+    const [tokenUrl, tokenOptions] = global.fetch.mock.calls[0];
+    expect(tokenUrl).toBe("https://oauth2.googleapis.com/token");
+
+    const params = Object.fromEntries(tokenOptions.body);
+    expect(params.grant_type).toBe(
+      "urn:ietf:params:oauth:grant-type:jwt-bearer",
+    );
+
+    const [header, claims] = params.assertion.split(".");
+    expect(decode(header)).toEqual({
+      alg: "RS256",
+      typ: "JWT",
+      kid: "key-1",
+    });
+    expect(decode(claims)).toMatchObject({
+      iss: "reports@project.iam.gserviceaccount.com",
+      scope: "https://www.googleapis.com/auth/analytics.readonly",
+      aud: "https://oauth2.googleapis.com/token",
+    });
+
+    const [reportUrl, reportOptions] = global.fetch.mock.calls[1];
+    expect(reportUrl).toBe(
+      "https://analyticsdata.googleapis.com/v1beta/properties/1234:runReport",
+    );
+    expect(reportOptions.headers.authorization).toBe("Bearer at-1");
+
+    // The chart plots views only, so that is the single metric requested.
+    expect(JSON.parse(reportOptions.body).metrics).toEqual([
+      { name: "screenPageViews" },
+    ]);
+    expect(result.rows).toEqual([{ date: "2026-07-01", views: 4 }]);
+  });
+
+  test("reuses the access token across reports", async () => {
+    mockGoogle();
+
+    const args = {
+      pagePath: "/pricing",
+      startDate: "2026-07-01",
+      endDate: "2026-07-01",
+      ga: GA,
+    };
+    await runPageReport(args);
+    await runPageReport(args);
+
+    const tokenCalls = global.fetch.mock.calls.filter(([url]) =>
+      String(url).includes("oauth2.googleapis.com"),
+    );
+    expect(tokenCalls).toHaveLength(1);
+    expect(global.fetch).toHaveBeenCalledTimes(3);
+  });
+
+  // Reports fire their GA calls together, so on a cold cache each one used to
+  // mint its own token.
+  test("mints one token for reports started concurrently", async () => {
+    mockGoogle();
+
+    const args = {
+      pagePath: "/pricing",
+      startDate: "2026-07-01",
+      endDate: "2026-07-01",
+      ga: GA,
+    };
+    await Promise.all([runPageReport(args), runPageReport(args)]);
+
+    const tokenCalls = global.fetch.mock.calls.filter(([url]) =>
+      String(url).includes("oauth2.googleapis.com"),
+    );
+    expect(tokenCalls).toHaveLength(1);
+  });
+
+  test("retries the token exchange after a failed one", async () => {
+    const args = {
+      pagePath: "/pricing",
+      startDate: "2026-07-01",
+      endDate: "2026-07-01",
+      ga: GA,
+    };
+
+    mockGoogle({ tokenStatus: 400 });
+    await expect(runPageReport(args)).rejects.toThrow(
+      /Google token request failed/,
+    );
+
+    // The failed exchange must not be left behind for the next caller to await.
+    mockGoogle();
+    await expect(runPageReport(args)).resolves.toBeDefined();
+  });
+
+  test("surfaces token and Data API failures", async () => {
+    const args = {
+      pagePath: "/pricing",
+      startDate: "2026-07-01",
+      endDate: "2026-07-01",
+      ga: GA,
+    };
+
+    mockGoogle({ tokenStatus: 400 });
+    await expect(runPageReport(args)).rejects.toThrow(
+      /Google token request failed \(400\)/,
+    );
+
+    clearAuthCache();
+    mockGoogle({ reportStatus: 403 });
+    await expect(runPageReport(args)).rejects.toThrow(/GA Data API 403/);
+  });
+
+  test("reports unusable key paths", async () => {
+    // The property id is checked while building the request URL, so every case
+    // here keeps it set — otherwise that error would mask the key one.
+    mockGoogle();
+
+    const args = {
+      pagePath: "/pricing",
+      startDate: "2026-07-01",
+      endDate: "2026-07-01",
+    };
+
+    await expect(
+      runPageReport({ ...args, ga: { propertyId: "1234" } }),
+    ).rejects.toThrow(/Google service-account key is not set/);
+    await expect(
+      runPageReport({
+        ...args,
+        ga: { propertyId: "1234", serviceAccountPath: missingPath },
+      }),
+    ).rejects.toThrow(/Could not read the service-account key/);
+    await expect(
+      runPageReport({
+        ...args,
+        ga: { propertyId: "1234", serviceAccountPath: brokenPath },
+      }),
+    ).rejects.toThrow(/no client_email \/ private_key/);
+  });
+
+  test("requires a property id", async () => {
+    mockGoogle();
+
+    await expect(
+      runPageReport({
+        pagePath: "/pricing",
+        startDate: "2026-07-01",
+        endDate: "2026-07-01",
+        ga: { serviceAccountPath: keyPath },
+      }),
+    ).rejects.toThrow(/GA property id is not set/);
+  });
+});
+
+describe("runSummary", () => {
+  const metrics = (views, users, engagementSeconds, rate, sessions) => ({
+    metricValues: [views, users, engagementSeconds, rate, sessions].map(
+      (value) => ({ value: String(value) }),
+    ),
+  });
+
+  // GA tags each row with the name of the date range it belongs to when the
+  // report asks for more than one.
+  const summaryBody = (rows) => ({
+    dimensionHeaders: [{ name: "dateRange" }],
+    rows,
+  });
+
+  const mockSummary = (body) => {
+    global.fetch = jest.fn(async (url) => {
+      const isToken = String(url).includes("oauth2.googleapis.com");
+
+      return {
+        ok: true,
+        status: 200,
+        json: async () =>
+          isToken ? { access_token: "at-1", expires_in: 3600 } : body,
+        text: async () => "",
+      };
+    });
+  };
+
+  const reportCalls = () =>
+    global.fetch.mock.calls.filter(
+      ([url]) => !String(url).includes("oauth2.googleapis.com"),
+    );
+
+  const ARGS = {
+    pagePath: "/pricing",
+    startDate: "2026-07-08",
+    endDate: "2026-07-14",
+    ga: GA,
+  };
+
+  beforeEach(() => {
+    clearAuthCache();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+  });
+
+  test("asks for both periods in one request", async () => {
+    mockSummary(
+      summaryBody([
+        {
+          dimensionValues: [{ value: "current" }],
+          ...metrics(200, 100, 600, 0.6, 20),
+        },
+        {
+          dimensionValues: [{ value: "previous" }],
+          ...metrics(100, 50, 200, 0.3, 10),
+        },
+      ]),
+    );
+
+    const result = await runSummary(ARGS);
+
+    expect(reportCalls()).toHaveLength(1);
+
+    const body = JSON.parse(reportCalls()[0][1].body);
+    expect(body.dateRanges).toEqual([
+      { startDate: "2026-07-08", endDate: "2026-07-14", name: "current" },
+      { startDate: "2026-07-01", endDate: "2026-07-07", name: "previous" },
+    ]);
+    expect(body.dimensionFilter).toEqual({
+      filter: {
+        fieldName: "pagePath",
+        stringFilter: { matchType: "EXACT", value: "/pricing" },
+      },
+    });
+
+    expect(result.views).toEqual({ value: 200, previous: 100, trend: 100 });
+    expect(result.users).toEqual({ value: 100, previous: 50, trend: 100 });
+    // 600s over 20 sessions against 200s over 10.
+    expect(result.avgDuration.seconds).toEqual(30);
+    expect(result.avgDuration.trend).toBeCloseTo(50);
+    expect(result.engagement.rate).toBeCloseTo(0.6);
+    expect(result.engagement.trend).toBeCloseTo(100);
+  });
+
+  test("matches rows by range name, whatever order they arrive in", async () => {
+    mockSummary(
+      summaryBody([
+        {
+          dimensionValues: [{ value: "previous" }],
+          ...metrics(100, 50, 200, 0.3, 10),
+        },
+        {
+          dimensionValues: [{ value: "current" }],
+          ...metrics(50, 25, 100, 0.15, 5),
+        },
+      ]),
+    );
+
+    const result = await runSummary(ARGS);
+
+    expect(result.views).toEqual({ value: 50, previous: 100, trend: -50 });
+  });
+
+  // A period with no traffic comes back with no row at all.
+  test("reads zeros and drops the trend for a period GA left out", async () => {
+    mockSummary(
+      summaryBody([
+        {
+          dimensionValues: [{ value: "current" }],
+          ...metrics(10, 5, 60, 0.5, 2),
+        },
+      ]),
+    );
+
+    const result = await runSummary(ARGS);
+
+    // The zero baseline travels with the metric so the page can tell a brand
+    // new page from one that was never measured.
+    expect(result.views).toEqual({ value: 10, previous: 0, trend: null });
+    expect(result.engagement).toEqual({ rate: 0.5, previous: 0, trend: null });
+  });
+
+  test("answers with zeros when the report has no rows at all", async () => {
+    mockSummary(summaryBody([]));
+
+    const result = await runSummary(ARGS);
+
+    expect(result.views).toEqual({ value: 0, previous: 0, trend: null });
+    expect(result.avgDuration).toEqual({
+      seconds: 0,
+      previous: 0,
+      trend: null,
+    });
+  });
+});
+
+describe("pageInsights batching", () => {
+  // The window is the last 30 days from today, so the one day the series
+  // reports has to be today for the backfill to keep it.
+  const today = new Date().toISOString().slice(0, 10);
+  const todayCompact = today.replace(/-/g, "");
+
+  const BATCH = {
+    reports: [
+      {
+        dimensionHeaders: [{ name: "dateRange" }],
+        rows: [
+          {
+            dimensionValues: [{ value: "current" }],
+            metricValues: [
+              { value: "200" },
+              { value: "100" },
+              { value: "600" },
+              { value: "0.6" },
+              { value: "20" },
+            ],
+          },
+          {
+            dimensionValues: [{ value: "previous" }],
+            metricValues: [
+              { value: "100" },
+              { value: "50" },
+              { value: "200" },
+              { value: "0.3" },
+              { value: "10" },
+            ],
+          },
+        ],
+      },
+      {
+        rows: [
+          {
+            dimensionValues: [{ value: todayCompact }],
+            metricValues: [{ value: "7" }],
+          },
+        ],
+      },
+    ],
+  };
+
+  const dataCalls = () =>
+    global.fetch.mock.calls.filter(
+      ([url]) => !String(url).includes("oauth2.googleapis.com"),
+    );
+
+  beforeEach(() => {
+    clearAuthCache();
+    localCache.clear();
+    jest.clearAllMocks();
+
+    global.fetch = jest.fn(async (url) => ({
+      ok: true,
+      status: 200,
+      json: async () =>
+        String(url).includes("oauth2.googleapis.com")
+          ? { access_token: "at-1", expires_in: 3600 }
+          : BATCH,
+      text: async () => "",
+    }));
+  });
+
+  afterEach(() => {
+    localCache.clear();
+    delete global.fetch;
+  });
+
+  // Summary current + summary previous + the daily series: three periods over
+  // two report shapes, one round trip.
+  test("asks for the summary and the series in a single request", async () => {
+    await pageInsights("/pricing", GA, { cacheKey: "page:1" });
+
+    expect(dataCalls()).toHaveLength(1);
+
+    const [url, options] = dataCalls()[0];
+    expect(url).toBe(
+      "https://analyticsdata.googleapis.com/v1beta/properties/1234:batchRunReports",
+    );
+
+    const { requests } = JSON.parse(options.body);
+    expect(requests).toHaveLength(2);
+
+    // The summary carries both periods and no date breakdown.
+    expect(requests[0].dimensions).toBeUndefined();
+    expect(requests[0].dateRanges).toHaveLength(2);
+    expect(requests[0].dateRanges.map((r) => r.name)).toEqual([
+      "current",
+      "previous",
+    ]);
+
+    // The series is broken down by date, which is why it can't be the same
+    // report as the summary.
+    expect(requests[1].dimensions).toEqual([{ name: "date" }]);
+    expect(requests[1].dateRanges).toHaveLength(1);
+
+    // The property lives in the URL — repeating it in a request is an error.
+    requests.forEach((request) => expect(request.property).toBeUndefined());
+  });
+
+  test("reads the summary off the first report and the series off the second", async () => {
+    const result = await pageInsights("/pricing", GA, { cacheKey: "page:1" });
+
+    expect(result.summary.views).toEqual({
+      value: 200,
+      previous: 100,
+      trend: 100,
+    });
+    expect(result.rows).toContainEqual({ date: today, views: 7 });
+    // Days GA skipped are still plotted, so the line has no false gaps.
+    expect(result.rows).toHaveLength(30);
+  });
+
+  // Both instants land on the same UTC day but on different local days for a
+  // host that isn't on UTC — the window has to follow the host's calendar.
+  test.each(["2026-08-11T23:30:00Z", "2026-08-12T00:30:00Z"])(
+    "asks for the window in the server's own timezone (%s)",
+    async (instant) => {
+      jest.useFakeTimers().setSystemTime(new Date(instant));
+
+      try {
+        await pageInsights("/pricing", GA, { cacheKey: `page:${instant}` });
+
+        // en-CA renders a local date as YYYY-MM-DD without going through UTC.
+        const local = (date) => date.toLocaleDateString("en-CA");
+        const start = new Date();
+        start.setDate(start.getDate() - 29);
+
+        const { requests } = JSON.parse(dataCalls()[0][1].body);
+        expect(requests[1].dateRanges[0]).toEqual({
+          startDate: local(start),
+          endDate: local(new Date()),
+        });
+      } finally {
+        jest.useRealTimers();
+      }
+    },
+  );
+
+  test("survives a batch that came back short", async () => {
+    global.fetch = jest.fn(async (url) => ({
+      ok: true,
+      status: 200,
+      json: async () =>
+        String(url).includes("oauth2.googleapis.com")
+          ? { access_token: "at-1", expires_in: 3600 }
+          : {},
+      text: async () => "",
+    }));
+
+    const result = await pageInsights("/pricing", GA, { cacheKey: "page:2" });
+
+    expect(result.summary.views).toEqual({
+      value: 0,
+      previous: 0,
+      trend: null,
+    });
+    expect(result.rows.every((row) => row.views === 0)).toBe(true);
+  });
+});
+
+describe("pageInsights caching", () => {
+  const reportCalls = () =>
+    global.fetch.mock.calls.filter(
+      ([url]) => !String(url).includes("oauth2.googleapis.com"),
+    ).length;
+
+  beforeEach(() => {
+    clearAuthCache();
+    localCache.clear();
+    jest.clearAllMocks();
+    mockGoogle();
+  });
+
+  afterEach(() => {
+    localCache.clear();
+    delete global.fetch;
+  });
+
+  test("keys the entry on the resource, not on the page path", async () => {
+    await pageInsights("/old-slug", GA, { cacheKey: "page:42" });
+    const first = reportCalls();
+    expect(first).toBeGreaterThan(0);
+
+    // Same resource after a slug change — served from cache.
+    await pageInsights("/new-slug", GA, { cacheKey: "page:42" });
+    expect(reportCalls()).toEqual(first);
+
+    // A different resource on the same path gets its own entry.
+    await pageInsights("/old-slug", GA, { cacheKey: "page:43" });
+    expect(reportCalls()).toEqual(first * 2);
+  });
+
+  test("falls back to the page path without a cacheKey", async () => {
+    await pageInsights("/pricing", GA);
+    const first = reportCalls();
+
+    await pageInsights("/pricing", GA);
+    expect(reportCalls()).toEqual(first);
+
+    await pageInsights("/about", GA);
+    expect(reportCalls()).toEqual(first * 2);
+  });
+});