vitest 0.0.30 → 0.0.34

package/README.gh.md

@@ -1,27 +1,41 @@
-# 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.
 
 > Vitest requires Vite v2.7.0 or above
 
+[**Join the Discord!**](https://discord.com/invite/2zYZNngd7y)
+
 ## 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/) for assertions
-- [Sinon](https://sinonjs.org/) for mocking
-- [JSDOM](https://github.com/jsdom/jsdom) for DOM mocking
+- [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 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 support
+- Out-of-box TypeScript / JSX support
 - Suite and Test filtering (skip, only, todo)
+- Concurrent Tests
 
 ```ts
 import { it, describe, expect, assert } from 'vitest'
@@ -46,6 +60,12 @@ describe('suite name', () => {
 $ npx vitest
 ```
 
+## Examples
+
+- [Unit Testing](./test/core)
+- [Vue Component Testing](./test/vue)
+- [React Component Testing](./test/react)
+
 ## Configuration
 
 `vitest` will read your root `vite.config.ts` when it present to match with the plugins and setup as your Vite app. If you want to it to have a different configuration for testing, you could either:
@@ -84,7 +104,7 @@ export default defineConfig({
 
 To get TypeScript working with the global APIs, add `vitest/global` to the `types` filed in your `tsconfig.json`
 
-```json
+```jsonc
 // tsconfig.json
 {
   "compilerOptions": {
@@ -118,6 +138,31 @@ $ vitest -w
 
 Vitest smartly searches the module graph and only rerun the related tests (just like how HMR works in Vite!).
 
+## Coverage
+
+Vitest works perfectly with [c8](https://github.com/bcoe/c8)
+
+```bash
+$ c8 vitest
+```
+
+```json
+{
+  "scripts": {
+    "test": "vitest",
+    "coverage": "c8 vitest"
+  }
+}
+```
+
+For convenience, we also provide a shorthand for passing `--coverage` option to CLI, which will wrap the process with `c8` for you. Note when using the shorthand, you will lose the ability to pass additional options to `c8`.
+
+```bash
+$ vitest --coverage
+```
+
+For more configuration avaliable, please refer to [c8](https://github.com/bcoe/c8)'s documentation.
+
 ## Filtering
 
 ### CLI
@@ -194,18 +239,38 @@ describe('suite', () => {
 })
 ```
 
-## TODO
+### 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(...)
 
-- [x] Reporter & Better output
-- [x] Task filter
-- [x] Mock
-- [x] Global Mode & Types
-- [ ] Parallel Executing
-- [x] CLI Help
-- [x] JSDom
-- [x] Watch
-- [ ] Source Map
-- [ ] Coverage
+it.only.concurrent(...)
+it.concurrent.only(...)
+
+it.todo.concurrent(...)
+it.concurrent.todo(...)
+```
 
 ## Sponsors
 

package/bin/vitest.mjs

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
-'use strict'
 
-import '../dist/node/cli.js'
+import { fileURLToPath } from 'url'
+import { resolve } from 'path'
+
+const argv = process.argv.slice(2)
+const filename = fileURLToPath(import.meta.url)
+const entry = resolve(filename, '../../dist/node/cli.js')
+
+if (argv.includes('--coverage')) {
+  process.argv.splice(2, 0, process.argv[0], entry)
+  await import('c8/bin/c8.js')
+}
+else {
+  await import('../dist/node/cli.js')
+}

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/entry.js

@@ -5,3 +5,8 @@ const inlineOptions = process.__vite_node__.server.config.test || {};
 const cliOptions = process.__vitest__.options || {};
 const options = Object.assign(Object.assign({}, cliOptions), inlineOptions);
 await run(options);
+const timer = setTimeout(() => {
+    // TODO: warn user and maybe error out
+    process.exit();
+}, 500);
+timer.unref();

package/dist/node/node.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;
@@ -185,7 +211,7 @@ export async function run(config) {
     snapshotManager.saveSnap();
     await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
     if (config.watch)
-        startWatcher(ctx);
+        await startWatcher(ctx);
 }
 export async function startWatcher(ctx) {
     var _a;
@@ -196,6 +222,7 @@ export async function startWatcher(ctx) {
     const seen = new Set();
     const { server, moduleCache } = process.__vite_node__;
     server.watcher.on('change', async (id) => {
+        id = normalizePath(id);
         getDependencyTests(id, ctx, changedTests, seen);
         seen.forEach(i => moduleCache.delete(i));
         seen.clear();
@@ -219,6 +246,14 @@ export async function startWatcher(ctx) {
             await ((_c = reporter.onWatcherStart) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
         }, 100);
     });
+    // add an empty promise so it never resolves
+    await new Promise(() => { });
+}
+function normalizePath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    if (normalized.startsWith('/'))
+        return normalized;
+    return `/${normalized}`;
 }
 function getDependencyTests(id, ctx, set = new Set(), seen = new Set()) {
     if (seen.has(id) || set.has(id))

package/dist/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.30",
+  "version": "0.0.34",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -47,6 +47,8 @@
     "test": "run-s test:*",
     "test:core": "node bin/vitest.mjs --dev -r test/core",
     "test:vue": "node bin/vitest.mjs --dev -r test/vue",
+    "test:react": "node bin/vitest.mjs --dev -r test/react",
+    "coverage": "node bin/vitest.mjs --dev -r test/core --coverage",
     "watch": "tsc -p src/tsconfig.json --watch"
   },
   "dependencies": {
@@ -54,6 +56,7 @@
     "@jest/test-result": "^27.4.2",
     "@types/chai": "^4.2.22",
     "@types/sinon-chai": "^3.2.6",
+    "c8": "^7.10.0",
     "chai": "^4.3.4",
     "chai-subset": "^1.6.0",
     "diff": "^5.0.0",
@@ -70,26 +73,24 @@
     "source-map": "^0.7.3"
   },
   "peerDependencies": {
-    "vite": "^2.7.0"
+    "vite": "^2.7.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.12.1",
+    "@antfu/eslint-config": "^0.12.2",
     "@antfu/ni": "^0.11.0",
     "@types/chai-subset": "^1.3.3",
     "@types/diff": "^5.0.1",
     "@types/jsdom": "^16.2.13",
     "@types/listr": "^0.14.4",
-    "@types/node": "^16.11.11",
+    "@types/node": "^16.11.12",
     "@types/sade": "^1.7.3",
     "@types/sinon": "^10.0.6",
-    "@vitejs/plugin-vue": "^1.10.1",
     "bumpp": "^7.1.1",
-    "eslint": "^8.4.0",
+    "eslint": "^8.4.1",
     "esno": "^0.12.1",
     "npm-run-all": "^4.1.5",
     "rimraf": "^3.0.2",
     "typescript": "^4.5.2",
-    "vite": "^2.7.0",
-    "vue": "^3.2.24"
+    "vite": "^2.7.1"
   }
 }