@oneuptime/common 11.3.5 → 11.3.6

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

@@ -0,0 +1,348 @@
+import {
+  CheckOn,
+  CriteriaFilter,
+  CriteriaFilterUtil,
+  EvaluateOverTimeType,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+
+describe("CriteriaFilterUtil", () => {
+  describe("isAnomalyFilterType", () => {
+    test.each([
+      FilterType.AnomalouslyHigh,
+      FilterType.AnomalouslyLow,
+      FilterType.Anomalous,
+    ])("returns true for %s", (filterType: FilterType) => {
+      expect(CriteriaFilterUtil.isAnomalyFilterType(filterType)).toBe(true);
+    });
+
+    test.each([FilterType.EqualTo, FilterType.GreaterThan])(
+      "returns false for %s",
+      (filterType: FilterType) => {
+        expect(CriteriaFilterUtil.isAnomalyFilterType(filterType)).toBe(false);
+      },
+    );
+
+    test("returns false for undefined", () => {
+      expect(CriteriaFilterUtil.isAnomalyFilterType(undefined)).toBe(false);
+    });
+  });
+
+  describe("hasValueField", () => {
+    test("returns true for a plain threshold filter", () => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn: CheckOn.ResponseTime,
+          filterType: FilterType.GreaterThan,
+        }),
+      ).toBe(true);
+    });
+
+    test("returns false for anomaly filter types", () => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn: CheckOn.MetricValue,
+          filterType: FilterType.AnomalouslyHigh,
+        }),
+      ).toBe(false);
+    });
+
+    test.each([
+      CheckOn.IsOnline,
+      CheckOn.SnmpIsOnline,
+      CheckOn.DnsIsOnline,
+      CheckOn.DomainIsExpired,
+      CheckOn.IsRequestTimeout,
+      CheckOn.SnmpOidExists,
+      CheckOn.IsValidCertificate,
+    ])("returns false for boolean-style checkOn %s", (checkOn: CheckOn) => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn,
+          filterType: FilterType.True,
+        }),
+      ).toBe(false);
+    });
+
+    test.each([
+      FilterType.IsEmpty,
+      FilterType.IsNotEmpty,
+      FilterType.True,
+      FilterType.False,
+    ])(
+      "returns false for valueless filter type %s",
+      (filterType: FilterType) => {
+        expect(
+          CriteriaFilterUtil.hasValueField({
+            checkOn: CheckOn.ResponseBody,
+            filterType,
+          }),
+        ).toBe(false);
+      },
+    );
+
+    test.each([
+      CheckOn.DnssecChainValid,
+      CheckOn.DnssecDnskeyExists,
+      CheckOn.DnssecDsExists,
+      CheckOn.DnssecResolverConsensus,
+      CheckOn.DnssecNameserverConsistent,
+      CheckOn.ExternalStatusPageIsOnline,
+    ])(
+      "returns false for the rest of the boolean checkOn group %s",
+      (checkOn: CheckOn) => {
+        expect(
+          CriteriaFilterUtil.hasValueField({
+            checkOn,
+            filterType: FilterType.GreaterThan,
+          }),
+        ).toBe(false);
+      },
+    );
+
+    test.each([CheckOn.DnssecIsValid, CheckOn.DnsRecordExists])(
+      "returns false for the existence-style checkOn %s",
+      (checkOn: CheckOn) => {
+        expect(
+          CriteriaFilterUtil.hasValueField({
+            checkOn,
+            filterType: FilterType.GreaterThan,
+          }),
+        ).toBe(false);
+      },
+    );
+
+    test.each([
+      FilterType.AnomalouslyHigh,
+      FilterType.AnomalouslyLow,
+      FilterType.Anomalous,
+    ])(
+      "anomaly filter type %s short-circuits even for a normally-valued checkOn",
+      (filterType: FilterType) => {
+        expect(
+          CriteriaFilterUtil.hasValueField({
+            checkOn: CheckOn.ResponseTime,
+            filterType,
+          }),
+        ).toBe(false);
+      },
+    );
+
+    test("returns true for ResponseTime with GreaterThan", () => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn: CheckOn.ResponseTime,
+          filterType: FilterType.GreaterThan,
+        }),
+      ).toBe(true);
+    });
+
+    test("returns true for ResponseStatusCode with EqualTo", () => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn: CheckOn.ResponseStatusCode,
+          filterType: FilterType.EqualTo,
+        }),
+      ).toBe(true);
+    });
+
+    test("returns true for a string-comparison filter that falls through all guards", () => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn: CheckOn.ResponseBody,
+          filterType: FilterType.Contains,
+        }),
+      ).toBe(true);
+    });
+
+    test("returns true when filterType is undefined and checkOn is not valueless", () => {
+      expect(
+        CriteriaFilterUtil.hasValueField({
+          checkOn: CheckOn.ResponseTime,
+          filterType: undefined,
+        }),
+      ).toBe(true);
+    });
+
+    test.each([
+      CheckOn.IsExpiredCertificate,
+      CheckOn.IsNotAValidCertificate,
+      CheckOn.IsSelfSignedCertificate,
+    ])(
+      "returns false for the rest of the certificate checkOn group %s",
+      (checkOn: CheckOn) => {
+        expect(
+          CriteriaFilterUtil.hasValueField({
+            checkOn,
+            filterType: FilterType.GreaterThan,
+          }),
+        ).toBe(false);
+      },
+    );
+  });
+
+  describe("getEvaluateOverTimeTypeByCriteriaFilter", () => {
+    test("returns an empty list when no filter is provided", () => {
+      expect(
+        CriteriaFilterUtil.getEvaluateOverTimeTypeByCriteriaFilter(undefined),
+      ).toEqual([]);
+    });
+
+    test("returns AllValues / AnyValue for IsOnline", () => {
+      const result: Array<EvaluateOverTimeType> =
+        CriteriaFilterUtil.getEvaluateOverTimeTypeByCriteriaFilter({
+          checkOn: CheckOn.IsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        } as CriteriaFilter);
+
+      expect(result).toEqual([
+        EvaluateOverTimeType.AllValues,
+        EvaluateOverTimeType.AnyValue,
+      ]);
+    });
+
+    test("returns the full set of aggregation types for a numeric filter", () => {
+      const result: Array<EvaluateOverTimeType> =
+        CriteriaFilterUtil.getEvaluateOverTimeTypeByCriteriaFilter({
+          checkOn: CheckOn.ResponseTime,
+          filterType: FilterType.GreaterThan,
+          value: 100,
+        } as CriteriaFilter);
+
+      expect(result).toEqual([
+        EvaluateOverTimeType.Average,
+        EvaluateOverTimeType.Sum,
+        EvaluateOverTimeType.MaximumValue,
+        EvaluateOverTimeType.MunimumValue,
+        EvaluateOverTimeType.AllValues,
+        EvaluateOverTimeType.AnyValue,
+      ]);
+    });
+  });
+
+  describe("getInverseFilterType", () => {
+    test.each([
+      [FilterType.GreaterThan, FilterType.LessThanOrEqualTo],
+      [FilterType.LessThan, FilterType.GreaterThanOrEqualTo],
+      [FilterType.GreaterThanOrEqualTo, FilterType.LessThan],
+      [FilterType.LessThanOrEqualTo, FilterType.GreaterThan],
+      [FilterType.EqualTo, FilterType.NotEqualTo],
+      [FilterType.NotEqualTo, FilterType.EqualTo],
+    ])("inverts %s to %s", (input: FilterType, expected: FilterType) => {
+      expect(CriteriaFilterUtil.getInverseFilterType(input)).toBe(expected);
+    });
+
+    test("returns the same filter type when there is no inverse", () => {
+      expect(CriteriaFilterUtil.getInverseFilterType(FilterType.Contains)).toBe(
+        FilterType.Contains,
+      );
+    });
+
+    test.each([
+      FilterType.Contains,
+      FilterType.NotContains,
+      FilterType.StartsWith,
+      FilterType.EndsWith,
+      FilterType.IsEmpty,
+      FilterType.True,
+    ])(
+      "returns %s itself for non-invertible filter types",
+      (filterType: FilterType) => {
+        expect(CriteriaFilterUtil.getInverseFilterType(filterType)).toBe(
+          filterType,
+        );
+      },
+    );
+
+    test("inversion is reversible for comparison filters", () => {
+      const inverse: FilterType = CriteriaFilterUtil.getInverseFilterType(
+        FilterType.GreaterThan,
+      );
+
+      expect(CriteriaFilterUtil.getInverseFilterType(inverse)).toBe(
+        FilterType.GreaterThan,
+      );
+    });
+  });
+
+  describe("isEvaluateOverTimeFilter", () => {
+    test.each([
+      CheckOn.ResponseStatusCode,
+      CheckOn.ResponseTime,
+      CheckOn.CPUUsagePercent,
+      CheckOn.MemoryUsagePercent,
+      CheckOn.IsOnline,
+      CheckOn.DnsResponseTime,
+    ])("returns true for %s", (checkOn: CheckOn) => {
+      expect(CriteriaFilterUtil.isEvaluateOverTimeFilter(checkOn)).toBe(true);
+    });
+
+    test.each([CheckOn.ResponseBody, CheckOn.ResponseHeader, CheckOn.Error])(
+      "returns false for %s",
+      (checkOn: CheckOn) => {
+        expect(CriteriaFilterUtil.isEvaluateOverTimeFilter(checkOn)).toBe(
+          false,
+        );
+      },
+    );
+
+    test.each([
+      CheckOn.ResponseStatusCode,
+      CheckOn.ResponseTime,
+      CheckOn.DiskUsagePercent,
+      CheckOn.CPUUsagePercent,
+      CheckOn.MemoryUsagePercent,
+      CheckOn.LoadAverage1Min,
+      CheckOn.LoadAverage5Min,
+      CheckOn.LoadAverage15Min,
+      CheckOn.SwapUsagePercent,
+      CheckOn.CPUIoWaitPercent,
+      CheckOn.IsOnline,
+      CheckOn.SnmpResponseTime,
+      CheckOn.SnmpIsOnline,
+      CheckOn.DnsResponseTime,
+      CheckOn.DnsIsOnline,
+      CheckOn.ExternalStatusPageResponseTime,
+      CheckOn.ExternalStatusPageIsOnline,
+    ])(
+      "returns true for every evaluate-over-time checkOn %s",
+      (checkOn: CheckOn) => {
+        expect(CriteriaFilterUtil.isEvaluateOverTimeFilter(checkOn)).toBe(true);
+      },
+    );
+
+    test.each([
+      CheckOn.ResponseBody,
+      CheckOn.IncomingRequest,
+      CheckOn.MetricValue,
+    ])(
+      "returns false for non-evaluate-over-time checkOn %s",
+      (checkOn: CheckOn) => {
+        expect(CriteriaFilterUtil.isEvaluateOverTimeFilter(checkOn)).toBe(
+          false,
+        );
+      },
+    );
+  });
+
+  describe("getEvaluateOverTimeTypeByCriteriaFilter (non-IsOnline)", () => {
+    test("returns the full 6-element aggregation set in order for a non-IsOnline checkOn", () => {
+      const result: Array<EvaluateOverTimeType> =
+        CriteriaFilterUtil.getEvaluateOverTimeTypeByCriteriaFilter({
+          checkOn: CheckOn.CPUUsagePercent,
+          filterType: FilterType.GreaterThan,
+          value: 90,
+        } as CriteriaFilter);
+
+      expect(result).toEqual([
+        EvaluateOverTimeType.Average,
+        EvaluateOverTimeType.Sum,
+        EvaluateOverTimeType.MaximumValue,
+        EvaluateOverTimeType.MunimumValue,
+        EvaluateOverTimeType.AllValues,
+        EvaluateOverTimeType.AnyValue,
+      ]);
+    });
+  });
+});

