@oneuptime/common 12.0.12 → 12.0.13

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

@@ -54,9 +54,44 @@ describe("MasterPage", () => {
   });
 
   it("should render correctly with makeTopSectionUnstick", () => {
-    render(<MasterPage {...defaultProps} makeTopSectionUnstick />);
+    render(
+      <MasterPage
+        {...defaultProps}
+        header={<div>Header</div>}
+        makeTopSectionUnstick
+      />,
+    );
 
     const topSection: HTMLElement = screen.getByRole("banner").parentElement!;
     expect(topSection).not.toHaveClass("sticky");
   });
+
+  it("should render the top section when it has a header or a navbar", () => {
+    const { rerender } = render(
+      <MasterPage {...defaultProps} header={<div>Header</div>} />,
+    );
+    expect(screen.getByRole("banner")).toBeInTheDocument();
+
+    rerender(<MasterPage {...defaultProps} navBar={<div>NavBar</div>} />);
+    expect(screen.getByRole("banner")).toBeInTheDocument();
+  });
+
+  /*
+   * The status page renders its own header and navbar inside children and
+   * passes neither prop. Rendering the top section anyway left an empty white
+   * bar with a drop shadow above the content.
+   */
+  it("should not render an empty top section when it has neither", () => {
+    render(<MasterPage {...defaultProps} />);
+
+    expect(screen.queryByRole("banner")).not.toBeInTheDocument();
+  });
+
+  it("should not render the top section when its only header is hidden", () => {
+    render(
+      <MasterPage {...defaultProps} header={<div>Header</div>} hideHeader />,
+    );
+
+    expect(screen.queryByRole("banner")).not.toBeInTheDocument();
+  });
 });

package/Tests/Utils/Monitor/MonitorMetricType.test.ts

@@ -1,7 +1,9 @@
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
 import { CheckOn } from "../../../Types/Monitor/CriteriaFilter";
 import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
-import MonitorType from "../../../Types/Monitor/MonitorType";
+import MonitorType, {
+  MonitorTypeHelper,
+} from "../../../Types/Monitor/MonitorType";
 import MonitorMetricTypeUtil, {
   MonitorMetricCategory,
 } from "../../../Utils/Monitor/MonitorMetricType";
@@ -333,3 +335,66 @@ describe("invariant: every displayed metric resolves its metadata", () => {
     }
   });
 });
+
+/*
+ * Regression suite for https://github.com/OneUptime/oneuptime/issues/3225.
+ *
+ * SSLCertificate was missing from getMonitorMetricTypesByMonitorType, so it
+ * fell through to `return []`. getMonitorMetricCategoriesByMonitorType
+ * short-circuits on an empty metric list and the dashboard hides the whole
+ * Monitor Metrics tab when there are no categories - so an SSL monitor
+ * showed no charts at all, even though IsOnline rows were being written to
+ * ClickHouse on every single check. An operator therefore had no way to see
+ * that their monitor was running, which is a large part of why the issue was
+ * reported as "the monitor never executes".
+ *
+ * The invariant test above cannot catch this: it iterates the metrics a type
+ * already lists, so an empty list passes vacuously.
+ */
+describe("SSL Certificate monitor metrics (issue #3225)", () => {
+  test("SSLCertificate reports IsOnline and ResponseTime", () => {
+    const metrics: Array<MonitorMetricType> =
+      MonitorMetricTypeUtil.getMonitorMetricTypesByMonitorType(
+        MonitorType.SSLCertificate,
+      );
+
+    expect(metrics).toContain(MonitorMetricType.IsOnline);
+    expect(metrics).toContain(MonitorMetricType.ResponseTime);
+  });
+
+  test("SSLCertificate produces at least one display category", () => {
+    const categories: Array<MonitorMetricCategory> =
+      MonitorMetricTypeUtil.getMonitorMetricCategoriesByMonitorType(
+        MonitorType.SSLCertificate,
+      );
+
+    // An empty list is what made the dashboard hide the metrics tab.
+    expect(categories.length).toBeGreaterThan(0);
+  });
+});
+
+describe("invariant: every probeable monitor type displays some metric", () => {
+  test("no probeable type falls through to an empty metric list", () => {
+    const typesWithoutMetrics: Array<MonitorType> = [];
+
+    for (const monitorType of ALL_MONITOR_TYPES) {
+      if (!MonitorTypeHelper.isProbableMonitor(monitorType)) {
+        continue;
+      }
+
+      const metrics: Array<MonitorMetricType> =
+        MonitorMetricTypeUtil.getMonitorMetricTypesByMonitorType(monitorType);
+
+      if (metrics.length === 0) {
+        typesWithoutMetrics.push(monitorType);
+      }
+    }
+
+    /*
+     * Asserting on the collected list rather than per-type so a failure
+     * names every offender at once - this is the structural hole that let
+     * SSLCertificate ship with no charts.
+     */
+    expect(typesWithoutMetrics).toEqual([]);
+  });
+});

package/Tests/Utils/Monitor/NetworkTopologyUtil.test.ts

