@useblacksmith/vitest 0.0.0-stage → 0.2.0

package/dist/record-reads.js

@@ -0,0 +1,109 @@
+import { createRequire, syncBuiltinESMExports } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Setup file the plugin puts first in every worker: each `fs` read lands in
+ * the dependency set Vitest keeps for the test file being run, beside its
+ * imports, so a fixture, a listed directory or a probed-but-missing file
+ * reruns the test when it changes. The wrapped functions stay on the shared
+ * `fs` object across the files a worker runs; the set is looked up per call,
+ * so a read is charged to whichever file is current.
+ */
+// Loaded with `require`, not `import`: under `vmThreads`/`vmForks` an import
+// would build this context's `node:fs` module namespace now, from the
+// functions as they are before wrapping, and a test file's own
+// `import { readFileSync } from 'node:fs'` would get that snapshot.
+const fs = createRequire(import.meta.url)('node:fs');
+const BRAND = Symbol.for('blacksmith.recordReads');
+const CONTEXT = Symbol.for('blacksmith.recordReads.context');
+// `vmThreads`/`vmForks` evaluate this file once per test context while the
+// builtin `fs` object is shared, so the wrappers read the worker state through
+// a slot the latest evaluation points at the current context's global.
+const shared = fs;
+shared[CONTEXT] = globalThis;
+function toPath(target) {
+    if (typeof target === 'string')
+        return target;
+    if (Buffer.isBuffer(target))
+        return target.toString();
+    if (target instanceof URL) {
+        try {
+            return fileURLToPath(target);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function record(target) {
+    const dependencies = shared[CONTEXT]
+        ?.__vitest_worker__?.dependencies;
+    if (!dependencies)
+        return;
+    const file = toPath(target);
+    if (file === null)
+        return;
+    const absolute = path.resolve(file);
+    if (absolute.split(path.sep).includes('node_modules'))
+        return;
+    dependencies.add(absolute);
+}
+/** A recursive copy reads every file below its source. */
+function recordTree(target) {
+    record(target);
+    const file = toPath(target);
+    if (file === null)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(file, { recursive: true, encoding: 'utf8' });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries)
+        record(path.join(file, entry));
+}
+function wrap(object, name, recorder = record) {
+    const original = object[name];
+    if (typeof original !== 'function' || BRAND in original)
+        return;
+    const wrapped = function (...args) {
+        recorder(args[0]);
+        return original.apply(this, args);
+    };
+    // `realpathSync.native` and friends live on the function.
+    Object.assign(wrapped, original);
+    wrap(wrapped, 'native', recorder);
+    Object.defineProperty(wrapped, BRAND, { value: true });
+    object[name] = wrapped;
+}
+const READS = [
+    'access',
+    'copyFile',
+    'lstat',
+    'open',
+    'opendir',
+    'readdir',
+    'readFile',
+    'readlink',
+    'realpath',
+    'stat',
+];
+for (const name of READS) {
+    wrap(fs, name);
+    wrap(fs, `${name}Sync`);
+    wrap(fs.promises, name);
+}
+wrap(fs, 'existsSync');
+wrap(fs, 'createReadStream');
+for (const object of [fs, fs.promises]) {
+    wrap(object, 'cp', recordTree);
+}
+wrap(fs, 'cpSync', recordTree);
+// `import { readFileSync } from 'node:fs'` binds the builtin's ESM namespace,
+// which only sees the wrapped functions once the namespace is resynced; the
+// vm pools keep their own per-context namespaces and expose their resync.
+const required = globalThis.__vitest_required__;
+(required?.syncBuiltinESMExports ?? syncBuiltinESMExports)();

package/dist/reporter.d.ts

@@ -0,0 +1,29 @@
+import type { Reporter, SerializedError, TestModule, TestRunEndReason, Vitest } from 'vitest/node';
+import { type RunError, type TestResultRecord } from './payload.js';
+export declare const ENV_BACKEND_URL = "BLACKSMITH_BACKEND_URL";
+export declare const ENV_TOKEN = "BLACKSMITH_JOB_HISTORY_TOKEN";
+export declare const RESULTS_PATH = "/api/jobs/test-results";
+/**
+ * Marks a reporter as ours across package copies: a workspace whose root and
+ * project resolve two installs of this package has two `BlacksmithReporter`
+ * classes, and `instanceof` would let both register.
+ */
+export declare const REPORTER_BRAND: unique symbol;
+export declare function isBlacksmithReporter(reporter: unknown): boolean;
+/**
+ * Sends every test's outcome and duration to Blacksmith in one request when
+ * the run ends. Does nothing unless the runner injected BLACKSMITH_BACKEND_URL
+ * and BLACKSMITH_JOB_HISTORY_TOKEN, and never changes the run's outcome.
+ */
+export declare class BlacksmithReporter implements Reporter {
+    readonly [REPORTER_BRAND] = true;
+    private vitest;
+    private startedAt;
+    onInit(vitest: Vitest): void;
+    onTestRunStart(): void;
+    onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
+    private report;
+}
+export declare function collectResults(testModules: ReadonlyArray<TestModule>, workspace: string | undefined): TestResultRecord[];
+/** Errors a module raised while being imported or collected, outside any test (a syntax error, a top-level throw). */
+export declare function collectModuleErrors(testModules: ReadonlyArray<TestModule>, workspace: string | undefined): RunError[];

package/dist/reporter.js

@@ -0,0 +1,149 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { buildPayload, MAX_ERROR_MESSAGE_CHARS, MAX_ERROR_STACK_CHARS, truncate, } from './payload.js';
+import { upload } from './upload.js';
+export const ENV_BACKEND_URL = 'BLACKSMITH_BACKEND_URL';
+export const ENV_TOKEN = 'BLACKSMITH_JOB_HISTORY_TOKEN';
+export const RESULTS_PATH = '/api/jobs/test-results';
+/**
+ * Marks a reporter as ours across package copies: a workspace whose root and
+ * project resolve two installs of this package has two `BlacksmithReporter`
+ * classes, and `instanceof` would let both register.
+ */
+export const REPORTER_BRAND = Symbol.for('@useblacksmith/vitest:reporter');
+export function isBlacksmithReporter(reporter) {
+    return (typeof reporter === 'object' &&
+        reporter !== null &&
+        REPORTER_BRAND in reporter);
+}
+const { version: reporterVersion } = createRequire(import.meta.url)('../package.json');
+/**
+ * Sends every test's outcome and duration to Blacksmith in one request when
+ * the run ends. Does nothing unless the runner injected BLACKSMITH_BACKEND_URL
+ * and BLACKSMITH_JOB_HISTORY_TOKEN, and never changes the run's outcome.
+ */
+export class BlacksmithReporter {
+    [REPORTER_BRAND] = true;
+    vitest;
+    startedAt = new Date();
+    onInit(vitest) {
+        this.vitest = vitest;
+    }
+    onTestRunStart() {
+        this.startedAt = new Date();
+    }
+    async onTestRunEnd(testModules, unhandledErrors, reason) {
+        const backendUrl = process.env[ENV_BACKEND_URL];
+        const token = process.env[ENV_TOKEN];
+        if (!backendUrl || !token)
+            return;
+        try {
+            await this.report(backendUrl, token, testModules, unhandledErrors, reason);
+        }
+        catch (error) {
+            this.vitest.logger.warn(`[blacksmith] could not report test results: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async report(backendUrl, token, testModules, unhandledErrors, reason) {
+        const workspace = process.env.GITHUB_WORKSPACE;
+        const results = collectResults(testModules, workspace);
+        const errors = [
+            ...collectModuleErrors(testModules, workspace),
+            ...unhandledErrors.map((error) => toRunError(null, error)),
+        ];
+        if (results.length === 0 && errors.length === 0)
+            return;
+        const payload = buildPayload(results, errors, {
+            started_at: this.startedAt.toISOString(),
+            finished_at: new Date().toISOString(),
+            reason,
+        }, { framework: this.vitest.version, reporter: reporterVersion });
+        const outcome = await upload(`${backendUrl.replace(/\/+$/, '')}${RESULTS_PATH}`, token, `blacksmith-vitest/${reporterVersion}`, JSON.stringify(payload));
+        if (!outcome.ok) {
+            throw new Error(outcome.error);
+        }
+        const counts = [
+            `${payload.results.length} test results`,
+            payload.errors.length > 0 ? `${payload.errors.length} errors` : '',
+            payload.truncated ? '(truncated)' : '',
+        ];
+        this.vitest.logger.log(`[blacksmith] reported ${counts.filter(Boolean).join(' ')}`);
+    }
+}
+export function collectResults(testModules, workspace) {
+    const records = [];
+    for (const testModule of testModules) {
+        const file = relativeFile(testModule, workspace);
+        const project = testModule.project.name || null;
+        for (const testCase of testModule.children.allTests()) {
+            const result = testCase.result();
+            if (result.state === 'pending')
+                continue;
+            records.push(toRecord(testCase, file, project, result.state));
+        }
+    }
+    return records;
+}
+/** Errors a module raised while being imported or collected, outside any test (a syntax error, a top-level throw). */
+export function collectModuleErrors(testModules, workspace) {
+    const errors = [];
+    for (const testModule of testModules) {
+        const file = relativeFile(testModule, workspace);
+        for (const error of testModule.errors()) {
+            errors.push(toRunError(file, error));
+        }
+    }
+    return errors;
+}
+/**
+ * Paths are repo-relative when the test file is inside the checkout (a
+ * monorepo package's vitest root is not the repo root), else Vitest's
+ * root-relative id.
+ */
+function relativeFile(testModule, workspace) {
+    if (workspace) {
+        const relative = path.relative(workspace, testModule.moduleId);
+        if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+            return relative.split(path.sep).join('/');
+        }
+    }
+    return testModule.relativeModuleId;
+}
+function toRecord(testCase, file, project, status) {
+    const diagnostic = testCase.diagnostic();
+    const record = {
+        file,
+        project,
+        suite: suiteChain(testCase),
+        name: testCase.name,
+        status,
+        duration_ms: diagnostic?.duration ?? null,
+        started_at: diagnostic
+            ? new Date(diagnostic.startTime).toISOString()
+            : null,
+        retries: diagnostic?.retryCount ?? 0,
+        flaky: diagnostic?.flaky ?? false,
+    };
+    const error = status === 'failed' ? testCase.result().errors?.[0] : undefined;
+    if (error) {
+        record.error = {
+            message: truncate(error.message ?? '', MAX_ERROR_MESSAGE_CHARS),
+            stack: truncate(error.stack ?? '', MAX_ERROR_STACK_CHARS),
+        };
+    }
+    return record;
+}
+function toRunError(file, error) {
+    return {
+        file,
+        message: truncate(error.message ?? '', MAX_ERROR_MESSAGE_CHARS),
+        stack: truncate(error.stack ?? '', MAX_ERROR_STACK_CHARS),
+    };
+}
+function suiteChain(testCase) {
+    const chain = [];
+    for (let parent = testCase.parent; parent.type === 'suite'; parent = parent.parent) {
+        chain.unshift(parent.name);
+    }
+    return chain;
+}

package/dist/sequencer.d.ts

@@ -0,0 +1,40 @@
+import { BaseSequencer, type ResolvedConfig, type TestSpecification, type Vitest } from 'vitest/node';
+declare const BRAND: unique symbol;
+type SequencerClass = ResolvedConfig['sequence']['sequencer'];
+/**
+ * The name of the configured sequencer when it is not Blacksmith's (nor a
+ * subclass of it), `null` when it is. Another plugin or the config may have
+ * replaced `sequence.sequencer` after this plugin's `config()` ran.
+ */
+export declare function customSequencer(sequencer: unknown): string | null;
+/** Zero-based shard owning `relativePath`; depends only on the path and `count`, never on the other test files. */
+export declare function shardFor(relativePath: string, count: number): number;
+export declare function inShard(root: string, moduleId: string, shard: {
+    index: number;
+    count: number;
+} | undefined): boolean;
+/**
+ * Replaces vitest's contiguous slices: a test stays in the same shard when
+ * other tests are added, removed or filtered out by `--changed`, so each
+ * shard's dependency record only ever has to vouch for its own tests.
+ */
+/**
+ * Vitest hands `shard()` the specs `--changed` kept, so a sequencer that
+ * slices by position moves tests between shards as the selection changes,
+ * and a test two shards disagree about can run on neither. The wrapper takes
+ * the sequencer's own assignment over the full test list, as on a full run,
+ * and keeps it whatever the selection; `sort()` stays the sequencer's.
+ */
+export declare function stableShards(Theirs: SequencerClass): SequencerClass;
+/**
+ * Which tests this shard runs, independent of the selection: by path hash
+ * under Blacksmith's sequencer, by the wrapped sequencer's own `shard()`
+ * over the full test list otherwise.
+ */
+export declare function shardOwner(vitest: Vitest): Promise<(moduleId: string) => boolean>;
+export declare class HashShardSequencer extends BaseSequencer {
+    /** Marks this class and its subclasses, across copies of the module. */
+    static readonly [BRAND] = true;
+    shard(files: TestSpecification[]): Promise<TestSpecification[]>;
+}
+export {};

package/dist/sequencer.js

@@ -0,0 +1,79 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { BaseSequencer, } from 'vitest/node';
+const BRAND = Symbol.for('blacksmith.vitest.sequencer');
+const WRAPPED = Symbol.for('blacksmith.vitest.sequencer.wrapped');
+/**
+ * The name of the configured sequencer when it is not Blacksmith's (nor a
+ * subclass of it), `null` when it is. Another plugin or the config may have
+ * replaced `sequence.sequencer` after this plugin's `config()` ran.
+ */
+export function customSequencer(sequencer) {
+    if (typeof sequencer !== 'function')
+        return null;
+    if (sequencer[BRAND] === true)
+        return null;
+    return sequencer.name || 'anonymous sequencer';
+}
+/** Zero-based shard owning `relativePath`; depends only on the path and `count`, never on the other test files. */
+export function shardFor(relativePath, count) {
+    const digest = createHash('sha1')
+        .update(relativePath.split(path.sep).join('/'))
+        .digest();
+    return digest.readUInt32BE(0) % count;
+}
+export function inShard(root, moduleId, shard) {
+    if (!shard)
+        return true;
+    return (shardFor(path.relative(root, moduleId), shard.count) === shard.index - 1);
+}
+/**
+ * Replaces vitest's contiguous slices: a test stays in the same shard when
+ * other tests are added, removed or filtered out by `--changed`, so each
+ * shard's dependency record only ever has to vouch for its own tests.
+ */
+/**
+ * Vitest hands `shard()` the specs `--changed` kept, so a sequencer that
+ * slices by position moves tests between shards as the selection changes,
+ * and a test two shards disagree about can run on neither. The wrapper takes
+ * the sequencer's own assignment over the full test list, as on a full run,
+ * and keeps it whatever the selection; `sort()` stays the sequencer's.
+ */
+export function stableShards(Theirs) {
+    return class extends Theirs {
+        static [BRAND] = true;
+        static [WRAPPED] = Theirs;
+        #vitest;
+        constructor(vitest) {
+            super(vitest);
+            this.#vitest = vitest;
+        }
+        shard = async (files) => {
+            const owns = await shardOwner(this.#vitest);
+            return files.filter((file) => owns(file.moduleId));
+        };
+    };
+}
+/**
+ * Which tests this shard runs, independent of the selection: by path hash
+ * under Blacksmith's sequencer, by the wrapped sequencer's own `shard()`
+ * over the full test list otherwise.
+ */
+export async function shardOwner(vitest) {
+    const { root, shard } = vitest.config;
+    if (!shard)
+        return () => true;
+    const Theirs = vitest.config.sequence.sequencer[WRAPPED];
+    if (!Theirs)
+        return (moduleId) => inShard(root, moduleId, shard);
+    const owned = new Set((await new Theirs(vitest).shard(await vitest.globTestSpecifications())).map((specification) => specification.moduleId));
+    return (moduleId) => owned.has(moduleId);
+}
+export class HashShardSequencer extends BaseSequencer {
+    /** Marks this class and its subclasses, across copies of the module. */
+    static [BRAND] = true;
+    async shard(files) {
+        const { root, shard } = this.ctx.config;
+        return files.filter((file) => inShard(root, file.moduleId, shard));
+    }
+}

package/dist/upload.d.ts

@@ -0,0 +1,17 @@
+export declare const REQUEST_TIMEOUT_MS = 10000;
+export declare const ATTEMPTS = 3;
+export declare const BACKOFF_MS: number[];
+export type UploadOutcome = {
+    ok: true;
+    status: number;
+    bytes: number;
+} | {
+    ok: false;
+    status: number | null;
+    error: string;
+};
+/**
+ * One gzipped bearer POST, retried on network errors and 5xx only; a 4xx is
+ * final because the same body would be rejected again.
+ */
+export declare function upload(url: string, token: string, userAgent: string, json: string, sleep?: (ms: number) => Promise<void>): Promise<UploadOutcome>;

package/dist/upload.js

@@ -0,0 +1,47 @@
+import { gzipSync } from 'node:zlib';
+export const REQUEST_TIMEOUT_MS = 10_000;
+export const ATTEMPTS = 3;
+export const BACKOFF_MS = [1_000, 2_000];
+/**
+ * One gzipped bearer POST, retried on network errors and 5xx only; a 4xx is
+ * final because the same body would be rejected again.
+ */
+export async function upload(url, token, userAgent, json, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+    const body = gzipSync(json);
+    let last = { ok: false, status: null, error: 'not attempted' };
+    for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
+        if (attempt > 0)
+            await sleep(BACKOFF_MS[attempt - 1] ?? 0);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    authorization: `Bearer ${token}`,
+                    'content-type': 'application/json',
+                    'content-encoding': 'gzip',
+                    'user-agent': userAgent,
+                },
+                body,
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+            if (response.ok) {
+                return { ok: true, status: response.status, bytes: body.byteLength };
+            }
+            last = {
+                ok: false,
+                status: response.status,
+                error: `HTTP ${response.status}`,
+            };
+            if (response.status < 500)
+                return last;
+        }
+        catch (error) {
+            last = {
+                ok: false,
+                status: null,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    return last;
+}

package/package.json

@@ -1,6 +1,39 @@
 {
-  "name": "@useblacksmith/vitest",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@useblacksmith/vitest",
+	"version": "0.2.0",
+	"description": "Reports Vitest test results to Blacksmith and runs only the tests affected since the last run",
+	"type": "module",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/useblacksmith/vitest.git"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"prepack": "npm run build",
+		"check:types": "tsc --noEmit",
+		"test": "vitest run"
+	},
+	"peerDependencies": {
+		"vitest": ">=5.1.0"
+	},
+	"devDependencies": {
+		"@types/node": "^26.6.6",
+		"@types/picomatch": "^4.0.3",
+		"typescript": "^7.0.2",
+		"vite": "^8.3.5",
+		"vitest": "^5.1.0"
+	},
+	"dependencies": {
+		"picomatch": "4.0.7"
+	}
+}