@oneuptime/common 14.0.1 → 14.0.2

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

@@ -0,0 +1,374 @@
+import Hostname from "../../../Types/API/Hostname";
+import URL from "../../../Types/API/URL";
+import { JSONObject } from "../../../Types/JSON";
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import Port from "../../../Types/Port";
+import MonitorOverviewTargetUtil, {
+  MonitorOverviewTarget,
+} from "../../../Utils/Monitor/MonitorOverviewTargetUtil";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * The hero shows what a monitor watches to every role that can open it, so
+ * the target line must identify the resource without leaking the secrets
+ * that monitor steps routinely carry: userinfo and tokens in URLs, and
+ * database credentials that sit right next to the host.
+ */
+
+const stepsOf: (...stepData: Array<JSONObject>) => MonitorSteps = (
+  ...stepData: Array<JSONObject>
+): MonitorSteps => {
+  return {
+    data: {
+      monitorStepsInstanceArray: stepData.map((data: JSONObject) => {
+        return { data: data };
+      }),
+    },
+  } as unknown as MonitorSteps;
+};
+
+const target: (
+  monitorType: MonitorType,
+  monitorSteps: MonitorSteps | undefined,
+  serverHostname?: string,
+) => MonitorOverviewTarget | null = (
+  monitorType: MonitorType,
+  monitorSteps: MonitorSteps | undefined,
+  serverHostname?: string,
+): MonitorOverviewTarget | null => {
+  return MonitorOverviewTargetUtil.getTarget({
+    monitorType: monitorType,
+    monitorSteps: monitorSteps,
+    serverHostname: serverHostname,
+  });
+};
+
+describe("MonitorOverviewTargetUtil.getTarget", () => {
+  it("Website shows the redacted URL", () => {
+    expect(
+      target(
+        MonitorType.Website,
+        stepsOf({
+          monitorDestination: "https://user:pass@shop.example.com/?ref=x#top",
+        }),
+      ),
+    ).toEqual({
+      value: "https://shop.example.com/",
+      isMono: true,
+      extraStepCount: 0,
+    });
+  });
+
+  it("Website reads a URL class instance", () => {
+    expect(
+      target(
+        MonitorType.Website,
+        stepsOf({
+          monitorDestination: URL.fromString(
+            "https://shop.example.com/health?key=secret",
+          ) as unknown as JSONObject,
+        }),
+      )?.value,
+    ).toBe("https://shop.example.com/health");
+  });
+
+  it("External status page shows the status page URL", () => {
+    expect(
+      target(
+        MonitorType.ExternalStatusPage,
+        stepsOf({
+          externalStatusPageMonitor: {
+            statusPageUrl: "https://status.vendor.com/?token=abc",
+          },
+        }),
+      )?.value,
+    ).toBe("https://status.vendor.com/");
+  });
+
+  it("SSL certificate shows the redacted URL", () => {
+    expect(
+      target(
+        MonitorType.SSLCertificate,
+        stepsOf({ monitorDestination: "https://secure.example.com" }),
+      )?.value,
+    ).toBe("https://secure.example.com");
+  });
+
+  it("API shows the method and the redacted URL", () => {
+    expect(
+      target(
+        MonitorType.API,
+        stepsOf({
+          requestType: "POST",
+          monitorDestination:
+            "https://api.example.com/v1/health?api_key=s3cr3t",
+        }),
+      ),
+    ).toEqual({
+      value: "POST https://api.example.com/v1/health",
+      isMono: true,
+      extraStepCount: 0,
+    });
+  });
+
+  it("Ping and IP show the host without userinfo", () => {
+    expect(
+      target(MonitorType.Ping, stepsOf({ monitorDestination: "10.0.0.5" }))
+        ?.value,
+    ).toBe("10.0.0.5");
+    expect(
+      target(
+        MonitorType.IP,
+        stepsOf({ monitorDestination: "admin@192.168.1.1" }),
+      )?.value,
+    ).toBe("192.168.1.1");
+  });
+
+  it("Port shows host:port", () => {
+    expect(
+      target(
+        MonitorType.Port,
+        stepsOf({
+          monitorDestination: Hostname.fromString(
+            "mail.example.com",
+          ) as unknown as JSONObject,
+          monitorDestinationPort: new Port(587) as unknown as JSONObject,
+        }),
+      )?.value,
+    ).toBe("mail.example.com:587");
+    expect(
+      target(MonitorType.Port, stepsOf({ monitorDestination: "db.local" }))
+        ?.value,
+    ).toBe("db.local");
+  });
+
+  it("DNS shows the record, the name and the resolver when one is set", () => {
+    expect(
+      target(
+        MonitorType.DNS,
+        stepsOf({
+          dnsMonitor: { queryName: "example.com", recordType: "MX" },
+        }),
+      )?.value,
+    ).toBe("MX example.com");
+    expect(
+      target(
+        MonitorType.DNS,
+        stepsOf({
+          dnsMonitor: {
+            queryName: "example.com",
+            recordType: "A",
+            hostname: "8.8.8.8",
+          },
+        }),
+      )?.value,
+    ).toBe("A example.com via 8.8.8.8");
+  });
+
+  it("Domain shows the domain name", () => {
+    expect(
+      target(
+        MonitorType.Domain,
+        stepsOf({ domainMonitor: { domainName: "example.org" } }),
+      )?.value,
+    ).toBe("example.org");
+  });
+
+  it("DNSSEC shows the domain name", () => {
+    expect(
+      target(
+        MonitorType.DNSSEC,
+        stepsOf({ dnssecMonitor: { domainName: "secure.example.org" } }),
+      )?.value,
+    ).toBe("secure.example.org");
+  });
+
+  it("SQL query and Database show engine · host:port/database", () => {
+    expect(
+      target(
+        MonitorType.SQLQuery,
+        stepsOf({
+          sqlMonitor: {
+            databaseType: "PostgreSQL",
+            host: "db.internal",
+            port: 5432,
+            databaseName: "orders",
+            username: "app",
+            password: "hunter2",
+          },
+        }),
+      )?.value,
+    ).toBe("PostgreSQL · db.internal:5432/orders");
+    expect(
+      target(
+        MonitorType.Database,
+        stepsOf({
+          databaseMonitor: {
+            databaseType: "MySQL",
+            host: "mysql.internal",
+            databaseName: "",
+          },
+        }),
+      )?.value,
+    ).toBe("MySQL · mysql.internal");
+  });
+
+  it("SQL target omits missing parts", () => {
+    expect(
+      target(
+        MonitorType.SQLQuery,
+        stepsOf({ sqlMonitor: { databaseName: "orders" } }),
+      )?.value,
+    ).toBe("orders");
+    expect(
+      target(MonitorType.SQLQuery, stepsOf({ sqlMonitor: {} })),
+    ).toBeNull();
+  });
+
+  it("SQL target never contains username or password", () => {
+    const value: string =
+      target(
+        MonitorType.SQLQuery,
+        stepsOf({
+          sqlMonitor: {
+            databaseType: "PostgreSQL",
+            host: "reporting:Sup3rS3cret@db.internal",
+            port: 5432,
+            databaseName: "orders",
+            username: "reporting",
+            password: "Sup3rS3cret",
+          },
+        }),
+      )?.value || "";
+
+    expect(value).toBe("PostgreSQL · db.internal:5432/orders");
+    expect(value).not.toContain("reporting");
+    expect(value).not.toContain("Sup3rS3cret");
+  });
+
+  it("Server shows the reported hostname", () => {
+    expect(
+      target(MonitorType.Server, stepsOf({}), "web-01.example.com"),
+    ).toEqual({ value: "web-01.example.com", isMono: true, extraStepCount: 0 });
+    expect(target(MonitorType.Server, stepsOf({}))).toBeNull();
+  });
+
+  it("scripted checks describe the script instead of a target", () => {
+    expect(target(MonitorType.SyntheticMonitor, stepsOf({}))).toEqual({
+      value: "Browser script",
+      isMono: false,
+      extraStepCount: 0,
+    });
+    expect(target(MonitorType.CustomJavaScriptCode, stepsOf({}))).toEqual({
+      value: "Custom script",
+      isMono: false,
+      extraStepCount: 0,
+    });
+  });
+
+  it.each([
+    MonitorType.NetworkDevice,
+    MonitorType.IncomingRequest,
+    MonitorType.IncomingEmail,
+    MonitorType.Logs,
+    MonitorType.Metrics,
+    MonitorType.Kubernetes,
+    MonitorType.Host,
+    MonitorType.Manual,
+  ])("%s has no target", (monitorType: MonitorType) => {
+    expect(
+      target(
+        monitorType,
+        stepsOf({ monitorDestination: "https://example.com" }),
+        "host-1",
+      ),
+    ).toBeNull();
+  });
+
+  it("extraStepCount", () => {
+    expect(
+      target(
+        MonitorType.Website,
+        stepsOf(
+          { monitorDestination: "https://a.example.com" },
+          { monitorDestination: "https://b.example.com" },
+          { monitorDestination: "https://c.example.com" },
+        ),
+      ),
+    ).toEqual({
+      value: "https://a.example.com",
+      isMono: true,
+      extraStepCount: 2,
+    });
+  });
+
+  it("malformed steps give null without throwing", () => {
+    expect(target(MonitorType.Website, undefined)).toBeNull();
+    expect(
+      target(MonitorType.Website, {
+        data: undefined,
+      } as unknown as MonitorSteps),
+    ).toBeNull();
+    expect(
+      target(MonitorType.API, {
+        data: { monitorStepsInstanceArray: "nope" },
+      } as unknown as MonitorSteps),
+    ).toBeNull();
+    expect(
+      target(MonitorType.API, {
+        data: { monitorStepsInstanceArray: [null] },
+      } as unknown as MonitorSteps),
+    ).toBeNull();
+    expect(
+      target(MonitorType.Website, stepsOf({ monitorDestination: { a: 1 } })),
+    ).toBeNull();
+    expect(target(MonitorType.DNS, stepsOf({ dnsMonitor: null }))).toBeNull();
+    expect(
+      target(MonitorType.Website, {
+        data: {
+          get monitorStepsInstanceArray(): never {
+            throw new Error("boom");
+          },
+        },
+      } as unknown as MonitorSteps),
+    ).toBeNull();
+  });
+});
+
+describe("MonitorOverviewTargetUtil.redactUrl", () => {
+  it("redactUrl strips userinfo, query and fragment", () => {
+    expect(
+      MonitorOverviewTargetUtil.redactUrl("https://user:pass@host/p?token=x#f"),
+    ).toBe("https://host/p");
+    expect(
+      MonitorOverviewTargetUtil.redactUrl("HTTPS://Admin@Host.example.com/x"),
+    ).toBe("HTTPS://Host.example.com/x");
+    expect(
+      MonitorOverviewTargetUtil.redactUrl("  https://host/p#only-fragment "),
+    ).toBe("https://host/p");
+  });
+
+  it("strips userinfo typed without a scheme", () => {
+    expect(
+      MonitorOverviewTargetUtil.redactUrl("user:pass@host.example.com/p"),
+    ).toBe("host.example.com/p");
+  });
+
+  it("leaves an @ in the path alone", () => {
+    expect(
+      MonitorOverviewTargetUtil.redactUrl("https://host/users/@alice"),
+    ).toBe("https://host/users/@alice");
+  });
+});
+
+describe("MonitorOverviewTargetUtil.redactHost", () => {
+  it("returns what follows the last @", () => {
+    expect(MonitorOverviewTargetUtil.redactHost("a@b@db.internal ")).toBe(
+      "db.internal",
+    );
+    expect(MonitorOverviewTargetUtil.redactHost("db.internal")).toBe(
+      "db.internal",
+    );
+  });
+});

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

