vitest 0.0.33 → 0.0.34

package/README.gh.md

@@ -1,10 +1,18 @@
-# vitest
-
-[![NPM version](https://img.shields.io/npm/v/vitest?color=a1b858&label=)](https://www.npmjs.com/package/vitest)
+<p align="center">
+<img src="https://user-images.githubusercontent.com/11247099/145112184-a9ff6727-661c-439d-9ada-963124a281f7.png" height="200">
+</p>
 
+<h1 align="center">
+Vitest
+</h1>
+<p align="center">
 A blazing fast unit test framework powered by Vite.
+<p>
+<p align="center">
+  <a href="https://www.npmjs.com/package/vitest"><img src="https://img.shields.io/npm/v/vitest?color=a1b858&label="></a>
+<p>
 
-> **This project is currently in closed beta exclusively for Sponsors.**<br>
+> 💖 **This project is currently in closed beta exclusively for Sponsors.**<br>
 > Become a Sponsor of [@patak-js](https://github.com/sponsors/patak-js) or [@antfu](https://github.com/sponsors/antfu) to access the source code and issues tracker.
 
 > ⚠️ **DISCLAIMER**: Vitest is still in development and not stable yet. It's not recommended to use it in production.
@@ -15,17 +23,19 @@ A blazing fast unit test framework powered by Vite.
 
 ## Features
 
-- [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins.
+- [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins. Use the same setup from your app!
 - [Jest Snapshot](https://jestjs.io/docs/snapshot-testing)
 - [Chai](https://www.chaijs.com/) built-in for assertions, with [jest-expect](https://jestjs.io/docs/expect) compatible APIs.
+- [Smart watch mode](#watch-mode), just like HMR for tests!
+- [Code coverage](#coverage)
 - [Sinon](https://sinonjs.org/) built-in for mocking
-- [JSDOM](https://github.com/jsdom/jsdom) built-in built-in for DOM mocking
+- [JSDOM](https://github.com/jsdom/jsdom) built-in for DOM and browser API mocking
 - Components testing ([Vue example](./test/vue), [React example](./test/react))
 - Async suite / test, top level await
 - ESM friendly
 - Out-of-box TypeScript / JSX support
 - Suite and Test filtering (skip, only, todo)
-- [Test coverage](#coverage)
+- Concurrent Tests
 
 ```ts
 import { it, describe, expect, assert } from 'vitest'
@@ -229,6 +239,39 @@ describe('suite', () => {
 })
 ```
 
+### Running tests concurrently
+
+Use `.concurrent` in consecutive tests to run them in parallel
+
+```ts
+// The two tasks marked with concurrent will be run in parallel
+describe('suite', () => {
+  it('serial task', () => {
+    assert.equal(Math.sqrt(4), 3)
+  })
+  it.concurrent('concurrent task 1', () => {
+    assert.equal(Math.sqrt(4), 3)
+  })
+  it.concurrent('concurrent task 2', () => {
+    assert.equal(Math.sqrt(4), 3)
+  })
+})
+```
+
+You can also use `.skip`, `.only`, and `.todo` with concurrent tasks. All the following combinations are valid:
+```js
+it.concurrent(...)
+
+it.skip.concurrent(...)
+it.concurrent.skip(...)
+
+it.only.concurrent(...)
+it.concurrent.only(...)
+
+it.todo.concurrent(...)
+it.concurrent.todo(...)
+```
+
 ## Sponsors
 
 <p align="center">

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const defaultIncludes: string[];
 export declare const defaultExcludes: string[];
 export declare const globalApis: string[];
+export declare const defaultConcurrentTimeout = 5000;

package/dist/constants.js

@@ -21,3 +21,4 @@ export const globalApis = [
     'beforeEach',
     'afterEach',
 ];
+export const defaultConcurrentTimeout = 5000;

package/dist/node/node.js

@@ -68,8 +68,10 @@ const stubRequests = {
         createHotContext() {
             return {
                 accept: () => { },
+                prune: () => { },
             };
         },
+        updateStyle() { },
     },
 };
 async function transform(server, id) {

package/dist/run/index.js

@@ -98,8 +98,15 @@ export async function runSuite(suite, ctx) {
     else {
         try {
             await callHook(suite, 'beforeAll', [suite]);
-            for (const t of suite.tasks)
-                await runTask(t, ctx);
+            for (const taskGroup of partitionTasks(suite.tasks)) {
+                if (taskGroup[0].concurrent) {
+                    await Promise.all(taskGroup.map(t => runTask(t, ctx)));
+                }
+                else {
+                    for (const t of taskGroup)
+                        await runTask(t, ctx);
+                }
+            }
             await callHook(suite, 'afterAll', [suite]);
         }
         catch (e) {
@@ -110,6 +117,25 @@ export async function runSuite(suite, ctx) {
     }
     await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
 }
+/**
+ * Partition consecutive serial and concurrent tasks in groups
+ */
+function partitionTasks(tasks) {
+    let taskGroup = [];
+    const groupedTasks = [];
+    for (const task of tasks) {
+        if (taskGroup.length === 0 || !!task.concurrent === !!taskGroup[0].concurrent) {
+            taskGroup.push(task);
+        }
+        else {
+            groupedTasks.push(taskGroup);
+            taskGroup = [task];
+        }
+    }
+    if (taskGroup.length > 0)
+        groupedTasks.push(taskGroup);
+    return groupedTasks;
+}
 export async function runFile(file, ctx) {
     var _a, _b;
     const { reporter } = ctx;

package/dist/suite.d.ts

@@ -2,9 +2,24 @@ import { SuiteCollector, TestFactory, TestFunction, Suite } 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;
+    concurrent: {
+        (name: string, fn: TestFunction, timeout?: number | undefined): void;
+        skip(name: string, fn: TestFunction, timeout?: number | undefined): void;
+        only(name: string, fn: TestFunction, timeout?: number | undefined): void;
+        todo(name: string): void;
+    };
+    skip: {
+        (name: string, fn: TestFunction): void;
+        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
+    };
+    only: {
+        (name: string, fn: TestFunction): void;
+        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
+    };
+    todo: {
+        (name: string): void;
+        concurrent(name: string): void;
+    };
 };
 export declare function suite(suiteName: string, factory?: TestFactory): SuiteCollector;
 export declare namespace suite {
@@ -15,9 +30,24 @@ export declare namespace suite {
 export declare const describe: typeof suite;
 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;
+    concurrent: {
+        (name: string, fn: TestFunction, timeout?: number | undefined): void;
+        skip(name: string, fn: TestFunction, timeout?: number | undefined): void;
+        only(name: string, fn: TestFunction, timeout?: number | undefined): void;
+        todo(name: string): void;
+    };
+    skip: {
+        (name: string, fn: TestFunction): void;
+        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
+    };
+    only: {
+        (name: string, fn: TestFunction): void;
+        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
+    };
+    todo: {
+        (name: string): void;
+        concurrent(name: string): void;
+    };
 };
 export declare const beforeAll: (fn: Suite['hooks']['beforeAll'][0]) => void;
 export declare const afterAll: (fn: Suite['hooks']['afterAll'][0]) => void;

package/dist/suite.js

@@ -1,4 +1,5 @@
 import { context } from './context';
+import { defaultConcurrentTimeout } from './constants';
 export const defaultSuite = suite('');
 function getCurrentSuite() {
     return context.currentSuite || defaultSuite;
@@ -16,6 +17,16 @@ function createSuiteCollector(name, factory = () => { }, mode) {
             afterEach: [],
         },
     };
+    const test = createTestCollector((name, fn, mode, concurrent) => {
+        queue.push({
+            name,
+            mode,
+            concurrent,
+            suite: {},
+            state: (mode !== 'run' && mode !== 'only') ? mode : undefined,
+            fn,
+        });
+    });
     const collector = {
         name,
         mode,
@@ -27,21 +38,6 @@ function createSuiteCollector(name, factory = () => { }, mode) {
     function addHook(name, ...fn) {
         suiteBase.hooks[name].push(...fn);
     }
-    function collectTask(name, fn, mode) {
-        queue.push({
-            name,
-            mode,
-            suite: {},
-            state: (mode !== 'run' && mode !== 'only') ? mode : undefined,
-            fn,
-        });
-    }
-    function test(name, fn) {
-        collectTask(name, fn, 'run');
-    }
-    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;
@@ -64,11 +60,66 @@ function createSuiteCollector(name, factory = () => { }, mode) {
     context.suites.push(collector);
     return collector;
 }
+function createConcurrentOptions(timeout) {
+    return { timeout: timeout !== null && timeout !== void 0 ? timeout : defaultConcurrentTimeout };
+}
+function createTestCollector(collectTask) {
+    function test(name, fn) {
+        collectTask(name, fn, 'run');
+    }
+    test.concurrent = concurrent;
+    test.skip = skip;
+    test.only = only;
+    test.todo = todo;
+    function concurrent(name, fn, timeout) {
+        collectTask(name, fn, 'run', createConcurrentOptions(timeout));
+    }
+    concurrent.skip = (name, fn, timeout) => collectTask(name, fn, 'skip', createConcurrentOptions(timeout));
+    concurrent.only = (name, fn, timeout) => collectTask(name, fn, 'only', createConcurrentOptions(timeout));
+    concurrent.todo = todo;
+    function skip(name, fn) {
+        collectTask(name, fn, 'skip');
+    }
+    skip.concurrent = concurrent.skip;
+    function only(name, fn) {
+        collectTask(name, fn, 'only');
+    }
+    only.concurrent = concurrent.only;
+    function todo(name) {
+        collectTask(name, () => { }, 'todo');
+    }
+    todo.concurrent = todo;
+    return test;
+}
 // 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 const test = (function () {
+    function test(name, fn) {
+        return getCurrentSuite().test(name, fn);
+    }
+    function concurrent(name, fn, timeout) {
+        return getCurrentSuite().test.concurrent(name, fn, timeout);
+    }
+    concurrent.skip = (name, fn, timeout) => getCurrentSuite().test.concurrent.skip(name, fn, timeout);
+    concurrent.only = (name, fn, timeout) => getCurrentSuite().test.concurrent.only(name, fn, timeout);
+    concurrent.todo = (name) => getCurrentSuite().test.concurrent.todo(name);
+    function skip(name, fn) {
+        return getCurrentSuite().test.skip(name, fn);
+    }
+    skip.concurrent = (name, fn, timeout) => getCurrentSuite().test.skip.concurrent(name, fn, timeout);
+    function only(name, fn) {
+        return getCurrentSuite().test.only(name, fn);
+    }
+    only.concurrent = (name, fn, timeout) => getCurrentSuite().test.only.concurrent(name, fn, timeout);
+    function todo(name) {
+        return getCurrentSuite().test.todo(name);
+    }
+    todo.concurrent = (name) => getCurrentSuite().test.todo.concurrent(name);
+    test.concurrent = concurrent;
+    test.skip = skip;
+    test.only = only;
+    test.todo = todo;
+    return test;
+})();
 export function suite(suiteName, factory) {
     return createSuiteCollector(suiteName, factory, 'run');
 }

package/dist/types.d.ts

@@ -64,9 +64,13 @@ export interface ResolvedConfig extends Required<UserOptions> {
 }
 export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 export declare type TaskState = RunMode | 'pass' | 'fail';
+export interface ConcurrentOptions {
+    timeout: number;
+}
 export interface Task {
     name: string;
     mode: RunMode;
+    concurrent?: ConcurrentOptions;
     suite: Suite;
     fn: () => Awaitable<void>;
     file?: File;
@@ -74,11 +78,30 @@ export interface Task {
     error?: unknown;
 }
 export declare type TestFunction = () => Awaitable<void>;
+interface ConcurrentCollector {
+    (name: string, fn: TestFunction, timeout?: number): void;
+    only: (name: string, fn: TestFunction, timeout?: number) => void;
+    skip: (name: string, fn: TestFunction, timeout?: number) => void;
+    todo: (name: string) => void;
+}
+interface OnlyCollector {
+    (name: string, fn: TestFunction): void;
+    concurrent: (name: string, fn: TestFunction, timeout?: number) => void;
+}
+interface SkipCollector {
+    (name: string, fn: TestFunction): void;
+    concurrent: (name: string, fn: TestFunction, timeout?: number) => void;
+}
+interface TodoCollector {
+    (name: string): void;
+    concurrent: (name: string) => 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;
+    concurrent: ConcurrentCollector;
+    only: OnlyCollector;
+    skip: SkipCollector;
+    todo: TodoCollector;
 }
 export declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
 export interface Suite {
@@ -136,3 +159,4 @@ export interface Reporter {
     onWatcherStart?: (ctx: RunnerContext) => Awaitable<void>;
     onWatcherRerun?: (files: string[], trigger: string, ctx: RunnerContext) => Awaitable<void>;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",