@sprucelabs/spruce-test-fixtures 45.2.7 → 46.0.0

package/build/__tests__/behavioral/CanUseStoresSetupInBeforeEach.test.d.ts

@@ -0,0 +1,7 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class CanUseStoresSetupInBeforeEachTest extends AbstractSpruceFixtureTest {
+    private static goodStore;
+    protected static beforeEach(): Promise<void>;
+    protected static shouldNotLoseData(): Promise<void>;
+    protected static shouldNotLoseData2(): Promise<void>;
+}

package/build/__tests__/behavioral/CanUseStoresSetupInBeforeEach.test.js

@@ -0,0 +1,41 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@sprucelabs/test");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const seed_1 = __importDefault(require("../../tests/decorators/seed"));
+const StoreFixture_1 = __importDefault(require("../../tests/fixtures/StoreFixture"));
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+const Good_store_1 = __importDefault(require("../testDirsAndFiles/one-good-store-skill/build/stores/Good.store"));
+class CanUseStoresSetupInBeforeEachTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.goodStore = await this.Fixture('store').Store('good');
+    }
+    static async shouldNotLoseData() {
+        const count = await this.goodStore.count({});
+        test_1.assert.isEqual(count, 3);
+    }
+    static async shouldNotLoseData2() {
+        const count = await this.goodStore.count({});
+        test_1.assert.isEqual(count, 10);
+    }
+}
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('good', 3)
+], CanUseStoresSetupInBeforeEachTest, "shouldNotLoseData", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('good', 10)
+], CanUseStoresSetupInBeforeEachTest, "shouldNotLoseData2", null);
+exports.default = CanUseStoresSetupInBeforeEachTest;
+StoreFixture_1.default.setStore('good', Good_store_1.default);

package/build/__tests__/behavioral/DatabaseFixture.test.d.ts

@@ -0,0 +1,7 @@
+import AbstractSpruceTest from '@sprucelabs/test';
+export default class StoreFixtureTest extends AbstractSpruceTest {
+    private static fixture;
+    protected static beforeEach(): Promise<void>;
+    protected static canGetDatabaseFixture(): Promise<void>;
+    protected static canConnectToDabatase(): Promise<void>;
+}

package/build/__tests__/behavioral/DatabaseFixture.test.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_stores_1 = require("@sprucelabs/data-stores");
+const test_1 = __importStar(require("@sprucelabs/test"));
+const FixtureFactory_1 = __importDefault(require("../../tests/fixtures/FixtureFactory"));
+class StoreFixtureTest extends test_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.fixture = new FixtureFactory_1.default({ cwd: this.cwd }).Fixture('database');
+    }
+    static async canGetDatabaseFixture() {
+        test_1.assert.isTruthy(this.fixture);
+    }
+    static async canConnectToDabatase() {
+        const db = await this.fixture.connectToDatabase();
+        test_1.assert.isTrue(db.isConnected());
+        await data_stores_1.DatabaseFixture.destroy();
+        test_1.assert.isFalse(db.isConnected());
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], StoreFixtureTest, "canGetDatabaseFixture", null);
+__decorate([
+    (0, test_1.test)()
+], StoreFixtureTest, "canConnectToDabatase", null);
+exports.default = StoreFixtureTest;

package/build/__tests__/behavioral/DbResetsAsExpected.test.d.ts

