vitest 0.0.33 → 0.0.37

package/dist/reporters/default.js

@@ -1,149 +0,0 @@
-/* eslint-disable no-console */
-import { performance } from 'perf_hooks';
-import { relative } from 'path';
-import c from 'picocolors';
-import Listr from 'listr';
-import { printError } from './error';
-const CROSS = '✖ ';
-export class DefaultReporter {
-    constructor() {
-        this.start = 0;
-        this.end = 0;
-        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();
-        this.taskMap = new Map();
-        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
-        tasks.forEach((t) => {
-            const obj = {};
-            obj.promise = new Promise((resolve, reject) => {
-                obj.resolve = resolve;
-                obj.reject = reject;
-            });
-            this.taskMap.set(t, obj);
-        });
-        const createTasksListr = (tasks) => {
-            return tasks.map((task) => {
-                return {
-                    title: task.name,
-                    skip: () => task.mode === 'skip',
-                    task: async () => {
-                        var _a;
-                        return await ((_a = this.taskMap.get(task)) === null || _a === void 0 ? void 0 : _a.promise);
-                    },
-                };
-            });
-        };
-        const listrOptions = {
-            exitOnError: false,
-        };
-        this.listr = new Listr(files.map((file) => {
-            return {
-                title: this.relative(file.filepath),
-                task: () => {
-                    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 [{
-                                title: suite.name,
-                                skip: () => suite.mode !== 'run',
-                                task: () => new Listr(createTasksListr(suite.tasks), listrOptions),
-                            }];
-                    }), listrOptions);
-                },
-            };
-        }), listrOptions);
-        this.listrPromise = this.listr.run().catch(() => { });
-    }
-    onTaskEnd(task) {
-        var _a, _b;
-        if (task.state === 'fail')
-            (_a = this.taskMap.get(task)) === null || _a === void 0 ? void 0 : _a.reject(task.error);
-        else
-            (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
-    }
-    async onFinished(ctx, files = ctx.files) {
-        var _a;
-        await this.listrPromise;
-        this.end = performance.now();
-        console.log();
-        const snapshot = ctx.snapshotManager.report();
-        if (snapshot)
-            console.log(snapshot.join('\n'));
-        const suites = files.flatMap(i => i.suites);
-        const tasks = suites.flatMap(i => i.tasks);
-        const failedFiles = files.filter(i => i.error);
-        const failedSuites = suites.filter(i => i.error);
-        const runnable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
-        const passed = tasks.filter(i => i.state === 'pass');
-        const failed = tasks.filter(i => i.state === 'fail');
-        const skipped = tasks.filter(i => i.state === 'skip');
-        const todo = tasks.filter(i => i.state === 'todo');
-        if (failedFiles.length) {
-            console.error(c.red(c.bold(`\nFailed to parse ${failedFiles.length} files:`)));
-            for (const file of failedFiles)
-                console.error(c.red(`- ${file.filepath}`));
-            console.log();
-            for (const file of failedFiles) {
-                await printError(file.error);
-                console.log();
-            }
-        }
-        if (failedSuites.length) {
-            console.error(c.bold(c.red(`\nFailed to run ${failedSuites.length} suites:`)));
-            for (const suite of failedSuites) {
-                console.error(c.red(`\n- ${(_a = suite.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${suite.name}`));
-                await printError(suite.error);
-                console.log();
-            }
-        }
-        if (failed.length) {
-            console.error(c.bold(c.red(`\nFailed Tests (${failed.length})`)));
-            for (const task of failed) {
-                console.error(`${c.red(`\n${CROSS + c.inverse(' FAIL ')}`)} ${[task.suite.name, task.name].filter(Boolean).join(' > ')}`);
-                await printError(task.error);
-                console.log();
-            }
-        }
-        console.log(c.bold(c.green(`Passed   ${passed.length} / ${runnable.length}`)));
-        if (failed.length)
-            console.log(c.bold(c.red(`Failed   ${failed.length} / ${runnable.length}`)));
-        if (skipped.length)
-            console.log(c.yellow(`Skipped  ${skipped.length}`));
-        if (todo.length)
-            console.log(c.dim(`Todo     ${todo.length}`));
-        console.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
-    }
-    async onWatcherStart(ctx) {
-        await this.listrPromise;
-        const failed = ctx.tasks.filter(i => i.state === 'fail');
-        if (failed.length)
-            console.log(`\n${c.bold(c.inverse(c.red(' FAIL ')))}${c.red(` ${failed.length} tests failed. Watching for file changes...`)}`);
-        else
-            console.log(`\n${c.bold(c.inverse(c.green(' PASS ')))}${c.green(' Watching for file changes...')}`);
-    }
-    async onWatcherRerun(files, trigger) {
-        await this.listrPromise;
-        console.clear();
-        console.log(c.blue('Re-running tests...') + c.dim(` [ ${this.relative(trigger)} ]\n`));
-    }
-    // TODO:
-    onSnapshotUpdate() {
-    }
-}

