@oneuptime/common 12.0.12 → 12.0.14

package/Tests/UI/Components/CommandPalette/PaletteFilter.test.ts

@@ -0,0 +1,234 @@
+import {
+  filterPaletteCommands,
+  getHighlightSegments,
+  getPaletteSectionId,
+  isSubsequenceMatch,
+  normalizePaletteQuery,
+  PaletteCommandMatch,
+  PaletteHighlightSegment,
+  PaletteMatchRank,
+  rankPaletteCommand,
+} from "../../../../UI/Components/CommandPalette/PaletteFilter";
+import { PaletteCommand } from "../../../../UI/Components/CommandPalette/Types";
+import { describe, expect, test } from "@jest/globals";
+
+type MakeCommandFunction = (
+  id: string,
+  title: string,
+  category: string,
+  keywords?: Array<string>,
+) => PaletteCommand;
+
+const makeCommand: MakeCommandFunction = (
+  id: string,
+  title: string,
+  category: string,
+  keywords?: Array<string>,
+): PaletteCommand => {
+  return {
+    id,
+    title,
+    category,
+    keywords,
+    onSelect: (): void => {},
+  };
+};
+
+describe("normalizePaletteQuery", () => {
+  test("trims whitespace and lowercases", () => {
+    expect(normalizePaletteQuery("  MoNiToRs  ")).toBe("monitors");
+    expect(normalizePaletteQuery("   ")).toBe("");
+  });
+});
+
+describe("isSubsequenceMatch", () => {
+  test("matches characters in order with gaps", () => {
+    expect(isSubsequenceMatch("mtr", "monitors")).toBe(true);
+  });
+
+  test("rejects characters out of order", () => {
+    expect(isSubsequenceMatch("rtm", "monitors")).toBe(false);
+  });
+
+  test("rejects characters that are missing entirely", () => {
+    expect(isSubsequenceMatch("xyz", "monitors")).toBe(false);
+  });
+
+  test("an empty needle matches anything", () => {
+    expect(isSubsequenceMatch("", "monitors")).toBe(true);
+  });
+});
+
+describe("rankPaletteCommand", () => {
+  test("title prefix wins over everything", () => {
+    const command: PaletteCommand = makeCommand("a", "Monitors", "Monitoring", [
+      "monitor",
+    ]);
+    expect(rankPaletteCommand(command, "mon")).toBe(
+      PaletteMatchRank.TitlePrefix,
+    );
+  });
+
+  test("title substring ranks below prefix", () => {
+    const command: PaletteCommand = makeCommand("a", "Create Monitor", "Other");
+    expect(rankPaletteCommand(command, "mon")).toBe(
+      PaletteMatchRank.TitleSubstring,
+    );
+  });
+
+  test("keyword match ranks below title matches", () => {
+    const command: PaletteCommand = makeCommand("a", "Uptime", "Other", [
+      "monitor",
+      "checks",
+    ]);
+    expect(rankPaletteCommand(command, "mon")).toBe(PaletteMatchRank.Keyword);
+  });
+
+  test("category match ranks below keyword", () => {
+    const command: PaletteCommand = makeCommand("a", "Stats", "Monitoring");
+    expect(rankPaletteCommand(command, "mon")).toBe(PaletteMatchRank.Category);
+  });
+
+  test("title subsequence is the last resort", () => {
+    // "mtr" is not a substring of anything here, but m→t→r appear in order.
+    const command: PaletteCommand = makeCommand("a", "Metrics", "Other");
+    expect(rankPaletteCommand(command, "mtr")).toBe(
+      PaletteMatchRank.TitleSubsequence,
+    );
+  });
+
+  test("no match at all returns null", () => {
+    const command: PaletteCommand = makeCommand("a", "Logs", "Telemetry");
+    expect(rankPaletteCommand(command, "zzz")).toBe(null);
+  });
+
+  test("matching is case-insensitive", () => {
+    const command: PaletteCommand = makeCommand("a", "MONITORS", "Other");
+    expect(rankPaletteCommand(command, "mon")).toBe(
+      PaletteMatchRank.TitlePrefix,
+    );
+  });
+});
+
+describe("filterPaletteCommands", () => {
+  test("orders results prefix > substring > keyword > category > subsequence", () => {
+    const commands: Array<PaletteCommand> = [
+      // Deliberately listed in reverse rank order to prove sorting happens.
+      makeCommand("subsequence", "Man on wire", "Zeta"),
+      makeCommand("category", "Stats", "Monitoring"),
+      makeCommand("keyword", "Uptime", "Other", ["monitor"]),
+      makeCommand("substring", "Create Monitor", "Other"),
+      makeCommand("prefix", "Monitors", "Other"),
+      makeCommand("excluded", "Logs", "Telemetry"),
+    ];
+
+    const matches: Array<PaletteCommandMatch> = filterPaletteCommands(
+      commands,
+      "mon",
+    );
+
+    expect(
+      matches.map((match: PaletteCommandMatch) => {
+        return match.command.id;
+      }),
+    ).toEqual(["prefix", "substring", "keyword", "category", "subsequence"]);
+  });
+
+  test("keeps catalog order within the same rank tier", () => {
+    const commands: Array<PaletteCommand> = [
+      makeCommand("first", "Monitors", "A"),
+      makeCommand("second", "Monitor Groups", "B"),
+      makeCommand("third", "Monitoring Secrets", "C"),
+    ];
+
+    const matches: Array<PaletteCommandMatch> = filterPaletteCommands(
+      commands,
+      "mon",
+    );
+
+    expect(
+      matches.map((match: PaletteCommandMatch) => {
+        return match.command.id;
+      }),
+    ).toEqual(["first", "second", "third"]);
+  });
+
+  test("an empty or whitespace query matches everything in original order", () => {
+    const commands: Array<PaletteCommand> = [
+      makeCommand("one", "Alpha", "A"),
+      makeCommand("two", "Beta", "B"),
+    ];
+
+    expect(
+      filterPaletteCommands(commands, "   ").map(
+        (match: PaletteCommandMatch) => {
+          return match.command.id;
+        },
+      ),
+    ).toEqual(["one", "two"]);
+  });
+
+  test("excludes commands that match nowhere", () => {
+    const commands: Array<PaletteCommand> = [
+      makeCommand("only", "Monitors", "Other"),
+      makeCommand("gone", "Logs", "Telemetry"),
+    ];
+
+    const matches: Array<PaletteCommandMatch> = filterPaletteCommands(
+      commands,
+      "monitors",
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0]!.command.id).toBe("only");
+  });
+});
+
+describe("getHighlightSegments", () => {
+  test("marks a single case-insensitive occurrence, preserving original casing", () => {
+    const segments: Array<PaletteHighlightSegment> = getHighlightSegments(
+      "Monitors",
+      "mon",
+    );
+
+    expect(segments).toEqual([
+      { text: "Mon", isMatch: true },
+      { text: "itors", isMatch: false },
+    ]);
+  });
+
+  test("marks every occurrence", () => {
+    const segments: Array<PaletteHighlightSegment> = getHighlightSegments(
+      "on and on",
+      "on",
+    );
+
+    expect(segments).toEqual([
+      { text: "on", isMatch: true },
+      { text: " and ", isMatch: false },
+      { text: "on", isMatch: true },
+    ]);
+  });
+
+  test("no occurrence yields one unmarked segment", () => {
+    expect(getHighlightSegments("Monitors", "zzz")).toEqual([
+      { text: "Monitors", isMatch: false },
+    ]);
+  });
+
+  test("an empty query yields one unmarked segment", () => {
+    expect(getHighlightSegments("Monitors", "  ")).toEqual([
+      { text: "Monitors", isMatch: false },
+    ]);
+  });
+});
+
+describe("getPaletteSectionId", () => {
+  test("slugs human titles for test ids", () => {
+    expect(getPaletteSectionId("Analytics & Automation")).toBe(
+      "analytics-automation",
+    );
+    expect(getPaletteSectionId("Essentials")).toBe("essentials");
+    expect(getPaletteSectionId("  Odd  Spacing  ")).toBe("odd-spacing");
+  });
+});

