@oneuptime/common 11.5.9 → 11.5.11

package/Tests/Types/Database/LessThan.test.ts

@@ -0,0 +1,62 @@
+import LessThan from "../../../Types/BaseDatabase/LessThan";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("LessThan", () => {
+  it("should create a LessThan object with a valid value", () => {
+    const value: number = 42;
+    const obj: LessThan<number> = new LessThan<number>(value);
+    expect(obj.value).toBe(value);
+  });
+
+  it("should get and set the value property", () => {
+    const obj: LessThan<number> = new LessThan<number>(1);
+    obj.value = 2;
+    expect(obj.value).toBe(2);
+  });
+
+  it("should return the correct string representation using toString", () => {
+    const obj: LessThan<number> = new LessThan<number>(42);
+    expect(obj.toString()).toBe("42");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: LessThan<number> = new LessThan<number>(42);
+    const expectedJSON: JSONObject = {
+      _type: "LessThan",
+      value: "42",
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a LessThan object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "LessThan",
+      value: "42",
+    };
+    const obj: LessThan<number> = LessThan.fromJSON(jsonInput);
+    expect(obj.value).toBe("42");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "42",
+    };
+    expect(() => {
+      return LessThan.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of LessThan", () => {
+    const obj: LessThan<number> = new LessThan<number>(42);
+    expect(obj).toBeInstanceOf(LessThan);
+  });
+
+  it("should handle date values", () => {
+    const value: Date = new Date("2023-01-01");
+    const obj: LessThan<Date> = new LessThan<Date>(value);
+    expect(obj.value).toBe(value);
+  });
+});

package/Tests/Types/Database/LessThanOrEqual.test.ts

@@ -0,0 +1,62 @@
+import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("LessThanOrEqual", () => {
+  it("should create a LessThanOrEqual object with a valid value", () => {
+    const value: number = 42;
+    const obj: LessThanOrEqual<number> = new LessThanOrEqual<number>(value);
+    expect(obj.value).toBe(value);
+  });
+
+  it("should get and set the value property", () => {
+    const obj: LessThanOrEqual<number> = new LessThanOrEqual<number>(1);
+    obj.value = 2;
+    expect(obj.value).toBe(2);
+  });
+
+  it("should return the correct string representation using toString", () => {
+    const obj: LessThanOrEqual<number> = new LessThanOrEqual<number>(42);
+    expect(obj.toString()).toBe("42");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: LessThanOrEqual<number> = new LessThanOrEqual<number>(42);
+    const expectedJSON: JSONObject = {
+      _type: "LessThanOrEqual",
+      value: "42",
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a LessThanOrEqual object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "LessThanOrEqual",
+      value: "42",
+    };
+    const obj: LessThanOrEqual<number> = LessThanOrEqual.fromJSON(jsonInput);
+    expect(obj.value).toBe("42");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "42",
+    };
+    expect(() => {
+      return LessThanOrEqual.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of LessThanOrEqual", () => {
+    const obj: LessThanOrEqual<number> = new LessThanOrEqual<number>(42);
+    expect(obj).toBeInstanceOf(LessThanOrEqual);
+  });
+
+  it("should handle date values", () => {
+    const value: Date = new Date("2023-01-01");
+    const obj: LessThanOrEqual<Date> = new LessThanOrEqual<Date>(value);
+    expect(obj.value).toBe(value);
+  });
+});

package/Tests/Types/Database/LessThanOrNull.test.ts

@@ -0,0 +1,62 @@
+import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("LessThanOrNull", () => {
+  it("should create a LessThanOrNull object with a valid value", () => {
+    const value: number = 42;
+    const obj: LessThanOrNull<number> = new LessThanOrNull<number>(value);
+    expect(obj.value).toBe(value);
+  });
+
+  it("should get and set the value property", () => {
+    const obj: LessThanOrNull<number> = new LessThanOrNull<number>(1);
+    obj.value = 2;
+    expect(obj.value).toBe(2);
+  });
+
+  it("should return the correct string representation using toString", () => {
+    const obj: LessThanOrNull<number> = new LessThanOrNull<number>(42);
+    expect(obj.toString()).toBe("42");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: LessThanOrNull<number> = new LessThanOrNull<number>(42);
+    const expectedJSON: JSONObject = {
+      _type: "LessThanOrNull",
+      value: "42",
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a LessThanOrNull object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "LessThanOrNull",
+      value: "42",
+    };
+    const obj: LessThanOrNull<number> = LessThanOrNull.fromJSON(jsonInput);
+    expect(obj.value).toBe("42");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "42",
+    };
+    expect(() => {
+      return LessThanOrNull.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of LessThanOrNull", () => {
+    const obj: LessThanOrNull<number> = new LessThanOrNull<number>(42);
+    expect(obj).toBeInstanceOf(LessThanOrNull);
+  });
+
+  it("should handle date values", () => {
+    const value: Date = new Date("2023-01-01");
+    const obj: LessThanOrNull<Date> = new LessThanOrNull<Date>(value);
+    expect(obj.value).toBe(value);
+  });
+});

package/Tests/Types/Database/MultiSearch.test.ts

@@ -0,0 +1,81 @@
+import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("MultiSearch", () => {
+  it("should create a MultiSearch object with fields and value", () => {
+    const obj: MultiSearch = new MultiSearch({
+      fields: ["name", "email"],
+      value: "demo",
+    });
+    expect(obj.fields).toEqual(["name", "email"]);
+    expect(obj.value).toBe("demo");
+  });
+
+  it("should get and set the fields and value properties", () => {
+    const obj: MultiSearch = new MultiSearch({ fields: ["a"], value: "x" });
+    obj.fields = ["b", "c"];
+    obj.value = "y";
+    expect(obj.fields).toEqual(["b", "c"]);
+    expect(obj.value).toBe("y");
+  });
+
+  it("should return the value using toString", () => {
+    const obj: MultiSearch = new MultiSearch({
+      fields: ["name"],
+      value: "demo",
+    });
+    expect(obj.toString()).toBe("demo");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: MultiSearch = new MultiSearch({
+      fields: ["name"],
+      value: "demo",
+    });
+    const expectedJSON: JSONObject = {
+      _type: "MultiSearch",
+      value: "demo",
+      fields: ["name"],
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a MultiSearch object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "MultiSearch",
+      value: "demo",
+      fields: ["name"],
+    };
+    const obj: MultiSearch = MultiSearch.fromJSON(jsonInput);
+    expect(obj.value).toBe("demo");
+    expect(obj.fields).toEqual(["name"]);
+  });
+
+  it("should default fields and value when missing in the JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "MultiSearch",
+    };
+    const obj: MultiSearch = MultiSearch.fromJSON(jsonInput);
+    expect(obj.fields).toEqual([]);
+    expect(obj.value).toBe("");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+    };
+    expect(() => {
+      return MultiSearch.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of MultiSearch", () => {
+    const obj: MultiSearch = new MultiSearch({
+      fields: ["name"],
+      value: "demo",
+    });
+    expect(obj).toBeInstanceOf(MultiSearch);
+  });
+});

package/Tests/Types/Database/NotContains.test.ts

@@ -0,0 +1,64 @@
+import NotContains from "../../../Types/BaseDatabase/NotContains";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("NotContains", () => {
+  it("should create a NotContains object with a valid value", () => {
+    const value: string = "oneuptime";
+    const obj: NotContains<string> = new NotContains<string>(value);
+    expect(obj.value).toBe(value);
+  });
+
+  it("should get and set the value property", () => {
+    const obj: NotContains<string> = new NotContains<string>("oldValue");
+    obj.value = "newValue";
+    expect(obj.value).toBe("newValue");
+  });
+
+  it("should return the value using toString", () => {
+    const obj: NotContains<string> = new NotContains<string>("oneuptime");
+    expect(obj.toString()).toBe("oneuptime");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: NotContains<string> = new NotContains<string>("oneuptime");
+    const expectedJSON: JSONObject = {
+      _type: "NotContains",
+      value: "oneuptime",
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a NotContains object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "NotContains",
+      value: "oneuptime",
+    };
+    const obj: NotContains<string> = NotContains.fromJSON(jsonInput);
+    expect(obj.value).toBe("oneuptime");
+  });
+
+  it("should default to an empty string when the JSON value is missing", () => {
+    const jsonInput: JSONObject = {
+      _type: "NotContains",
+    };
+    const obj: NotContains<string> = NotContains.fromJSON(jsonInput);
+    expect(obj.value).toBe("");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "oneuptime",
+    };
+    expect(() => {
+      return NotContains.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of NotContains", () => {
+    const obj: NotContains<string> = new NotContains<string>("oneuptime");
+    expect(obj).toBeInstanceOf(NotContains);
+  });
+});

package/Tests/Types/Database/NotNull.test.ts

@@ -0,0 +1,44 @@
+import NotNull from "../../../Types/BaseDatabase/NotNull";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("NotNull", () => {
+  it("should create a NotNull object", () => {
+    const obj: NotNull = new NotNull();
+    expect(obj).toBeInstanceOf(NotNull);
+  });
+
+  it("should return an empty string using toString", () => {
+    const obj: NotNull = new NotNull();
+    expect(obj.toString()).toBe("");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: NotNull = new NotNull();
+    const expectedJSON: JSONObject = {
+      _type: "NotNull",
+      value: null,
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a NotNull object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "NotNull",
+      value: null,
+    };
+    const obj: NotNull = NotNull.fromJSON(jsonInput);
+    expect(obj).toBeInstanceOf(NotNull);
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: null,
+    };
+    expect(() => {
+      return NotNull.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+});

package/Tests/Types/Database/StartsWith.test.ts

@@ -0,0 +1,64 @@
+import StartsWith from "../../../Types/BaseDatabase/StartsWith";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("StartsWith", () => {
+  it("should create a StartsWith object with a valid value", () => {
+    const value: string = "oneuptime";
+    const obj: StartsWith<string> = new StartsWith<string>(value);
+    expect(obj.value).toBe(value);
+  });
+
+  it("should get and set the value property", () => {
+    const obj: StartsWith<string> = new StartsWith<string>("oldValue");
+    obj.value = "newValue";
+    expect(obj.value).toBe("newValue");
+  });
+
+  it("should return the value using toString", () => {
+    const obj: StartsWith<string> = new StartsWith<string>("oneuptime");
+    expect(obj.toString()).toBe("oneuptime");
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: StartsWith<string> = new StartsWith<string>("oneuptime");
+    const expectedJSON: JSONObject = {
+      _type: "StartsWith",
+      value: "oneuptime",
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create a StartsWith object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "StartsWith",
+      value: "oneuptime",
+    };
+    const obj: StartsWith<string> = StartsWith.fromJSON(jsonInput);
+    expect(obj.value).toBe("oneuptime");
+  });
+
+  it("should default to an empty string when the JSON value is missing", () => {
+    const jsonInput: JSONObject = {
+      _type: "StartsWith",
+    };
+    const obj: StartsWith<string> = StartsWith.fromJSON(jsonInput);
+    expect(obj.value).toBe("");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "oneuptime",
+    };
+    expect(() => {
+      return StartsWith.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of StartsWith", () => {
+    const obj: StartsWith<string> = new StartsWith<string>("oneuptime");
+    expect(obj).toBeInstanceOf(StartsWith);
+  });
+});

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

@@ -12,6 +12,33 @@ import MonitorStepSqlMonitor, {
 } from "../../../Types/Monitor/MonitorStepSqlMonitor";
 import SqlDatabaseType from "../../../Types/Monitor/SqlDatabaseType";
 import { JSONObject } from "../../../Types/JSON";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+
+const getSqlMonitorStep: (
+  overrides?: Partial<MonitorStepSqlMonitor>,
+) => MonitorStep = (
+  overrides: Partial<MonitorStepSqlMonitor> = {},
+): MonitorStep => {
+  const id: ObjectID = ObjectID.generate();
+  const monitorStep: MonitorStep = MonitorStep.getDefaultMonitorStep({
+    monitorName: "SQL monitor",
+    monitorType: MonitorType.SQLQuery,
+    onlineMonitorStatusId: id,
+    offlineMonitorStatusId: id,
+    defaultIncidentSeverityId: id,
+    defaultAlertSeverityId: id,
+  });
+
+  return monitorStep.setSqlMonitor({
+    ...MonitorStepSqlMonitorUtil.getDefault(),
+    host: "sql.internal",
+    databaseName: "orders",
+    query: "SELECT 1",
+    ...overrides,
+  });
+};
 
 describe("MonitorStepSqlMonitorUtil", () => {
   describe("getDefault", () => {
@@ -20,6 +47,7 @@ describe("MonitorStepSqlMonitorUtil", () => {
       expect(def.databaseType).toBe(SqlDatabaseType.PostgreSQL);
       expect(def.port).toBe(5432);
       expect(def.useSsl).toBe(false);
+      expect(def.useWindowsIntegratedAuthentication).toBe(false);
       expect(def.rejectUnauthorizedSsl).toBe(true);
       expect(def.statementTimeoutInMs).toBe(
         DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
@@ -62,12 +90,13 @@ describe("MonitorStepSqlMonitorUtil", () => {
   describe("fromJSON/toJSON round-trip", () => {
     test("preserves values and clamps out-of-range inputs", () => {
       const json: JSONObject = {
-        databaseType: SqlDatabaseType.PostgreSQL,
+        databaseType: SqlDatabaseType.MicrosoftSqlServer,
         host: "db.internal",
         port: 5433,
         databaseName: "orders",
         username: "readonly",
         password: "{{monitorSecrets.dbPass}}",
+        useWindowsIntegratedAuthentication: true,
         useSsl: true,
         rejectUnauthorizedSsl: false,
         query: "SELECT COUNT(*) FROM orders",
@@ -82,6 +111,7 @@ describe("MonitorStepSqlMonitorUtil", () => {
       expect(parsed.host).toBe("db.internal");
       expect(parsed.port).toBe(5433);
       expect(parsed.password).toBe("{{monitorSecrets.dbPass}}");
+      expect(parsed.useWindowsIntegratedAuthentication).toBe(true);
       expect(parsed.useSsl).toBe(true);
       expect(parsed.rejectUnauthorizedSsl).toBe(false);
       // clamped
@@ -105,6 +135,58 @@ describe("MonitorStepSqlMonitorUtil", () => {
       });
       expect(parsed.rejectUnauthorizedSsl).toBe(true);
       expect(parsed.useSsl).toBe(false);
+      expect(parsed.useWindowsIntegratedAuthentication).toBe(false);
+    });
+
+    test("serializes an explicit false value for older SQL monitor configurations", () => {
+      const json: JSONObject = MonitorStepSqlMonitorUtil.toJSON(
+        MonitorStepSqlMonitorUtil.getDefault(),
+      );
+
+      expect(json["useWindowsIntegratedAuthentication"]).toBe(false);
+    });
+  });
+
+  describe("MonitorStep validation", () => {
+    test("accepts integrated authentication for Microsoft SQL Server", () => {
+      const monitorStep: MonitorStep = getSqlMonitorStep({
+        databaseType: SqlDatabaseType.MicrosoftSqlServer,
+        port: 1433,
+        username: "",
+        password: "",
+        useWindowsIntegratedAuthentication: true,
+      });
+
+      expect(
+        MonitorStep.getValidationError(monitorStep, MonitorType.SQLQuery),
+      ).toBeNull();
+    });
+
+    test.each([SqlDatabaseType.PostgreSQL, SqlDatabaseType.MySQL])(
+      "rejects integrated authentication for %s",
+      (databaseType: SqlDatabaseType) => {
+        const monitorStep: MonitorStep = getSqlMonitorStep({
+          databaseType,
+          useWindowsIntegratedAuthentication: true,
+        });
+
+        expect(
+          MonitorStep.getValidationError(monitorStep, MonitorType.SQLQuery),
+        ).toBe(
+          "Windows Integrated Authentication is only supported for Microsoft SQL Server",
+        );
+      },
+    );
+
+    test("preserves validation compatibility for SQL-login monitors", () => {
+      const monitorStep: MonitorStep = getSqlMonitorStep({
+        databaseType: SqlDatabaseType.PostgreSQL,
+        useWindowsIntegratedAuthentication: false,
+      });
+
+      expect(
+        MonitorStep.getValidationError(monitorStep, MonitorType.SQLQuery),
+      ).toBeNull();
     });
   });
 });