@sprucelabs/spruce-test-fixtures 45.2.9 → 46.0.2

package/build/esm/__tests__/behavioral/DbResetsAsExpected.test.js

@@ -0,0 +1,28 @@
+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;
+};
+import { test, assert } from '@sprucelabs/test';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import seed from '../../tests/decorators/seed.js';
+import StoreFixture from '../../tests/fixtures/StoreFixture.js';
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+import GoodStore from '../testDirsAndFiles/one-good-store-skill/build/stores/Good.store.js';
+//do not seed anything else here, this test is to ensure db settings are reset before any
+//seed is called
+export default class DbResetsAsExpectedTest extends AbstractSpruceFixtureTest {
+    static shouldBeReset() {
+        assert.isEqual(process.env.DB_NAME, 'memory');
+        assert.isEqual(process.env.DB_CONNECTION_STRING, 'memory://');
+    }
+    static doesNothing() { }
+}
+__decorate([
+    test()
+], DbResetsAsExpectedTest, "shouldBeReset", null);
+__decorate([
+    seed('good', 1)
+], DbResetsAsExpectedTest, "doesNothing", null);
+StoreFixture.setStore('good', GoodStore);

package/build/esm/__tests__/behavioral/DecoratoringEmitToPassThroughProxy.test.d.ts

@@ -0,0 +1,15 @@
+import { AbstractSpruceFixtureTest } from '../..';
+export default class DecoratingEmitToPassThroughProxyTest extends AbstractSpruceFixtureTest {
+    private static lastInstance;
+    protected static sharesInstance(): void;
+    protected static canClearInstance(): void;
+    protected static canGetAndSetProxyGenerator(): void;
+    protected static canSetDefaultProxyPassThrough(id: string): Promise<void>;
+    protected static canSetTokenWhileDecorating(): Promise<void>;
+    protected static decoratorPassProps(): Promise<void>;
+    private static assertPropsCopied;
+    protected static instanceIsSameEachTest(): Promise<void>;
+    protected static loginSetsUpProxyTokenGenerator(): Promise<void>;
+    private static assertProxyEquals;
+    private static getDecorator;
+}

package/build/esm/__tests__/behavioral/DecoratoringEmitToPassThroughProxy.test.js

@@ -0,0 +1,125 @@
+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 { test, assert } from '@sprucelabs/test';
+import { AbstractSpruceFixtureTest, login } from '../../index.js';
+import ClientProxyDecorator from '../../ClientProxyDecorator.js';
+import { DEMO_NUMBER } from '../../tests/constants.js';
+let DecoratingEmitToPassThroughProxyTest = class DecoratingEmitToPassThroughProxyTest extends AbstractSpruceFixtureTest {
+    static sharesInstance() {
+        const instance = this.getDecorator();
+        assert.isEqual(instance, ClientProxyDecorator.getInstance());
+    }
+    static canClearInstance() {
+        const instance = this.getDecorator();
+        ClientProxyDecorator.clearInstance();
+        assert.isNotEqual(instance, this.getDecorator());
+    }
+    static canGetAndSetProxyGenerator() {
+        const instance = this.getDecorator();
+        const cb = () => __awaiter(this, void 0, void 0, function* () { return '12345'; });
+        instance.setProxyTokenGenerator(cb);
+        assert.isEqual(instance.getProxyTokenGenerator(), cb);
+    }
+    static canSetDefaultProxyPassThrough(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = this.getDecorator();
+            instance.setProxyTokenGenerator(() => __awaiter(this, void 0, void 0, function* () { return id; }));
+            const client = instance.decorateEmitToPassProxyToken(login.getClient());
+            yield this.assertProxyEquals(client, id);
+        });
+    }
+    static canSetTokenWhileDecorating() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = this.getDecorator();
+            const client = instance.decorateEmitToPassProxyToken(login.getClient(), '123');
+            yield this.assertProxyEquals(client, '123');
+            this.lastInstance = this.getDecorator();
+        });
+    }
+    static decoratorPassProps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = login.getClient();
+            this.assertPropsCopied(client, 'auth', { skill: true });
+            this.assertPropsCopied(client, 'hell', { world: 'there' });
+        });
+    }
+    static assertPropsCopied(client, key, props) {
+        const instance = this.getDecorator();
+        client[key] = props;
+        const decorated = instance.decorateEmitToPassProxyToken(client);
+        //@ts-ignore
+        assert.isEqualDeep(decorated[key], props);
+    }
+    static instanceIsSameEachTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isEqual(this.lastInstance, this.getDecorator());
+        });
+    }
+    static loginSetsUpProxyTokenGenerator() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const generator = this.getDecorator().getProxyTokenGenerator();
+            assert.isTruthy(generator);
+        });
+    }
+    static assertProxyEquals(client, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let passedSource;
+            yield client.on('whoami::v2020_12_25', ({ source }) => {
+                passedSource = source;
+                return {
+                    type: 'anonymous',
+                    auth: {},
+                };
+            });
+            yield client.emit('whoami::v2020_12_25');
+            assert.isEqual(passedSource.proxyToken, id);
+            yield client.emitAndFlattenResponses('whoami::v2020_12_25');
+            assert.isEqual(passedSource.proxyToken, id);
+        });
+    }
+    static getDecorator() {
+        return ClientProxyDecorator.getInstance();
+    }
+};
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "sharesInstance", null);
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "canClearInstance", null);
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "canGetAndSetProxyGenerator", null);
+__decorate([
+    test('can set token to 234', '234'),
+    test('can set token to waka', 'waka')
+], DecoratingEmitToPassThroughProxyTest, "canSetDefaultProxyPassThrough", null);
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "canSetTokenWhileDecorating", null);
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "decoratorPassProps", null);
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "instanceIsSameEachTest", null);
+__decorate([
+    test()
+], DecoratingEmitToPassThroughProxyTest, "loginSetsUpProxyTokenGenerator", null);
+DecoratingEmitToPassThroughProxyTest = __decorate([
+    login(DEMO_NUMBER)
+], DecoratingEmitToPassThroughProxyTest);
+export default DecoratingEmitToPassThroughProxyTest;

