@useblacksmith/vitest 0.2.1 → 0.4.0

package/README.md

@@ -24,6 +24,23 @@ With the plugin, vitest only runs tests impacted by changes since the last succe
 
 Requires Vitest 5.1 or newer.
 
+### Vite+
+
+Vite+ runs Vitest under `vp test`, so the plugin is loaded from the shared `vite.config.ts`:
+
+```ts
+// vite.config.ts
+import 'vite-plus/test/config'
+import { defineConfig } from 'vite-plus'
+import blacksmith from '@useblacksmith/vitest'
+
+export default defineConfig({
+	plugins: [blacksmith()],
+})
+```
+
+`vp test run` then runs the affected selection, including with `--shard`, test file filters, and `--config <path> --dir .` from a workspace package. Requires `vite-plus` 1.5.0 or newer, the first release that ships Vitest 5.1.
+
 ## Running locally
 
 The same selection applies locally: a run reruns what changed on disk since the last successful run, committed or not. To run every test locally and select only in CI:

package/dist/affected.d.ts

@@ -2,7 +2,7 @@ import { BloomFilter } from './bloom.js';
 import type { Reporter, TestModule, TestRunEndReason, TestSpecification, VCSProvider, VCSProviderOptions, Vitest } from 'vitest/node';
 import { type Tree } from './git.js';
 export declare const SNAPSHOT_FILE = "blacksmith.json";
