@oneuptime/common 11.6.1 → 11.7.0

package/Tests/Types/Log/LogQueryToFilter.test.ts

@@ -0,0 +1,111 @@
+import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
+import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
+import LessThan from "../../../Types/BaseDatabase/LessThan";
+import NotEqual from "../../../Types/BaseDatabase/NotEqual";
+import Search from "../../../Types/BaseDatabase/Search";
+import {
+  LogFilter,
+  queryStringToFilter,
+} from "../../../Types/Log/LogQueryToFilter";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * queryStringToFilter turns the log search bar's query string into a
+ * Query<Log>-shaped filter. It sits on top of the (separately tested)
+ * LogQueryParser, so these tests focus on the mapping layer: operator ->
+ * BaseDatabase value type, top-level vs @attribute routing, severity casing
+ * normalization, and free-text accumulation into body Search.
+ */
+
+describe("queryStringToFilter - free text", () => {
+  test("empty query yields an empty filter", () => {
+    expect(queryStringToFilter("")).toEqual({});
+  });
+
+  test("bare words become a body Search", () => {
+    const filter: LogFilter = queryStringToFilter("connection refused");
+    expect(filter.body).toBeInstanceOf(Search);
+    expect((filter.body as Search<string>).toString()).toBe(
+      "connection refused",
+    );
+  });
+});
+
+describe("queryStringToFilter - top-level fields", () => {
+  test("severity:error normalizes to title-case Error as an equals match", () => {
+    const filter: LogFilter = queryStringToFilter("severity:error");
+    expect(filter.severityText).toBe("Error");
+  });
+
+  test("level:warn aliases to severityText and normalizes warn -> Warning", () => {
+    const filter: LogFilter = queryStringToFilter("level:warn");
+    expect(filter.severityText).toBe("Warning");
+  });
+
+  test("service:api maps to primaryEntityId", () => {
+    const filter: LogFilter = queryStringToFilter("service:api");
+    expect(filter.primaryEntityId).toBe("api");
+  });
+
+  test("negation produces a NotEqual with normalized severity", () => {
+    const filter: LogFilter = queryStringToFilter("-severity:debug");
+    expect(filter.severityText).toBeInstanceOf(NotEqual);
+    expect((filter.severityText as unknown as NotEqual<string>).value).toBe(
+      "Debug",
+    );
+  });
+
+  test("wildcard produces a Search with the asterisks stripped", () => {
+    const filter: LogFilter = queryStringToFilter("service:api-*");
+    expect(filter.primaryEntityId).toBeInstanceOf(Search);
+    expect(
+      (filter.primaryEntityId as unknown as Search<string>).toString(),
+    ).toBe("api-");
+  });
+});
+
+describe("queryStringToFilter - attribute fields", () => {
+  test("@http.status_code:500 lands under attributes as an equals string", () => {
+    const filter: LogFilter = queryStringToFilter("@http.status_code:500");
+    expect(filter.attributes).toEqual({ "http.status_code": "500" });
+  });
+
+  test("numeric comparison operators parse the value as a number", () => {
+    const gt: LogFilter = queryStringToFilter("@duration:>1000");
+    expect(gt.attributes!["duration"]).toBeInstanceOf(GreaterThan);
+    expect((gt.attributes!["duration"] as GreaterThan<number>).value).toBe(
+      1000,
+    );
+
+    const gte: LogFilter = queryStringToFilter("@duration:>=1000");
+    expect(gte.attributes!["duration"]).toBeInstanceOf(GreaterThanOrEqual);
+
+    const lt: LogFilter = queryStringToFilter("@duration:<50");
+    expect(lt.attributes!["duration"]).toBeInstanceOf(LessThan);
+    expect((lt.attributes!["duration"] as LessThan<number>).value).toBe(50);
+  });
+
+  test("a non-numeric comparison value stays a string", () => {
+    const filter: LogFilter = queryStringToFilter("@version:>abc");
+    expect((filter.attributes!["version"] as GreaterThan<string>).value).toBe(
+      "abc",
+    );
+  });
+
+  test("negated attribute filter produces a NotEqual", () => {
+    const filter: LogFilter = queryStringToFilter("-@http.method:GET");
+    expect(filter.attributes!["http.method"]).toBeInstanceOf(NotEqual);
+    expect((filter.attributes!["http.method"] as NotEqual<string>).value).toBe(
+      "GET",
+    );
+  });
+});
+
+describe("queryStringToFilter - combinations", () => {
+  test("a field filter plus trailing free text populate distinct slots", () => {
+    const filter: LogFilter = queryStringToFilter("severity:error timeout");
+    expect(filter.severityText).toBe("Error");
+    expect(filter.body).toBeInstanceOf(Search);
+    expect((filter.body as Search<string>).toString()).toBe("timeout");
+  });
+});

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

