@sprucelabs/test-utils 3.1.83 → 3.2.0

package/build/esm/AbstractSpruceTest.js

@@ -0,0 +1,51 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from 'path';
+export default class AbstractSpruceTest {
+    static beforeAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cwd = process.cwd();
+        });
+    }
+    static afterAll() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    static beforeEach() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    static afterEach() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    static resolvePath(...filePath) {
+        const cwd = this.cwd;
+        let builtPath = path.join(...filePath);
+        if (!cwd) {
+            throw new Error('You must call super.beforeAll().');
+        }
+        if (builtPath[0] !== '/') {
+            if (builtPath.substr(0, 2) === './') {
+                builtPath = builtPath.substr(1);
+            }
+            builtPath = path.join(cwd, builtPath);
+        }
+        return builtPath;
+    }
+    static wait(ms = 1000) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                setTimeout(() => resolve(true), ms);
+            });
+        });
+    }
+    static log(...args) {
+        const str = args.map((a) => `${a}`).join(' ');
+        process.stderr.write(str);
+    }
+}

package/build/esm/AssertionError.d.ts

@@ -0,0 +1,3 @@
+export default class AssertionError extends Error {
+    constructor(message: string, stack?: string);
+}

package/build/esm/AssertionError.js

@@ -0,0 +1,9 @@
+import StackCleaner from './StackCleaner.js';
+export default class AssertionError extends Error {
+    constructor(message, stack) {
+        var _a;
+        super(message);
+        this.message = StackCleaner.clean(message ? `${message}\n` : '');
+        this.stack = StackCleaner.clean(`${this.message}${((_a = stack !== null && stack !== void 0 ? stack : this.stack) !== null && _a !== void 0 ? _a : '').replace(message, '')}`);
+    }
+}

package/build/esm/StackCleaner.d.ts

@@ -0,0 +1,4 @@
+export default class StackCleaner {
+    private static matchPattern;
+    static clean(stack: string): string;
+}

package/build/esm/StackCleaner.js

@@ -0,0 +1,9 @@
+export default class StackCleaner {
+    static clean(stack) {
+        const lines = stack.split(/\r?\n/);
+        const filtered = lines.filter((line) => line.search(this.matchPattern) === -1);
+        const newStack = filtered.join('\n');
+        return newStack;
+    }
+}
+StackCleaner.matchPattern = /spruce-test\/(?!src\/__tests__)|node_modules|internal\/process\/task_queues|@babel|regenerator-runtime\/runtime/gi;

package/build/esm/assert/assert.d.ts

@@ -0,0 +1,44 @@
+import { expectType } from 'ts-expect';
+declare type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+declare type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+declare type IsAny<T> = IfAny<T, true, never>;
+declare type TypeEqual<T, U> = IsAny<T> extends never ? Exclude<T, U> extends never ? Exclude<U, T> extends never ? true : false : false : false;
+declare function isExactType<T, E, Pass = TypeEqual<T, E>>(_: Pass): void;
+export interface ISpruceAssert {
+    isNumber(actual: any, message?: string): asserts actual is number;
+    isType: typeof expectType;
+    isExactType: typeof isExactType;
+    isArray<T extends any[]>(actual: any, message?: string): asserts actual is T;
+    areSameType<T>(actual: T, expected: T): asserts actual is T;
+    isEqual<T>(actual: T, expected: T, message?: string): asserts actual is T;
+    isNotEqual<T>(actual: T, expected: T, message?: string): asserts actual is T;
+    isEqualDeep<T>(actual: T, expected: T, message?: string, shouldAppendDelta?: boolean): asserts actual is T;
+    isAbove<T>(actual: T, floor: T, message?: string): void;
+    isBelow<T>(actual: T, ceiling: T, message?: string): void;
+    isUndefined<T>(actual: T, message?: string): void;
+    isTruthy<T = any>(value: T, message?: string): asserts value is NonNullable<T>;
+    isFalsy(value: any, message?: string): void;
+    isTrue(actual: boolean | undefined | null, message?: string): asserts actual is true;
+    isFalse(actual: boolean | undefined | null, message?: string): asserts actual is false;
+    isObject<T>(actual: T, message?: string): void;
+    isLength(actual: any[] | undefined | null, expected: number, message?: string): void;
+    isNull(actual: any, message?: string): void;
+    doesNotInclude<T>(haystack: T, needle: RecursivePartial<T>, message?: string): void;
+    doesNotInclude(haystack: string, needle: string, message?: string): void;
+    doesNotInclude(haystack: any, needle: string, message?: string): void;
+    doesNotInclude(haystack: any, needle: any, message?: string): void;
+    doesInclude<T>(haystack: T, needle: RecursivePartial<T>, message?: string): void;
+    doesInclude(haystack: string, needle: string, message?: string): void;
+    doesInclude(haystack: any, needle: string, message?: string): void;
+    doesInclude(haystack: any, needle: any, message?: string): void;
+    isString(actual: any, message?: string): asserts actual is string;
+    isFunction(actual: any, message?: string): asserts actual is Function;
+    hasAllFunctions(obj: any, functionNames: string[]): void;
+    doesThrow(cb: () => any, matcher?: string | RegExp | undefined, msg?: string | undefined): Error;
+    doesThrowAsync(cb: () => any | Promise<any>, matcher?: string | RegExp | undefined, msg?: string | undefined): Promise<Error>;
+    fail(message?: string): void;
+}
+declare const assert: ISpruceAssert;
+export default assert;

