mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-09-13 18:32:12 +03:00
3d4f3e4960
* test(infra): retry recursive temp-dir removal instead of failing a shard on ENOTEMPTY (#11966) Two shards on release/v3.8.51 went red in one day with the same signature — "ENOTEMPTY, Directory not empty: /tmp/omniroute-<test>-XXXXXX" — from combo-same-provider-cascade (Unit Tests fast-path 4/4, on a PR that touches only .github/) and auth-policy-embeddings-webfetch-7785 (the 20k-test TIA step). Both pass alone and on re-run: the cleanup races something still writing into the directory (SQLite WAL/-shm checkpoint, a worker, the backup) and under a loaded hosted runner the window opens. 1154 test files do their own cleanup with fs.rmSync(dir, { recursive: true, force: true }); 57 already asked for retries. One-shot codemod (scripts/ad-hoc/codemod-rm-maxretries.mjs, kept for the record): every rm / rmSync / rmdirSync option object with `recursive: true` and no `maxRetries` gains `maxRetries: 5, retryDelay: 100` — Node itself then retries ENOTEMPTY/EBUSY/EPERM for up to ~0.5 s before giving up. 2243 call sites in 1292 files under tests/, the shared tests/_setup/isolateDataDir.ts exit hook included. Only the option object changes: no call site, assertion or import is touched. Validation: prettier and ESLint (with the frozen suppressions) clean on all 1292 files; a random 20-file sample runs green (quota-redis-store hangs identically on the untouched tree — it needs a Redis on localhost, an environment matter). The four unit shards on this PR are the full run. * fix(quality): let check-forgotten-sibling-tests read a 1,000-file diff The gate shells out to `git diff` through execFileSync with Node's default 1 MB maxBuffer; the 1,292-file codemod in this PR is the first diff large enough to overflow it, and the gate died with `spawnSync git ENOBUFS` before comparing anything. 64 MB is far above any real PR and costs nothing when unused.
93 lines
3.1 KiB
TypeScript
93 lines
3.1 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { RingBuffer } from "../../../src/lib/services/ringBuffer.ts";
|
|
import type { LogLine } from "../../../src/lib/services/types.ts";
|
|
|
|
function makeLine(line: string, stream: "stdout" | "stderr" = "stdout"): LogLine {
|
|
return { ts: Date.now(), stream, line };
|
|
}
|
|
|
|
test("push respects byte limit (evicts oldest)", () => {
|
|
// 100-byte limit: each entry is ~40 bytes overhead + line bytes
|
|
const buf = new RingBuffer(100);
|
|
|
|
buf.push(makeLine("first")); // ~45 bytes
|
|
buf.push(makeLine("second")); // ~46 bytes — total ~91
|
|
buf.push(makeLine("third")); // would exceed → evict "first"
|
|
|
|
const snap = buf.snapshot();
|
|
assert.ok(!snap.some((e) => e.line === "first"), "first should be evicted");
|
|
assert.ok(
|
|
snap.some((e) => e.line === "second"),
|
|
"second should be retained"
|
|
);
|
|
assert.ok(
|
|
snap.some((e) => e.line === "third"),
|
|
"third should be retained"
|
|
);
|
|
});
|
|
|
|
test("snapshot returns isolated copy", () => {
|
|
const buf = new RingBuffer();
|
|
buf.push(makeLine("a"));
|
|
const snap1 = buf.snapshot();
|
|
buf.push(makeLine("b"));
|
|
const snap2 = buf.snapshot();
|
|
|
|
assert.equal(snap1.length, 1, "first snapshot unchanged");
|
|
assert.equal(snap2.length, 2, "second snapshot includes new entry");
|
|
});
|
|
|
|
test("subscribe receives new lines", () => {
|
|
const buf = new RingBuffer();
|
|
const received: LogLine[] = [];
|
|
const unsub = buf.subscribe((l) => received.push(l));
|
|
|
|
buf.push(makeLine("hello"));
|
|
buf.push(makeLine("world"));
|
|
|
|
assert.equal(received.length, 2);
|
|
assert.equal(received[0].line, "hello");
|
|
assert.equal(received[1].line, "world");
|
|
|
|
unsub();
|
|
buf.push(makeLine("after-unsub"));
|
|
assert.equal(received.length, 2, "no more events after unsubscribe");
|
|
});
|
|
|
|
test("flush writes to file when path set", async () => {
|
|
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-ring-"));
|
|
const filePath = path.join(tmpDir, "ring.log");
|
|
|
|
try {
|
|
const buf = new RingBuffer();
|
|
buf.setFlushPath(filePath);
|
|
buf.push(makeLine("line-one"));
|
|
buf.push({ ts: Date.now(), stream: "stderr", line: "err-line" });
|
|
|
|
// Force flush by calling private method indirectly — dispose triggers cleanup
|
|
// We access the private method via prototype cast for testing purposes.
|
|
(buf as unknown as { flushToDisk: () => void }).flushToDisk();
|
|
|
|
assert.ok(fs.existsSync(filePath), "flush file should exist");
|
|
const content = fs.readFileSync(filePath, "utf8");
|
|
assert.ok(content.includes("line-one"), "flush file should contain log entry");
|
|
assert.ok(content.includes("[stderr]"), "flush file should contain stderr entry");
|
|
} finally {
|
|
fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
|
|
}
|
|
});
|
|
|
|
test("dispose clears subscribers and stops flush timer", () => {
|
|
const buf = new RingBuffer();
|
|
const received: LogLine[] = [];
|
|
buf.subscribe((l) => received.push(l));
|
|
buf.dispose();
|
|
|
|
buf.push(makeLine("after-dispose"));
|
|
assert.equal(received.length, 0, "no events after dispose");
|
|
});
|