package/build/esm/__tests__/behavioral/DelaysConnectWhenOnlyUsingLoginDecorator.test.d.ts

@@ -0,0 +1,4 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class DelaysConnectWhenOnlyUsingLoginDecoratorTest extends AbstractSpruceFixtureTest {
+    protected static globalEmitterListeningToAuthenticate(): Promise<void>;
+}

package/build/esm/__tests__/behavioral/DelaysConnectWhenOnlyUsingLoginDecorator.test.js

@@ -0,0 +1,40 @@
+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 { MercuryTestClient } from '@sprucelabs/mercury-client';
+import { assert, test } from '@sprucelabs/test';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER } from '../../tests/constants.js';
+import fake from '../../tests/decorators/fake.js';
+process.env.SKILL_ID = 'yay';
+process.env.SKILL_API_KEY = 'yay';
+let DelaysConnectWhenOnlyUsingLoginDecoratorTest = class DelaysConnectWhenOnlyUsingLoginDecoratorTest extends AbstractSpruceFixtureTest {
+    static globalEmitterListeningToAuthenticate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emitter = MercuryTestClient.getInternalEmitter({
+                eventSignatures: {},
+            });
+            //@ts-ignore
+            assert.isTruthy(emitter.listenersByEvent['authenticate::v2020_12_25']);
+        });
+    }
+};
+__decorate([
+    test()
+], DelaysConnectWhenOnlyUsingLoginDecoratorTest, "globalEmitterListeningToAuthenticate", null);
+DelaysConnectWhenOnlyUsingLoginDecoratorTest = __decorate([
+    fake.login(DEMO_NUMBER)
+], DelaysConnectWhenOnlyUsingLoginDecoratorTest);
+export default DelaysConnectWhenOnlyUsingLoginDecoratorTest;

package/build/esm/__tests__/behavioral/DisablingSchemaValidationOnTest.test.d.ts

@@ -0,0 +1,5 @@
+import { AbstractSpruceFixtureTest } from '../..';
+export default class DisablingSchemaValidationOnTestTest extends AbstractSpruceFixtureTest {
+    protected static shouldValidateIsFalse(): void;
+    protected static revertsBeforeEachTest(): void;
+}

package/build/esm/__tests__/behavioral/DisablingSchemaValidationOnTest.test.js