package/dist/reporters/error.d.ts

@@ -1,9 +0,0 @@
-export declare function printError(error: unknown): Promise<void>;
-interface Poisition {
-    line: number;
-    column: number;
-}
-export declare function posToNumber(source: string, pos: number | Poisition): number;
-export declare function numberToPos(source: string, offset: number | Poisition): Poisition;
-export declare function generateCodeFrame(source: string, start?: number | Poisition, end?: number, range?: number): string;
-export {};

package/dist/reporters/error.js

@@ -1,182 +0,0 @@
-/* eslint-disable no-console */
-import { promises as fs, existsSync } from 'fs';
-import c from 'picocolors';
-import * as diff from 'diff';
-import { notNullish } from '@antfu/utils';
-import { SourceMapConsumer } from 'source-map';
-export async function printError(error) {
-    if (!(error instanceof Error)) {
-        console.error(error);
-        return;
-    }
-    const { modulesTransformResult } = process.__vite_node__;
-    const e = error;
-    let codeFramePrinted = false;
-    const stacks = parseStack(e.stack || '');
-    const nearest = stacks.find(stack => modulesTransformResult.has(stack.file));
-    if (nearest) {
-        const transformResult = modulesTransformResult.get(nearest.file);
-        const pos = await getOriginalPos(transformResult === null || transformResult === void 0 ? void 0 : transformResult.map, nearest);
-        if (pos && existsSync(nearest.file)) {
-            const sourceCode = await fs.readFile(nearest.file, 'utf-8');
-            console.error(`${c.red(`${c.bold(e.name)}: ${e.message}`)}`);
-            console.log(c.gray(`${nearest.file}:${pos.line}:${pos.column}`));
-            console.log(c.yellow(generateCodeFrame(sourceCode, pos)));
-            codeFramePrinted = true;
-        }
-    }
-    if (!codeFramePrinted)
-        console.error(e);
-    if (e.showDiff)
-        console.error(c.gray(generateDiff(stringify(e.actual), stringify(e.expected))));
-}
-function getOriginalPos(map, { line, column }) {
-    return new Promise((resolve) => {
-        if (!map)
-            return resolve(null);
-        SourceMapConsumer.with(map, null, (consumer) => {
-            const pos = consumer.originalPositionFor({ line, column });
-            if (pos.line != null && pos.column != null)
-                resolve(pos);
-            else
-                resolve(null);
-        });
-    });
-}
-const splitRE = /\r?\n/;
-export function posToNumber(source, pos) {
-    if (typeof pos === 'number')
-        return pos;
-    const lines = source.split(splitRE);
-    const { line, column } = pos;
-    let start = 0;
-    for (let i = 0; i < line - 1; i++)
-        start += lines[i].length + 1;
-    return start + column;
-}
-export function numberToPos(source, offset) {
-    if (typeof offset !== 'number')
-        return offset;
-    if (offset > source.length) {
-        throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
-    }
-    const lines = source.split(splitRE);
-    let counted = 0;
-    let line = 0;
-    let column = 0;
-    for (; line < lines.length; line++) {
-        const lineLength = lines[line].length + 1;
-        if (counted + lineLength >= offset) {
-            column = offset - counted + 1;
-            break;
-        }
-        counted += lineLength;
-    }
-    return { line: line + 1, column };
-}
-export function generateCodeFrame(source, start = 0, end, range = 2) {
-    start = posToNumber(source, start);
-    end = end || start;
-    const lines = source.split(splitRE);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                const line = j + 1;
-                res.push(`${c.gray(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}|`)}  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
-                    res.push(`${c.gray('   |')}  ${' '.repeat(pad)}${'^'.repeat(length)}`);
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.max(Math.min(end - count, lineLength), 1);
-                        res.push(`${c.gray('   |')}  ${'^'.repeat(length)}`);
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function stringify(obj) {
-    // TODO: handle more types
-    return String(obj);
-}
-const stackFnCallRE = /at (.*) \((.+):(\d+):(\d+)\)$/;
-const stackBarePathRE = /at ()(.+):(\d+):(\d+)$/;
-function parseStack(stack) {
-    const lines = stack.split('\n');
-    const stackFrames = lines.map((raw) => {
-        const line = raw.trim();
-        const match = line.match(stackFnCallRE) || line.match(stackBarePathRE);
-        if (!match)
-            return null;
-        let file = match[2];
-        if (file.startsWith('file://'))
-            file = file.slice(7);
-        return {
-            method: match[1],
-            file: match[2],
-            line: parseInt(match[3]),
-            column: parseInt(match[4]),
-        };
-    });
-    return stackFrames.filter(notNullish);
-}
-/**
- * Returns a diff between 2 strings with coloured ANSI output.
- *
- * @description
- * The diff will be either inline or unified dependent on the value
- * of `Base.inlineDiff`.
- *
- * @param {string} actual
- * @param {string} expected
- * @return {string} Diff
- */
-function generateDiff(actual, expected) {
-    const diffSize = 2048;
-    if (actual.length > diffSize)
-        actual = `${actual.substring(0, diffSize)} ... Lines skipped`;
-    if (expected.length > diffSize)
-        expected = `${expected.substring(0, diffSize)} ... Lines skipped`;
-    return unifiedDiff(actual, expected);
-}
-/**
- * Returns unified diff between two strings with coloured ANSI output.
- *
- * @private
- * @param {String} actual
- * @param {String} expected
- * @return {string} The diff.
- */
-function unifiedDiff(actual, expected) {
-    const indent = '  ';
-    function cleanUp(line) {
-        if (line[0] === '+')
-            return indent + c.green(`${line[0]} ${line.slice(1)}`);
-        if (line[0] === '-')
-            return indent + c.red(`${line[0]} ${line.slice(1)}`);
-        if (line.match(/@@/))
-            return '--';
-        if (line.match(/\\ No newline/))
-            return null;
-        return indent + line;
-    }
-    const msg = diff.createPatch('string', actual, expected);
-    const lines = msg.split('\n').splice(5);
-    return (`\n${indent}${c.red('- actual')}\n${indent}${c.green('+ expected')}\n\n${lines.map(cleanUp).filter(notBlank).join('\n')}`);
-}
-function notBlank(line) {
-    return typeof line !== 'undefined' && line !== null;
-}

