@oneuptime/common 12.0.5 → 12.0.7

package/Tests/Types/JSONFunctions.test.ts

@@ -1,4 +1,4 @@
-import { JSONArray, JSONObject, ObjectType } from "../../Types/JSON";
+import { JSONArray, JSONObject, JSONValue, ObjectType } from "../../Types/JSON";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import JSONFunctions from "../../Types/JSONFunctions";
 
@@ -350,6 +350,208 @@ describe("JSONFunctions Class", () => {
     });
   });
 
+  /*
+   * serializeValue used to have no Array.isArray branch. Arrays are typeof
+   * "object", so anything nested deeper than one level fell through to
+   * serialize(), which walks with `for (const key in val)` and returned
+   * { "0": ..., "1": ... } in place of the array. Only the OUTERMOST array was
+   * safe, because serialize() special-cases an array-valued key — which is
+   * exactly why this went unnoticed: `{ a: [1, 2] }` looked fine.
+   *
+   * Everything stored deeper than that was silently rewritten on its way into
+   * a JSON column, and the object that came back out was no longer iterable.
+   * These tests pin the array shape at every depth.
+   */
+  describe("Nested arrays survive serialization", () => {
+    test("Serializes an array of tuples without collapsing the tuples into objects", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        filters: [
+          ["service", "api"],
+          ["status", "error"],
+        ],
+      });
+
+      expect(serialized).toEqual({
+        filters: [
+          ["service", "api"],
+          ["status", "error"],
+        ],
+      });
+    });
+
+    test("Every element of a serialized array of tuples is still an array", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        filters: [["service", "api"]],
+      });
+
+      const filters: JSONArray = serialized["filters"] as JSONArray;
+
+      expect(Array.isArray(filters)).toBe(true);
+      expect(Array.isArray(filters[0])).toBe(true);
+    });
+
+    test("A serialized tuple is still destructurable, which is how callers read it", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        filters: [["service", "api"]],
+      });
+
+      const filters: JSONArray = serialized["filters"] as JSONArray;
+
+      // This threw "(destructured parameter) is not iterable" before the fix.
+      const read: Array<string> = (
+        filters as unknown as Array<[string, string]>
+      ).map(([facetKey, value]: [string, string]): string => {
+        return `${facetKey}:${value}`;
+      });
+
+      expect(read).toEqual(["service:api"]);
+    });
+
+    test("Serializes arrays nested three and four levels deep", () => {
+      expect(JSONFunctions.serialize({ deep: [[[1, 2]]] })).toEqual({
+        deep: [[[1, 2]]],
+      });
+      expect(JSONFunctions.serialize({ deeper: [[[["x"]]]] })).toEqual({
+        deeper: [[[["x"]]]],
+      });
+    });
+
+    test("Serializes an array held by an object that itself sits inside an array", () => {
+      expect(
+        JSONFunctions.serialize({
+          queries: [{ groupBy: ["host", "region"] }, { groupBy: [] }],
+        }),
+      ).toEqual({
+        queries: [{ groupBy: ["host", "region"] }, { groupBy: [] }],
+      });
+    });
+
+    test("Keeps empty arrays at every depth as arrays", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        outer: [],
+        nested: [[]],
+      });
+
+      expect(serialized["outer"]).toEqual([]);
+      expect(Array.isArray(serialized["nested"])).toBe(true);
+      expect((serialized["nested"] as JSONArray)[0]).toEqual([]);
+    });
+
+    test("Keeps null and empty-string elements inside a nested array", () => {
+      expect(JSONFunctions.serialize({ rows: [[null, ""]] })).toEqual({
+        rows: [[null, ""]],
+      });
+    });
+
+    test("Still tags a Date held inside a nested array", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        rows: [[new Date("2023-01-01T00:00:00.000Z")]],
+      });
+
+      const rows: JSONArray = serialized["rows"] as JSONArray;
+      const inner: JSONArray = rows[0] as unknown as JSONArray;
+      const when: JSONObject = inner[0] as JSONObject;
+
+      expect(Array.isArray(rows)).toBe(true);
+      expect(Array.isArray(inner)).toBe(true);
+      expect(when["_type"]).toBe(ObjectType.DateTime);
+    });
+
+    test("Still tags a Buffer held inside a nested array rather than treating it as an array", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        rows: [[Buffer.from([1, 2, 3])]],
+      });
+
+      const inner: JSONArray = (
+        serialized["rows"] as JSONArray
+      )[0] as unknown as JSONArray;
+      const payload: JSONObject = inner[0] as JSONObject;
+
+      expect(Array.isArray(inner)).toBe(true);
+      expect(payload["_type"]).toBe(ObjectType.Buffer);
+    });
+
+    test("A Buffer inside a nested array rebuilds into a Buffer", () => {
+      const roundTripped: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(
+          JSON.stringify(
+            JSONFunctions.serialize({ rows: [[Buffer.from([1, 2, 3])]] }),
+          ),
+        ),
+      );
+
+      const inner: JSONArray = (
+        roundTripped["rows"] as JSONArray
+      )[0] as unknown as JSONArray;
+
+      expect(Buffer.isBuffer(inner[0])).toBe(true);
+      expect(inner[0]).toEqual(Buffer.from([1, 2, 3]));
+    });
+
+    test("A typed array is tagged as a Buffer, never walked as an array", () => {
+      /*
+       * ArrayBuffer.isView is checked before the array branch, and it has to
+       * stay that way: a Uint8Array is not array-literal data and walking it
+       * element by element would lose the Buffer tag deserialize looks for.
+       */
+      const serialized: JSONObject = JSONFunctions.serialize({
+        payload: new Uint8Array([1, 2, 3]),
+      });
+
+      const payload: JSONObject = serialized["payload"] as JSONObject;
+
+      expect(Array.isArray(payload)).toBe(false);
+      expect(payload["_type"]).toBe(ObjectType.Buffer);
+    });
+
+    test("serializeValue returns an array when handed one directly", () => {
+      /*
+       * The path LocalStorage/SessionStorage/Cookie take — they serialize the
+       * caller's value itself, with no wrapper object, so a flat array reaches
+       * serializeValue and used to come back as { "0": ..., "1": ... }.
+       */
+      const serialized: JSONValue = JSONFunctions.serializeValue([
+        "service",
+        "api",
+      ]);
+
+      expect(Array.isArray(serialized)).toBe(true);
+      expect(serialized).toEqual(["service", "api"]);
+    });
+
+    test("A flat top-level array survives a serializeValue round trip", () => {
+      const original: JSONValue = ["time", "body", "severityText"];
+
+      const roundTripped: JSONValue = JSONFunctions.deserializeValue(
+        JSON.parse(
+          JSON.stringify(JSONFunctions.serializeValue(original)),
+        ) as JSONValue,
+      );
+
+      expect(Array.isArray(roundTripped)).toBe(true);
+      expect(roundTripped).toEqual(original);
+    });
+
+    test("serializeValue and deserializeValue agree on array-ness", () => {
+      const input: JSONValue = [["a", "b"], ["c"], []];
+
+      expect(JSONFunctions.serializeValue(input)).toEqual(input);
+      expect(JSONFunctions.deserializeValue(input)).toEqual(input);
+    });
+
+    test("A numeric-keyed object is still serialized as an object", () => {
+      // The corrupted shape itself must not be mistaken for an array.
+      const serialized: JSONObject = JSONFunctions.serialize({
+        legacy: [{ "0": "service", "1": "api" }],
+      });
+
+      const legacy: JSONArray = serialized["legacy"] as JSONArray;
+
+      expect(Array.isArray(legacy[0])).toBe(false);
+      expect(legacy[0]).toEqual({ "0": "service", "1": "api" });
+    });
+  });
+
   describe("serialize and deserialize round trip", () => {
     test("A plain object survives a serialize -> JSON -> deserialize round trip", () => {
       const original: JSONObject = {
@@ -363,5 +565,54 @@ describe("JSONFunctions Class", () => {
       );
       expect(roundTripped).toEqual(original);
     });
+
+    test("A saved telemetry view survives the round trip it is stored through", () => {
+      /*
+       * The exact shape TelemetrySavedViewState puts in the `query` JSON
+       * column of TraceSavedView / MetricSavedView.
+       */
+      const original: JSONObject = {
+        search: "status:error",
+        filters: [
+          ["primaryEntityId", "6512f1a0a1b2c3d4e5f60718"],
+          ["attributes.http.method", "GET"],
+        ],
+        timeRange: { range: "Past one hour" },
+        pageSize: 50,
+        rootOnly: false,
+      };
+
+      const roundTripped: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(JSON.stringify(JSONFunctions.serialize(original))),
+      );
+
+      expect(roundTripped).toEqual(original);
+    });
+
+    test("Arrays nested at any depth survive the round trip", () => {
+      const original: JSONObject = {
+        tuples: [
+          ["a", "b"],
+          ["c", "d"],
+        ],
+        deep: [[[1, 2]]],
+        mixed: [{ groupBy: ["host"] }, ["x", ["y"]]],
+        empty: [[]],
+      };
+
+      const roundTripped: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(JSON.stringify(JSONFunctions.serialize(original))),
+      );
+
+      expect(roundTripped).toEqual(original);
+    });
+
+    test("serializeArray keeps nested arrays inside each object", () => {
+      const input: JSONArray = [{ filters: [["a", "b"]] }];
+
+      expect(JSONFunctions.serializeArray(input)).toEqual([
+        { filters: [["a", "b"]] },
+      ]);
+    });
   });
 });

