vitest 0.0.3 → 0.0.8

package/README.md

@@ -11,6 +11,7 @@ A blazing fast test runner powered by Vite.
 - Chai for assertions.
 - Async suite / test.
 - ESM friendly, top level await.
+- Suite and Test filtering (skip, only, todo).
 
 ```ts
 import { it, describe, expect, assert } from 'vitest'
@@ -34,6 +35,67 @@ describe('suite name', () => {
 $ npx vitest
 ```
 
+## Filtering
+
+### Skipping suites and tasks
+
+Use `.skip` to avoid running certain suites or tests 
+
+```ts
+describe.skip('skipped suite', () => {
+  it('task', () => {
+    // Suite skipped, no error
+    assert.equal(Math.sqrt(4), 3)
+  })
+})
+
+describe('suite', () => {
+  it.skip('skipped task', () => {
+    // Task skipped, no error
+    assert.equal(Math.sqrt(4), 3)
+  })
+})
+```
+
+### Selecting suites and tests to run
+
+Use `.only` to only run certain suites or tests 
+
+```ts
+// Only this suite (and others marked with only) are run
+describe.only('suite', () => {
+  it('task', () => {
+    assert.equal(Math.sqrt(4), 3) 
+  })
+})
+
+describe('another suite', () => {
+  it('skipped task', () => {
+     // Task skipped, as tests are running in Only mode
+    assert.equal(Math.sqrt(4), 3)
+  })
+
+  it.only('task', () => {
+     // Only this task (and others marked with only) are run
+    assert.equal(Math.sqrt(4), 2)
+  })
+})
+```
+
+### Unimplemented suites and tests
+
+Use `.todo` to stub suites and tests that should be implemented
+
+```ts
+ // An entry will be shown in the report for this suite
+describe.todo('unimplemented suite')
+
+// An entry will be shown in the report for this task
+describe.suite('suite', () => {
+  it.todo('unimplemented task')
+})
+```
+
 ## TODO
 
 - [ ] Reporter & Better output

package/bin/vitest.mjs

@@ -5,18 +5,27 @@ import { fileURLToPath } from 'url'
 import { resolve, dirname } from 'path'
 import { run } from 'vite-node'
 import minimist from 'minimist'
