@oneuptime/common 12.0.4 → 12.0.5

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

@@ -0,0 +1,118 @@
+import {
+  KubernetesMetricCategory,
+  KubernetesMetricDefinition,
+  getAllKubernetesMetricCategories,
+  getAllKubernetesMetrics,
+  getKubernetesMetricById,
+  getKubernetesMetricByMetricName,
+  getKubernetesMetricsByCategory,
+} from "../../../Types/Monitor/KubernetesMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("KubernetesMetricCatalog", () => {
+  const allMetrics: Array<KubernetesMetricDefinition> =
+    getAllKubernetesMetrics();
+  const allCategories: Array<KubernetesMetricCategory> =
+    getAllKubernetesMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map(
+      (m: KubernetesMetricDefinition) => {
+        return m.id;
+      },
+    );
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map(
+      (m: KubernetesMetricDefinition) => {
+        return m.metricName;
+      },
+    );
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getKubernetesMetricsByCategory(category).length).toBeGreaterThan(
+        0,
+      );
+    }
+  });
+
+  test("getKubernetesMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getKubernetesMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getKubernetesMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getKubernetesMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getKubernetesMetricById returns undefined for an unknown id", () => {
+    expect(getKubernetesMetricById("does-not-exist")).toBeUndefined();
+    expect(getKubernetesMetricById("")).toBeUndefined();
+  });
+
+  test("getKubernetesMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getKubernetesMetricByMetricName(metric.metricName)).toEqual(
+        metric,
+      );
+    }
+  });
+
+  test("getKubernetesMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getKubernetesMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(
+      getKubernetesMetricByMetricName("k8s.pod.cpu.utilization"),
+    ).toBeDefined();
+    expect(
+      getKubernetesMetricByMetricName("k8s.pod.memory.usage"),
+    ).toBeDefined();
+  });
+});

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

@@ -146,6 +146,28 @@ describe("MonitorCriteriaInstance", () => {
         });
       expect(instance).toBeNull();
     });
+
+    /*
+     * A domain whose registration data cannot be read has no expiry date, so
+     * DomainIsExpired cannot decide anything. Requiring IsOnline as well is
+     * what stops an unreadable registration from being reported as healthy
+     * (issue #3046).
+     */
+    test("Domain monitor requires a successful lookup as well as a live registration", () => {
+      const instance: MonitorCriteriaInstance | null =
+        MonitorCriteriaInstance.getDefaultOnlineMonitorCriteriaInstance({
+          monitorType: MonitorType.Domain,
+          monitorStatusId,
+          monitorName: "identity.digital",
+        });
+
+      expect(instance?.data?.filterCondition).toBe(FilterCondition.All);
+      expect(instance?.data?.filters).toHaveLength(2);
+      expect(instance?.data?.filters[0]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(instance?.data?.filters[0]?.filterType).toBe(FilterType.True);
+      expect(instance?.data?.filters[1]?.checkOn).toBe(CheckOn.DomainIsExpired);
+      expect(instance?.data?.filters[1]?.filterType).toBe(FilterType.False);
+    });
   });
 
   describe("getDefaultOfflineMonitorCriteriaInstance", () => {
@@ -181,6 +203,26 @@ describe("MonitorCriteriaInstance", () => {
       );
       expect(instance.data?.incidents[0]?.title).toContain("Edge");
     });
+
+    test("Domain offline criteria fires on an expired registration or a failed lookup", () => {
+      const instance: MonitorCriteriaInstance =
+        MonitorCriteriaInstance.getDefaultOfflineMonitorCriteriaInstance({
+          monitorType: MonitorType.Domain,
+          monitorStatusId: new ObjectID("bbbbbbbbbbbbbbbbbbbbbbbb"),
+          incidentSeverityId: new ObjectID("cccccccccccccccccccccccc"),
+          alertSeverityId: new ObjectID("dddddddddddddddddddddddd"),
+          monitorName: "identity.digital",
+        });
+
+      expect(instance.data?.filterCondition).toBe(FilterCondition.Any);
+      expect(instance.data?.filters).toHaveLength(2);
+      expect(instance.data?.filters[0]?.checkOn).toBe(CheckOn.DomainIsExpired);
+      expect(instance.data?.filters[0]?.filterType).toBe(FilterType.True);
+      expect(instance.data?.filters[1]?.checkOn).toBe(CheckOn.IsOnline);
+      expect(instance.data?.filters[1]?.filterType).toBe(FilterType.False);
+      expect(instance.data?.createIncidents).toBe(true);
+      expect(instance.data?.incidents[0]?.title).toContain("identity.digital");
+    });
   });
 
   describe("getValidationError", () => {

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

@@ -1,5 +1,6 @@
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import MonitorType from "../../../Types/Monitor/MonitorType";
+import DomainLookupMethod from "../../../Types/Monitor/DomainMonitor/DomainLookupMethod";
 import ObjectID from "../../../Types/ObjectID";
 import HTTPMethod from "../../../Types/API/HTTPMethod";
 import { JSONObject, ObjectType } from "../../../Types/JSON";
@@ -179,5 +180,42 @@ describe("MonitorStep", () => {
       const parsed: JSONObject = JSON.parse(step.toString()) as JSONObject;
       expect(parsed["_type"]).toBe(ObjectType.MonitorStep);
     });
+
+    /*
+     * Domain monitors saved before the lookupMethod option existed carry no
+     * such key. fromJSON has to fill it in, because the probe reads the
+     * deserialized config directly and its type says the field is present.
+     */
+    function restoreWithDomainMonitor(domainMonitor: JSONObject): JSONObject {
+      const json: JSONObject =
+        MonitorStep.getDefaultMonitorStep(DEFAULT_ARG).toJSON();
+
+      (json["value"] as JSONObject)["domainMonitor"] = domainMonitor;
+
+      return MonitorStep.fromJSON(json).data
+        ?.domainMonitor as unknown as JSONObject;
+    }
+
+    test("fills in the domain monitor lookup method for a step saved without one", () => {
+      const domainMonitor: JSONObject = restoreWithDomainMonitor({
+        domainName: "identity.digital",
+        timeout: 10000,
+        retries: 3,
+      });
+
+      expect(domainMonitor["domainName"]).toBe("identity.digital");
+      expect(domainMonitor["lookupMethod"]).toBe(DomainLookupMethod.Auto);
+    });
+
+    test("preserves an explicitly chosen domain monitor lookup method", () => {
+      const domainMonitor: JSONObject = restoreWithDomainMonitor({
+        domainName: "identity.digital",
+        lookupMethod: DomainLookupMethod.WHOIS,
+        timeout: 10000,
+        retries: 3,
+      });
+
+      expect(domainMonitor["lookupMethod"]).toBe(DomainLookupMethod.WHOIS);
+    });
   });
 });

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