package/Tests/Types/Monitor/SnmpMonitor/SnmpAuthProtocol.test.ts

@@ -0,0 +1,61 @@
+import SnmpAuthProtocol, {
+  SnmpAuthProtocolUtil,
+} from "../../../../Types/Monitor/SnmpMonitor/SnmpAuthProtocol";
+
+describe("SnmpAuthProtocolUtil.parse", () => {
+  test("parses each protocol from its canonical spelling", () => {
+    expect(SnmpAuthProtocolUtil.parse("MD5")).toBe(SnmpAuthProtocol.MD5);
+    expect(SnmpAuthProtocolUtil.parse("SHA")).toBe(SnmpAuthProtocol.SHA);
+    expect(SnmpAuthProtocolUtil.parse("SHA256")).toBe(SnmpAuthProtocol.SHA256);
+    expect(SnmpAuthProtocolUtil.parse("SHA512")).toBe(SnmpAuthProtocol.SHA512);
+  });
+
+  test("accepts the hyphenated UI labels", () => {
+    // "SHA-256" is the label the form shows for that option.
+    expect(SnmpAuthProtocolUtil.parse("SHA-256")).toBe(SnmpAuthProtocol.SHA256);
+    expect(SnmpAuthProtocolUtil.parse("SHA-512")).toBe(SnmpAuthProtocol.SHA512);
+    expect(SnmpAuthProtocolUtil.parse("SHA-1")).toBe(SnmpAuthProtocol.SHA);
+  });
+
+  test("treats SHA, SHA1 and SHA-1 as the same (SHA-1) algorithm", () => {
+    expect(SnmpAuthProtocolUtil.parse("sha")).toBe(SnmpAuthProtocol.SHA);
+    expect(SnmpAuthProtocolUtil.parse("sha1")).toBe(SnmpAuthProtocol.SHA);
+    expect(SnmpAuthProtocolUtil.parse("sha-1")).toBe(SnmpAuthProtocol.SHA);
+  });
+
+  test("is case-insensitive and whitespace-tolerant", () => {
+    expect(SnmpAuthProtocolUtil.parse("  md5 ")).toBe(SnmpAuthProtocol.MD5);
+    expect(SnmpAuthProtocolUtil.parse("Sha256")).toBe(SnmpAuthProtocol.SHA256);
+  });
+
+  test("returns undefined — never a silent default — for unknown input", () => {
+    /*
+     * Deliberately NOT defaulting to MD5: 'unset' and 'unreadable' are
+     * different problems and only the caller can decide the fallback.
+     */
+    expect(SnmpAuthProtocolUtil.parse("SHA-3")).toBeUndefined();
+    expect(SnmpAuthProtocolUtil.parse("nonsense")).toBeUndefined();
+    expect(SnmpAuthProtocolUtil.parse("")).toBeUndefined();
+    expect(SnmpAuthProtocolUtil.parse(null)).toBeUndefined();
+    expect(SnmpAuthProtocolUtil.parse(undefined)).toBeUndefined();
+  });
+});
+
+describe("SnmpAuthProtocolUtil.isUnrecognized", () => {
+  test("is true only when something is stored but no spelling matches", () => {
+    expect(SnmpAuthProtocolUtil.isUnrecognized("SHA-3")).toBe(true);
+    expect(SnmpAuthProtocolUtil.isUnrecognized("md-5")).toBe(true);
+  });
+
+  test("is false for a recognised value", () => {
+    expect(SnmpAuthProtocolUtil.isUnrecognized("SHA-256")).toBe(false);
+    expect(SnmpAuthProtocolUtil.isUnrecognized("md5")).toBe(false);
+  });
+
+  test("an empty or absent column is 'unset', not 'unrecognized'", () => {
+    expect(SnmpAuthProtocolUtil.isUnrecognized("")).toBe(false);
+    expect(SnmpAuthProtocolUtil.isUnrecognized("   ")).toBe(false);
+    expect(SnmpAuthProtocolUtil.isUnrecognized(null)).toBe(false);
+    expect(SnmpAuthProtocolUtil.isUnrecognized(undefined)).toBe(false);
+  });
+});

