@oneuptime/common 11.6.1 → 11.7.0

package/Tests/UI/Utils/TableViewUrlState.test.ts

@@ -0,0 +1,272 @@
+import TableViewUrlState, {
+  MaxItemsOnPage,
+  TableViewUrlStateData,
+} from "../../../UI/Utils/TableViewUrlState";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The `view` slice carries the parts of a table's state that aren't column
+ * filters: the search box, its label chips, the active sort and where the user
+ * is in the pagination.
+ *
+ * Two properties matter and are pinned here:
+ *
+ *  1. Defaults are never written. A table nobody has touched must contribute
+ *     no query params at all, otherwise every page in the app grows a tail of
+ *     noise the first time it renders.
+ *  2. Every field is validated independently on the way back in. The param is
+ *     user-editable, so `?...-view={"page":"drop table"}` has to degrade to
+ *     "no page", not to a broken table or a hostile value in the API call.
+ */
+
+describe("TableViewUrlState.toJSON", () => {
+  test("returns null when nothing differs from the defaults", () => {
+    expect(TableViewUrlState.toJSON({})).toBeNull();
+    expect(
+      TableViewUrlState.toJSON({
+        search: "",
+        labels: [],
+        page: 1,
+      }),
+    ).toBeNull();
+  });
+
+  test("treats a whitespace-only search as empty", () => {
+    expect(TableViewUrlState.toJSON({ search: "   " })).toBeNull();
+  });
+
+  test("includes a search term", () => {
+    expect(TableViewUrlState.toJSON({ search: "api" })).toEqual({
+      search: "api",
+    });
+  });
+
+  test("includes selected labels and drops empty ids", () => {
+    expect(TableViewUrlState.toJSON({ labels: ["a", "", "b"] })).toEqual({
+      labels: ["a", "b"],
+    });
+  });
+
+  test("omits the page when it is the first one", () => {
+    expect(TableViewUrlState.toJSON({ page: 1 })).toBeNull();
+    expect(TableViewUrlState.toJSON({ page: 3 })).toEqual({ page: 3 });
+  });
+
+  test("omits a sort that matches the table's own default", () => {
+    expect(
+      TableViewUrlState.toJSON(
+        { sortBy: "createdAt", sortOrder: SortOrder.Descending },
+        { sortBy: "createdAt", sortOrder: SortOrder.Descending },
+      ),
+    ).toBeNull();
+  });
+
+  test("includes a sort that differs from the default field", () => {
+    expect(
+      TableViewUrlState.toJSON(
+        { sortBy: "name", sortOrder: SortOrder.Ascending },
+        { sortBy: "createdAt", sortOrder: SortOrder.Descending },
+      ),
+    ).toEqual({ sortBy: "name", sortOrder: SortOrder.Ascending });
+  });
+
+  test("includes a sort that only differs by direction", () => {
+    expect(
+      TableViewUrlState.toJSON(
+        { sortBy: "createdAt", sortOrder: SortOrder.Ascending },
+        { sortBy: "createdAt", sortOrder: SortOrder.Descending },
+      ),
+    ).toEqual({ sortBy: "createdAt", sortOrder: SortOrder.Ascending });
+  });
+
+  test("includes a sort when the table had no default", () => {
+    expect(
+      TableViewUrlState.toJSON({
+        sortBy: "name",
+        sortOrder: SortOrder.Ascending,
+      }),
+    ).toEqual({ sortBy: "name", sortOrder: SortOrder.Ascending });
+  });
+
+  test("includes the page size only when one was supplied", () => {
+    expect(TableViewUrlState.toJSON({ itemsOnPage: 50 })).toEqual({
+      itemsOnPage: 50,
+    });
+    expect(TableViewUrlState.toJSON({ itemsOnPage: undefined })).toBeNull();
+  });
+
+  test("carries every field at once", () => {
+    expect(
+      TableViewUrlState.toJSON({
+        search: "api",
+        labels: ["label-1"],
+        sortBy: "name",
+        sortOrder: SortOrder.Descending,
+        page: 4,
+        itemsOnPage: 25,
+      }),
+    ).toEqual({
+      search: "api",
+      labels: ["label-1"],
+      sortBy: "name",
+      sortOrder: SortOrder.Descending,
+      page: 4,
+      itemsOnPage: 25,
+    });
+  });
+});
+
+describe("TableViewUrlState.fromJSON", () => {
+  test("returns an empty state for null / undefined / a non-object", () => {
+    expect(TableViewUrlState.fromJSON(null)).toEqual({});
+    expect(TableViewUrlState.fromJSON(undefined)).toEqual({});
+    expect(TableViewUrlState.fromJSON("nope" as unknown as JSONObject)).toEqual(
+      {},
+    );
+  });
+
+  test("reads a well-formed snapshot", () => {
+    expect(
+      TableViewUrlState.fromJSON({
+        search: "api",
+        labels: ["a", "b"],
+        sortBy: "name",
+        sortOrder: SortOrder.Descending,
+        page: 3,
+        itemsOnPage: 25,
+      }),
+    ).toEqual({
+      search: "api",
+      labels: ["a", "b"],
+      sortBy: "name",
+      sortOrder: SortOrder.Descending,
+      page: 3,
+      itemsOnPage: 25,
+    });
+  });
+
+  describe("hand-edited values are rejected field by field", () => {
+    test("a non-string search is dropped", () => {
+      expect(
+        TableViewUrlState.fromJSON({ search: 5 as unknown as string }).search,
+      ).toBeUndefined();
+    });
+
+    test("an empty search is dropped", () => {
+      expect(
+        TableViewUrlState.fromJSON({ search: "  " }).search,
+      ).toBeUndefined();
+    });
+
+    test("labels that aren't an array are dropped", () => {
+      expect(
+        TableViewUrlState.fromJSON({ labels: "a" as unknown as Array<string> })
+          .labels,
+      ).toBeUndefined();
+    });
+
+    test("non-string entries inside labels are dropped", () => {
+      expect(
+        TableViewUrlState.fromJSON({
+          labels: ["a", 5, null, "b"] as unknown as Array<string>,
+        }).labels,
+      ).toEqual(["a", "b"]);
+    });
+
+    test("an unrecognised sortOrder falls back to ascending", () => {
+      expect(
+        TableViewUrlState.fromJSON({
+          sortBy: "name",
+          sortOrder: "sideways" as unknown as SortOrder,
+        }),
+      ).toEqual({ sortBy: "name", sortOrder: SortOrder.Ascending });
+    });
+
+    test("a sortOrder without a sortBy is ignored", () => {
+      expect(
+        TableViewUrlState.fromJSON({ sortOrder: SortOrder.Descending }),
+      ).toEqual({});
+    });
+
+    test("a non-numeric page is dropped", () => {
+      expect(
+        TableViewUrlState.fromJSON({ page: "2" as unknown as number }).page,
+      ).toBeUndefined();
+    });
+
+    test("a zero or negative page is dropped", () => {
+      expect(TableViewUrlState.fromJSON({ page: 0 }).page).toBeUndefined();
+      expect(TableViewUrlState.fromJSON({ page: -4 }).page).toBeUndefined();
+    });
+
+    test("a fractional page is floored", () => {
+      expect(TableViewUrlState.fromJSON({ page: 3.9 }).page).toBe(3);
+    });
+
+    test("NaN and Infinity are dropped", () => {
+      expect(TableViewUrlState.fromJSON({ page: NaN }).page).toBeUndefined();
+      expect(
+        TableViewUrlState.fromJSON({ page: Infinity }).page,
+      ).toBeUndefined();
+    });
+
+    test("a page size above the cap is dropped rather than sent to the API", () => {
+      expect(
+        TableViewUrlState.fromJSON({ itemsOnPage: MaxItemsOnPage }).itemsOnPage,
+      ).toBe(MaxItemsOnPage);
+      expect(
+        TableViewUrlState.fromJSON({ itemsOnPage: MaxItemsOnPage + 1 })
+          .itemsOnPage,
+      ).toBeUndefined();
+      expect(
+        TableViewUrlState.fromJSON({ itemsOnPage: 10_000_000 }).itemsOnPage,
+      ).toBeUndefined();
+    });
+
+    test("one bad field does not discard the good ones", () => {
+      expect(
+        TableViewUrlState.fromJSON({
+          search: "api",
+          page: "not a page" as unknown as number,
+          itemsOnPage: -1,
+          sortBy: "name",
+          sortOrder: SortOrder.Descending,
+        }),
+      ).toEqual({
+        search: "api",
+        sortBy: "name",
+        sortOrder: SortOrder.Descending,
+      });
+    });
+
+    test("unknown keys are ignored entirely", () => {
+      expect(
+        TableViewUrlState.fromJSON({
+          search: "api",
+          somethingElse: "ignored",
+        } as unknown as JSONObject),
+      ).toEqual({ search: "api" });
+    });
+  });
+});
+
+describe("TableViewUrlState round trip", () => {
+  test("survives toJSON -> JSON -> fromJSON unchanged", () => {
+    const state: TableViewUrlStateData = {
+      search: "api gateway",
+      labels: ["label-1", "label-2"],
+      sortBy: "name",
+      sortOrder: SortOrder.Descending,
+      page: 7,
+      itemsOnPage: 50,
+    };
+
+    const json: JSONObject | null = TableViewUrlState.toJSON(state);
+
+    expect(
+      TableViewUrlState.fromJSON(JSON.parse(JSON.stringify(json))),
+    ).toEqual(state);
+  });
+});

