@oneuptime/common 11.5.9 → 11.5.11

package/Tests/Types/BaseDatabase/AggregationIntervalUtil.test.ts

@@ -22,8 +22,45 @@ describe("AggregationIntervalUtil", () => {
         3 * HOUR,
         AggregationInterval.Minute,
       ],
-      ["3 hours + 1ms -> Hour", 3 * HOUR + 1, AggregationInterval.Hour],
-      ["1 day -> Hour", DAY, AggregationInterval.Hour],
+      [
+        "3 hours + 1ms -> FiveMinutes",
+        3 * HOUR + 1,
+        AggregationInterval.FiveMinutes,
+      ],
+      ["4 hours -> FiveMinutes", 4 * HOUR, AggregationInterval.FiveMinutes],
+      [
+        "exactly 12 hours -> FiveMinutes (inclusive bound)",
+        12 * HOUR,
+        AggregationInterval.FiveMinutes,
+      ],
+      [
+        "12 hours + 1ms -> FifteenMinutes",
+        12 * HOUR + 1,
+        AggregationInterval.FifteenMinutes,
+      ],
+      [
+        "18 hours -> FifteenMinutes",
+        18 * HOUR,
+        AggregationInterval.FifteenMinutes,
+      ],
+      [
+        "exactly 24 hours -> FifteenMinutes (inclusive bound)",
+        24 * HOUR,
+        AggregationInterval.FifteenMinutes,
+      ],
+      [
+        "24 hours + 1ms -> ThirtyMinutes",
+        24 * HOUR + 1,
+        AggregationInterval.ThirtyMinutes,
+      ],
+      ["2 days -> ThirtyMinutes", 2 * DAY, AggregationInterval.ThirtyMinutes],
+      [
+        "exactly 3 days -> ThirtyMinutes (inclusive bound)",
+        3 * DAY,
+        AggregationInterval.ThirtyMinutes,
+      ],
+      ["3 days + 1ms -> Hour", 3 * DAY + 1, AggregationInterval.Hour],
+      ["5 days -> Hour", 5 * DAY, AggregationInterval.Hour],
       [
         "exactly 7 days -> Hour (inclusive bound)",
         7 * DAY,
@@ -84,6 +121,9 @@ describe("AggregationIntervalUtil", () => {
     test("returns the widest interval as the window grows", () => {
       const order: Array<AggregationInterval> = [
         AggregationInterval.Minute,
+        AggregationInterval.FiveMinutes,
+        AggregationInterval.FifteenMinutes,
+        AggregationInterval.ThirtyMinutes,
         AggregationInterval.Hour,
         AggregationInterval.Day,
         AggregationInterval.Week,
@@ -92,7 +132,10 @@ describe("AggregationIntervalUtil", () => {
       ];
       const durations: Array<number> = [
         HOUR,
+        6 * HOUR,
+        18 * HOUR,
         2 * DAY,
+        5 * DAY,
         30 * DAY,
         90 * DAY,
         365 * DAY,
@@ -119,6 +162,9 @@ describe("AggregationIntervalUtil", () => {
   describe("getAggregationIntervalMs", () => {
     test.each([
       [AggregationInterval.Minute, 1000 * 60],
+      [AggregationInterval.FiveMinutes, 1000 * 60 * 5],
+      [AggregationInterval.FifteenMinutes, 1000 * 60 * 15],
+      [AggregationInterval.ThirtyMinutes, 1000 * 60 * 30],
       [AggregationInterval.Hour, 1000 * 60 * 60],
       [AggregationInterval.Day, 1000 * 60 * 60 * 24],
       [AggregationInterval.Week, 1000 * 60 * 60 * 24 * 7],
@@ -148,6 +194,9 @@ describe("AggregationIntervalUtil", () => {
     test("intervals are strictly increasing in width", () => {
       const ordered: Array<AggregationInterval> = [
         AggregationInterval.Minute,
+        AggregationInterval.FiveMinutes,
+        AggregationInterval.FifteenMinutes,
+        AggregationInterval.ThirtyMinutes,
         AggregationInterval.Hour,
         AggregationInterval.Day,
         AggregationInterval.Week,
@@ -164,4 +213,64 @@ describe("AggregationIntervalUtil", () => {
       }
     });
   });
+
+  describe("floorDateToIntervalGrid", () => {
+    // 2020-01-01T00:00:00Z is on every sub-day epoch grid.
+    const gridOrigin: number = Date.UTC(2020, 0, 1, 0, 0, 0);
+
+    test.each([
+      // [interval, offset into the bucket, expected floored offset]
+      [AggregationInterval.Minute, 37 * 1000, 0],
+      [AggregationInterval.FiveMinutes, 4 * 60 * 1000 + 12 * 1000, 0],
+      [
+        AggregationInterval.FiveMinutes,
+        7 * 60 * 1000, // 00:07 floors to 00:05
+        5 * 60 * 1000,
+      ],
+      [
+        AggregationInterval.FifteenMinutes,
+        22 * 60 * 1000, // 00:22 floors to 00:15
+        15 * 60 * 1000,
+      ],
+      [
+        AggregationInterval.ThirtyMinutes,
+        44 * 60 * 1000, // 00:44 floors to 00:30
+        30 * 60 * 1000,
+      ],
+      [AggregationInterval.Hour, 59 * 60 * 1000, 0],
+    ])(
+      "floors %s timestamps down to the bucket boundary",
+      (
+        interval: AggregationInterval,
+        offsetMs: number,
+        expectedOffsetMs: number,
+      ) => {
+        const floored: Date = AggregationIntervalUtil.floorDateToIntervalGrid(
+          new Date(gridOrigin + offsetMs),
+          interval,
+        );
+        expect(floored.getTime()).toBe(gridOrigin + expectedOffsetMs);
+      },
+    );
+
+    test("a timestamp already on the 15-minute grid is unchanged", () => {
+      const onGrid: Date = new Date(gridOrigin + 45 * 60 * 1000);
+      expect(
+        AggregationIntervalUtil.floorDateToIntervalGrid(
+          onGrid,
+          AggregationInterval.FifteenMinutes,
+        ).getTime(),
+      ).toBe(onGrid.getTime());
+    });
+
+    test("calendar intervals (Week) are returned unchanged", () => {
+      const midWeek: Date = new Date(gridOrigin + 3 * 24 * 60 * 60 * 1000);
+      expect(
+        AggregationIntervalUtil.floorDateToIntervalGrid(
+          midWeek,
+          AggregationInterval.Week,
+        ).getTime(),
+      ).toBe(midWeek.getTime());
+    });
+  });
 });

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,65 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("Includes", () => {
+  it("should create an Includes object with string values", () => {
+    const values: Array<string> = ["a", "b"];
+    const obj: Includes = new Includes(values);
+    expect(obj.values).toEqual(values);
+  });
+
+  it("should get and set the values property", () => {
+    const obj: Includes = new Includes(["a"]);
+    obj.values = ["c", "d"];
+    expect(obj.values).toEqual(["c", "d"]);
+  });
+
+  it("should handle numeric values", () => {
+    const values: Array<number> = [1, 2, 3];
+    const obj: Includes = new Includes(values);
+    expect(obj.values).toEqual(values);
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: Includes = new Includes(["a", "b"]);
+    const expectedJSON: JSONObject = {
+      _type: "Includes",
+      value: ["a", "b"],
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create an Includes object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "Includes",
+      value: ["a", "b"],
+    };
+    const obj: Includes = Includes.fromJSON(jsonInput);
+    expect(obj.values).toEqual(["a", "b"]);
+  });
+
+  it("should default to an empty array when the JSON value is missing", () => {
+    const jsonInput: JSONObject = {
+      _type: "Includes",
+    };
+    const obj: Includes = Includes.fromJSON(jsonInput);
+    expect(obj.values).toEqual([]);
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: [],
+    };
+    expect(() => {
+      return Includes.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of Includes", () => {
+    const obj: Includes = new Includes(["a"]);
+    expect(obj).toBeInstanceOf(Includes);
+  });
+});

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

@@ -0,0 +1,65 @@
+import IncludesAll from "../../../Types/BaseDatabase/IncludesAll";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("IncludesAll", () => {
+  it("should create an IncludesAll object with string values", () => {
+    const values: Array<string> = ["a", "b"];
+    const obj: IncludesAll = new IncludesAll(values);
+    expect(obj.values).toEqual(values);
+  });
+
+  it("should get and set the values property", () => {
+    const obj: IncludesAll = new IncludesAll(["a"]);
+    obj.values = ["c", "d"];
+    expect(obj.values).toEqual(["c", "d"]);
+  });
+
+  it("should handle numeric values", () => {
+    const values: Array<number> = [1, 2, 3];
+    const obj: IncludesAll = new IncludesAll(values);
+    expect(obj.values).toEqual(values);
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: IncludesAll = new IncludesAll(["a", "b"]);
+    const expectedJSON: JSONObject = {
+      _type: "IncludesAll",
+      value: ["a", "b"],
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create an IncludesAll object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "IncludesAll",
+      value: ["a", "b"],
+    };
+    const obj: IncludesAll = IncludesAll.fromJSON(jsonInput);
+    expect(obj.values).toEqual(["a", "b"]);
+  });
+
+  it("should default to an empty array when the JSON value is missing", () => {
+    const jsonInput: JSONObject = {
+      _type: "IncludesAll",
+    };
+    const obj: IncludesAll = IncludesAll.fromJSON(jsonInput);
+    expect(obj.values).toEqual([]);
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: [],
+    };
+    expect(() => {
+      return IncludesAll.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of IncludesAll", () => {
+    const obj: IncludesAll = new IncludesAll(["a"]);
+    expect(obj).toBeInstanceOf(IncludesAll);
+  });
+});

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

@@ -0,0 +1,65 @@
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("IncludesNone", () => {
+  it("should create an IncludesNone object with string values", () => {
+    const values: Array<string> = ["a", "b"];
+    const obj: IncludesNone = new IncludesNone(values);
+    expect(obj.values).toEqual(values);
+  });
+
+  it("should get and set the values property", () => {
+    const obj: IncludesNone = new IncludesNone(["a"]);
+    obj.values = ["c", "d"];
+    expect(obj.values).toEqual(["c", "d"]);
+  });
+
+  it("should handle numeric values", () => {
+    const values: Array<number> = [1, 2, 3];
+    const obj: IncludesNone = new IncludesNone(values);
+    expect(obj.values).toEqual(values);
+  });
+
+  it("should generate the correct JSON representation using toJSON", () => {
+    const obj: IncludesNone = new IncludesNone(["a", "b"]);
+    const expectedJSON: JSONObject = {
+      _type: "IncludesNone",
+      value: ["a", "b"],
+    };
+    expect(obj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create an IncludesNone object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "IncludesNone",
+      value: ["a", "b"],
+    };
+    const obj: IncludesNone = IncludesNone.fromJSON(jsonInput);
+    expect(obj.values).toEqual(["a", "b"]);
+  });
+
+  it("should default to an empty array when the JSON value is missing", () => {
+    const jsonInput: JSONObject = {
+      _type: "IncludesNone",
+    };
+    const obj: IncludesNone = IncludesNone.fromJSON(jsonInput);
+    expect(obj.values).toEqual([]);
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: [],
+    };
+    expect(() => {
+      return IncludesNone.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be an instance of IncludesNone", () => {
+    const obj: IncludesNone = new IncludesNone(["a"]);
+    expect(obj).toBeInstanceOf(IncludesNone);
+  });
+});

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

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