@oneuptime/common 12.0.32 → 12.0.34

package/Tests/Types/WebsiteRequest.test.ts

@@ -3,6 +3,9 @@ import Hostname from "../../Types/API/Hostname";
 import Protocol from "../../Types/API/Protocol";
 import Route from "../../Types/API/Route";
 import URL from "../../Types/API/URL";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { HTTPResponseBodyBudget } from "../../Utils/HTTPResponseBodyReader";
+import { Readable } from "stream";
 
 /*
  * WebsiteRequest wraps axios, so axios is mocked and the assertions are about
@@ -15,9 +18,18 @@ const axiosMock: jest.Mock = jest.fn();
 jest.mock("axios", () => {
   return {
     __esModule: true,
-    default: (...args: Array<unknown>) => {
-      return axiosMock(...args);
-    },
+    default: Object.assign(
+      (...args: Array<unknown>) => {
+        return axiosMock(...args);
+      },
+      {
+        isAxiosError: (error: unknown): boolean => {
+          return Boolean(
+            (error as { isAxiosError?: boolean | undefined })?.isAxiosError,
+          );
+        },
+      },
+    ),
   };
 });
 
@@ -119,6 +131,27 @@ describe("WebsiteRequest.fetch", () => {
     });
   });
 
+  test("should allow HEAD Content-Length to describe a larger hypothetical GET body", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    axiosMock.mockResolvedValue({
+      status: 200,
+      data: Readable.from([]),
+      headers: { "Content-Length": "1000000" },
+    });
+
+    await expect(
+      WebsiteRequest.fetch(url, {
+        isHeadRequest: true,
+        doNotFallbackFromHead: true,
+        responseBodyBudget: budget,
+      }),
+    ).resolves.toMatchObject({
+      responseStatusCode: 200,
+      isOnline: true,
+    });
+    expect(budget.remainingBytes).toBe(4);
+  });
+
   test("should set maxRedirects to 0 when redirects are not to be followed", async () => {
     axiosMock.mockResolvedValue(okResponse());
 
@@ -135,6 +168,235 @@ describe("WebsiteRequest.fetch", () => {
     expect(axiosMock.mock.calls[0]![1]).not.toHaveProperty("maxRedirects");
   });
 
+  test("should accept 2xx and 3xx responses when manual redirect handling is requested", async () => {
+    axiosMock.mockResolvedValue(okResponse({ status: 302 }));
+
+    await WebsiteRequest.fetch(url, {
+      doNotFollowRedirects: true,
+      acceptRedirectResponses: true,
+    });
+
+    const requestOptions: {
+      validateStatus?: ((status: number) => boolean) | undefined;
+    } = axiosMock.mock.calls[0]![1] as {
+      validateStatus?: ((status: number) => boolean) | undefined;
+    };
+    expect(requestOptions.validateStatus).toBeDefined();
+    expect(requestOptions.validateStatus!(199)).toBe(false);
+    expect(requestOptions.validateStatus!(200)).toBe(true);
+    expect(requestOptions.validateStatus!(302)).toBe(true);
+    expect(requestOptions.validateStatus!(399)).toBe(true);
+    expect(requestOptions.validateStatus!(400)).toBe(false);
+  });
+
+  test("should use axios default status validation when redirect responses are not accepted", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+
+    await WebsiteRequest.fetch(url, {});
+
+    expect(axiosMock.mock.calls[0]![1]).not.toHaveProperty("validateStatus");
+  });
+
+  test("should forward byte limits and disable implicit proxy routing", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+
+    await WebsiteRequest.fetch(url, {
+      maxContentLength: 10 * 1024 * 1024,
+      maxBodyLength: 256 * 1024,
+      disableProxy: true,
+    });
+
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      maxContentLength: 10 * 1024 * 1024,
+      maxBodyLength: 256 * 1024,
+      proxy: false,
+    });
+  });
+
+  test("should preserve explicit zero-byte limits", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+
+    await WebsiteRequest.fetch(url, {
+      maxContentLength: 0,
+      maxBodyLength: 0,
+    });
+
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      maxContentLength: 0,
+      maxBodyLength: 0,
+    });
+  });
+
+  test("should leave byte limits and proxy routing unset by default", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+
+    await WebsiteRequest.fetch(url, {});
+
+    const requestOptions: Record<string, unknown> = axiosMock.mock.calls[0]![1];
+    expect(requestOptions).not.toHaveProperty("maxContentLength");
+    expect(requestOptions).not.toHaveProperty("maxBodyLength");
+    expect(requestOptions).not.toHaveProperty("proxy");
+  });
+
+  test("should use an internal validated dispatch URL that the reporting URL cannot represent", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    const dispatchUrl: string = "https://example.com/~health";
+
+    await WebsiteRequest.fetch(url, { dispatchUrl: dispatchUrl });
+
+    expect(axiosMock.mock.calls[0]![0]).toBe(dispatchUrl);
+  });
+
+  test("should forward AbortSignal and normalize a budgeted HTML stream", async () => {
+    const controller: AbortController = new AbortController();
+    const bodyText: string = "<html>bounded</html>";
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100);
+    axiosMock.mockResolvedValue({
+      status: 200,
+      data: Readable.from([Buffer.from(bodyText)]),
+      headers: { "content-type": "text/html" },
+    });
+
+    const response: WebsiteResponse = await WebsiteRequest.fetch(url, {
+      signal: controller.signal,
+      responseBodyBudget: budget,
+      limitRedirectResponseBody: true,
+    });
+
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      signal: controller.signal,
+      responseType: "stream",
+      maxContentLength: -1,
+    });
+    expect(response.responseBody.toString()).toBe(bodyText);
+    expect(budget.remainingBytes).toBe(100 - Buffer.byteLength(bodyText));
+  });
+
+  test("should strip a leading UTF-8 BOM from a budgeted HTML stream", async () => {
+    const html: string = "<html><body>bounded</body></html>";
+    const bodyText: string = `\uFEFF${html}`;
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100);
+    axiosMock.mockResolvedValue({
+      status: 200,
+      data: Readable.from([Buffer.from(bodyText)]),
+      headers: { "content-type": "text/html; charset=utf-8" },
+    });
+
+    const response: WebsiteResponse = await WebsiteRequest.fetch(url, {
+      responseBodyBudget: budget,
+    });
+
+    expect(response.responseBody.toString()).toBe(html);
+    expect(budget.remainingBytes).toBe(100 - Buffer.byteLength(bodyText));
+  });
+
+  test("should enforce a per-response cap independently from the shared budget", async () => {
+    const body: Readable = Readable.from([Buffer.from("12345")]);
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100);
+    axiosMock.mockResolvedValue({
+      status: 200,
+      data: body,
+      headers: {},
+    });
+
+    await expect(
+      WebsiteRequest.fetch(url, {
+        responseBodyBudget: budget,
+        maximumResponseBytes: 4,
+      }),
+    ).rejects.toBeInstanceOf(BadDataException);
+
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(95);
+  });
+
+  test("should enforce the smaller redirect cap before returning a followed redirect", async () => {
+    const redirectBody: Readable = Readable.from([Buffer.from("12345")]);
+    axiosMock.mockResolvedValue({
+      status: 302,
+      data: redirectBody,
+      headers: { Location: "https://example.com/final" },
+    });
+
+    await expect(
+      WebsiteRequest.fetch(url, {
+        acceptRedirectResponses: true,
+        responseBodyBudget: new HTTPResponseBodyBudget(100, 4),
+        limitRedirectResponseBody: true,
+      }),
+    ).rejects.toBeInstanceOf(BadDataException);
+
+    expect(axiosMock).toHaveBeenCalledTimes(1);
+    expect(redirectBody.destroyed).toBe(true);
+  });
+
+  test("should allow a caller-visible redirect body to use the full cumulative budget", async () => {
+    const bodyText: string = "12345";
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10, 4);
+    axiosMock.mockResolvedValue({
+      status: 302,
+      data: Readable.from([Buffer.from(bodyText)]),
+      headers: { Location: "https://example.com/final" },
+    });
+
+    const response: WebsiteResponse = await WebsiteRequest.fetch(url, {
+      acceptRedirectResponses: true,
+      responseBodyBudget: budget,
+      limitRedirectResponseBody: false,
+    });
+
+    expect(response.responseStatusCode).toBe(302);
+    expect(response.responseBody.toString()).toBe(bodyText);
+    expect(budget.remainingBytes).toBe(5);
+  });
+
+  test("should preserve deadline and budget options on the internal HEAD-to-GET fallback", async () => {
+    const controller: AbortController = new AbortController();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(13);
+    const headError: {
+      isAxiosError: true;
+      response: {
+        status: number;
+        data: Readable | string;
+        headers: Record<string, string>;
+      };
+    } = {
+      isAxiosError: true,
+      response: {
+        status: 405,
+        data: Readable.from([Buffer.from("\uFEFFno")]),
+        headers: { "content-type": "text/plain" },
+      },
+    };
+    axiosMock.mockRejectedValueOnce(headError).mockResolvedValueOnce({
+      status: 200,
+      data: Readable.from([Buffer.from("fallback")]),
+      headers: {},
+    });
+
+    const response: WebsiteResponse = await WebsiteRequest.fetch(url, {
+      isHeadRequest: true,
+      signal: controller.signal,
+      responseBodyBudget: budget,
+      limitRedirectResponseBody: true,
+    });
+
+    expect(axiosMock).toHaveBeenCalledTimes(2);
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      method: HTTPMethod.HEAD,
+      signal: controller.signal,
+      responseType: "stream",
+    });
+    expect(axiosMock.mock.calls[1]![1]).toMatchObject({
+      method: HTTPMethod.GET,
+      signal: controller.signal,
+      responseType: "stream",
+    });
+    expect(response.responseBody.toString()).toBe("fallback");
+    expect(headError.response.data).toBe("no");
+    expect(budget.remainingBytes).toBe(0);
+  });
+
   test("should forward proxy agents when supplied", async () => {
     axiosMock.mockResolvedValue(okResponse());
 
@@ -194,6 +456,10 @@ describe("WebsiteRequest.fetch", () => {
         isHeadRequest: true,
         timeout: 9000,
         doNotFollowRedirects: true,
+        acceptRedirectResponses: true,
+        maxContentLength: 4096,
+        maxBodyLength: 2048,
+        disableProxy: true,
         headers: { "x-trace": "abc" },
       });
 
@@ -201,10 +467,26 @@ describe("WebsiteRequest.fetch", () => {
         method: HTTPMethod.GET,
         timeout: 9000,
         maxRedirects: 0,
+        maxContentLength: 4096,
+        maxBodyLength: 2048,
+        proxy: false,
         headers: { "x-trace": "abc" },
       });
     });
 
+    test("should let an outer redirect guard disable the internal HEAD fallback", async () => {
+      axiosMock.mockRejectedValueOnce(new Error("HEAD not allowed"));
+
+      await expect(
+        WebsiteRequest.fetch(url, {
+          isHeadRequest: true,
+          doNotFallbackFromHead: true,
+        }),
+      ).rejects.toThrow("HEAD not allowed");
+
+      expect(axiosMock).toHaveBeenCalledTimes(1);
+    });
+
     test("should propagate the error when the GET retry also fails", async () => {
       axiosMock
         .mockRejectedValueOnce(new Error("HEAD not allowed"))

package/Tests/UI/Components/BasicRadioButtons.test.tsx

@@ -0,0 +1,336 @@
+// Components
+import BasicRadioButtons, {
+  BasicRadioButtonOption,
+} from "../../../UI/Components/RadioButtons/BasicRadioButtons";
+import { describe, expect, test } from "@jest/globals";
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
+import getJestMockFunction, { MockFunction } from "../../../Tests/MockType";
+
+/*
+ * A regression suite for a bug that shipped and was visible on every desktop.
+ *
+ * The option title and its description were two inline spans inside one label,
+ * separated by `ml-1 sm:ml-0`. The `sm:` variant cancels the margin at every
+ * breakpoint from 640px up -- i.e. on every desktop -- so the only gap between
+ * the two strings disappeared and the pair rendered as one run-on sentence:
+ * "Create an alertNotifies the team and runs the on-call policy." The narrow
+ * phone layout, the one place the 4px margin survived, was the only place it
+ * looked right, which is why it went unnoticed.
+ *
+ * So the assertions below are about the two strings being separate, stacked
+ * block elements with no horizontal-margin hack between them. The rest of the
+ * suite pins the selection behaviour that these options exist to drive.
+ */
+
+const ALERT_TITLE: string = "Create an alert";
+const ALERT_DESCRIPTION: string =
+  "Notifies the team and runs the on-call policy.";
+const SILENT_TITLE: string = "Do nothing";
+const SILENT_DESCRIPTION: string = "Leaves the monitor silent.";
+
+const options: Array<BasicRadioButtonOption> = [
+  {
+    title: ALERT_TITLE,
+    description: ALERT_DESCRIPTION,
+    value: "alert",
+  },
+  {
+    title: SILENT_TITLE,
+    description: SILENT_DESCRIPTION,
+    value: "silent",
+  },
+];
+
+type RadioAtFunction = (index: number) => HTMLInputElement;
+
+/*
+ * Addressed by position because the suite also asserts things about the pair
+ * of elements at each index. Where the point of a test is the ASSOCIATION
+ * between a radio and its label, it queries by accessible name instead --
+ * see the "each radio is named by its own title" group.
+ */
+const radioAt: RadioAtFunction = (index: number): HTMLInputElement => {
+  const radio: HTMLElement | undefined = screen.getAllByRole("radio")[index];
+
+  if (!radio) {
+    throw new Error(`No radio button rendered at index ${index}.`);
+  }
+
+  return radio as HTMLInputElement;
+};
+
+describe("BasicRadioButtons", () => {
+  /*
+   * The label used to be a bare sibling of its input, with no htmlFor and
+   * without wrapping it, so nothing tied the two together. Two things followed
+   * from that, and neither was visible to a sighted mouse user: the radio had
+   * no accessible name at all -- a screen reader announced "radio button, not
+   * checked" and never read "Create an alert" -- and the only hit target was
+   * the 16px dot, so clicking the words did nothing.
+   */
+  describe("each radio is named by its own title", () => {
+    test("the radio can be found by its title", () => {
+      render(
+        <BasicRadioButtons
+          options={options}
+          onChange={getJestMockFunction()}
+        />,
+      );
+
+      expect(
+        screen.getByRole("radio", { name: new RegExp(ALERT_TITLE) }),
+      ).toBeInTheDocument();
+      expect(
+        screen.getByRole("radio", { name: new RegExp(SILENT_TITLE) }),
+      ).toBeInTheDocument();
+    });
+
+    test("no two radios share a name", () => {
+      render(
+        <BasicRadioButtons
+          options={options}
+          onChange={getJestMockFunction()}
+        />,
+      );
+
+      const first: HTMLElement = screen.getByRole("radio", {
+        name: new RegExp(ALERT_TITLE),
+      });
+      const second: HTMLElement = screen.getByRole("radio", {
+        name: new RegExp(SILENT_TITLE),
+      });
+
+      expect(first).not.toBe(second);
+    });
+
+    test("clicking the title text selects that option", () => {
+      const onChange: MockFunction = getJestMockFunction();
+
+      render(<BasicRadioButtons options={options} onChange={onChange} />);
+
+      onChange.mockClear();
+      fireEvent.click(screen.getByText(SILENT_TITLE));
+
+      expect(onChange).toHaveBeenCalledWith("silent");
+    });
+
+    test("clicking the description text selects that option too", () => {
+      const onChange: MockFunction = getJestMockFunction();
+
+      render(<BasicRadioButtons options={options} onChange={onChange} />);
+
+      onChange.mockClear();
+      fireEvent.click(screen.getByText(SILENT_DESCRIPTION));
+
+      expect(onChange).toHaveBeenCalledWith("silent");
+    });
+  });
+
+  describe("an option's title and description", () => {
+    /*
+     * The exact bug. `sm:ml-0` on the description is what glued the two strings
+     * together on desktop, and a horizontal margin is meaningless once the
+     * description is a block on its own line -- so its reappearance is the
+     * regression, whatever else changes around it.
+     */
+    test("the description is a block under the title, not an inline span nudged sideways", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(<BasicRadioButtons onChange={onChange} options={options} />);
+
+      const title: HTMLElement = screen.getByText(ALERT_TITLE);
+      const description: HTMLElement = screen.getByText(ALERT_DESCRIPTION);
+
+      expect(title).toHaveClass("block");
+      expect(description).toHaveClass("block");
+      expect(description.className).not.toContain("ml-1");
+      expect(description.className).not.toContain("sm:ml-0");
+    });
+
+    /*
+     * That an exact-match query for the title alone finds an element is the
+     * proof that the two strings are still two elements: fold them into one
+     * text node -- the shape the bug rendered as -- and this query finds
+     * nothing, because the node's text would be title + description.
+     */
+    test("the title is queryable on its own, and the description follows it", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(<BasicRadioButtons onChange={onChange} options={options} />);
+
+      const title: HTMLElement = screen.getByText(ALERT_TITLE);
+      const description: HTMLElement = screen.getByText(ALERT_DESCRIPTION);
+
+      expect(title).not.toBe(description);
+      expect(title.contains(description)).toBe(false);
+      expect(title.nextElementSibling).toBe(description);
+      expect(title.closest("label")).toBe(description.closest("label"));
+    });
+
+    /*
+     * `description` is optional, and an empty <span> still takes its `mt-0.5`
+     * with it -- which would leave a ragged extra gap under every title-only
+     * option in a list that mixes the two.
+     */
+    test("an option with no description renders no description element", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(
+        <BasicRadioButtons
+          onChange={onChange}
+          options={[{ title: SILENT_TITLE, value: "silent" }]}
+        />,
+      );
+
+      const label: HTMLLabelElement | null = screen
+        .getByText(SILENT_TITLE)
+        .closest("label");
+
+      expect(label).not.toBeNull();
+      expect(label?.children).toHaveLength(1);
+      expect(screen.getAllByRole("radio")).toHaveLength(1);
+    });
+  });
+
+  describe("selection", () => {
+    /*
+     * The whole point of the control: the form above it only learns which
+     * branch the user picked through onChange.
+     */
+    test("picking an option reports its value and checks only that radio", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(<BasicRadioButtons onChange={onChange} options={options} />);
+
+      fireEvent.click(radioAt(0));
+
+      expect(onChange).toHaveBeenLastCalledWith("alert");
+      expect(radioAt(0)).toBeChecked();
+      expect(radioAt(1)).not.toBeChecked();
+
+      fireEvent.click(radioAt(1));
+
+      expect(onChange).toHaveBeenLastCalledWith("silent");
+      expect(radioAt(0)).not.toBeChecked();
+      expect(radioAt(1)).toBeChecked();
+    });
+
+    /*
+     * A form that opens on a saved value has to show that value selected AND
+     * hand it back once, so the parent's state matches what is on screen
+     * before the user touches anything. Firing more than once here is not
+     * harmless: callers wire onChange to setState and to "mark form dirty".
+     */
+    test("initialValue selects that option on mount and reports it exactly once", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(
+        <BasicRadioButtons
+          onChange={onChange}
+          options={options}
+          initialValue="silent"
+        />,
+      );
+
+      expect(radioAt(1)).toBeChecked();
+      expect(radioAt(0)).not.toBeChecked();
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith("silent");
+    });
+
+    /*
+     * No initial value means no pre-selected branch. A control that quietly
+     * checked the first option would submit a choice the user never made.
+     */
+    test("with no initialValue nothing is selected and the empty value is reported", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(<BasicRadioButtons onChange={onChange} options={options} />);
+
+      expect(radioAt(0)).not.toBeChecked();
+      expect(radioAt(1)).not.toBeChecked();
+      expect(onChange).toHaveBeenCalledWith("");
+    });
+
+    test("an empty-string initialValue also selects nothing", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(
+        <BasicRadioButtons
+          onChange={onChange}
+          options={options}
+          initialValue=""
+        />,
+      );
+
+      expect(radioAt(0)).not.toBeChecked();
+      expect(radioAt(1)).not.toBeChecked();
+      expect(onChange).toHaveBeenCalledWith("");
+    });
+  });
+
+  describe("per-option children", () => {
+    /*
+     * Options carry their own follow-up fields (pick an on-call policy, choose
+     * a status page). Showing them for an unchosen option would put inputs on
+     * screen that the form never reads; leaving them behind after the user
+     * switches branches is worse -- the stale field looks live and editable.
+     */
+    test("children appear only while their own option is checked", () => {
+      const childText: string = "Choose an on-call policy";
+      const onChange: MockFunction = getJestMockFunction();
+
+      render(
+        <BasicRadioButtons
+          onChange={onChange}
+          options={[
+            {
+              title: ALERT_TITLE,
+              description: ALERT_DESCRIPTION,
+              value: "alert",
+              children: <div>{childText}</div>,
+            },
+            {
+              title: SILENT_TITLE,
+              value: "silent",
+            },
+          ]}
+        />,
+      );
+
+      expect(screen.queryByText(childText)).not.toBeInTheDocument();
+
+      fireEvent.click(radioAt(0));
+
+      expect(screen.getByText(childText)).toBeInTheDocument();
+
+      fireEvent.click(radioAt(1));
+
+      expect(screen.queryByText(childText)).not.toBeInTheDocument();
+    });
+  });
+
+  describe("validation message", () => {
+    /*
+     * The error is the only feedback a user gets when a required choice was
+     * skipped; a swallowed message leaves a form that refuses to submit and
+     * says nothing about why.
+     */
+    test("the error prop renders its message", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(
+        <BasicRadioButtons
+          onChange={onChange}
+          options={options}
+          error="Pick one of these."
+        />,
+      );
+
+      expect(screen.getByTestId("error-message")).toHaveTextContent(
+        "Pick one of these.",
+      );
+    });
+
+    test("no error element is rendered when there is no error", () => {
+      const onChange: MockFunction = getJestMockFunction();
+      render(<BasicRadioButtons onChange={onChange} options={options} />);
+
+      expect(screen.queryByTestId("error-message")).not.toBeInTheDocument();
+    });
+  });
+});