package/Tests/Utils/Base64.test.ts

@@ -0,0 +1,51 @@
+import Base64 from "../../Utils/Base64";
+
+describe("Base64", () => {
+  describe("uint8ArrayToBase64Url", () => {
+    test("should encode bytes without padding characters", () => {
+      const bytes: Uint8Array = new Uint8Array([1, 2, 3, 4, 5]);
+      const encoded: string = Base64.uint8ArrayToBase64Url(bytes);
+
+      expect(encoded).not.toContain("=");
+      expect(encoded).toEqual("AQIDBAU");
+    });
+
+    test("should use url safe alphabet instead of + and /", () => {
+      // 0xFB 0xFF encodes to "+/8=" in standard base64.
+      const bytes: Uint8Array = new Uint8Array([0xfb, 0xff]);
+      const encoded: string = Base64.uint8ArrayToBase64Url(bytes);
+
+      expect(encoded).not.toContain("+");
+      expect(encoded).not.toContain("/");
+      expect(encoded).toEqual("-_8");
+    });
+
+    test("should return an empty string for empty input", () => {
+      expect(Base64.uint8ArrayToBase64Url(new Uint8Array([]))).toEqual("");
+    });
+  });
+
+  describe("base64UrlToUint8Array", () => {
+    test("should decode a url safe string back to the original bytes", () => {
+      const decoded: Uint8Array = Base64.base64UrlToUint8Array("-_8");
+
+      expect(Array.from(decoded)).toEqual([0xfb, 0xff]);
+    });
+
+    test("should return an empty array for empty input", () => {
+      expect(Array.from(Base64.base64UrlToUint8Array(""))).toEqual([]);
+    });
+  });
+
+  test("should round trip arbitrary bytes", () => {
+    const bytes: Uint8Array = new Uint8Array([
+      0, 1, 62, 63, 64, 127, 128, 200, 254, 255,
+    ]);
+
+    const roundTripped: Uint8Array = Base64.base64UrlToUint8Array(
+      Base64.uint8ArrayToBase64Url(bytes),
+    );
+
+    expect(Array.from(roundTripped)).toEqual(Array.from(bytes));
+  });
+});

