@oneuptime/common 12.0.6 → 12.0.7

package/Tests/Utils/LegacySerializedArray.test.ts

@@ -0,0 +1,139 @@
+import { readLegacySerializedArray } from "../../Utils/LegacySerializedArray";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The pre-fix serializer turned an array it received directly into a
+ * numeric-keyed object. Values written that way are still in databases and in
+ * browser local storage, so both shapes have to read back — while a genuine
+ * object that merely happens to carry a "0" key must not be mistaken for one
+ * of them.
+ */
+
+describe("readLegacySerializedArray", () => {
+  describe("Values that are already arrays", () => {
+    test("Returns an array unchanged", () => {
+      expect(readLegacySerializedArray(["time", "body"])).toEqual([
+        "time",
+        "body",
+      ]);
+    });
+
+    test("Returns an empty array unchanged", () => {
+      expect(readLegacySerializedArray([])).toEqual([]);
+    });
+
+    test("Leaves element types alone", () => {
+      const mixed: Array<unknown> = [1, "x", null, { a: 1 }, ["nested"]];
+
+      expect(readLegacySerializedArray(mixed)).toEqual(mixed);
+    });
+
+    test("Returns the same reference, not a copy", () => {
+      const original: Array<unknown> = ["time"];
+
+      expect(readLegacySerializedArray(original)).toBe(original);
+    });
+  });
+
+  describe("Values corrupted into numeric-keyed objects", () => {
+    test("Rebuilds a two-element array", () => {
+      expect(readLegacySerializedArray({ "0": "service", "1": "api" })).toEqual(
+        ["service", "api"],
+      );
+    });
+
+    test("Rebuilds a longer array in index order", () => {
+      expect(
+        readLegacySerializedArray({
+          "0": "time",
+          "1": "body",
+          "2": "severityText",
+        }),
+      ).toEqual(["time", "body", "severityText"]);
+    });
+
+    test("Rebuilds in index order even when the keys are out of order", () => {
+      expect(
+        readLegacySerializedArray({
+          "2": "third",
+          "0": "first",
+          "1": "second",
+        }),
+      ).toEqual(["first", "second", "third"]);
+    });
+
+    test("Rebuilds a single-element array", () => {
+      expect(readLegacySerializedArray({ "0": "only" })).toEqual(["only"]);
+    });
+
+    test("Keeps null and empty-string elements", () => {
+      expect(readLegacySerializedArray({ "0": null, "1": "" })).toEqual([
+        null,
+        "",
+      ]);
+    });
+
+    test("Reads an empty object as an empty array", () => {
+      // An empty array is exactly what the old serializer wrote as {}.
+      expect(readLegacySerializedArray({})).toEqual([]);
+    });
+
+    test("The result is a real array, so it can be destructured", () => {
+      const restored: Array<unknown> | null = readLegacySerializedArray({
+        "0": "service",
+        "1": "api",
+      });
+
+      expect(Array.isArray(restored)).toBe(true);
+      expect(() => {
+        const [first]: Array<unknown> = restored as Array<unknown>;
+        return first;
+      }).not.toThrow();
+    });
+  });
+
+  describe("Values that are not arrays in any shape", () => {
+    test("Rejects null and undefined", () => {
+      expect(readLegacySerializedArray(null)).toBeNull();
+      expect(readLegacySerializedArray(undefined)).toBeNull();
+    });
+
+    test("Rejects primitives", () => {
+      expect(readLegacySerializedArray("time")).toBeNull();
+      expect(readLegacySerializedArray(7)).toBeNull();
+      expect(readLegacySerializedArray(true)).toBeNull();
+    });
+
+    test("Rejects a plain object with named keys", () => {
+      expect(readLegacySerializedArray({ facetKey: "service" })).toBeNull();
+    });
+
+    test("Rejects an object that only partly looks like an array", () => {
+      // "0" is there but "1" is not, so the run of indices is incomplete.
+      expect(
+        readLegacySerializedArray({ "0": "service", foo: "bar" }),
+      ).toBeNull();
+    });
+
+    test("Rejects an object whose indices do not start at zero", () => {
+      expect(readLegacySerializedArray({ "1": "a", "2": "b" })).toBeNull();
+    });
+
+    test("Rejects an object with a gap in its indices", () => {
+      expect(readLegacySerializedArray({ "0": "a", "2": "b" })).toBeNull();
+    });
+
+    test("Rejects a real saved-view state object", () => {
+      /*
+       * Guards the boundary the other way: a JSON column's own object must
+       * never be read as a list of its values.
+       */
+      expect(
+        readLegacySerializedArray({
+          search: "status:error",
+          pageSize: 50,
+        }),
+      ).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,190 @@
+import MonitorDependencyRule, {
+  ParentMonitorStatusRef,
+  SuppressingParent,
+} from "../../../Utils/Monitor/MonitorDependencyRule";
+
+const parent: (
+  overrides: Partial<ParentMonitorStatusRef>,
+) => ParentMonitorStatusRef = (
+  overrides: Partial<ParentMonitorStatusRef>,
+): ParentMonitorStatusRef => {
+  return {
+    monitorId: "m1",
+    monitorName: "Router",
+    statusId: "s-online",
+    statusName: "Online",
+    isOfflineState: false,
+    ...overrides,
+  };
+};
+
+describe("MonitorDependencyRule.getSuppressingParents", () => {
+  describe("with a configured suppression status list", () => {
+    const configured: Set<string> = new Set<string>([
+      "s-offline",
+      "s-degraded",
+    ]);
+
+    test("a parent whose status is in the list suppresses", () => {
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [
+            parent({
+              monitorId: "m1",
+              monitorName: "Core Router",
+              statusId: "s-offline",
+              statusName: "Offline",
+            }),
+          ],
+          configuredSuppressionStatusIds: configured,
+        });
+
+      expect(result).toEqual([
+        { monitorId: "m1", monitorName: "Core Router", statusName: "Offline" },
+      ]);
+    });
+
+    test("a parent whose status is not in the list does not suppress", () => {
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [parent({ statusId: "s-online" })],
+          configuredSuppressionStatusIds: configured,
+        });
+
+      expect(result).toEqual([]);
+    });
+
+    test("the configured list wins even when the parent is offline", () => {
+      /*
+       * isOfflineState is only the fallback signal. With an explicit list
+       * configured, an offline parent whose status id is not listed must NOT
+       * suppress — otherwise the operator's narrower rule is ignored.
+       */
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [parent({ statusId: "s-online", isOfflineState: true })],
+          configuredSuppressionStatusIds: configured,
+        });
+
+      expect(result).toEqual([]);
+    });
+
+    test("a parent with no current status never suppresses", () => {
+      // A never-evaluated parent (undefined statusId) must not silence children.
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [parent({ statusId: undefined, isOfflineState: true })],
+          configuredSuppressionStatusIds: configured,
+        });
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("with no configured list (offline fallback)", () => {
+    const empty: Set<string> = new Set<string>();
+
+    test("an offline parent suppresses", () => {
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [
+            parent({
+              monitorName: "Switch",
+              statusName: "Offline",
+              isOfflineState: true,
+            }),
+          ],
+          configuredSuppressionStatusIds: empty,
+        });
+
+      expect(result).toEqual([
+        { monitorId: "m1", monitorName: "Switch", statusName: "Offline" },
+      ]);
+    });
+
+    test("a non-offline parent does not suppress", () => {
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [parent({ isOfflineState: false })],
+          configuredSuppressionStatusIds: empty,
+        });
+
+      expect(result).toEqual([]);
+    });
+
+    test("falls back to the label 'Offline' when statusName is missing", () => {
+      const result: Array<SuppressingParent> =
+        MonitorDependencyRule.getSuppressingParents({
+          parents: [parent({ statusName: undefined, isOfflineState: true })],
+          configuredSuppressionStatusIds: empty,
+        });
+
+      expect(result[0]?.statusName).toBe("Offline");
+    });
+  });
+
+  test("returns only the suppressing subset, preserving input order", () => {
+    const result: Array<SuppressingParent> =
+      MonitorDependencyRule.getSuppressingParents({
+        parents: [
+          parent({ monitorId: "a", statusId: "s-offline" }),
+          parent({ monitorId: "b", statusId: "s-online" }),
+          parent({ monitorId: "c", statusId: "s-offline" }),
+        ],
+        configuredSuppressionStatusIds: new Set<string>(["s-offline"]),
+      });
+
+    expect(
+      result.map((p: SuppressingParent) => {
+        return p.monitorId;
+      }),
+    ).toEqual(["a", "c"]);
+  });
+
+  test("an empty parent list yields no suppressors", () => {
+    expect(
+      MonitorDependencyRule.getSuppressingParents({
+        parents: [],
+        configuredSuppressionStatusIds: new Set<string>(["s-offline"]),
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe("MonitorDependencyRule.buildSuppressionReason", () => {
+  test("uses the singular noun for a single parent", () => {
+    const reason: string = MonitorDependencyRule.buildSuppressionReason([
+      { monitorId: "m1", monitorName: "Router", statusName: "Offline" },
+    ]);
+    expect(reason).toBe('parent monitor "Router" is Offline');
+  });
+
+  test("uses the plural noun and comma-joins multiple parents", () => {
+    const reason: string = MonitorDependencyRule.buildSuppressionReason([
+      { monitorId: "m1", monitorName: "Router", statusName: "Offline" },
+      { monitorId: "m2", monitorName: "Switch", statusName: "Degraded" },
+    ]);
+    expect(reason).toBe(
+      'parent monitors "Router" is Offline, "Switch" is Degraded',
+    );
+  });
+
+  test("quotes each monitor name so odd names stay legible", () => {
+    const reason: string = MonitorDependencyRule.buildSuppressionReason([
+      {
+        monitorId: "m1",
+        monitorName: "us-east, primary",
+        statusName: "Offline",
+      },
+    ]);
+    // The name itself contains a comma; the quotes keep it from reading as two.
+    expect(reason).toBe('parent monitor "us-east, primary" is Offline');
+  });
+
+  test("an empty parent list produces the singular stem with no names", () => {
+    // Degenerate input still returns a string rather than throwing.
+    expect(MonitorDependencyRule.buildSuppressionReason([])).toBe(
+      "parent monitor ",
+    );
+  });
+});

package/Tests/Utils/Realtime.test.ts

@@ -0,0 +1,78 @@
+import RealtimeUtil from "../../Utils/Realtime";
+import ObjectID from "../../Types/ObjectID";
+import ModelEventType from "../../Types/Realtime/ModelEventType";
+
+describe("RealtimeUtil.getRoomId", () => {
+  test("joins tenant, model and event type with hyphens", () => {
+    expect(
+      RealtimeUtil.getRoomId("tenant1", "Monitor", ModelEventType.Create),
+    ).toBe("tenant1-Monitor-Create");
+  });
+
+  test("appends the model id when one is given", () => {
+    expect(
+      RealtimeUtil.getRoomId(
+        "tenant1",
+        "Monitor",
+        ModelEventType.Update,
+        "model9",
+      ),
+    ).toBe("tenant1-Monitor-Update-model9");
+  });
+
+  test("accepts ObjectID for tenant and model id, using their string form", () => {
+    const tenant: ObjectID = new ObjectID(
+      "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+    );
+    const modelId: ObjectID = new ObjectID(
+      "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+    );
+
+    expect(
+      RealtimeUtil.getRoomId(
+        tenant,
+        "Incident",
+        ModelEventType.Delete,
+        modelId,
+      ),
+    ).toBe(`${tenant.toString()}-Incident-Delete-${modelId.toString()}`);
+  });
+
+  test("the room id changes with the event type (rooms are per-event)", () => {
+    const create: string = RealtimeUtil.getRoomId(
+      "t",
+      "Monitor",
+      ModelEventType.Create,
+    );
+    const update: string = RealtimeUtil.getRoomId(
+      "t",
+      "Monitor",
+      ModelEventType.Update,
+    );
+    expect(create).not.toBe(update);
+  });
+
+  test("the id-scoped room is distinct from the collection-wide room", () => {
+    // A subscriber to one model must not collect the whole collection's events.
+    const collectionRoom: string = RealtimeUtil.getRoomId(
+      "t",
+      "Monitor",
+      ModelEventType.Update,
+    );
+    const itemRoom: string = RealtimeUtil.getRoomId(
+      "t",
+      "Monitor",
+      ModelEventType.Update,
+      "m1",
+    );
+    expect(itemRoom).not.toBe(collectionRoom);
+    expect(itemRoom.startsWith(collectionRoom)).toBe(true);
+  });
+
+  test("an empty-string model id is falsy, so no id segment is appended", () => {
+    // Documents the `if (modelId)` guard: "" behaves like an omitted id.
+    expect(
+      RealtimeUtil.getRoomId("t", "Monitor", ModelEventType.Create, ""),
+    ).toBe("t-Monitor-Create");
+  });
+});

package/Tests/Utils/Telemetry/SavedViewFilters.test.ts

@@ -0,0 +1,246 @@
+import JSONFunctions from "../../../Types/JSONFunctions";
+import TelemetrySavedViewState from "../../../Types/Telemetry/TelemetrySavedViewState";
+import { JSONObject } from "../../../Types/JSON";
+import {
+  readSavedViewFilters,
+  SavedViewFilterTuple,
+} from "../../../Utils/Telemetry/SavedViewFilters";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Facet filters are stored as [facetKey, value] tuples inside a JSON column,
+ * and for a while the serializer rewrote every one of them into
+ * { "0": facetKey, "1": value }. Those rows are still in the database, so the
+ * explorers cannot destructure saved filters directly — a single bad row used
+ * to take the whole Traces page down with
+ * "TypeError: (destructured parameter) is not iterable".
+ *
+ * These tests cover both shapes and the junk in between.
+ */
+
+// The shape a pre-fix serializer left in the database.
+const LEGACY_CORRUPTED_FILTERS: unknown = [
+  { "0": "primaryEntityId", "1": "6512f1a0a1b2c3d4e5f60718" },
+  { "0": "attributes.http.method", "1": "GET" },
+];
+
+describe("readSavedViewFilters", () => {
+  describe("Well-formed saved state", () => {
+    test("Reads tuples that were stored correctly", () => {
+      expect(
+        readSavedViewFilters([
+          ["service", "api"],
+          ["status", "error"],
+        ]),
+      ).toEqual([
+        ["service", "api"],
+        ["status", "error"],
+      ]);
+    });
+
+    test("Reads a single tuple", () => {
+      expect(readSavedViewFilters([["service", "api"]])).toEqual([
+        ["service", "api"],
+      ]);
+    });
+
+    test("Returns an empty list for an empty list", () => {
+      expect(readSavedViewFilters([])).toEqual([]);
+    });
+
+    test("Keeps a filter whose value is deliberately the empty string", () => {
+      expect(readSavedViewFilters([["statusMessage", ""]])).toEqual([
+        ["statusMessage", ""],
+      ]);
+    });
+
+    test("Ignores anything beyond the first two elements of a tuple", () => {
+      expect(
+        readSavedViewFilters([["service", "api", "extra", "junk"]]),
+      ).toEqual([["service", "api"]]);
+    });
+
+    test("Preserves order", () => {
+      expect(
+        readSavedViewFilters([
+          ["c", "3"],
+          ["a", "1"],
+          ["b", "2"],
+        ]),
+      ).toEqual([
+        ["c", "3"],
+        ["a", "1"],
+        ["b", "2"],
+      ]);
+    });
+
+    test("Returns real arrays, so callers can destructure them", () => {
+      const filters: Array<SavedViewFilterTuple> = readSavedViewFilters([
+        ["service", "api"],
+      ]);
+
+      const read: Array<string> = filters.map(
+        ([facetKey, value]: SavedViewFilterTuple): string => {
+          return `${facetKey}:${value}`;
+        },
+      );
+
+      expect(read).toEqual(["service:api"]);
+    });
+  });
+
+  describe("Legacy rows corrupted by the old serializer", () => {
+    test("Reads { '0': key, '1': value } back into a tuple", () => {
+      expect(readSavedViewFilters(LEGACY_CORRUPTED_FILTERS)).toEqual([
+        ["primaryEntityId", "6512f1a0a1b2c3d4e5f60718"],
+        ["attributes.http.method", "GET"],
+      ]);
+    });
+
+    test("A healed legacy row is destructurable", () => {
+      const filters: Array<SavedViewFilterTuple> = readSavedViewFilters(
+        LEGACY_CORRUPTED_FILTERS,
+      );
+
+      expect(() => {
+        return filters.map(([facetKey]: SavedViewFilterTuple): string => {
+          return facetKey;
+        });
+      }).not.toThrow();
+    });
+
+    test("Reads a list that mixes healed and correct rows", () => {
+      expect(
+        readSavedViewFilters([
+          { "0": "service", "1": "api" },
+          ["status", "error"],
+        ]),
+      ).toEqual([
+        ["service", "api"],
+        ["status", "error"],
+      ]);
+    });
+
+    test("Heals exactly what the old serializer produced, end to end", () => {
+      /*
+       * Reproduce the corruption the way it actually happened — through the
+       * pre-fix serializer — rather than hand-writing the broken shape.
+       */
+      const corrupted: JSONObject = {
+        filters: [
+          { "0": "service", "1": "api" },
+          { "0": "status", "1": "error" },
+        ],
+      };
+
+      expect(readSavedViewFilters(corrupted["filters"])).toEqual([
+        ["service", "api"],
+        ["status", "error"],
+      ]);
+    });
+  });
+
+  describe("Malformed saved state never throws", () => {
+    test("Returns an empty list for undefined, null and non-arrays", () => {
+      expect(readSavedViewFilters(undefined)).toEqual([]);
+      expect(readSavedViewFilters(null)).toEqual([]);
+      expect(readSavedViewFilters("service:api")).toEqual([]);
+      expect(readSavedViewFilters(42)).toEqual([]);
+      expect(readSavedViewFilters(true)).toEqual([]);
+      expect(readSavedViewFilters({})).toEqual([]);
+      expect(readSavedViewFilters({ service: "api" })).toEqual([]);
+    });
+
+    test("Drops entries that are not tuple-shaped at all", () => {
+      expect(
+        readSavedViewFilters([
+          "service:api",
+          42,
+          null,
+          undefined,
+          true,
+          ["status", "error"],
+        ]),
+      ).toEqual([["status", "error"]]);
+    });
+
+    test("Drops entries with no usable facet key", () => {
+      expect(
+        readSavedViewFilters([
+          [],
+          ["", "api"],
+          [null, "api"],
+          [{ nested: true }, "api"],
+          ["service", "api"],
+        ]),
+      ).toEqual([["service", "api"]]);
+    });
+
+    test("Falls back to an empty value when the stored value is unusable", () => {
+      expect(readSavedViewFilters([["service", null]])).toEqual([
+        ["service", ""],
+      ]);
+      expect(readSavedViewFilters([["service"]])).toEqual([["service", ""]]);
+      expect(readSavedViewFilters([["service", { nested: true }]])).toEqual([
+        ["service", ""],
+      ]);
+      expect(readSavedViewFilters([["service", ["a"]]])).toEqual([
+        ["service", ""],
+      ]);
+    });
+
+    test("Stringifies values that came back as numbers or booleans", () => {
+      expect(
+        readSavedViewFilters([
+          ["duration", 500],
+          ["hasException", true],
+        ]),
+      ).toEqual([
+        ["duration", "500"],
+        ["hasException", "true"],
+      ]);
+    });
+
+    test("Drops non-finite numeric values rather than writing 'NaN' into a chip", () => {
+      expect(readSavedViewFilters([["duration", NaN]])).toEqual([
+        ["duration", ""],
+      ]);
+      expect(readSavedViewFilters([["duration", Infinity]])).toEqual([
+        ["duration", ""],
+      ]);
+    });
+
+    test("Reads a numeric facet key stored as a number", () => {
+      expect(readSavedViewFilters([[7, "api"]])).toEqual([["7", "api"]]);
+    });
+  });
+
+  describe("Round trip through the serializer that stores the view", () => {
+    test("Filters written by the fixed serializer read straight back", () => {
+      const state: TelemetrySavedViewState = {
+        search: "status:error",
+        filters: [
+          ["service", "api"],
+          ["attributes.http.method", "GET"],
+        ],
+        pageSize: 50,
+      };
+
+      const stored: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(
+          JSON.stringify(JSONFunctions.serialize(state as JSONObject)),
+        ),
+      );
+
+      expect(readSavedViewFilters(stored["filters"])).toEqual(state.filters);
+    });
+
+    test("A view with no filters at all reads as no filters", () => {
+      const state: TelemetrySavedViewState = { search: "status:error" };
+
+      const stored: JSONObject = JSONFunctions.serialize(state as JSONObject);
+
+      expect(readSavedViewFilters(stored["filters"])).toEqual([]);
+    });
+  });
+});

package/Tests/__mocks__/i18next-browser-languagedetector.js

@@ -0,0 +1,21 @@
+"use strict";
+
+/*
+ * The real detector is only installed in the frontend feature sets. Tests that
+ * render status page components import Utils/i18n, which registers this plugin,
+ * so a minimal stand-in that always resolves to English is enough.
+ */
+class LanguageDetector {
+  init() {}
+
+  detect() {
+    return "en";
+  }
+
+  cacheUserLanguage() {}
+}
+
+LanguageDetector.type = "languageDetector";
+
+module.exports = LanguageDetector;
+module.exports.default = LanguageDetector;

package/Types/AI/FixPullRequestCiStatus.ts

@@ -3,7 +3,7 @@ import CodeFixTaskType from "./CodeFixTaskType";
 /*
  * The rolled-up CI conclusion recorded on an AI fix pull request
  * (AIAgentTaskPullRequest.ciStatus) — B4 Tier 1: verification via the
- * customer's OWN CI on the draft PRs. We read check-run conclusions through
+ * customer's OWN CI on the fix PRs. We read check-run conclusions through
  * the GitHub App; we never re-run or gate the customer's CI.
  *
  * G9 honesty rule: only Green and ExpectedFailureObserved ever count as

package/Types/AI/FixVerificationStatus.ts

@@ -7,8 +7,8 @@
  *   - Passed: every configured command (setup, build, test) exited 0 —
  *     possibly after bounded agent repair attempts.
  *   - Failed: a configured command still failed after the repair attempts
- *     were exhausted. The PR still opens (as a draft, clearly labeled) so
- *     the work is not lost — the human reviewer decides.
+ *     were exhausted. The PR still opens, with the failure clearly labeled
+ *     in its body, so the work is not lost — the human reviewer decides.
  *   - Skipped: the repository has no verification commands configured, so
  *     nothing could be verified.
  */