package/Tests/UI/Components/CommandPalette/RecentCommands.test.ts

@@ -0,0 +1,97 @@
+import {
+  readRecentCommandIds,
+  RECENT_COMMANDS_LIMIT,
+  writeRecentCommandId,
+} from "../../../../UI/Components/CommandPalette/RecentCommands";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+const STORAGE_KEY: string = "test-command-palette-recents";
+
+describe("RecentCommands storage", () => {
+  afterEach(() => {
+    window.localStorage.clear();
+    jest.restoreAllMocks();
+  });
+
+  test("reads back what was written, most recent first", () => {
+    writeRecentCommandId(STORAGE_KEY, "first");
+    writeRecentCommandId(STORAGE_KEY, "second");
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual(["second", "first"]);
+  });
+
+  test("re-selecting a command moves it to the front instead of duplicating", () => {
+    writeRecentCommandId(STORAGE_KEY, "a");
+    writeRecentCommandId(STORAGE_KEY, "b");
+    writeRecentCommandId(STORAGE_KEY, "a");
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual(["a", "b"]);
+  });
+
+  test(`keeps at most ${RECENT_COMMANDS_LIMIT} ids`, () => {
+    for (let index: number = 0; index < RECENT_COMMANDS_LIMIT + 3; index++) {
+      writeRecentCommandId(STORAGE_KEY, `command-${index}`);
+    }
+
+    const stored: Array<string> = readRecentCommandIds(STORAGE_KEY);
+
+    expect(stored).toHaveLength(RECENT_COMMANDS_LIMIT);
+    // Newest first; the earliest writes fell off the end.
+    expect(stored[0]).toBe(`command-${RECENT_COMMANDS_LIMIT + 2}`);
+  });
+
+  test("caps reads even when storage holds more ids than the limit", () => {
+    const oversized: Array<string> = [];
+    for (let index: number = 0; index < 20; index++) {
+      oversized.push(`command-${index}`);
+    }
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(oversized));
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toHaveLength(
+      RECENT_COMMANDS_LIMIT,
+    );
+  });
+
+  test("tolerates corrupt JSON", () => {
+    window.localStorage.setItem(STORAGE_KEY, "{not json[");
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual([]);
+  });
+
+  test("tolerates JSON that is not an array", () => {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify({ nope: true }));
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual([]);
+  });
+
+  test("filters non-string entries out of a stored array", () => {
+    window.localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify(["ok", 42, null, { id: "x" }, "also-ok"]),
+    );
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual(["ok", "also-ok"]);
+  });
+
+  test("an empty key reads as no recents", () => {
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual([]);
+  });
+
+  test("a throwing setItem (quota / private mode) is swallowed", () => {
+    jest.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
+      throw new Error("QuotaExceededError");
+    });
+
+    expect(() => {
+      writeRecentCommandId(STORAGE_KEY, "anything");
+    }).not.toThrow();
+  });
+
+  test("a throwing getItem is swallowed and reads as no recents", () => {
+    jest.spyOn(Storage.prototype, "getItem").mockImplementation(() => {
+      throw new Error("SecurityError");
+    });
+
+    expect(readRecentCommandIds(STORAGE_KEY)).toEqual([]);
+  });
+});

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

