Files
clean-architecture-frontend…/tests/platform/telemetry/telemetry-buffer.test.ts
T

90 lines
3.4 KiB
TypeScript

import { describe, expect, it } from "vitest";
import { createTelemetryBuffer } from "../../../src/platform/telemetry/telemetry-buffer.ts";
import type { TelemetryEvent } from "../../../src/platform/telemetry/telemetry-event.ts";
import { createDeterministicSampler } from "../../../src/platform/telemetry/telemetry-sampler.ts";
const infoEvent = (id: string): TelemetryEvent<unknown> => ({
kind: "test.info",
severity: "info",
payload: { id },
});
const criticalEvent = (id: string): TelemetryEvent<unknown> => ({
kind: "test.critical",
severity: "critical",
payload: { id },
});
describe("createDeterministicSampler", () => {
it("makes the same sampling decision for the same stable key", () => {
const sampler = createDeterministicSampler({ rate: 0.1 });
expect(sampler.keep("interaction-123")).toBe(sampler.keep("interaction-123"));
});
it("approximates the configured rate over many keys", () => {
const sampler = createDeterministicSampler({ rate: 0.1 });
let kept = 0;
for (let i = 0; i < 10_000; i += 1) if (sampler.keep(`interaction-${i}`)) kept += 1;
expect(kept).toBeGreaterThan(700);
expect(kept).toBeLessThan(1_300);
});
it("is exact at the edges and rejects invalid rates", () => {
expect(createDeterministicSampler({ rate: 1 }).keep("x")).toBe(true);
expect(createDeterministicSampler({ rate: 0 }).keep("x")).toBe(false);
expect(() => createDeterministicSampler({ rate: 1.5 })).toThrow(TypeError);
expect(() => createDeterministicSampler({ rate: Number.NaN })).toThrow(TypeError);
});
});
describe("createTelemetryBuffer", () => {
it("never exceeds event or byte ceilings", () => {
const buffer = createTelemetryBuffer({
maxEvents: 2,
maxBytes: 1_024,
});
buffer.push(infoEvent("a"));
buffer.push(infoEvent("b"));
buffer.push(criticalEvent("c"));
expect(buffer.size).toBeLessThanOrEqual(2);
expect(buffer.bytes).toBeLessThanOrEqual(1_024);
expect(buffer.items.some((item) => item.severity === "critical")).toBe(true);
});
it("drops an incoming low-severity event rather than evicting a severe one", () => {
const buffer = createTelemetryBuffer({ maxEvents: 1, maxBytes: 1_024 });
buffer.push(criticalEvent("keep"));
expect(buffer.push(infoEvent("late"))).toBe(false);
expect(buffer.items).toEqual([criticalEvent("keep")]);
expect(buffer.dropped).toBe(1);
});
it("enforces the byte ceiling independently of the event count", () => {
const buffer = createTelemetryBuffer({ maxEvents: 100, maxBytes: 200 });
for (let i = 0; i < 50; i += 1) buffer.push(infoEvent(`event-${i}`));
expect(buffer.bytes).toBeLessThanOrEqual(200);
expect(buffer.size).toBeLessThan(50);
});
it("rejects a single event larger than the byte ceiling", () => {
const buffer = createTelemetryBuffer({ maxEvents: 10, maxBytes: 64 });
expect(buffer.push(infoEvent("x".repeat(100)))).toBe(false);
expect(buffer.size).toBe(0);
});
it("hands batches out in FIFO order and releases their bytes", () => {
const buffer = createTelemetryBuffer({ maxEvents: 10, maxBytes: 10_000 });
buffer.push(infoEvent("a"));
buffer.push(infoEvent("b"));
buffer.push(infoEvent("c"));
const batch = buffer.take(2);
expect(batch.map((entry) => entry.event)).toEqual([infoEvent("a"), infoEvent("b")]);
expect(buffer.size).toBe(1);
buffer.take(10);
expect(buffer.bytes).toBe(0);
});
});