@@ -13,6 +13,12 @@ describe("NetworkTopologyUtil.buildTopology", () => {
   const now: Date = new Date("2026-07-22T12:00:00Z");
   const fresh: Date = new Date("2026-07-22T11:55:00Z");
   const stale: Date = new Date("2026-07-22T11:30:00Z");
+  /*
+   * Past the shared staleness window (an hour at the default interval), so
+   * "we have stopped polling this entirely" rather than "the probe is a bit
+   * behind" — the distinction issue #3220 turned on.
+   */
+  const outOfContact: Date = new Date("2026-07-22T09:00:00Z");
 
   const makeDevice: (
     id: string,
@@ -155,12 +161,24 @@ describe("NetworkTopologyUtil.buildTopology", () => {
       expect(nodeById(result, "d3")!.status).toBe("up");
     });
 
-    it("derives device status from lastSeenAt freshness", () => {
+    it("derives device status from the outcome of the last poll", () => {
       const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
         [
-          makeDevice("d1", "fresh-device", { lastSeenAt: fresh }),
-          makeDevice("d2", "stale-device", { lastSeenAt: stale }),
-          makeDevice("d3", "never-seen", { lastSeenAt: undefined }),
+          makeDevice("d1", "answered", {
+            isReachable: true,
+            lastPolledAt: fresh,
+            lastSeenAt: fresh,
+          }),
+          makeDevice("d2", "did-not-answer", {
+            isReachable: false,
+            lastPolledAt: fresh,
+            lastSeenAt: outOfContact,
+          }),
+          makeDevice("d3", "never-polled", {
+            isReachable: undefined,
+            lastPolledAt: undefined,
+            lastSeenAt: undefined,
+          }),
         ],
         now,
       );
@@ -170,6 +188,75 @@ describe("NetworkTopologyUtil.buildTopology", () => {
       expect(nodeById(result, "d3")!.status).toBe("unknown");
     });
 
+    /*
+     * Issue #3220: the map drew a whole fleet red because its probe could
+     * not get round every device inside the old fixed 15-minute freshness
+     * window. A device that answered its last poll is up on the map however
+     * far behind the schedule has fallen.
+     */
+    it("issue #3220: a device that answered 30 minutes ago is still up on the map", () => {
+      const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
+        [
+          makeDevice("d1", "behind-schedule", {
+            isReachable: true,
+            lastPolledAt: stale,
+            lastSeenAt: stale,
+          }),
+        ],
+        now,
+      );
+
+      expect(nodeById(result, "d1")!.status).toBe("up");
+    });
+
+    /*
+     * A device nothing has polled for hours keeps its last known colour
+     * rather than being drawn as an outage. Repainting a whole map red
+     * because its probe stopped is the false-positive storm this change
+     * exists to remove; the staleness signal belongs on the device page,
+     * not in the graph's only three colours.
+     */
+    it("a device nothing has polled for hours keeps its last known colour", () => {
+      const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
+        [
+          makeDevice("d1", "out-of-contact", {
+            isReachable: true,
+            lastPolledAt: outOfContact,
+            lastSeenAt: outOfContact,
+          }),
+          makeDevice("d2", "out-of-contact-and-failing", {
+            isReachable: false,
+            lastPolledAt: outOfContact,
+            lastSeenAt: outOfContact,
+          }),
+        ],
+        now,
+      );
+
+      expect(nodeById(result, "d1")!.status).toBe("up");
+      expect(nodeById(result, "d2")!.status).toBe("down");
+    });
+
+    /*
+     * Rows written before the reachability columns existed carry only
+     * lastSeenAt; the map must keep drawing them from that until their next
+     * walk fills the rest in.
+     */
+    it("falls back to lastSeenAt for rows with no recorded poll outcome", () => {
+      const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
+        [
+          makeDevice("d1", "legacy-fresh", { lastSeenAt: fresh }),
+          makeDevice("d2", "legacy-out-of-contact", {
+            lastSeenAt: outOfContact,
+          }),
+        ],
+        now,
+      );
+
+      expect(nodeById(result, "d1")!.status).toBe("up");
+      expect(nodeById(result, "d2")!.status).toBe("down");
+    });
+
     it("merges the same link reported from both ends by both protocols", () => {
       const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
         [
@@ -762,7 +849,13 @@ describe("NetworkTopologyUtil.buildTopology", () => {
       expect(nodeById(result, "endpoint:ep-4")!.name).toBe("aa:00:00:00:00:04");
     });
 
-    it("derives endpoint status from lastSeenAt with the same freshness rule", () => {
+    /*
+     * Endpoints are ARP/FDB-learned hosts with no poll of their own, so
+     * freshness really is all there is. The window is the shared staleness
+     * one (an hour) rather than the old 15 minutes, so a host behind a
+     * switch its probe polls slowly does not blink out between walks.
+     */
+    it("derives endpoint status from lastSeenAt freshness", () => {
       const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
         [makeDevice("d1", "edge-1")],
         now,
@@ -774,7 +867,7 @@ describe("NetworkTopologyUtil.buildTopology", () => {
           }),
           makeEndpoint("ep-2", "aa:00:00:00:00:02", {
             attachedNetworkDeviceId: "d1",
-            lastSeenAt: stale,
+            lastSeenAt: outOfContact,
           }),
           makeEndpoint("ep-3", "aa:00:00:00:00:03", {
             attachedNetworkDeviceId: "d1",
@@ -788,6 +881,22 @@ describe("NetworkTopologyUtil.buildTopology", () => {
       expect(nodeById(result, "endpoint:ep-3")!.status).toBe("unknown");
     });
 
+    it("an endpoint seen half an hour ago is still up, not blinked out", () => {
+      const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
+        [makeDevice("d1", "edge-1")],
+        now,
+        [],
+        [
+          makeEndpoint("ep-1", "aa:00:00:00:00:01", {
+            attachedNetworkDeviceId: "d1",
+            lastSeenAt: stale,
+          }),
+        ],
+      );
+
+      expect(nodeById(result, "endpoint:ep-1")!.status).toBe("up");
+    });
+
     it("labels the port from the interface row, then falls back to if<index>", () => {
       const interfaces: Array<TopologyInterfaceInput> = [
         { networkDeviceId: "d1", interfaceIndex: 9, name: "Fa0/9" },