@@ -0,0 +1,23 @@
+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;
+};
+import { test, assert } from '@sprucelabs/test';
+import { AbstractSpruceFixtureTest } from '../../index.js';
+export default class DisablingSchemaValidationOnTestTest extends AbstractSpruceFixtureTest {
+    static shouldValidateIsFalse() {
+        assert.isEqual(process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT, 'false');
+        process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT = 'true';
+    }
+    static revertsBeforeEachTest() {
+        assert.isEqual(process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT, 'false');
+    }
+}
+__decorate([
+    test()
+], DisablingSchemaValidationOnTestTest, "shouldValidateIsFalse", null);
+__decorate([
+    test()
+], DisablingSchemaValidationOnTestTest, "revertsBeforeEachTest", null);

package/build/esm/__tests__/behavioral/DoesntResetAccountIfOnlySeedingLocally.test.d.ts

@@ -0,0 +1,8 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class DoesntResetAccountIfOnlySeedingLocally extends AbstractSpruceFixtureTest {
+    protected static beforeEach(): Promise<void>;
+    protected static doesNotResetAccount(): void;
+    protected static doesNotResetBefore(): Promise<void>;
+    protected static resetAfterSeedingOrgs(): void;
+    protected static shouldNotHaveHit(): void;
+}

package/build/esm/__tests__/behavioral/DoesntResetAccountIfOnlySeedingLocally.test.js

@@ -0,0 +1,76 @@
+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 { MercuryTestClient } from '@sprucelabs/mercury-client';
+import { coreEventContracts } from '@sprucelabs/mercury-core-events';
+import { assert, test } from '@sprucelabs/test';
+import { login, seed, StoreFixture } from '../../index.js';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER_ACCOUNT_RESET } from '../../tests/constants.js';
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+import GoodStore from '../testDirsAndFiles/one-good-store-skill/build/stores/Good.store.js';
+let hitCount = 0;
+MercuryTestClient.reset = () => { };
+//@ts-ignore
+const emitter = MercuryTestClient.getInternalEmitter(coreEventContracts[0]);
+void emitter.on('list-organizations::v2020_12_25', () => {
+    hitCount++;
+    return {
+        organizations: [],
+    };
+});
+let DoesntResetAccountIfOnlySeedingLocally = class DoesntResetAccountIfOnlySeedingLocally extends AbstractSpruceFixtureTest {
+    static beforeEach() {
+        const _super = Object.create(null, {
+            beforeEach: { get: () => super.beforeEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.beforeEach.call(this);
+        });
+    }
+    static doesNotResetAccount() {
+        assert.isEqual(hitCount, 1);
+    }
+    static doesNotResetBefore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isEqual(hitCount, 1);
+        });
+    }
+    static resetAfterSeedingOrgs() {
+        assert.isEqual(hitCount, 2);
+    }
+    static shouldNotHaveHit() {
+        assert.isEqual(hitCount, 2);
+    }
+};
+__decorate([
+    test(),
+    seed('good', 5)
+], DoesntResetAccountIfOnlySeedingLocally, "doesNotResetAccount", null);
+__decorate([
+    test(),
+    seed('organizations', 1)
+], DoesntResetAccountIfOnlySeedingLocally, "doesNotResetBefore", null);
+__decorate([
+    test()
+], DoesntResetAccountIfOnlySeedingLocally, "resetAfterSeedingOrgs", null);
+__decorate([
+    test()
+], DoesntResetAccountIfOnlySeedingLocally, "shouldNotHaveHit", null);
+DoesntResetAccountIfOnlySeedingLocally = __decorate([
+    login(DEMO_NUMBER_ACCOUNT_RESET)
+], DoesntResetAccountIfOnlySeedingLocally);
+export default DoesntResetAccountIfOnlySeedingLocally;
+StoreFixture.setStore('good', GoodStore);

package/build/esm/__tests__/behavioral/DummyStore.d.ts

