@oneuptime/common 11.7.2 → 11.7.4

package/Tests/Types/Monitor/MonitorStepProfileMonitor.test.ts

@@ -0,0 +1,185 @@
+import Profile from "../../../Models/AnalyticsModels/Profile";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import Search from "../../../Types/BaseDatabase/Search";
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStepProfileMonitor, {
+  MonitorStepProfileMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepProfileMonitor";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("MonitorStepProfileMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns an empty monitor scoped to the last 60 seconds", () => {
+      const def: MonitorStepProfileMonitor =
+        MonitorStepProfileMonitorUtil.getDefault();
+
+      expect(def.attributes).toEqual({});
+      expect(def.profileType).toBe("");
+      expect(def.profileTypes).toEqual([]);
+      expect(def.telemetryServiceIds).toEqual([]);
+      expect(def.entityKeys).toEqual([]);
+      expect(def.lastXSecondsOfProfiles).toBe(60);
+    });
+  });
+
+  describe("toQuery", () => {
+    test("builds only the time window for the empty default", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery(
+        MonitorStepProfileMonitorUtil.getDefault(),
+      );
+
+      // Only the rolling time window is present.
+      expect(query.startTime).toBeInstanceOf(InBetween);
+      expect(query.primaryEntityId).toBeUndefined();
+      expect(query.entityKeys).toBeUndefined();
+      expect(query.attributes).toBeUndefined();
+      expect(query.profileType).toBeUndefined();
+    });
+
+    test("builds no filters at all when the time window is disabled", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query).toEqual({});
+    });
+
+    test("scopes to telemetry services when provided", () => {
+      const serviceId: ObjectID = ObjectID.generate();
+
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        telemetryServiceIds: [serviceId],
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.primaryEntityId).toBeInstanceOf(Includes);
+      expect((query.primaryEntityId as Includes).values).toEqual([serviceId]);
+    });
+
+    test("scopes to entity keys when provided", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        entityKeys: ["host-1", "pod-2"],
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.entityKeys).toBeInstanceOf(Includes);
+      expect((query.entityKeys as Includes).values).toEqual([
+        "host-1",
+        "pod-2",
+      ]);
+    });
+
+    test("passes attributes through only when non-empty", () => {
+      const withAttrs: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        attributes: { "service.name": "checkout" },
+        lastXSecondsOfProfiles: 0,
+      });
+      expect(withAttrs.attributes).toEqual({ "service.name": "checkout" });
+
+      const withoutAttrs: Query<Profile> =
+        MonitorStepProfileMonitorUtil.toQuery({
+          ...MonitorStepProfileMonitorUtil.getDefault(),
+          attributes: {},
+          lastXSecondsOfProfiles: 0,
+        });
+      expect(withoutAttrs.attributes).toBeUndefined();
+    });
+
+    test("uses Includes for profileTypes", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        profileTypes: ["cpu", "heap"],
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.profileType).toBeInstanceOf(Includes);
+      expect((query.profileType as unknown as Includes).values).toEqual([
+        "cpu",
+        "heap",
+      ]);
+    });
+
+    test("a single profileType wins over profileTypes as a Search", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        profileTypes: ["cpu", "heap"],
+        profileType: "cpu",
+        lastXSecondsOfProfiles: 0,
+      });
+
+      expect(query.profileType).toBeInstanceOf(Search);
+      expect((query.profileType as unknown as Search<string>).value).toBe(
+        "cpu",
+      );
+    });
+
+    test("builds a bounded time window from lastXSecondsOfProfiles", () => {
+      const query: Query<Profile> = MonitorStepProfileMonitorUtil.toQuery({
+        ...MonitorStepProfileMonitorUtil.getDefault(),
+        lastXSecondsOfProfiles: 120,
+      });
+
+      const window: InBetween<Date> = query.startTime as InBetween<Date>;
+      expect(window).toBeInstanceOf(InBetween);
+
+      const spanMs: number =
+        window.endValue.getTime() - window.startValue.getTime();
+      // 120 seconds, allowing a small margin for clock advance during the call.
+      expect(spanMs).toBeGreaterThanOrEqual(119 * 1000);
+      expect(spanMs).toBeLessThanOrEqual(121 * 1000);
+    });
+  });
+
+  describe("round-trip", () => {
+    test("fromJSON(toJSON(x)) preserves a populated monitor", () => {
+      const monitor: MonitorStepProfileMonitor = {
+        attributes: { env: "prod", replicas: 3, canary: true },
+        profileType: "cpu",
+        profileTypes: ["cpu", "heap"],
+        telemetryServiceIds: [ObjectID.generate(), ObjectID.generate()],
+        entityKeys: ["host-1"],
+        lastXSecondsOfProfiles: 300,
+      };
+
+      const json: JSONObject = MonitorStepProfileMonitorUtil.toJSON(monitor);
+      const roundTripped: MonitorStepProfileMonitor =
+        MonitorStepProfileMonitorUtil.fromJSON(json);
+
+      expect(roundTripped.attributes).toEqual(monitor.attributes);
+      expect(roundTripped.profileType).toBe(monitor.profileType);
+      expect(roundTripped.profileTypes).toEqual(monitor.profileTypes);
+      expect(roundTripped.entityKeys).toEqual(monitor.entityKeys);
+      expect(roundTripped.lastXSecondsOfProfiles).toBe(
+        monitor.lastXSecondsOfProfiles,
+      );
+      expect(
+        roundTripped.telemetryServiceIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ).toEqual(
+        monitor.telemetryServiceIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      );
+    });
+
+    test("fromJSON defaults entityKeys to an empty array when absent", () => {
+      const parsed: MonitorStepProfileMonitor =
+        MonitorStepProfileMonitorUtil.fromJSON({
+          attributes: {},
+          profileType: "",
+          profileTypes: [],
+          telemetryServiceIds: [],
+          lastXSecondsOfProfiles: 60,
+        });
+
+      expect(parsed.entityKeys).toEqual([]);
+    });
+  });
+});