package/Tests/UI/Components/Charts/ChartBucketIdentity.test.ts

@@ -106,7 +106,14 @@ describe("series data does not merge across days", () => {
     const rows: Array<ChartDataPoint> = chartRows(xAxis, hourlyPoints(48));
     const withData: Array<ChartDataPoint> = rowsCarryingData(rows);
 
-    expect(rows).toHaveLength(97);
+    /*
+     * 96, not the 97 slots the raw grid walks. The 97th is the start of the
+     * bucket CONTAINING the window end — [Mar 4 00:00, Mar 4 00:30), which
+     * this 48h window does not reach into at all — so nothing can ever land
+     * there and it is dropped rather than left as a blank slot stretching
+     * the axis past the data. See XAxisUtil.getRenderableIntervals.
+     */
+    expect(rows).toHaveLength(96);
     expect(withData).toHaveLength(48);
 
     for (const row of withData) {
@@ -125,8 +132,14 @@ describe("series data does not merge across days", () => {
       -1,
     );
 
-    // Hourly points on a half-hourly axis reach the second-to-last tick.
-    expect(lastRowWithData).toBe(rows.length - 3);
+    /*
+     * Hourly points on a half-hourly axis reach the second-to-last tick: the
+     * final hourly point is at 47h, and the tick after it is the 47:30 slot,
+     * which no hourly point lands on. (This used to read `length - 3`, back
+     * when the grid also carried an unfillable 48:00 slot past the end of
+     * the window.)
+     */
+    expect(lastRowWithData).toBe(rows.length - 2);
   });
 
   test("a Sum aggregate is not inflated by a merged day", () => {