npm - @oneuptime/common - Versions diffs - 11.6.1 → 11.7.0 - Mend

@oneuptime/common 11.6.1 → 11.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (420) hide show

package/Tests/Types/WebsiteRequest.test.ts ADDED Viewed

@@ -0,0 +1,230 @@
+import HTTPMethod from "../../Types/API/HTTPMethod";
+import Hostname from "../../Types/API/Hostname";
+import Protocol from "../../Types/API/Protocol";
+import Route from "../../Types/API/Route";
+import URL from "../../Types/API/URL";
+/*
+ * WebsiteRequest wraps axios, so axios is mocked and the assertions are about
+ * the wrapper's own decisions: which method it picks, which axios options it
+ * derives from its own option names, and the HEAD -> GET retry that exists
+ * because some servers answer HEAD with an error but GET with a page.
+ */
+const axiosMock: jest.Mock = jest.fn();
+jest.mock("axios", () => {
+  return {
+    __esModule: true,
+    default: (...args: Array<unknown>) => {
+      return axiosMock(...args);
+    },
+  };
+});
+import WebsiteRequest, { WebsiteResponse } from "../../Types/WebsiteRequest";
+const url: URL = new URL(
+  Protocol.HTTPS,
+  new Hostname("example.com"),
+  new Route("/index.html"),
+);
+type OkResponseFunction = (data?: {
+  status?: number;
+  body?: string;
+  headers?: Record<string, string>;
+}) => Record<string, unknown>;
+const okResponse: OkResponseFunction = (data?: {
+  status?: number;
+  body?: string;
+  headers?: Record<string, string>;
+}): Record<string, unknown> => {
+  return {
+    status: data?.status ?? 200,
+    data: data?.body ?? "<html><body>hello</body></html>",
+    headers: data?.headers ?? { "content-type": "text/html" },
+  };
+};
+describe("WebsiteRequest.fetch", () => {
+  beforeEach(() => {
+    axiosMock.mockReset();
+  });
+  test("should issue a GET with a default 5s timeout", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    await WebsiteRequest.fetch(url, {});
+    expect(axiosMock).toHaveBeenCalledTimes(1);
+    expect(axiosMock.mock.calls[0]![0]).toEqual(url.toString());
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      method: HTTPMethod.GET,
+      timeout: 5000,
+    });
+  });
+  test("should map the response onto the WebsiteResponse shape", async () => {
+    axiosMock.mockResolvedValue(
+      okResponse({
+        status: 201,
+        body: "<html>ok</html>",
+        headers: { server: "nginx" },
+      }),
+    );
+    const response: WebsiteResponse = await WebsiteRequest.fetch(url, {
+      headers: { "x-trace": "abc" },
+    });
+    expect(response.url).toBe(url);
+    expect(response.responseStatusCode).toEqual(201);
+    expect(response.responseHeaders).toEqual({ server: "nginx" });
+    expect(response.requestHeaders).toEqual({ "x-trace": "abc" });
+    expect(response.responseBody.toString()).toEqual("<html>ok</html>");
+    // A response that came back at all counts as online, whatever its status.
+    expect(response.isOnline).toBe(true);
+  });
+  test("should default requestHeaders to an empty object", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    const response: WebsiteResponse = await WebsiteRequest.fetch(url, {});
+    expect(response.requestHeaders).toEqual({});
+  });
+  test("should pass through an explicit timeout and headers", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    await WebsiteRequest.fetch(url, {
+      timeout: 12345,
+      headers: { authorization: "Bearer token" },
+    });
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      timeout: 12345,
+      headers: { authorization: "Bearer token" },
+    });
+  });
+  test("should use HEAD when asked", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    await WebsiteRequest.fetch(url, { isHeadRequest: true });
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      method: HTTPMethod.HEAD,
+    });
+  });
+  test("should set maxRedirects to 0 when redirects are not to be followed", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    await WebsiteRequest.fetch(url, { doNotFollowRedirects: true });
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({ maxRedirects: 0 });
+  });
+  test("should not set maxRedirects by default", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    await WebsiteRequest.fetch(url, {});
+    expect(axiosMock.mock.calls[0]![1]).not.toHaveProperty("maxRedirects");
+  });
+  test("should forward proxy agents when supplied", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    const httpAgent: unknown = { name: "http-agent" };
+    const httpsAgent: unknown = { name: "https-agent" };
+    await WebsiteRequest.fetch(url, {
+      httpAgent: httpAgent as never,
+      httpsAgent: httpsAgent as never,
+    });
+    expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+      httpAgent,
+      httpsAgent,
+    });
+  });
+  test("should not set agent options when none are supplied", async () => {
+    axiosMock.mockResolvedValue(okResponse());
+    await WebsiteRequest.fetch(url, {});
+    expect(axiosMock.mock.calls[0]![1]).not.toHaveProperty("httpAgent");
+    expect(axiosMock.mock.calls[0]![1]).not.toHaveProperty("httpsAgent");
+  });
+  describe("HEAD failure fallback", () => {
+    test("should retry with GET when a HEAD request fails", async () => {
+      /*
+       * Some servers reject HEAD (404/405) while serving the page fine over
+       * GET, so a failed HEAD must not be reported as the site being down.
+       */
+      axiosMock
+        .mockRejectedValueOnce(new Error("HEAD not allowed"))
+        .mockResolvedValueOnce(okResponse({ status: 200 }));
+      const response: WebsiteResponse = await WebsiteRequest.fetch(url, {
+        isHeadRequest: true,
+      });
+      expect(axiosMock).toHaveBeenCalledTimes(2);
+      expect(axiosMock.mock.calls[0]![1]).toMatchObject({
+        method: HTTPMethod.HEAD,
+      });
+      expect(axiosMock.mock.calls[1]![1]).toMatchObject({
+        method: HTTPMethod.GET,
+      });
+      expect(response.responseStatusCode).toEqual(200);
+    });
+    test("should preserve the other options on the retry", async () => {
+      axiosMock
+        .mockRejectedValueOnce(new Error("HEAD not allowed"))
+        .mockResolvedValueOnce(okResponse());
+      await WebsiteRequest.fetch(url, {
+        isHeadRequest: true,
+        timeout: 9000,
+        doNotFollowRedirects: true,
+        headers: { "x-trace": "abc" },
+      });
+      expect(axiosMock.mock.calls[1]![1]).toMatchObject({
+        method: HTTPMethod.GET,
+        timeout: 9000,
+        maxRedirects: 0,
+        headers: { "x-trace": "abc" },
+      });
+    });
+    test("should propagate the error when the GET retry also fails", async () => {
+      axiosMock
+        .mockRejectedValueOnce(new Error("HEAD not allowed"))
+        .mockRejectedValueOnce(new Error("site is down"));
+      await expect(
+        WebsiteRequest.fetch(url, { isHeadRequest: true }),
+      ).rejects.toThrow("site is down");
+      expect(axiosMock).toHaveBeenCalledTimes(2);
+    });
+    test("should not retry a failed GET request", async () => {
+      axiosMock.mockRejectedValue(new Error("site is down"));
+      await expect(WebsiteRequest.fetch(url, {})).rejects.toThrow(
+        "site is down",
+      );
+      expect(axiosMock).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/Tests/UI/Components/EntityFilterRoundTrip.test.tsx ADDED Viewed

@@ -0,0 +1,103 @@
+import EntityFilter from "../../../UI/Components/Filters/EntityFilter";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import Filter from "../../../UI/Components/Filters/Types/Filter";
+import FilterData from "../../../UI/Components/Filters/Types/FilterData";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
+import IsNull from "../../../Types/BaseDatabase/IsNull";
+import NotNull from "../../../Types/BaseDatabase/NotNull";
+import GenericObject from "../../../Types/GenericObject";
+import { cleanup, render, screen } from "@testing-library/react";
+import React from "react";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+/*
+ * `EntityFilter` encodes a single-entity "is not" as a one-item IncludesNone,
+ * because there is no dedicated NotEqual-for-entities operator. Reading that
+ * encoding back is what makes the operator survive a remount — which is every
+ * Back-navigation and every shared link.
+ *
+ * The read side used to only understand IsNull, NotNull and a bare string, so
+ * "is not" silently reverted to "is" (with its value dropped) the moment the
+ * component re-mounted: the URL still carried the right filter, but the UI
+ * disagreed with it.
+ */
+type Resource = GenericObject & { ownerId?: string };
+const FILTER: Filter<Resource> = {
+  key: "ownerId",
+  title: "Owner",
+  type: FieldType.Entity,
+  filterDropdownOptions: [
+    { label: "Alex", value: "user-1" },
+    { label: "Sam", value: "user-2" },
+  ],
+} as unknown as Filter<Resource>;
+type RenderWithFunction = (filterData: FilterData<Resource>) => void;
+const renderWith: RenderWithFunction = (
+  filterData: FilterData<Resource>,
+): void => {
+  render(
+    <EntityFilter<Resource>
+      filter={FILTER}
+      filterData={filterData}
+      onFilterChanged={jest.fn()}
+    />,
+  );
+};
+describe("EntityFilter operator round trip", () => {
+  afterEach(() => {
+    cleanup();
+  });
+  test("a bare id reads back as 'is'", () => {
+    renderWith({ ownerId: "user-1" } as unknown as FilterData<Resource>);
+    expect(screen.getByText("is")).toBeTruthy();
+  });
+  test("a one-item IncludesNone reads back as 'is not', not 'is'", () => {
+    renderWith({
+      ownerId: new IncludesNone(["user-1"]),
+    } as unknown as FilterData<Resource>);
+    expect(screen.getByText("is not")).toBeTruthy();
+  });
+  test("the selected entity survives alongside the 'is not' operator", () => {
+    renderWith({
+      ownerId: new IncludesNone(["user-1"]),
+    } as unknown as FilterData<Resource>);
+    expect(screen.getByText("Alex")).toBeTruthy();
+  });
+  test("IsNull reads back as 'is empty'", () => {
+    renderWith({ ownerId: new IsNull() } as unknown as FilterData<Resource>);
+    expect(screen.getByText("is empty")).toBeTruthy();
+  });
+  test("NotNull reads back as 'is not empty'", () => {
+    renderWith({ ownerId: new NotNull() } as unknown as FilterData<Resource>);
+    expect(screen.getByText("is not empty")).toBeTruthy();
+  });
+  test("no value at all falls back to 'is'", () => {
+    renderWith({} as unknown as FilterData<Resource>);
+    expect(screen.getByText("is")).toBeTruthy();
+  });
+  test("an empty IncludesNone still selects the 'is not' operator", () => {
+    renderWith({
+      ownerId: new IncludesNone([]),
+    } as unknown as FilterData<Resource>);
+    expect(screen.getByText("is not")).toBeTruthy();
+  });
+});