@oneuptime/common 12.0.34 → 13.0.0

package/Tests/Types/Telemetry/InventoryLiveness.test.ts

@@ -0,0 +1,99 @@
+import EntitySource from "../../../Types/Telemetry/EntitySource";
+import {
+  InventoryLiveness,
+  INVENTORY_LIVE_WINDOW_MINUTES,
+  INVENTORY_STALE_AFTER_MINUTES,
+  getInventoryLivenessState,
+} from "../../../Types/Telemetry/InventoryLiveness";
+
+const NOW: Date = new Date("2026-09-07T12:00:00.000Z");
+
+describe("inventory heartbeat classification", () => {
+  test.each([
+    [-60_000, InventoryLiveness.Live],
+    [0, InventoryLiveness.Live],
+    [30 * 60_000, InventoryLiveness.Live],
+    [31 * 60_000 - 1, InventoryLiveness.Live],
+    [31 * 60_000, InventoryLiveness.Recent],
+    [31 * 60_000 + 1, InventoryLiveness.Recent],
+    [1440 * 60_000, InventoryLiveness.Recent],
+    [1441 * 60_000 - 1, InventoryLiveness.Recent],
+    [1441 * 60_000, InventoryLiveness.Stale],
+    [1441 * 60_000 + 1, InventoryLiveness.Stale],
+    [365 * 24 * 60 * 60_000, InventoryLiveness.Stale],
+  ])(
+    "an age of %s ms has status %s",
+    (age: number, status: InventoryLiveness) => {
+      expect(
+        getInventoryLivenessState({
+          source: EntitySource.Discovered,
+          lastSeenAt: new Date(NOW.getTime() - age),
+          now: NOW,
+        }),
+      ).toBe(status);
+    },
+  );
+
+  test.each([undefined, null, "not-a-date", new Date(NaN)])(
+    "an absent or invalid discovered heartbeat is never seen (%s)",
+    (lastSeenAt: Date | string | undefined | null) => {
+      expect(
+        getInventoryLivenessState({
+          source: EntitySource.Discovered,
+          lastSeenAt,
+          now: NOW,
+        }),
+      ).toBe(InventoryLiveness.Never);
+    },
+  );
+
+  test.each([
+    EntitySource.Inventory,
+    EntitySource.Manual,
+    "unknown",
+    undefined,
+  ])("%s is never aged as telemetry", (source: string | undefined) => {
+    for (const lastSeenAt of [
+      undefined,
+      null,
+      "not-a-date",
+      NOW,
+      new Date("2000-01-01T00:00:00.000Z"),
+    ]) {
+      expect(getInventoryLivenessState({ source, lastSeenAt, now: NOW })).toBe(
+        InventoryLiveness.NotTracked,
+      );
+    }
+  });
+
+  test("serialized dates and Date objects classify identically", () => {
+    for (const minutes of [0, 30, 31, 1440, 1441]) {
+      const lastSeenAt: Date = new Date(NOW.getTime() - minutes * 60_000);
+      expect(
+        getInventoryLivenessState({
+          source: EntitySource.Discovered,
+          lastSeenAt: lastSeenAt.toISOString(),
+          now: NOW,
+        }),
+      ).toBe(
+        getInventoryLivenessState({
+          source: EntitySource.Discovered,
+          lastSeenAt,
+          now: NOW,
+        }),
+      );
+    }
+  });
+
+  test("thresholds retain the established inventory badge vocabulary", () => {
+    expect(INVENTORY_LIVE_WINDOW_MINUTES).toBe(30);
+    expect(INVENTORY_STALE_AFTER_MINUTES).toBe(1440);
+    expect(Object.values(InventoryLiveness)).toEqual([
+      "live",
+      "recent",
+      "stale",
+      "never",
+      "not-tracked",
+    ]);
+  });
+});

package/Tests/UI/Components/CustomFields/CustomFieldsDetail.test.tsx

@@ -78,7 +78,9 @@ import CustomFieldsDetail from "../../../../UI/Components/CustomFields/CustomFie
 import BaseModel from "../../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import Incident from "../../../../Models/DatabaseModels/Incident";
 import IncidentCustomField from "../../../../Models/DatabaseModels/IncidentCustomField";
+import { CardButtonSchema } from "../../../../UI/Components/Card/Card";
 import CustomFieldType from "../../../../Types/CustomField/CustomFieldType";
