vitest 0.0.25 → 0.0.29

package/README.gh.md

@@ -9,6 +9,8 @@ A blazing fast unit test framework powered by Vite.
 
 > ⚠️ **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
+
 ## Features
 
 - [Vite](https://vitejs.dev/)'s config, transformers, resolvers, and plugins.
@@ -114,10 +116,25 @@ export default defineConfig({
 $ vitest -w
 ```
 
-Vitest will smartly search for the module graph to only rerun the related tests.
+Vitest smartly searches the module graph and only rerun the related tests (just like how HMR works in Vite!).
 
 ## Filtering
 
+### CLI
+
+You can use CLI to filter test files my name:
+
+```bash
+$ vitest basic
+```
+
+Will only execute test files that contain `basic`, e.g.
+
+```
+basic.test.ts
+basic-foo.test.ts
+```
+
 ### Skipping suites and tasks
 
 Use `.skip` to avoid running certain suites or tests 

package/dist/index.d.ts

@@ -19,6 +19,8 @@ declare global {
             toEqual(expected: any): void;
             toStrictEqual(expected: any): void;
             toBe(expected: any): void;
+            toMatch(expected: string | RegExp): void;
+            toMatchObject(expected: any): void;
             toContain(item: any): void;
             toBeTruthy(): void;
             toBeFalsy(): void;
@@ -27,10 +29,10 @@ declare global {
             toBeNull(): void;
             toBeDefined(): void;
             toBeInstanceOf(c: any): void;
-            toBeCalledTimes(n: number): void;
-            toBeCalledOnce(): void;
-            toBeCalled(): void;
+            toHaveBeenCalledTimes(n: number): void;
+            toHaveBeenCalledOnce(): void;
             toHaveBeenCalled(): void;
+            toHaveBeenCalledWith(...args: any[]): void;
         }
         interface ExpectStatic {
             addSnapshotSerializer: import('pretty-format').Plugin;

package/dist/integrations/chai/jest-expect.js

@@ -12,6 +12,15 @@ export function JestChaiExpect() {
         utils.addMethod(proto, 'toBe', function (expected) {
             return this.equal(expected);
         });
+        utils.addMethod(proto, 'toMatchObject', function (expected) {
+            return this.containSubset(expected);
+        });
+        utils.addMethod(proto, 'toMatch', function (expected) {
+            if (typeof expected === 'string')
+                return this.include(expected);
+            else
+                return this.match(expected);
+        });
         utils.addMethod(proto, 'toContain', function (item) {
             return this.contain(item);
         });
@@ -39,17 +48,20 @@ export function JestChaiExpect() {
             return this.instanceOf(obj);
         });
         // mock
-        utils.addMethod(proto, 'toBeCalledTimes', function (number) {
+        utils.addMethod(proto, 'toHaveBeenCalledTimes', function (number) {
             return this.callCount(number);
         });
-        utils.addMethod(proto, 'toBeCalledOnce', function () {
+        utils.addMethod(proto, 'toHaveBeenCalledOnce', function () {
             return this.callCount(1);
         });
-        utils.addMethod(proto, 'toBeCalled', function () {
+        utils.addMethod(proto, 'toHaveBeenCalled', function () {
             return this.called;
         });
         utils.addMethod(proto, 'toHaveBeenCalled', function () {
             return this.called;
         });
+        utils.addMethod(proto, 'toHaveBeenCalledWith', function (...args) {
+            return this.calledWith(...args);
+        });
     };
 }

package/dist/integrations/chai/setup.js

@@ -1,9 +1,11 @@
 import chai from 'chai';
 import SinonChai from 'sinon-chai';
+import Subset from 'chai-subset';
 import { JestChaiExpect } from './jest-expect';
 import { SnapshotPlugin } from './snapshot';
 export async function setupChai(config) {
     chai.use(SinonChai);
     chai.use(JestChaiExpect());
+    chai.use(Subset);
     chai.use(await SnapshotPlugin(config));
 }

package/dist/node/cli.js

@@ -19,13 +19,18 @@ sade('vitest [filter]', true)
     .option('--global', 'inject apis globally', false)
     .option('--dev', 'dev mode', false)
     .option('--jsdom', 'mock browser api using JSDOM', false)
-    .action(async (filters, options) => {
+    .action(async (filters, argv) => {
     process.env.VITEST = 'true';
+    const defaultInline = [
+        'vue',
+        '@vue',
+    ];
     const __dirname = dirname(fileURLToPath(import.meta.url));
-    const root = resolve(options.root || process.cwd());
-    const configPath = options.config
-        ? resolve(root, options.config)
+    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 });
+    const options = argv;
     options.config = configPath;
     options.root = root;
     options.filters = filters
@@ -39,7 +44,7 @@ sade('vitest [filter]', true)
     await startViteNode({
         root,
         files: [
-            resolve(__dirname, options.dev ? '../../src/node/entry.ts' : './entry.js'),
+            resolve(__dirname, argv.dev ? '../../src/node/entry.ts' : './entry.js'),
         ],
         config: configPath,
         defaultConfig: {
@@ -49,11 +54,31 @@ sade('vitest [filter]', true)
                 ],
             },
         },
-        shouldExternalize(id) {
-            if (id.includes('/node_modules/vitest/'))
-                return false;
-            else
-                return id.includes('/node_modules/');
+        shouldExternalize(id, server) {
+            var _a, _b, _c, _d;
+            const inline = ['vitest', ...defaultInline, ...((_b = (_a = server.config.test) === null || _a === void 0 ? void 0 : _a.deps) === null || _b === void 0 ? void 0 : _b.inline) || []];
+            const external = ((_d = (_c = server.config.test) === null || _c === void 0 ? void 0 : _c.deps) === null || _d === void 0 ? void 0 : _d.external) || [];
+            for (const ex of inline) {
+                if (typeof ex === 'string') {
+                    if (id.includes(`/node_modules/${ex}/`))
+                        return false;
+                }
+                else {
+                    if (ex.test(id))
+                        return false;
+                }
+            }
+            for (const ex of external) {
+                if (typeof ex === 'string') {
+                    if (id.includes(`/node_modules/${ex}/`))
+                        return true;
+                }
+                else {
+                    if (ex.test(id))
+                        return true;
+                }
+            }
+            return id.includes('/node_modules/');
         },
     });
 })

package/dist/node/entry.js

@@ -3,4 +3,5 @@ if (!process.__vite_node__ || !process.__vitest__)
     throw new Error('Vitest can only run in vite-node environment, please use the CLI to start the process');
 const inlineOptions = process.__vite_node__.server.config.test || {};
 const cliOptions = process.__vitest__.options || {};
-await run(Object.assign(Object.assign({}, inlineOptions), cliOptions));
+const options = Object.assign(Object.assign({}, cliOptions), inlineOptions);
+await run(options);

package/dist/node/node.d.ts

@@ -15,7 +15,7 @@ export interface ViteNodeOptions {
     root: string;
     files: string[];
     _?: string[];
-    shouldExternalize?: (file: string) => boolean;
+    shouldExternalize?: (file: string, server: ViteDevServer) => boolean;
     config?: string;
     defaultConfig?: InlineConfig;
 }

package/dist/node/node.js

@@ -42,6 +42,8 @@ function normalizeId(id) {
         id = `\0${id.slice('/@id/__x00__'.length)}`;
     if (id && id.startsWith('/@id/'))
         id = id.slice('/@id/'.length);
+    if (id.startsWith('__vite-browser-external:'))
+        id = id.slice('__vite-browser-external:'.length);
     return id;
 }
 function toFilePath(id, server) {
@@ -58,6 +60,29 @@ function toFilePath(id, server) {
         absolute = `/${absolute}`;
     return absolute;
 }
+const stubRequests = {
+    '/@vite/client': {
+        injectQuery: (id) => id,
+        createHotContext() {
+            return {
+                accept: () => { },
+            };
+        },
+    },
+};
+async function transform(server, id) {
+    if (id.match(/\.(?:[cm]?[jt]sx?|json)$/)) {
+        return await server.transformRequest(id, { ssr: true });
+    }
+    else {
+        // for components like Vue, we want to use the client side
+        // plugins but then covert the code to be consumed by the server
+        const result = await server.transformRequest(id);
+        if (!result)
+            return undefined;
+        return await server.ssrTransform(result.code, result.map, id);
+    }
+}
 async function execute(files, server, options) {
     const result = [];
     for (const file of files)
@@ -74,7 +99,9 @@ async function execute(files, server, options) {
             }
             return cachedRequest(dep, callstack);
         };
-        const result = await server.transformRequest(id, { ssr: true });
+        if (id in stubRequests)
+            return stubRequests[id];
+        const result = await transform(server, id);
         if (!result)
             throw new Error(`failed to load ${id}`);
         const url = pathToFileURL(fsPath);
@@ -97,11 +124,11 @@ async function execute(files, server, options) {
         return exports;
     }
     async function cachedRequest(rawId, callstack) {
-        if (builtinModules.includes(rawId))
-            return import(rawId);
         const id = normalizeId(rawId);
+        if (builtinModules.includes(id))
+            return import(id);
         const fsPath = toFilePath(id, server);
-        if (options.shouldExternalize(fsPath))
+        if (options.shouldExternalize(fsPath, server))
             return import(fsPath);
         if (__pendingModules__.has(fsPath))
             return __pendingModules__.get(fsPath);

package/dist/reporters/default.d.ts

@@ -1,5 +1,5 @@
 import Listr from 'listr';
-import { File, Reporter, RunnerContext, Task } from '../types';
+import { File, Reporter, RunnerContext, Task, ResolvedConfig } from '../types';
 interface TaskPromise {
     promise: Promise<void>;
     resolve: () => void;
@@ -11,6 +11,9 @@ export declare class DefaultReporter implements Reporter {
     listr: Listr | null;
     listrPromise: Promise<void> | null;
     taskMap: Map<Task, TaskPromise>;
+    cwd: string;
+    relative(path: string): string;
+    onStart(config: ResolvedConfig): void;
     onCollected(files: File[]): void;
     onTaskEnd(task: Task): void;
     onFinished(ctx: RunnerContext): Promise<void>;

package/dist/reporters/default.js

@@ -11,6 +11,14 @@ export class DefaultReporter {
         this.listr = null;
         this.listrPromise = null;
         this.taskMap = new Map();
+        this.cwd = process.cwd();
+    }
+    relative(path) {
+        return relative(this.cwd, path);
+    }
+    onStart(config) {
+        this.cwd = config.root;
+        console.log(c.green(`Running tests under ${c.gray(this.cwd)}\n`));
     }
     onCollected(files) {
         this.start = performance.now();
@@ -41,9 +49,14 @@ export class DefaultReporter {
         };
         this.listr = new Listr(files.map((file) => {
             return {
-                title: relative(process.cwd(), file.filepath),
+                title: this.relative(file.filepath),
                 task: () => {
-                    return new Listr(file.suites.flatMap((suite) => {
+                    if (file.error)
+                        throw file.error;
+                    const suites = file.suites.filter(i => i.tasks.length);
+                    if (!suites.length)
+                        throw new Error('No tasks found');
+                    return new Listr(suites.flatMap((suite) => {
                         if (!suite.name)
                             return createTasksListr(suite.tasks);
                         return [{
@@ -122,7 +135,7 @@ export class DefaultReporter {
     async onWatcherRerun(files, trigger) {
         await this.listrPromise;
         console.clear();
-        console.log(c.blue('Re-running tests...') + c.dim(` [ ${relative(process.cwd(), trigger)} ]\n`));
+        console.log(c.blue('Re-running tests...') + c.dim(` [ ${this.relative(trigger)} ]\n`));
     }
     // TODO:
     onSnapshotUpdate() {

package/dist/run/index.js

@@ -98,9 +98,8 @@ export async function runSuite(suite, ctx) {
     else {
         try {
             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)
+            for (const t of suite.tasks)
+                await runTask(t, ctx);
             await callHook(suite, 'afterAll', [suite]);
         }
         catch (e) {

package/dist/types.d.ts

@@ -11,6 +11,13 @@ export interface UserOptions {
      * @default ['**\/node_modules\/**']
      */
     excludes?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     */
+    deps?: {
+        external?: (string | RegExp)[];
+        inline?: (string | RegExp)[];
+    };
     /**
      * Register apis globally
      *
@@ -52,6 +59,7 @@ export interface UserOptions {
 }
 export interface ResolvedConfig extends Required<UserOptions> {
     filters?: string[];
+    config?: string;
 }
 export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 export declare type TaskState = RunMode | 'pass' | 'fail';
@@ -114,7 +122,7 @@ export interface GlobalContext {
     currentSuite: SuiteCollector | null;
 }
 export interface Reporter {
-    onStart?: (userOptions: ResolvedConfig) => Awaitable<void>;
+    onStart?: (config: ResolvedConfig) => Awaitable<void>;
     onCollected?: (files: File[], ctx: RunnerContext) => Awaitable<void>;
     onFinished?: (ctx: RunnerContext) => Awaitable<void>;
     onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.25",
+  "version": "0.0.29",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -44,8 +44,9 @@
     "lint": "eslint \"{src,test}/**/*.ts\"",
     "prepublishOnly": "nr build",
     "release": "bumpp --commit --push --tag && esmo scripts/publish.ts",
-    "test": "node bin/vitest.mjs --dev",
-    "test:update": "nr test -u",
+    "test": "run-s test:*",
+    "test:core": "node bin/vitest.mjs --dev -r test/core",
+    "test:vue": "node bin/vitest.mjs --dev -r test/vue",
     "watch": "tsc -p src/tsconfig.json --watch"
   },
   "dependencies": {
@@ -53,6 +54,7 @@
     "@types/chai": "^4.2.22",
     "@types/sinon-chai": "^3.2.6",
     "chai": "^4.3.4",
+    "chai-subset": "^1.6.0",
     "fast-glob": "^3.2.7",
     "find-up": "^6.2.0",
     "jest-snapshot": "^27.4.2",
@@ -64,19 +66,26 @@
     "sinon": "^12.0.1",
     "sinon-chai": "^3.7.0"
   },
+  "peerDependencies": {
+    "vite": "^2.7.0"
+  },
   "devDependencies": {
     "@antfu/eslint-config": "^0.12.1",
     "@antfu/ni": "^0.11.0",
+    "@types/chai-subset": "^1.3.3",
     "@types/jsdom": "^16.2.13",
     "@types/listr": "^0.14.4",
     "@types/node": "^16.11.11",
     "@types/sade": "^1.7.3",
     "@types/sinon": "^10.0.6",
+    "@vitejs/plugin-vue": "^1.10.1",
     "bumpp": "^7.1.1",
     "eslint": "^8.4.0",
     "esno": "^0.12.1",
+    "npm-run-all": "^4.1.5",
     "rimraf": "^3.0.2",
     "typescript": "^4.5.2",
-    "vite": "^2.6.14"
+    "vite": "^2.7.0",
+    "vue": "^3.2.24"
   }
 }