package/Tests/Utils/Boolean.test.ts

@@ -0,0 +1,76 @@
+import BooleanUtil from "../../Utils/Boolean";
+
+describe("BooleanUtil", () => {
+  describe("isBoolean", () => {
+    test("should return true only for real booleans", () => {
+      expect(BooleanUtil.isBoolean(true)).toBe(true);
+      expect(BooleanUtil.isBoolean(false)).toBe(true);
+    });
+
+    test("should return false for boolean-ish values that are not booleans", () => {
+      expect(BooleanUtil.isBoolean("true")).toBe(false);
+      expect(BooleanUtil.isBoolean(1)).toBe(false);
+      expect(BooleanUtil.isBoolean(0)).toBe(false);
+      expect(BooleanUtil.isBoolean(null)).toBe(false);
+      expect(BooleanUtil.isBoolean(undefined)).toBe(false);
+      expect(BooleanUtil.isBoolean({})).toBe(false);
+    });
+  });
+
+  describe("convertToBoolean", () => {
+    test("should convert truthy values to true", () => {
+      expect(BooleanUtil.convertToBoolean(true)).toBe(true);
+      expect(BooleanUtil.convertToBoolean(1)).toBe(true);
+      expect(BooleanUtil.convertToBoolean("true")).toBe(true);
+      // Note: any non empty string is truthy, including "false".
+      expect(BooleanUtil.convertToBoolean("false")).toBe(true);
+      expect(BooleanUtil.convertToBoolean({})).toBe(true);
+    });
+
+    test("should convert falsy values to false", () => {
+      expect(BooleanUtil.convertToBoolean(false)).toBe(false);
+      expect(BooleanUtil.convertToBoolean(0)).toBe(false);
+      expect(BooleanUtil.convertToBoolean("")).toBe(false);
+      expect(BooleanUtil.convertToBoolean(null)).toBe(false);
+      expect(BooleanUtil.convertToBoolean(undefined)).toBe(false);
+    });
+  });
+
+  describe("canBeConvertedToBoolean", () => {
+    test("should accept the supported boolean representations", () => {
+      const supported: Array<any> = [
+        "true",
+        "false",
+        "1",
+        "0",
+        1,
+        0,
+        true,
+        false,
+      ];
+
+      for (const value of supported) {
+        expect(BooleanUtil.canBeConvertedToBoolean(value)).toBe(true);
+      }
+    });
+
+    test("should reject anything else", () => {
+      const unsupported: Array<any> = [
+        "TRUE",
+        "yes",
+        "no",
+        2,
+        -1,
+        "",
+        null,
+        undefined,
+        {},
+        [],
+      ];
+
+      for (const value of unsupported) {
+        expect(BooleanUtil.canBeConvertedToBoolean(value)).toBe(false);
+      }
+    });
+  });
+});