+import IconProp from "../../../../Types/Icon/IconProp";
 import { JSONObject } from "../../../../Types/JSON";
 import ObjectID from "../../../../Types/ObjectID";
 
@@ -153,6 +155,8 @@ const resolveListWith: ResolveListFunction = (data: Array<BaseModel>): void => {
 interface RenderOptions {
   hideIfEmpty?: boolean | undefined;
   isEditable?: boolean | undefined;
+  additionalButtons?: Array<CardButtonSchema> | undefined;
+  onValuesLoaded?: ((customFields: JSONObject) => void) | undefined;
 }
 
 type RenderCardFunction = (options?: RenderOptions) => void;
@@ -169,6 +173,8 @@ const renderCard: RenderCardFunction = (options?: RenderOptions): void => {
       modelId={INCIDENT_ID}
       hideIfEmpty={options?.hideIfEmpty}
       isEditable={options?.isEditable}
+      additionalButtons={options?.additionalButtons}
+      onValuesLoaded={options?.onValuesLoaded}
     />,
   );
 };
@@ -717,3 +723,157 @@ describe("CustomFieldsDetail - a rejected save", () => {
     expect(container).toBeEmptyDOMElement();
   });
 });
+
+/*
+ * Both props exist for the Monitor Template's Custom Field Defaults card
+ * (issue #3548), which needs a second button — "Sync Custom Fields to Linked
+ * Monitors" — and needs to word and enable that button from the values this
+ * card has actually loaded.
+ */
+describe("CustomFieldsDetail - additionalButtons", () => {
+  const buildSyncButton: (onClick: () => void) => CardButtonSchema = (
+    onClick: () => void,
+  ): CardButtonSchema => {
+    return {
+      title: "Sync Custom Fields",
+      icon: IconProp.Refresh,
+      onClick: onClick,
+    };
+  };
+
+  test("renders beside the edit button and calls back when clicked", async () => {
+    const onSyncClick: MockFunction = getJestMockFunction();
+    resolveListWith(buildSchema([{ name: "Vendor" }]));
+    getItemMock.mockResolvedValue(buildIncident({ Vendor: "Cisco" }) as never);
+
+    renderCard({
+      additionalButtons: [
+        buildSyncButton(() => {
+          onSyncClick();
+        }),
+      ],
+    });
+
+    expect(await screen.findByText("Edit Fields")).toBeInTheDocument();
+    const syncButton: HTMLElement = screen.getByText("Sync Custom Fields");
+
+    fireEvent.click(syncButton);
+
+    expect(onSyncClick).toHaveBeenCalledTimes(1);
+  });
+
+  /*
+   * A disabled extra button stays on screen: its tooltip is where the reason
+   * lives ("Set at least one default above before syncing"), and a button that
+   * vanishes takes the explanation with it.
+   */
+  test("honours disabled without removing the button", async () => {
+    const onSyncClick: MockFunction = getJestMockFunction();
+    resolveListWith(buildSchema([{ name: "Vendor" }]));
+    getItemMock.mockResolvedValue(buildIncident(undefined) as never);
+
+    renderCard({
+      additionalButtons: [
+        {
+          ...buildSyncButton(() => {
+            onSyncClick();
+          }),
+          disabled: true,
+        },
+      ],
+    });
+
+    fireEvent.click(await screen.findByText("Sync Custom Fields"));
+
+    expect(onSyncClick).not.toHaveBeenCalled();
+  });
+
+  /*
+   * The gating on "Edit Fields" is about whether there is anything to edit
+   * here. Whether a push to OTHER records is worth offering is the caller's
+   * question, and it still has an answer on a record with no values — that is
+   * exactly when the caller wants to say why the push is unavailable.
+   */
+  test("renders even when there is no edit button to sit beside", async () => {
+    resolveListWith([]);
+    getItemMock.mockResolvedValue(buildIncident(undefined) as never);
+
+    renderCard({
+      additionalButtons: [
+        buildSyncButton(() => {
+          // Nothing: this test is about the button existing.
+        }),
+      ],
+    });
+
+    expect(await screen.findByText(NO_FIELDS_MESSAGE)).toBeInTheDocument();
+    expect(screen.queryByText("Edit Fields")).not.toBeInTheDocument();
+    expect(screen.getByText("Sync Custom Fields")).toBeInTheDocument();
+  });
+});
+
+describe("CustomFieldsDetail - onValuesLoaded", () => {
+  test("reports the record's stored bag once the load settles", async () => {
+    const onValuesLoaded: MockFunction = getJestMockFunction();
+    resolveListWith(buildSchema([{ name: "Vendor" }]));
+    getItemMock.mockResolvedValue(buildIncident({ Vendor: "Cisco" }) as never);
+
+    renderCard({
+      onValuesLoaded: (customFields: JSONObject): void => {
+        onValuesLoaded(customFields);
+      },
+    });
+
+    await waitFor(() => {
+      expect(onValuesLoaded).toHaveBeenCalledWith({ Vendor: "Cisco" });
+    });
+  });
+
+  // A record with nothing stored is a value, not a missing callback.
+  test("reports an empty bag for a record with no custom fields", async () => {
+    const onValuesLoaded: MockFunction = getJestMockFunction();
+    resolveListWith(buildSchema([{ name: "Vendor" }]));
+    getItemMock.mockResolvedValue(buildIncident(undefined) as never);
+
+    renderCard({
+      onValuesLoaded: (customFields: JSONObject): void => {
+        onValuesLoaded(customFields);
+      },
+    });
+
+    await waitFor(() => {
+      expect(onValuesLoaded).toHaveBeenCalledWith({});
+    });
+  });
+
+  /*
+   * The reason this is a callback rather than something the caller fetches
+   * itself: an edit made in this card has to reach the caller, or its extra
+   * button goes on explaining a state that is two saves out of date.
+   */
+  test("reports again with the new values after a save", async () => {
+    const onValuesLoaded: MockFunction = getJestMockFunction();
+    resolveListWith(buildSchema([{ name: "Vendor" }]));
+    getItemMock.mockResolvedValue(buildIncident(undefined) as never);
+    updateByIdMock.mockResolvedValue(undefined as never);
+
+    renderCard({
+      onValuesLoaded: (customFields: JSONObject): void => {
+        onValuesLoaded(customFields);
+      },
+    });
+
+    await waitFor(() => {
+      expect(onValuesLoaded).toHaveBeenCalledWith({});
+    });
+
+    getItemMock.mockResolvedValue(buildIncident({ Vendor: "Cisco" }) as never);
+
+    fireEvent.click(await screen.findByText("Edit Fields"));
+    fireEvent.click(await screen.findByText("Save"));
+
+    await waitFor(() => {
+      expect(onValuesLoaded).toHaveBeenCalledWith({ Vendor: "Cisco" });
+    });
+  });
+});

