@dash0/sdk-web 0.18.3 → 0.18.5

package/src/utils/time_test.ts

@@ -0,0 +1,282 @@
+import { expect, describe, it, vi, beforeEach, afterEach } from "vitest";
+import { now, nowNanos, toNanosTs, getTimeOrigin, domHRTimestampToNanos } from "./time";
+import * as globals from "./globals";
+
+describe("now", () => {
+  it("returns the current time in milliseconds", () => {
+    const before = new Date().getTime();
+    const result = now();
+    const after = new Date().getTime();
+
+    expect(result).toBeGreaterThanOrEqual(before);
+    expect(result).toBeLessThanOrEqual(after);
+  });
+});
+
+describe("toNanosTs", () => {
+  it("converts milliseconds to nanoseconds as string", () => {
+    const ms = 1609459200000; // 2021-01-01 00:00:00 UTC
+    const result = toNanosTs(ms);
+    expect(result).toBe("1609459200000000000");
+  });
+
+  it("converts Date object to nanoseconds as string", () => {
+    const date = new Date(1609459200000);
+    const result = toNanosTs(date);
+    expect(result).toBe("1609459200000000000");
+  });
+
+  it("handles zero timestamp", () => {
+    const result = toNanosTs(0);
+    expect(result).toBe("0000000");
+  });
+
+  it("preserves precision", () => {
+    const ms = 1234567890123;
+    const result = toNanosTs(ms);
+    expect(result).toBe("1234567890123000000");
+  });
+});
+
+describe("getTimeOrigin", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns timeOrigin when available", () => {
+    const mockPerf = {
+      timeOrigin: 1609459200000,
+      now: vi.fn(),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+
+    const result = getTimeOrigin();
+    expect(result).toBe(1609459200000);
+  });
+
+  it("falls back to timing.fetchStart when timeOrigin is not a number", () => {
+    const mockPerf = {
+      timing: {
+        fetchStart: 1609459200000,
+      },
+      now: vi.fn(),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+
+    const result = getTimeOrigin();
+    expect(result).toBe(1609459200000);
+  });
+
+  it("returns undefined when perf is not available", () => {
+    vi.spyOn(globals, "perf", "get").mockReturnValue(undefined);
+
+    const result = getTimeOrigin();
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined when both timeOrigin and fetchStart are unavailable", () => {
+    const mockPerf = {
+      now: vi.fn(),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+
+    const result = getTimeOrigin();
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("nowNanos", () => {
+  let dateNowSpy: any;
+
+  beforeEach(() => {
+    dateNowSpy = vi.spyOn(Date.prototype, "getTime");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("uses performance time when available and not drifted", () => {
+    const timeOrigin = 1609459200000;
+    const perfNow = 5000; // 5 seconds after time origin
+    const expectedTime = timeOrigin + perfNow; // 1609459205000
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn().mockReturnValue(perfNow),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    dateNowSpy.mockReturnValue(expectedTime);
+
+    const result = nowNanos();
+    const expected = String(expectedTime * 1000000);
+    expect(result).toBe(expected);
+  });
+
+  it("falls back to Date when drift is exactly 60000ms (60 seconds)", () => {
+    const timeOrigin = 1609459200000;
+    const perfNow = 5000;
+    const perfTime = timeOrigin + perfNow; // 1609459205000
+    const dateTime = perfTime + 60000; // 60000ms drift
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn().mockReturnValue(perfNow),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(dateTime) + "000000";
+    expect(result).toBe(expected);
+  });
+
+  it("falls back to Date when drift exceeds 60000ms (positive)", () => {
+    const timeOrigin = 1609459200000;
+    const perfNow = 5000;
+    const perfTime = timeOrigin + perfNow;
+    const dateTime = perfTime + 65000; // 65000ms drift (browser slept)
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn().mockReturnValue(perfNow),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(dateTime) + "000000";
+    expect(result).toBe(expected);
+  });
+
+  it("falls back to Date when drift exceeds 60000ms (negative)", () => {
+    const timeOrigin = 1609459200000;
+    const perfNow = 5000;
+    const perfTime = timeOrigin + perfNow;
+    const dateTime = perfTime - 65000; // -65000ms drift (clock adjustment)
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn().mockReturnValue(perfNow),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(dateTime) + "000000";
+    expect(result).toBe(expected);
+  });
+
+  it("uses performance time when drift is just under 60000ms (59999ms)", () => {
+    const timeOrigin = 1609459200000;
+    const perfNow = 5000;
+    const perfTime = timeOrigin + perfNow;
+    const dateTime = perfTime + 59999; // 59999ms drift (still acceptable)
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn().mockReturnValue(perfNow),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(perfTime * 1000000);
+    expect(result).toBe(expected);
+  });
+
+  it("uses performance time when drift is just under -60000ms (-59999ms)", () => {
+    const timeOrigin = 1609459200000;
+    const perfNow = 5000;
+    const perfTime = timeOrigin + perfNow;
+    const dateTime = perfTime - 59999; // -59999ms drift (still acceptable)
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn().mockReturnValue(perfNow),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(perfTime * 1000000);
+    expect(result).toBe(expected);
+  });
+
+  it("falls back to Date when timeOrigin is not available", () => {
+    vi.spyOn(globals, "perf", "get").mockReturnValue(undefined);
+    const dateTime = 1609459205000;
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(dateTime) + "000000";
+    expect(result).toBe(expected);
+  });
+
+  it("falls back to Date when timeOrigin is not a number", () => {
+    const mockPerf = {
+      timeOrigin: undefined,
+      now: vi.fn().mockReturnValue(5000),
+      timing: {}, // no fetchStart either
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+    const dateTime = 1609459205000;
+    dateNowSpy.mockReturnValue(dateTime);
+
+    const result = nowNanos();
+    const expected = String(dateTime) + "000000";
+    expect(result).toBe(expected);
+  });
+});
+
+describe("domHRTimestampToNanos", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("converts DOM high resolution timestamp to nanoseconds", () => {
+    const timeOrigin = 1609459200000;
+    const hrTimestamp = 5000.123; // 5.000123 seconds after time origin
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn(),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+
+    const result = domHRTimestampToNanos(hrTimestamp);
+    const expectedMs = timeOrigin + hrTimestamp;
+    const expectedNanos = String(Math.round(expectedMs * 1000000));
+    expect(result).toBe(expectedNanos);
+  });
+
+  it("rounds to nearest nanosecond", () => {
+    const timeOrigin = 1000;
+    const hrTimestamp = 0.0000001; // Very small fraction
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn(),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+
+    const result = domHRTimestampToNanos(hrTimestamp);
+    const expectedMs = timeOrigin + hrTimestamp;
+    const expectedNanos = String(Math.round(expectedMs * 1000000));
+    expect(result).toBe(expectedNanos);
+  });
+
+  it("handles zero timestamp", () => {
+    const timeOrigin = 1609459200000;
+
+    const mockPerf = {
+      timeOrigin,
+      now: vi.fn(),
+    };
+    vi.spyOn(globals, "perf", "get").mockReturnValue(mockPerf as any);
+
+    const result = domHRTimestampToNanos(0);
+    const expectedNanos = String(Math.round(timeOrigin * 1000000));
+    expect(result).toBe(expectedNanos);
+  });
+});