@@ -0,0 +1,332 @@
+import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
+import MonitorStatusTimeline from "../../../Models/DatabaseModels/MonitorStatusTimeline";
+import Color from "../../../Types/Color";
+import ObjectID from "../../../Types/ObjectID";
+import MonitorStatusHistoryUtil, {
+  MonitorStatusChangeRow,
+} from "../../../Utils/Monitor/MonitorStatusHistoryUtil";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * The hero's "Operational for 3 days" and the "Recent status changes" card
+ * both read the newest few timeline rows. These pin when a duration may be
+ * claimed at all, and how an orphaned open row is kept from reading as
+ * still running.
+ */
+
+const NOW: Date = new Date("2026-09-21T12:00:00.000Z");
+const OPERATIONAL_ID: string = "22222222-2222-4222-8222-222222222222";
+const OFFLINE_ID: string = "44444444-4444-4444-8444-444444444444";
+
+const row: (data: {
+  id: string;
+  statusId: string;
+  statusName?: string;
+  color?: string;
+  startsAt: string;
+  endsAt?: string | undefined;
+}) => MonitorStatusTimeline = (data: {
+  id: string;
+  statusId: string;
+  statusName?: string;
+  color?: string;
+  startsAt: string;
+  endsAt?: string | undefined;
+}): MonitorStatusTimeline => {
+  const timeline: MonitorStatusTimeline = new MonitorStatusTimeline();
+  timeline._id = data.id;
+  timeline.monitorStatusId = new ObjectID(data.statusId);
+  timeline.startsAt = new Date(data.startsAt);
+
+  if (data.endsAt) {
+    timeline.endsAt = new Date(data.endsAt);
+  }
+
+  if (data.statusName) {
+    const status: MonitorStatus = new MonitorStatus();
+    status.name = data.statusName;
+
+    if (data.color) {
+      status.color = new Color(data.color);
+    }
+
+    timeline.monitorStatus = status;
+  }
+
+  return timeline;
+};
+
+const OPEN_OPERATIONAL: MonitorStatusTimeline = row({
+  id: "row-3",
+  statusId: OPERATIONAL_ID,
+  statusName: "Operational",
+  color: "#10B981",
+  startsAt: "2026-09-18T08:00:00.000Z",
+});
+
+describe("MonitorStatusHistoryUtil.getStatusSince", () => {
+  it("since only for a matching open newest row", () => {
+    expect(
+      MonitorStatusHistoryUtil.getStatusSince({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: OPEN_OPERATIONAL,
+        now: NOW,
+      })?.toISOString(),
+    ).toBe("2026-09-18T08:00:00.000Z");
+
+    // Another status in the newest row: drift, so no duration is claimed.
+    expect(
+      MonitorStatusHistoryUtil.getStatusSince({
+        currentStatusId: OFFLINE_ID,
+        latestRow: OPEN_OPERATIONAL,
+        now: NOW,
+      }),
+    ).toBeUndefined();
+
+    // A closed newest row does not describe the current status.
+    expect(
+      MonitorStatusHistoryUtil.getStatusSince({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: row({
+          id: "row-closed",
+          statusId: OPERATIONAL_ID,
+          startsAt: "2026-09-18T08:00:00.000Z",
+          endsAt: "2026-09-19T08:00:00.000Z",
+        }),
+        now: NOW,
+      }),
+    ).toBeUndefined();
+
+    expect(
+      MonitorStatusHistoryUtil.getStatusSince({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: undefined,
+        now: NOW,
+      }),
+    ).toBeUndefined();
+
+    expect(
+      MonitorStatusHistoryUtil.getStatusSince({
+        currentStatusId: undefined,
+        latestRow: OPEN_OPERATIONAL,
+        now: NOW,
+      }),
+    ).toBeUndefined();
+  });
+
+  it("since clamps future dates", () => {
+    expect(
+      MonitorStatusHistoryUtil.getStatusSince({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: row({
+          id: "row-future",
+          statusId: OPERATIONAL_ID,
+          startsAt: "2026-09-21T12:05:00.000Z",
+        }),
+        now: NOW,
+      })?.toISOString(),
+    ).toBe(NOW.toISOString());
+  });
+});
+
+describe("MonitorStatusHistoryUtil.hasStatusDrift", () => {
+  it("drift on mismatch", () => {
+    expect(
+      MonitorStatusHistoryUtil.hasStatusDrift({
+        currentStatusId: OFFLINE_ID,
+        latestRow: OPEN_OPERATIONAL,
+      }),
+    ).toBe(true);
+    expect(
+      MonitorStatusHistoryUtil.hasStatusDrift({
+        currentStatusId: undefined,
+        latestRow: OPEN_OPERATIONAL,
+      }),
+    ).toBe(true);
+  });
+
+  it("no drift when they agree or there is no row", () => {
+    expect(
+      MonitorStatusHistoryUtil.hasStatusDrift({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: OPEN_OPERATIONAL,
+      }),
+    ).toBe(false);
+    expect(
+      MonitorStatusHistoryUtil.hasStatusDrift({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: undefined,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("MonitorStatusHistoryUtil.getStatusChangeRows", () => {
+  it("the newest open row is ongoing", () => {
+    const rows: Array<MonitorStatusChangeRow> =
+      MonitorStatusHistoryUtil.getStatusChangeRows([
+        OPEN_OPERATIONAL,
+        row({
+          id: "row-2",
+          statusId: OFFLINE_ID,
+          statusName: "Offline",
+          color: "#EF4444",
+          startsAt: "2026-09-18T07:30:00.000Z",
+          endsAt: "2026-09-18T08:00:00.000Z",
+        }),
+      ]);
+
+    expect(rows).toEqual([
+      {
+        id: "row-3",
+        statusName: "Operational",
+        statusColor: "#10B981",
+        startsAt: new Date("2026-09-18T08:00:00.000Z"),
+        endsAt: undefined,
+        isOngoing: true,
+      },
+      {
+        id: "row-2",
+        statusName: "Offline",
+        statusColor: "#EF4444",
+        startsAt: new Date("2026-09-18T07:30:00.000Z"),
+        endsAt: new Date("2026-09-18T08:00:00.000Z"),
+        isOngoing: false,
+      },
+    ]);
+  });
+
+  it("an orphan open row is capped at its successor's start", () => {
+    const rows: Array<MonitorStatusChangeRow> =
+      MonitorStatusHistoryUtil.getStatusChangeRows([
+        OPEN_OPERATIONAL,
+        // Left open by a missed close: it ended when the newer row began.
+        row({
+          id: "row-orphan",
+          statusId: OFFLINE_ID,
+          statusName: "Offline",
+          startsAt: "2026-09-17T08:00:00.000Z",
+        }),
+      ]);
+
+    expect(rows[1]!.isOngoing).toBe(false);
+    expect(rows[1]!.endsAt?.toISOString()).toBe("2026-09-18T08:00:00.000Z");
+    expect(rows[0]!.isOngoing).toBe(true);
+  });
+
+  it("a closed newest row is not ongoing", () => {
+    const rows: Array<MonitorStatusChangeRow> =
+      MonitorStatusHistoryUtil.getStatusChangeRows([
+        row({
+          id: "row-closed",
+          statusId: OPERATIONAL_ID,
+          startsAt: "2026-09-18T08:00:00.000Z",
+          endsAt: "2026-09-19T08:00:00.000Z",
+        }),
+      ]);
+
+    expect(rows[0]!.isOngoing).toBe(false);
+    expect(rows[0]!.statusName).toBe("Unknown status");
+    expect(rows[0]!.statusColor).toBeUndefined();
+  });
+
+  it("skips a row with no start and returns nothing for no rows", () => {
+    const undated: MonitorStatusTimeline = new MonitorStatusTimeline();
+    undated._id = "row-undated";
+
+    expect(
+      MonitorStatusHistoryUtil.getStatusChangeRows([undated, OPEN_OPERATIONAL])
+        .length,
+    ).toBe(1);
+    expect(MonitorStatusHistoryUtil.getStatusChangeRows([])).toEqual([]);
+  });
+});
+
+describe("MonitorStatusHistoryUtil.getStatusFingerprint", () => {
+  it("fingerprint changes when the newest row closes", () => {
+    const open: string = MonitorStatusHistoryUtil.getStatusFingerprint({
+      currentStatusId: OPERATIONAL_ID,
+      latestRow: OPEN_OPERATIONAL,
+    });
+
+    expect(open).toBe(`${OPERATIONAL_ID}|row-3|`);
+
+    const closed: string = MonitorStatusHistoryUtil.getStatusFingerprint({
+      currentStatusId: OPERATIONAL_ID,
+      latestRow: row({
+        id: "row-3",
+        statusId: OPERATIONAL_ID,
+        startsAt: "2026-09-18T08:00:00.000Z",
+        endsAt: "2026-09-21T11:00:00.000Z",
+      }),
+    });
+
+    expect(closed).toBe(`${OPERATIONAL_ID}|row-3|2026-09-21T11:00:00.000Z`);
+    expect(closed).not.toBe(open);
+  });
+
+  it("fingerprint changes with the current status and the newest row", () => {
+    const base: string = MonitorStatusHistoryUtil.getStatusFingerprint({
+      currentStatusId: OPERATIONAL_ID,
+      latestRow: OPEN_OPERATIONAL,
+    });
+
+    expect(
+      MonitorStatusHistoryUtil.getStatusFingerprint({
+        currentStatusId: OFFLINE_ID,
+        latestRow: OPEN_OPERATIONAL,
+      }),
+    ).not.toBe(base);
+    expect(
+      MonitorStatusHistoryUtil.getStatusFingerprint({
+        currentStatusId: OPERATIONAL_ID,
+        latestRow: row({
+          id: "row-4",
+          statusId: OPERATIONAL_ID,
+          startsAt: "2026-09-21T11:00:00.000Z",
+        }),
+      }),
+    ).not.toBe(base);
+    expect(
+      MonitorStatusHistoryUtil.getStatusFingerprint({
+        currentStatusId: undefined,
+        latestRow: undefined,
+      }),
+    ).toBe("||");
+  });
+});
+
+describe("MonitorStatusHistoryUtil.normalizeColor", () => {
+  it("normalizeColor handles Color and string", () => {
+    expect(MonitorStatusHistoryUtil.normalizeColor(new Color("#10B981"))).toBe(
+      "#10B981",
+    );
+    expect(MonitorStatusHistoryUtil.normalizeColor("  #abc ")).toBe("#abc");
+    expect(MonitorStatusHistoryUtil.normalizeColor("rgb(16, 185, 129)")).toBe(
+      "rgb(16, 185, 129)",
+    );
+    expect(MonitorStatusHistoryUtil.normalizeColor("red")).toBe("red");
+    expect(
+      MonitorStatusHistoryUtil.normalizeColor({
+        _type: "Color",
+        value: "#EF4444",
+      } as unknown as Color),
+    ).toBe("#EF4444");
+  });
+
+  it("empty or invalid gives undefined", () => {
+    expect(MonitorStatusHistoryUtil.normalizeColor(undefined)).toBeUndefined();
+    expect(MonitorStatusHistoryUtil.normalizeColor(null)).toBeUndefined();
+    expect(MonitorStatusHistoryUtil.normalizeColor("")).toBeUndefined();
+    expect(
+      MonitorStatusHistoryUtil.normalizeColor(new Color("")),
+    ).toBeUndefined();
+    expect(MonitorStatusHistoryUtil.normalizeColor("#12345")).toBeUndefined();
+    expect(
+      MonitorStatusHistoryUtil.normalizeColor("red; background: url(x)"),
+    ).toBeUndefined();
+    expect(
+      MonitorStatusHistoryUtil.normalizeColor("expression(alert(1))"),
+    ).toBeUndefined();
+  });
+});