@sprucelabs/spruce-test-fixtures 45.2.9 → 46.0.2

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

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

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

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

@@ -0,0 +1,79 @@
+"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 test_1 = __importStar(require("@sprucelabs/test"));
+const test_utils_1 = require("@sprucelabs/test-utils");
+const FixtureFactory_1 = __importDefault(require("../../tests/fixtures/FixtureFactory"));
+const MercuryFixture_1 = __importDefault(require("../../tests/fixtures/MercuryFixture"));
+const OrganizationFixture_1 = __importDefault(require("../../tests/fixtures/OrganizationFixture"));
+const PersonFixture_1 = __importDefault(require("../../tests/fixtures/PersonFixture"));
+const SkillFixture_1 = __importDefault(require("../../tests/fixtures/SkillFixture"));
+class FixtureFactoryTest extends test_1.default {
+    static throwsWithBadFixture() {
+        //@ts-ignore
+        const err = test_1.assert.doesThrow(() => this.Fixture().Fixture('taco'));
+        test_utils_1.errorAssert.assertError(err, 'INVALID_FIXTURE', {
+            suppliedName: 'taco',
+        });
+    }
+    static getsFixture(name, Class) {
+        //@ts-ignore
+        const fixture = this.Fixture().Fixture(name);
+        test_1.assert.isTrue(fixture instanceof Class);
+    }
+    static Fixture() {
+        return new FixtureFactory_1.default({ cwd: this.cwd });
+    }
+    static async destroyDisconnectsClient() {
+        const { client } = await this.Fixture()
+            .Fixture('person')
+            .loginAsDemoPerson();
+        test_1.assert.isTrue(client.isConnected());
+        await FixtureFactory_1.default.destroy();
+        test_1.assert.isFalse(client.isConnected());
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], FixtureFactoryTest, "throwsWithBadFixture", null);
+__decorate([
+    (0, test_1.test)('person fixture', 'person', PersonFixture_1.default),
+    (0, test_1.test)('mercury fixture', 'mercury', MercuryFixture_1.default),
+    (0, test_1.test)('org fixture', 'organization', OrganizationFixture_1.default),
+    (0, test_1.test)('skill fixture', 'skill', SkillFixture_1.default)
+], FixtureFactoryTest, "getsFixture", null);
+__decorate([
+    (0, test_1.test)()
+], FixtureFactoryTest, "destroyDisconnectsClient", null);
+exports.default = FixtureFactoryTest;

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

@@ -0,0 +1,15 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class LocationFixtureTest extends AbstractSpruceFixtureTest {
+    protected static beforeEach(): Promise<void>;
+    protected static canCreateWithSpecificOrg(): Promise<void>;
+    protected static canCreatLocationWithNoParams(): Promise<void>;
+    protected static isNotPartOfLocationToStart(): Promise<void>;
+    protected static canAddPersonToLocation(): Promise<void>;
+    protected static throwsWhenTryingToRemovePersonWithBadIds(): Promise<void>;
+    protected static canRemoveRole(): Promise<void>;
+    private static isPersonPartOfLocation;
+    protected static seedLocationAndAddPerson(): Promise<{
+        location: import("@sprucelabs/schema").SchemaStaticValues<import("@sprucelabs/mercury-types").SpruceSchemas.Spruce.v2020_07_22.LocationSchema, false, import("@sprucelabs/schema").SchemaOptionalFieldNames<import("@sprucelabs/mercury-types").SpruceSchemas.Spruce.v2020_07_22.LocationSchema>, import("@sprucelabs/schema").StaticSchemaAllValues<import("@sprucelabs/mercury-types").SpruceSchemas.Spruce.v2020_07_22.LocationSchema, false>>;
+        person: import("@sprucelabs/mercury-types").SpruceSchemas.Spruce.v2020_07_22.Person;
+    }>;
+}

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