@@ -1,4 +1,5 @@
 import { JSONObject } from "../../../Types/JSON";
+import DomainLookupMethod from "../../../Types/Monitor/DomainMonitor/DomainLookupMethod";
 import MonitorStepDomainMonitor, {
   MonitorStepDomainMonitorUtil,
 } from "../../../Types/Monitor/MonitorStepDomainMonitor";
@@ -13,6 +14,16 @@ describe("MonitorStepDomainMonitorUtil", () => {
       expect(def.timeout).toBe(10000);
       expect(def.retries).toBe(3);
     });
+
+    /*
+     * Auto rather than RDAP: about half the ccTLDs (.io, .co, .de, ...)
+     * publish no RDAP service, so RDAP-only would break them.
+     */
+    test("defaults to the Auto lookup method", () => {
+      expect(MonitorStepDomainMonitorUtil.getDefault().lookupMethod).toBe(
+        DomainLookupMethod.Auto,
+      );
+    });
   });
 
   describe("fromJSON", () => {
@@ -20,11 +31,13 @@ describe("MonitorStepDomainMonitorUtil", () => {
       const parsed: MonitorStepDomainMonitor =
         MonitorStepDomainMonitorUtil.fromJSON({
           domainName: "oneuptime.com",
+          lookupMethod: DomainLookupMethod.RDAP,
           timeout: 3000,
           retries: 7,
         });
 
       expect(parsed.domainName).toBe("oneuptime.com");
+      expect(parsed.lookupMethod).toBe(DomainLookupMethod.RDAP);
       expect(parsed.timeout).toBe(3000);
       expect(parsed.retries).toBe(7);
     });
@@ -41,12 +54,54 @@ describe("MonitorStepDomainMonitorUtil", () => {
       expect(parsed.timeout).toBe(10000);
       expect(parsed.retries).toBe(3);
     });
+
+    /*
+     * Every domain monitor saved before RDAP support existed has no
+     * lookupMethod key at all, and must keep working.
+     */
+    test("treats a monitor saved without a lookup method as Auto", () => {
+      const parsed: MonitorStepDomainMonitor =
+        MonitorStepDomainMonitorUtil.fromJSON({
+          domainName: "identity.digital",
+          timeout: 10000,
+          retries: 3,
+        });
+
+      expect(parsed.lookupMethod).toBe(DomainLookupMethod.Auto);
+    });
+
+    test("treats an unrecognised lookup method as Auto", () => {
+      expect(
+        MonitorStepDomainMonitorUtil.fromJSON({ lookupMethod: "" })
+          .lookupMethod,
+      ).toBe(DomainLookupMethod.Auto);
+
+      expect(
+        MonitorStepDomainMonitorUtil.fromJSON({ lookupMethod: "Telepathy" })
+          .lookupMethod,
+      ).toBe(DomainLookupMethod.Auto);
+
+      expect(
+        MonitorStepDomainMonitorUtil.fromJSON({ lookupMethod: 42 })
+          .lookupMethod,
+      ).toBe(DomainLookupMethod.Auto);
+    });
+
+    test("accepts every declared lookup method", () => {
+      for (const method of Object.values(DomainLookupMethod)) {
+        expect(
+          MonitorStepDomainMonitorUtil.fromJSON({ lookupMethod: method })
+            .lookupMethod,
+        ).toBe(method);
+      }
+    });
   });
 
   describe("round-trip", () => {
     test("toJSON emits every field and fromJSON restores it", () => {
       const monitor: MonitorStepDomainMonitor = {
         domainName: "example.com",
+        lookupMethod: DomainLookupMethod.WHOIS,
         timeout: 5000,
         retries: 2,
       };
@@ -57,4 +112,24 @@ describe("MonitorStepDomainMonitorUtil", () => {
       expect(MonitorStepDomainMonitorUtil.fromJSON(json)).toEqual(monitor);
     });
   });
+
+  describe("parseLookupMethod", () => {
+    test("accepts the declared values and rejects anything else", () => {
+      expect(MonitorStepDomainMonitorUtil.parseLookupMethod("RDAP")).toBe(
+        DomainLookupMethod.RDAP,
+      );
+      expect(MonitorStepDomainMonitorUtil.parseLookupMethod("WHOIS")).toBe(
+        DomainLookupMethod.WHOIS,
+      );
+      expect(MonitorStepDomainMonitorUtil.parseLookupMethod("rdap")).toBe(
+        DomainLookupMethod.Auto,
+      );
+      expect(MonitorStepDomainMonitorUtil.parseLookupMethod(null)).toBe(
+        DomainLookupMethod.Auto,
+      );
+      expect(MonitorStepDomainMonitorUtil.parseLookupMethod(undefined)).toBe(
+        DomainLookupMethod.Auto,
+      );
+    });
+  });
 });

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

