@descryy/runtime-test-runner 0.0.0

package/dist/test-runner-collector.d.ts

@@ -0,0 +1,370 @@
+/**
+ * §17's test-runner observation: **`node:test` (RT-073), Jest and Vitest
+ * (RT-123)**, each observed through that runner's own structured reporter
+ * API rather than TAP, a JSON summary file, or any other printed format.
+ *
+ * ## Three reporters, one envelope, no per-runner branch below this line
+ *
+ * The per-runner knowledge is *what a runner's own API calls things*, and
+ * that only exists inside the runner's process. So each runner gets a
+ * reporter that speaks its API (`reporter.ts`, `jest-reporter.ts`,
+ * `vitest-reporter.ts`) and writes one shared NDJSON envelope — node:test's
+ * own event and field names, kept because they were first. Everything from
+ * `createEventTranslator` down is runner-agnostic, the same boundary rule
+ * the IR has. The only per-runner logic is `PROFILES` below: how a command
+ * is recognised, what it is refused for, and which flags are injected.
+ *
+ * ## The defect a second runner exposed in code that had already shipped
+ *
+ * A `test.skip` emits **`test:pass` carrying `skip: true`** on node:test,
+ * and the translator mapped every `test:pass` to TEST_PASSED — so a
+ * skipped test was evidence of a passing one, the shape this checklist
+ * exists to ban, invisible because every fixture was fully-running. They
+ * are counted now, not emitted; see `TraceCoverage.notRun`.
+ *
+ * The node:test notes below still describe what this file's node path
+ * does, unchanged.
+ *
+ * `test:start` / `test:pass` / `test:fail` translate directly into
+ * `TEST_STARTED` / `TEST_PASSED` / `TEST_FAILED` Evidence, with the real
+ * `file`/`line`/`column` Node's own reporter stream already carries —
+ * `reliability: "self-contained"`, the same class a Python traceback or
+ * Ruby backtrace gets, since this came from the runtime's own captured
+ * state, not derivation.
+ *
+ * **Discovery is declared, never inferred** (RT-032's own precedent):
+ * `discoverRunner` refuses a command that names none of the three runners
+ * it observes, rather than sniffing `package.json`/lockfiles to guess which
+ * runner a project uses. Also refuses a command that already carries its
+ * own `--test-reporter` — safely co-existing with an unknown pre-existing
+ * reporter configuration (matching destinations positionally, possibly
+ * conflicting output) is real complexity this collector does not attempt
+ * to get right blindly; a caller who wants both gets an honest refusal
+ * naming why, not a best-effort guess.
+ *
+ * **Trace capture (RT-074): declared, via `TestContext.diagnostic()`, not
+ * inferred from anything.** A test that makes a backend call and wants its
+ * TEST_PASSED/TEST_FAILED evidence to correlate with that call's backend
+ * evidence calls `t.diagnostic("requestId: <the id it used>")` (and/or
+ * `traceId: ...`) — a real node:test API, surfaced as its own
+ * `test:diagnostic` reporter event, distinguishable from suite-level
+ * summary diagnostics by carrying the same `file`/`line` as the test
+ * itself. Nothing here guesses a request id from timing or proximity; a
+ * test that says nothing gets `requestId: null`, same as before.
+ *
+ * **TEST_CASE graph mapping (RT-076): `payload.qualifiedName`, not
+ * `payload.name`, is what a real graph resolves against.** node:test's own
+ * events carry only a test's innermost title; `adapter-typescript`'s
+ * TEST_CASE node name is the full `describe()` chain, space-joined ahead
+ * of the title. `SuiteStack` (below) reconstructs that chain purely from
+ * the reporter stream this collector already reads. `graphNodeId` on
+ * emitted evidence is still always null here, same as every other
+ * collector — `graph-mapping.ts`'s `resolveObservedTestCase` is what a
+ * caller holding both the store and the graph driver uses to resolve and
+ * attribute it, after `write()`, the same way `vertical-slice` already
+ * does for every other evidence type.
+ *
+ * **A note for whoever next mutation-tests this file (RT-080).** This
+ * package's own tests import `@descryy/runtime-test-runner` by package
+ * name, resolving through `exports` to `dist/` — not `../src/*.ts`
+ * directly. Mutating this file and re-running with a bare `node --test
+ * <file>` proves nothing: the compiled `dist/` is untouched and the
+ * mutation is never in the code path actually executed, an inert check
+ * that reads as a passing safety net. Always rebuild between mutate and
+ * run — `npm test` at the repo root does this automatically (`npm run
+ * build && node --test ...`); a scoped `npx tsc -b packages/test-runner`
+ * before a scoped `node --test packages/test-runner/test/*.test.ts` also
+ * works and is faster while iterating on one file.
+ */
+import { type ManagedProcess } from "@descryy/runtime-controller";
+import type { Collector, EmitFn, TestRunnerConfiguration } from "@descryy/runtime-contracts";
+/**
+ * §2 (RT-?): the contracts type, not a look-alike -- `ExecutionConfiguration.testRunner`
+ * IS this shape, the same "one type, not two that could drift" precedent
+ * `BrowserConfiguration`/`BrowserSessionOptions` already set (RT-068). Kept
+ * as a re-export so every existing `@descryy/runtime-test-runner` import
+ * of `TestRunnerConfiguration` still resolves.
+ */
+export type { TestRunnerConfiguration } from "@descryy/runtime-contracts";
+export interface TestRunnerCollectorOptions {
+    readonly configuration: TestRunnerConfiguration;
+    /** Joins emitted Evidence back to a named service, same convention as every other collector. Omit for a standalone test run with no corresponding service. */
+    readonly service?: string;
+}
+/**
+ * Which runner a declared command names. The value is carried through
+ * discovery rather than re-derived, so nothing downstream re-parses a
+ * command string it has already been told the answer for.
+ */
+export type RunnerKind = "node:test" | "jest" | "vitest" | "junit" | "xunit" | "playwright" | "pytest" | "rspec" | "phpunit" | "minitest";
+/**
+ * The version of the NDJSON envelope every reporter speaks (RT-130).
+ *
+ * ## Why a version, and why now rather than when it first hurts
+ *
+ * The three reporters that exist today are TypeScript in this package,
+ * compiled by the same `tsc -b` as the translator — so they cannot drift
+ * from it without the build saying so. **The JUnit listener will not be**:
+ * it is a Java source built by a separate step, and a compiled artifact
+ * that still runs while the envelope moves underneath it produces *wrong
+ * events*, not a build error.
+ *
+ * That is the failure the placement argument was really about. Wiring a
+ * build step can only tell you a file did not compile; it cannot tell you
+ * the thing that *did* compile is no longer telling the truth. A version
+ * in the stream can, at the moment it would otherwise be believed.
+ *
+ * **Landed before the first out-of-band reporter exists, deliberately.** A
+ * version added afterwards has nothing to check on the transition it was
+ * added for: the first listener would speak an unversioned envelope, and
+ * the absence-is-an-error rule below could not be turned on without
+ * breaking it.
+ *
+ * Bump this only when the envelope's *meaning* changes for an existing
+ * field. Adding an optional field a reporter may omit — `skipReason`,
+ * `isSuite`, `qualifiedName` — is not a bump: an older reporter that never
+ * sets it is still telling the truth, and the translator already has a
+ * documented answer for its absence.
+ */
+export declare const ENVELOPE_VERSION = 1;
+/** The handshake line every reporter emits before its first event. */
+export declare const ENVELOPE_HANDSHAKE_TYPE = "descry:envelope";
+export type EnvelopeVerdict = 
+/** A handshake line, consumed here — never translated into an event. */
+{
+    readonly kind: "handshake";
+}
+/** Not a handshake and not translatable: ordinary noise on stdout. */
+ | {
+    readonly kind: "ignore";
+}
+/** A translatable event from a reporter speaking this envelope. */
+ | {
+    readonly kind: "event";
+}
+/** The reporter cannot be believed; `reason` goes to COLLECTOR_ERROR. */
+ | {
+    readonly kind: "refuse";
+    readonly reason: string;
+};
+/**
+ * The envelope gate, a function of its own because the case it exists for
+ * **cannot be reached end to end** (RT-130).
+ *
+ * Measured: node:test redirects a test's stdout — the patched
+ * `process.stdout.write` and the raw fd alike — and re-emits its output as
+ * a `test:stdout` event. So a fixture cannot put a stale handshake on the
+ * wire, and there is no way to drive the mismatch path through a real
+ * `node --test` run. That is a genuine safety property of the design (a
+ * test's own `console.log` can never be mistaken for a reporter line) and
+ * simultaneously the reason this logic is a pure function with its own
+ * tests rather than four lines inside `start()`.
+ *
+ * Stated rather than left as a coverage gap: the wiring is asserted end to
+ * end — a real run declares version 1, produces no `COLLECTOR_ERROR`, and
+ * the handshake never becomes an event — and the refusal is asserted here.
+ */
+export declare function createEnvelopeGate(): {
+    inspect(parsed: unknown, isEvent: boolean): EnvelopeVerdict;
+};
+/**
+ * Why a test did not run, in terms no runner owns.
+ *
+ * - `disabled` — declared not to run (`test.skip`, `@Disabled`, xUnit `Skip=`)
+ * - `not-implemented` — declared as absent rather than switched off (`test.todo`)
+ * - `precondition-unmet` — ran real code and bailed on an assumption (JUnit's `aborted`)
+ * - `unspecified` — the runner reported a skip without saying which
+ *
+ * `not-implemented` exists because RT-124 collapsed node:test's `skip` and
+ * `todo` into one event with no way to tell them apart — "switched off" and
+ * "never written" are different facts about coverage, and that distinction
+ * was dropped silently in the change whose whole subject was not dropping
+ * distinctions silently. `precondition-unmet` is Lane A's JUnit finding
+ * (RT-088), landed with the vocabulary rather than after it.
+ */
+export type SkipReason = "disabled" | "not-implemented" | "precondition-unmet" | "unspecified";
+export type RunnerDiscovery = {
+    readonly ok: true;
+    readonly kind: RunnerKind;
+    readonly command: string;
+    readonly args: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * **Where the reporter flags land in argv is load-bearing for node, not
+ * cosmetic.** Measured while building RT-073: `node --test sample.test.mjs
+ * --test-reporter=... --test-reporter-destination=...` silently falls back
+ * to the default TAP reporter -- once node's `--test` argument parser sees
+ * a positional file argument, anything after it stops being read as a
+ * flag. `node --test --test-reporter=... --test-reporter-destination=...
+ * sample.test.mjs` works. `discoverRunner` only guarantees `--test` is
+ * present *somewhere* in `args`, not that it is the last flag before any
+ * file arguments (a caller may pass `node --test --concurrency=4
+ * some.test.mjs`, and the reporter flags need to land after `--test` but
+ * still before `some.test.mjs`) -- so this inserts them immediately after
+ * the `--test` token specifically, not at the end of the array.
+ *
+ * Jest and Vitest both use full CLI parsers (yargs / cac) that read flags
+ * anywhere, so theirs are appended. That is a real difference between the
+ * three and is why this is per-runner rather than one shared rule.
+ */
+export declare function withReporterFlags(args: readonly string[]): readonly string[];
+/**
+ * Exported on its own so a caller can validate a configured command before
+ * ever attempting to spawn it — the same "refuse atomically before anything
+ * is spawned" shape `validateServicesConfiguration` already established.
+ *
+ * **Declared, never inferred** (RT-032's precedent): this reads the command
+ * the caller wrote and nothing else. It does not open `package.json`, a
+ * lockfile, or a config file to guess which runner a project uses, and a
+ * command it does not recognise gets a named refusal rather than a
+ * best-effort guess.
+ */
+export declare function discoverRunner(rawCommand: string): RunnerDiscovery;
+export declare function reporterFlagsFor(kind: RunnerKind, args: readonly string[]): readonly string[];
+/** `{}` for every profile that has no `reporterEnv` — `start()`'s merge then adds nothing. */
+export declare function reporterEnvFor(kind: RunnerKind, args: readonly string[]): Record<string, string | undefined>;
+/**
+ * The NDJSON envelope every runner's reporter emits — node:test's own event
+ * names and field names, kept as the shared shape because it was first and
+ * renaming it would churn a working translator for nothing. `reporter.ts`,
+ * `jest-reporter.ts` and `vitest-reporter.ts` all write this, which is why
+ * nothing below this line branches on which runner produced it.
+ */
+export interface NodeTestEvent {
+    readonly type: string;
+    readonly data: {
+        readonly name?: string;
+        /**
+         * The full `describe()` chain, space-joined ahead of the title, when
+         * the reporter could supply it directly. Jest and Vitest can; node:test
+         * cannot (its events carry only the innermost title), which is why
+         * `SuiteStack` exists and why this is optional rather than required.
+         */
+        readonly qualifiedName?: string;
+        /** True for a test that did not run. Not a pass — see `TraceCoverage.notRun`. */
+        readonly skip?: boolean;
+        readonly todo?: boolean;
+        /**
+         * **Why it did not run** — a payload field rather than a second event
+         * type (RT-129), because the test for "does this need its own type" is
+         * whether collapsing it changes the answer to *was this code covered*.
+         * Skipped-vs-passed does, oppositely, and earned `TEST_SKIPPED` in
+         * RT-124. Every value here answers `notRun`, so nothing routes
+         * differently and what differs is the explanation.
+         *
+         * Set by each **reporter**, not derived here, for the same reason
+         * `isSuite` is: only the reporter knows what its runner can tell apart.
+         * `unspecified` is a real answer — Vitest reports `state: "skipped"`
+         * for both `.skip` and `.todo` (measured), so claiming either would be
+         * a guess dressed as a fact.
+         *
+         * Runner-agnostic by construction: no value may name a runner, the same
+         * boundary the translator itself keeps.
+         */
+        readonly skipReason?: SkipReason;
+        /**
+         * True when this event describes a **container** (a `describe()` block)
+         * rather than a test case. Only node:test reports containers through
+         * the same channel as tests; Jest's and Vitest's per-test callbacks
+         * never fire for one, so their reporters never set this.
+         */
+        readonly isSuite?: boolean;
+        readonly nesting?: number;
+        readonly file?: string;
+        readonly line?: number;
+        readonly column?: number;
+        readonly message?: string;
+        readonly details?: {
+            readonly duration_ms?: number;
+            readonly error?: {
+                readonly code?: string;
+                readonly failureType?: string;
+                readonly cause?: unknown;
+            };
+        };
+    };
+}
+export declare function isNodeTestEvent(value: unknown): value is NodeTestEvent;
+/**
+ * `test:pass`/`test:fail` arrive from node's own reporter stream BEFORE any
+ * `t.diagnostic()` call inside that same test shows up as its own
+ * `test:diagnostic` event -- measured directly: for a passing test that
+ * calls `t.diagnostic("requestId: X")`, the real event order is
+ * `test:start`, `test:pass`, *then* `test:diagnostic`. Emitting
+ * TEST_PASSED/TEST_FAILED immediately would mean it goes out with
+ * `requestId: null` even when the test declared one one event later --
+ * and `EvidenceStore` has no path to correct a `requestId` after
+ * `write()` (`attribute()` exists only for `graphNodeId`, deliberately;
+ * see its own doc comment). So a result is held, not emitted immediately,
+ * until either a same-test diagnostic merges into it or a signal arrives
+ * that no more are coming for this test (the next `test:start`, or a
+ * diagnostic with no `file` -- node's own suite-level summary lines,
+ * which never carry one). A bounded, disclosed delay -- at most one test's
+ * duration, never batched until the whole run ends -- not a violation of
+ * this collector's own streaming-first design, RT-073's `pumpLines`.
+ */
+export interface TraceCoverage {
+    /** How many TEST_PASSED/TEST_FAILED results this collector has actually emitted. The denominator -- report against this, never against `idsPresent` alone, or "correlated 3 of 3" reads as full coverage when 40 tests ran and only 3 said anything. */
+    readonly testsObserved: number;
+    /** Of `testsObserved`, how many carried a real `requestId` and/or `traceId` via `t.diagnostic()`. */
+    readonly idsPresent: number;
+    /**
+     * Tests the runner reported as **not run** — `.skip` and `.todo`. Each
+     * also gets its own `TEST_SKIPPED` Evidence (RT-124); this is the count,
+     * for a caller that wants the denominator without scanning the store.
+     *
+     * **This collector used to report them as TEST_PASSED**, which is the one
+     * shape this checklist exists to ban, arriving through a runner's own API
+     * rather than through a summary line. Measured on node:test: a skipped
+     * test emits `test:pass` carrying `skip: true`, and a `test.todo` emits
+     * `test:pass` carrying `todo: true`; the translator mapped every
+     * `test:pass` to TEST_PASSED. Vitest reports both as `state: "skipped"`;
+     * Jest reports `.todo` as `status: "todo"` and omits `.skip` from its
+     * result callback altogether, so its count here is a floor, not a total —
+     * disclosed rather than presented as complete.
+     *
+     * **This was a bare counter in RT-123 and is now backed by a real
+     * event.** `RUNTIME_EVENT_TYPES` had no member for a test that did not
+     * run, so counting was the only honest thing a package could do without
+     * extending a shared vocabulary; RT-124 added `TEST_SKIPPED` with its
+     * three producers in one change. The counter stayed because it is the
+     * denominator — "12 passed" is never silently "9 passed and 3 that never
+     * ran" — but the fact is now attributable, with a source location and a
+     * qualified name that resolves to a `TEST_CASE` node.
+     *
+     * TEST_STARTED **is** still emitted for a skipped test — the runner does
+     * not know it will be skipped when it announces the start — so
+     * `testsObserved + notRun` is what reconciles against the TEST_STARTED
+     * count, not `testsObserved` alone.
+     */
+    readonly notRun: number;
+}
+export declare function createEventTranslator(emit: EmitFn, service: string | undefined, processId: string): {
+    handle(event: NodeTestEvent): void;
+    flush(): void;
+    coverage(): TraceCoverage;
+};
+/**
+ * Feeds complete NDJSON lines from `managed`'s growing output buffer to
+ * `onLine`, exactly once each, as they arrive -- streaming-first, not
+ * batched until the process exits. A narrower, single-purpose relative of
+ * `orchestrator`'s `createPollingProcessOutputSource` (same buffer-growth
+ * assumption, same "ends only once the process is finished AND the buffer
+ * stopped growing" ordering) rather than a shared dependency on it: this
+ * collector only ever needs complete lines fed to a callback, not the
+ * general `ProcessOutputSource` shape, and taking a dependency on
+ * `@descryy/runtime-orchestrator` -- the assembly layer -- from a collector
+ * would invert the direction every other package in this repo depends in.
+ */
+export declare function pumpLines(managed: ManagedProcess, onLine: (line: string) => void, pollIntervalMs?: number): Promise<void>;
+export interface TestRunnerCollector extends Collector {
+    /** Resolves once the spawned runner process has exited and every buffered line has been translated. Await this, not just `stop()`, to know the run finished. */
+    waitForCompletion(): Promise<void>;
+    /** How many observed tests actually carried a `t.diagnostic()`-declared correlation id, against how many were observed at all -- the denominator matters (RT-074): "N correlated" alone reads as full coverage no matter how small N is relative to the real test count. `{testsObserved: 0, idsPresent: 0}` before any result has been observed. */
+    traceCoverage(): TraceCoverage;
+}
+export declare function createTestRunnerCollector(options: TestRunnerCollectorOptions): TestRunnerCollector;
+//# sourceMappingURL=test-runner-collector.d.ts.map

package/dist/test-runner-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner-collector.d.ts","sourceRoot":"","sources":["../src/test-runner-collector.ts"],"names":[],"mappings":"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"}