package/Tests/Types/Monitor/MonitorStepSnmpMonitor.test.ts

@@ -0,0 +1,156 @@
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStepSnmpMonitor, {
+  MonitorStepSnmpMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepSnmpMonitor";
+import SnmpAuthProtocol from "../../../Types/Monitor/SnmpMonitor/SnmpAuthProtocol";
+import SnmpPrivProtocol from "../../../Types/Monitor/SnmpMonitor/SnmpPrivProtocol";
+import SnmpSecurityLevel from "../../../Types/Monitor/SnmpMonitor/SnmpSecurityLevel";
+import SnmpVersion from "../../../Types/Monitor/SnmpMonitor/SnmpVersion";
+
+describe("MonitorStepSnmpMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns a v2c community-string monitor on port 161", () => {
+      const def: MonitorStepSnmpMonitor =
+        MonitorStepSnmpMonitorUtil.getDefault();
+
+      expect(def.snmpVersion).toBe(SnmpVersion.V2c);
+      expect(def.hostname).toBe("");
+      expect(def.port).toBe(161);
+      expect(def.communityString).toBe("public");
+      expect(def.oids).toEqual([]);
+      expect(def.timeout).toBe(5000);
+      expect(def.retries).toBe(3);
+      expect(def.monitorInterfaces).toBe(false);
+    });
+  });
+
+  describe("fromJSON defaults", () => {
+    test("fills in defaults for an empty object and leaves v3 auth undefined", () => {
+      const parsed: MonitorStepSnmpMonitor =
+        MonitorStepSnmpMonitorUtil.fromJSON({});
+
+      expect(parsed.snmpVersion).toBe(SnmpVersion.V2c);
+      expect(parsed.port).toBe(161);
+      // An empty/missing community string collapses to undefined.
+      expect(parsed.communityString).toBeUndefined();
+      expect(parsed.snmpV3Auth).toBeUndefined();
+      expect(parsed.oids).toEqual([]);
+      expect(parsed.monitorInterfaces).toBe(false);
+    });
+
+    test("coerces monitorInterfaces to a real boolean", () => {
+      expect(
+        MonitorStepSnmpMonitorUtil.fromJSON({ monitorInterfaces: 1 })
+          .monitorInterfaces,
+      ).toBe(true);
+      expect(
+        MonitorStepSnmpMonitorUtil.fromJSON({ monitorInterfaces: 0 })
+          .monitorInterfaces,
+      ).toBe(false);
+    });
+  });
+
+  describe("fromJSON OID parsing", () => {
+    test("maps each OID and defaults optional name/description to undefined", () => {
+      const parsed: MonitorStepSnmpMonitor =
+        MonitorStepSnmpMonitorUtil.fromJSON({
+          oids: [
+            { oid: "1.3.6.1.2.1.1.3.0", name: "sysUpTime", description: "Up" },
+            { oid: "1.3.6.1.2.1.1.5.0" },
+          ],
+        });
+
+      expect(parsed.oids).toEqual([
+        {
+          oid: "1.3.6.1.2.1.1.3.0",
+          name: "sysUpTime",
+          description: "Up",
+        },
+        {
+          oid: "1.3.6.1.2.1.1.5.0",
+          name: undefined,
+          description: undefined,
+        },
+      ]);
+    });
+  });
+
+  describe("fromJSON v3 auth parsing", () => {
+    test("parses a full authPriv v3 configuration", () => {
+      const parsed: MonitorStepSnmpMonitor =
+        MonitorStepSnmpMonitorUtil.fromJSON({
+          snmpVersion: SnmpVersion.V3,
+          hostname: "10.0.0.1",
+          snmpV3Auth: {
+            securityLevel: SnmpSecurityLevel.AuthPriv,
+            username: "monitor",
+            authProtocol: SnmpAuthProtocol.SHA,
+            authKey: "{{monitorSecrets.authKey}}",
+            privProtocol: SnmpPrivProtocol.AES,
+            privKey: "{{monitorSecrets.privKey}}",
+          },
+        });
+
+      expect(parsed.snmpV3Auth).toEqual({
+        securityLevel: SnmpSecurityLevel.AuthPriv,
+        username: "monitor",
+        authProtocol: SnmpAuthProtocol.SHA,
+        authKey: "{{monitorSecrets.authKey}}",
+        privProtocol: SnmpPrivProtocol.AES,
+        privKey: "{{monitorSecrets.privKey}}",
+      });
+    });
+
+    test("defaults the security level to NoAuthNoPriv when auth is present but empty", () => {
+      const parsed: MonitorStepSnmpMonitor =
+        MonitorStepSnmpMonitorUtil.fromJSON({
+          snmpVersion: SnmpVersion.V3,
+          snmpV3Auth: {},
+        });
+
+      expect(parsed.snmpV3Auth).toEqual({
+        securityLevel: SnmpSecurityLevel.NoAuthNoPriv,
+        username: "",
+        authProtocol: undefined,
+        authKey: undefined,
+        privProtocol: undefined,
+        privKey: undefined,
+      });
+    });
+  });
+
+  describe("round-trip", () => {
+    test("fromJSON(toJSON(x)) preserves a fully populated v3 monitor", () => {
+      const monitor: MonitorStepSnmpMonitor = {
+        snmpVersion: SnmpVersion.V3,
+        hostname: "10.0.0.5",
+        port: 1610,
+        communityString: undefined,
+        snmpV3Auth: {
+          securityLevel: SnmpSecurityLevel.AuthNoPriv,
+          username: "reader",
+          authProtocol: SnmpAuthProtocol.MD5,
+          authKey: "secret",
+          privProtocol: undefined,
+          privKey: undefined,
+        },
+        oids: [
+          {
+            oid: "1.3.6.1.2.1.1.1.0",
+            name: "sysDescr",
+            description: undefined,
+          },
+        ],
+        timeout: 8000,
+        retries: 2,
+        monitorInterfaces: true,
+      };
+
+      const json: JSONObject = MonitorStepSnmpMonitorUtil.toJSON(monitor);
+      const roundTripped: MonitorStepSnmpMonitor =
+        MonitorStepSnmpMonitorUtil.fromJSON(json);
+
+      expect(roundTripped).toEqual(monitor);
+    });
+  });
+});