@sprucelabs/test 7.7.268 → 7.7.272

package/build/esm/__tests__/Assert.test.js

@@ -1,562 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-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 AbstractSpruceTest from '../AbstractSpruceTest.js';
-import assert from '../assert.js';
-import test from '../decorators.js';
-import assertUtil from '../utilities/assert.utility.js';
-export default class AssertTest extends AbstractSpruceTest {
-    static canHandleAsyncThrows() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let hitError = false;
-            yield assert.doesThrowAsync(() => __awaiter(this, void 0, void 0, function* () {
-                return new Promise(() => {
-                    hitError = true;
-                    throw new Error('should catch');
-                });
-            }));
-            assert.isTrue(hitError);
-        });
-    }
-    static canDetectNoErrorThrown() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let hitCallback = true;
-            let detectedNoThrow = false;
-            try {
-                assert.doesThrow(() => __awaiter(this, void 0, void 0, function* () {
-                    hitCallback = true;
-                }));
-            }
-            catch (err) {
-                detectedNoThrow = true;
-                assert.isTruthy(err);
-            }
-            assert.isTrue(hitCallback);
-            assert.isTrue(detectedNoThrow);
-        });
-    }
-    static isEqual() {
-        assert.doesThrow(() => assert.isEqual('hello', 'world'), /not equal/);
-        assert.isEqual(1, 1);
-    }
-    static isAbove() {
-        assert.isAbove(10, 5);
-        assert.doesThrow(() => assert.isAbove(5, 10), /is not above/);
-        assert.doesThrow(() => assert.isAbove(undefined, 10), /is not a number/);
-    }
-    static isBelow() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isBelow(5, 10);
-            assert.doesThrow(() => assert.isBelow(10, 5), /is not below/);
-            assert.doesThrow(() => assert.isBelow(undefined, 5), /is not a number/);
-        });
-    }
-    static typeTests() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isType('string');
-            assert.isType(123);
-            const myCustomObj = {
-                testStr: 'blah',
-            };
-            assert.isType(myCustomObj);
-            assert.areSameType(true, true);
-        });
-    }
-    static canMatchErrorByString() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesThrow(() => {
-                throw new Error('Match on string');
-            }, 'on string');
-            yield assert.doesThrowAsync(() => __awaiter(this, void 0, void 0, function* () {
-                throw new Error('canMatchErrorByString: Match on string');
-            }), 'on string');
-        });
-    }
-    static doesNotMatchErrorByBadString() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let errorThrown = false;
-            try {
-                assert.doesThrow(() => {
-                    throw new Error('doesNotMatchErrorByBadString: Match on string');
-                }, 'on string2');
-            }
-            catch (err) {
-                errorThrown = true;
-            }
-            assert.isTrue(errorThrown);
-        });
-    }
-    static throwMatchesErrorByRegex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.doesThrow(() => {
-                throw new Error('Match on string');
-            }, /on STRING/i);
-            yield assert.doesThrowAsync(() => __awaiter(this, void 0, void 0, function* () {
-                throw new Error('Match on string');
-            }), /on STRING/i);
-        });
-    }
-    static throwReturnsTheError() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const err = assert.doesThrow(() => {
-                throw new Error('Match on string');
-            });
-            assert.isEqual(err.message, 'Match on string');
-            const err2 = yield assert.doesThrowAsync(() => __awaiter(this, void 0, void 0, function* () {
-                throw new Error('Match on string');
-            }));
-            assert.isEqual(err2.message, 'Match on string');
-        });
-    }
-    static doesNotMatchErrorByBadRegex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let errorThrown = false;
-            try {
-                assert.doesThrow(() => {
-                    throw new Error('Match on string');
-                }, /on string2/);
-            }
-            catch (err) {
-                errorThrown = true;
-            }
-            assert.isTrue(errorThrown);
-        });
-    }
-    static doesNotMatchErrorByBadRegexAsync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let errorThrown = false;
-            try {
-                yield assert.doesThrowAsync(() => __awaiter(this, void 0, void 0, function* () {
-                    throw new Error('Match on string');
-                }), /on string2/);
-            }
-            catch (err) {
-                errorThrown = true;
-            }
-            assert.isTrue(errorThrown);
-        });
-    }
-    static assertIsString() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = (() => {
-                return 'test';
-            })();
-            assert.isString(path);
-            assert.isType(path);
-        });
-    }
-    static includeAndDoesNotInclude(haystack, needle) {
-        assert.doesInclude(haystack, needle);
-        assert.doesThrow(() => assert.doesNotInclude(haystack, needle), /should not include/);
-    }
-    static doesIncludeThrowsAsExpected(haystack, needle, matcher) {
-        const err = assert.doesThrow(() => assert.doesInclude(haystack, needle), matcher);
-        assert.doesNotInclude(err.message, 'undefined');
-    }
-    static hasAllFunctionsAndPasses() {
-        const obj = { func1: () => { }, func2() { }, foo: 'bar' };
-        assert.hasAllFunctions(obj, ['func1', 'func2']);
-    }
-    static hasAllFunctionsAndFails() {
-        const obj = { func1: () => { }, func2() { }, foo: 'bar' };
-        let errorHit = false;
-        try {
-            assert.hasAllFunctions(obj, ['func1', 'func3']);
-        }
-        catch (err) {
-            errorHit = true;
-            assert.doesInclude(err.message, 'func3');
-        }
-        assert.isTrue(errorHit);
-    }
-    static doesThrowIncludesOriginalStackTrace() {
-        function throwError() {
-            throw new Error('taco');
-        }
-        try {
-            throwError();
-        }
-        catch (err) {
-            const errWithStack = assert.doesThrow(() => assertUtil.checkDoesThrowError(/bravo/, err), /taco/);
-            assert.doesInclude(errWithStack.message, /at new Promise/);
-        }
-    }
-    static isTruthy() {
-        const run = () => {
-            return 'test';
-        };
-        const value = run();
-        assert.isTruthy(value);
-        assert.isType(value);
-        assert.doesThrow(() => assert.isTruthy(false), /is not truthy/);
-        assert.doesThrow(() => assert.isTruthy(undefined), /is not truthy/);
-        assert.doesThrow(() => assert.isTruthy(null), /is not truthy/);
-        assert.doesThrow(() => assert.isTruthy(0), /is not truthy/);
-    }
-    static isFalsy() {
-        assert.isFalsy(null);
-        assert.isFalsy(0);
-        assert.isFalsy(undefined);
-        assert.isFalsy(false);
-        assert.doesThrow(() => assert.isFalsy(1), /is not falsy/);
-        assert.doesThrow(() => assert.isFalsy('undefined'), /is not falsy/);
-    }
-    static isString() {
-        assert.isString('test');
-        assert.doesThrow(() => assert.isString(true), 'not a string');
-    }
-    static isTrue() {
-        assert.isTrue(true);
-        assert.doesThrow(() => assert.isTrue(false), /does not equal(.*?)true/gis);
-        assert.doesThrow(() => assert.isTrue(undefined), /does not equal(.*?)true/gis);
-    }
-    static isFalse() {
-        assert.isFalse(false);
-        assert.doesThrow(() => assert.isFalse(true), /does not equal(.*?)false/gis);
-        assert.doesThrow(() => assert.isFalse(undefined), /does not equal(.*?)false/gis);
-    }
-    static deepEqual() {
-        assert.isEqualDeep({ test: true }, { test: true });
-        assert.doesThrow(() => assert.isEqualDeep({ test: true }, { test: false }), /true => false/);
-        assert.doesThrow(() => assert.isEqualDeep({ test: '1' }, { test: 1 }), /"1" => 1/);
-    }
-    static isUndefined() {
-        assert.isUndefined(undefined);
-        assert.doesThrow(() => assert.isUndefined(true), /not undefined/);
-    }
-    static isNotEqual() {
-        assert.isNotEqual(true, false);
-        assert.doesThrow(() => assert.isNotEqual('do', 'do'), /should not equal/);
-    }
-    static fail() {
-        assert.doesThrow(() => assert.fail('waka waka'), 'waka waka');
-    }
-    static isObject() {
-        assert.isObject({ test: true });
-        assert.doesThrow(() => assert.isObject(true), /not an object/gi);
-    }
-    static isLength() {
-        assert.isLength([], 0);
-        assert.isLength(['test'], 1);
-        assert.doesThrow(() => assert.isLength(['test'], 4), /expected length of/gi);
-        assert.doesThrow(() => assert.isLength(undefined, 4), /undefined/gi);
-        assert.doesThrow(() => assert.isLength(null, 4), /null/gi);
-    }
-    static isNull() {
-        assert.isNull(null);
-        assert.doesThrow(() => assert.isNull(false));
-        assert.doesThrow(() => assert.isNull(undefined));
-    }
-    static isExactType() {
-        const test = null;
-        assert.isExactType(true);
-        let test2;
-        assert.isExactType(true);
-    }
-    static isArray() {
-        assert.isArray([]);
-        assert.doesThrow(() => assert.isArray(true), /is not an array/);
-        let couldBeArray;
-        couldBeArray = [];
-        function test() {
-            assert.isArray(couldBeArray);
-            assert.isExactType(true);
-        }
-        test();
-    }
-    static isNumber() {
-        assert.doesThrow(() => assert.isNumber('test'));
-        assert.doesThrow(() => assert.isNumber('1'));
-        assert.isNumber(1);
-        assert.isNumber(2);
-    }
-    static printsNiceDiff() {
-        // assert.isEqualDeep(
-        // 	{ test: true, taco: 'bell' },
-        // 	{ test: false, burger: 'king' }
-        // )
-        assert.isFalsy([new Error('yay')]);
-    }
-}
-__decorate([
-    test()
-], AssertTest, "canHandleAsyncThrows", null);
-__decorate([
-    test()
-], AssertTest, "canDetectNoErrorThrown", null);
-__decorate([
-    test()
-], AssertTest, "isEqual", null);
-__decorate([
-    test()
-], AssertTest, "isAbove", null);
-__decorate([
-    test()
-], AssertTest, "isBelow", null);
-__decorate([
-    test()
-], AssertTest, "typeTests", null);
-__decorate([
-    test()
-], AssertTest, "canMatchErrorByString", null);
-__decorate([
-    test()
-], AssertTest, "doesNotMatchErrorByBadString", null);
-__decorate([
-    test()
-], AssertTest, "throwMatchesErrorByRegex", null);
-__decorate([
-    test()
-], AssertTest, "throwReturnsTheError", null);
-__decorate([
-    test()
-], AssertTest, "doesNotMatchErrorByBadRegex", null);
-__decorate([
-    test()
-], AssertTest, "doesNotMatchErrorByBadRegexAsync", null);
-__decorate([
-    test('asserts is string (test will pass, types will fail)')
-], AssertTest, "assertIsString", null);
-__decorate([
-    test('include uses string to match string', 'hello world', 'world'),
-    test('assert regex on string', 'hello world', /world/gi),
-    test('assert regex obj on string', 'hello world', new RegExp('world', 'gis')),
-    test('include uses partial and matches 0th level', { hello: 'world', taco: 'bell' }, { taco: 'bell' }),
-    test('include can find string as value on 0th level', { hello: 'world', taco: 'bell' }, 'bell'),
-    test('include can find scalar on 1st level', { hello: 'world', taco: 'bell', flavor: { cheese: true, buffalo: true } }, { 'flavor.cheese': true }),
-    test('include can find scalar on 2nd level', {
-        hello: 'world',
-        taco: 'bell',
-        flavor: { cheese: { size: 'large', buffalo: true } },
-    }, { 'flavor.cheese.size': 'large' }),
-    test('include can find object on 2nd level', {
-        hello: 'world',
-        taco: 'bell',
-        flavor: { cheese: { size: 'large', buffalo: { wing: true } } },
-    }, { 'flavor.cheese.buffalo': { wing: true } }),
-    test('include can search inside array with index', {
-        flavors: [{ cheese: true }, { peperoni: true }],
-    }, { 'flavors[0].cheese': true }),
-    test('include can search inside array without index', {
-        flavors: [{ cheese: true }, { peperoni: true }],
-    }, { 'flavors[].peperoni': true }),
-    test('include can search inside array without index', {
-        flavors: [
-            { size: 'large', toppings: [{ meat: true }, { cheese: true }] },
-            { size: 'small' },
-        ],
-    }, { 'flavors[].toppings[].meat': true }),
-    test('include can search array without index', [{ cheese: true }, { meat: true }], { meat: true }),
-    test('include can match on partial object', { cheese: true, meat: true }, {
-        meat: true,
-    }),
-    test('include can search array without index', [{ cheese: true }, { meat: true }], { '[].meat': true }),
-    test('include can search array without index', [{ cheese: true }, { meat: true }], { meat: true }),
-    test('include matches partial object in array', [
-        {
-            name: 'schemas.types.ts',
-            description: 'Every schema you need based on all your contracts',
-            path: '/var/folders/qw/v2bfr0c94bn37vclwvcltsj40000gn/tmp/5b49b673-7df0-4edd-ba9d-683a69a70f72/src/.spruce/schemas/schemas.types.ts',
-            action: 'updated',
-        },
-    ], {
-        action: 'updated',
-    }),
-    test('include matches deep equal on object with nested object in array', [
-        {
-            name: 'schemas.types.ts',
-            description: 'Every schema you need based on all your contracts',
-            path: '/var/folders/qw/v2bfr0c94bn37vclwvcltsj40000gn/tmp/5b49b673-7df0-4edd-ba9d-683a69a70f72/src/.spruce/schemas/schemas.types.ts',
-            action: 'updated',
-            deep: {
-                foo: 'bar',
-            },
-        },
-    ], {
-        name: 'schemas.types.ts',
-        description: 'Every schema you need based on all your contracts',
-        path: '/var/folders/qw/v2bfr0c94bn37vclwvcltsj40000gn/tmp/5b49b673-7df0-4edd-ba9d-683a69a70f72/src/.spruce/schemas/schemas.types.ts',
-        action: 'updated',
-        deep: {
-            foo: 'bar',
-        },
-    }),
-    test('include matches deep equal on nested object in array', [
-        {
-            name: 'schemas.types.ts',
-            description: 'Every schema you need based on all your contracts',
-            path: '/var/folders/qw/v2bfr0c94bn37vclwvcltsj40000gn/tmp/5b49b673-7df0-4edd-ba9d-683a69a70f72/src/.spruce/schemas/schemas.types.ts',
-            action: 'updated',
-            deep: {
-                foo: 'bar',
-            },
-        },
-    ], {
-        name: 'schemas.types.ts',
-        deep: {
-            foo: 'bar',
-        },
-    }),
-    test('include matches object props', {
-        results: {
-            errors: [new Error('test'), new Error('test2')],
-        },
-    }, {
-        'results.errors[].stack': 'test2',
-    }),
-    test('include matches object props against regex', {
-        results: {
-            errors: [new Error('test'), new Error('test2')],
-        },
-    }, {
-        'results.errors[].stack': /test[1|2]/,
-    }),
-    test('include matches when passed an array and matching against object with numbers', [6, 7], 7),
-    test('include matches object with array property in array of objects', [
-        {
-            methodName: 'use',
-            args: [null],
-        },
-        {
-            methodName: 'on',
-            args: ['confirm-pin', null],
-        },
-        {
-            methodName: 'on',
-            args: ['who-am-i', null],
-        },
-        {
-            methodName: 'on',
-            args: ['authenticate', null],
-        },
-        {
-            methodName: 'on',
-            args: ['can-listen', null],
-        },
-        {
-            methodName: 'emit',
-            args: ['test.what-an-event', null],
-        },
-    ], {
-        methodName: 'emit',
-        args: ['test.what-an-event', null],
-    })
-], AssertTest, "includeAndDoesNotInclude", null);
-__decorate([
-    test('include fails as expected with strings', 'taco', 'bravo', /could not find(.*?)"bravo"/gis),
-    test('include fails as expected with regex obj on string', 'hello world', new RegExp('cheeseball', 'gis')),
-    test('include fails as expected matching string against object', { hello: 'world' }, 'taco', /Could not find(.*?)taco/gis),
-    test('include fails as expected matching string against object with array', {
-        flavors: [
-            { size: 'large', toppings: [{ meat: true }, { cheese: true }] },
-            { size: 'small' },
-        ],
-    }, { 'flavors[].toppings[].meat': false }, /could not find match(.*?)false(.*?)at(.*?)toppings\[\]\.meat/gis),
-    test.only('include fails as expected matching string against nested object', {
-        cheese: { size: 'large', toppings: { meat: true } },
-    }, { 'cheese.toppings.stink': false }, /the path(.*?)cheese.toppings.stink(.*?)was not found in/gis),
-    test('include fails as expected by not showing full object if path matches but value differs', {
-        cheese: { size: 'large', toppings: { meat: true } },
-    }, { 'cheese.toppings.meat': false }, /expected(.*?)false(.*?)but found(.*?)true(.*?) at(.*?)cheese.toppings.meat/gis),
-    test("include fails when can't find in an array", [
-        {
-            name: 'schemas.types.ts',
-            description: 'Every schema you need based on all your contracts',
-            path: '/var/folders/qw/v2bfr0c94bn37vclwvcltsj40000gn/tmp/5b49b673-7df0-4edd-ba9d-683a69a70f72/src/.spruce/schemas/schemas.types.ts',
-            action: 'updated',
-        },
-    ], {
-        action: 'star',
-    }, /could not find(.*?)"action": "star"/gis),
-    test("include fails when can't find in an array", [
-        {
-            name: 'schemas.types.ts',
-            description: 'Every schema you need based on all your contracts',
-            path: '/var/folders/qw/v2bfr0c94bn37vclwvcltsj40000gn/tmp/5b49b673-7df0-4edd-ba9d-683a69a70f72/src/.spruce/schemas/schemas.types.ts',
-            action: 'updated',
-        },
-    ], {
-        name: 'schemas.types.ts',
-        action: '2',
-    }, /could not find(.*?)"name": "schemas.types.ts"/gis),
-    test('include fails object props against regex', {
-        results: {
-            errors: [new Error('test'), new Error('test2')],
-        },
-    }, {
-        'results.errors[].stack': /test3/,
-    }, /could not find match/i),
-    test('include fails when passed an array and matching against object', ['hey', 'there'], { name: 'hey', foo: 'bar' }, /could not find/i),
-    test('include fails when passed an array and matching against object with numbers', [6, 7], { name: 7, foo: 6 }, /could not find/i),
-    test('include matches when passed an array and matching against numbers', [6, 7], 9),
-    test('include fails when searching an object for a regex', { foo: 'bar', taco: 'bravo' }, /yummy/)
-], AssertTest, "doesIncludeThrowsAsExpected", null);
-__decorate([
-    test()
-], AssertTest, "hasAllFunctionsAndPasses", null);
-__decorate([
-    test()
-], AssertTest, "hasAllFunctionsAndFails", null);
-__decorate([
-    test()
-], AssertTest, "doesThrowIncludesOriginalStackTrace", null);
-__decorate([
-    test()
-], AssertTest, "isTruthy", null);
-__decorate([
-    test()
-], AssertTest, "isFalsy", null);
-__decorate([
-    test()
-], AssertTest, "isString", null);
-__decorate([
-    test()
-], AssertTest, "isTrue", null);
-__decorate([
-    test()
-], AssertTest, "isFalse", null);
-__decorate([
-    test()
-], AssertTest, "deepEqual", null);
-__decorate([
-    test()
-], AssertTest, "isUndefined", null);
-__decorate([
-    test()
-], AssertTest, "isNotEqual", null);
-__decorate([
-    test()
-], AssertTest, "fail", null);
-__decorate([
-    test()
-], AssertTest, "isObject", null);
-__decorate([
-    test()
-], AssertTest, "isLength", null);
-__decorate([
-    test()
-], AssertTest, "isNull", null);
-__decorate([
-    test()
-], AssertTest, "isExactType", null);
-__decorate([
-    test()
-], AssertTest, "isArray", null);
-__decorate([
-    test()
-], AssertTest, "isNumber", null);
-__decorate([
-    test.skip('Example of pretty print. Remove skip() to see. Always fails.')
-], AssertTest, "printsNiceDiff", null);

