@faststats/web 0.2.14 → 0.3.1

package/tests/replay.test.ts

@@ -1,582 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { gunzipSync } from "node:zlib";
-import ReplayTracker from "../src/replay";
-import {
-	getOrCreateSessionId,
-	type SessionContext,
-	setDefaultSiteKey,
-} from "../src/utils/session-manager";
-
-function decodeBody(data: string | Uint8Array): string {
-	if (typeof data === "string") return data;
-	return gunzipSync(data).toString("utf8");
-}
-
-class MockStorage {
-	private readonly data = new Map<string, string>();
-
-	getItem(key: string): string | null {
-		return this.data.get(key) ?? null;
-	}
-
-	setItem(key: string, value: string): void {
-		this.data.set(key, value);
-	}
-
-	removeItem(key: string): void {
-		this.data.delete(key);
-	}
-}
-
-type ReplayEvent = {
-	type: number;
-	timestamp: number;
-	data?: Record<string, unknown>;
-};
-
-type ReplayBatch = {
-	token: string;
-	sessionId: string;
-	windowId: string;
-	viewId: string;
-	sessionStart: number;
-	identifier?: string;
-	batchId: string;
-	sequence: number;
-	timestamp: number;
-	url: string;
-	isFinal?: boolean;
-	events: ReplayEvent[];
-};
-
-type ReplayTrackerInternals = {
-	events: ReplayEvent[];
-	pending: ReplayBatch[];
-	pendingSizeBytes: number;
-	minLengthFlushTask: ReturnType<typeof setTimeout> | null;
-	retryTask: ReturnType<typeof setTimeout> | null;
-	startTime: number;
-	onEvent: (event: ReplayEvent, isCheckout?: boolean) => void;
-	trackPageChange: (url?: string) => void;
-	flush: (
-		lowLatency: boolean,
-		contextOverride?: SessionContext,
-		isFinal?: boolean,
-	) => Promise<void>;
-	send: (
-		data: string | Uint8Array,
-		isCompressed: boolean,
-		lowLatency: boolean,
-	) => Promise<boolean>;
-};
-
-function setGlobal(name: keyof typeof globalThis, value: unknown): void {
-	Object.defineProperty(globalThis, name, {
-		configurable: true,
-		writable: true,
-		value,
-	});
-}
-
-const original = {
-	window: globalThis.window,
-	document: globalThis.document,
-	location: globalThis.location,
-	navigator: globalThis.navigator,
-	fetch: globalThis.fetch,
-	localStorage: globalThis.localStorage,
-	sessionStorage: globalThis.sessionStorage,
-};
-
-beforeEach(() => {
-	setGlobal("window", {
-		location: { href: "https://example.com/" },
-		addEventListener: () => {},
-		removeEventListener: () => {},
-	} as unknown as Window);
-	setGlobal("document", {
-		visibilityState: "visible",
-		addEventListener: () => {},
-		removeEventListener: () => {},
-	} as unknown as Document);
-	setGlobal("location", { href: "https://example.com/" } as Location);
-	setGlobal("localStorage", new MockStorage());
-	setGlobal("sessionStorage", new MockStorage());
-	setDefaultSiteKey("site_test");
-	setGlobal("navigator", { sendBeacon: () => false });
-	setGlobal(
-		"fetch",
-		(async () => new Response("", { status: 204 })) as unknown as typeof fetch,
-	);
-});
-
-afterEach(() => {
-	setGlobal("window", original.window);
-	setGlobal("document", original.document);
-	setGlobal("location", original.location);
-	setGlobal("navigator", original.navigator);
-	setGlobal("fetch", original.fetch);
-	setGlobal("localStorage", original.localStorage);
-	setGlobal("sessionStorage", original.sessionStorage);
-});
-
-function createTracker(
-	options: Partial<ConstructorParameters<typeof ReplayTracker>[0]> = {},
-): ReplayTrackerInternals {
-	return new ReplayTracker({
-		siteKey: "site_test",
-		samplingPercentage: 100,
-		...options,
-	}) as unknown as ReplayTrackerInternals;
-}
-
-async function captureReplayBatch(
-	tracker: ReplayTrackerInternals,
-): Promise<ReplayBatch> {
-	const payloads: ReplayBatch[] = [];
-	tracker.send = async (data) => {
-		payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-		return true;
-	};
-	tracker.startTime = Date.now() - 1000;
-	tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-	await tracker.flush(false);
-	return payloads[0] as ReplayBatch;
-}
-
-describe("ReplayTracker", () => {
-	test("buffers replay events", () => {
-		const tracker = createTracker({
-			maxEvents: 1000,
-			minReplayLengthMs: Number.MAX_SAFE_INTEGER,
-		});
-
-		tracker.onEvent({ type: 2, timestamp: 1, data: {} }, false);
-		tracker.onEvent({ type: 3, timestamp: 2, data: {} }, false);
-
-		expect(tracker.events.length).toBe(2);
-	});
-
-	test("does not flush before minimum replay length", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: Number.MAX_SAFE_INTEGER,
-		});
-
-		let sent = 0;
-		tracker.send = async () => {
-			sent++;
-			return true;
-		};
-		tracker.startTime = Date.now();
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-
-		expect(sent).toBe(0);
-		expect(tracker.events.length).toBe(1);
-		expect(tracker.pending.length).toBe(0);
-
-		if (tracker.minLengthFlushTask) clearTimeout(tracker.minLengthFlushTask);
-	});
-
-	test("flushes buffered events once minimum replay length is reached", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 20,
-		});
-
-		let sent = 0;
-		tracker.send = async () => {
-			sent++;
-			return true;
-		};
-		tracker.startTime = Date.now();
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await new Promise((resolve) => setTimeout(resolve, 40));
-
-		expect(sent).toBe(1);
-		expect(tracker.events.length).toBe(0);
-		expect(tracker.pending.length).toBe(0);
-	});
-
-	test("emits replay payload when flushed", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const captured: { payload: ReplayBatch | null; lowLatency: boolean } = {
-			payload: null,
-			lowLatency: false,
-		};
-		tracker.send = async (data, _isCompressed, nextLowLatency) => {
-			captured.payload = JSON.parse(decodeBody(data)) as ReplayBatch;
-			captured.lowLatency = nextLowLatency;
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(true);
-
-		expect(captured.payload).not.toBeNull();
-		expect(captured.payload?.token).toBe("site_test");
-		expect(captured.payload?.sessionId).toBeTruthy();
-		expect(captured.payload?.windowId).toBeTruthy();
-		expect(captured.payload?.viewId).toBeTruthy();
-		expect(captured.payload?.sessionStart).toBeGreaterThan(0);
-		expect(captured.payload?.batchId).toBeTruthy();
-		expect(captured.payload?.events).toHaveLength(1);
-		expect(captured.lowLatency).toBe(true);
-		expect(tracker.pending.length).toBe(0);
-	});
-
-	test("emits stable batch ids while queued for retry", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return payloads.length > 1;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(2);
-		expect(payloads[1]?.batchId).toBe(payloads[0]?.batchId);
-		expect(payloads[1]?.sequence).toBe(payloads[0]?.sequence);
-
-		if (tracker.retryTask) clearTimeout(tracker.retryTask);
-	});
-
-	test("keeps the same replay session id across later batches", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return true;
-		};
-
-		getOrCreateSessionId();
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(2);
-		expect(payloads[0]?.sessionId).toBeTruthy();
-		expect(payloads[1]?.sessionId).toBe(payloads[0]?.sessionId);
-	});
-
-	test("uses a new session id after idle timeout", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return true;
-		};
-
-		getOrCreateSessionId();
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		const local = globalThis.localStorage as unknown as MockStorage;
-		local.setItem(
-			"faststats_session_activity",
-			(Date.now() - 31 * 60 * 1000).toString(),
-		);
-
-		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(3);
-		expect(payloads[1]?.sessionId).toBe(payloads[0]?.sessionId);
-		expect(payloads[1]?.isFinal).toBe(true);
-		expect(payloads[2]?.sessionId).not.toBe(payloads[0]?.sessionId);
-	});
-
-	test("finalizes queued events under previous session after idle timeout", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return true;
-		};
-
-		const previousSessionId = getOrCreateSessionId();
-		const local = globalThis.localStorage as unknown as MockStorage;
-		local.setItem(
-			"faststats_session_activity",
-			(Date.now() - 31 * 60 * 1000).toString(),
-		);
-
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(1);
-		expect(payloads[0]?.sessionId).toBe(previousSessionId);
-		expect(payloads[0]?.isFinal).toBe(true);
-	});
-
-	test("keeps the same window and view ids across replay batches", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const payloads: ReplayBatch[] = [];
-		tracker.send = async (data) => {
-			payloads.push(JSON.parse(decodeBody(data)) as ReplayBatch);
-			return true;
-		};
-		getOrCreateSessionId();
-		tracker.startTime = Date.now() - 1000;
-
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-		tracker.onEvent({ type: 3, timestamp: Date.now(), data: {} }, false);
-		await tracker.flush(false);
-
-		expect(payloads).toHaveLength(2);
-		expect(payloads[1]?.windowId).toBe(payloads[0]?.windowId);
-		expect(payloads[1]?.viewId).toBe(payloads[0]?.viewId);
-		expect(payloads[1]?.sequence).toBe((payloads[0]?.sequence ?? 0) + 1);
-	});
-
-	test("window id is stable across replay tracker remounts", async () => {
-		const sharedSession = new MockStorage();
-		sharedSession.setItem("faststats_window_id_site_test", "stable-window");
-
-		setGlobal("sessionStorage", sharedSession);
-
-		const first = createTracker({ minReplayLengthMs: 0 });
-		const second = createTracker({ minReplayLengthMs: 0 });
-
-		const firstBatch = await captureReplayBatch(first);
-		const secondBatch = await captureReplayBatch(second);
-
-		expect(firstBatch.windowId).toBe("stable-window");
-		expect(secondBatch.windowId).toBe("stable-window");
-	});
-
-	test("same session across tabs with different window ids", async () => {
-		const sharedLocal = new MockStorage();
-		sharedLocal.setItem("faststats_session_id", "shared-session");
-		sharedLocal.setItem("faststats_session_activity", Date.now().toString());
-		sharedLocal.setItem("faststats_session_start", Date.now().toString());
-
-		setGlobal("localStorage", sharedLocal);
-		setGlobal("sessionStorage", new MockStorage());
-
-		const first = createTracker({ minReplayLengthMs: 0 });
-		const firstBatch = await captureReplayBatch(first);
-
-		setGlobal("sessionStorage", new MockStorage());
-		const second = createTracker({ minReplayLengthMs: 0 });
-		const secondBatch = await captureReplayBatch(second);
-
-		expect(firstBatch.sessionId).toBe("shared-session");
-		expect(secondBatch.sessionId).toBe("shared-session");
-		expect(firstBatch.windowId).not.toBe(secondBatch.windowId);
-	});
-
-	test("trackPageChange rotates viewId and emits meta event", () => {
-		const tracker = createTracker();
-		(tracker as unknown as { started: boolean }).started = true;
-		const firstViewId = (tracker as unknown as { viewId: string }).viewId;
-
-		tracker.trackPageChange("https://example.com/about");
-
-		const viewEvent = tracker.events.find(
-			(e) =>
-				(e.data as Record<string, unknown> | undefined)?.tag ===
-				"faststats:view",
-		);
-		expect(viewEvent).toBeDefined();
-		const payload = (viewEvent?.data as Record<string, unknown> | undefined)
-			?.payload as Record<string, unknown> | undefined;
-		expect(payload?.href).toBe("https://example.com/about");
-		expect((tracker as unknown as { viewId: string }).viewId).not.toBe(
-			firstViewId,
-		);
-	});
-
-	test("sends replay as plain JSON when CompressionStream is unavailable", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const captured: { bodyType: "string" | "blob" | null } = {
-			bodyType: null,
-		};
-		tracker.send = async (data) => {
-			captured.bodyType = typeof data === "string" ? "string" : "blob";
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-
-		expect(captured.bodyType).toBe("string");
-	});
-
-	test("sends replay as gzip Uint8Array when CompressionStream is available", async () => {
-		setGlobal("window", {
-			...(globalThis.window as unknown as Record<string, unknown>),
-			CompressionStream: globalThis.CompressionStream,
-		});
-
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		const captured: {
-			bodyType: "string" | "binary" | null;
-			compressed: boolean;
-			size: number;
-		} = { bodyType: null, compressed: false, size: 0 };
-		tracker.send = async (data, isCompressed) => {
-			captured.bodyType = typeof data === "string" ? "string" : "binary";
-			captured.compressed = isCompressed;
-			if (data instanceof Uint8Array) {
-				captured.size = data.byteLength;
-			}
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		for (let i = 0; i < 10; i++) {
-			tracker.onEvent(
-				{
-					type: 2,
-					timestamp: Date.now(),
-					data: { i, payload: "x".repeat(500) },
-				},
-				false,
-			);
-		}
-
-		await tracker.flush(false);
-
-		expect(captured.bodyType).toBe("binary");
-		expect(captured.compressed).toBe(true);
-		expect(captured.size).toBeGreaterThan(0);
-		expect(captured.size).toBeLessThan(5000);
-	});
-
-	test("compresses on unload (low latency) flush", async () => {
-		setGlobal("window", {
-			...(globalThis.window as unknown as Record<string, unknown>),
-			CompressionStream: globalThis.CompressionStream,
-		});
-
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		let compressedFlag = false;
-		let lowLatencyFlag = false;
-		tracker.send = async (_data, isCompressed, lowLatency) => {
-			compressedFlag = isCompressed;
-			lowLatencyFlag = lowLatency;
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(true, undefined, true);
-
-		expect(compressedFlag).toBe(true);
-		expect(lowLatencyFlag).toBe(true);
-	});
-
-	test("keeps failed batches queued for retry", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-		});
-
-		tracker.send = async () => false;
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent({ type: 2, timestamp: Date.now(), data: {} }, false);
-
-		await tracker.flush(false);
-
-		expect(tracker.pending.length).toBe(1);
-		expect(tracker.retryTask).not.toBeNull();
-
-		if (tracker.retryTask) clearTimeout(tracker.retryTask);
-	});
-
-	test("drops replay batches that exceed the queue byte limit", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-			maxQueueSizeBytes: 600,
-		});
-
-		let sent = 0;
-		tracker.send = async () => {
-			sent++;
-			return true;
-		};
-		tracker.startTime = Date.now() - 1000;
-		tracker.onEvent(
-			{
-				type: 2,
-				timestamp: Date.now(),
-				data: { payload: "x".repeat(1000) },
-			},
-			false,
-		);
-
-		await tracker.flush(false);
-
-		expect(sent).toBe(0);
-		expect(tracker.pending.length).toBe(0);
-		expect(tracker.pendingSizeBytes).toBe(0);
-	});
-
-	test("keeps pending replay queue under the byte limit", async () => {
-		const tracker = createTracker({
-			minReplayLengthMs: 0,
-			maxQueueSizeBytes: 900,
-		});
-
-		tracker.send = async () => false;
-		tracker.startTime = Date.now() - 1000;
-
-		for (let i = 0; i < 4; i++) {
-			tracker.onEvent(
-				{
-					type: 2,
-					timestamp: Date.now(),
-					data: { i, payload: "x".repeat(300) },
-				},
-				false,
-			);
-			await tracker.flush(false);
-		}
-
-		expect(tracker.pending.length).toBeGreaterThan(0);
-		expect(tracker.pendingSizeBytes).toBeLessThanOrEqual(900);
-
-		if (tracker.retryTask) clearTimeout(tracker.retryTask);
-	});
-});