Decode caller-selected protocols from existing recordings through shared CLI/MCP Evidence. Page literal output lines after complete decoding; preserve explicit full output, source identity and failed cleanup ownership. Verified real sigrok-cli 0.7.2 workflows, published UART/SPI/I2C recordings, independent UART values, selector limits, SDK schemas and cleanup regressions. Co-authored-by: Olorinm <59321404+Olorinm@users.noreply.github.com> Assisted-by: Kogasa (gensokyo-skills:kogasa-surprise-testing)
109 lines
3.8 KiB
TypeScript
109 lines
3.8 KiB
TypeScript
import { expect, it, onTestFinished, vi } from "vitest";
|
|
import { writeFile } from "node:fs/promises";
|
|
import type { FileHandle } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { SigrokRecordingProvider } from "../../../src/signals/SigrokRecordingProvider.js";
|
|
import { SignalRecordingService } from "../../../src/application/signals/SignalRecordingService.js";
|
|
import { PrivateRuntimeRoot } from "../../../src/process/PrivateRuntimeRoot.js";
|
|
import { spawnOwnedProviderProcess } from "../../../src/process/ProviderProcess.js";
|
|
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
|
|
|
const cleanup = vi.hoisted(() => ({
|
|
path: "",
|
|
denied: false,
|
|
handles: [] as FileHandle[],
|
|
}));
|
|
vi.mock("node:fs/promises", async (importOriginal) => {
|
|
const filesystem = await importOriginal<typeof import("node:fs/promises")>();
|
|
return {
|
|
...filesystem,
|
|
open: async (...args: Parameters<typeof filesystem.open>) => {
|
|
const handle = await filesystem.open(...args);
|
|
if (args[0] === cleanup.path) {
|
|
cleanup.handles.push(handle);
|
|
const close = handle.close.bind(handle);
|
|
handle.close = async () => {
|
|
if (cleanup.denied && handle.fd >= 0)
|
|
throw new Error("Descriptor close deliberately denied");
|
|
await close();
|
|
};
|
|
}
|
|
return handle;
|
|
},
|
|
};
|
|
});
|
|
|
|
it
|
|
.runIf(process.platform === "linux")
|
|
.each(["capture", "tool", "limiter", "kernel"])(
|
|
"retains failed %s descriptors and retries them before further acquisition and shutdown",
|
|
async (member) => {
|
|
const directory = await createTestTempDirectory("rea-signal-descriptor-");
|
|
const path = join(directory, "recording.vcd");
|
|
const command = join(directory, "sigrok.mjs");
|
|
const limiter = join(directory, "limiter");
|
|
await writeFile(path, "recording bytes");
|
|
await writeFile(limiter, "limiter", { mode: 0o700 });
|
|
await writeFile(
|
|
command,
|
|
`if(process.argv.includes('--version'))console.log('sigrok-cli 0.7.2\\nlibsigrokdecode 0.5.3');else console.log('10-20 uart-1: 42');`,
|
|
{ mode: 0o700 },
|
|
);
|
|
let launches = 0;
|
|
const provider = new SigrokRecordingProvider(
|
|
{
|
|
...process.env,
|
|
REA_SIGROK_COMMAND: command,
|
|
REA_SIGROK_PRLIMIT_COMMAND: limiter,
|
|
},
|
|
(input) => {
|
|
launches += 1;
|
|
return spawnOwnedProviderProcess({
|
|
...input,
|
|
command: process.execPath,
|
|
arguments: [command, ...input.arguments],
|
|
expectedCommand: process.execPath,
|
|
});
|
|
},
|
|
() => PrivateRuntimeRoot.create({ parent: directory }),
|
|
);
|
|
cleanup.path =
|
|
member === "capture"
|
|
? path
|
|
: member === "tool"
|
|
? command
|
|
: member === "limiter"
|
|
? limiter
|
|
: "/proc/self/limits";
|
|
cleanup.denied = true;
|
|
cleanup.handles = [];
|
|
onTestFinished(async () => {
|
|
cleanup.denied = false;
|
|
await provider.close();
|
|
for (const handle of cleanup.handles) await handle.close();
|
|
cleanup.path = "";
|
|
});
|
|
const service = new SignalRecordingService(provider);
|
|
const first = await service.decode({ path, decoders: "uart" });
|
|
expect(first).toMatchObject({
|
|
ok: false,
|
|
error: { cleanupIncomplete: true, cleanupResources: [cleanup.path] },
|
|
});
|
|
expect(cleanup.handles).toHaveLength(1);
|
|
expect(cleanup.handles[0]?.fd).toBeGreaterThanOrEqual(0);
|
|
const launchCount = launches;
|
|
expect(await service.decode({ path, decoders: "uart" })).toMatchObject({
|
|
ok: false,
|
|
error: { cleanupIncomplete: true },
|
|
});
|
|
expect(cleanup.handles).toHaveLength(1);
|
|
expect(launches).toBe(launchCount);
|
|
await expect(provider.close()).rejects.toMatchObject({
|
|
cleanupIncomplete: true,
|
|
});
|
|
cleanup.denied = false;
|
|
await provider.close();
|
|
expect(cleanup.handles[0]?.fd).toBe(-1);
|
|
},
|
|
);
|