vitest 0.0.27 → 0.0.31

package/README.gh.md

@@ -9,6 +9,8 @@ A blazing fast unit test framework powered by Vite.
 
 > ⚠️ **DISCLAIMER**: Vitest is still in development and not stable yet. It's not recommended to use it in production.
 
+> Vitest requires Vite v2.7.0 or above
+
 ## Features
 
 - [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins.
@@ -44,6 +46,12 @@ describe('suite name', () => {
 $ npx vitest
 ```
 
+## Examples
+
+- [Unit Testing](./test/core)
+- [Vue Component Testing](./test/vue)
+- [React Component Testing](./test/react)
+
 ## Configuration
 
 `vitest` will read your root `vite.config.ts` when it present to match with the plugins and setup as your Vite app. If you want to it to have a different configuration for testing, you could either:
@@ -114,10 +122,25 @@ export default defineConfig({
 $ vitest -w
 ```
 
-Vitest will smartly search for the module graph to only rerun the related tests.
+Vitest smartly searches the module graph and only rerun the related tests (just like how HMR works in Vite!).
 
 ## Filtering
 
+### CLI
+
+You can use CLI to filter test files my name:
+
+```bash
+$ vitest basic
+```
+
+Will only execute test files that contain `basic`, e.g.
+
+```
+basic.test.ts
+basic-foo.test.ts
+```
+
 ### Skipping suites and tasks
 
 Use `.skip` to avoid running certain suites or tests 

package/dist/index.d.ts

@@ -19,6 +19,8 @@ declare global {
             toEqual(expected: any): void;
             toStrictEqual(expected: any): void;
             toBe(expected: any): void;
+            toMatch(expected: string | RegExp): void;
+            toMatchObject(expected: any): void;
             toContain(item: any): void;
             toBeTruthy(): void;
             toBeFalsy(): void;
@@ -27,10 +29,10 @@ declare global {
             toBeNull(): void;
             toBeDefined(): void;
             toBeInstanceOf(c: any): void;
-            toBeCalledTimes(n: number): void;
-            toBeCalledOnce(): void;
-            toBeCalled(): void;
+            toHaveBeenCalledTimes(n: number): void;
+            toHaveBeenCalledOnce(): void;
             toHaveBeenCalled(): void;
+            toHaveBeenCalledWith(...args: any[]): void;
         }
         interface ExpectStatic {
             addSnapshotSerializer: import('pretty-format').Plugin;

package/dist/integrations/chai/jest-expect.js

@@ -12,6 +12,15 @@ export function JestChaiExpect() {
         utils.addMethod(proto, 'toBe', function (expected) {
             return this.equal(expected);
         });
+        utils.addMethod(proto, 'toMatchObject', function (expected) {
+            return this.containSubset(expected);
+        });
+        utils.addMethod(proto, 'toMatch', function (expected) {
+            if (typeof expected === 'string')
+                return this.include(expected);
+            else
+                return this.match(expected);
+        });
         utils.addMethod(proto, 'toContain', function (item) {
             return this.contain(item);
         });
@@ -39,17 +48,20 @@ export function JestChaiExpect() {
             return this.instanceOf(obj);
         });
         // mock
-        utils.addMethod(proto, 'toBeCalledTimes', function (number) {
+        utils.addMethod(proto, 'toHaveBeenCalledTimes', function (number) {
             return this.callCount(number);
         });
-        utils.addMethod(proto, 'toBeCalledOnce', function () {
+        utils.addMethod(proto, 'toHaveBeenCalledOnce', function () {
             return this.callCount(1);
         });
-        utils.addMethod(proto, 'toBeCalled', function () {
+        utils.addMethod(proto, 'toHaveBeenCalled', function () {
             return this.called;
         });
         utils.addMethod(proto, 'toHaveBeenCalled', function () {
             return this.called;
         });
+        utils.addMethod(proto, 'toHaveBeenCalledWith', function (...args) {
+            return this.calledWith(...args);
+        });
     };
 }

package/dist/integrations/chai/setup.js

@@ -1,9 +1,11 @@
 import chai from 'chai';
 import SinonChai from 'sinon-chai';
+import Subset from 'chai-subset';
 import { JestChaiExpect } from './jest-expect';
 import { SnapshotPlugin } from './snapshot';
 export async function setupChai(config) {
     chai.use(SinonChai);
     chai.use(JestChaiExpect());
+    chai.use(Subset);
     chai.use(await SnapshotPlugin(config));
 }

package/dist/integrations/chai/snapshot/manager.d.ts

@@ -24,6 +24,7 @@ export declare class SnapshotManager {
     setTask(task: Task): void;
     setContext(context: Context): void;
     assert(received: unknown, message: string): void;
+    clear(): void;
     saveSnap(): void;
-    report(): void;
+    report(): string[] | undefined;
 }

package/dist/integrations/chai/snapshot/manager.js

@@ -58,6 +58,9 @@ export class SnapshotManager {
             expect(actual.trim()).equals(expected ? expected.trim() : '', message || `Snapshot name: \`${key}\``);
         }
     }
+    clear() {
+        this.snapshotSummary = makeEmptySnapshotSummary(this.snapshotOptions);
+    }
     saveSnap() {
         if (!this.testFile || !this.snapshotState)
             return;
@@ -69,7 +72,6 @@ export class SnapshotManager {
     report() {
         const outputs = getSnapshotSummaryOutput(this.rootDir, this.snapshotSummary);
         if (outputs.length > 1)
-            // eslint-disable-next-line no-console
-            console.log(`\n${outputs.join('\n')}`);
+            return outputs;
     }
 }

package/dist/node/cli.js

@@ -19,13 +19,19 @@ sade('vitest [filter]', true)
     .option('--global', 'inject apis globally', false)
     .option('--dev', 'dev mode', false)
     .option('--jsdom', 'mock browser api using JSDOM', false)
-    .action(async (filters, options) => {
+    .action(async (filters, argv) => {
     process.env.VITEST = 'true';
+    const defaultInline = [
+        'vue',
+        '@vue',
+        'diff',
+    ];
     const __dirname = dirname(fileURLToPath(import.meta.url));
-    const root = resolve(options.root || process.cwd());
-    const configPath = options.config
-        ? resolve(root, options.config)
+    const root = resolve(argv.root || process.cwd());
+    const configPath = argv.config
+        ? resolve(root, argv.config)
         : await findUp(['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs', 'vite.config.ts', 'vite.config.js', 'vite.config.mjs'], { cwd: root });
+    const options = argv;
     options.config = configPath;
     options.root = root;
     options.filters = filters
@@ -39,7 +45,7 @@ sade('vitest [filter]', true)
     await startViteNode({
         root,
         files: [
-            resolve(__dirname, options.dev ? '../../src/node/entry.ts' : './entry.js'),
+            resolve(__dirname, argv.dev ? '../../src/node/entry.ts' : './entry.js'),
         ],
         config: configPath,
         defaultConfig: {
@@ -49,11 +55,31 @@ sade('vitest [filter]', true)
                 ],
             },
         },
-        shouldExternalize(id) {
-            if (id.includes('/node_modules/vitest/'))
-                return false;
-            else
-                return id.includes('/node_modules/');
+        shouldExternalize(id, server) {
+            var _a, _b, _c, _d;
+            const inline = ['vitest', ...defaultInline, ...((_b = (_a = server.config.test) === null || _a === void 0 ? void 0 : _a.deps) === null || _b === void 0 ? void 0 : _b.inline) || []];
+            const external = ((_d = (_c = server.config.test) === null || _c === void 0 ? void 0 : _c.deps) === null || _d === void 0 ? void 0 : _d.external) || [];
+            for (const ex of inline) {
+                if (typeof ex === 'string') {
+                    if (id.includes(`/node_modules/${ex}/`))
+                        return false;
+                }
+                else {
+                    if (ex.test(id))
+                        return false;
+                }
+            }
+            for (const ex of external) {
+                if (typeof ex === 'string') {
+                    if (id.includes(`/node_modules/${ex}/`))
+                        return true;
+                }
+                else {
+                    if (ex.test(id))
+                        return true;
+                }
+            }
+            return id.includes('/node_modules/');
         },
     });
 })

package/dist/node/entry.js

@@ -3,4 +3,10 @@ if (!process.__vite_node__ || !process.__vitest__)
     throw new Error('Vitest can only run in vite-node environment, please use the CLI to start the process');
 const inlineOptions = process.__vite_node__.server.config.test || {};
 const cliOptions = process.__vitest__.options || {};
-await run(Object.assign(Object.assign({}, cliOptions), inlineOptions));
+const options = Object.assign(Object.assign({}, cliOptions), inlineOptions);
+await run(options);
+const timer = setTimeout(() => {
+    // TODO: warn user and maybe error out
+    process.exit();
+}, 500);
+timer.unref();

package/dist/node/node.d.ts

@@ -1,4 +1,4 @@
-import { InlineConfig, ViteDevServer } from 'vite';
+import { InlineConfig, ViteDevServer, TransformResult } from 'vite';
 declare global {
     namespace NodeJS {
         interface Process {
@@ -6,6 +6,7 @@ declare global {
                 server: ViteDevServer;
                 watch?: boolean;
                 moduleCache: Map<string, Promise<any>>;
+                modulesTransformResult: Map<string, TransformResult>;
             };
         }
     }
@@ -15,7 +16,7 @@ export interface ViteNodeOptions {
     root: string;
     files: string[];
     _?: string[];
-    shouldExternalize?: (file: string) => boolean;
+    shouldExternalize?: (file: string, server: ViteDevServer) => boolean;
     config?: string;
     defaultConfig?: InlineConfig;
 }

package/dist/node/node.js

@@ -5,7 +5,8 @@ import vm from 'vm';
 import { createServer, mergeConfig } from 'vite';
 import c from 'picocolors';
 const { red, dim, yellow } = c;
-const __pendingModules__ = new Map();
+const moduleCache = new Map();
+const modulesTransformResult = new Map();
 export async function run(argv) {
     process.exitCode = 0;
     const root = argv.root || process.cwd();
@@ -22,7 +23,8 @@ export async function run(argv) {
     await server.pluginContainer.buildStart({});
     process.__vite_node__ = {
         server,
-        moduleCache: __pendingModules__,
+        moduleCache,
+        modulesTransformResult,
     };
     try {
         await execute(files, server, argv);
@@ -42,6 +44,8 @@ function normalizeId(id) {
         id = `\0${id.slice('/@id/__x00__'.length)}`;
     if (id && id.startsWith('/@id/'))
         id = id.slice('/@id/'.length);
+    if (id.startsWith('__vite-browser-external:'))
+        id = id.slice('__vite-browser-external:'.length);
     return id;
 }
 function toFilePath(id, server) {
@@ -58,6 +62,29 @@ function toFilePath(id, server) {
         absolute = `/${absolute}`;
     return absolute;
 }
+const stubRequests = {
+    '/@vite/client': {
+        injectQuery: (id) => id,
+        createHotContext() {
+            return {
+                accept: () => { },
+            };
+        },
+    },
+};
+async function transform(server, id) {
+    if (id.match(/\.(?:[cm]?[jt]sx?|json)$/)) {
+        return await server.transformRequest(id, { ssr: true });
+    }
+    else {
+        // for components like Vue, we want to use the client side
+        // plugins but then covert the code to be consumed by the server
+        const result = await server.transformRequest(id);
+        if (!result)
+            return undefined;
+        return await server.ssrTransform(result.code, result.map, id);
+    }
+}
 async function execute(files, server, options) {
     const result = [];
     for (const file of files)
@@ -74,9 +101,12 @@ async function execute(files, server, options) {
             }
             return cachedRequest(dep, callstack);
         };
-        const result = await server.transformRequest(id, { ssr: true });
+        if (id in stubRequests)
+            return stubRequests[id];
+        const result = await transform(server, id);
         if (!result)
             throw new Error(`failed to load ${id}`);
+        modulesTransformResult.set(id, result);
         const url = pathToFileURL(fsPath);
         const exports = {};
         const context = {
@@ -97,16 +127,16 @@ async function execute(files, server, options) {
         return exports;
     }
     async function cachedRequest(rawId, callstack) {
-        if (builtinModules.includes(rawId))
-            return import(rawId);
         const id = normalizeId(rawId);
+        if (builtinModules.includes(id))
+            return import(id);
         const fsPath = toFilePath(id, server);
-        if (options.shouldExternalize(fsPath))
+        if (options.shouldExternalize(fsPath, server))
             return import(fsPath);
-        if (__pendingModules__.has(fsPath))
-            return __pendingModules__.get(fsPath);
-        __pendingModules__.set(fsPath, directRequest(id, fsPath, callstack));
-        return await __pendingModules__.get(fsPath);
+        if (moduleCache.has(fsPath))
+            return moduleCache.get(fsPath);
+        moduleCache.set(fsPath, directRequest(id, fsPath, callstack));
+        return await moduleCache.get(fsPath);
     }
     function exportAll(exports, sourceModule) {
         // eslint-disable-next-line no-restricted-syntax

package/dist/reporters/default.d.ts

@@ -1,5 +1,5 @@
 import Listr from 'listr';
-import { File, Reporter, RunnerContext, Task } from '../types';
+import { File, Reporter, RunnerContext, Task, ResolvedConfig } from '../types';
 interface TaskPromise {
     promise: Promise<void>;
     resolve: () => void;
@@ -11,9 +11,12 @@ export declare class DefaultReporter implements Reporter {
     listr: Listr | null;
     listrPromise: Promise<void> | null;
     taskMap: Map<Task, TaskPromise>;
+    cwd: string;
+    relative(path: string): string;
+    onStart(config: ResolvedConfig): void;
     onCollected(files: File[]): void;
     onTaskEnd(task: Task): void;
-    onFinished(ctx: RunnerContext): Promise<void>;
+    onFinished(ctx: RunnerContext, files?: File[]): Promise<void>;
     onWatcherStart(ctx: RunnerContext): Promise<void>;
     onWatcherRerun(files: string[], trigger: string): Promise<void>;
     onSnapshotUpdate(): void;

package/dist/reporters/default.js

@@ -3,6 +3,7 @@ import { performance } from 'perf_hooks';
 import { relative } from 'path';
 import c from 'picocolors';
 import Listr from 'listr';
+import { printError } from './error';
 const CROSS = '✖ ';
 export class DefaultReporter {
     constructor() {
@@ -11,6 +12,14 @@ export class DefaultReporter {
         this.listr = null;
         this.listrPromise = null;
         this.taskMap = new Map();
+        this.cwd = process.cwd();
+    }
+    relative(path) {
+        return relative(this.cwd, path);
+    }
+    onStart(config) {
+        this.cwd = config.root;
+        console.log(c.green(`Running tests under ${c.gray(this.cwd)}\n`));
     }
     onCollected(files) {
         this.start = performance.now();
@@ -41,9 +50,14 @@ export class DefaultReporter {
         };
         this.listr = new Listr(files.map((file) => {
             return {
-                title: relative(process.cwd(), file.filepath),
+                title: this.relative(file.filepath),
                 task: () => {
-                    return new Listr(file.suites.flatMap((suite) => {
+                    if (file.error)
+                        throw file.error;
+                    const suites = file.suites.filter(i => i.tasks.length);
+                    if (!suites.length)
+                        throw new Error('No tasks found');
+                    return new Listr(suites.flatMap((suite) => {
                         if (!suite.name)
                             return createTasksListr(suite.tasks);
                         return [{
@@ -64,11 +78,16 @@ export class DefaultReporter {
         else
             (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
     }
-    async onFinished(ctx) {
+    async onFinished(ctx, files = ctx.files) {
+        var _a;
         await this.listrPromise;
         this.end = performance.now();
         console.log();
-        const { tasks, suites, files } = ctx;
+        const snapshot = ctx.snapshotManager.report();
+        if (snapshot)
+            console.log(snapshot.join('\n'));
+        const suites = files.flatMap(i => i.suites);
+        const tasks = suites.flatMap(i => i.tasks);
         const failedFiles = files.filter(i => i.error);
         const failedSuites = suites.filter(i => i.error);
         const runnable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
@@ -77,30 +96,30 @@ export class DefaultReporter {
         const skipped = tasks.filter(i => i.state === 'skip');
         const todo = tasks.filter(i => i.state === 'todo');
         if (failedFiles.length) {
-            console.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
-            failedFiles.forEach((i) => {
-                console.error(c.red(`\n- ${i.filepath}`));
-                console.error(i.error || 'Unknown error');
+            console.error(c.red(c.bold(`\nFailed to parse ${failedFiles.length} files:`)));
+            for (const file of failedFiles)
+                console.error(c.red(`- ${file.filepath}`));
+            console.log();
+            for (const file of failedFiles) {
+                await printError(file.error);
                 console.log();
-            });
+            }
         }
         if (failedSuites.length) {
             console.error(c.bold(c.red(`\nFailed to run ${failedSuites.length} suites:`)));
-            failedSuites.forEach((i) => {
-                var _a;
-                console.error(c.red(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`));
-                console.error(i.error || 'Unknown error');
+            for (const suite of failedSuites) {
+                console.error(c.red(`\n- ${(_a = suite.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${suite.name}`));
+                await printError(suite.error);
                 console.log();
-            });
+            }
         }
         if (failed.length) {
             console.error(c.bold(c.red(`\nFailed Tests (${failed.length})`)));
-            failed.forEach((task) => {
-                var _a;
-                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');
+            for (const task of failed) {
+                console.error(`${c.red(`\n${CROSS + c.inverse(' FAIL ')}`)} ${[task.suite.name, task.name].filter(Boolean).join(' > ')}`);
+                await printError(task.error);
                 console.log();
-            });
+            }
         }
         console.log(c.bold(c.green(`Passed   ${passed.length} / ${runnable.length}`)));
         if (failed.length)
@@ -122,7 +141,7 @@ export class DefaultReporter {
     async onWatcherRerun(files, trigger) {
         await this.listrPromise;
         console.clear();
-        console.log(c.blue('Re-running tests...') + c.dim(` [ ${relative(process.cwd(), trigger)} ]\n`));
+        console.log(c.blue('Re-running tests...') + c.dim(` [ ${this.relative(trigger)} ]\n`));
     }
     // TODO:
     onSnapshotUpdate() {

package/dist/reporters/error.d.ts

@@ -0,0 +1,9 @@
+export declare function printError(error: unknown): Promise<void>;
+interface Poisition {
+    line: number;
+    column: number;
+}
+export declare function posToNumber(source: string, pos: number | Poisition): number;
+export declare function numberToPos(source: string, offset: number | Poisition): Poisition;
+export declare function generateCodeFrame(source: string, start?: number | Poisition, end?: number, range?: number): string;
+export {};

package/dist/reporters/error.js

@@ -0,0 +1,182 @@
+/* eslint-disable no-console */
+import { promises as fs, existsSync } from 'fs';
+import c from 'picocolors';
+import * as diff from 'diff';
+import { notNullish } from '@antfu/utils';
+import { SourceMapConsumer } from 'source-map';
+export async function printError(error) {
+    if (!(error instanceof Error)) {
+        console.error(error);
+        return;
+    }
+    const { modulesTransformResult } = process.__vite_node__;
+    const e = error;
+    let codeFramePrinted = false;
+    const stacks = parseStack(e.stack || '');
+    const nearest = stacks.find(stack => modulesTransformResult.has(stack.file));
+    if (nearest) {
+        const transformResult = modulesTransformResult.get(nearest.file);
+        const pos = await getOriginalPos(transformResult === null || transformResult === void 0 ? void 0 : transformResult.map, nearest);
+        if (pos && existsSync(nearest.file)) {
+            const sourceCode = await fs.readFile(nearest.file, 'utf-8');
+            console.error(`${c.red(`${c.bold(e.name)}: ${e.message}`)}`);
+            console.log(c.gray(`${nearest.file}:${pos.line}:${pos.column}`));
+            console.log(c.yellow(generateCodeFrame(sourceCode, pos)));
+            codeFramePrinted = true;
+        }
+    }
+    if (!codeFramePrinted)
+        console.error(e);
+    if (e.showDiff)
+        console.error(c.gray(generateDiff(stringify(e.actual), stringify(e.expected))));
+}
+function getOriginalPos(map, { line, column }) {
+    return new Promise((resolve) => {
+        if (!map)
+            return resolve(null);
+        SourceMapConsumer.with(map, null, (consumer) => {
+            const pos = consumer.originalPositionFor({ line, column });
+            if (pos.line != null && pos.column != null)
+                resolve(pos);
+            else
+                resolve(null);
+        });
+    });
+}
+const splitRE = /\r?\n/;
+export function posToNumber(source, pos) {
+    if (typeof pos === 'number')
+        return pos;
+    const lines = source.split(splitRE);
+    const { line, column } = pos;
+    let start = 0;
+    for (let i = 0; i < line - 1; i++)
+        start += lines[i].length + 1;
+    return start + column;
+}
+export function numberToPos(source, offset) {
+    if (typeof offset !== 'number')
+        return offset;
+    if (offset > source.length) {
+        throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+    }
+    const lines = source.split(splitRE);
+    let counted = 0;
+    let line = 0;
+    let column = 0;
+    for (; line < lines.length; line++) {
+        const lineLength = lines[line].length + 1;
+        if (counted + lineLength >= offset) {
+            column = offset - counted + 1;
+            break;
+        }
+        counted += lineLength;
+    }
+    return { line: line + 1, column };
+}
+export function generateCodeFrame(source, start = 0, end, range = 2) {
+    start = posToNumber(source, start);
+    end = end || start;
+    const lines = source.split(splitRE);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${c.gray(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}|`)}  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`${c.gray('   |')}  ${' '.repeat(pad)}${'^'.repeat(length)}`);
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`${c.gray('   |')}  ${'^'.repeat(length)}`);
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function stringify(obj) {
+    // TODO: handle more types
+    return String(obj);
+}
+const stackFnCallRE = /at (.*) \((.+):(\d+):(\d+)\)$/;
+const stackBarePathRE = /at ()(.+):(\d+):(\d+)$/;
+function parseStack(stack) {
+    const lines = stack.split('\n');
+    const stackFrames = lines.map((raw) => {
+        const line = raw.trim();
+        const match = line.match(stackFnCallRE) || line.match(stackBarePathRE);
+        if (!match)
+            return null;
+        let file = match[2];
+        if (file.startsWith('file://'))
+            file = file.slice(7);
+        return {
+            method: match[1],
+            file: match[2],
+            line: parseInt(match[3]),
+            column: parseInt(match[4]),
+        };
+    });
+    return stackFrames.filter(notNullish);
+}
+/**
+ * Returns a diff between 2 strings with coloured ANSI output.
+ *
+ * @description
+ * The diff will be either inline or unified dependent on the value
+ * of `Base.inlineDiff`.
+ *
+ * @param {string} actual
+ * @param {string} expected
+ * @return {string} Diff
+ */
+function generateDiff(actual, expected) {
+    const diffSize = 2048;
+    if (actual.length > diffSize)
+        actual = `${actual.substring(0, diffSize)} ... Lines skipped`;
+    if (expected.length > diffSize)
+        expected = `${expected.substring(0, diffSize)} ... Lines skipped`;
+    return unifiedDiff(actual, expected);
+}
+/**
+ * Returns unified diff between two strings with coloured ANSI output.
+ *
+ * @private
+ * @param {String} actual
+ * @param {String} expected
+ * @return {string} The diff.
+ */
+function unifiedDiff(actual, expected) {
+    const indent = '  ';
+    function cleanUp(line) {
+        if (line[0] === '+')
+            return indent + c.green(`${line[0]} ${line.slice(1)}`);
+        if (line[0] === '-')
+            return indent + c.red(`${line[0]} ${line.slice(1)}`);
+        if (line.match(/@@/))
+            return '--';
+        if (line.match(/\\ No newline/))
+            return null;
+        return indent + line;
+    }
+    const msg = diff.createPatch('string', actual, expected);
+    const lines = msg.split('\n').splice(5);
+    return (`\n${indent}${c.red('- actual')}\n${indent}${c.green('+ expected')}\n\n${lines.map(cleanUp).filter(notBlank).join('\n')}`);
+}
+function notBlank(line) {
+    return typeof line !== 'undefined' && line !== null;
+}

package/dist/run/index.js

@@ -163,6 +163,7 @@ export async function run(config) {
         (await import('../integrations/jsdom')).setupJSDOM(globalThis);
     await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
     const filesMap = await collectFiles(testFilepaths);
+    const snapshotManager = getSnapshotManager();
     const ctx = {
         filesMap,
         get files() {
@@ -177,24 +178,25 @@ export async function run(config) {
                 .reduce((tasks, suite) => tasks.concat(suite.tasks), []);
         },
         config,
-        reporter: config.reporter,
+        reporter,
+        snapshotManager,
     };
     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();
+    snapshotManager.saveSnap();
     await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
     if (config.watch)
-        startWatcher(ctx);
+        await 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));
+    var _a;
+    const { reporter, snapshotManager, filesMap } = ctx;
+    await ((_a = reporter.onWatcherStart) === null || _a === void 0 ? void 0 : _a.call(reporter, ctx));
     let timer;
     const changedTests = new Set();
     const seen = new Set();
     const { server, moduleCache } = process.__vite_node__;
     server.watcher.on('change', async (id) => {
+        id = normalizePath(id);
         getDependencyTests(id, ctx, changedTests, seen);
         seen.forEach(i => moduleCache.delete(i));
         seen.clear();
@@ -202,23 +204,30 @@ export async function startWatcher(ctx) {
             return;
         clearTimeout(timer);
         timer = setTimeout(async () => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             if (changedTests.size === 0)
                 return;
-            const snapshot = getSnapshotManager();
+            snapshotManager.clear();
             const paths = Array.from(changedTests);
             changedTests.clear();
-            await ((_b = (_a = ctx.reporter).onWatcherRerun) === null || _b === void 0 ? void 0 : _b.call(_a, paths, id, ctx));
+            await ((_a = reporter.onWatcherRerun) === null || _a === void 0 ? void 0 : _a.call(reporter, paths, id, ctx));
             paths.forEach(i => moduleCache.delete(i));
-            const files = await collectFiles(paths);
-            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));
+            const newFilesMap = await collectFiles(paths);
+            Object.assign(filesMap, newFilesMap);
+            await runFiles(newFilesMap, ctx);
+            snapshotManager.saveSnap();
+            await ((_b = reporter.onFinished) === null || _b === void 0 ? void 0 : _b.call(reporter, ctx, Object.values(newFilesMap)));
+            await ((_c = reporter.onWatcherStart) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
         }, 100);
     });
+    // add an empty promise so it never resolves
+    await new Promise(() => { });
+}
+function normalizePath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    if (normalized.startsWith('/'))
+        return normalized;
+    return `/${normalized}`;
 }
 function getDependencyTests(id, ctx, set = new Set(), seen = new Set()) {
     if (seen.has(id) || set.has(id))

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { SnapshotManager } from './integrations/chai/snapshot/manager';
 export declare type Awaitable<T> = Promise<T> | T;
 export interface UserOptions {
     /**
@@ -11,6 +12,13 @@ export interface UserOptions {
      * @default ['**\/node_modules\/**']
      */
     excludes?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     */
+    deps?: {
+        external?: (string | RegExp)[];
+        inline?: (string | RegExp)[];
+    };
     /**
      * Register apis globally
      *
@@ -52,6 +60,7 @@ export interface UserOptions {
 }
 export interface ResolvedConfig extends Required<UserOptions> {
     filters?: string[];
+    config?: string;
 }
 export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 export declare type TaskState = RunMode | 'pass' | 'fail';
@@ -108,15 +117,16 @@ export interface RunnerContext {
     tasks: Task[];
     config: ResolvedConfig;
     reporter: Reporter;
+    snapshotManager: SnapshotManager;
 }
 export interface GlobalContext {
     suites: SuiteCollector[];
     currentSuite: SuiteCollector | null;
 }
 export interface Reporter {
-    onStart?: (userOptions: ResolvedConfig) => Awaitable<void>;
+    onStart?: (config: ResolvedConfig) => Awaitable<void>;
     onCollected?: (files: File[], ctx: RunnerContext) => Awaitable<void>;
-    onFinished?: (ctx: RunnerContext) => Awaitable<void>;
+    onFinished?: (ctx: RunnerContext, files?: File[]) => Awaitable<void>;
     onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onSuiteEnd?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onFileBegin?: (file: File, ctx: RunnerContext) => Awaitable<void>;
@@ -125,5 +135,4 @@ export interface Reporter {
     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.27",
+  "version": "0.0.31",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -44,15 +44,20 @@
     "lint": "eslint \"{src,test}/**/*.ts\"",
     "prepublishOnly": "nr build",
     "release": "bumpp --commit --push --tag && esmo scripts/publish.ts",
-    "test": "node bin/vitest.mjs --dev",
-    "test:update": "nr test -u",
+    "test": "run-s test:*",
+    "test:core": "node bin/vitest.mjs --dev -r test/core",
+    "test:vue": "node bin/vitest.mjs --dev -r test/vue",
+    "test:react": "node bin/vitest.mjs --dev -r test/react",
     "watch": "tsc -p src/tsconfig.json --watch"
   },
   "dependencies": {
+    "@antfu/utils": "^0.3.0",
     "@jest/test-result": "^27.4.2",
     "@types/chai": "^4.2.22",
     "@types/sinon-chai": "^3.2.6",
     "chai": "^4.3.4",
+    "chai-subset": "^1.6.0",
+    "diff": "^5.0.0",
     "fast-glob": "^3.2.7",
     "find-up": "^6.2.0",
     "jest-snapshot": "^27.4.2",
@@ -62,21 +67,28 @@
     "picocolors": "^1.0.0",
     "sade": "^1.7.4",
     "sinon": "^12.0.1",
-    "sinon-chai": "^3.7.0"
+    "sinon-chai": "^3.7.0",
+    "source-map": "^0.7.3"
+  },
+  "peerDependencies": {
+    "vite": "^2.7.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.12.1",
+    "@antfu/eslint-config": "^0.12.2",
     "@antfu/ni": "^0.11.0",
+    "@types/chai-subset": "^1.3.3",
+    "@types/diff": "^5.0.1",
     "@types/jsdom": "^16.2.13",
     "@types/listr": "^0.14.4",
-    "@types/node": "^16.11.11",
+    "@types/node": "^16.11.12",
     "@types/sade": "^1.7.3",
     "@types/sinon": "^10.0.6",
     "bumpp": "^7.1.1",
-    "eslint": "^8.4.0",
+    "eslint": "^8.4.1",
     "esno": "^0.12.1",
+    "npm-run-all": "^4.1.5",
     "rimraf": "^3.0.2",
     "typescript": "^4.5.2",
-    "vite": "^2.6.14"
+    "vite": "^2.7.0"
   }
 }