@oneuptime/common 12.0.4 → 12.0.6

package/Tests/Utils/Telemetry/CaptureSpanExportGating.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, jest, test, beforeEach } from "@jest/globals";
+
+/*
+ * Contract under test — @CaptureSpan's export gating.
+ *
+ * The decorator wraps ~hundreds of methods, some of which sit on per-record
+ * telemetry ingest paths. It must be a plain method call (no span, no
+ * attribute flattening, no AsyncLocalStorage transition) whenever no span
+ * exporter is installed — spans that are never exported are pure overhead —
+ * and only build the attribute object when there is actually something to
+ * attach. When an exporter IS installed it must keep the full original
+ * behavior: named span, OK status on success, recorded exception + rethrow
+ * on failure, for both sync and async methods.
+ */
+
+type JestMock = ReturnType<typeof jest.fn>;
+
+type FakeSpan = {
+  setStatus: JestMock;
+  end: JestMock;
+};
+
+const fakeSpan: FakeSpan = {
+  setStatus: jest.fn(),
+  end: jest.fn(),
+};
+
+let spanExportEnabled: boolean = false;
+
+const startActiveSpanMock: JestMock = jest.fn((data: any) => {
+  return data.fn(fakeSpan);
+});
+const recordExceptionMock: JestMock = jest.fn();
+
+jest.mock("../../../Server/Utils/Telemetry", () => {
+  return {
+    __esModule: true,
+    default: {
+      isSpanExportEnabled: (): boolean => {
+        return spanExportEnabled;
+      },
+      startActiveSpan: (data: unknown): unknown => {
+        return startActiveSpanMock(data);
+      },
+      recordExceptionMarkSpanAsErrorAndEndSpan: (data: unknown): unknown => {
+        return recordExceptionMock(data);
+      },
+    },
+  };
+});
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../Server/EnvironmentConfig",
+  ) as Record<string, unknown>;
+  return {
+    ...actual,
+    DisableTelemetry: false,
+  };
+});
+
+import CaptureSpan from "../../../Server/Utils/Telemetry/CaptureSpan";
+
+/*
+ * Apply the decorator exactly the way TypeScript does for a static method,
+ * without relying on decorator syntax support in the test transform.
+ */
+function decorate(
+  data: Parameters<typeof CaptureSpan>[0] | undefined,
+  fn: (...args: Array<any>) => any,
+  methodName: string = "method",
+): (...args: Array<any>) => any {
+  class Host {}
+  const descriptor: TypedPropertyDescriptor<any> = { value: fn };
+  CaptureSpan(data)(Host, methodName, descriptor);
+  return descriptor.value;
+}
+
+beforeEach(() => {
+  spanExportEnabled = false;
+  startActiveSpanMock.mockClear();
+  recordExceptionMock.mockClear();
+  fakeSpan.setStatus.mockClear();
+  fakeSpan.end.mockClear();
+});
+
+describe("CaptureSpan with no span exporter installed", () => {
+  test("calls the original method directly and creates no span", () => {
+    const original: JestMock = jest.fn().mockReturnValue("result");
+    const wrapped: (...args: Array<any>) => any = decorate(undefined, original);
+
+    expect(wrapped("a", 1)).toBe("result");
+    expect(original).toHaveBeenCalledWith("a", 1);
+    expect(startActiveSpanMock).not.toHaveBeenCalled();
+  });
+
+  test("preserves `this` binding", () => {
+    const wrapped: (...args: Array<any>) => any = decorate(
+      undefined,
+      function (this: { value: number }): number {
+        return this.value;
+      },
+    );
+
+    expect(wrapped.call({ value: 42 })).toBe(42);
+  });
+
+  test("async results and rejections pass through untouched", async () => {
+    const wrappedOk: (...args: Array<any>) => any = decorate(
+      undefined,
+      async (): Promise<string> => {
+        return "async-result";
+      },
+    );
+    await expect(wrappedOk()).resolves.toBe("async-result");
+
+    const boom: Error = new Error("boom");
+    const wrappedFail: (...args: Array<any>) => any = decorate(
+      undefined,
+      async (): Promise<never> => {
+        throw boom;
+      },
+    );
+    await expect(wrappedFail()).rejects.toBe(boom);
+    expect(startActiveSpanMock).not.toHaveBeenCalled();
+  });
+
+  test("sync throws pass through untouched", () => {
+    const boom: Error = new Error("sync-boom");
+    const wrapped: (...args: Array<any>) => any = decorate(undefined, () => {
+      throw boom;
+    });
+
+    expect(() => {
+      return wrapped();
+    }).toThrow(boom);
+    expect(startActiveSpanMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("CaptureSpan with a span exporter installed", () => {
+  beforeEach(() => {
+    spanExportEnabled = true;
+  });
+
+  test("creates a span named Class.method and returns the result", () => {
+    const wrapped: (...args: Array<any>) => any = decorate(
+      undefined,
+      () => {
+        return "spanned";
+      },
+      "doWork",
+    );
+
+    expect(wrapped()).toBe("spanned");
+    expect(startActiveSpanMock).toHaveBeenCalledTimes(1);
+
+    const callData: any = startActiveSpanMock.mock.calls[0]![0];
+    expect(callData.name).toBe("Host.doWork");
+    expect(fakeSpan.setStatus).toHaveBeenCalledWith({ code: 1 }); // OK
+    expect(fakeSpan.end).toHaveBeenCalledTimes(1);
+  });
+
+  test("bare @CaptureSpan() attaches no attributes (flattening skipped)", () => {
+    const wrapped: (...args: Array<any>) => any = decorate(undefined, () => {
+      return "x";
+    });
+    wrapped("argument-that-must-not-be-captured");
+
+    const callData: any = startActiveSpanMock.mock.calls[0]![0];
+    expect(callData.options).toEqual({});
+  });
+
+  test("captureArguments flattens call arguments into span attributes", () => {
+    const wrapped: (...args: Array<any>) => any = decorate(
+      { captureArguments: true },
+      () => {
+        return "x";
+      },
+    );
+    wrapped("first", { nested: { key: "v" } });
+
+    const callData: any = startActiveSpanMock.mock.calls[0]![0];
+    expect(callData.options.attributes["arg0"]).toBe("first");
+    expect(callData.options.attributes["arg1.nested.key"]).toBe("v");
+  });
+
+  test("static attributes are attached", () => {
+    const wrapped: (...args: Array<any>) => any = decorate(
+      { attributes: { component: "test" } },
+      () => {
+        return "x";
+      },
+    );
+    wrapped();
+
+    const callData: any = startActiveSpanMock.mock.calls[0]![0];
+    expect(callData.options.attributes["component"]).toBe("test");
+  });
+
+  test("async success marks the span OK and ends it", async () => {
+    const wrapped: (...args: Array<any>) => any = decorate(
+      undefined,
+      async (): Promise<string> => {
+        return "ok";
+      },
+    );
+
+    await expect(wrapped()).resolves.toBe("ok");
+    expect(fakeSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
+    expect(fakeSpan.end).toHaveBeenCalledTimes(1);
+  });
+
+  test("async failure records the exception, rethrows, and ends the span", async () => {
+    const boom: Error = new Error("async-span-boom");
+    const wrapped: (...args: Array<any>) => any = decorate(
+      undefined,
+      async (): Promise<never> => {
+        throw boom;
+      },
+    );
+
+    await expect(wrapped()).rejects.toBe(boom);
+    expect(recordExceptionMock).toHaveBeenCalledTimes(1);
+    expect(recordExceptionMock.mock.calls[0]![0]).toMatchObject({
+      exception: boom,
+    });
+    expect(fakeSpan.end).toHaveBeenCalledTimes(1);
+  });
+
+  test("sync failure records the exception and rethrows", () => {
+    const boom: Error = new Error("sync-span-boom");
+    const wrapped: (...args: Array<any>) => any = decorate(undefined, () => {
+      throw boom;
+    });
+
+    expect(() => {
+      return wrapped();
+    }).toThrow(boom);
+    expect(recordExceptionMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("export flag is consulted at call time, not decoration time", () => {
+  /*
+   * Decorators run at class-definition (import) time, long before
+   * Telemetry.init() installs an exporter and flips the flag. If the wrapper
+   * captured the flag when it was applied instead of reading it per call,
+   * every span in the process would be silently lost — decoration always
+   * happens while the flag is still false.
+   */
+  test("a method decorated before the exporter exists starts spanning once export turns on", () => {
+    const wrapped: (...args: Array<any>) => any = decorate(undefined, () => {
+      return "x";
+    });
+
+    expect(wrapped()).toBe("x");
+    expect(startActiveSpanMock).not.toHaveBeenCalled();
+
+    spanExportEnabled = true;
+    expect(wrapped()).toBe("x");
+    expect(startActiveSpanMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("a method decorated while export was on drops to passthrough when it turns off", () => {
+    spanExportEnabled = true;
+    const wrapped: (...args: Array<any>) => any = decorate(undefined, () => {
+      return "y";
+    });
+
+    expect(wrapped()).toBe("y");
+    expect(startActiveSpanMock).toHaveBeenCalledTimes(1);
+
+    spanExportEnabled = false;
+    expect(wrapped()).toBe("y");
+    expect(startActiveSpanMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("Telemetry.isSpanExportEnabled (real module)", () => {
+  test("defaults to false before init installs a trace exporter", () => {
+    const RealTelemetry: any = (
+      jest.requireActual("../../../Server/Utils/Telemetry") as any
+    ).default;
+
+    expect(RealTelemetry.isSpanExportEnabled()).toBe(false);
+  });
+});

package/Tests/Utils/Telemetry/IngestionTimestamp.test.ts

@@ -0,0 +1,170 @@
+import {
+  IngestionStamp,
+  getIngestionStamp,
+  getRetentionDateDb,
+} from "../../../Server/Utils/Telemetry/IngestionTimestamp";
+import OneUptimeDate from "../../../Types/Date";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * Minimal structural view of a jest spy — the @jest/globals and @types/jest
+ * spy types disagree in this repo, so annotate with just the surface this
+ * test reads.
+ */
+type SpyLike = {
+  mock: { calls: Array<Array<unknown>> };
+  mockRestore: () => void;
+};
+
+/*
+ * Contract under test — the per-second memo behind every ingested row's
+ * createdAt / retentionDate stamps.
+ *
+ * The Otel logs / traces / metrics row builders used to derive these per
+ * row (current Date + ClickHouse format + moment add-days + second format,
+ * per log record / span / metric datapoint). The memo must hand out values
+ * IDENTICAL to that per-row derivation — same second → same strings — and
+ * roll over crisply on the second boundary, or rows would carry stale
+ * createdAt / retention stamps.
+ */
+
+describe("getIngestionStamp", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("db string matches toClickhouseDateTime of the stamp's date", () => {
+    jest.setSystemTime(new Date("2026-08-10T13:45:59.700Z"));
+
+    const stamp: IngestionStamp = getIngestionStamp();
+
+    expect(stamp.db).toBe(OneUptimeDate.toClickhouseDateTime(stamp.date));
+    expect(stamp.db).toBe("2026-08-10 13:45:59");
+  });
+
+  test("date is truncated to the second", () => {
+    jest.setSystemTime(new Date("2026-08-10T13:45:59.999Z"));
+
+    const stamp: IngestionStamp = getIngestionStamp();
+
+    expect(stamp.date.getMilliseconds()).toBe(0);
+    expect(stamp.date.getTime()).toBe(
+      new Date("2026-08-10T13:45:59.000Z").getTime(),
+    );
+  });
+
+  test("same second returns the identical stamp object (memo hit)", () => {
+    jest.setSystemTime(new Date("2026-08-10T13:45:59.100Z"));
+    const first: IngestionStamp = getIngestionStamp();
+
+    jest.setSystemTime(new Date("2026-08-10T13:45:59.900Z"));
+    const second: IngestionStamp = getIngestionStamp();
+
+    expect(second).toBe(first);
+  });
+
+  test("rolls over when the second changes", () => {
+    jest.setSystemTime(new Date("2026-08-10T13:45:59.900Z"));
+    const first: IngestionStamp = getIngestionStamp();
+
+    jest.setSystemTime(new Date("2026-08-10T13:46:00.000Z"));
+    const second: IngestionStamp = getIngestionStamp();
+
+    expect(second).not.toBe(first);
+    expect(first.db).toBe("2026-08-10 13:45:59");
+    expect(second.db).toBe("2026-08-10 13:46:00");
+  });
+});
+
+describe("getRetentionDateDb", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-08-10T13:45:59.700Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("equals the per-row derivation it replaced (addRemoveDays + format)", () => {
+    const stamp: IngestionStamp = getIngestionStamp();
+
+    for (const days of [1, 15, 30, 90, 365]) {
+      expect(getRetentionDateDb(stamp, days)).toBe(
+        OneUptimeDate.toClickhouseDateTime(
+          OneUptimeDate.addRemoveDays(stamp.date, days),
+        ),
+      );
+    }
+  });
+
+  test("distinct retention windows produce distinct dates", () => {
+    const stamp: IngestionStamp = getIngestionStamp();
+
+    expect(getRetentionDateDb(stamp, 15)).toBe(
+      OneUptimeDate.toClickhouseDateTime(
+        OneUptimeDate.addRemoveDays(stamp.date, 15),
+      ),
+    );
+    expect(getRetentionDateDb(stamp, 30)).toBe(
+      OneUptimeDate.toClickhouseDateTime(
+        OneUptimeDate.addRemoveDays(stamp.date, 30),
+      ),
+    );
+    expect(getRetentionDateDb(stamp, 15)).not.toBe(
+      getRetentionDateDb(stamp, 30),
+    );
+  });
+
+  test("memoizes per retention window: addRemoveDays runs once per (second, days)", () => {
+    const stamp: IngestionStamp = getIngestionStamp();
+    const addRemoveDaysSpy: SpyLike = jest.spyOn(
+      OneUptimeDate,
+      "addRemoveDays",
+    ) as unknown as SpyLike;
+
+    const first: string = getRetentionDateDb(stamp, 15);
+    const callsAfterFirst: number = addRemoveDaysSpy.mock.calls.length;
+
+    for (let i: number = 0; i < 50; i++) {
+      expect(getRetentionDateDb(stamp, 15)).toBe(first);
+    }
+
+    expect(addRemoveDaysSpy.mock.calls.length).toBe(callsAfterFirst);
+    addRemoveDaysSpy.mockRestore();
+  });
+
+  test("stays consistent with the stamp's own second, not the current clock", () => {
+    const stamp: IngestionStamp = getIngestionStamp();
+    const expected: string = getRetentionDateDb(stamp, 15);
+
+    // Clock moves on; a held stamp must keep answering for ITS second.
+    jest.setSystemTime(new Date("2026-08-10T13:46:30.000Z"));
+
+    expect(getRetentionDateDb(stamp, 15)).toBe(expected);
+  });
+
+  test("computes correctly for a bare stamp that never went through the memo", () => {
+    const bareStamp: IngestionStamp = {
+      date: new Date("2026-01-01T00:00:00.000Z"),
+      db: "2026-01-01 00:00:00",
+    };
+
+    expect(getRetentionDateDb(bareStamp, 15)).toBe(
+      OneUptimeDate.toClickhouseDateTime(
+        OneUptimeDate.addRemoveDays(bareStamp.date, 15),
+      ),
+    );
+  });
+});

package/Tests/Utils/Telemetry/SavedViewTimeRange.test.ts

@@ -0,0 +1,244 @@
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import { TelemetrySavedViewTimeRange } from "../../../Types/Telemetry/TelemetrySavedViewState";
+import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTime";
+import TimeRange from "../../../Types/Time/TimeRange";
+import {
+  deserializeSavedViewTimeRange,
+  readSavedViewTimeRange,
+  serializeSavedViewTimeRange,
+} from "../../../Utils/Telemetry/SavedViewTimeRange";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * A saved view stores a time *selection*, not the window that selection
+ * resolved to at save time. Getting this wrong is invisible on the day the
+ * view is saved — the frozen window and the rolling one still cover the same
+ * minutes — and only shows up later, when "Past 1 Hour" comes back pointing at
+ * an hour that has long since passed. These tests pin the distinction.
+ */
+
+const ROLLING_RANGES: Array<TimeRange> = (
+  Object.values(TimeRange) as Array<TimeRange>
+).filter((range: TimeRange): boolean => {
+  return range !== TimeRange.CUSTOM;
+});
+
+describe("serializeSavedViewTimeRange", () => {
+  test("stores a rolling range as its token alone", () => {
+    const serialized: TelemetrySavedViewTimeRange = serializeSavedViewTimeRange(
+      {
+        range: TimeRange.PAST_ONE_HOUR,
+      },
+    );
+
+    expect(serialized).toEqual({ range: TimeRange.PAST_ONE_HOUR });
+    expect(serialized.startValue).toBeUndefined();
+    expect(serialized.endValue).toBeUndefined();
+  });
+
+  test.each(ROLLING_RANGES)(
+    "never stores absolute timestamps for %s",
+    (range: TimeRange) => {
+      const serialized: TelemetrySavedViewTimeRange =
+        serializeSavedViewTimeRange({ range: range });
+
+      expect(serialized).toEqual({ range: range });
+    },
+  );
+
+  /*
+   * The regression this whole module exists for: the picker keeps a resolved
+   * window alongside a rolling token (the viewer needs it to query), and the
+   * old code persisted that window. Carrying it here would freeze the range.
+   */
+  test("drops the resolved window that a rolling range carries", () => {
+    const serialized: TelemetrySavedViewTimeRange = serializeSavedViewTimeRange(
+      {
+        range: TimeRange.PAST_ONE_HOUR,
+        startAndEndDate: new InBetween<Date>(
+          new Date("2026-01-01T10:00:00.000Z"),
+          new Date("2026-01-01T11:00:00.000Z"),
+        ),
+      },
+    );
+
+    expect(serialized).toEqual({ range: TimeRange.PAST_ONE_HOUR });
+  });
+
+  test("stores absolute ISO timestamps for a custom range", () => {
+    const serialized: TelemetrySavedViewTimeRange = serializeSavedViewTimeRange(
+      {
+        range: TimeRange.CUSTOM,
+        startAndEndDate: new InBetween<Date>(
+          new Date("2026-01-01T10:00:00.000Z"),
+          new Date("2026-01-02T10:00:00.000Z"),
+        ),
+      },
+    );
+
+    expect(serialized).toEqual({
+      range: TimeRange.CUSTOM,
+      startValue: "2026-01-01T10:00:00.000Z",
+      endValue: "2026-01-02T10:00:00.000Z",
+    });
+  });
+
+  /*
+   * A picker state that has been through JSON once already hands back date
+   * strings rather than Date instances, and `.toISOString()` on a string
+   * throws.
+   */
+  test("normalizes date strings on a custom range", () => {
+    const serialized: TelemetrySavedViewTimeRange = serializeSavedViewTimeRange(
+      {
+        range: TimeRange.CUSTOM,
+        startAndEndDate: new InBetween<Date>(
+          "2026-01-01T10:00:00.000Z" as unknown as Date,
+          "2026-01-02T10:00:00.000Z" as unknown as Date,
+        ),
+      },
+    );
+
+    expect(serialized).toEqual({
+      range: TimeRange.CUSTOM,
+      startValue: "2026-01-01T10:00:00.000Z",
+      endValue: "2026-01-02T10:00:00.000Z",
+    });
+  });
+
+  test("stores a custom range with no window as the token alone", () => {
+    expect(serializeSavedViewTimeRange({ range: TimeRange.CUSTOM })).toEqual({
+      range: TimeRange.CUSTOM,
+    });
+  });
+});
+
+describe("readSavedViewTimeRange", () => {
+  test.each(ROLLING_RANGES)(
+    "restores %s as a rolling range with no pinned window",
+    (range: TimeRange) => {
+      const restored: RangeStartAndEndDateTime | undefined =
+        readSavedViewTimeRange({ range: range });
+
+      expect(restored).toEqual({ range: range });
+      expect(restored?.startAndEndDate).toBeUndefined();
+    },
+  );
+
+  test("restores a custom range as its pinned window", () => {
+    const restored: RangeStartAndEndDateTime | undefined =
+      readSavedViewTimeRange({
+        range: TimeRange.CUSTOM,
+        startValue: "2026-01-01T10:00:00.000Z",
+        endValue: "2026-01-02T10:00:00.000Z",
+      });
+
+    expect(restored?.range).toBe(TimeRange.CUSTOM);
+    expect(restored?.startAndEndDate?.startValue).toEqual(
+      new Date("2026-01-01T10:00:00.000Z"),
+    );
+    expect(restored?.startAndEndDate?.endValue).toEqual(
+      new Date("2026-01-02T10:00:00.000Z"),
+    );
+  });
+
+  test("accepts Date instances as well as strings on a custom range", () => {
+    const restored: RangeStartAndEndDateTime | undefined =
+      readSavedViewTimeRange({
+        range: TimeRange.CUSTOM,
+        startValue: new Date("2026-01-01T10:00:00.000Z"),
+        endValue: new Date("2026-01-02T10:00:00.000Z"),
+      });
+
+    expect(restored?.startAndEndDate?.startValue).toEqual(
+      new Date("2026-01-01T10:00:00.000Z"),
+    );
+  });
+
+  test.each([
+    ["undefined", undefined],
+    ["null", null],
+    ["a string", "Past 1 Hour"],
+    ["a number", 3600],
+    ["an empty object", {}],
+    ["a non-string range", { range: 42 }],
+    ["an unknown range token", { range: "Past 7 Fortnights" }],
+    ["a custom range with no window", { range: TimeRange.CUSTOM }],
+    [
+      "a custom range missing its end",
+      { range: TimeRange.CUSTOM, startValue: "2026-01-01T10:00:00.000Z" },
+    ],
+    [
+      "a custom range with unparseable dates",
+      {
+        range: TimeRange.CUSTOM,
+        startValue: "not-a-date",
+        endValue: "also-not-a-date",
+      },
+    ],
+    [
+      "a custom range with empty-string dates",
+      { range: TimeRange.CUSTOM, startValue: "", endValue: "" },
+    ],
+  ])("returns undefined for %s", (_label: string, saved: unknown) => {
+    expect(readSavedViewTimeRange(saved)).toBeUndefined();
+  });
+});
+
+describe("deserializeSavedViewTimeRange", () => {
+  test.each([
+    ["undefined", undefined],
+    ["null", null],
+    ["an empty object", {}],
+    ["an unknown range token", { range: "Past 7 Fortnights" }],
+    ["a custom range with unparseable dates", { range: TimeRange.CUSTOM }],
+  ])("falls back to the past hour for %s", (_label: string, saved: unknown) => {
+    expect(deserializeSavedViewTimeRange(saved)).toEqual({
+      range: TimeRange.PAST_ONE_HOUR,
+    });
+  });
+
+  test("passes through a usable stored range", () => {
+    expect(
+      deserializeSavedViewTimeRange({ range: TimeRange.PAST_TWO_DAYS }),
+    ).toEqual({ range: TimeRange.PAST_TWO_DAYS });
+  });
+});
+
+describe("round trip", () => {
+  test.each(ROLLING_RANGES)(
+    "%s survives serialize -> JSONB -> deserialize as a rolling range",
+    (range: TimeRange) => {
+      const stored: unknown = JSON.parse(
+        JSON.stringify(serializeSavedViewTimeRange({ range: range })),
+      );
+
+      expect(deserializeSavedViewTimeRange(stored)).toEqual({ range: range });
+    },
+  );
+
+  test("a custom range survives serialize -> JSONB -> deserialize intact", () => {
+    const original: RangeStartAndEndDateTime = {
+      range: TimeRange.CUSTOM,
+      startAndEndDate: new InBetween<Date>(
+        new Date("2025-11-03T08:15:00.000Z"),
+        new Date("2025-11-04T09:45:00.000Z"),
+      ),
+    };
+
+    const stored: unknown = JSON.parse(
+      JSON.stringify(serializeSavedViewTimeRange(original)),
+    );
+
+    const restored: RangeStartAndEndDateTime =
+      deserializeSavedViewTimeRange(stored);
+
+    expect(restored.range).toBe(TimeRange.CUSTOM);
+    expect(restored.startAndEndDate?.startValue).toEqual(
+      original.startAndEndDate?.startValue,
+    );
+    expect(restored.startAndEndDate?.endValue).toEqual(
+      original.startAndEndDate?.endValue,
+    );
+  });
+});