+import { findUp } from 'find-up'
 
 const argv = minimist(process.argv.slice(2), {
-  string: ['root'],
+  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: resolve(argv.root || process.cwd()),
+  root,
   files: [
-    resolve(__dirname, '../dist/cli.js'),
+    resolve(__dirname, argv.dev ? '../src/cli.ts' : '../dist/cli.js'),
   ],
+  config: configPath,
   defaultConfig: {
     optimizeDeps: {
       exclude: [

package/dist/chai.d.ts

@@ -0,0 +1,12 @@
+export { assert, should, expect } from 'chai';
+declare global {
+    namespace Chai {
+        interface Assertion {
+            toMatchSnapshot(message?: string): Assertion;
+            matchSnapshot(message?: string): Assertion;
+        }
+        interface ExpectStatic {
+            addSnapshotSerializer: import('pretty-format').Plugin;
+        }
+    }
+}

package/dist/chai.js

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

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { join } from 'path';
+var _a;
 import minimist from 'minimist';
 import c from 'picocolors';
 import { run } from './run';
@@ -7,8 +7,8 @@ const argv = minimist(process.argv.slice(2), {
     alias: {
         u: 'update',
     },
-    string: ['root'],
-    boolean: ['update'],
+    string: ['root', 'config'],
+    boolean: ['update', 'dev'],
     unknown(name) {
         if (name[0] === '-') {
             console.error(c.red(`Unknown argument: ${name}`));
@@ -18,11 +18,11 @@ const argv = minimist(process.argv.slice(2), {
         return true;
     },
 });
-// TODO: load config, CLI
-await run({
-    rootDir: argv.root || join(process.cwd(), 'test'),
-    updateSnapshot: argv.update,
-});
+// @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), { updateSnapshot: argv.update, rootDir: argv.root || process.cwd() }));
 function help() {
     log('Help: finish help');
 }

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+import { UserConfig } from 'vite';
+import { UserOptions } from './types';
+export interface VitestConfig extends UserConfig {
+    /**
+     * Options for Vitest
+     */
+    test?: UserOptions;
+}
+export declare function defineConfig(config: VitestConfig): VitestConfig;
+declare module 'vite' {
+    interface UserConfig {
+        /**
+         * Options for Vitest
+         */
+        test?: UserOptions;
+    }
+}

package/dist/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/hooks.d.ts

@@ -1,11 +1,10 @@
-import { Suite, Task } from './types';
-import { TaskResult } from '.';
-export declare const beforeHook: {
+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 afterHook: {
+export declare const afterAllHook: {
     on(fn: (...args: any[]) => void | Promise<void>): void;
     fire(...args: any[]): Promise<void>;
     clear(): void;
@@ -16,18 +15,18 @@ export declare const beforeEachHook: {
     clear(): void;
 };
 export declare const afterEachHook: {
-    on(fn: (args_0: Task, args_1: TaskResult) => void | Promise<void>): void;
-    fire(args_0: Task, args_1: TaskResult): Promise<void>;
+    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: string) => void | Promise<void>): void;
-    fire(args_0: string): Promise<void>;
+    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: string) => void | Promise<void>): void;
-    fire(args_0: string): Promise<void>;
+    on(fn: (args_0: File) => void | Promise<void>): void;
+    fire(args_0: File): Promise<void>;
     clear(): void;
 };
 export declare const beforeSuiteHook: {
@@ -40,11 +39,11 @@ export declare const afterSuiteHook: {
     fire(args_0: Suite): Promise<void>;
     clear(): void;
 };
-export declare const before: (fn: (...args: any[]) => void | Promise<void>) => void;
-export declare const after: (fn: (...args: any[]) => void | Promise<void>) => 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, args_1: TaskResult) => void | Promise<void>) => void;
-export declare const beforeFile: (fn: (args_0: string) => void | Promise<void>) => void;
-export declare const afterFile: (fn: (args_0: string) => 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,14 +1,14 @@
 import { createHook } from './utils/hook';
-export const beforeHook = createHook();
-export const afterHook = createHook();
+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 before = beforeHook.on;
-export const after = afterHook.on;
+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;

package/dist/index.d.ts

@@ -1,14 +1,5 @@
 export * from './types';
 export * from './suite';
-export { assert, should, expect } from 'chai';
-declare global {
-    namespace Chai {
-        interface Assertion {
-            toMatchSnapshot(message?: string): Assertion;
-            matchSnapshot(message?: string): Assertion;
-        }
-        interface ExpectStatic {
-            addSnapshotSerializer: import('pretty-format').Plugin;
-        }
-    }
-}
+export * from './config';
+export * from './chai';
+export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';

package/dist/index.js

@@ -1,3 +1,5 @@
 export * from './types';
 export * from './suite';
-export { assert, should, expect } from 'chai';
+export * from './config';
+export * from './chai';
+export { beforeAll, afterAll, beforeEach, afterEach, beforeFile, afterFile, beforeSuite, afterSuite } from './hooks';

package/dist/reporters/default.d.ts

@@ -0,0 +1,18 @@
+import { File, Reporter, RunnerContext, Suite, Task } from '../types';
+export declare class DefaultReporter implements Reporter {
+    indent: number;
+    start: number;
+    end: number;
+    onStart(): void;
+    onCollected(): void;
+    onFinished({ files }: RunnerContext): void;
+    onSuiteBegin(suite: Suite): void;
+    onSuiteEnd(suite: Suite): void;
+    onFileBegin(file: File): void;
+    onFileEnd(): void;
+    onTaskBegin(): void;
+    onTaskEnd(t: Task): void;
+    log(msg?: string, indentDelta?: number): void;
+    error(msg?: string, indentDelta?: number): void;
+    onSnapshotUpdate(): void;
+}

package/dist/reporters/default.js

@@ -0,0 +1,86 @@
+import { relative } from 'path';
+import { performance } from 'perf_hooks';
+import c from 'picocolors';
+const DOT = '· ';
+export class DefaultReporter {
+    constructor() {
+        this.indent = 0;
+        this.start = 0;
+        this.end = 0;
+    }
+    onStart() {
+        this.indent = 0;
+    }
+    onCollected() {
+        this.start = performance.now();
+    }
+    onFinished({ files }) {
+        this.end = performance.now();
+        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        const passed = tasks.filter(i => i.status === 'pass');
+        const failed = tasks.filter(i => i.status === 'fail');
+        const skipped = tasks.filter(i => i.status === 'skip');
+        const todo = tasks.filter(i => i.status === 'todo');
+        this.indent = 0;
+        this.log(c.green(`Passed   ${passed.length} / ${tasks.length}`));
+        if (skipped.length)
+            this.log(c.yellow(`Skipped  ${skipped.length}`));
+        if (todo.length)
+            this.log(c.dim(`Todo     ${todo.length}`));
+        if (failed.length)
+            this.log(c.red(`Failed   ${failed.length} / ${tasks.length}`));
+        this.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
+    }
+    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() {
+        this.indent += 1;
+    }
+    onTaskEnd(t) {
+        if (t.status === 'pass') {
+            this.log(`${c.green(`✔ ${t.name}`)}`);
+        }
+        else if (t.status === 'skip') {
+            this.log(c.dim(c.yellow(`${DOT + t.name} (skipped)`)));
+        }
+        else if (t.status === 'todo') {
+            this.log(c.dim(`${DOT + t.name} (todo)`));
+        }
+        else {
+            this.error(`${c.red(`⤫ ${c.inverse(c.red(' FAIL '))} ${t.name}`)}`);
+            this.error(String(t.error), 1);
+            process.exitCode = 1;
+        }
+        this.indent -= 1;
+    }
+    log(msg = '', indentDelta = 0) {
+        // eslint-disable-next-line no-console
+        console.log(`${' '.repeat((this.indent + indentDelta) * 2)}${msg}`);
+    }
+    error(msg = '', indentDelta = 0) {
+        // eslint-disable-next-line no-console
+        console.error(c.red(`${' '.repeat((this.indent + indentDelta) * 2)}${msg}`));
+    }
+    onSnapshotUpdate() {
+    }
+}

package/dist/run.d.ts

@@ -1,5 +1,5 @@
-import { File, Options, Task, TaskResult } from './types';
-export declare function runTasks(tasks: Task[]): Promise<TaskResult[]>;
-export declare function parseFile(filepath: string): Promise<File>;
-export declare function runFile(filepath: string): Promise<void>;
+import { File, Options, Task, RunnerContext } from './types';
+export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
+export declare function collectFiles(files: string[]): Promise<File[]>;
+export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
 export declare function run(options?: Options): Promise<void>;

package/dist/run.js

@@ -1,93 +1,103 @@
-import { relative } from 'path';
-import c from 'picocolors';
 import chai from 'chai';
 import fg from 'fast-glob';
 import { clearContext, defaultSuite } from './suite';
 import { context } from './context';
-import { afterEachHook, afterFileHook, afterHook, afterSuiteHook, beforeEachHook, beforeFileHook, beforeHook, beforeSuiteHook } from './hooks';
-import { SnapshotPlugin } from './snapshot/index';
-export async function runTasks(tasks) {
-    const results = [];
-    for (const task of tasks) {
-        const result = { task };
-        await beforeEachHook.fire(task);
+import { afterEachHook, afterFileHook, afterAllHook, afterSuiteHook, beforeEachHook, beforeFileHook, beforeAllHook, beforeSuiteHook } from './hooks';
+import { SnapshotPlugin } from './snapshot';
+import { DefaultReporter } from './reporters/default';
+export async function runTask(task, ctx) {
+    var _a, _b;
+    const { reporter } = ctx;
+    await ((_a = reporter.onTaskBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, task, ctx));
+    await beforeEachHook.fire(task);
+    if (task.suite.mode === 'skip' || task.mode === 'skip') {
+        task.status = 'skip';
+    }
+    else if (task.suite.mode === 'todo' || task.mode === 'todo') {
+        task.status = 'todo';
+    }
+    else {
         try {
             await task.fn();
+            task.status = 'pass';
         }
         catch (e) {
-            result.error = e;
+            task.status = 'fail';
+            task.error = e;
         }
-        results.push(result);
-        await afterEachHook.fire(task, result);
     }
-    return results;
+    await afterEachHook.fire(task);
+    await ((_b = reporter.onTaskEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
 }
-// TODO: REPORTER
-const { log } = console;
-export async function parseFile(filepath) {
-    clearContext();
-    await import(filepath);
-    const suites = [defaultSuite, ...context.suites];
-    const tasks = await Promise.all(suites.map(async (suite) => {
-        await beforeSuiteHook.fire(suite);
-        context.currentSuite = suite;
-        return [suite, await suite.collect()];
-    }));
-    const file = {
-        filepath,
-        suites,
-        tasks,
-    };
-    file.tasks.forEach(([, tasks]) => tasks.forEach(task => task.file = file));
-    return file;
-}
-export async function runFile(filepath) {
-    await beforeFileHook.fire(filepath);
-    const file = await parseFile(filepath);
-    for (const [suite, tasks] of file.tasks) {
-        let indent = 1;
-        if (suite.name) {
-            log(' '.repeat(indent * 2) + suite.name);
-            indent += 1;
-        }
-        const result = await runTasks(tasks);
-        for (const r of result) {
-            if (r.error === undefined) {
-                log(`${' '.repeat(indent * 2)}${c.inverse(c.green(' PASS '))} ${c.green(r.task.name)}`);
-            }
-            else {
-                console.error(`${' '.repeat(indent * 2)}${c.inverse(c.red(' FAIL '))} ${c.red(r.task.name)}`);
-                console.error(' '.repeat((indent + 2) * 2) + c.red(String(r.error)));
-                process.exitCode = 1;
-            }
+export async function collectFiles(files) {
+    const result = [];
+    for (const filepath of files) {
+        clearContext();
+        await import(filepath);
+        const collectors = [defaultSuite, ...context.suites];
+        const suites = [];
+        const file = {
+            filepath,
+            suites: [],
+        };
+        for (const c of collectors) {
+            context.currentSuite = c;
+            suites.push(await c.collect(file));
         }
-        if (suite.name)
-            indent -= 1;
+        file.suites = suites;
+        result.push(file);
+    }
+    return result;
+}
+export async function runFile(file, ctx) {
+    var _a, _b, _c, _d;
+    const { reporter } = ctx;
+    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(filepath);
+    await afterFileHook.fire(file);
+    await ((_d = reporter.onFileEnd) === null || _d === void 0 ? void 0 : _d.call(reporter, file, ctx));
 }
 export async function run(options = {}) {
+    var _a, _b, _c;
     const { rootDir = process.cwd() } = options;
-    chai.use(SnapshotPlugin({
+    chai.use(await SnapshotPlugin({
         rootDir,
         update: options.updateSnapshot,
     }));
-    const files = await fg(options.includes || ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'], {
+    const paths = await fg(options.includes || ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'], {
         absolute: true,
         cwd: options.rootDir,
+        ignore: options.excludes || ['**/node_modules/**', '**/dist/**'],
     });
-    if (!files.length) {
+    if (!paths.length) {
         console.error('No test files found');
         process.exitCode = 1;
         return;
     }
-    await beforeHook.fire();
-    for (const file of files) {
-        log(`${relative(process.cwd(), file)}`);
-        await runFile(file);
-        log();
-    }
-    await afterHook.fire();
-    log();
+    const reporter = new DefaultReporter();
+    await ((_a = reporter.onStart) === null || _a === void 0 ? void 0 : _a.call(reporter, options));
+    const files = await collectFiles(paths);
+    const ctx = {
+        files,
+        mode: isOnlyMode(files) ? 'only' : 'all',
+        userOptions: options,
+        reporter,
+    };
+    await ((_b = reporter.onCollected) === null || _b === void 0 ? void 0 : _b.call(reporter, ctx));
+    await beforeAllHook.fire();
+    for (const file of files)
+        await runFile(file, ctx);
+    await afterAllHook.fire();
+    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
+}
+function isOnlyMode(files) {
+    return !!files.find(file => file.suites.find(suite => suite.mode === 'only' || suite.tasks.find(t => t.mode === 'only')));
 }

package/dist/snapshot/index.d.ts

@@ -5,5 +5,5 @@ export interface SnapshotOptions {
     rootDir: string;
     update?: boolean;
 }
-export declare function SnapshotPlugin(options: SnapshotOptions): ChaiPlugin;
+export declare function SnapshotPlugin(options: SnapshotOptions): Promise<ChaiPlugin>;
 export {};

package/dist/snapshot/index.js

@@ -1,21 +1,19 @@
 import Snap from 'jest-snapshot';
-import { after, before, beforeEach } from '../hooks';
+import { afterAll, beforeEach } from '../hooks';
 import { SnapshotManager } from './manager';
 const { addSerializer } = Snap;
 let _manager;
-export function SnapshotPlugin(options) {
+export async function SnapshotPlugin(options) {
     const { rootDir } = options;
     _manager = new SnapshotManager({
         rootDir,
         update: options.update,
     });
+    _manager.snapshotResolver = await Snap.buildSnapshotResolver({
+        transform: [],
+        rootDir,
+    });
     return function (chai, utils) {
-        before(async () => {
-            _manager.snapshotResolver = await Snap.buildSnapshotResolver({
-                transform: [],
-                rootDir,
-            });
-        });
         beforeEach((task) => {
             var _a;
             _manager.setContext({
@@ -24,7 +22,7 @@ export function SnapshotPlugin(options) {
                 fullTitle: [task.suite.name, task.name].filter(Boolean).join(' > '),
             });
         });
-        after(() => {
+        afterAll(() => {
             _manager.saveSnap();
             _manager.report();
         });

package/dist/suite.d.ts

@@ -1,7 +1,22 @@
-import { Suite } from './types';
-export declare const defaultSuite: Suite;
-export declare const test: (name: string, fn: () => Promise<void> | void) => void;
-export declare function clearContext(): void;
-export declare function suite(suiteName: string, factory?: (test: Suite['test']) => Promise<void> | void): Suite;
+import { SuiteCollector, TestFactory, TestFunction } from './types';
+export declare const defaultSuite: SuiteCollector;
+export declare const test: {
+    (name: string, fn: TestFunction): void;
+    skip(name: string, fn: TestFunction): void;
+    only(name: string, fn: TestFunction): void;
+    todo(name: string): void;
+};
+export declare function suite(suiteName: string, factory?: TestFactory): SuiteCollector;
+export declare namespace suite {
+    var skip: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
+    var only: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
+    var todo: (suiteName: string) => SuiteCollector;
+}
 export declare const describe: typeof suite;
-export declare const it: (name: string, fn: () => Promise<void> | void) => void;
+export declare const it: {
+    (name: string, fn: TestFunction): void;
+    skip(name: string, fn: TestFunction): void;
+    only(name: string, fn: TestFunction): void;
+    todo(name: string): void;
+};
+export declare function clearContext(): void;

package/dist/suite.js

@@ -1,41 +1,75 @@
 import { context } from './context';
 export const defaultSuite = suite('');
-export const test = (name, fn) => (context.currentSuite || defaultSuite).test(name, fn);
-export function clearContext() {
-    context.suites.length = 0;
-    defaultSuite.clear();
+function getCurrentSuite() {
+    return context.currentSuite || defaultSuite;
 }
-export function suite(suiteName, factory) {
+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) {
     const queue = [];
     const factoryQueue = [];
-    const suite = {
+    const collector = {
         name: suiteName,
+        mode,
         test,
         collect,
         clear,
     };
-    function test(name, fn) {
-        const task = {
-            suite,
+    function collectTask(name, fn, mode) {
+        queue.push({
             name,
+            mode,
+            suite: {},
+            status: 'init',
             fn,
-        };
-        queue.push(task);
+        });
+    }
+    function test(name, fn) {
+        collectTask(name, fn, mode);
     }
+    test.skip = (name, fn) => collectTask(name, fn, 'skip');
+    test.only = (name, fn) => collectTask(name, fn, 'only');
+    test.todo = (name) => collectTask(name, () => { }, 'todo');
     function clear() {
         queue.length = 0;
         factoryQueue.length = 0;
     }
-    async function collect() {
+    async function collect(file) {
         factoryQueue.length = 0;
         if (factory)
             await factory(test);
-        return [...factoryQueue, ...queue];
+        const tasks = [...factoryQueue, ...queue];
+        const suite = {
+            name: collector.name,
+            mode: collector.mode,
+            tasks,
+            file,
+        };
+        tasks.forEach((task) => {
+            task.suite = suite;
+            if (file)
+                task.file = file;
+        });
+        return suite;
     }
-    context.currentSuite = suite;
-    context.suites.push(suite);
-    return suite;
+    context.currentSuite = collector;
+    context.suites.push(collector);
+    return collector;
+}
+export function suite(suiteName, factory) {
+    return createSuiteCollector('run', suiteName, factory);
 }
+suite.skip = (suiteName, factory) => createSuiteCollector('skip', suiteName, factory);
+suite.only = (suiteName, factory) => createSuiteCollector('only', suiteName, factory);
+suite.todo = (suiteName) => createSuiteCollector('todo', suiteName);
 // alias
 export const describe = suite;
 export const it = test;
+// utils
+export function clearContext() {
+    context.suites.length = 0;
+    defaultSuite.clear();
+    context.currentSuite = defaultSuite;
+}

package/dist/types.d.ts

@@ -1,31 +1,67 @@
-export interface Options {
-    rootDir?: string;
+export declare type Awaitable<T> = Promise<T> | T;
+export interface UserOptions {
     includes?: string[];
     excludes?: string[];
+}
+export interface Options extends UserOptions {
+    rootDir?: string;
     updateSnapshot?: boolean;
 }
+export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
+export declare type TaskStatus = 'init' | 'pass' | 'fail' | 'skip' | 'todo';
 export interface Task {
     name: string;
+    mode: RunMode;
     suite: Suite;
-    fn: () => Promise<void> | void;
+    fn: () => Awaitable<void>;
     file?: File;
-}
-export interface TaskResult {
-    task: Task;
+    status: TaskStatus;
     error?: unknown;
 }
+export declare type TestFunction = () => Awaitable<void>;
+export interface TestCollector {
+    (name: string, fn: TestFunction): void;
+    only: (name: string, fn: TestFunction) => void;
+    skip: (name: string, fn: TestFunction) => void;
+    todo: (name: string) => void;
+}
 export interface Suite {
     name: string;
-    test: (name: string, fn: () => Promise<void> | void) => void;
-    collect: () => Promise<Task[]>;
+    mode: RunMode;
+    tasks: Task[];
+    file?: File;
+}
+export interface SuiteCollector {
+    name: string;
+    mode: RunMode;
+    test: TestCollector;
+    collect: (file?: File) => Promise<Suite>;
     clear: () => void;
 }
+export declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
 export interface File {
     filepath: string;
     suites: Suite[];
-    tasks: [Suite, Task[]][];
+}
+export interface RunnerContext {
+    files: File[];
+    mode: 'all' | 'only';
+    userOptions: Options;
+    reporter: Reporter;
 }
 export interface GlobalContext {
-    suites: Suite[];
-    currentSuite: Suite | null;
+    suites: SuiteCollector[];
+    currentSuite: SuiteCollector | null;
+}
+export interface Reporter {
+    onStart: (userOptions: Options) => 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.3",
+  "version": "0.0.8",
   "type": "module",
   "description": "",
   "keywords": [],
@@ -32,19 +32,9 @@
   "bin": {
     "vitest": "./bin/vitest.mjs"
   },
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
-    "lint": "eslint \"{src,test}/**/*.ts\"",
-    "prepublishOnly": "nr build",
-    "release": "bumpp --commit --push --tag && pnpm publish",
-    "test": "npx vite-node src/cli.ts --",
-    "test:update": "nr test -u"
-  },
   "devDependencies": {
     "@antfu/eslint-config": "^0.11.1",
     "@antfu/ni": "^0.11.0",
-    "@types/chai": "^4.2.22",
     "@types/minimist": "^1.2.2",
     "@types/node": "^16.11.11",
     "bumpp": "^7.1.1",
@@ -55,12 +45,22 @@
   },
   "dependencies": {
     "@jest/test-result": "^27.4.2",
+    "@types/chai": "^4.2.22",
     "chai": "^4.3.4",
     "fast-glob": "^3.2.7",
+    "find-up": "^6.2.0",
     "jest-snapshot": "^27.4.2",
     "jest-util": "^27.4.2",
     "minimist": "^1.2.5",
     "picocolors": "^1.0.0",
-    "vite-node": "v0.1.8"
+    "vite-node": "^0.1.10"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "lint": "eslint \"{src,test}/**/*.ts\"",
+    "release": "bumpp --commit --push --tag && pnpm publish",
+    "test": "node bin/vitest.mjs --dev",
+    "test:update": "nr test -u"
   }
-}
+}