package/build/esm/assert/assert.js

@@ -0,0 +1,233 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import chalk from 'chalk';
+import deepEqual from 'deep-equal';
+import escapeRegExp from 'lodash/escapeRegExp.js';
+import isObjectLike from 'lodash/isObjectLike.js';
+import { expectType } from 'ts-expect';
+import diff from 'variable-diff';
+import assertUtil from './assert.utility.js';
+const stringify = assertUtil.stringify.bind(assertUtil);
+function isExactType(_) { }
+const assert = {
+    areSameType() { },
+    isType: expectType,
+    isExactType,
+    isNumber(actual, message) {
+        if (typeof actual !== 'number') {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not a number!`);
+        }
+    },
+    isEqual(actual, expected, message) {
+        if (actual !== expected) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} does not equal ${stringify(expected)}`);
+        }
+    },
+    isNotEqual(actual, expected, message) {
+        if (actual === expected) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} should not equal ${stringify(expected)}`);
+        }
+    },
+    isEqualDeep(actual, expected, message, shouldAppendDelta = true) {
+        if (!deepEqual(actual, expected, { strict: true })) {
+            let result = diff(actual, expected);
+            this.fail(`${message !== null && message !== void 0 ? message : `Deep equal failed.\n\nActual would need the following changes to match expected:`}${shouldAppendDelta ? `\n\n${result.text}` : ``}`);
+        }
+    },
+    isAbove(actual, floor, message) {
+        if (typeof actual !== 'number') {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not a number!`);
+        }
+        if (actual <= floor) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not above ${stringify(floor)}`);
+        }
+    },
+    isBelow(actual, ceiling, message) {
+        if (typeof actual !== 'number') {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not a number!`);
+        }
+        if (actual >= ceiling) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not below ${stringify(ceiling)}`);
+        }
+    },
+    isUndefined(actual, message) {
+        if (typeof actual !== 'undefined') {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not undefined`);
+        }
+    },
+    isTruthy(actual, message) {
+        if (actual === false ||
+            actual === null ||
+            typeof actual === 'undefined' ||
+            actual === 0) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not truthy`);
+        }
+    },
+    isFalsy(actual, message) {
+        if (actual) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not falsy`);
+        }
+    },
+    isNull(actual, message) {
+        if (actual !== null) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not null`);
+        }
+    },
+    isString(actual, message) {
+        assertUtil.assertTypeof(actual, 'string', message);
+    },
+    isFunction(actual, message) {
+        assertUtil.assertTypeof(actual, 'function', message);
+    },
+    isTrue(actual, message) {
+        //@ts-ignore
+        this.isEqual(actual, true, message);
+    },
+    isFalse(actual, message) {
+        //@ts-ignore
+        this.isEqual(actual, false, message);
+    },
+    isObject(actual, message) {
+        if (!isObjectLike(actual)) {
+            throw this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not an object`);
+        }
+    },
+    isArray(actual, message) {
+        if (!Array.isArray(actual)) {
+            throw this.fail(message !== null && message !== void 0 ? message : `${stringify(actual)} is not an array`);
+        }
+    },
+    isLength(actual, expected, message) {
+        if (!actual) {
+            throw this.fail(message !== null && message !== void 0 ? message : `Expected array of length ${expected}, but got ${stringify(actual)}`);
+        }
+        //@ts-ignore
+        this.isEqual(actual.length, expected, message !== null && message !== void 0 ? message : `Expected length of ${stringify(expected)}, but got a length of ${stringify(actual.length)}`);
+    },
+    doesNotInclude(haystack, needle, message) {
+        let doesInclude = false;
+        try {
+            this.doesInclude(haystack, needle);
+            doesInclude = true;
+        }
+        catch (_a) {
+            doesInclude = false;
+        }
+        if (doesInclude) {
+            this.fail(message !== null && message !== void 0 ? message : `${stringify(haystack)} should not include ${stringify(needle)}, but it does`);
+        }
+    },
+    doesInclude(haystack, needle, message) {
+        let msg = message !== null && message !== void 0 ? message : `Could not find ${stringify(needle)} in ${stringify(haystack)}`;
+        const isNeedleString = typeof needle === 'string';
+        const isNeedleRegex = needle instanceof RegExp;
+        if (typeof haystack === 'string' &&
+            (isNeedleString || isNeedleRegex) &&
+            haystack.search(isNeedleString ? escapeRegExp(needle) : needle) > -1) {
+            return;
+        }
+        const isHaystackObject = isObjectLike(haystack);
+        const { needleHasArrayNotation, path, expected } = assertUtil.parseIncludeNeedle(needle);
+        if (Array.isArray(haystack)) {
+            let cleanedNeedle = needle;
+            if (path && path.substr(0, 3) === '[].') {
+                cleanedNeedle = { [path.substr(3)]: expected };
+            }
+            const found = assertUtil.doHaystacksPassCheck(haystack, cleanedNeedle, this.doesInclude.bind(this));
+            if (found) {
+                return;
+            }
+        }
+        if (isHaystackObject && isObjectLike(needle)) {
+            try {
+                //@ts-ignore
+                this.isEqualDeep(haystack, needle);
+                return;
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+        }
+        if (assertUtil.foundUsing3rdPartyIncludes(haystack, needle, isHaystackObject)) {
+            return;
+        }
+        if (!Array.isArray(haystack) &&
+            isHaystackObject &&
+            isObjectLike(needle) &&
+            Object.keys(needle).length === 1 &&
+            !needleHasArrayNotation &&
+            path) {
+            const actual = assertUtil.valueAtPath(haystack, path);
+            if (typeof actual === 'undefined') {
+                msg = `The path ${stringify(path)} was not found in ${stringify(haystack)}`;
+            }
+            else {
+                msg = `Expected ${chalk.green(stringify(needle[path]))} but found ${chalk.red(stringify(actual))} at ${stringify(path)} in ${stringify(haystack)}`;
+            }
+            if (typeof expected === 'string' &&
+                typeof actual === 'string' &&
+                actual.search(expected) > -1) {
+                return;
+            }
+            else if (expected instanceof RegExp && expected.exec(actual)) {
+                return;
+            }
+            else {
+                //@ts-ignore
+                this.isEqualDeep(expected, actual, msg, false);
+            }
+            return;
+        }
+        if (isHaystackObject && isObjectLike(needle) && path) {
+            const { actualBeforeArray, pathAfterFirstArray } = assertUtil.splitPathBasedOnArrayNotation(path, haystack);
+            if (!Array.isArray(actualBeforeArray)) {
+                this.fail(msg);
+            }
+            const found = assertUtil.doHaystacksPassCheck(actualBeforeArray, {
+                [pathAfterFirstArray]: expected,
+            }, this.doesInclude.bind(this));
+            if (found) {
+                return;
+            }
+            msg = `Could not find match ${stringify(expected)} at ${stringify(pathAfterFirstArray)} in ${stringify(actualBeforeArray)}.`;
+        }
+        this.fail(msg);
+    },
+    hasAllFunctions(obj, functionNames) {
+        functionNames.forEach((name) => {
+            if (typeof obj[name] !== 'function') {
+                this.fail(`A function named "${name}" does not exist on ${stringify(obj)}`);
+            }
+        });
+    },
+    doesThrow(cb, matcher, msg) {
+        try {
+            cb();
+        }
+        catch (err) {
+            assertUtil.checkDoesThrowError(matcher, err, msg);
+            return err;
+        }
+        this.fail('Expected a thrown error, but never got one!');
+    },
+    doesThrowAsync(cb, matcher, msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield cb();
+            }
+            catch (err) {
+                assertUtil.checkDoesThrowError(matcher, err, msg);
+                return err;
+            }
+            this.fail('Expected a thrown error, but never got one!');
+        });
+    },
+    fail: assertUtil.fail,
+};
+export default assert;