package/Tests/Types/Monitor/SnmpMonitor/SnmpPrivProtocol.test.ts

@@ -0,0 +1,62 @@
+import SnmpPrivProtocol, {
+  SnmpPrivProtocolUtil,
+} from "../../../../Types/Monitor/SnmpMonitor/SnmpPrivProtocol";
+
+describe("SnmpPrivProtocolUtil.parse", () => {
+  test("parses each cipher from its canonical spelling", () => {
+    expect(SnmpPrivProtocolUtil.parse("DES")).toBe(SnmpPrivProtocol.DES);
+    expect(SnmpPrivProtocolUtil.parse("AES")).toBe(SnmpPrivProtocol.AES);
+    expect(SnmpPrivProtocolUtil.parse("AES256")).toBe(SnmpPrivProtocol.AES256);
+  });
+
+  test("treats AES, AES128 and AES-128 as the same (AES-128) cipher", () => {
+    expect(SnmpPrivProtocolUtil.parse("aes")).toBe(SnmpPrivProtocol.AES);
+    expect(SnmpPrivProtocolUtil.parse("aes128")).toBe(SnmpPrivProtocol.AES);
+    expect(SnmpPrivProtocolUtil.parse("aes-128")).toBe(SnmpPrivProtocol.AES);
+  });
+
+  test("accepts the hyphenated UI label for AES-256", () => {
+    expect(SnmpPrivProtocolUtil.parse("AES-256")).toBe(SnmpPrivProtocol.AES256);
+    expect(SnmpPrivProtocolUtil.parse("aes256")).toBe(SnmpPrivProtocol.AES256);
+  });
+
+  test("is case-insensitive and whitespace-tolerant", () => {
+    expect(SnmpPrivProtocolUtil.parse("  des ")).toBe(SnmpPrivProtocol.DES);
+    expect(SnmpPrivProtocolUtil.parse("Aes-256")).toBe(SnmpPrivProtocol.AES256);
+  });
+
+  test("does NOT confuse the weaker AES-128 with AES-256", () => {
+    // Guards the exact downgrade the parser exists to prevent.
+    expect(SnmpPrivProtocolUtil.parse("aes")).not.toBe(SnmpPrivProtocol.AES256);
+    expect(SnmpPrivProtocolUtil.parse("aes-256")).not.toBe(
+      SnmpPrivProtocol.AES,
+    );
+  });
+
+  test("returns undefined — never a silent DES default — for unknown input", () => {
+    expect(SnmpPrivProtocolUtil.parse("3des")).toBeUndefined();
+    expect(SnmpPrivProtocolUtil.parse("rc4")).toBeUndefined();
+    expect(SnmpPrivProtocolUtil.parse("")).toBeUndefined();
+    expect(SnmpPrivProtocolUtil.parse(null)).toBeUndefined();
+    expect(SnmpPrivProtocolUtil.parse(undefined)).toBeUndefined();
+  });
+});
+
+describe("SnmpPrivProtocolUtil.isUnrecognized", () => {
+  test("is true only when something is stored but no spelling matches", () => {
+    expect(SnmpPrivProtocolUtil.isUnrecognized("3des")).toBe(true);
+    expect(SnmpPrivProtocolUtil.isUnrecognized("aes-512")).toBe(true);
+  });
+
+  test("is false for a recognised value", () => {
+    expect(SnmpPrivProtocolUtil.isUnrecognized("AES-256")).toBe(false);
+    expect(SnmpPrivProtocolUtil.isUnrecognized("des")).toBe(false);
+  });
+
+  test("an empty or absent column is 'unset', not 'unrecognized'", () => {
+    expect(SnmpPrivProtocolUtil.isUnrecognized("")).toBe(false);
+    expect(SnmpPrivProtocolUtil.isUnrecognized("   ")).toBe(false);
+    expect(SnmpPrivProtocolUtil.isUnrecognized(null)).toBe(false);
+    expect(SnmpPrivProtocolUtil.isUnrecognized(undefined)).toBe(false);
+  });
+});