@@ -0,0 +1,5 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class DbResetsAsExpectedTest extends AbstractSpruceFixtureTest {
+    protected static shouldBeReset(): void;
+    protected static doesNothing(): void;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@sprucelabs/test");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const seed_1 = __importDefault(require("../../tests/decorators/seed"));
+const StoreFixture_1 = __importDefault(require("../../tests/fixtures/StoreFixture"));
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+const Good_store_1 = __importDefault(require("../testDirsAndFiles/one-good-store-skill/build/stores/Good.store"));
+//do not seed anything else here, this test is to ensure db settings are reset before any
+//seed is called
+class DbResetsAsExpectedTest extends AbstractSpruceFixtureTest_1.default {
+    static shouldBeReset() {
+        test_1.assert.isEqual(process.env.DB_NAME, 'memory');
+        test_1.assert.isEqual(process.env.DB_CONNECTION_STRING, 'memory://');
+    }
+    static doesNothing() { }
+}
+__decorate([
+    (0, test_1.test)()
+], DbResetsAsExpectedTest, "shouldBeReset", null);
+__decorate([
+    (0, seed_1.default)('good', 1)
+], DbResetsAsExpectedTest, "doesNothing", null);
+exports.default = DbResetsAsExpectedTest;
+StoreFixture_1.default.setStore('good', Good_store_1.default);

package/build/__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/__tests__/behavioral/DecoratoringEmitToPassThroughProxy.test.js

@@ -0,0 +1,109 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+const ClientProxyDecorator_1 = __importDefault(require("../../ClientProxyDecorator"));
+const constants_1 = require("../../tests/constants");
+let DecoratingEmitToPassThroughProxyTest = class DecoratingEmitToPassThroughProxyTest extends __1.AbstractSpruceFixtureTest {
+    static sharesInstance() {
+        const instance = this.getDecorator();
+        test_1.assert.isEqual(instance, ClientProxyDecorator_1.default.getInstance());
+    }
+    static canClearInstance() {
+        const instance = this.getDecorator();
+        ClientProxyDecorator_1.default.clearInstance();
+        test_1.assert.isNotEqual(instance, this.getDecorator());
+    }
+    static canGetAndSetProxyGenerator() {
+        const instance = this.getDecorator();
+        const cb = async () => '12345';
+        instance.setProxyTokenGenerator(cb);
+        test_1.assert.isEqual(instance.getProxyTokenGenerator(), cb);
+    }
+    static async canSetDefaultProxyPassThrough(id) {
+        const instance = this.getDecorator();
+        instance.setProxyTokenGenerator(async () => id);
+        const client = instance.decorateEmitToPassProxyToken(__1.login.getClient());
+        await this.assertProxyEquals(client, id);
+    }
+    static async canSetTokenWhileDecorating() {
+        const instance = this.getDecorator();
+        const client = instance.decorateEmitToPassProxyToken(__1.login.getClient(), '123');
+        await this.assertProxyEquals(client, '123');
+        this.lastInstance = this.getDecorator();
+    }
+    static async decoratorPassProps() {
+        const client = __1.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
+        test_1.assert.isEqualDeep(decorated[key], props);
+    }
+    static async instanceIsSameEachTest() {
+        test_1.assert.isEqual(this.lastInstance, this.getDecorator());
+    }
+    static async loginSetsUpProxyTokenGenerator() {
+        const generator = this.getDecorator().getProxyTokenGenerator();
+        test_1.assert.isTruthy(generator);
+    }
+    static async assertProxyEquals(client, id) {
+        let passedSource;
+        await client.on('whoami::v2020_12_25', ({ source }) => {
+            passedSource = source;
+            return {
+                type: 'anonymous',
+                auth: {},
+            };
+        });
+        await client.emit('whoami::v2020_12_25');
+        test_1.assert.isEqual(passedSource.proxyToken, id);
+        await client.emitAndFlattenResponses('whoami::v2020_12_25');
+        test_1.assert.isEqual(passedSource.proxyToken, id);
+    }
+    static getDecorator() {
+        return ClientProxyDecorator_1.default.getInstance();
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "sharesInstance", null);
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "canClearInstance", null);
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "canGetAndSetProxyGenerator", null);
+__decorate([
+    (0, test_1.test)('can set token to 234', '234'),
+    (0, test_1.test)('can set token to waka', 'waka')
+], DecoratingEmitToPassThroughProxyTest, "canSetDefaultProxyPassThrough", null);
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "canSetTokenWhileDecorating", null);
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "decoratorPassProps", null);
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "instanceIsSameEachTest", null);
+__decorate([
+    (0, test_1.test)()
+], DecoratingEmitToPassThroughProxyTest, "loginSetsUpProxyTokenGenerator", null);
+DecoratingEmitToPassThroughProxyTest = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER)
+], DecoratingEmitToPassThroughProxyTest);
+exports.default = DecoratingEmitToPassThroughProxyTest;

package/build/__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/__tests__/behavioral/DelaysConnectWhenOnlyUsingLoginDecorator.test.js

@@ -0,0 +1,34 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mercury_client_1 = require("@sprucelabs/mercury-client");
+const test_1 = require("@sprucelabs/test");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const constants_1 = require("../../tests/constants");
+const fake_1 = __importDefault(require("../../tests/decorators/fake"));
+process.env.SKILL_ID = 'yay';
+process.env.SKILL_API_KEY = 'yay';
+let DelaysConnectWhenOnlyUsingLoginDecoratorTest = class DelaysConnectWhenOnlyUsingLoginDecoratorTest extends AbstractSpruceFixtureTest_1.default {
+    static async globalEmitterListeningToAuthenticate() {
+        const emitter = mercury_client_1.MercuryTestClient.getInternalEmitter({
+            eventSignatures: {},
+        });
+        //@ts-ignore
+        test_1.assert.isTruthy(emitter.listenersByEvent['authenticate::v2020_12_25']);
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], DelaysConnectWhenOnlyUsingLoginDecoratorTest, "globalEmitterListeningToAuthenticate", null);
+DelaysConnectWhenOnlyUsingLoginDecoratorTest = __decorate([
+    fake_1.default.login(constants_1.DEMO_NUMBER)
+], DelaysConnectWhenOnlyUsingLoginDecoratorTest);
+exports.default = DelaysConnectWhenOnlyUsingLoginDecoratorTest;

