vitest 0.0.16 → 0.0.17

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/index.d.ts

@@ -3,4 +3,3 @@ export * from './suite';
 export * from './config';
 export * from './integrations/chai';
 export * from './integrations/sinon';
-export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';

package/dist/index.js

@@ -3,4 +3,3 @@ export * from './suite';
 export * from './config';
 export * from './integrations/chai';
 export * from './integrations/sinon';
-export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';

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

@@ -1,8 +1,10 @@
 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 {

package/dist/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/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/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/run.js

@@ -2,15 +2,19 @@ import fg from 'fast-glob';
 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 = [];
@@ -78,19 +82,17 @@ export async function runFile(file, ctx) {
     if (runableSuites.length === 0)
         return;
     await ((_a = reporter.onFileBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, file, ctx));
-    await beforeFileHook.fire(file);
     // 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 beforeSuiteHook.fire(suite);
+        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 afterSuiteHook.fire(suite);
+        await callHook(suite, 'afterAll', [suite]);
         await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
     }));
-    await afterFileHook.fire(file);
     await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
 }
 export async function run(config) {
@@ -123,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

@@ -41,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 {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "",
   "keywords": [],
   "homepage": "https://github.com/antfu/vitest#readme",
@@ -33,16 +33,6 @@
     "bin",
     "*.d.ts"
   ],
-  "scripts": {
-    "prepare": "esmo scripts/generate-types.ts",
-    "build": "rimraf dist && tsc -p src/tsconfig.json",
-    "lint": "eslint \"{src,test}/**/*.ts\"",
-    "prepublishOnly": "nr build",
-    "release": "bumpp --commit --push --tag && pnpm publish",
-    "test": "node bin/vitest.mjs --dev",
-    "test:update": "nr test -u",
-    "watch": "tsc -p src/tsconfig.json --watch"
-  },
   "dependencies": {
     "@jest/test-result": "^27.4.2",
     "@types/chai": "^4.2.22",
@@ -74,5 +64,13 @@
     "rimraf": "^3.0.2",
     "typescript": "^4.5.2",
     "vite": "^2.6.14"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -p src/tsconfig.json",
+    "lint": "eslint \"{src,test}/**/*.ts\"",
+    "release": "bumpp --commit --push --tag && pnpm publish",
+    "test": "node bin/vitest.mjs --dev",
+    "test:update": "nr test -u",
+    "watch": "tsc -p src/tsconfig.json --watch"
   }
-}
+}

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;