package/Tests/Types/OnCallDutyPolicy/RestrictionTimes.test.ts

@@ -0,0 +1,331 @@
+import DayOfWeek from "../../../Types/Day/DayOfWeek";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import RestrictionTimes, {
+  RestrictionType,
+  WeeklyResctriction,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+
+describe("RestrictionTimes", () => {
+  describe("getDefaultRestrictonTimeData / getDefault", () => {
+    test("default data has no restriction", () => {
+      const data: ReturnType<
+        typeof RestrictionTimes.getDefaultRestrictonTimeData
+      > = RestrictionTimes.getDefaultRestrictonTimeData();
+
+      expect(data.restictionType).toBe(RestrictionType.None);
+      expect(data.dayRestrictionTimes).toBeNull();
+      expect(data.weeklyRestrictionTimes).toEqual([]);
+    });
+
+    test("getDefault returns an instance with no restriction", () => {
+      const restrictionTimes: RestrictionTimes = RestrictionTimes.getDefault();
+
+      expect(restrictionTimes).toBeInstanceOf(RestrictionTimes);
+      expect(restrictionTimes.restictionType).toBe(RestrictionType.None);
+      expect(restrictionTimes.dayRestrictionTimes).toBeNull();
+      expect(restrictionTimes.weeklyRestrictionTimes).toEqual([]);
+    });
+
+    test("getDefaultRestrictonTimeData returns a fresh object each call", () => {
+      const first: ReturnType<
+        typeof RestrictionTimes.getDefaultRestrictonTimeData
+      > = RestrictionTimes.getDefaultRestrictonTimeData();
+      const second: ReturnType<
+        typeof RestrictionTimes.getDefaultRestrictonTimeData
+      > = RestrictionTimes.getDefaultRestrictonTimeData();
+
+      expect(first).not.toBe(second);
+      expect(first.weeklyRestrictionTimes).not.toBe(
+        second.weeklyRestrictionTimes,
+      );
+
+      // Mutating the first call's array must not leak into the second call.
+      first.weeklyRestrictionTimes.push(
+        RestrictionTimes.getDefaultWeeklyRestrictionTIme(),
+      );
+
+      expect(first.weeklyRestrictionTimes.length).toBe(1);
+      expect(second.weeklyRestrictionTimes).toEqual([]);
+    });
+
+    test("getDefault returns a new instance each call", () => {
+      const first: RestrictionTimes = RestrictionTimes.getDefault();
+      const second: RestrictionTimes = RestrictionTimes.getDefault();
+
+      expect(first).not.toBe(second);
+
+      // Mutating one instance must not affect the other.
+      first.addDefaultWeeklyRestriction();
+
+      expect(first.restictionType).toBe(RestrictionType.Weekly);
+      expect(second.restictionType).toBe(RestrictionType.None);
+      expect(second.weeklyRestrictionTimes).toEqual([]);
+    });
+  });
+
+  describe("getDefaultWeeklyRestrictionTIme", () => {
+    test("spans Sunday to Monday with date start/end times", () => {
+      const weekly: WeeklyResctriction =
+        RestrictionTimes.getDefaultWeeklyRestrictionTIme();
+
+      expect(weekly.startDay).toBe(DayOfWeek.Sunday);
+      expect(weekly.endDay).toBe(DayOfWeek.Monday);
+      expect(weekly.startTime).toBeInstanceOf(Date);
+      expect(weekly.endTime).toBeInstanceOf(Date);
+    });
+  });
+
+  describe("addDefaultDailyRestriction", () => {
+    test("sets a daily restriction with day times and clears weekly", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultDailyRestriction();
+
+      expect(restrictionTimes.restictionType).toBe(RestrictionType.Daily);
+      expect(restrictionTimes.dayRestrictionTimes).not.toBeNull();
+      expect(restrictionTimes.dayRestrictionTimes!.startTime).toBeInstanceOf(
+        Date,
+      );
+      expect(restrictionTimes.dayRestrictionTimes!.endTime).toBeInstanceOf(
+        Date,
+      );
+      expect(restrictionTimes.weeklyRestrictionTimes).toEqual([]);
+    });
+
+    test("start time is at 00:00:00 and end time is at 01:00:00", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultDailyRestriction();
+
+      const startTime: Date = restrictionTimes.dayRestrictionTimes!
+        .startTime as Date;
+      const endTime: Date = restrictionTimes.dayRestrictionTimes!
+        .endTime as Date;
+
+      expect(startTime.getHours()).toBe(0);
+      expect(startTime.getMinutes()).toBe(0);
+      expect(startTime.getSeconds()).toBe(0);
+
+      expect(endTime.getHours()).toBe(1);
+      expect(endTime.getMinutes()).toBe(0);
+      expect(endTime.getSeconds()).toBe(0);
+    });
+
+    test("switching from weekly to daily clears the weekly restrictions", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultWeeklyRestriction();
+      expect(restrictionTimes.weeklyRestrictionTimes.length).toBe(1);
+
+      restrictionTimes.addDefaultDailyRestriction();
+
+      expect(restrictionTimes.restictionType).toBe(RestrictionType.Daily);
+      expect(restrictionTimes.weeklyRestrictionTimes).toEqual([]);
+      expect(restrictionTimes.dayRestrictionTimes).not.toBeNull();
+    });
+  });
+
+  describe("addDefaultWeeklyRestriction", () => {
+    test("sets a weekly restriction and clears day times", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultWeeklyRestriction();
+
+      expect(restrictionTimes.restictionType).toBe(RestrictionType.Weekly);
+      expect(restrictionTimes.dayRestrictionTimes).toBeNull();
+      expect(restrictionTimes.weeklyRestrictionTimes.length).toBe(1);
+      expect(restrictionTimes.weeklyRestrictionTimes[0]!.startDay).toBe(
+        DayOfWeek.Sunday,
+      );
+    });
+
+    test("default weekly entry ends on Monday with date start/end times", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultWeeklyRestriction();
+
+      const entry: WeeklyResctriction =
+        restrictionTimes.weeklyRestrictionTimes[0]!;
+
+      expect(entry.endDay).toBe(DayOfWeek.Monday);
+      expect(entry.startTime).toBeInstanceOf(Date);
+      expect(entry.endTime).toBeInstanceOf(Date);
+    });
+
+    test("switching from daily to weekly clears the day restriction", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultDailyRestriction();
+      expect(restrictionTimes.dayRestrictionTimes).not.toBeNull();
+
+      restrictionTimes.addDefaultWeeklyRestriction();
+
+      expect(restrictionTimes.restictionType).toBe(RestrictionType.Weekly);
+      expect(restrictionTimes.dayRestrictionTimes).toBeNull();
+      expect(restrictionTimes.weeklyRestrictionTimes.length).toBe(1);
+    });
+  });
+
+  describe("removeAllRestrictions", () => {
+    test("resets a configured instance back to no restriction", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultWeeklyRestriction();
+
+      restrictionTimes.removeAllRestrictions();
+
+      expect(restrictionTimes.restictionType).toBe(RestrictionType.None);
+      expect(restrictionTimes.dayRestrictionTimes).toBeNull();
+      expect(restrictionTimes.weeklyRestrictionTimes).toEqual([]);
+    });
+  });
+
+  describe("toJSON / fromJSON", () => {
+    test("serializes with the RestrictionTimes object type", () => {
+      const json: JSONObject = new RestrictionTimes().toJSON();
+
+      expect(json["_type"]).toBe(ObjectType.RestrictionTimes);
+      expect(json["value"]).toBeDefined();
+    });
+
+    test("round-trips the restriction type", () => {
+      const original: RestrictionTimes = new RestrictionTimes();
+      original.addDefaultWeeklyRestriction();
+
+      const restored: RestrictionTimes = RestrictionTimes.fromJSON(
+        original.toJSON(),
+      );
+
+      expect(restored).toBeInstanceOf(RestrictionTimes);
+      expect(restored.restictionType).toBe(RestrictionType.Weekly);
+    });
+
+    test("round-trips a daily restriction preserving day times", () => {
+      const original: RestrictionTimes = new RestrictionTimes();
+      original.addDefaultDailyRestriction();
+
+      const restored: RestrictionTimes = RestrictionTimes.fromJSON(
+        original.toJSON(),
+      );
+
+      expect(restored).toBeInstanceOf(RestrictionTimes);
+      expect(restored.restictionType).toBe(RestrictionType.Daily);
+      expect(restored.dayRestrictionTimes).not.toBeNull();
+      expect(restored.dayRestrictionTimes!.startTime).toBeDefined();
+      expect(restored.dayRestrictionTimes!.endTime).toBeDefined();
+    });
+
+    test("falls back to an empty object when weeklyRestrictionTimes is missing", () => {
+      /*
+       * The source uses `(data["weeklyRestrictionTimes"] ...) || {}`, so when the
+       * value object omits weeklyRestrictionTimes the fallback is an empty object
+       * (NOT an empty array). This documents that quirky behavior precisely.
+       */
+      const restored: RestrictionTimes = RestrictionTimes.fromJSON({
+        _type: ObjectType.RestrictionTimes,
+        value: {
+          restictionType: RestrictionType.None,
+          dayRestrictionTimes: null,
+        },
+      });
+
+      expect(restored.weeklyRestrictionTimes).toEqual({});
+      expect(Array.isArray(restored.weeklyRestrictionTimes)).toBe(false);
+    });
+
+    test("preserves a provided weeklyRestrictionTimes array on fromJSON", () => {
+      const restored: RestrictionTimes = RestrictionTimes.fromJSON({
+        _type: ObjectType.RestrictionTimes,
+        value: {
+          restictionType: RestrictionType.None,
+          dayRestrictionTimes: null,
+          weeklyRestrictionTimes: [],
+        },
+      });
+
+      expect(restored.weeklyRestrictionTimes).toEqual([]);
+      expect(Array.isArray(restored.weeklyRestrictionTimes)).toBe(true);
+    });
+
+    test("throws BadDataException when given null", () => {
+      expect(() => {
+        RestrictionTimes.fromJSON(null as unknown as JSONObject);
+      }).toThrowError(BadDataException);
+    });
+
+    test("returns the same instance when given a RestrictionTimes", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+
+      expect(RestrictionTimes.fromJSON(restrictionTimes)).toBe(
+        restrictionTimes,
+      );
+    });
+
+    test("throws BadDataException for a missing object type", () => {
+      expect(() => {
+        RestrictionTimes.fromJSON({});
+      }).toThrowError(BadDataException);
+    });
+
+    test("throws BadDataException when value is missing", () => {
+      expect(() => {
+        RestrictionTimes.fromJSON({ _type: ObjectType.RestrictionTimes });
+      }).toThrowError(BadDataException);
+    });
+  });
+
+  describe("toDatabase / fromDatabase", () => {
+    /*
+     * toDatabase and fromDatabase are protected static overrides; reach them
+     * through a typed accessor so the database (de)serialization branches are
+     * exercised directly.
+     */
+    type DbAccessor = {
+      toDatabase(value: unknown): JSONObject | null;
+      fromDatabase(value: JSONObject): RestrictionTimes | null;
+    };
+    const accessor: DbAccessor = RestrictionTimes as unknown as DbAccessor;
+
+    test("toDatabase serializes a RestrictionTimes instance to its JSON", () => {
+      const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+      restrictionTimes.addDefaultWeeklyRestriction();
+
+      const db: JSONObject | null = accessor.toDatabase(restrictionTimes);
+
+      expect(db).not.toBeNull();
+      expect(db!["_type"]).toBe(ObjectType.RestrictionTimes);
+      expect(db).toEqual(restrictionTimes.toJSON());
+    });
+
+    test("toDatabase serializes a plain value object when not an instance", () => {
+      const plain: JSONObject = {
+        _type: ObjectType.RestrictionTimes,
+        value: {
+          restictionType: RestrictionType.None,
+          dayRestrictionTimes: null,
+          weeklyRestrictionTimes: [],
+        },
+      };
+
+      const db: JSONObject | null = accessor.toDatabase(plain);
+
+      expect(db).not.toBeNull();
+      expect(db!["_type"]).toBe(ObjectType.RestrictionTimes);
+    });
+
+    test("toDatabase returns null for a falsy value", () => {
+      expect(accessor.toDatabase(null)).toBeNull();
+      expect(accessor.toDatabase(undefined)).toBeNull();
+    });
+
+    test("fromDatabase rebuilds a RestrictionTimes from stored JSON", () => {
+      const original: RestrictionTimes = new RestrictionTimes();
+      original.addDefaultWeeklyRestriction();
+
+      const restored: RestrictionTimes | null = accessor.fromDatabase(
+        original.toJSON(),
+      );
+
+      expect(restored).toBeInstanceOf(RestrictionTimes);
+      expect(restored!.restictionType).toBe(RestrictionType.Weekly);
+    });
+
+    test("fromDatabase returns null for a falsy value", () => {
+      expect(accessor.fromDatabase(null as unknown as JSONObject)).toBeNull();
+    });
+  });
+});