@@ -0,0 +1,198 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import "@testing-library/jest-dom";
+import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
+import React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * Side menus build `countQuery` (and `requestOptions`) as fresh object
+ * literals on every render, and section layouts re-render on every in-section
+ * navigation. Without a value-level guard every one of those re-renders
+ * re-issued the badge's POST /count - across the 43 badge usages that was 1-2
+ * redundant requests per navigation. These tests pin the guard's contract:
+ * value-equal props never refetch, a real value change does, and the global
+ * refresh event still forces a refetch regardless of the guard.
+ */
+
+/*
+ * Declared before jest.mock but dereferenced inside the factory: ts-jest
+ * hoists the jest.mock call above these initializers, so naming the mock
+ * directly in the factory would capture undefined.
+ */
+const countMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      count: (...args: Array<any>) => {
+        return countMock(...args);
+      },
+    },
+  };
+});
+
+/*
+ * SideMenuItem reads the active route off Navigation and UILink navigates
+ * through it; neither is what these tests are about.
+ */
+jest.mock("../../../UI/Utils/Navigation", () => {
+  return {
+    __esModule: true,
+    default: {
+      isOnThisPage: () => {
+        return false;
+      },
+      navigate: () => {
+        return undefined;
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Translation", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {
+        translateString: (value: string | undefined) => {
+          return value;
+        },
+        translateValue: (value: unknown) => {
+          return value;
+        },
+      };
+    },
+  };
+});
+
+import CountModelSideMenuItem, {
+  REFRESH_SIDEBAR_COUNT_EVENT,
+} from "../../../UI/Components/SideMenu/CountModelSideMenuItem";
+import { RequestOptions } from "../../../UI/Utils/ModelAPI/ModelAPI";
+import GlobalEvents from "../../../UI/Utils/GlobalEvents";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import Query from "../../../Types/BaseDatabase/Query";
+import Route from "../../../Types/API/Route";
+import Link from "../../../Types/Link";
+
+const link: Link = {
+  title: "Monitors",
+  to: new Route("/dashboard/monitors"),
+};
+
+type MakeQueryFunction = (name: string) => Query<Monitor>;
+
+/**
+ * A FRESH object every call - the point of these tests is that value-equal
+ * but identity-distinct props must not refetch, exactly what side menus
+ * produce on every parent render.
+ */
+const makeQuery: MakeQueryFunction = (name: string): Query<Monitor> => {
+  return { name: name } as Query<Monitor>;
+};
+
+type MakeRequestOptionsFunction = () => RequestOptions;
+
+const makeRequestOptions: MakeRequestOptionsFunction = (): RequestOptions => {
+  return {
+    requestHeaders: {
+      "x-badge": "1",
+    },
+  };
+};
+
+type RenderItemFunction = (
+  query: Query<Monitor>,
+  requestOptions?: RequestOptions,
+) => React.ReactElement;
+
+const renderItem: RenderItemFunction = (
+  query: Query<Monitor>,
+  requestOptions?: RequestOptions,
+): React.ReactElement => {
+  return (
+    <CountModelSideMenuItem<Monitor>
+      link={link}
+      modelType={Monitor}
+      countQuery={query}
+      requestOptions={requestOptions}
+    />
+  );
+};
+
+describe("CountModelSideMenuItem fetch guard", () => {
+  beforeEach(() => {
+    countMock.mockReset();
+    countMock.mockResolvedValue(5 as never);
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("re-rendering with a value-equal but identity-fresh query fetches exactly once", async () => {
+    const { rerender } = render(
+      renderItem(makeQuery("active"), makeRequestOptions()),
+    );
+
+    // wait for the count to land so the initial fetch is fully settled.
+    await waitFor(() => {
+      expect(screen.getByText("5")).toBeInTheDocument();
+    });
+    expect(countMock).toHaveBeenCalledTimes(1);
+
+    /*
+     * Simulate what section layouts do on every in-section navigation: a
+     * re-render where countQuery and requestOptions are brand-new objects
+     * with identical contents.
+     */
+    rerender(renderItem(makeQuery("active"), makeRequestOptions()));
+    rerender(renderItem(makeQuery("active"), makeRequestOptions()));
+
+    // effects flushed synchronously by RTL's act - still exactly one fetch.
+    expect(countMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("a value-level change to the query refetches with the new query", async () => {
+    const { rerender } = render(renderItem(makeQuery("active")));
+
+    await waitFor(() => {
+      expect(countMock).toHaveBeenCalledTimes(1);
+    });
+
+    rerender(renderItem(makeQuery("resolved")));
+
+    await waitFor(() => {
+      expect(countMock).toHaveBeenCalledTimes(2);
+    });
+
+    // the refetch must carry the NEW query, not a stale closure.
+    const secondCallArgs: any = countMock.mock.calls[1]![0];
+    expect(secondCallArgs.query).toEqual({ name: "resolved" });
+    expect(secondCallArgs.modelType).toBe(Monitor);
+  });
+
+  test("the global refresh event still forces a refetch even when the query is unchanged", async () => {
+    render(renderItem(makeQuery("active")));
+
+    await waitFor(() => {
+      expect(countMock).toHaveBeenCalledTimes(1);
+    });
+
+    await act(async () => {
+      GlobalEvents.dispatchEvent(REFRESH_SIDEBAR_COUNT_EVENT);
+    });
+
+    await waitFor(() => {
+      expect(countMock).toHaveBeenCalledTimes(2);
+    });
+  });
+});

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

@@ -6,7 +6,7 @@ import getJestMockFunction, { MockFunction } from "../../MockType";
 
 const markdownViewerMock: MockFunction = getJestMockFunction();
 
-jest.mock("../../../UI/Components/Markdown.tsx/MarkdownViewer", () => {
+jest.mock("../../../UI/Components/Markdown.tsx/LazyMarkdownViewer", () => {
   return {
     __esModule: true,
     default: (props: MarkdownViewerProps): React.ReactElement => {