package/dist/run/index.d.ts

@@ -1,8 +0,0 @@
-import { File, ResolvedConfig, Task, RunnerContext, Suite } from '../types';
-export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
-export declare function collectFiles(paths: string[]): Promise<Record<string, File>>;
-export declare function runSuite(suite: Suite, ctx: RunnerContext): Promise<void>;
-export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
-export declare function runFiles(filesMap: Record<string, File>, ctx: RunnerContext): Promise<void>;
-export declare function run(config: ResolvedConfig): Promise<void>;
-export declare function startWatcher(ctx: RunnerContext): Promise<void>;

package/dist/run/index.js

@@ -1,248 +0,0 @@
-import fg from 'fast-glob';
-import { setupChai } from '../integrations/chai/setup';
-import { clearContext, defaultSuite } from '../suite';
-import { context } from '../context';
-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, _c;
-    const { reporter } = 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') {
-        try {
-            await callHook(task.suite, 'beforeEach', [task, task.suite]);
-            await task.fn();
-            task.state = 'pass';
-        }
-        catch (e) {
-            task.state = 'fail';
-            task.error = e;
-            process.exitCode = 1;
-        }
-        try {
-            await callHook(task.suite, 'afterEach', [task, task.suite]);
-        }
-        catch (e) {
-            task.state = 'fail';
-            task.error = e;
-            process.exitCode = 1;
-        }
-    }
-    await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
-}
-export async function collectFiles(paths) {
-    const files = {};
-    for (const filepath of paths) {
-        const file = {
-            filepath,
-            suites: [],
-            collected: false,
-        };
-        clearContext();
-        try {
-            await import(filepath);
-            const collectors = [defaultSuite, ...context.suites];
-            for (const c of collectors) {
-                context.currentSuite = c;
-                file.suites.push(await c.collect(file));
-            }
-            file.collected = true;
-        }
-        catch (e) {
-            file.error = e;
-            file.collected = false;
-            process.exitCode = 1;
-        }
-        files[filepath] = file;
-    }
-    const allFiles = Object.values(files);
-    const allSuites = allFiles.reduce((suites, file) => suites.concat(file.suites), []);
-    interpretOnlyMode(allSuites);
-    allSuites.forEach((i) => {
-        if (i.mode === 'skip')
-            i.tasks.forEach(t => t.mode === 'run' && (t.mode = 'skip'));
-        else
-            interpretOnlyMode(i.tasks);
-        i.tasks.forEach(t => t.mode === 'skip' && (t.state = 'skip'));
-    });
-    return files;
-}
-/**
- * If any items been marked as `only`, mark all other items as `skip`.
- */
-function interpretOnlyMode(items) {
-    if (items.some(i => i.mode === 'only')) {
-        items.forEach((i) => {
-            if (i.mode === 'run')
-                i.mode = 'skip';
-            else if (i.mode === 'only')
-                i.mode = 'run';
-        });
-    }
-}
-export async function runSuite(suite, ctx) {
-    var _a, _b;
-    const { reporter } = ctx;
-    await ((_a = reporter.onSuiteBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, suite, ctx));
-    if (suite.mode === 'skip') {
-        suite.status = 'skip';
-    }
-    else if (suite.mode === 'todo') {
-        suite.status = 'todo';
-    }
-    else {
-        try {
-            await callHook(suite, 'beforeAll', [suite]);
-            for (const t of suite.tasks)
-                await runTask(t, ctx);
-            await callHook(suite, 'afterAll', [suite]);
-        }
-        catch (e) {
-            suite.error = e;
-            suite.status = 'fail';
-            process.exitCode = 1;
-        }
-    }
-    await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
-}
-export async function runFile(file, ctx) {
-    var _a, _b;
-    const { reporter } = ctx;
-    const runnableSuites = file.suites.filter(i => i.mode === 'run');
-    if (runnableSuites.length === 0)
-        return;
-    await ((_a = reporter.onFileBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, file, ctx));
-    if (ctx.config.parallel) {
-        await Promise.all(file.suites.map(suite => runSuite(suite, ctx)));
-    }
-    else {
-        for (const suite of file.suites)
-            await runSuite(suite, ctx);
-    }
-    await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
-}
-export async function runFiles(filesMap, ctx) {
-    var _a;
-    const { reporter } = ctx;
-    await ((_a = reporter.onCollected) === null || _a === void 0 ? void 0 : _a.call(reporter, Object.values(filesMap), ctx));
-    for (const file of Object.values(filesMap))
-        await runFile(file, ctx);
-}
-export async function run(config) {
-    var _a, _b, _c;
-    config.reporter = config.reporter || new DefaultReporter();
-    const { reporter } = config;
-    // if watch, tell `vite-node` not to end the process
-    if (config.watch)
-        process.__vite_node__.watch = true;
-    // setup chai
-    await setupChai(config);
-    // collect files
-    let testFilepaths = await fg(config.includes || defaultIncludes, {
-        absolute: true,
-        cwd: config.root,
-        ignore: config.excludes || defaultExcludes,
-    });
-    // if name filters are provided by the CLI
-    if ((_a = config.filters) === null || _a === void 0 ? void 0 : _a.length)
-        testFilepaths = testFilepaths.filter(i => config.filters.some(f => i.includes(f)));
-    if (!testFilepaths.length) {
-        console.error('No test files found');
-        process.exitCode = 1;
-        return;
-    }
-    // setup envs
-    if (config.global)
-        (await import('../integrations/global')).registerApiGlobally();
-    if (config.jsdom)
-        (await import('../integrations/jsdom')).setupJSDOM(globalThis);
-    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
-    const filesMap = await collectFiles(testFilepaths);
-    const snapshotManager = getSnapshotManager();
-    const ctx = {
-        filesMap,
-        get files() {
-            return Object.values(this.filesMap);
-        },
-        get suites() {
-            return Object.values(this.filesMap)
-                .reduce((suites, file) => suites.concat(file.suites), []);
-        },
-        get tasks() {
-            return this.suites
-                .reduce((tasks, suite) => tasks.concat(suite.tasks), []);
-        },
-        config,
-        reporter,
-        snapshotManager,
-    };
-    await runFiles(filesMap, ctx);
-    snapshotManager.saveSnap();
-    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
-    if (config.watch)
-        await startWatcher(ctx);
-}
-export async function startWatcher(ctx) {
-    var _a;
-    const { reporter, snapshotManager, filesMap } = ctx;
-    await ((_a = reporter.onWatcherStart) === null || _a === void 0 ? void 0 : _a.call(reporter, ctx));
-    let timer;
-    const changedTests = new Set();
-    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();
-        if (changedTests.size === 0)
-            return;
-        clearTimeout(timer);
-        timer = setTimeout(async () => {
-            var _a, _b, _c;
-            if (changedTests.size === 0)
-                return;
-            snapshotManager.clear();
-            const paths = Array.from(changedTests);
-            changedTests.clear();
-            await ((_a = reporter.onWatcherRerun) === null || _a === void 0 ? void 0 : _a.call(reporter, paths, id, ctx));
-            paths.forEach(i => moduleCache.delete(i));
-            const newFilesMap = await collectFiles(paths);
-            Object.assign(filesMap, newFilesMap);
-            await runFiles(newFilesMap, ctx);
-            snapshotManager.saveSnap();
-            await ((_b = reporter.onFinished) === null || _b === void 0 ? void 0 : _b.call(reporter, ctx, Object.values(newFilesMap)));
-            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))
-        return set;
-    seen.add(id);
-    if (id in ctx.filesMap) {
-        set.add(id);
-        return set;
-    }
-    const mod = process.__vite_node__.server.moduleGraph.getModuleById(id);
-    if (mod) {
-        mod.importers.forEach((i) => {
-            if (i.id)
-                getDependencyTests(i.id, ctx, set, seen);
-        });
-    }
-    return set;
-}

package/dist/suite.d.ts

@@ -1,26 +0,0 @@
-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;
-};
-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: TestFunction): void;
-    skip(name: string, fn: TestFunction): void;
-    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;