@oneuptime/common 12.0.8 → 12.0.9

package/Tests/Server/Utils/Monitor/Criteria/SSLMonitorCriteria.test.ts

@@ -0,0 +1,468 @@
+import SSLMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/SSLMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import SslMonitorResponse from "../../../../../Types/Monitor/SSLMonitor/SslMonitorResponse";
+import ProbeMonitorResponse from "../../../../../Types/Probe/ProbeMonitorResponse";
+import ObjectID from "../../../../../Types/ObjectID";
+
+function dateFromNow(input: { days?: number; hours?: number }): Date {
+  const ms: number =
+    (input.days ?? 0) * 24 * 60 * 60 * 1000 +
+    (input.hours ?? 0) * 60 * 60 * 1000;
+  return new Date(Date.now() + ms);
+}
+
+function buildDataToProcess(input: {
+  isOnline?: boolean;
+  isTimeout?: boolean;
+  sslResponse?: SslMonitorResponse | undefined;
+  includeSslResponse?: boolean;
+}): ProbeMonitorResponse {
+  const includeSsl: boolean = input.includeSslResponse ?? true;
+
+  return {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    monitorStepId: ObjectID.generate(),
+    probeId: ObjectID.generate(),
+    failureCause: "",
+    isOnline: input.isOnline ?? true,
+    isTimeout: input.isTimeout,
+    responseTimeInMs: 42,
+    sslResponse: includeSsl ? input.sslResponse : undefined,
+    monitoredAt: new Date(),
+  };
+}
+
+async function evaluate(
+  dataToProcess: ProbeMonitorResponse,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return SSLMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess,
+    criteriaFilter,
+  });
+}
+
+describe("SSLMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  describe("IsOnline", () => {
+    test("online + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("online + False → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    test("offline + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: false }),
+        {
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+  });
+
+  describe("IsRequestTimeout", () => {
+    test("timed out + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: false, isTimeout: true }),
+        {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("did not time out + True → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true, isTimeout: false }),
+        {
+          checkOn: CheckOn.IsRequestTimeout,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("IsValidCertificate", () => {
+    /*
+     * A certificate counts as valid only when the host is online, the response
+     * carries an expiry that is still in the future, and the cert is not
+     * self-signed.
+     */
+    test("valid cert + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: true,
+          sslResponse: {
+            expiresAt: dateFromNow({ days: 30 }),
+            isSelfSigned: false,
+          },
+        }),
+        {
+          checkOn: CheckOn.IsValidCertificate,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is valid.");
+    });
+
+    test("self-signed cert is not valid + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: true,
+          sslResponse: {
+            expiresAt: dateFromNow({ days: 30 }),
+            isSelfSigned: true,
+          },
+        }),
+        {
+          checkOn: CheckOn.IsValidCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is not valid.");
+    });
+
+    test("valid cert + False → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: true,
+          sslResponse: {
+            expiresAt: dateFromNow({ days: 30 }),
+            isSelfSigned: false,
+          },
+        }),
+        {
+          checkOn: CheckOn.IsValidCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    test("offline host makes the cert invalid + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: false,
+          sslResponse: {
+            expiresAt: dateFromNow({ days: 30 }),
+            isSelfSigned: false,
+          },
+        }),
+        {
+          checkOn: CheckOn.IsValidCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is not valid.");
+    });
+  });
+
+  describe("IsSelfSignedCertificate", () => {
+    test("self-signed + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { isSelfSigned: true },
+        }),
+        {
+          checkOn: CheckOn.IsSelfSignedCertificate,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL Certificate is self signed.");
+    });
+
+    test("not self-signed + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { isSelfSigned: false },
+        }),
+        {
+          checkOn: CheckOn.IsSelfSignedCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL Certificate is not self signed.");
+    });
+
+    test("no ssl response counts as not self-signed + True → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ includeSslResponse: false }),
+        {
+          checkOn: CheckOn.IsSelfSignedCertificate,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("IsExpiredCertificate", () => {
+    test("expired cert + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ days: -1 }) },
+        }),
+        {
+          checkOn: CheckOn.IsExpiredCertificate,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is expired.");
+    });
+
+    test("not-yet-expired cert + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ days: 30 }) },
+        }),
+        {
+          checkOn: CheckOn.IsExpiredCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is not expired.");
+    });
+
+    /*
+     * With no expiry present the cert cannot be judged expired, so a False
+     * filter still reports "not expired".
+     */
+    test("no expiry present + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ sslResponse: {} }),
+        {
+          checkOn: CheckOn.IsExpiredCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is not expired.");
+    });
+  });
+
+  describe("IsNotAValidCertificate", () => {
+    test("expired cert is not valid + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: true,
+          sslResponse: {
+            expiresAt: dateFromNow({ days: -1 }),
+            isSelfSigned: false,
+          },
+        }),
+        {
+          checkOn: CheckOn.IsNotAValidCertificate,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is not valid.");
+    });
+
+    test("healthy cert + False → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          isOnline: true,
+          sslResponse: {
+            expiresAt: dateFromNow({ days: 30 }),
+            isSelfSigned: false,
+          },
+        }),
+        {
+          checkOn: CheckOn.IsNotAValidCertificate,
+          filterType: FilterType.False,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is valid.");
+    });
+
+    test("missing ssl response is treated as not valid + True → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ isOnline: true, includeSslResponse: false }),
+        {
+          checkOn: CheckOn.IsNotAValidCertificate,
+          filterType: FilterType.True,
+          value: undefined,
+        },
+      );
+
+      expect(result).toBe("SSL certificate is not valid.");
+    });
+  });
+
+  describe("ExpiresInHours", () => {
+    test("~48h left + LessThan 72 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ hours: 48 }) },
+        }),
+        {
+          checkOn: CheckOn.ExpiresInHours,
+          filterType: FilterType.LessThan,
+          value: 72,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("~48h left + GreaterThan 72 → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ hours: 48 }) },
+        }),
+        {
+          checkOn: CheckOn.ExpiresInHours,
+          filterType: FilterType.GreaterThan,
+          value: 72,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    // A falsy (zero) or unparseable threshold makes the filter undecidable.
+    test("zero threshold → undecidable", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ hours: 48 }) },
+        }),
+        {
+          checkOn: CheckOn.ExpiresInHours,
+          filterType: FilterType.LessThan,
+          value: 0,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    test("no expiry present → undecidable", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ sslResponse: {} }),
+        {
+          checkOn: CheckOn.ExpiresInHours,
+          filterType: FilterType.LessThan,
+          value: 72,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("ExpiresInDays", () => {
+    test("~10 days left + LessThan 30 → met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ days: 10 }) },
+        }),
+        {
+          checkOn: CheckOn.ExpiresInDays,
+          filterType: FilterType.LessThan,
+          value: 30,
+        },
+      );
+
+      expect(result).toBeTruthy();
+    });
+
+    test("~90 days left + LessThan 30 → not met", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({
+          sslResponse: { expiresAt: dateFromNow({ days: 90 }) },
+        }),
+        {
+          checkOn: CheckOn.ExpiresInDays,
+          filterType: FilterType.LessThan,
+          value: 30,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+
+    test("no expiry present → undecidable", async () => {
+      const result: string | null = await evaluate(
+        buildDataToProcess({ sslResponse: {} }),
+        {
+          checkOn: CheckOn.ExpiresInDays,
+          filterType: FilterType.LessThan,
+          value: 30,
+        },
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  test("an unrelated CheckOn is not claimed by this evaluator", async () => {
+    const result: string | null = await evaluate(
+      buildDataToProcess({ sslResponse: {} }),
+      {
+        checkOn: CheckOn.ResponseTime,
+        filterType: FilterType.LessThan,
+        value: 1000,
+      },
+    );
+
+    expect(result).toBeNull();
+  });
+});