package/build/esm/assert/assert.utility.d.ts

@@ -0,0 +1,28 @@
+import { ISpruceAssert } from './assert';
+export declare const UNDEFINED_PLACEHOLDER = "_____________undefined_____________";
+export declare const FUNCTION_PLACEHOLDER = "_____________function_____________";
+export declare const CIRCULAR_PLACEHOLDER = "_____________circular_____________";
+export declare const NULL_PLACEHOLDER = "_____________null_____________";
+declare const assertUtil: {
+    fail(message?: string, stack?: string): never;
+    stringify(object: any): string;
+    replacePlaceholders(str: string): string;
+    dropInPlaceholders(obj: Record<string, any>): Record<string, any>;
+    dropInPlaceholder(obj: Record<string, any>, checker: (obj: any, depth: number) => boolean, placeholder: string, depth?: number): Record<string, any>;
+    doHaystacksPassCheck(haystacks: any[], needle: any, check: ISpruceAssert['doesInclude']): boolean;
+    assertTypeof(actual: any, type: string, message: string | undefined): void;
+    checkDoesThrowError(matcher: string | RegExp | undefined, err: Error, msg?: string | undefined): void;
+    partialContains(object: any, subObject: any): boolean | undefined;
+    valueAtPath(object: Record<string, any>, path: string): any;
+    parseIncludeNeedle(needle: any): {
+        needleHasArrayNotation: boolean;
+        path?: string | undefined;
+        expected?: any;
+    };
+    splitPathBasedOnArrayNotation(path: string, haystack: any): {
+        actualBeforeArray: any;
+        pathAfterFirstArray: string;
+    };
+    foundUsing3rdPartyIncludes(haystack: any, needle: any, isHaystackObject: boolean): boolean;
+};
+export default assertUtil;