@@ -0,0 +1,55 @@
+import { AbstractStore } from '@sprucelabs/data-stores';
+import { SpruceSchemas } from '@sprucelabs/mercury-types';
+import { StoreSeedOptions } from '../../types/store.types';
+declare const dummySchema: {
+    id: string;
+    fields: {
+        id: {
+            type: "id";
+        };
+    };
+};
+declare type DummySchema = typeof dummySchema;
+export declare class DummyStore extends AbstractStore<DummySchema> {
+    name: string;
+    protected collectionName: string;
+    protected createSchema: {
+        id: string;
+        fields: {
+            id: {
+                type: "id";
+            };
+        };
+    };
+    protected updateSchema: {
+        id: string;
+        fields: {
+            id: {
+                type: "id";
+            };
+        };
+    };
+    protected fullSchema: {
+        id: string;
+        fields: {
+            id: {
+                type: "id";
+            };
+        };
+    };
+    protected databaseSchema: {
+        id: string;
+        fields: {
+            id: {
+                type: "id";
+            };
+        };
+    };
+    static lastFakedOwner?: SpruceSchemas.Spruce.v2020_07_22.Person;
+    static seedCb?: () => Promise<void> | void;
+    static wasSeedInvoked: boolean;
+    static seedOptions: {};
+    static Store(options: any): DummyStore;
+    seed(options: StoreSeedOptions): Promise<void>;
+}
+export {};

package/build/esm/__tests__/behavioral/DummyStore.js

@@ -0,0 +1,43 @@
+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 { AbstractStore } from '@sprucelabs/data-stores';
+import { buildSchema } from '@sprucelabs/schema';
+const dummySchema = buildSchema({
+    id: 'dummy',
+    fields: {
+        id: {
+            type: 'id',
+        },
+    },
+});
+export class DummyStore extends AbstractStore {
+    constructor() {
+        super(...arguments);
+        this.name = 'Dummy!';
+        this.collectionName = 'dummies';
+        this.createSchema = dummySchema;
+        this.updateSchema = dummySchema;
+        this.fullSchema = dummySchema;
+        this.databaseSchema = dummySchema;
+    }
+    static Store(options) {
+        return new this(options);
+    }
+    seed(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            DummyStore.wasSeedInvoked = true;
+            DummyStore.seedOptions = options;
+            yield ((_a = DummyStore.seedCb) === null || _a === void 0 ? void 0 : _a.call(DummyStore));
+        });
+    }
+}
+DummyStore.wasSeedInvoked = false;
+DummyStore.seedOptions = {};

package/build/esm/__tests__/behavioral/FakingEventResponses.test.d.ts

@@ -0,0 +1,12 @@
+import { AbstractSpruceFixtureTest } from '../..';
+export default class FakingErrorResponsesTest extends AbstractSpruceFixtureTest {
+    private static client;
+    protected static beforeEach(): Promise<void>;
+    protected static throwsWhenFakingResponse(fqen: any, targetAndPayload: any): Promise<void>;
+    protected static onClearsPreviousListeners(fqen: any): Promise<void>;
+    protected static throwsEvenWhenFakingWithPreviousListeners(): Promise<void>;
+    protected static fakeEventsAreClearedFromPreviousTest(): Promise<void>;
+    protected static canFakeEventWithNoResponse(): Promise<void>;
+    protected static canCustomizeTheErrorPassedIn(): Promise<void>;
+    private static assertResponseIsFakeEventError;
+}

package/build/esm/__tests__/behavioral/FakingEventResponses.test.js