package/Tests/Types/Monitor/SnmpMonitor/SnmpSecurityLevel.test.ts

@@ -0,0 +1,68 @@
+import SnmpSecurityLevel, {
+  SnmpSecurityLevelUtil,
+} from "../../../../Types/Monitor/SnmpMonitor/SnmpSecurityLevel";
+
+describe("SnmpSecurityLevelUtil.parse", () => {
+  test("parses each level from its value spelling", () => {
+    expect(SnmpSecurityLevelUtil.parse("noAuthNoPriv")).toBe(
+      SnmpSecurityLevel.NoAuthNoPriv,
+    );
+    expect(SnmpSecurityLevelUtil.parse("authNoPriv")).toBe(
+      SnmpSecurityLevel.AuthNoPriv,
+    );
+    expect(SnmpSecurityLevelUtil.parse("authPriv")).toBe(
+      SnmpSecurityLevel.AuthPriv,
+    );
+  });
+
+  test("collapses the key spelling onto the value spelling (case-insensitive)", () => {
+    /*
+     * The enum keys ("AuthPriv") and values ("authPriv") differ only by the
+     * first letter's case — exactly the drift a hand-written row produces.
+     */
+    expect(SnmpSecurityLevelUtil.parse("AuthPriv")).toBe(
+      SnmpSecurityLevel.AuthPriv,
+    );
+    expect(SnmpSecurityLevelUtil.parse("NOAUTHNOPRIV")).toBe(
+      SnmpSecurityLevel.NoAuthNoPriv,
+    );
+  });
+
+  test("is whitespace-tolerant", () => {
+    expect(SnmpSecurityLevelUtil.parse("  authpriv  ")).toBe(
+      SnmpSecurityLevel.AuthPriv,
+    );
+  });
+
+  test("returns undefined rather than silently dropping to NoAuthNoPriv", () => {
+    /*
+     * The whole point: an unmatched value must not fall through to 'no
+     * security at all'. The caller decides, not the parser.
+     */
+    expect(SnmpSecurityLevelUtil.parse("auth")).toBeUndefined();
+    expect(SnmpSecurityLevelUtil.parse("priv")).toBeUndefined();
+    expect(SnmpSecurityLevelUtil.parse("secure")).toBeUndefined();
+    expect(SnmpSecurityLevelUtil.parse("")).toBeUndefined();
+    expect(SnmpSecurityLevelUtil.parse(null)).toBeUndefined();
+    expect(SnmpSecurityLevelUtil.parse(undefined)).toBeUndefined();
+  });
+});
+
+describe("SnmpSecurityLevelUtil.isUnrecognized", () => {
+  test("is true only when something is stored but no spelling matches", () => {
+    expect(SnmpSecurityLevelUtil.isUnrecognized("auth")).toBe(true);
+    expect(SnmpSecurityLevelUtil.isUnrecognized("full")).toBe(true);
+  });
+
+  test("is false for a recognised value in either spelling", () => {
+    expect(SnmpSecurityLevelUtil.isUnrecognized("authPriv")).toBe(false);
+    expect(SnmpSecurityLevelUtil.isUnrecognized("AuthPriv")).toBe(false);
+  });
+
+  test("an empty or absent column is 'unset', not 'unrecognized'", () => {
+    expect(SnmpSecurityLevelUtil.isUnrecognized("")).toBe(false);
+    expect(SnmpSecurityLevelUtil.isUnrecognized("   ")).toBe(false);
+    expect(SnmpSecurityLevelUtil.isUnrecognized(null)).toBe(false);
+    expect(SnmpSecurityLevelUtil.isUnrecognized(undefined)).toBe(false);
+  });
+});