@@ -0,0 +1,109 @@
+import {
+  PodmanMetricCategory,
+  PodmanMetricDefinition,
+  getAllPodmanMetricCategories,
+  getAllPodmanMetrics,
+  getPodmanMetricById,
+  getPodmanMetricByMetricName,
+  getPodmanMetricsByCategory,
+} from "../../../Types/Monitor/PodmanMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("PodmanMetricCatalog", () => {
+  const allMetrics: Array<PodmanMetricDefinition> = getAllPodmanMetrics();
+  const allCategories: Array<PodmanMetricCategory> =
+    getAllPodmanMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: PodmanMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map((m: PodmanMetricDefinition) => {
+      return m.metricName;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getPodmanMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getPodmanMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getPodmanMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getPodmanMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getPodmanMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getPodmanMetricById returns undefined for an unknown id", () => {
+    expect(getPodmanMetricById("does-not-exist")).toBeUndefined();
+    expect(getPodmanMetricById("")).toBeUndefined();
+  });
+
+  test("getPodmanMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getPodmanMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getPodmanMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getPodmanMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(
+      getPodmanMetricByMetricName("container.cpu.usage.total"),
+    ).toBeDefined();
+    expect(
+      getPodmanMetricByMetricName("container.cpu.utilization"),
+    ).toBeDefined();
+  });
+});

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

@@ -0,0 +1,107 @@
+import {
+  ProxmoxMetricCategory,
+  ProxmoxMetricDefinition,
+  getAllProxmoxMetricCategories,
+  getAllProxmoxMetrics,
+  getProxmoxMetricById,
+  getProxmoxMetricByMetricName,
+  getProxmoxMetricsByCategory,
+} from "../../../Types/Monitor/ProxmoxMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ProxmoxMetricCatalog", () => {
+  const allMetrics: Array<ProxmoxMetricDefinition> = getAllProxmoxMetrics();
+  const allCategories: Array<ProxmoxMetricCategory> =
+    getAllProxmoxMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: ProxmoxMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map(
+      (m: ProxmoxMetricDefinition) => {
+        return m.metricName;
+      },
+    );
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getProxmoxMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getProxmoxMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getProxmoxMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getProxmoxMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getProxmoxMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getProxmoxMetricById returns undefined for an unknown id", () => {
+    expect(getProxmoxMetricById("does-not-exist")).toBeUndefined();
+    expect(getProxmoxMetricById("")).toBeUndefined();
+  });
+
+  test("getProxmoxMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getProxmoxMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getProxmoxMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getProxmoxMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(getProxmoxMetricByMetricName("pve_up")).toBeDefined();
+    expect(getProxmoxMetricByMetricName("pve_uptime_seconds")).toBeDefined();
+  });
+});