package/build/esm/__tests__/SpruceTest.test.d.ts

@@ -1,12 +0,0 @@
-import AbstractSpruceTest from '../AbstractSpruceTest';
-export default class SpruceTest extends AbstractSpruceTest {
-    protected static beforeAll(): Promise<void>;
-    protected static beforeEach(): Promise<void>;
-    protected static afterEach(): Promise<void>;
-    protected static doesCallBeforeAll(): Promise<void>;
-    protected static basicPassingTest(): Promise<void>;
-    protected static canAccessVarsFromDecorator(hello: string, world: string): Promise<void>;
-    protected static calledBeforeAndAfterEach(): Promise<void>;
-    protected static asyncDebuggerWaits(): Promise<void>;
-    protected static todo(): Promise<void>;
-}

package/build/esm/__tests__/SpruceTest.test.js

@@ -1,91 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-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 AbstractSpruceTest from '../AbstractSpruceTest.js';
-import assert from '../assert.js';
-import test from '../decorators.js';
-let beforeAllCount = 0;
-let beforeEachCount = 0;
-let afterEachCount = 0;
-export default class SpruceTest extends AbstractSpruceTest {
-    static beforeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            beforeAllCount += 1;
-        });
-    }
-    static beforeEach() {
-        return __awaiter(this, void 0, void 0, function* () {
-            beforeEachCount += 1;
-        });
-    }
-    static afterEach() {
-        return __awaiter(this, void 0, void 0, function* () {
-            afterEachCount += 1;
-        });
-    }
-    static doesCallBeforeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isEqual(beforeAllCount, 1);
-        });
-    }
-    static basicPassingTest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isTrue(true);
-            assert.isFalse(false);
-            assert.isEqual(5, 5, `Thing's don't equal`);
-        });
-    }
-    static canAccessVarsFromDecorator(hello, world) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isEqual(hello, 'hello');
-            assert.isEqual(world, 'world');
-        });
-    }
-    static calledBeforeAndAfterEach() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.isEqual(beforeEachCount, 4);
-            assert.isEqual(afterEachCount, 3);
-        });
-    }
-    static asyncDebuggerWaits() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.wait(1000);
-            assert.isTruthy(results);
-        });
-    }
-    static todo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO
-        });
-    }
-}
-__decorate([
-    test()
-], SpruceTest, "doesCallBeforeAll", null);
-__decorate([
-    test()
-], SpruceTest, "basicPassingTest", null);
-__decorate([
-    test('can pass variables to test handler from decorator', 'hello', 'world')
-], SpruceTest, "canAccessVarsFromDecorator", null);
-__decorate([
-    test()
-], SpruceTest, "calledBeforeAndAfterEach", null);
-__decorate([
-    test()
-], SpruceTest, "asyncDebuggerWaits", null);
-__decorate([
-    test.todo('can create a TODO test')
-], SpruceTest, "todo", null);

package/build/esm/__tests__/StackCleaner.test.d.ts

@@ -1,4 +0,0 @@
-import AbstractSpruceTest from '../AbstractSpruceTest';
-export default class ErrorStackTest extends AbstractSpruceTest {
-    protected static removesExpected(stack: string, expected: string): Promise<void>;
-}