package/build/__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/__tests__/behavioral/DisablingSchemaValidationOnTest.test.js

@@ -0,0 +1,26 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+class DisablingSchemaValidationOnTestTest extends __1.AbstractSpruceFixtureTest {
+    static shouldValidateIsFalse() {
+        test_1.assert.isEqual(process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT, 'false');
+        process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT = 'true';
+    }
+    static revertsBeforeEachTest() {
+        test_1.assert.isEqual(process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT, 'false');
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], DisablingSchemaValidationOnTestTest, "shouldValidateIsFalse", null);
+__decorate([
+    (0, test_1.test)()
+], DisablingSchemaValidationOnTestTest, "revertsBeforeEachTest", null);
+exports.default = DisablingSchemaValidationOnTestTest;

package/build/__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/__tests__/behavioral/DoesntResetAccountIfOnlySeedingLocally.test.js

@@ -0,0 +1,65 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mercury_client_1 = require("@sprucelabs/mercury-client");
+const mercury_core_events_1 = require("@sprucelabs/mercury-core-events");
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const constants_1 = require("../../tests/constants");
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+const Good_store_1 = __importDefault(require("../testDirsAndFiles/one-good-store-skill/build/stores/Good.store"));
+let hitCount = 0;
+mercury_client_1.MercuryTestClient.reset = () => { };
+//@ts-ignore
+const emitter = mercury_client_1.MercuryTestClient.getInternalEmitter(mercury_core_events_1.coreEventContracts[0]);
+void emitter.on('list-organizations::v2020_12_25', () => {
+    hitCount++;
+    return {
+        organizations: [],
+    };
+});
+let DoesntResetAccountIfOnlySeedingLocally = class DoesntResetAccountIfOnlySeedingLocally extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+    }
+    static doesNotResetAccount() {
+        test_1.assert.isEqual(hitCount, 1);
+    }
+    static async doesNotResetBefore() {
+        test_1.assert.isEqual(hitCount, 1);
+    }
+    static resetAfterSeedingOrgs() {
+        test_1.assert.isEqual(hitCount, 2);
+    }
+    static shouldNotHaveHit() {
+        test_1.assert.isEqual(hitCount, 2);
+    }
+};
+__decorate([
+    (0, test_1.test)(),
+    (0, __1.seed)('good', 5)
+], DoesntResetAccountIfOnlySeedingLocally, "doesNotResetAccount", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, __1.seed)('organizations', 1)
+], DoesntResetAccountIfOnlySeedingLocally, "doesNotResetBefore", null);
+__decorate([
+    (0, test_1.test)()
+], DoesntResetAccountIfOnlySeedingLocally, "resetAfterSeedingOrgs", null);
+__decorate([
+    (0, test_1.test)()
+], DoesntResetAccountIfOnlySeedingLocally, "shouldNotHaveHit", null);
+DoesntResetAccountIfOnlySeedingLocally = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER_ACCOUNT_RESET)
+], DoesntResetAccountIfOnlySeedingLocally);
+exports.default = DoesntResetAccountIfOnlySeedingLocally;
+__1.StoreFixture.setStore('good', Good_store_1.default);

package/build/__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/__tests__/behavioral/DummyStore.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyStore = void 0;
+const data_stores_1 = require("@sprucelabs/data-stores");
+const schema_1 = require("@sprucelabs/schema");
+const dummySchema = (0, schema_1.buildSchema)({
+    id: 'dummy',
+    fields: {
+        id: {
+            type: 'id',
+        },
+    },
+});
+class DummyStore extends data_stores_1.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);
+    }
+    async seed(options) {
+        var _a;
+        DummyStore.wasSeedInvoked = true;
+        DummyStore.seedOptions = options;
+        await ((_a = DummyStore.seedCb) === null || _a === void 0 ? void 0 : _a.call(DummyStore));
+    }
+}
+exports.DummyStore = DummyStore;
+DummyStore.wasSeedInvoked = false;
+DummyStore.seedOptions = {};

package/build/__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;
+}