@oneuptime/common 12.0.34 → 13.0.1

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

@@ -46,6 +46,10 @@ describe("MANUAL_ENTITY_TYPES", () => {
     expect(MANUAL_ENTITY_TYPES.has(EntityType.Host)).toBe(false);
     expect(MANUAL_ENTITY_TYPES.has(EntityType.KubernetesPod)).toBe(false);
     expect(MANUAL_ENTITY_TYPES.has(EntityType.NetworkDevice)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.VMwareVCenter)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.VMwareVirtualMachine)).toBe(
+      false,
+    );
   });
 });
 
@@ -77,6 +81,21 @@ describe("INVENTORY_ENTITY_TYPES", () => {
       false,
     );
     expect(INVENTORY_ENTITY_TYPES.has(EntityType.ProxmoxGuest)).toBe(false);
+    /*
+     * VMware rows come purely from OTLP discovery (the vcenter receiver
+     * emits resources), not from a poller-fed inventory table — so they
+     * carry a heartbeat, are TTL-pruned, and must stay out of this set.
+     */
+    for (const entityType of [
+      EntityType.VMwareVCenter,
+      EntityType.VMwareCluster,
+      EntityType.VMwareHost,
+      EntityType.VMwareVirtualMachine,
+      EntityType.VMwareDatastore,
+    ]) {
+      expect(INVENTORY_ENTITY_TYPES.has(entityType)).toBe(false);
+      expect(isNonInventoryItemType(entityType)).toBe(false);
+    }
   });
 });
 

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/ColorPickerBuild.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "@jest/globals";
+import childProcess from "child_process";
+import path from "path";
+
+const COMMON_ROOT: string = path.resolve(__dirname, "..", "..");
+const PICKER_SOURCE: string = path.join(
+  COMMON_ROOT,
+  "UI/Components/Forms/Fields/ColorPicker.tsx",
+);
+const COLOR_CONTROL_MODULE: RegExp =
+  /^(lib|es)\/(components\/(chrome|common)\/|helpers\/)/;
+
+/*
+ * FormField reaches this component even on pages without a color field. The
+ * react-color barrel included every picker implementation in those pages'
+ * bundles. Build the actual component with the frontend configuration and
+ * inspect emitted modules, so tree-shaking and type-only imports are accounted
+ * for. A subprocess supplies the native Node environment esbuild requires.
+ */
+function bundledColorModules(nodeEnv: string): Array<string> {
+  const script: string = `
+    const path = require("path");
+    const commonRoot = ${JSON.stringify(COMMON_ROOT)};
+    const esbuild = require(require.resolve("esbuild", { paths: [commonRoot] }));
+    const { createConfig } = require(path.join(commonRoot, "UI/esbuild-config.js"));
+    const config = createConfig({
+      serviceName: "Dashboard",
+      publicPath: "/dashboard/dist/",
+      entryPoint: ${JSON.stringify(PICKER_SOURCE)},
+    });
+
+    esbuild.build({
+      ...config,
+      write: false,
+      sourcemap: false,
+      metafile: true,
+      logLevel: "silent",
+    }).then((result) => {
+      const included = new Set();
+      for (const output of Object.values(result.metafile.outputs)) {
+        for (const [input, contribution] of Object.entries(output.inputs)) {
+          if (contribution.bytesInOutput > 0 && input.includes("/react-color/")) {
+            included.add(input.split("/react-color/")[1]);
+          }
+        }
+      }
+      console.log(JSON.stringify([...included].sort()));
+    }).catch((error) => {
+      console.error(error);
+      process.exitCode = 1;
+    });
+  `;
+
+  return JSON.parse(
+    childProcess.execFileSync(process.execPath, ["-e", script], {
+      cwd: COMMON_ROOT,
+      env: { ...process.env, NODE_ENV: nodeEnv },
+      encoding: "utf8",
+      timeout: 60000,
+      maxBuffer: 1024 * 1024,
+    }),
+  ) as Array<string>;
+}
+
+describe("color picker frontend bundle", () => {
+  test.each(["production", "development"])(
+    "includes Chrome and shared controls without the other pickers in %s",
+    (nodeEnv: string) => {
+      const modules: Array<string> = bundledColorModules(nodeEnv);
+
+      expect(modules).toEqual(
+        expect.arrayContaining([
+          expect.stringMatching(/^(lib|es)\/components\/chrome\/Chrome\.js$/),
+          expect.stringMatching(
+            /^(lib|es)\/components\/common\/ColorWrap\.js$/,
+          ),
+        ]),
+      );
+      expect(
+        modules.filter((modulePath: string) => {
+          return !COLOR_CONTROL_MODULE.test(modulePath);
+        }),
+      ).toEqual([]);
+    },
+  );
+});

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

@@ -10,6 +10,38 @@ import renderer, {
 } from "react-test-renderer";
 
 describe("Breadcrumbs", () => {
+  test.each([1, 2, 5, 8])(
+    "keeps a %i-item trail visible and wrappable on small screens",
+    (count: number) => {
+      const links: Array<Link> = Array.from(
+        { length: count },
+        (_value: unknown, index: number): Link => {
+          return {
+            title: `Breadcrumb ${index}`,
+            to: new Route(`/page-${index}`),
+          };
+        },
+      );
+      const testRenderer: ReactTestRenderer = renderer.create(
+        <Breadcrumbs links={links} />,
+      );
+      const testInstance: ReactTestInstance = testRenderer.root;
+      const nav: ReactTestInstance = testInstance.findByType("nav");
+      const list: ReactTestInstance = testInstance.findByType("ol");
+
+      /*
+       * JSDOM does not apply Tailwind media queries. Assert the classes that
+       * control visibility and wrapping instead of a misleading visibility check.
+       */
+      expect(nav.props["className"].split(" ")).toContain("block");
+      expect(nav.props["className"]).not.toContain("hidden");
+      expect(list.props["className"].split(" ")).toContain("flex-wrap");
+      expect(nav.props["aria-label"]).toBe("Breadcrumb");
+      expect(testInstance.findAllByType("li")).toHaveLength(count);
+      testRenderer.unmount();
+    },
+  );
+
   test('Should render correctly and also contain "Home" and "Projects" string', () => {
     const links: Array<Link> = [
       {

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" });
+    });
+  });
+});