package/Tests/UI/ReactRouterSingletonBuild.test.ts

@@ -0,0 +1,133 @@
+import { afterAll, describe, expect, test } from "@jest/globals";
+import childProcess from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+const REPOSITORY_ROOT: string = path.resolve(__dirname, "..", "..", "..");
+const COMMON_MODULES: string = path.join(
+  REPOSITORY_ROOT,
+  "Common",
+  "node_modules",
+);
+const ESBUILD_CONFIG: string = path.join(
+  REPOSITORY_ROOT,
+  "Common",
+  "UI",
+  "esbuild-config.js",
+);
+const APP_LINK: string = path.join(
+  REPOSITORY_ROOT,
+  "App/FeatureSet/Dashboard/src/Components/AppLink/AppLink.tsx",
+);
+const temporaryRoots: Array<string> = [];
+
+interface RenderResult {
+  html: string;
+  error: string;
+}
+
+/*
+ * PublicDashboard mounts its own router but reuses Dashboard widgets and their
+ * AppLink. Separate package installations otherwise create two router contexts.
+ * A mocked AppLink or Jest's react-router-dom module mapper hides that failure,
+ * so bundle the actual link source against two physical router installations.
+ */
+function renderSharedLink(nodeEnv: string): RenderResult {
+  const root: string = fs.mkdtempSync(
+    path.join(os.tmpdir(), "oneuptime-router-"),
+  );
+  temporaryRoots.push(root);
+  fs.symlinkSync(COMMON_MODULES, path.join(root, "node_modules"), "dir");
+
+  for (const packageName of ["public", "shared"]) {
+    const moduleDirectory: string = path.join(
+      root,
+      packageName,
+      "node_modules",
+    );
+    fs.mkdirSync(moduleDirectory, { recursive: true });
+    for (const dependency of ["react-router", "react-router-dom"]) {
+      fs.cpSync(
+        path.join(COMMON_MODULES, dependency),
+        path.join(moduleDirectory, dependency),
+        { recursive: true, dereference: true },
+      );
+    }
+  }
+
+  fs.copyFileSync(APP_LINK, path.join(root, "shared", "AppLink.tsx"));
+  const entry: string = path.join(root, "public", "Entry.tsx");
+  fs.writeFileSync(
+    entry,
+    `
+      import React from "react";
+      import { MemoryRouter } from "react-router-dom";
+      import { renderToStaticMarkup } from "react-dom/server";
+      import AppLink from "../shared/AppLink";
+
+      globalThis.routerFixtureMarkup = renderToStaticMarkup(
+        <MemoryRouter initialEntries={["/public-dashboard"]}>
+          <AppLink to={{ toString: () => "/dashboard/monitors/example" }}>
+            Unit 0660 monitor
+          </AppLink>
+        </MemoryRouter>,
+      );
+    `,
+  );
+
+  const script: string = `
+    const path = require("path");
+    const configModule = require(${JSON.stringify(ESBUILD_CONFIG)});
+    const esbuild = require(require.resolve("esbuild", {
+      paths: [${JSON.stringify(COMMON_MODULES)}],
+    }));
+    const config = configModule.createConfig({
+      serviceName: "PublicDashboard",
+      publicPath: "/public-dashboard/dist/",
+      entryPoint: ${JSON.stringify(entry)},
+    });
+    config.write = false;
+    config.splitting = false;
+    config.format = "cjs";
+    config.sourcemap = false;
+    config.logLevel = "silent";
+
+    esbuild.build(config).then((result) => {
+      const output = result.outputFiles[0].text;
+      new Function("require", "module", "exports", output)(require, { exports: {} }, {});
+      console.log(JSON.stringify({ html: globalThis.routerFixtureMarkup, error: "" }));
+    }).catch((error) => {
+      console.log(JSON.stringify({ html: "", error: String(error) }));
+    });
+  `;
+
+  return JSON.parse(
+    childProcess.execFileSync(process.execPath, ["-e", script], {
+      cwd: REPOSITORY_ROOT,
+      env: { ...process.env, NODE_ENV: nodeEnv },
+      encoding: "utf8",
+      timeout: 120000,
+      maxBuffer: 1024 * 1024,
+    }),
+  ) as RenderResult;
+}
+
+afterAll(() => {
+  for (const root of temporaryRoots) {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+describe("shared public dashboard router context", () => {
+  test.each(["production", "development"])(
+    "renders the real shared AppLink inside the public router in %s",
+    (nodeEnv: string) => {
+      const result: RenderResult = renderSharedLink(nodeEnv);
+      expect(result.error).toBe("");
+      expect(result.html).toContain('href="/dashboard/monitors/example"');
+      expect(result.html).toContain("Unit 0660 monitor");
+    },
+    180000,
+  );
+});

package/Tests/UI/Rum/ReplayHeader.test.tsx

@@ -139,6 +139,14 @@ describe("ReplayHeader", () => {
     });
   });
 
+  /*
+   * The clock is its own right-hand block since the header redesign: the
+   * wall-clock time leads on its own line, with the start date and the
+   * "playhead / length" pair under it. It used to be one inline run
+   * where the offset pair needed parentheses to stay legible; the pair
+   * is asserted without them now, and the wall clock is asserted from
+   * its own element either way.
+   */
   describe("clock", () => {
     it("shows the playhead as wall-clock time next to the offset and the length", () => {
       render(<ReplayHeader {...makeProps()} />);
@@ -148,7 +156,7 @@ describe("ReplayHeader", () => {
         "10:13:22",
       );
       expect(screen.getByTestId("replay-header-clock")).toHaveTextContent(
-        "(0:41 / 4:12)",
+        "0:41 / 4:12",
       );
     });
 
@@ -162,7 +170,7 @@ describe("ReplayHeader", () => {
         /Invalid/,
       );
       expect(screen.getByTestId("replay-header-clock")).toHaveTextContent(
-        "(0:41 / 4:12)",
+        "0:41 / 4:12",
       );
     });