package/build/esm/assert/assert.utility.js

@@ -0,0 +1,176 @@
+import chalk from 'chalk';
+import get from 'lodash/get.js';
+import includes from 'lodash/includes.js';
+import isObject from 'lodash/isObject.js';
+import isObjectLike from 'lodash/isObjectLike.js';
+import AssertionError from '../AssertionError.js';
+export const UNDEFINED_PLACEHOLDER = '_____________undefined_____________';
+export const FUNCTION_PLACEHOLDER = '_____________function_____________';
+export const CIRCULAR_PLACEHOLDER = '_____________circular_____________';
+export const NULL_PLACEHOLDER = '_____________null_____________';
+const assertUtil = {
+    fail(message, stack) {
+        throw new AssertionError(message !== null && message !== void 0 ? message : 'Fail!', stack);
+    },
+    stringify(object) {
+        var _a;
+        let stringified;
+        if (Array.isArray(object)) {
+            stringified = `[\n${object.map((o) => this.stringify(o).split('\n').join('\n\t'))}\n]`;
+        }
+        else if (typeof object === 'number') {
+            // this hack allows the Spruce Test Reporter to render number errors (they got eaten by terminal-kit's style regex)
+            stringified = chalk.bgBlack.white(` ${object} `);
+        }
+        else if (object instanceof Error) {
+            stringified = `${(_a = object.stack) !== null && _a !== void 0 ? _a : object.message}`;
+        }
+        else if (object instanceof RegExp) {
+            stringified = `${object.toString()}`;
+        }
+        else if (typeof object === 'undefined') {
+            stringified = 'undefined';
+        }
+        else if (typeof object === 'string') {
+            stringified = `"${object}"`;
+        }
+        else {
+            stringified = JSON.stringify(assertUtil.dropInPlaceholders(object), undefined, 2).replace(/\\/g, '');
+        }
+        if (stringified.length > 5000) {
+            stringified =
+                stringified.substr(0, 1000) +
+                    '\n\n... big object ...\n\n' +
+                    stringified.substr(stringified.length - 1000);
+        }
+        stringified = assertUtil.replacePlaceholders(stringified);
+        return `\n\n${chalk.bold(stringified)}\n\n`;
+    },
+    replacePlaceholders(str) {
+        return str
+            .replace(new RegExp(`"${UNDEFINED_PLACEHOLDER}"`, 'g'), chalk.italic('undefined'))
+            .replace(new RegExp(`"${FUNCTION_PLACEHOLDER}"`, 'g'), chalk.italic('Function'))
+            .replace(new RegExp(`"${NULL_PLACEHOLDER}"`, 'g'), chalk.italic('NULL'));
+    },
+    dropInPlaceholders(obj) {
+        const checkedObjects = [{ obj, depth: 0 }];
+        let updated = this.dropInPlaceholder(obj, (obj, depth) => {
+            if (isObject(obj) &&
+                checkedObjects.some((checked) => {
+                    return checked.obj === obj && checked.depth < depth;
+                })) {
+                return true;
+            }
+            checkedObjects.push({ obj, depth });
+            return false;
+        }, CIRCULAR_PLACEHOLDER);
+        updated = this.dropInPlaceholder(updated, (obj) => typeof obj === 'undefined', UNDEFINED_PLACEHOLDER);
+        updated = this.dropInPlaceholder(updated, (obj) => typeof obj === 'function', FUNCTION_PLACEHOLDER);
+        updated = this.dropInPlaceholder(updated, (obj) => obj === null, NULL_PLACEHOLDER);
+        return updated;
+    },
+    dropInPlaceholder(obj, checker, placeholder, depth = 1) {
+        if (!isObject(obj)) {
+            return obj;
+        }
+        const updated = Array.isArray(obj) ? [] : {};
+        Object.keys(obj).forEach((key) => {
+            //@ts-ignore
+            updated[key] =
+                // @ts-ignore
+                checker(obj[key], depth) ? placeholder : obj[key];
+            //@ts-ignore
+            if (typeof updated[key] !== 'function' && isObject(updated[key])) {
+                //@ts-ignore
+                updated[key] = this.dropInPlaceholder(
+                //@ts-ignore
+                updated[key], checker, placeholder, depth + 1);
+            }
+        });
+        return updated;
+    },
+    doHaystacksPassCheck(haystacks, needle, check) {
+        return !!haystacks.find((haystack) => {
+            try {
+                check(haystack, needle);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    },
+    assertTypeof(actual, type, message) {
+        if (typeof actual !== type) {
+            this.fail(message !== null && message !== void 0 ? message : `${JSON.stringify(actual)} is not a ${type}`);
+        }
+    },
+    checkDoesThrowError(matcher, err, msg) {
+        var _a, _b;
+        const message = (_b = (_a = err.stack) !== null && _a !== void 0 ? _a : err.message) !== null && _b !== void 0 ? _b : '**MISSING ERROR MESSAGE**';
+        if (typeof matcher === 'string' && message.search(matcher) === -1) {
+            this.fail(msg !== null && msg !== void 0 ? msg : `Expected thrown error whose message contains: \n\n${chalk.bold(matcher)}\n\nbut got back:\n\n\`${chalk.bold(message)}\`.`, '\n\nStack: ' + err.stack);
+        }
+        else if (matcher instanceof RegExp && message.search(matcher) === -1) {
+            this.fail(msg !== null && msg !== void 0 ? msg : `Expected thrown error whose message matches the regex: \n\n${chalk.bold(matcher)}\n\nbut got back:\n\n\`${chalk.bold(message)}\`.`, '\n\nStack: ' + err.stack);
+        }
+    },
+    partialContains(object, subObject) {
+        const objProps = object ? Object.getOwnPropertyNames(object) : [];
+        const subProps = subObject ? Object.getOwnPropertyNames(subObject) : [];
+        if (objProps.length == 0 || subProps.length === 0) {
+            return;
+        }
+        if (subProps.length > objProps.length) {
+            return false;
+        }
+        for (const subProp of subProps) {
+            if (!Object.prototype.hasOwnProperty.call(object, subProp)) {
+                return false;
+            }
+            if ((!isObjectLike(object[subProp]) || !isObjectLike(subObject[subProp])) &&
+                object[subProp] !== subObject[subProp]) {
+                return false;
+            }
+            if (isObjectLike(object[subProp]) &&
+                isObjectLike(subObject[subProp]) &&
+                !this.partialContains(object[subProp], subObject[subProp])) {
+                return false;
+            }
+        }
+        return true;
+    },
+    valueAtPath(object, path) {
+        return get(object, path);
+    },
+    parseIncludeNeedle(needle) {
+        const path = Object.keys(needle)[0];
+        const expected = path && needle[path];
+        const needleHasArrayNotation = !!(path && path.search(/\[\]\./) > -1);
+        return { needleHasArrayNotation, path, expected };
+    },
+    splitPathBasedOnArrayNotation(path, haystack) {
+        var _a;
+        const pathParts = path.split('[].');
+        const pathToFirstArray = (_a = pathParts.shift()) !== null && _a !== void 0 ? _a : '';
+        const pathAfterFirstArray = pathParts.join('[].');
+        const actualBeforeArray = this.valueAtPath(haystack, pathToFirstArray);
+        return { actualBeforeArray, pathAfterFirstArray };
+    },
+    foundUsing3rdPartyIncludes(haystack, needle, isHaystackObject) {
+        let passed = false;
+        if (typeof haystack === 'string' &&
+            typeof needle === 'string' &&
+            haystack.search(needle) > -1) {
+            passed = true;
+        }
+        if (isHaystackObject && includes(haystack, needle)) {
+            passed = true;
+        }
+        if (isHaystackObject && this.partialContains(haystack, needle)) {
+            passed = true;
+        }
+        return passed;
+    },
+};
+export default assertUtil;

package/build/esm/decorators.d.ts

@@ -0,0 +1,8 @@
+/** Test decorator */
+declare function test(description?: string, ...args: any[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare namespace test {
+    var only: (description?: string | undefined, ...args: any[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+    var todo: (description?: string | undefined, ..._args: any[]) => (target: any, propertyKey: string) => void;
+    var skip: (description?: string | undefined, ...args: any[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+}
+export default test;

package/build/esm/decorators.js

@@ -0,0 +1,80 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/** Hooks up before, after, etc. */
+function hookupTestClass(target) {
+    if (target.__isTestingHookedUp) {
+        return;
+    }
+    target.__isTestingHookedUp = true;
+    const hooks = ['beforeAll', 'beforeEach', 'afterAll', 'afterEach'];
+    hooks.forEach((hook) => {
+        // Have they defined a hook
+        if (!target[hook]) {
+            return;
+        }
+        // @ts-ignore
+        if (global[hook]) {
+            // @ts-ignore
+            global[hook](() => __awaiter(this, void 0, void 0, function* () {
+                return target[hook]();
+            }));
+        }
+    });
+}
+/** Test decorator */
+export default function test(description, ...args) {
+    return function (target, propertyKey, descriptor) {
+        // Lets attach before/after
+        hookupTestClass(target);
+        const bound = descriptor.value.bind(target);
+        // Make sure each test gets the spruce
+        it(description !== null && description !== void 0 ? description : propertyKey, () => __awaiter(this, void 0, void 0, function* () {
+            //@ts-ignore
+            global.activeTest = {
+                file: target.name,
+                test: propertyKey,
+            };
+            return bound(...args);
+        }));
+    };
+}
+/** Only decorator */
+test.only = (description, ...args) => {
+    return function (target, propertyKey, descriptor) {
+        // Lets attach before/after
+        hookupTestClass(target);
+        const bound = descriptor.value.bind(target);
+        // Make sure each test gets the spruce
+        it.only(description !== null && description !== void 0 ? description : propertyKey, () => __awaiter(this, void 0, void 0, function* () {
+            return bound(...args);
+        }));
+    };
+};
+/** Todo decorator */
+test.todo = (description, ..._args) => {
+    return function (target, propertyKey) {
+        // Lets attach before/after
+        hookupTestClass(target);
+        // Make sure each test gets the spruce
+        it.todo(description !== null && description !== void 0 ? description : propertyKey);
+    };
+};
+/** Skip decorator */
+test.skip = (description, ...args) => {
+    return function (target, propertyKey, descriptor) {
+        // Lets attach before/after
+        hookupTestClass(target);
+        const bound = descriptor.value.bind(target);
+        // Make sure each test gets the spruce
+        it.skip(description !== null && description !== void 0 ? description : propertyKey, () => __awaiter(this, void 0, void 0, function* () {
+            return bound(...args);
+        }));
+    };
+};

package/build/esm/index.d.ts

@@ -1,3 +1,9 @@
 export { default as errorAssert } from './utilities/errorAssert';
 export { default as errorAssertUtil } from './utilities/errorAssert.utility';
 export { default as generateId } from './utilities/generateId.utility';
+export { default } from './AbstractSpruceTest';
+export { default as assert } from './assert/assert';
+export * from './assert/assert';
+export { default as test } from './decorators';
+export { default as assertUtil } from './assert/assert.utility';
+export { default as StackCleaner } from './StackCleaner';