@@ -0,0 +1,155 @@
+import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * MonitorCriteria wraps the ordered list of MonitorCriteriaInstance that a
+ * monitor step evaluates. These tests lock in the default builder (which
+ * composes the online + offline instances), the validation contract (which
+ * delegates to each instance), and the toJSON/fromJSON round-trip.
+ */
+
+const DEFAULT_ARG: {
+  monitorType: MonitorType;
+  monitorName: string;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+} = {
+  monitorType: MonitorType.Ping,
+  monitorName: "Gateway",
+  onlineMonitorStatusId: new ObjectID("100000000000000000000011"),
+  offlineMonitorStatusId: new ObjectID("100000000000000000000012"),
+  defaultIncidentSeverityId: new ObjectID("100000000000000000000013"),
+  defaultAlertSeverityId: new ObjectID("100000000000000000000014"),
+};
+
+describe("MonitorCriteria", () => {
+  describe("getDefaultMonitorCriteria", () => {
+    test("composes both an offline and an online instance for Ping", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+
+      // Ping has both an offline (Disallow) and an online criteria instance.
+      expect(criteria.data?.monitorCriteriaInstanceArray).toHaveLength(2);
+      for (const instance of criteria.data!.monitorCriteriaInstanceArray) {
+        expect(instance).toBeInstanceOf(MonitorCriteriaInstance);
+      }
+    });
+
+    test("the default Ping criteria passes validation", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBeNull();
+    });
+  });
+
+  describe("getValidationError", () => {
+    test("errors when data is missing", () => {
+      const criteria: MonitorCriteria = new MonitorCriteria();
+      criteria.data = undefined;
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBe("Monitor Criteria is required");
+    });
+
+    test("errors when the instance array is empty", () => {
+      const criteria: MonitorCriteria = new MonitorCriteria();
+      criteria.data = { monitorCriteriaInstanceArray: [] };
+      expect(
+        MonitorCriteria.getValidationError(criteria, MonitorType.Ping),
+      ).toBe("Monitor Criteria is required");
+    });
+
+    test("propagates a validation error from a contained instance", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      // Corrupt a contained instance: strip its required name.
+      criteria.data!.monitorCriteriaInstanceArray[0]!.data!.name = "";
+      const error: string | null = MonitorCriteria.getValidationError(
+        criteria,
+        MonitorType.Ping,
+      );
+      expect(error).toContain("Name is required");
+    });
+  });
+
+  describe("getNewMonitorCriteriaAsJSON", () => {
+    test("wraps a single default instance", () => {
+      const json: JSONObject = MonitorCriteria.getNewMonitorCriteriaAsJSON();
+      expect(json["_type"]).toBe("MonitorCriteria");
+      const value: JSONObject = json["value"] as JSONObject;
+      expect(Array.isArray(value["monitorCriteriaInstanceArray"])).toBe(true);
+      expect(
+        (value["monitorCriteriaInstanceArray"] as Array<unknown>).length,
+      ).toBe(1);
+    });
+  });
+
+  describe("toJSON / fromJSON round-trip", () => {
+    test("serializes with the MonitorCriteria type wrapper", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const json: JSONObject = criteria.toJSON();
+      expect(json["_type"]).toBe(ObjectType.MonitorCriteria);
+    });
+
+    test("round-trips the instance count", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const restored: MonitorCriteria = MonitorCriteria.fromJSON(
+        criteria.toJSON(),
+      );
+      expect(restored.data?.monitorCriteriaInstanceArray).toHaveLength(2);
+      expect(restored.data?.monitorCriteriaInstanceArray[0]).toBeInstanceOf(
+        MonitorCriteriaInstance,
+      );
+    });
+
+    test("toString returns a JSON string of the serialized value", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      const parsed: JSONObject = JSON.parse(criteria.toString()) as JSONObject;
+      expect(parsed["_type"]).toBe(ObjectType.MonitorCriteria);
+    });
+  });
+
+  describe("fromJSON validation", () => {
+    test("returns the same instance when given a MonitorCriteria", () => {
+      const criteria: MonitorCriteria =
+        MonitorCriteria.getDefaultMonitorCriteria(DEFAULT_ARG);
+      expect(MonitorCriteria.fromJSON(criteria as unknown as JSONObject)).toBe(
+        criteria,
+      );
+    });
+
+    test("throws on a wrong _type", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({ _type: "Nope", value: {} });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when value is missing", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({
+          _type: ObjectType.MonitorCriteria,
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("throws when monitorCriteriaInstanceArray is missing", () => {
+      expect(() => {
+        return MonitorCriteria.fromJSON({
+          _type: ObjectType.MonitorCriteria,
+          value: {},
+        });
+      }).toThrow(BadDataException);
+    });
+  });
+});