fava/dist/assert.js

A wannabe tiny largely-drop-in replacement for ava that works in the browser too.

/* IMPORT */
import Utils from './utils.js';
/* MAIN */
//TODO: Maybe use "concordance" for clean diffs https://github.com/concordancejs/concordance
//TODO: Maybe switch to a more ava-like "like" function: https://github.com/avajs/ava/blob/main/lib/like-selector.js
//TODO: Improve error messages (Extend Error with extra diffs and stuff)
//TODO: Support snapshots
const Assert = {
    /* API */
    pass: (message) => {
        return;
    },
    fail: (message) => {
        throw new Error(message ?? 'The "fail" assertion got called');
    },
    assert: (value, message) => {
        return Assert.truthy(value, message);
    },
    truthy: (value, message) => {
        if (!!value)
            return;
        throw new Error(message ?? `Expected "${value}" to be truthy`);
    },
    falsy: (value, message) => {
        if (!value)
            return;
        throw new Error(message ?? `Expected "${value}" to be falsy`);
    },
    true: (value, message) => {
        if (value === true)
            return;
        throw new Error(message ?? `Expected "${value}" to be true`);
    },
    false: (value, message) => {
        if (value === false)
            return;
        throw new Error(message ?? `Expected "${value}" to be false`);
    },
    is: (value, expected, message) => {
        if (Object.is(value, expected))
            return;
        throw new Error(message ?? `Expected "${value}" to be exactly "${expected}"`);
    },
    not: (value, expected, message) => {
        if (!Object.is(value, expected))
            return;
        throw new Error(message ?? `Expected "${value}" to not be exactly "${expected}"`);
    },
    deepEqual: (value, expected, message) => {
        if (Utils.lang.isEqual(value, expected))
            return;
        throw new Error(message ?? `Expected "${value}" to be deeply equal to "${expected}"`);
    },
    notDeepEqual: (value, expected, message) => {
        if (!Utils.lang.isEqual(value, expected))
            return;
        throw new Error(message ?? `Expected "${value}" to not be deeply equal to "${expected}"`);
    },
    like: (value, partial, message) => {
        if (Utils.lang.isLike(value, partial))
            return;
        throw new Error(message ?? `Expected "${value}" to be like "${partial}"`);
    },
    notLike: (value, partial, message) => {
        if (!Utils.lang.isLike(value, partial))
            return;
        throw new Error(message ?? `Expected "${value}" to not be like "${partial}"`);
    },
    error: (error, expectation) => {
        if (!Utils.lang.isError(error)) {
            throw new Error(`Expected exception to be an instance of "Error", but got "${error}"`);
        }
        if (expectation) {
            const { instanceOf, is, message, name, code } = expectation;
            if (!Utils.lang.isUndefined(instanceOf)) {
                if (!(error instanceof instanceOf)) {
                    throw new Error(`Expected error to be an instance of "${instanceOf}" but got "${error}"`);
                }
            }
            if (!Utils.lang.isUndefined(is)) {
                if (!Object.is(error, is)) {
                    throw new Error(`Expected error to be exactly "${is}" but got "${error}"`);
                }
            }
            if (!Utils.lang.isUndefined(message)) {
                if (error.message !== message) {
                    throw new Error(`Expected error to have message "${message}" but got "${error.message}"`);
                }
            }
            if (!Utils.lang.isUndefined(name)) {
                if (error.name !== name) {
                    throw new Error(`Expected error to have name "${name}" but got "${error.name}"`);
                }
            }
            if (!Utils.lang.isUndefined(code)) {
                const errorCode = Utils.lang.isException(error) ? error.code : undefined;
                if (errorCode !== code) {
                    throw new Error(`Expected error to have code "${code}" but got "${errorCode}"`);
                }
            }
        }
    },
    throws: (fn, expectation, message) => {
        try {
            fn();
        }
        catch (error) {
            Assert.error(error, expectation);
            return;
        }
        throw new Error(message ?? 'Expected function to throw');
    },
    throwsAsync: async (fn, expectation, message) => {
        try {
            await fn();
        }
        catch (error) {
            Assert.error(error, expectation);
            return;
        }
        throw new Error(message ?? 'Expected function to throw or reject');
    },
    notThrows: (fn, message) => {
        try {
            fn();
        }
        catch (error) {
            throw new Error(message ?? 'Expected function to not throw');
        }
    },
    notThrowsAsync: async (fn, message) => {
        try {
            await fn();
        }
        catch (error) {
            throw new Error(message ?? 'Expected function to not throw or reject');
        }
    },
    regex: (str, regex, message) => {
        if (regex.test(str))
            return;
        throw new Error(message ?? `Expected "${str}" to match the regex "${regex}"`);
    },
    notRegex: (str, regex, message) => {
        if (!regex.test(str))
            return;
        throw new Error(message ?? `Expected "${str}" to not match the regex "${regex}"`);
    },
    wait: (ms) => {
        return new Promise(resolve => {
            setTimeout(resolve, ms);
        });
    }
};
/* EXPORT */
export default Assert;