@@ -0,0 +1,128 @@
+"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 };
+};
+var LocationFixtureTest_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+let LocationFixtureTest = LocationFixtureTest_1 = class LocationFixtureTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        await this.seeder.resetAccount();
+        await this.seeder.resetAccount(constants_1.DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER);
+    }
+    static async canCreateWithSpecificOrg() {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'Location fixture org',
+        });
+        const location = await this.locations.seedDemoLocation({
+            name: 'Location fixture location',
+            organizationId: org.id,
+        });
+        test_1.assert.isEqual(org.id, location.organizationId);
+    }
+    static async canCreatLocationWithNoParams() {
+        const location = await this.locations.seedDemoLocation({});
+        test_1.assert.isTruthy(location);
+    }
+    static async isNotPartOfLocationToStart() {
+        const location = await this.locations.seedDemoLocation({
+            name: 'Location fixture location',
+        });
+        const { person } = await this.people.loginAsDemoPerson(constants_1.DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER);
+        const isHired = await this.locations.isPartOfLocation({
+            personId: person.id,
+            locationId: location.id,
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+        });
+        test_1.assert.isFalse(isHired);
+    }
+    static async canAddPersonToLocation() {
+        const { person, location } = await this.seedLocationAndAddPerson();
+        const isHired = await LocationFixtureTest_1.isPersonPartOfLocation(person.id, location.id);
+        test_1.assert.isTrue(isHired);
+    }
+    static async throwsWhenTryingToRemovePersonWithBadIds() {
+        await test_1.assert.doesThrowAsync(() => this.locations.removePerson({
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+            personId: 'aoeu',
+            locationId: 'aoeu',
+            roleBase: 'test',
+            organizationId: '234',
+        }));
+    }
+    static async canRemoveRole() {
+        const { person, location } = await this.seedLocationAndAddPerson();
+        await this.locations.removePerson({
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+            personId: person.id,
+            locationId: location.id,
+            organizationId: location.organizationId,
+            roleBase: 'guest',
+        });
+        const isHired = await this.isPersonPartOfLocation(person.id, location.id);
+        test_1.assert.isFalse(isHired);
+    }
+    static async isPersonPartOfLocation(personId, locationId) {
+        return await this.locations.isPartOfLocation({
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+            personId,
+            locationId,
+        });
+    }
+    static async seedLocationAndAddPerson() {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'Location fixture org',
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+        });
+        await this.organizations.seedDemoOrganization({
+            name: 'Outside org',
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER,
+        });
+        const location = await this.locations.seedDemoLocation({
+            name: 'Location fixture location',
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+            organizationId: org.id,
+        });
+        const { person } = await this.people.loginAsDemoPerson(constants_1.DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER);
+        await this.locations.addPerson({
+            personId: person.id,
+            organizationId: org.id,
+            locationId: location.id,
+            roleBase: 'guest',
+            phone: constants_1.DEMO_NUMBER_LOCATION_FIXTURE,
+        });
+        return { location, person };
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], LocationFixtureTest, "canCreateWithSpecificOrg", null);
+__decorate([
+    (0, test_1.test)()
+], LocationFixtureTest, "canCreatLocationWithNoParams", null);
+__decorate([
+    (0, test_1.test)()
+], LocationFixtureTest, "isNotPartOfLocationToStart", null);
+__decorate([
+    (0, test_1.test)()
+], LocationFixtureTest, "canAddPersonToLocation", null);
+__decorate([
+    (0, test_1.test)()
+], LocationFixtureTest, "throwsWhenTryingToRemovePersonWithBadIds", null);
+__decorate([
+    (0, test_1.test)()
+], LocationFixtureTest, "canRemoveRole", null);
+LocationFixtureTest = LocationFixtureTest_1 = __decorate([
+    fake_1.default.login(constants_1.DEMO_NUMBER_LOCATION_FIXTURE)
+], LocationFixtureTest);
+exports.default = LocationFixtureTest;

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

@@ -0,0 +1,12 @@
+import { AbstractSpruceFixtureTest } from '../..';
+export default class LoginDecoratorHandlingProxiesForMeTest extends AbstractSpruceFixtureTest {
+    private static lastToken?;
+    protected static proxyTokenGeneratorReturnsExpectedProxyToken(expected: string): Promise<void>;
+    protected static onlyEmitsEventOnce(): Promise<void>;
+    protected static tokenSetBackAfterEachTest(): Promise<void>;
+    protected static tokenBackToOriginLoggedInPerson(): Promise<void>;
+    protected static loggingAnAsDemoPerson2AgainSetsValidProxy(): Promise<void>;
+    private static getDecorator;
+    private static generateToken;
+    private static loginAsSecondPerson;
+}

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