@@ -0,0 +1,147 @@
+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 { eventAssertUtil } from '@sprucelabs/spruce-event-utils';
+import { test, assert } from '@sprucelabs/test';
+import { AbstractSpruceFixtureTest } from '../../index.js';
+import SpruceError from '../../errors/SpruceError.js';
+import eventFaker from '../../tests/eventFaker.js';
+export default class FakingErrorResponsesTest extends AbstractSpruceFixtureTest {
+    static beforeEach() {
+        const _super = Object.create(null, {
+            beforeEach: { get: () => super.beforeEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.beforeEach.call(this);
+            this.client = (yield this.mercury.connectToApi());
+        });
+    }
+    static throwsWhenFakingResponse(fqen, targetAndPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield eventFaker.makeEventThrow(fqen);
+            yield this.assertResponseIsFakeEventError(fqen, targetAndPayload);
+        });
+    }
+    static onClearsPreviousListeners(fqen) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let wasOldHit = false;
+            let wasNewHit = false;
+            if (!this.client.doesHandleEvent(fqen)) {
+                this.client.mixinContract({
+                    eventSignatures: {
+                        [fqen]: {},
+                    },
+                });
+            }
+            yield this.client.on(fqen, () => {
+                wasOldHit = true;
+            });
+            yield eventFaker.on(fqen, () => {
+                wasNewHit = true;
+                return {
+                    auth: {},
+                    type: 'anonymous',
+                };
+            });
+            assert.isFalse(wasNewHit);
+            yield this.client.emit(fqen);
+            assert.isFalse(wasOldHit);
+            assert.isTrue(wasNewHit);
+        });
+    }
+    static throwsEvenWhenFakingWithPreviousListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+            //@ts-ignore
+            yield this.client.on('whoami::v2020_12_25', () => __awaiter(this, void 0, void 0, function* () {
+                return {};
+            }));
+            yield eventFaker.makeEventThrow('whoami::v2020_12_25');
+            yield this.assertResponseIsFakeEventError('whoami::v2020_12_25');
+        });
+    }
+    static fakeEventsAreClearedFromPreviousTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.on('request-pin::v2020_12_25', () => __awaiter(this, void 0, void 0, function* () {
+                return {
+                    challenge: 'aoeu',
+                };
+            }));
+            yield this.client.emitAndFlattenResponses('request-pin::v2020_12_25', {
+                payload: {
+                    phone: '+555-000-0001',
+                },
+            });
+        });
+    }
+    static canFakeEventWithNoResponse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fqen = 'test-burrito::v1';
+            this.client.mixinContract({
+                eventSignatures: {
+                    [fqen]: {
+                        isGlobal: true,
+                    },
+                },
+            });
+            yield eventFaker.handleReactiveEvent(fqen);
+            const results = yield this.client.emit(fqen);
+            assert.isEqual(results.totalErrors, 0);
+        });
+    }
+    static canCustomizeTheErrorPassedIn() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const error = new SpruceError({
+                code: 'INVALID_TARGET',
+            });
+            yield eventFaker.makeEventThrow('whoami::v2020_12_25', error);
+            const results = yield this.client.emit('whoami::v2020_12_25');
+            assert.isEqualDeep((_a = results.responses[0].errors) === null || _a === void 0 ? void 0 : _a[0], error);
+        });
+    }
+    static assertResponseIsFakeEventError(fqen, targetAndPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.client.emit(fqen, targetAndPayload);
+            assert.isEqual(results.totalErrors, 1);
+            eventAssertUtil.assertErrorFromResponse(results, 'FAKE_EVENT_ERROR', {
+                fqen,
+            });
+        });
+    }
+}
+__decorate([
+    test('faking whoami::v2020_12_25', 'whoami::v2020_12_25'),
+    test('faking request-pin::v2020_12_25', 'request-pin::v2020_12_25', {
+        payload: {
+            phone: '+555-000-0001',
+        },
+    })
+], FakingErrorResponsesTest, "throwsWhenFakingResponse", null);
+__decorate([
+    test('on clears previous listeners 1', 'whoami::v2020_12_25'),
+    test('on clears previous listeners 2', 'what-the::v2020_12_25')
+], FakingErrorResponsesTest, "onClearsPreviousListeners", null);
+__decorate([
+    test()
+], FakingErrorResponsesTest, "throwsEvenWhenFakingWithPreviousListeners", null);
+__decorate([
+    test()
+], FakingErrorResponsesTest, "fakeEventsAreClearedFromPreviousTest", null);
+__decorate([
+    test()
+], FakingErrorResponsesTest, "canFakeEventWithNoResponse", null);
+__decorate([
+    test()
+], FakingErrorResponsesTest, "canCustomizeTheErrorPassedIn", null);

package/build/esm/__tests__/behavioral/FixtureFactory.test.d.ts

@@ -0,0 +1,7 @@
+import AbstractSpruceTest from '@sprucelabs/test';
+export default class FixtureFactoryTest extends AbstractSpruceTest {
+    protected static throwsWithBadFixture(): void;
+    protected static getsFixture(name: string, Class: any): void;
+    private static Fixture;
+    protected static destroyDisconnectsClient(): Promise<void>;
+}