@oneuptime/common 12.0.13 → 12.0.14

package/Tests/App/Dashboard/DashboardCommandPalette.test.tsx

@@ -0,0 +1,338 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import "@testing-library/jest-dom";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+} from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * The flagship interaction of the command palette — press Cmd/Ctrl+K anywhere
+ * on the dashboard and the palette appears — lives entirely in the
+ * DashboardCommandPalette host: a document-level keydown listener plus a
+ * GlobalEvents subscription. The App suite runs in plain node and can only
+ * pin source patterns, so this suite actually mounts the host (real
+ * CommandPalette underneath, portal and all) and fires the real events.
+ *
+ * Escape/close-key semantics inside the open palette are deliberately NOT
+ * pinned here — they belong to the Common CommandPalette's own contract. This
+ * suite owns only the host's chord, its politeness rules, the global toggle
+ * event, and listener cleanup.
+ */
+
+const navigateMock: MockFunction = getJestMockFunction();
+const getListMock: MockFunction = getJestMockFunction();
+const getCurrentProjectIdMock: MockFunction = getJestMockFunction();
+const getAllPermissionsMock: MockFunction = getJestMockFunction();
+const isMasterAdminMock: MockFunction = getJestMockFunction();
+
+/*
+ * The arrow wrappers are load bearing: jest.mock is hoisted above the
+ * compiled requires, so the consts above are still in their temporal dead
+ * zone when the factory body runs. Dereferencing them lazily, at call time,
+ * is what works (same pattern as InvestigationPanel.test.tsx).
+ */
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string, defaultValue?: string): string => {
+          return defaultValue ?? key;
+        },
+      };
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (...args: Array<unknown>) => {
+        return getListMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Navigation", () => {
+  return {
+    __esModule: true,
+    default: {
+      navigate: (...args: Array<unknown>) => {
+        return navigateMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Permission", () => {
+  return {
+    __esModule: true,
+    default: {
+      getAllPermissions: (...args: Array<unknown>) => {
+        return getAllPermissionsMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: (...args: Array<unknown>) => {
+        return isMasterAdminMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Project", () => {
+  return {
+    __esModule: true,
+    default: {
+      getCurrentProjectId: (...args: Array<unknown>) => {
+        return getCurrentProjectIdMock(...args);
+      },
+    },
+  };
+});
+
+/*
+ * The real catalog hook walks the full RouteMap through useTranslation; the
+ * host only needs SOME catalog, so a single-page one keeps the suite about
+ * the host's event wiring rather than the NavBar's contents.
+ */
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Utils/NavigationItems",
+  () => {
+    const useDashboardNavigationItemsStub: () => unknown = (): unknown => {
+      /*
+       * Route is loaded lazily for the same hoisting reason as the mock
+       * functions above; requireActual keeps it the real class.
+       */
+      const RouteClass: typeof import("../../../Types/API/Route").default = (
+        jest.requireActual("../../../Types/API/Route") as {
+          default: typeof import("../../../Types/API/Route").default;
+        }
+      ).default;
+      return {
+        navItems: [
+          {
+            id: "home-nav-bar-item",
+            title: "Home",
+            icon: "Home",
+            route: new RouteClass("/dashboard/abc123/home"),
+          },
+        ],
+        moreMenuItems: [],
+        rightElement: {
+          id: "user-profile-nav-bar-item",
+          title: "User Profile",
+          description: "Your account",
+          icon: "User",
+          route: new RouteClass("/dashboard/user-profile/picture"),
+        },
+      };
+    };
+
+    // The App source consumes the hook as the module's default export.
+    return {
+      __esModule: true,
+      default: useDashboardNavigationItemsStub,
+      useDashboardNavigationItems: useDashboardNavigationItemsStub,
+    };
+  },
+);
+
+import DashboardCommandPalette from "../../../../App/FeatureSet/Dashboard/src/Components/CommandPalette/DashboardCommandPalette";
+import EventName from "../../../../App/FeatureSet/Dashboard/src/Utils/EventName";
+import GlobalEvents from "../../../UI/Utils/GlobalEvents";
+
+function palette(): HTMLElement | null {
+  return screen.queryByTestId("command-palette");
+}
+
+/*
+ * The chord is dispatched on document.body — where real key events land when
+ * no input is focused — and bubbles up to the host's document-level listener.
+ */
+function pressChord(init: KeyboardEventInit): void {
+  fireEvent.keyDown(document.body, init);
+}
+
+beforeEach(() => {
+  /*
+   * The open panel schedules an enter-transition frame (rAF + fallback
+   * timer); fake timers keep those under act()'s control.
+   */
+  jest.useFakeTimers();
+  getCurrentProjectIdMock.mockReturnValue(null);
+  getAllPermissionsMock.mockReturnValue([]);
+  isMasterAdminMock.mockReturnValue(false);
+  getListMock.mockResolvedValue({ data: [], count: 0 } as never);
+});
+
+afterEach(() => {
+  cleanup();
+  jest.clearAllTimers();
+  jest.useRealTimers();
+  navigateMock.mockReset();
+  getListMock.mockReset();
+  getCurrentProjectIdMock.mockReset();
+  getAllPermissionsMock.mockReset();
+  isMasterAdminMock.mockReset();
+});
+
+describe("DashboardCommandPalette Cmd/Ctrl+K chord", () => {
+  test("Cmd+K on the document opens the palette", () => {
+    render(<DashboardCommandPalette />);
+    expect(palette()).toBeNull();
+
+    pressChord({ key: "k", metaKey: true });
+
+    expect(palette()).toBeInTheDocument();
+  });
+
+  test("the same chord closes an open palette", () => {
+    render(<DashboardCommandPalette />);
+
+    pressChord({ key: "k", metaKey: true });
+    expect(palette()).toBeInTheDocument();
+
+    pressChord({ key: "k", metaKey: true });
+    expect(palette()).toBeNull();
+  });
+
+  test("Ctrl+K works exactly like Cmd+K (Windows/Linux)", () => {
+    render(<DashboardCommandPalette />);
+
+    pressChord({ key: "k", ctrlKey: true });
+    expect(palette()).toBeInTheDocument();
+
+    pressChord({ key: "k", ctrlKey: true });
+    expect(palette()).toBeNull();
+  });
+
+  test("a chord another handler already claimed (defaultPrevented) is ignored", () => {
+    render(<DashboardCommandPalette />);
+
+    /*
+     * A capture-phase window listener models "some earlier handler took this
+     * chord": it runs before the host's document listener and claims the
+     * event, exactly the situation defaultPrevented is checked for.
+     */
+    const claimChord: (event: KeyboardEvent) => void = (
+      event: KeyboardEvent,
+    ): void => {
+      event.preventDefault();
+    };
+    window.addEventListener("keydown", claimChord, { capture: true });
+
+    try {
+      pressChord({ key: "k", metaKey: true });
+      expect(palette()).toBeNull();
+    } finally {
+      window.removeEventListener("keydown", claimChord, { capture: true });
+    }
+
+    // And with the claimer gone the same chord opens the palette again.
+    pressChord({ key: "k", metaKey: true });
+    expect(palette()).toBeInTheDocument();
+  });
+
+  test("extra modifiers on the chord do not open the palette", () => {
+    render(<DashboardCommandPalette />);
+
+    pressChord({ key: "k", metaKey: true, shiftKey: true });
+    pressChord({ key: "k", ctrlKey: true, altKey: true });
+    pressChord({ key: "k" });
+
+    expect(palette()).toBeNull();
+  });
+});
+
+describe("DashboardCommandPalette global toggle event", () => {
+  test("the COMMAND_PALETTE_TOGGLE event toggles the palette", () => {
+    render(<DashboardCommandPalette />);
+    expect(palette()).toBeNull();
+
+    act((): void => {
+      GlobalEvents.dispatchEvent(EventName.COMMAND_PALETTE_TOGGLE);
+    });
+    expect(palette()).toBeInTheDocument();
+
+    act((): void => {
+      GlobalEvents.dispatchEvent(EventName.COMMAND_PALETTE_TOGGLE);
+    });
+    expect(palette()).toBeNull();
+  });
+});
+
+describe("DashboardCommandPalette listener cleanup", () => {
+  test("unmounting removes every document keydown listener it added, same references", () => {
+    const addSpy: ReturnType<typeof jest.spyOn> = jest.spyOn(
+      document,
+      "addEventListener",
+    );
+    const removeSpy: ReturnType<typeof jest.spyOn> = jest.spyOn(
+      document,
+      "removeEventListener",
+    );
+
+    try {
+      const view: ReturnType<typeof render> = render(
+        <DashboardCommandPalette />,
+      );
+
+      const addedKeydownListeners: Array<unknown> = addSpy.mock.calls
+        .filter((call: Array<unknown>): boolean => {
+          return call[0] === "keydown";
+        })
+        .map((call: Array<unknown>): unknown => {
+          return call[1];
+        });
+
+      // The host claims the chord at the document level while mounted.
+      expect(addedKeydownListeners.length).toBeGreaterThanOrEqual(1);
+
+      view.unmount();
+
+      const removedKeydownListeners: Array<unknown> = removeSpy.mock.calls
+        .filter((call: Array<unknown>): boolean => {
+          return call[0] === "keydown";
+        })
+        .map((call: Array<unknown>): unknown => {
+          return call[1];
+        });
+
+      /*
+       * Every added listener must be removed with the SAME function
+       * reference — an inline re-created arrow in the cleanup would leave
+       * the original behind and stack a listener per mount.
+       */
+      for (const listener of addedKeydownListeners) {
+        expect(removedKeydownListeners).toContain(listener);
+      }
+
+      // And a chord after unmount reaches nothing.
+      pressChord({ key: "k", metaKey: true });
+      expect(palette()).toBeNull();
+    } finally {
+      addSpy.mockRestore();
+      removeSpy.mockRestore();
+    }
+  });
+});

package/Tests/App/Dashboard/InvestigationPanel.test.tsx

@@ -60,7 +60,7 @@ jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
  * Record MarkdownViewer's props so safeMode remains an asserted part of the
  * contract even when the Common Jest config replaces its markdown renderer.
  */
-jest.mock("../../../UI/Components/Markdown.tsx/MarkdownViewer", () => {
+jest.mock("../../../UI/Components/Markdown.tsx/LazyMarkdownViewer", () => {
   return {
     __esModule: true,
     default: (props: MarkdownViewerProps): React.ReactElement => {

package/Tests/App/Dashboard/MonitorTypePicker.test.tsx

@@ -51,6 +51,15 @@ const search: SearchFunction = (value: string): void => {
   });
 };
 
+// Every type the catalog actually offers, in the order the picker lists them.
+const catalogTypeValues: Array<string> = categorizedOptions.flatMap(
+  (group: CardSelectOptionGroup) => {
+    return group.options.map((option: CardSelectOption) => {
+      return option.value;
+    });
+  },
+);
+
 type ShownTypesFunction = () => Array<string>;
 
 const shownTypes: ShownTypesFunction = (): Array<string> => {
@@ -231,6 +240,25 @@ describe("Monitor type picker", () => {
 
       expect(onChange).toHaveBeenCalledWith(MonitorType.Kubernetes);
     });
+
+    /*
+     * The e2e suite reaches a folded-away type by typing its MonitorType value
+     * into this box and then clicking card-select-option-<value>
+     * (selectMonitorTypeCard in E2E/Tests/Dashboard/Helpers/Monitors.ts). That
+     * only holds while every type's own value is a search term that finds it,
+     * which a renamed title or a reworded description can quietly break — and
+     * the only thing that would notice is a full release e2e run.
+     */
+    test.each(catalogTypeValues)(
+      "typing %s finds the card the e2e suite goes on to click",
+      (value: string) => {
+        renderPicker();
+
+        search(value);
+
+        expect(screen.getByTestId(`card-select-option-${value}`)).toBeVisible();
+      },
+    );
   });
 
   describe("coming back to a form that already has a type", () => {

package/Tests/Models/UserPushCriticalAlertColumn.test.ts

@@ -0,0 +1,172 @@
+/**
+ * UserPush.isCriticalAlertEnabled column contract.
+ *
+ * This is the one stored preference in the product whose purpose is to DEFEAT
+ * a choice the user made with a physical switch on their phone. Everything
+ * below pins a property that, quietly changed, either wakes people who did not
+ * ask to be woken or - far worse for an on-call product - stops waking people
+ * who did.
+ *
+ * The three "default" mechanisms are separate and easy to confuse:
+ * - NEW rows get false from the Postgres column default (@Column default)
+ * - EXISTING rows got false from the migration's NOT NULL DEFAULT false
+ * - @TableColumn defaultValue is documentation for the generated API schema
+ *   and forms; it defaults nothing at runtime
+ */
+
+import UserPush from "../../Models/DatabaseModels/UserPush";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import Permission from "../../Types/Permission";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import fs from "fs";
+import path from "path";
+
+const COLUMN: string = "isCriticalAlertEnabled";
+
+const MIGRATIONS_DIR: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+);
+
+const MIGRATION_CLASS: string = "MigrationName1787156982416";
+
+const MIGRATION_PATH: string = path.join(
+  MIGRATIONS_DIR,
+  "1787156982416-MigrationName.ts",
+);
+
+function metadata(): TableColumnMetadata {
+  return new UserPush().getTableColumnMetadata(COLUMN);
+}
+
+function typeOrmColumn(): ColumnMetadataArgs | undefined {
+  return getMetadataArgsStorage().columns.find((column: ColumnMetadataArgs) => {
+    return column.target === UserPush && column.propertyName === COLUMN;
+  });
+}
+
+describe("UserPush.isCriticalAlertEnabled", () => {
+  test("exists as a boolean column", () => {
+    expect(metadata()).toBeDefined();
+    expect(metadata().type).toBe(TableColumnType.Boolean);
+  });
+
+  test("a newly registered device does NOT override silent mode", () => {
+    /*
+     * The single most important assertion in this file. Overriding a silenced
+     * phone is opted into, never inherited: a responder who installs the app
+     * has not asked to be woken by it, and a default of true would make every
+     * existing user's phone start ringing through Do Not Disturb on upgrade.
+     */
+    expect(typeOrmColumn()).toBeDefined();
+    expect(typeOrmColumn()?.options.default).toBe(false);
+  });
+
+  test("every device that existed before this feature was backfilled as off", () => {
+    const migration: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+    expect(migration).toContain('ALTER TABLE "UserPush"');
+    expect(migration).toContain(
+      `ADD "${COLUMN}" boolean NOT NULL DEFAULT false`,
+    );
+  });
+
+  test("the migration is registered, so the column actually exists at runtime", () => {
+    /*
+     * A migration file missing from Index.ts never runs. The column would then
+     * be absent from Postgres while every select in the paging path asks for
+     * it, which fails the query that sends the page.
+     */
+    const index: string = fs.readFileSync(
+      path.join(MIGRATIONS_DIR, "Index.ts"),
+      "utf8",
+    );
+
+    // Imported AND listed in the exported array - the import alone does nothing.
+    expect(index.match(new RegExp(MIGRATION_CLASS, "g"))?.length).toBe(2);
+  });
+
+  test("the migration's down() removes the column", () => {
+    const migration: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+    expect(migration).toContain(
+      `ALTER TABLE "UserPush" DROP COLUMN "${COLUMN}"`,
+    );
+  });
+
+  test("is a default-value column, so existing create calls keep working", () => {
+    expect(new UserPush().isDefaultValueColumn(COLUMN)).toBe(true);
+    expect(metadata().required).toBeFalsy();
+  });
+
+  test("is documented as defaulting to off", () => {
+    expect(metadata().defaultValue).toBe(false);
+  });
+});
+
+describe("UserPush.isCriticalAlertEnabled access control", () => {
+  /*
+   * UserPush is an owner-only table: its table-level `read` names
+   * Permission.CurrentUser and nothing else, which is what scopes every read
+   * to the caller's own rows. A new column has to keep that shape or it
+   * becomes the exception that widens the table.
+   */
+  test("is readable only by the responder it belongs to", () => {
+    const read: Array<Permission> | undefined =
+      new UserPush().getColumnAccessControlFor(COLUMN)?.read;
+
+    expect(read).toEqual([Permission.CurrentUser]);
+  });
+
+  test("is settable at registration by the responder", () => {
+    const create: Array<Permission> | undefined =
+      new UserPush().getColumnAccessControlFor(COLUMN)?.create;
+
+    expect(create).toEqual([Permission.CurrentUser]);
+  });
+
+  test("cannot be written through the generic CRUD update surface", () => {
+    /*
+     * Every column on this model has an empty update list; writes go through
+     * the dedicated routes that check row ownership first and then act as
+     * root. Granting update here would let the flag be flipped by any path
+     * that can PUT the model, which is a wider surface than "the phone that
+     * owns this row".
+     */
+    const update: Array<Permission> | undefined =
+      new UserPush().getColumnAccessControlFor(COLUMN)?.update;
+
+    expect(update).toEqual([]);
+  });
+
+  test("does not widen the table's owner-only read scope", () => {
+    /*
+     * isAccessGrantedOnlyByCurrentUser is true exactly while the TABLE read
+     * list holds nothing but CurrentUser, and that is what stamps
+     * `userId = me` onto every read of this table. Adding a column must not
+     * disturb it.
+     */
+    expect(new UserPush().getReadPermissions()).toEqual([
+      Permission.CurrentUser,
+    ]);
+  });
+
+  test("is not marked readable through relation queries", () => {
+    /*
+     * canReadOnRelationQuery makes a column readable from a nested select on a
+     * model whose own read is admin-wide, skipping this table's column check
+     * entirely. isVerified - the column this one sits beside and is read
+     * alongside - does not set it, and neither does this: the paging path
+     * reads both as root, so nothing needs the flag.
+     */
+    expect(metadata().canReadOnRelationQuery).toBeFalsy();
+  });
+});