@@ -0,0 +1,92 @@
+"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 spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+const ClientProxyDecorator_1 = __importDefault(require("../../ClientProxyDecorator"));
+const constants_1 = require("../../tests/constants");
+let LoginDecoratorHandlingProxiesForMeTest = class LoginDecoratorHandlingProxiesForMeTest extends __1.AbstractSpruceFixtureTest {
+    static async proxyTokenGeneratorReturnsExpectedProxyToken(expected) {
+        await __1.login.getClient().on('register-proxy-token::v2020_12_25', () => {
+            return {
+                token: expected,
+            };
+        });
+        const token = await this.generateToken();
+        test_1.assert.isEqual(token, expected);
+    }
+    static async onlyEmitsEventOnce() {
+        let hitCount = 0;
+        await __1.login.getClient().on('register-proxy-token::v2020_12_25', () => {
+            hitCount++;
+            return {
+                token: 'aoeu',
+            };
+        });
+        const generator = this.getDecorator().getProxyTokenGenerator();
+        await (generator === null || generator === void 0 ? void 0 : generator());
+        test_1.assert.isEqual(hitCount, 0);
+        await (generator === null || generator === void 0 ? void 0 : generator());
+        await (generator === null || generator === void 0 ? void 0 : generator());
+        test_1.assert.isEqual(hitCount, 0);
+    }
+    static async tokenSetBackAfterEachTest() {
+        this.lastToken = await this.generateToken();
+        await this.loginAsSecondPerson();
+        const newToken = await this.generateToken();
+        test_1.assert.isNotEqual(this.lastToken, newToken);
+    }
+    static async tokenBackToOriginLoggedInPerson() {
+        const token = await this.generateToken();
+        test_1.assert.isEqual(this.lastToken, token);
+    }
+    static async loggingAnAsDemoPerson2AgainSetsValidProxy() {
+        const { client } = await this.loginAsSecondPerson();
+        const token = await this.generateToken();
+        const results = await client.emit('whoami::v2020_12_25', {
+            source: {
+                proxyToken: token,
+            },
+        });
+        spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+    }
+    static getDecorator() {
+        return ClientProxyDecorator_1.default.getInstance();
+    }
+    static async generateToken() {
+        const generator = this.getDecorator().getProxyTokenGenerator();
+        const token = await (generator === null || generator === void 0 ? void 0 : generator());
+        return token;
+    }
+    static async loginAsSecondPerson() {
+        return this.Fixture('view').loginAsDemoPerson(constants_1.DEMO_NUMBER_LOGIN_DECORATOR_2);
+    }
+};
+__decorate([
+    (0, test_1.test)('proxy set to random', `${Math.random() * new Date().getTime()}`)
+], LoginDecoratorHandlingProxiesForMeTest, "proxyTokenGeneratorReturnsExpectedProxyToken", null);
+__decorate([
+    (0, test_1.test)()
+], LoginDecoratorHandlingProxiesForMeTest, "onlyEmitsEventOnce", null);
+__decorate([
+    (0, test_1.test)()
+], LoginDecoratorHandlingProxiesForMeTest, "tokenSetBackAfterEachTest", null);
+__decorate([
+    (0, test_1.test)()
+], LoginDecoratorHandlingProxiesForMeTest, "tokenBackToOriginLoggedInPerson", null);
+__decorate([
+    (0, test_1.test)()
+], LoginDecoratorHandlingProxiesForMeTest, "loggingAnAsDemoPerson2AgainSetsValidProxy", null);
+LoginDecoratorHandlingProxiesForMeTest = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER_LOGIN_DECORATOR)
+], LoginDecoratorHandlingProxiesForMeTest);
+exports.default = LoginDecoratorHandlingProxiesForMeTest;

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

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

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

@@ -0,0 +1,29 @@
+"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 mercury_client_1 = require("@sprucelabs/mercury-client");
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+const constants_1 = require("../../tests/constants");
+let MakingSureLocalEventsAreHandledLocallyTest = class MakingSureLocalEventsAreHandledLocallyTest extends __1.AbstractSpruceFixtureTest {
+    static async throwsWhenNoListenerSetForLocalEvent() {
+        await this.SkillFromTestDir('skill');
+        const skill = await this.Fixture('skill').seedDemoSkill();
+        spruce_skill_utils_1.AuthService.Auth(this.cwd).updateCurrentSkill(skill);
+        await __1.MercuryFixture.beforeEach(this.cwd);
+        test_1.assert.isEqualDeep(mercury_client_1.MercuryTestClient.getNamespacesThatMustBeHandledLocally(), [skill.slug]);
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], MakingSureLocalEventsAreHandledLocallyTest, "throwsWhenNoListenerSetForLocalEvent", null);
+MakingSureLocalEventsAreHandledLocallyTest = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER_HANDLING_EVENTS_LOCALLY)
+], MakingSureLocalEventsAreHandledLocallyTest);
+exports.default = MakingSureLocalEventsAreHandledLocallyTest;

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

@@ -0,0 +1,19 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class MercuryFixtureTest extends AbstractSpruceFixtureTest {
+    private static fixture;
+    protected static beforeEach(): Promise<void>;
+    protected static hasDefaultContractByDefault(): Promise<void>;
+    protected static canGetMoreThanOneClient(): Promise<void>;
+    protected static canCreateMercuryFixture(): Promise<void>;
+    protected static returnsConnectedClient(): Promise<void>;
+    protected static returnsSameClientOnSecondConnect(): Promise<void>;
+    protected static importsContractIfLocalOneIsGenerated(sigs: any[]): Promise<void>;
+    protected static beforeEachResetsBackToSavedContract(): Promise<void>;
+    protected static typesTestProperly(): Promise<void>;
+    protected static canSetDefaultClient(): Promise<void>;
+    protected static allClientsGoingForwardUseThatClient(): Promise<void>;
+    protected static resetsDefaultClientBeforeEach(): Promise<void>;
+    protected static canForceNewClient(): Promise<void>;
+    private static connectToApi;
+    private static createDirWriteContractFileAndSetCwd;
+}