package/Tests/Utils/Crypto.test.ts

@@ -0,0 +1,48 @@
+import Crypto from "../../Utils/Crypto";
+
+describe("Crypto", () => {
+  describe("getMd5Hash", () => {
+    test("should return the known md5 hash of a string", () => {
+      expect(Crypto.getMd5Hash("hello")).toEqual(
+        "5d41402abc4b2a76b9719d911017c592",
+      );
+    });
+
+    test("should return a 32 character lowercase hex digest", () => {
+      expect(Crypto.getMd5Hash("oneuptime")).toMatch(/^[0-9a-f]{32}$/);
+    });
+
+    test("should be deterministic and case sensitive", () => {
+      expect(Crypto.getMd5Hash("OneUptime")).toEqual(
+        Crypto.getMd5Hash("OneUptime"),
+      );
+      expect(Crypto.getMd5Hash("OneUptime")).not.toEqual(
+        Crypto.getMd5Hash("oneuptime"),
+      );
+    });
+  });
+
+  describe("getSha256Hash", () => {
+    test("should return the known sha256 hash of a string", () => {
+      expect(Crypto.getSha256Hash("hello")).toEqual(
+        "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
+      );
+    });
+
+    test("should return a 64 character lowercase hex digest", () => {
+      expect(Crypto.getSha256Hash("oneuptime")).toMatch(/^[0-9a-f]{64}$/);
+    });
+
+    test("should hash the empty string", () => {
+      expect(Crypto.getSha256Hash("")).toEqual(
+        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      );
+    });
+  });
+
+  test("md5 and sha256 of the same input should differ", () => {
+    expect(Crypto.getMd5Hash("hello")).not.toEqual(
+      Crypto.getSha256Hash("hello"),
+    );
+  });
+});