-declare const SNAPSHOT_VERSION = 4;
+declare const SNAPSHOT_VERSION = 5;
 /** A `dependencies` entry, compiled: test files matching `tests` depend on files matching `deps`; both root-relative. */
 export interface DependencyRule {
     tests: (file: string) => boolean;
@@ -20,6 +20,8 @@ export interface Shard {
 export interface Snapshot {
     version: typeof SNAPSHOT_VERSION;
     head: string;
+    /** Vitest's root relative to the repository, so one package's snapshot never vouches for another's. */
+    root: string;
     shard: Shard | null;
     /** Names of the projects the run covered (`--project` narrows them). */
     projects: string[];

package/dist/affected.js

@@ -11,7 +11,7 @@ import { shardOwner } from './sequencer.js';
 export const SNAPSHOT_FILE = 'blacksmith.json';
 // Bumped whenever the snapshot's shape changes or the records an anchor
 // vouches for gain a kind of dependency, so an older snapshot is not trusted.
-const SNAPSHOT_VERSION = 4;
+const SNAPSHOT_VERSION = 5;
 export function compileDependencies(dependencies) {
     return Object.entries(dependencies ?? {}).map(([tests, deps]) => ({
         tests: picomatch(tests, { dot: true }),
@@ -138,10 +138,11 @@ async function readSnapshot(file) {
     }
     if (typeof parsed !== 'object' || parsed === null)
         return null;
-    const { version, head, shard, projects, tree, tests } = parsed;
+    const { version, head, root, shard, projects, tree, tests } = parsed;
     const covered = BloomFilter.parse(tests);
     if (version !== SNAPSHOT_VERSION ||
         typeof head !== 'string' ||
+        typeof root !== 'string' ||
         !isShard(shard) ||
         !Array.isArray(projects) ||
         !projects.every((name) => typeof name === 'string') ||
@@ -152,6 +153,7 @@ async function readSnapshot(file) {
     return {
         version: SNAPSHOT_VERSION,
         head,
+        root,
         shard,
         projects: projects,
         tree,
@@ -213,6 +215,12 @@ export class TreeSnapshotProvider {
             log(`no dependency snapshot, running every test of the ${describeShard(shard)}`);
             return null;
         }
+        const repo = await repoRoot(root);
+        const here = repoRelative(repo, this.vitest.config.root);
+        if (snapshot.root !== here) {
+            log(`dependency snapshot is for ${snapshot.root || 'the repository root'}, this run is for ${here || 'the repository root'}, running every test of the ${describeShard(shard)}`);
+            return null;
+        }
         if (!sameShard(snapshot.shard, shard)) {
             log(`dependency snapshot is for ${describeShard(snapshot.shard)}, running every test of the ${describeShard(shard)}`);
             return null;
@@ -222,7 +230,6 @@ export class TreeSnapshotProvider {
             log(`dependency snapshot covers projects [${snapshot.projects.join(', ')}], this run covers [${projects.join(', ')}], running every test of the ${describeShard(shard)}`);
             return null;
         }
-        const repo = await repoRoot(root);
         const tree = await anchorTree(repo, await anchoredPaths(this.vitest, repo, dir, this.dependencies));
         const changedPaths = diffTrees(snapshot.tree, tree);
         const owns = await shardOwner(this.vitest);
@@ -307,6 +314,7 @@ export class ShadowAnalysis {
         const repo = await repoRoot(vitest.config.root);
         const key = cacheKey({
             snapshotVersion: SNAPSHOT_VERSION,
+            root: repoRelative(repo, vitest.config.root),
             projects: projectNames(vitest),
             shard: vitest.config.shard ?? null,
             head: process.env.GITHUB_SHA || (await headSha(repo)),
@@ -480,6 +488,7 @@ export class SnapshotRecorder {
         const snapshot = {
             version: SNAPSHOT_VERSION,
             head: await headSha(repo),
+            root: repoRelative(repo, root),
             shard: shard ?? null,
             projects: projectNames(this.vitest),
             tree: await anchorTree(repo, await anchoredPaths(this.vitest, repo, cacheDir, this.provider.dependencies)),
@@ -499,6 +508,7 @@ export class SnapshotRecorder {
             return;
         const key = cacheKey({
             snapshotVersion: snapshot.version,
+            root: snapshot.root,
             projects: snapshot.projects,
             shard: snapshot.shard,
             head: snapshot.head,
@@ -554,6 +564,7 @@ export async function restoreDependencyCache(vitest) {
     const repo = await repoRoot(vitest.config.root);
     const key = cacheKey({
         snapshotVersion: SNAPSHOT_VERSION,
+        root: repoRelative(repo, vitest.config.root),
         projects: projectNames(vitest),
         shard: vitest.config.shard ?? null,
         head: process.env.GITHUB_SHA || (await headSha(repo)),

package/dist/cache.d.ts

@@ -21,6 +21,8 @@ export interface CacheKey {
 export declare const DEFAULT_CACHE_PREFIX = "blacksmith-vitest";
 export declare function cacheKey(input: {
     snapshotVersion: number;
+    /** Vitest's root relative to the repository: each package of a monorepo keeps its own entries. */
+    root: string;
     projects: string[];
     shard: {
         index: number;

package/dist/cache.js

@@ -21,9 +21,9 @@ export const DEFAULT_CACHE_PREFIX = 'blacksmith-vitest';
 export function cacheKey(input) {
     const scope = [
         `v${input.snapshotVersion}`,
-        input.projects.some(Boolean)
+        input.root !== '' || input.projects.some(Boolean)
             ? createHash('sha1')
-                .update(input.projects.join('\n'))
+                .update([input.root, ...input.projects].join('\n'))
                 .digest('hex')
                 .slice(0, 12)
             : 'all',

package/dist/git.js

@@ -116,6 +116,15 @@ function under(sorted, dir) {
     return listing;
 }
 const DIRECTORY_MODE = '040000';
+/** A path nothing could read, e.g. a component over NAME_MAX or a NUL byte, is as absent as a missing one. */
+function lstat(file) {
+    try {
+        return lstatSync(file, { throwIfNoEntry: false });
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * What each path looks like now: a file is `<mode> <blob>` as `git ls-tree`
  * prints it, a symlink hashes its target, a directory hashes its listing (every
@@ -139,7 +148,7 @@ export async function anchorTree(repo, paths) {
         return tree;
     const present = new Map();
     for (const file of wanted) {
-        const stat = lstatSync(path.join(repo, file), { throwIfNoEntry: false });
+        const stat = lstat(path.join(repo, file));
         if (stat !== undefined)
             present.set(file, stat);
     }

package/dist/index.d.ts

@@ -1,8 +1,4 @@
 import type { Plugin } from 'vitest/config';
-export { BlacksmithReporter } from './reporter.js';
-export { HashShardSequencer, shardFor } from './sequencer.js';
-export { ShadowAnalysis, type ShadowResult, SNAPSHOT_FILE, type Snapshot, } from './affected.js';
-export type { Payload, RunError, TestResultRecord, TestStatus, } from './payload.js';
 export interface BlacksmithOptions {
     /**
      * Run every test instead of only those affected since the last green run.

package/dist/index.js

@@ -1,9 +1,6 @@
 import { fileURLToPath } from 'node:url';
 import { compileDependencies, configuredProvider, isTreeSnapshotProvider, isSnapshotRecorder, restoreDependencyCache, ShadowAnalysis, SnapshotRecorder, TreeSnapshotProvider, } from './affected.js';
 import { customSequencer, HashShardSequencer, stableShards, } from './sequencer.js';
-export { BlacksmithReporter } from './reporter.js';
-export { HashShardSequencer, shardFor } from './sequencer.js';
-export { ShadowAnalysis, SNAPSHOT_FILE, } from './affected.js';
 /** Beside this module; `.ts` when the plugin runs from source (its own test fixtures). */
 const recordReads = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './record-reads.ts' : './record-reads.js', import.meta.url));
 /** Whether this Vitest wired up the pieces `--changed` selection relies on. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@useblacksmith/vitest",
-	"version": "0.2.1",
-	"description": "Reports Vitest test results to Blacksmith and runs only the tests affected since the last run",
+	"version": "0.4.0",
+	"description": "Runs only the Vitest tests affected since the last successful run, with Blacksmith-backed caching",
 	"type": "module",
 	"license": "MIT",
 	"repository": {
@@ -21,7 +21,8 @@
 		"build": "tsc -p tsconfig.build.json",
 		"prepack": "npm run build",
 		"check:types": "tsc --noEmit",
-		"test": "vitest run"
+		"test": "vitest run",
+		"release": "scripts/release.sh"
 	},
 	"peerDependencies": {
 		"vitest": ">=5.1.0"

package/dist/payload.d.ts

@@ -1,56 +0,0 @@
-export type TestStatus = 'passed' | 'failed' | 'skipped';
-export interface TestError {
-    message: string;
-    stack: string;
-}
-export interface TestResultRecord {
-    /** Test file, relative to the repository when the run is inside GITHUB_WORKSPACE */
-    file: string;
-    /** Vitest project the test ran in; null for the root project */
-    project: string | null;
-    /** Enclosing describe blocks, outermost first */
-    suite: string[];
-    name: string;
-    status: TestStatus;
-    /** null for tests that never ran (skipped, todo) */
-    duration_ms: number | null;
-    started_at: string | null;
-    retries: number;
-    flaky: boolean;
-    error?: TestError;
-}
-/** A failure outside any test: a module that threw while being imported or collected, or an unhandled error */
-export interface RunError {
-    /** null when the error is not attributable to a test file */
-    file: string | null;
-    message: string;
-    stack: string;
-}
-export interface Payload {
-    framework: 'vitest';
-    framework_version: string;
-    reporter_version: string;
-    run: {
-        started_at: string;
-        finished_at: string;
-        reason: 'passed' | 'failed' | 'interrupted';
-    };
-    results: TestResultRecord[];
-    errors: RunError[];
-    /** true when results or errors beyond the count or byte caps were dropped */
-    truncated: boolean;
-}
-export declare const MAX_RESULTS = 50000;
-export declare const MAX_PAYLOAD_BYTES: number;
-export declare const MAX_ERROR_MESSAGE_CHARS = 4096;
-export declare const MAX_ERROR_STACK_CHARS = 16384;
-export declare function truncate(text: string, max: number): string;
-/**
- * Keeps results in order until either cap is hit, then errors in whatever
- * budget is left, so a payload never serializes past MAX_PAYLOAD_BYTES of
- * JSON (the gzip input, which is also the backend's memory ceiling).
- */
-export declare function buildPayload(results: TestResultRecord[], errors: RunError[], run: Payload['run'], versions: {
-    framework: string;
-    reporter: string;
-}, maxBytes?: number): Payload;

package/dist/payload.js

@@ -1,40 +0,0 @@
-export const MAX_RESULTS = 50_000;
-export const MAX_PAYLOAD_BYTES = 32 * 1024 * 1024;
-export const MAX_ERROR_MESSAGE_CHARS = 4_096;
-export const MAX_ERROR_STACK_CHARS = 16_384;
-export function truncate(text, max) {
-    return text.length > max ? `${text.slice(0, max)}…` : text;
-}
-/**
- * Keeps results in order until either cap is hit, then errors in whatever
- * budget is left, so a payload never serializes past MAX_PAYLOAD_BYTES of
- * JSON (the gzip input, which is also the backend's memory ceiling).
- */
-export function buildPayload(results, errors, run, versions, maxBytes = MAX_PAYLOAD_BYTES) {
-    let bytes = 0;
-    let truncated = false;
-    const keep = (items, max) => {
-        const kept = [];
-        for (const item of items) {
-            const size = JSON.stringify(item).length + 1;
-            if (kept.length >= max || bytes + size > maxBytes) {
-                truncated = true;
-                break;
-            }
-            bytes += size;
-            kept.push(item);
-        }
-        return kept;
-    };
-    const keptResults = keep(results, MAX_RESULTS);
-    const keptErrors = keep(errors, MAX_RESULTS);
-    return {
-        framework: 'vitest',
-        framework_version: versions.framework,
-        reporter_version: versions.reporter,
-        run,
-        results: keptResults,
-        errors: keptErrors,
-        truncated,
-    };
-}

package/dist/reporter.d.ts

@@ -1,29 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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/upload.d.ts

@@ -1,17 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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;
-}