vitest 0.0.21 → 0.0.22

package/README.md

@@ -158,7 +158,7 @@ describe('suite', () => {
 - [ ] Parallel Executing
 - [ ] CLI Help (Use yargs)
 - [x] JSDom
-- [ ] Watch
+- [x] Watch
 - [ ] Source Map
 - [ ] Coverage
 

package/dist/cli.js

@@ -1,4 +1,3 @@
-var _a;
 import minimist from 'minimist';
 import c from 'picocolors';
 import { run } from './run';
@@ -19,8 +18,9 @@ const argv = minimist(process.argv.slice(2), {
         return true;
     },
 });
-// @ts-expect-error
-const server = (_a = process === null || process === void 0 ? void 0 : process.__vite_node__) === null || _a === void 0 ? void 0 : _a.server;
+if (!process.__vite_node__)
+    throw new Error('Vite can only run in Vite environment, please use the CLI to start the process');
+const server = process.__vite_node__.server;
 const viteConfig = (server === null || server === void 0 ? void 0 : server.config) || {};
 const testOptions = viteConfig.test || {};
 await run(Object.assign(Object.assign(Object.assign({}, argv), testOptions), { server, updateSnapshot: argv.update, rootDir: argv.root || process.cwd(), nameFilters: argv._ }));

package/dist/entry.js

@@ -2,7 +2,7 @@ import { fileURLToPath } from 'url';
 import { resolve, dirname } from 'path';
 import minimist from 'minimist';
 import { findUp } from 'find-up';
-import { run } from './node.js';
+import { run } from './node/index.js';
 process.env.VITEST = 'true';
 const argv = minimist(process.argv.slice(2), {
     alias: {

package/dist/node/index.d.ts

@@ -0,0 +1,22 @@
+import { InlineConfig, ViteDevServer } from 'vite';
+declare global {
+    namespace NodeJS {
+        interface Process {
+            __vite_node__: {
+                server: ViteDevServer;
+                watch?: boolean;
+                moduleCache: Map<string, Promise<any>>;
+            };
+        }
+    }
+}
+export interface ViteNodeOptions {
+    silent?: boolean;
+    root: string;
+    files: string[];
+    _?: string[];
+    shouldExternalize?: (file: string) => boolean;
+    config?: string;
+    defaultConfig?: InlineConfig;
+}
+export declare function run(argv: ViteNodeOptions): Promise<void>;

package/dist/{node.js → node/index.js}

@@ -5,6 +5,7 @@ import vm from 'vm';
 import { createServer, mergeConfig } from 'vite';
 import c from 'picocolors';
 const { red, dim, yellow } = c;
+const __pendingModules__ = new Map();
 export async function run(argv) {
     process.exitCode = 0;
     const root = argv.root || process.cwd();
@@ -19,9 +20,9 @@ export async function run(argv) {
         resolve: {},
     }));
     await server.pluginContainer.buildStart({});
-    // @ts-expect-error
     process.__vite_node__ = {
         server,
+        moduleCache: __pendingModules__,
     };
     try {
         await execute(files, server, argv);
@@ -31,7 +32,8 @@ export async function run(argv) {
         throw e;
     }
     finally {
-        await server.close();
+        if (!process.__vite_node__.watch)
+            await server.close();
     }
 }
 function normalizeId(id) {
@@ -47,7 +49,9 @@ function toFilePath(id, server) {
         ? id.slice(4)
         : id.startsWith(dirname(server.config.root))
             ? id
-            : slash(resolve(server.config.root, id.slice(1)));
+            : id.startsWith('/')
+                ? slash(resolve(server.config.root, id.slice(1)))
+                : id;
     if (absolute.startsWith('//'))
         absolute = absolute.slice(1);
     if (!absolute.startsWith('/'))
@@ -55,15 +59,12 @@ function toFilePath(id, server) {
     return absolute;
 }
 async function execute(files, server, options) {
-    const __pendingModules__ = new Map();
     const result = [];
     for (const file of files)
         result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []));
     return result;
-    async function directRequest(rawId, callstack) {
-        if (builtinModules.includes(rawId))
-            return import(rawId);
-        callstack = [...callstack, rawId];
+    async function directRequest(id, fsPath, callstack) {
+        callstack = [...callstack, id];
         const request = async (dep) => {
             if (callstack.includes(dep)) {
                 throw new Error(`${red('Circular dependency detected')}\nStack:\n${[...callstack, dep].reverse().map((i) => {
@@ -73,19 +74,15 @@ async function execute(files, server, options) {
             }
             return cachedRequest(dep, callstack);
         };
-        const id = normalizeId(rawId);
-        const absolute = toFilePath(id, server);
-        if (options.shouldExternalize(absolute))
-            return import(absolute);
         const result = await server.transformRequest(id, { ssr: true });
         if (!result)
             throw new Error(`failed to load ${id}`);
-        const url = pathToFileURL(absolute);
+        const url = pathToFileURL(fsPath);
         const exports = {};
         const context = {
             require: createRequire(url),
-            __filename: absolute,
-            __dirname: dirname(absolute),
+            __filename: fsPath,
+            __dirname: dirname(fsPath),
             __vite_ssr_import__: request,
             __vite_ssr_dynamic_import__: request,
             __vite_ssr_exports__: exports,
@@ -93,17 +90,23 @@ async function execute(files, server, options) {
             __vite_ssr_import_meta__: { url },
         };
         const fn = vm.runInThisContext(`async (${Object.keys(context).join(',')}) => { ${result.code} }`, {
-            filename: absolute,
+            filename: fsPath,
             lineOffset: 0,
         });
         await fn(...Object.values(context));
         return exports;
     }
-    async function cachedRequest(id, callstack) {
-        if (__pendingModules__.has(id))
-            return __pendingModules__.get(id);
-        __pendingModules__.set(id, directRequest(id, callstack));
-        return await __pendingModules__.get(id);
+    async function cachedRequest(rawId, callstack) {
+        if (builtinModules.includes(rawId))
+            return import(rawId);
+        const id = normalizeId(rawId);
+        const fsPath = toFilePath(id, server);
+        if (options.shouldExternalize(fsPath))
+            return import(fsPath);
+        if (__pendingModules__.has(fsPath))
+            return __pendingModules__.get(fsPath);
+        __pendingModules__.set(fsPath, directRequest(id, fsPath, callstack));
+        return await __pendingModules__.get(fsPath);
     }
     function exportAll(exports, sourceModule) {
         // eslint-disable-next-line no-restricted-syntax

package/dist/reporters/default.d.ts

@@ -1,24 +1,21 @@
 import Listr from 'listr';
-import { Reporter, RunnerContext, Task } from '../types';
+import { File, Reporter, RunnerContext, Task } from '../types';
 interface TaskPromise {
     promise: Promise<void>;
     resolve: () => void;
     reject: (e: unknown) => void;
 }
 export declare class DefaultReporter implements Reporter {
-    indent: number;
     start: number;
     end: number;
     listr: Listr | null;
     listrPromise: Promise<void> | null;
     taskMap: Map<Task, TaskPromise>;
-    onStart(): void;
-    onCollected(ctx: RunnerContext): void;
+    onCollected(files: File[]): void;
     onTaskEnd(task: Task): void;
-    onFinished({ files }: RunnerContext): Promise<void>;
-    private getIndent;
-    private log;
-    private error;
+    onFinished(ctx: RunnerContext): Promise<void>;
+    onWatcherStart(ctx: RunnerContext): Promise<void>;
+    onWatcherRerun(files: string[], trigger: string): Promise<void>;
     onSnapshotUpdate(): void;
 }
 export {};

package/dist/reporters/default.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import { performance } from 'perf_hooks';
 import { relative } from 'path';
 import c from 'picocolors';
@@ -5,20 +6,16 @@ import Listr from 'listr';
 const CROSS = '✖ ';
 export class DefaultReporter {
     constructor() {
-        this.indent = 0;
         this.start = 0;
         this.end = 0;
         this.listr = null;
         this.listrPromise = null;
         this.taskMap = new Map();
     }
-    onStart() {
-        this.indent = 0;
-    }
-    onCollected(ctx) {
+    onCollected(files) {
         this.start = performance.now();
         this.taskMap = new Map();
-        const tasks = ctx.files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
         tasks.forEach((t) => {
             const obj = {};
             obj.promise = new Promise((resolve, reject) => {
@@ -42,7 +39,7 @@ export class DefaultReporter {
         const listrOptions = {
             exitOnError: false,
         };
-        this.listr = new Listr(ctx.files.map((file) => {
+        this.listr = new Listr(files.map((file) => {
             return {
                 title: relative(process.cwd(), file.filepath),
                 task: () => {
@@ -67,12 +64,11 @@ export class DefaultReporter {
         else
             (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
     }
-    async onFinished({ files }) {
+    async onFinished(ctx) {
         await this.listrPromise;
-        this.log();
         this.end = performance.now();
-        const suites = files.reduce((acc, file) => acc.concat(file.suites), []);
-        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        console.log();
+        const { tasks, suites, files } = ctx;
         const failedFiles = files.filter(i => i.error);
         const failedSuites = suites.filter(i => i.error);
         const runable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
@@ -80,53 +76,54 @@ export class DefaultReporter {
         const failed = tasks.filter(i => i.state === 'fail');
         const skipped = tasks.filter(i => i.state === 'skip');
         const todo = tasks.filter(i => i.state === 'todo');
-        this.indent = 0;
         if (failedFiles.length) {
-            this.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
+            console.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
             failedFiles.forEach((i) => {
-                this.error(`\n- ${i.filepath}`);
+                console.error(c.red(`\n- ${i.filepath}`));
                 console.error(i.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
         if (failedSuites.length) {
-            this.error(c.bold(`\nFailed to run ${failedSuites.length} suites:`));
+            console.error(c.bold(`\nFailed to run ${failedSuites.length} suites:`));
             failedSuites.forEach((i) => {
                 var _a;
-                this.error(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`);
+                console.error(c.red(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`));
                 console.error(i.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
         if (failed.length) {
-            this.error(c.bold(`\nFailed Tests (${failed.length})`));
+            console.error(c.bold(`\nFailed Tests (${failed.length})`));
             failed.forEach((task) => {
                 var _a;
-                this.error(`\n${CROSS + c.inverse(c.red(' FAIL '))} ${[task.suite.name, task.name].filter(Boolean).join(' > ')} ${c.gray(c.dim(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`))}`);
+                console.error(`\n${CROSS + c.inverse(c.red(' FAIL '))} ${[task.suite.name, task.name].filter(Boolean).join(' > ')} ${c.gray(c.dim(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`))}`);
                 console.error(task.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
-        this.log(c.bold(c.green(`Passed   ${passed.length} / ${runable.length}`)));
+        console.log(c.bold(c.green(`Passed   ${passed.length} / ${runable.length}`)));
         if (failed.length)
-            this.log(c.bold(c.red(`Failed   ${failed.length} / ${runable.length}`)));
+            console.log(c.bold(c.red(`Failed   ${failed.length} / ${runable.length}`)));
         if (skipped.length)
-            this.log(c.yellow(`Skipped  ${skipped.length}`));
+            console.log(c.yellow(`Skipped  ${skipped.length}`));
         if (todo.length)
-            this.log(c.dim(`Todo     ${todo.length}`));
-        this.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
-    }
-    getIndent(offest = 0) {
-        return ' '.repeat((this.indent + offest) * 2);
+            console.log(c.dim(`Todo     ${todo.length}`));
+        console.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
     }
-    log(msg = '', indentOffset = 0) {
-        // eslint-disable-next-line no-console
-        console.log(`${this.getIndent(indentOffset)}${msg}`);
+    async onWatcherStart(ctx) {
+        await this.listrPromise;
+        const failed = ctx.tasks.some(i => i.state === 'fail');
+        if (failed)
+            console.log(c.red('\nTests failed. Watching for file changes...'));
+        else
+            console.log(c.green('\nWatching for file changes...'));
     }
-    error(msg = '', indentOffset = 0) {
-        // eslint-disable-next-line no-console
-        console.error(c.red(`${this.getIndent(indentOffset)}${msg}`));
+    async onWatcherRerun(files, trigger) {
+        await this.listrPromise;
+        console.log(c.blue(`File ${relative(process.cwd(), trigger)} changed, re-running tests...`));
     }
+    // TODO:
     onSnapshotUpdate() {
     }
 }

package/dist/run/index.d.ts

@@ -0,0 +1,8 @@
+import { File, Config, Task, RunnerContext, Suite } from '../types';
+export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
+export declare function collectFiles(paths: string[]): Promise<Record<string, File>>;
+export declare function runSite(suite: Suite, ctx: RunnerContext): Promise<void>;
+export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
+export declare function runFiles(filesMap: Record<string, File>, ctx: RunnerContext): Promise<void>;
+export declare function run(config: Config): Promise<void>;
+export declare function startWatcher(ctx: RunnerContext): Promise<void>;

package/dist/{run.js → run/index.js}

@@ -1,10 +1,10 @@
 import fg from 'fast-glob';
-import { setupChai } from './integrations/chai/setup';
-import { clearContext, defaultSuite } from './suite';
-import { context } from './context';
-import { DefaultReporter } from './reporters/default';
-import { defaultIncludes, defaultExcludes } from './constants';
-import { getSnapshotManager } from './integrations/chai/snapshot';
+import { setupChai } from '../integrations/chai/setup';
+import { clearContext, defaultSuite } from '../suite';
+import { context } from '../context';
+import { DefaultReporter } from '../reporters/default';
+import { defaultIncludes, defaultExcludes } from '../constants';
+import { getSnapshotManager } from '../integrations/chai/snapshot';
 async function callHook(suite, name, args) {
     await Promise.all(suite.hooks[name].map(fn => fn(...args)));
 }
@@ -36,7 +36,7 @@ export async function runTask(task, ctx) {
     await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
 }
 export async function collectFiles(paths) {
-    const files = [];
+    const files = {};
     for (const filepath of paths) {
         const file = {
             filepath,
@@ -58,9 +58,10 @@ export async function collectFiles(paths) {
             file.collected = false;
             process.exitCode = 1;
         }
-        files.push(file);
+        files[filepath] = file;
     }
-    const allSuites = files.reduce((suites, file) => suites.concat(file.suites), []);
+    const allFiles = Object.values(files);
+    const allSuites = allFiles.reduce((suites, file) => suites.concat(file.suites), []);
     interpretOnlyMode(allSuites);
     allSuites.forEach((i) => {
         if (i.mode === 'skip')
@@ -125,40 +126,111 @@ export async function runFile(file, ctx) {
     }
     await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
 }
+export async function runFiles(filesMap, ctx) {
+    var _a;
+    const { reporter } = ctx;
+    await ((_a = reporter.onCollected) === null || _a === void 0 ? void 0 : _a.call(reporter, Object.values(filesMap), ctx));
+    for (const file of Object.values(filesMap))
+        await runFile(file, ctx);
+}
 export async function run(config) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
+    // if watch, tell `vite-node` not to end the process
+    if (config.watch)
+        process.__vite_node__.watch = true;
     // setup chai
     await setupChai(config);
     // collect files
-    let paths = await fg(config.includes || defaultIncludes, {
+    let testFilepaths = await fg(config.includes || defaultIncludes, {
         absolute: true,
         cwd: config.rootDir,
         ignore: config.excludes || defaultExcludes,
     });
+    // if name filters are provided by the CLI
     if ((_a = config.nameFilters) === null || _a === void 0 ? void 0 : _a.length)
-        paths = paths.filter(i => config.nameFilters.some(f => i.includes(f)));
-    if (!paths.length) {
+        testFilepaths = testFilepaths.filter(i => config.nameFilters.some(f => i.includes(f)));
+    if (!testFilepaths.length) {
         console.error('No test files found');
         process.exitCode = 1;
         return;
     }
-    const reporter = new DefaultReporter();
-    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
+    // setup envs
     if (config.global)
-        (await import('./global')).registerApiGlobally();
+        (await import('../global')).registerApiGlobally();
     if (config.jsdom)
-        (await import('./integrations/jsdom')).setupJSDOM(globalThis);
-    const files = await collectFiles(paths);
+        (await import('../integrations/jsdom')).setupJSDOM(globalThis);
+    const reporter = new DefaultReporter();
+    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
+    const filesMap = await collectFiles(testFilepaths);
     const ctx = {
-        files,
+        filesMap,
+        get files() {
+            return Object.values(this.filesMap);
+        },
+        get suites() {
+            return Object.values(this.filesMap)
+                .reduce((suites, file) => suites.concat(file.suites), []);
+        },
+        get tasks() {
+            return this.suites
+                .reduce((tasks, suite) => tasks.concat(suite.tasks), []);
+        },
         config,
         reporter,
     };
-    await ((_c = reporter.onCollected) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
-    for (const file of files)
-        await runFile(file, ctx);
+    await runFiles(filesMap, ctx);
     const snapshot = getSnapshotManager();
     snapshot === null || snapshot === void 0 ? void 0 : snapshot.saveSnap();
     snapshot === null || snapshot === void 0 ? void 0 : snapshot.report();
-    await ((_d = reporter.onFinished) === null || _d === void 0 ? void 0 : _d.call(reporter, ctx));
+    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
+    if (config.watch)
+        startWatcher(ctx);
+}
+export async function startWatcher(ctx) {
+    var _a, _b;
+    await ((_b = (_a = ctx.reporter).onWatcherStart) === null || _b === void 0 ? void 0 : _b.call(_a, ctx));
+    let timer;
+    const changedTests = new Set();
+    const seen = new Set();
+    const { server, moduleCache } = process.__vite_node__;
+    server.watcher.on('change', async (id) => {
+        getDependencyTests(id, ctx, changedTests, seen);
+        seen.forEach(i => moduleCache.delete(i));
+        seen.clear();
+        if (changedTests.size === 0)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(async () => {
+            var _a, _b, _c, _d;
+            const snapshot = getSnapshotManager();
+            const pathes = Array.from(changedTests);
+            changedTests.clear();
+            await ((_b = (_a = ctx.reporter).onWatcherRerun) === null || _b === void 0 ? void 0 : _b.call(_a, pathes, id, ctx));
+            pathes.forEach(i => moduleCache.delete(i));
+            const files = await collectFiles(pathes);
+            Object.assign(ctx.filesMap, files);
+            await runFiles(files, ctx);
+            // TODO: clear snapshot state
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.saveSnap();
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.report();
+            await ((_d = (_c = ctx.reporter).onWatcherStart) === null || _d === void 0 ? void 0 : _d.call(_c, ctx));
+        }, 100);
+    });
+}
+function getDependencyTests(id, ctx, set = new Set(), seen = new Set()) {
+    if (seen.has(id) || set.has(id))
+        return set;
+    seen.add(id);
+    if (id in ctx.filesMap) {
+        set.add(id);
+        return set;
+    }
+    const mod = process.__vite_node__.server.moduleGraph.getModuleById(id);
+    if (mod) {
+        mod.importers.forEach((i) => {
+            if (i.id)
+                getDependencyTests(i.id, ctx, set, seen);
+        });
+    }
+    return set;
 }

package/dist/types.d.ts

@@ -78,7 +78,10 @@ export interface File {
     error?: unknown;
 }
 export interface RunnerContext {
+    filesMap: Record<string, File>;
     files: File[];
+    suites: Suite[];
+    tasks: Task[];
     config: Config;
     reporter: Reporter;
 }
@@ -88,7 +91,7 @@ export interface GlobalContext {
 }
 export interface Reporter {
     onStart?: (userOptions: Config) => Awaitable<void>;
-    onCollected?: (ctx: RunnerContext) => Awaitable<void>;
+    onCollected?: (files: File[], ctx: RunnerContext) => Awaitable<void>;
     onFinished?: (ctx: RunnerContext) => Awaitable<void>;
     onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onSuiteEnd?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
@@ -96,5 +99,7 @@ export interface Reporter {
     onFileEnd?: (file: File, ctx: RunnerContext) => Awaitable<void>;
     onTaskBegin?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
     onTaskEnd?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
+    onWatcherStart?: (ctx: RunnerContext) => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string, ctx: RunnerContext) => Awaitable<void>;
     onSnapshotUpdate?: () => Awaitable<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "",
   "keywords": [],
   "homepage": "https://github.com/antfu/vitest#readme",

package/dist/node.d.ts

@@ -1,11 +0,0 @@
-import { InlineConfig } from 'vite';
-export interface ViteNodeOptions {
-    silent?: boolean;
-    root: string;
-    files: string[];
-    _?: string[];
-    shouldExternalize?: (file: string) => boolean;
-    config?: string;
-    defaultConfig?: InlineConfig;
-}
-export declare function run(argv: ViteNodeOptions): Promise<void>;

package/dist/run.d.ts

@@ -1,6 +0,0 @@
-import { File, Config, Task, RunnerContext, Suite } from './types';
-export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
-export declare function collectFiles(paths: string[]): Promise<File[]>;
-export declare function runSite(suite: Suite, ctx: RunnerContext): Promise<void>;
-export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
-export declare function run(config: Config): Promise<void>;