vitest 0.0.13 → 0.0.17

package/README.md

@@ -6,10 +6,11 @@ A blazing fast test runner powered by Vite.
 
 ## Features
 
-- [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins. Powered by [vite-node](https://github.com/antfu/vite-node)
+- [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins.
 - [Jest Snapshot](https://jestjs.io/docs/snapshot-testing)
 - [Chai](https://www.chaijs.com/) for assertions
 - [Sinon](https://sinonjs.org/) for mocking
+- [JSDOM](https://github.com/jsdom/jsdom) for DOM mocking
 - Async suite / test, top level await
 - ESM friendly
 - Out-of-box TypeScript support
@@ -20,11 +21,12 @@ import { it, describe, expect, assert } from 'vitest'
 
 describe('suite name', () => {
   it('foo', () => {
-    assert.equal(Math.sqrt(4), 2)
+    expect(1 + 1).toEqual(2)
+    expect(true).to.be.true
   })
 
   it('bar', () => {
-    expect(1 + 1).eq(2)
+    assert.equal(Math.sqrt(4), 2)
   })
 
   it('snapshot', () => {

package/bin/vitest.mjs

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 'use strict'
 
-import '../dist/cli.js'
+import '../dist/entry.js'

package/dist/cli.js

@@ -1,36 +1,29 @@
-import { fileURLToPath } from 'url';
-import { resolve, dirname } from 'path';
+var _a;
 import minimist from 'minimist';
-import { findUp } from 'find-up';
-import { run } from './node.js';
-process.env.VITEST = 'true';
+import c from 'picocolors';
+import { run } from './run';
+const { log } = console;
 const argv = minimist(process.argv.slice(2), {
     alias: {
-        c: 'config',
+        u: 'update',
+        w: 'watch',
     },
     string: ['root', 'config'],
-    boolean: ['dev'],
-});
-const __dirname = dirname(fileURLToPath(import.meta.url));
-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 });
-await run({
-    root,
-    files: [
-        resolve(__dirname, argv.dev ? '../src/cli-entry.ts' : './cli-entry.js'),
-    ],
-    config: configPath,
-    defaultConfig: {
-        optimizeDeps: {
-            exclude: [
-                'vitest',
-            ],
-        },
-    },
-    shouldExternalize(id) {
-        if (id.includes('/node_modules/vitest/'))
-            return false;
-        else
-            return id.includes('/node_modules/');
+    boolean: ['update', 'dev', 'global', 'watch', 'jsdom'],
+    unknown(name) {
+        if (name[0] === '-') {
+            console.error(c.red(`Unknown argument: ${name}`));
+            help();
+            process.exit(1);
+        }
+        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;
+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._ }));
+function help() {
+    log('Help: finish help');
+}

package/dist/constants.js

@@ -1,22 +1,23 @@
 export const defaultIncludes = ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'];
 export const defaultExcludes = ['**/node_modules/**', '**/dist/**'];
 export const globalApis = [
+    // suite
     'suite',
     'test',
     'describe',
     'it',
+    // chai
+    'chai',
     'expect',
     'assert',
+    // sinon
+    'sinon',
     'spy',
     'mock',
     'stub',
-    'sinon',
+    // hooks
     'beforeAll',
     'afterAll',
     'beforeEach',
     'afterEach',
-    'beforeFile',
-    'afterFile',
-    'beforeSuite',
-    'afterSuite',
 ];

package/dist/entry.js

@@ -0,0 +1,38 @@
+import { fileURLToPath } from 'url';
+import { resolve, dirname } from 'path';
+import minimist from 'minimist';
+import { findUp } from 'find-up';
+import { run } from './node.js';
+process.env.VITEST = 'true';
+const argv = minimist(process.argv.slice(2), {
+    alias: {
+        c: 'config',
+    },
+    string: ['root', 'config'],
+    boolean: ['dev'],
+});
+const __dirname = dirname(fileURLToPath(import.meta.url));
+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 });
+await run({
+    root,
+    files: [
+        resolve(__dirname, argv.dev ? '../src/cli.ts' : './cli.js'),
+    ],
+    config: configPath,
+    defaultConfig: {
+        optimizeDeps: {
+            exclude: [
+                'vitest',
+            ],
+        },
+    },
+    shouldExternalize(id) {
+        if (id.includes('/node_modules/vitest/'))
+            return false;
+        else
+            return id.includes('/node_modules/');
+    },
+});

package/dist/index.d.ts

@@ -1,8 +1,5 @@
-import sinon from 'sinon';
 export * from './types';
 export * from './suite';
 export * from './config';
-export * from './chai';
-export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';
-export { sinon };
-export declare const mock: sinon.SinonMockStatic, spy: sinon.SinonSpyStatic, stub: sinon.SinonStubStatic;
+export * from './integrations/chai';
+export * from './integrations/sinon';

package/dist/index.js

@@ -1,8 +1,5 @@
-import sinon from 'sinon';
 export * from './types';
 export * from './suite';
 export * from './config';
-export * from './chai';
-export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';
-export { sinon };
-export const { mock, spy, stub } = sinon;
+export * from './integrations/chai';
+export * from './integrations/sinon';

package/dist/integrations/chai/index.d.ts

@@ -0,0 +1,3 @@
+import chai from 'chai';
+export { assert, should, expect } from 'chai';
+export { chai };

package/dist/integrations/chai/index.js

@@ -0,0 +1,3 @@
+import chai from 'chai';
+export { assert, should, expect } from 'chai';
+export { chai };

package/dist/{chai.d.ts → integrations/chai/jest-expect.d.ts}

@@ -1,14 +1,14 @@
-import { Config } from 'vitest';
-export declare function setupChai(config: Config): Promise<void>;
-export { assert, should, expect } from 'chai';
+import { ChaiPlugin } from './types';
+export declare function JestChaiExpect(): ChaiPlugin;
 declare global {
     namespace Chai {
         interface Assertion {
-            toMatchSnapshot(message?: string): Assertion;
-            matchSnapshot(message?: string): Assertion;
             toEqual(expected: any): void;
             toStrictEqual(expected: any): void;
+            toBe(expected: any): void;
             toContain(item: any): void;
+            toBeTruthy(): void;
+            toBeFalsy(): void;
             toBeNaN(): void;
             toBeUndefined(): void;
             toBeNull(): void;

package/dist/{chai.js → integrations/chai/jest-expect.js}

@@ -1,15 +1,7 @@
-import chai from 'chai';
-import SinonChai from 'sinon-chai';
-import { SnapshotPlugin } from './snapshot';
-export async function setupChai(config) {
-    chai.use(SinonChai);
-    chai.use(await SnapshotPlugin({
-        rootDir: config.rootDir || process.cwd(),
-        update: config.updateSnapshot,
-    }));
-    // Jest Compact
-    // TODO: add more https://jestjs.io/docs/expect
-    chai.use((chai, utils) => {
+// Jest Expect Compact
+// TODO: add more https://jestjs.io/docs/expect
+export function JestChaiExpect() {
+    return (chai, utils) => {
         const proto = chai.Assertion.prototype;
         utils.addMethod(proto, 'toEqual', function (expected) {
             return this.eql(expected);
@@ -17,9 +9,20 @@ export async function setupChai(config) {
         utils.addMethod(proto, 'toStrictEqual', function (expected) {
             return this.equal(expected);
         });
+        utils.addMethod(proto, 'toBe', function (expected) {
+            return this.be(expected);
+        });
         utils.addMethod(proto, 'toContain', function (item) {
             return this.contain(item);
         });
+        utils.addMethod(proto, 'toBeTruthy', function () {
+            const obj = utils.flag(this, 'object');
+            this.assert(Boolean(obj), 'expected #{this} to be truthy', 'expected #{this} to not be truthy', obj);
+        });
+        utils.addMethod(proto, 'toFalsy', function () {
+            const obj = utils.flag(this, 'object');
+            this.assert(!obj, 'expected #{this} to be falsy', 'expected #{this} to not be falsy', obj);
+        });
         utils.addMethod(proto, 'toBeNaN', function () {
             return this.be.NaN;
         });
@@ -32,6 +35,5 @@ export async function setupChai(config) {
         utils.addMethod(proto, 'toBeDefined', function () {
             return this.not.be.undefined;
         });
-    });
+    };
 }
-export { assert, should, expect } from 'chai';

package/dist/integrations/chai/setup.d.ts

@@ -0,0 +1,2 @@
+import { Config } from 'vitest';
+export declare function setupChai(config: Config): Promise<void>;

package/dist/integrations/chai/setup.js

@@ -0,0 +1,12 @@
+import chai from 'chai';
+import SinonChai from 'sinon-chai';
+import { JestChaiExpect } from './jest-expect';
+import { SnapshotPlugin } from './snapshot';
+export async function setupChai(config) {
+    chai.use(SinonChai);
+    chai.use(JestChaiExpect());
+    chai.use(await SnapshotPlugin({
+        rootDir: config.rootDir || process.cwd(),
+        update: config.updateSnapshot,
+    }));
+}

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

@@ -0,0 +1,19 @@
+import { ChaiPlugin } from '../types';
+import { SnapshotManager } from './manager';
+export interface SnapshotOptions {
+    rootDir: string;
+    update?: boolean;
+}
+export declare function getSnapshotManager(): SnapshotManager;
+export declare function SnapshotPlugin(options: SnapshotOptions): Promise<ChaiPlugin>;
+declare global {
+    namespace Chai {
+        interface Assertion {
+            toMatchSnapshot(message?: string): Assertion;
+            matchSnapshot(message?: string): Assertion;
+        }
+        interface ExpectStatic {
+            addSnapshotSerializer: import('pretty-format').Plugin;
+        }
+    }
+}

package/dist/{snapshot → integrations/chai/snapshot}/index.js

@@ -1,8 +1,10 @@
 import Snap from 'jest-snapshot';
-import { afterAll, beforeEach } from '../hooks';
 import { SnapshotManager } from './manager';
 const { addSerializer } = Snap;
 let _manager;
+export function getSnapshotManager() {
+    return _manager;
+}
 export async function SnapshotPlugin(options) {
     const { rootDir } = options;
     _manager = new SnapshotManager({
@@ -14,18 +16,6 @@ export async function SnapshotPlugin(options) {
         rootDir,
     });
     return function (chai, utils) {
-        beforeEach((task) => {
-            var _a;
-            _manager.setContext({
-                file: ((_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath) || task.name,
-                title: task.name,
-                fullTitle: [task.suite.name, task.name].filter(Boolean).join(' > '),
-            });
-        });
-        afterAll(() => {
-            _manager.saveSnap();
-            _manager.report();
-        });
         for (const key of ['matchSnapshot', 'toMatchSnapshot']) {
             utils.addMethod(chai.Assertion.prototype, key, function (message) {
                 const expected = utils.flag(this, 'object');

package/dist/{snapshot → integrations/chai/snapshot}/manager.d.ts

@@ -1,5 +1,6 @@
 import type { SnapshotStateType, SnapshotResolver } from 'jest-snapshot';
 import type { SnapshotStateOptions } from 'jest-snapshot/build/State';
+import { Task } from '../../../types';
 import { SnapshotSummary } from './utils/types';
 export interface Context {
     file: string;
@@ -20,6 +21,7 @@ export declare class SnapshotManager {
         snapshotResolver?: SnapshotResolver | null;
     });
     onFileChanged(): void;
+    setTask(task: Task): void;
     setContext(context: Context): void;
     assert(received: unknown, message: string): void;
     saveSnap(): void;

package/dist/{snapshot → integrations/chai/snapshot}/manager.js

@@ -31,6 +31,14 @@ export class SnapshotManager {
         this.testFile = this.context.file;
         this.snapshotState = new SnapshotState(this.snapshotResolver.resolveSnapshotPath(this.testFile), this.snapshotOptions);
     }
+    setTask(task) {
+        var _a;
+        this.setContext({
+            file: ((_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath) || task.name,
+            title: task.name,
+            fullTitle: [task.suite.name, task.name].filter(Boolean).join(' > '),
+        });
+    }
     setContext(context) {
         if (!context.title || !context.file)
             return;

package/dist/integrations/chai/types.d.ts

@@ -0,0 +1,3 @@
+import { use as chaiUse } from 'chai';
+export declare type FirstFunctionArgument<T> = T extends (arg: infer A) => unknown ? A : never;
+export declare type ChaiPlugin = FirstFunctionArgument<typeof chaiUse>;

package/dist/integrations/chai/types.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/jsdom.d.ts

@@ -0,0 +1,5 @@
+import { JSDOM } from 'jsdom';
+export declare function setupJSDOM(global: any): {
+    dom: JSDOM;
+    restore(): void;
+};

package/dist/integrations/jsdom.js

@@ -0,0 +1,20 @@
+import { JSDOM } from 'jsdom';
+export function setupJSDOM(global) {
+    const dom = new JSDOM('<!DOCTYPE html>', {
+        pretendToBeVisual: true,
+        runScripts: 'dangerously',
+        // TODO: options
+        url: 'http://localhost:3000',
+    });
+    const keys = Object.getOwnPropertyNames(dom.window)
+        .filter(k => !k.startsWith('_'))
+        .filter(k => !(k in global));
+    for (const key of keys)
+        global[key] = dom.window[key];
+    return {
+        dom,
+        restore() {
+            keys.forEach(key => delete global[key]);
+        },
+    };
+}

package/dist/integrations/sinon.d.ts

@@ -0,0 +1,3 @@
+import sinon from 'sinon';
+export { sinon };
+export declare const mock: sinon.SinonMockStatic, spy: sinon.SinonSpyStatic, stub: sinon.SinonStubStatic;

package/dist/integrations/sinon.js

@@ -0,0 +1,3 @@
+import sinon from 'sinon';
+export { sinon };
+export const { mock, spy, stub } = sinon;

package/dist/reporters/default.d.ts

@@ -1,19 +1,24 @@
-import { File, Reporter, RunnerContext, Suite, Task } from '../types';
+import Listr from 'listr';
+import { 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(): void;
-    onSuiteBegin(suite: Suite): void;
-    onSuiteEnd(suite: Suite): void;
-    onFileBegin(file: File): void;
-    onFileEnd(): void;
-    onTaskBegin(task: Task): void;
+    onCollected(ctx: RunnerContext): void;
     onTaskEnd(task: Task): void;
-    onFinished({ files }: RunnerContext): void;
+    onFinished({ files }: RunnerContext): Promise<void>;
     private getIndent;
     private log;
     private error;
     onSnapshotUpdate(): void;
 }
+export {};

package/dist/reporters/default.js

@@ -1,69 +1,75 @@
-import { relative } from 'path';
 import { performance } from 'perf_hooks';
+import { relative } from 'path';
 import c from 'picocolors';
-import ora from 'ora';
-const DOT = '· ';
-const CHECK = '✔ ';
-const CROSS = '⤫ ';
+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() {
+    onCollected(ctx) {
         this.start = performance.now();
-    }
-    onSuiteBegin(suite) {
-        if (suite.name) {
-            this.indent += 1;
-            const name = DOT + suite.name;
-            if (suite.mode === 'skip')
-                this.log(c.dim(c.yellow(`${name} (skipped)`)));
-            else if (suite.mode === 'todo')
-                this.log(c.dim(`${name} (todo)`));
-            else
-                this.log(name);
-        }
-    }
-    onSuiteEnd(suite) {
-        if (suite.name)
-            this.indent -= 1;
-    }
-    onFileBegin(file) {
-        this.log(`- ${relative(process.cwd(), file.filepath)} ${c.dim(`(${file.suites.flatMap(i => i.tasks).length} tests)`)}`);
-    }
-    onFileEnd() {
-        this.log();
-    }
-    onTaskBegin(task) {
-        this.indent += 1;
-        // @ts-expect-error
-        task.__ora = ora({ text: task.name, prefixText: this.getIndent().slice(1), spinner: 'arc' }).start();
+        this.taskMap = new Map();
+        const tasks = ctx.files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        tasks.forEach((t) => {
+            const obj = {};
+            obj.promise = new Promise((resolve, reject) => {
+                obj.resolve = resolve;
+                obj.reject = reject;
+            });
+            this.taskMap.set(t, obj);
+        });
+        const createTasksListr = (tasks) => {
+            return tasks.map((task) => {
+                return {
+                    title: task.name,
+                    skip: () => task.mode === 'skip',
+                    task: async () => {
+                        var _a;
+                        return await ((_a = this.taskMap.get(task)) === null || _a === void 0 ? void 0 : _a.promise);
+                    },
+                };
+            });
+        };
+        const listrOptions = {
+            exitOnError: false,
+        };
+        this.listr = new Listr(ctx.files.map((file) => {
+            return {
+                title: relative(process.cwd(), file.filepath),
+                task: () => {
+                    return new Listr(file.suites.flatMap((suite) => {
+                        if (!suite.name)
+                            return createTasksListr(suite.tasks);
+                        return [{
+                                title: suite.name,
+                                skip: () => suite.mode !== 'run',
+                                task: () => new Listr(createTasksListr(suite.tasks), listrOptions),
+                            }];
+                    }), listrOptions);
+                },
+            };
+        }), listrOptions);
+        this.listrPromise = this.listr.run().catch(() => { });
     }
     onTaskEnd(task) {
-        var _a;
-        // @ts-expect-error
-        (_a = task.__ora) === null || _a === void 0 ? void 0 : _a.stop();
-        if (task.state === 'pass') {
-            this.log(`${c.green(CHECK + task.name)}`);
-        }
-        else if (task.state === 'skip') {
-            this.log(c.dim(c.yellow(`${DOT + task.name} (skipped)`)));
-        }
-        else if (task.state === 'todo') {
-            this.log(c.dim(`${DOT + task.name} (todo)`));
-        }
-        else {
-            this.error(`${c.red(`${CROSS}${task.name}`)}`);
-            process.exitCode = 1;
-        }
-        this.indent -= 1;
+        var _a, _b;
+        if (task.state === 'fail')
+            (_a = this.taskMap.get(task)) === null || _a === void 0 ? void 0 : _a.reject(task.error);
+        else
+            (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
     }
-    onFinished({ files }) {
+    async onFinished({ files }) {
+        await this.listrPromise;
+        this.log();
         this.end = performance.now();
         const failedFiles = files.filter(i => i.error);
         const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
@@ -85,14 +91,14 @@ export class DefaultReporter {
             this.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(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`)}`);
+                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(task.error || 'Unknown error');
                 this.log();
             });
         }
-        this.log(c.green(`Passed   ${passed.length} / ${runable.length}`));
+        this.log(c.bold(c.green(`Passed   ${passed.length} / ${runable.length}`)));
         if (failed.length)
-            this.log(c.red(`Failed   ${failed.length} / ${runable.length}`));
+            this.log(c.bold(c.red(`Failed   ${failed.length} / ${runable.length}`)));
         if (skipped.length)
             this.log(c.yellow(`Skipped  ${skipped.length}`));
         if (todo.length)

package/dist/run.js

@@ -1,16 +1,20 @@
 import fg from 'fast-glob';
-import { setupChai } from './chai';
+import { setupChai } from './integrations/chai/setup';
 import { clearContext, defaultSuite } from './suite';
 import { context } from './context';
-import { afterEachHook, afterFileHook, afterAllHook, afterSuiteHook, beforeEachHook, beforeFileHook, beforeAllHook, beforeSuiteHook } from './hooks';
 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)));
+}
 export async function runTask(task, ctx) {
-    var _a, _b;
+    var _a, _b, _c;
     const { reporter } = ctx;
-    await ((_a = reporter.onTaskBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, task, ctx));
+    (_a = getSnapshotManager()) === null || _a === void 0 ? void 0 : _a.setTask(task);
+    await ((_b = reporter.onTaskBegin) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
     if (task.mode === 'run') {
-        await beforeEachHook.fire(task);
+        await callHook(task.suite, 'afterEach', [task, task.suite]);
         try {
             await task.fn();
             task.state = 'pass';
@@ -19,9 +23,9 @@ export async function runTask(task, ctx) {
             task.state = 'fail';
             task.error = e;
         }
-        await afterEachHook.fire(task);
+        await callHook(task.suite, 'afterEach', [task, task.suite]);
     }
-    await ((_b = reporter.onTaskEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
+    await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
 }
 export async function collectFiles(paths) {
     const files = [];
@@ -72,23 +76,24 @@ function interpretOnlyMode(items) {
     }
 }
 export async function runFile(file, ctx) {
-    var _a, _b, _c, _d;
+    var _a, _b;
     const { reporter } = ctx;
     const runableSuites = file.suites.filter(i => i.mode === 'run');
     if (runableSuites.length === 0)
         return;
     await ((_a = reporter.onFileBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, file, ctx));
-    await beforeFileHook.fire(file);
-    for (const suite of file.suites) {
-        await ((_b = reporter.onSuiteBegin) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
-        await beforeSuiteHook.fire(suite);
-        for (const t of suite.tasks)
-            await runTask(t, ctx);
-        await afterSuiteHook.fire(suite);
-        await ((_c = reporter.onSuiteEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, suite, ctx));
-    }
-    await afterFileHook.fire(file);
-    await ((_d = reporter.onFileEnd) === null || _d === void 0 ? void 0 : _d.call(reporter, file, ctx));
+    // TODO: support toggling parallel or serial
+    await Promise.all(file.suites.map(async (suite) => {
+        var _a, _b;
+        await ((_a = reporter.onSuiteBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, suite, ctx));
+        await callHook(suite, 'beforeAll', [suite]);
+        await Promise.all(suite.tasks.map(i => runTask(i, ctx)));
+        // for (const t of suite.tasks)
+        //   await runTask(t, ctx)
+        await callHook(suite, 'afterAll', [suite]);
+        await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
+    }));
+    await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
 }
 export async function run(config) {
     var _a, _b, _c, _d;
@@ -111,6 +116,8 @@ export async function run(config) {
     await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
     if (config.global)
         (await import('./global')).registerApiGlobally();
+    if (config.jsdom)
+        (await import('./integrations/jsdom')).setupJSDOM(globalThis);
     const files = await collectFiles(paths);
     const ctx = {
         files,
@@ -118,9 +125,10 @@ export async function run(config) {
         reporter,
     };
     await ((_c = reporter.onCollected) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
-    await beforeAllHook.fire();
     for (const file of files)
         await runFile(file, ctx);
-    await afterAllHook.fire();
+    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));
 }

package/dist/suite.d.ts

@@ -1,4 +1,4 @@
-import { SuiteCollector, TestFactory, TestFunction } from './types';
+import { SuiteCollector, TestFactory, TestFunction, Suite } from './types';
 export declare const defaultSuite: SuiteCollector;
 export declare const test: {
     (name: string, fn: TestFunction): void;
@@ -19,4 +19,8 @@ export declare const it: {
     only(name: string, fn: TestFunction): void;
     todo(name: string): void;
 };
+export declare const beforeAll: (fn: Suite['hooks']['beforeAll'][0]) => void;
+export declare const afterAll: (fn: Suite['hooks']['afterAll'][0]) => void;
+export declare const beforeEach: (fn: Suite['hooks']['beforeEach'][0]) => void;
+export declare const afterEach: (fn: Suite['hooks']['afterEach'][0]) => void;
 export declare function clearContext(): void;

package/dist/suite.js

@@ -3,20 +3,30 @@ export const defaultSuite = suite('');
 function getCurrentSuite() {
     return context.currentSuite || defaultSuite;
 }
-export const test = (name, fn) => getCurrentSuite().test(name, fn);
-test.skip = (name, fn) => getCurrentSuite().test.skip(name, fn);
-test.only = (name, fn) => getCurrentSuite().test.only(name, fn);
-test.todo = (name) => getCurrentSuite().test.todo(name);
-function createSuiteCollector(mode, suiteName, factory) {
+function createSuiteCollector(name, factory = () => { }, mode) {
     const queue = [];
     const factoryQueue = [];
+    const suiteBase = {
+        name,
+        mode,
+        hooks: {
+            beforeAll: [],
+            afterAll: [],
+            beforeEach: [],
+            afterEach: [],
+        },
+    };
     const collector = {
-        name: suiteName,
+        name,
         mode,
         test,
         collect,
         clear,
+        on: addHook,
     };
+    function addHook(name, ...fn) {
+        suiteBase.hooks[name].push(...fn);
+    }
     function collectTask(name, fn, mode) {
         queue.push({
             name,
@@ -41,12 +51,8 @@ function createSuiteCollector(mode, suiteName, factory) {
         if (factory)
             await factory(test);
         const tasks = [...factoryQueue, ...queue];
-        const suite = {
-            name: collector.name,
-            mode: collector.mode,
-            tasks,
-            file,
-        };
+        const suite = Object.assign(Object.assign({}, suiteBase), { tasks,
+            file });
         tasks.forEach((task) => {
             task.suite = suite;
             if (file)
@@ -58,15 +64,25 @@ function createSuiteCollector(mode, suiteName, factory) {
     context.suites.push(collector);
     return collector;
 }
+// apis
+export const test = (name, fn) => getCurrentSuite().test(name, fn);
+test.skip = (name, fn) => getCurrentSuite().test.skip(name, fn);
+test.only = (name, fn) => getCurrentSuite().test.only(name, fn);
+test.todo = (name) => getCurrentSuite().test.todo(name);
 export function suite(suiteName, factory) {
-    return createSuiteCollector('run', suiteName, factory);
+    return createSuiteCollector(suiteName, factory, 'run');
 }
-suite.skip = (suiteName, factory) => createSuiteCollector('skip', suiteName, factory);
-suite.only = (suiteName, factory) => createSuiteCollector('only', suiteName, factory);
-suite.todo = (suiteName) => createSuiteCollector('todo', suiteName);
+suite.skip = (suiteName, factory) => createSuiteCollector(suiteName, factory, 'skip');
+suite.only = (suiteName, factory) => createSuiteCollector(suiteName, factory, 'only');
+suite.todo = (suiteName) => createSuiteCollector(suiteName, undefined, 'todo');
 // alias
 export const describe = suite;
 export const it = test;
+// hooks
+export const beforeAll = (fn) => getCurrentSuite().on('beforeAll', fn);
+export const afterAll = (fn) => getCurrentSuite().on('afterAll', fn);
+export const beforeEach = (fn) => getCurrentSuite().on('beforeEach', fn);
+export const afterEach = (fn) => getCurrentSuite().on('afterEach', fn);
 // utils
 export function clearContext() {
     context.suites.length = 0;

package/dist/types.d.ts

@@ -8,7 +8,13 @@ export interface UserOptions {
      *
      * @default false
      */
-    global?: string;
+    global?: boolean;
+    /**
+     * Use `js-dom` to mock browser APIs
+     *
+     * @default false
+     */
+    jsdom?: boolean;
 }
 export interface Config extends UserOptions {
     rootDir?: string;
@@ -35,18 +41,26 @@ export interface TestCollector {
     skip: (name: string, fn: TestFunction) => void;
     todo: (name: string) => void;
 }
+export declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
 export interface Suite {
     name: string;
     mode: RunMode;
     tasks: Task[];
     file?: File;
+    hooks: {
+        beforeAll: HookListener<[Suite]>[];
+        afterAll: HookListener<[Suite]>[];
+        beforeEach: HookListener<[Task, Suite]>[];
+        afterEach: HookListener<[Task, Suite]>[];
+    };
 }
 export interface SuiteCollector {
-    name: string;
-    mode: RunMode;
+    readonly name: string;
+    readonly mode: RunMode;
     test: TestCollector;
     collect: (file?: File) => Promise<Suite>;
     clear: () => void;
+    on: <T extends keyof Suite['hooks']>(name: T, ...fn: Suite['hooks'][T]) => void;
 }
 export declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
 export interface File {
@@ -65,14 +79,14 @@ export interface GlobalContext {
     currentSuite: SuiteCollector | null;
 }
 export interface Reporter {
-    onStart: (userOptions: Config) => Awaitable<void>;
-    onCollected: (ctx: RunnerContext) => Awaitable<void>;
-    onFinished: (ctx: RunnerContext) => Awaitable<void>;
-    onSuiteBegin: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
-    onSuiteEnd: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
-    onFileBegin: (file: File, ctx: RunnerContext) => Awaitable<void>;
-    onFileEnd: (file: File, ctx: RunnerContext) => Awaitable<void>;
-    onTaskBegin: (task: Task, ctx: RunnerContext) => Awaitable<void>;
-    onTaskEnd: (task: Task, ctx: RunnerContext) => Awaitable<void>;
-    onSnapshotUpdate: () => Awaitable<void>;
+    onStart?: (userOptions: Config) => Awaitable<void>;
+    onCollected?: (ctx: RunnerContext) => Awaitable<void>;
+    onFinished?: (ctx: RunnerContext) => Awaitable<void>;
+    onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
+    onSuiteEnd?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
+    onFileBegin?: (file: File, ctx: RunnerContext) => Awaitable<void>;
+    onFileEnd?: (file: File, ctx: RunnerContext) => Awaitable<void>;
+    onTaskBegin?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
+    onTaskEnd?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
+    onSnapshotUpdate?: () => Awaitable<void>;
 }

package/global.d.ts

@@ -3,19 +3,16 @@ declare global {
   const test: typeof import('vitest')['test']
   const describe: typeof import('vitest')['describe']
   const it: typeof import('vitest')['it']
+  const chai: typeof import('vitest')['chai']
   const expect: typeof import('vitest')['expect']
   const assert: typeof import('vitest')['assert']
+  const sinon: typeof import('vitest')['sinon']
   const spy: typeof import('vitest')['spy']
   const mock: typeof import('vitest')['mock']
   const stub: typeof import('vitest')['stub']
-  const sinon: typeof import('vitest')['sinon']
   const beforeAll: typeof import('vitest')['beforeAll']
   const afterAll: typeof import('vitest')['afterAll']
   const beforeEach: typeof import('vitest')['beforeEach']
   const afterEach: typeof import('vitest')['afterEach']
-  const beforeFile: typeof import('vitest')['beforeFile']
-  const afterFile: typeof import('vitest')['afterFile']
-  const beforeSuite: typeof import('vitest')['beforeSuite']
-  const afterSuite: typeof import('vitest')['afterSuite']
 }
 export {}

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/index'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.13",
+  "version": "0.0.17",
   "description": "",
   "keywords": [],
   "homepage": "https://github.com/antfu/vitest#readme",
@@ -42,6 +42,8 @@
     "find-up": "^6.2.0",
     "jest-snapshot": "^27.4.2",
     "jest-util": "^27.4.2",
+    "jsdom": "^19.0.0",
+    "listr": "^0.14.3",
     "minimist": "^1.2.5",
     "ora": "^6.0.1",
     "picocolors": "^1.0.0",
@@ -51,6 +53,8 @@
   "devDependencies": {
     "@antfu/eslint-config": "^0.11.1",
     "@antfu/ni": "^0.11.0",
+    "@types/jsdom": "^16.2.13",
+    "@types/listr": "^0.14.4",
     "@types/minimist": "^1.2.2",
     "@types/node": "^16.11.11",
     "@types/sinon": "^10.0.6",

package/dist/cli-entry.js

@@ -1,28 +0,0 @@
-var _a;
-import minimist from 'minimist';
-import c from 'picocolors';
-import { run } from './run';
-const { log } = console;
-const argv = minimist(process.argv.slice(2), {
-    alias: {
-        u: 'update',
-    },
-    string: ['root', 'config'],
-    boolean: ['update', 'dev', 'global'],
-    unknown(name) {
-        if (name[0] === '-') {
-            console.error(c.red(`Unknown argument: ${name}`));
-            help();
-            process.exit(1);
-        }
-        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;
-const viteConfig = (server === null || server === void 0 ? void 0 : server.config) || {};
-const testOptions = viteConfig.test || {};
-await run(Object.assign(Object.assign({}, testOptions), { server, global: argv.global, updateSnapshot: argv.update, rootDir: argv.root || process.cwd(), nameFilters: argv._ }));
-function help() {
-    log('Help: finish help');
-}

package/dist/hooks.d.ts

@@ -1,49 +0,0 @@
-import { File, Suite, Task } from './types';
-export declare const beforeAllHook: {
-    on(fn: (...args: any[]) => void | Promise<void>): void;
-    fire(...args: any[]): Promise<void>;
-    clear(): void;
-};
-export declare const afterAllHook: {
-    on(fn: (...args: any[]) => void | Promise<void>): void;
-    fire(...args: any[]): Promise<void>;
-    clear(): void;
-};
-export declare const beforeEachHook: {
-    on(fn: (args_0: Task) => void | Promise<void>): void;
-    fire(args_0: Task): Promise<void>;
-    clear(): void;
-};
-export declare const afterEachHook: {
-    on(fn: (args_0: Task) => void | Promise<void>): void;
-    fire(args_0: Task): Promise<void>;
-    clear(): void;
-};
-export declare const beforeFileHook: {
-    on(fn: (args_0: File) => void | Promise<void>): void;
-    fire(args_0: File): Promise<void>;
-    clear(): void;
-};
-export declare const afterFileHook: {
-    on(fn: (args_0: File) => void | Promise<void>): void;
-    fire(args_0: File): Promise<void>;
-    clear(): void;
-};
-export declare const beforeSuiteHook: {
-    on(fn: (args_0: Suite) => void | Promise<void>): void;
-    fire(args_0: Suite): Promise<void>;
-    clear(): void;
-};
-export declare const afterSuiteHook: {
-    on(fn: (args_0: Suite) => void | Promise<void>): void;
-    fire(args_0: Suite): Promise<void>;
-    clear(): void;
-};
-export declare const beforeAll: (fn: (...args: any[]) => void | Promise<void>) => void;
-export declare const afterAll: (fn: (...args: any[]) => void | Promise<void>) => void;
-export declare const beforeEach: (fn: (args_0: Task) => void | Promise<void>) => void;
-export declare const afterEach: (fn: (args_0: Task) => void | Promise<void>) => void;
-export declare const beforeFile: (fn: (args_0: File) => void | Promise<void>) => void;
-export declare const afterFile: (fn: (args_0: File) => void | Promise<void>) => void;
-export declare const beforeSuite: (fn: (args_0: Suite) => void | Promise<void>) => void;
-export declare const afterSuite: (fn: (args_0: Suite) => void | Promise<void>) => void;

package/dist/hooks.js

@@ -1,17 +0,0 @@
-import { createHook } from './utils/hook';
-export const beforeAllHook = createHook();
-export const afterAllHook = createHook();
-export const beforeEachHook = createHook();
-export const afterEachHook = createHook();
-export const beforeFileHook = createHook();
-export const afterFileHook = createHook();
-export const beforeSuiteHook = createHook();
-export const afterSuiteHook = createHook();
-export const beforeAll = beforeAllHook.on;
-export const afterAll = afterAllHook.on;
-export const beforeEach = beforeEachHook.on;
-export const afterEach = afterEachHook.on;
-export const beforeFile = beforeFileHook.on;
-export const afterFile = afterFileHook.on;
-export const beforeSuite = beforeSuiteHook.on;
-export const afterSuite = afterSuiteHook.on;

package/dist/snapshot/index.d.ts

@@ -1,9 +0,0 @@
-import { use as chaiUse } from 'chai';
-declare type FirstFunctionArgument<T> = T extends (arg: infer A) => unknown ? A : never;
-declare type ChaiPlugin = FirstFunctionArgument<typeof chaiUse>;
-export interface SnapshotOptions {
-    rootDir: string;
-    update?: boolean;
-}
-export declare function SnapshotPlugin(options: SnapshotOptions): Promise<ChaiPlugin>;
-export {};