102 lines
3.6 KiB
TypeScript
102 lines
3.6 KiB
TypeScript
import type { LiveQueryEvent, QueryRow } from "@/lib/types";
|
|
import { RING_CAPACITY, mergeGap, pushRow, type LiveRow } from "./ringBuffer";
|
|
|
|
function event(ts: number, domain: string, overrides: Partial<LiveQueryEvent> = {}): LiveQueryEvent {
|
|
return {
|
|
ts,
|
|
domain,
|
|
client_ip: "192.0.2.10",
|
|
qtype: 1,
|
|
blocked: false,
|
|
block_reason: "",
|
|
response_time_us: 500,
|
|
cache_hit: false,
|
|
upstream: "udp://9.9.9.9:53",
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function liveRow(key: number, ts: number, domain: string, overrides: Partial<LiveQueryEvent> = {}): LiveRow {
|
|
return { ...event(ts, domain, overrides), key };
|
|
}
|
|
|
|
function fetchedRow(id: number, ts: number, domain: string, overrides: Partial<LiveQueryEvent> = {}): QueryRow {
|
|
return { id, ...event(ts, domain, overrides) };
|
|
}
|
|
|
|
function counter(start = 100): () => number {
|
|
let n = start;
|
|
return () => ++n;
|
|
}
|
|
|
|
describe("pushRow", () => {
|
|
test("prepends newest-first", () => {
|
|
let rows: LiveRow[] = [];
|
|
rows = pushRow(rows, liveRow(1, 10, "a.example"));
|
|
rows = pushRow(rows, liveRow(2, 11, "b.example"));
|
|
expect(rows.map((r) => r.domain)).toEqual(["b.example", "a.example"]);
|
|
});
|
|
|
|
test("drops the oldest beyond capacity", () => {
|
|
let rows: LiveRow[] = [];
|
|
for (let i = 0; i < 5; i++) rows = pushRow(rows, liveRow(i, i, `d${i}.example`), 3);
|
|
expect(rows).toHaveLength(3);
|
|
expect(rows.map((r) => r.key)).toEqual([4, 3, 2]);
|
|
});
|
|
|
|
test("default capacity is 500", () => {
|
|
let rows: LiveRow[] = [];
|
|
for (let i = 0; i < RING_CAPACITY + 10; i++) rows = pushRow(rows, liveRow(i, i, "x.example"));
|
|
expect(rows).toHaveLength(RING_CAPACITY);
|
|
});
|
|
});
|
|
|
|
describe("mergeGap", () => {
|
|
test("skips rows already in the buffer and counts only new ones", () => {
|
|
const buffer = [liveRow(2, 100, "seen.example"), liveRow(1, 99, "old.example")];
|
|
const fetched = [
|
|
fetchedRow(30, 102, "gap2.example"),
|
|
fetchedRow(29, 101, "gap1.example"),
|
|
fetchedRow(28, 100, "seen.example"),
|
|
];
|
|
const { rows, missed } = mergeGap(buffer, fetched, counter());
|
|
expect(missed).toBe(2);
|
|
expect(rows.map((r) => r.domain)).toEqual(["gap2.example", "gap1.example", "seen.example", "old.example"]);
|
|
});
|
|
|
|
test("no additions returns the buffer unchanged with missed 0", () => {
|
|
const buffer = [liveRow(1, 100, "seen.example")];
|
|
const { rows, missed } = mergeGap(buffer, [fetchedRow(5, 100, "seen.example")], counter());
|
|
expect(missed).toBe(0);
|
|
expect(rows).toBe(buffer);
|
|
});
|
|
|
|
test("rows differing only in qtype are not deduplicated", () => {
|
|
const buffer = [liveRow(1, 100, "dual.example", { qtype: 1 })];
|
|
const fetched = [fetchedRow(5, 100, "dual.example", { qtype: 28 })];
|
|
const { missed } = mergeGap(buffer, fetched, counter());
|
|
expect(missed).toBe(1);
|
|
});
|
|
|
|
test("assigns fresh keys from the counter and drops the id", () => {
|
|
const { rows } = mergeGap([], [fetchedRow(77, 100, "gap.example")], counter(200));
|
|
expect(rows[0]?.key).toBe(201);
|
|
expect("id" in (rows[0] ?? {})).toBe(false);
|
|
});
|
|
|
|
test("result is capped at capacity, keeping the newest", () => {
|
|
const buffer = [liveRow(3, 300, "live.example")];
|
|
const fetched = [fetchedRow(2, 302, "g2.example"), fetchedRow(1, 301, "g1.example")];
|
|
const { rows, missed } = mergeGap(buffer, fetched, counter(), 2);
|
|
expect(missed).toBe(2);
|
|
expect(rows.map((r) => r.domain)).toEqual(["g2.example", "g1.example"]);
|
|
});
|
|
|
|
test("merged rows stay sorted newest-first by ts", () => {
|
|
const buffer = [liveRow(4, 105, "after-reopen.example"), liveRow(3, 100, "before.example")];
|
|
const fetched = [fetchedRow(9, 103, "gap.example")];
|
|
const { rows } = mergeGap(buffer, fetched, counter());
|
|
expect(rows.map((r) => r.ts)).toEqual([105, 103, 100]);
|
|
});
|
|
});
|