@oneuptime/common 12.0.33 → 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/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", () => {