package/Tests/Types/Monitor/SnmpMonitor/SnmpVersion.test.ts

@@ -0,0 +1,51 @@
+import SnmpVersion, {
+  SnmpVersionUtil,
+} from "../../../../Types/Monitor/SnmpMonitor/SnmpVersion";
+
+describe("SnmpVersionUtil.parse", () => {
+  test("reads the stored key spelling (V1/V3), case-insensitively", () => {
+    expect(SnmpVersionUtil.parse("V1")).toBe(SnmpVersion.V1);
+    expect(SnmpVersionUtil.parse("v1")).toBe(SnmpVersion.V1);
+    expect(SnmpVersionUtil.parse("V3")).toBe(SnmpVersion.V3);
+    expect(SnmpVersionUtil.parse("v3")).toBe(SnmpVersion.V3);
+  });
+
+  test("reads the probe-contract value spelling (1/3)", () => {
+    expect(SnmpVersionUtil.parse("1")).toBe(SnmpVersion.V1);
+    expect(SnmpVersionUtil.parse("3")).toBe(SnmpVersion.V3);
+  });
+
+  test("tolerates surrounding whitespace", () => {
+    expect(SnmpVersionUtil.parse("  v3  ")).toBe(SnmpVersion.V3);
+    expect(SnmpVersionUtil.parse("\t3\n")).toBe(SnmpVersion.V3);
+  });
+
+  test("defaults to V2c for the v2c spellings and anything unknown", () => {
+    // V2c is the default branch, so both its own spellings and junk land here.
+    expect(SnmpVersionUtil.parse("2c")).toBe(SnmpVersion.V2c);
+    expect(SnmpVersionUtil.parse("V2c")).toBe(SnmpVersion.V2c);
+    expect(SnmpVersionUtil.parse("banana")).toBe(SnmpVersion.V2c);
+    expect(SnmpVersionUtil.parse("")).toBe(SnmpVersion.V2c);
+  });
+
+  test("defaults to V2c for null and undefined", () => {
+    expect(SnmpVersionUtil.parse(null)).toBe(SnmpVersion.V2c);
+    expect(SnmpVersionUtil.parse(undefined)).toBe(SnmpVersion.V2c);
+  });
+});
+
+describe("SnmpVersionUtil.isV3", () => {
+  test("is true only for the v3 spellings", () => {
+    expect(SnmpVersionUtil.isV3("V3")).toBe(true);
+    expect(SnmpVersionUtil.isV3("3")).toBe(true);
+    expect(SnmpVersionUtil.isV3(" v3 ")).toBe(true);
+  });
+
+  test("is false for v1, v2c, unknown and empty input", () => {
+    expect(SnmpVersionUtil.isV3("V1")).toBe(false);
+    expect(SnmpVersionUtil.isV3("2c")).toBe(false);
+    expect(SnmpVersionUtil.isV3("nope")).toBe(false);
+    expect(SnmpVersionUtil.isV3(null)).toBe(false);
+    expect(SnmpVersionUtil.isV3(undefined)).toBe(false);
+  });
+});