@sprucelabs/spruce-test-fixtures 45.2.9 → 46.0.2

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

@@ -0,0 +1,61 @@
+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, { test, assert } from '@sprucelabs/test';
+import { errorAssert } from '@sprucelabs/test-utils';
+import FixtureFactory from '../../tests/fixtures/FixtureFactory.js';
+import MercuryFixture from '../../tests/fixtures/MercuryFixture.js';
+import OrganizationFixture from '../../tests/fixtures/OrganizationFixture.js';
+import PersonFixture from '../../tests/fixtures/PersonFixture.js';
+import SkillFixture from '../../tests/fixtures/SkillFixture.js';
+export default class FixtureFactoryTest extends AbstractSpruceTest {
+    static throwsWithBadFixture() {
+        //@ts-ignore
+        const err = assert.doesThrow(() => this.Fixture().Fixture('taco'));
+        errorAssert.assertError(err, 'INVALID_FIXTURE', {
+            suppliedName: 'taco',
+        });
+    }
+    static getsFixture(name, Class) {
+        //@ts-ignore
+        const fixture = this.Fixture().Fixture(name);
+        assert.isTrue(fixture instanceof Class);
+    }
+    static Fixture() {
+        return new FixtureFactory({ cwd: this.cwd });
+    }
+    static destroyDisconnectsClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = yield this.Fixture()
+                .Fixture('person')
+                .loginAsDemoPerson();
+            assert.isTrue(client.isConnected());
+            yield FixtureFactory.destroy();
+            assert.isFalse(client.isConnected());
+        });
+    }
+}
+__decorate([
+    test()
+], FixtureFactoryTest, "throwsWithBadFixture", null);
+__decorate([
+    test('person fixture', 'person', PersonFixture),
+    test('mercury fixture', 'mercury', MercuryFixture),
+    test('org fixture', 'organization', OrganizationFixture),
+    test('skill fixture', 'skill', SkillFixture)
+], FixtureFactoryTest, "getsFixture", null);
+__decorate([
+    test()
+], FixtureFactoryTest, "destroyDisconnectsClient", null);

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

@@ -0,0 +1,153 @@
+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());
+    });
+};
+var LocationFixtureTest_1;
+import { test, assert } from '@sprucelabs/test';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER_LOCATION_FIXTURE, DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER, } from '../../tests/constants.js';
+import fake from '../../tests/decorators/fake.js';
+let LocationFixtureTest = LocationFixtureTest_1 = class LocationFixtureTest 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);
+            yield this.seeder.resetAccount();
+            yield this.seeder.resetAccount(DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER);
+        });
+    }
+    static canCreateWithSpecificOrg() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.organizations.seedDemoOrganization({
+                name: 'Location fixture org',
+            });
+            const location = yield this.locations.seedDemoLocation({
+                name: 'Location fixture location',
+                organizationId: org.id,
+            });
+            assert.isEqual(org.id, location.organizationId);
+        });
+    }
+    static canCreatLocationWithNoParams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const location = yield this.locations.seedDemoLocation({});
+            assert.isTruthy(location);
+        });
+    }
+    static isNotPartOfLocationToStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const location = yield this.locations.seedDemoLocation({
+                name: 'Location fixture location',
+            });
+            const { person } = yield this.people.loginAsDemoPerson(DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER);
+            const isHired = yield this.locations.isPartOfLocation({
+                personId: person.id,
+                locationId: location.id,
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+            });
+            assert.isFalse(isHired);
+        });
+    }
+    static canAddPersonToLocation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { person, location } = yield this.seedLocationAndAddPerson();
+            const isHired = yield LocationFixtureTest_1.isPersonPartOfLocation(person.id, location.id);
+            assert.isTrue(isHired);
+        });
+    }
+    static throwsWhenTryingToRemovePersonWithBadIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield assert.doesThrowAsync(() => this.locations.removePerson({
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+                personId: 'aoeu',
+                locationId: 'aoeu',
+                roleBase: 'test',
+                organizationId: '234',
+            }));
+        });
+    }
+    static canRemoveRole() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { person, location } = yield this.seedLocationAndAddPerson();
+            yield this.locations.removePerson({
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+                personId: person.id,
+                locationId: location.id,
+                organizationId: location.organizationId,
+                roleBase: 'guest',
+            });
+            const isHired = yield this.isPersonPartOfLocation(person.id, location.id);
+            assert.isFalse(isHired);
+        });
+    }
+    static isPersonPartOfLocation(personId, locationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.locations.isPartOfLocation({
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+                personId,
+                locationId,
+            });
+        });
+    }
+    static seedLocationAndAddPerson() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.organizations.seedDemoOrganization({
+                name: 'Location fixture org',
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+            });
+            yield this.organizations.seedDemoOrganization({
+                name: 'Outside org',
+                phone: DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER,
+            });
+            const location = yield this.locations.seedDemoLocation({
+                name: 'Location fixture location',
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+                organizationId: org.id,
+            });
+            const { person } = yield this.people.loginAsDemoPerson(DEMO_NUMBER_LOCATION_FIXTURE_OUTSIDER);
+            yield this.locations.addPerson({
+                personId: person.id,
+                organizationId: org.id,
+                locationId: location.id,
+                roleBase: 'guest',
+                phone: DEMO_NUMBER_LOCATION_FIXTURE,
+            });
+            return { location, person };
+        });
+    }
+};
+__decorate([
+    test()
+], LocationFixtureTest, "canCreateWithSpecificOrg", null);
+__decorate([
+    test()
+], LocationFixtureTest, "canCreatLocationWithNoParams", null);
+__decorate([
+    test()
+], LocationFixtureTest, "isNotPartOfLocationToStart", null);
+__decorate([
+    test()
+], LocationFixtureTest, "canAddPersonToLocation", null);
+__decorate([
+    test()
+], LocationFixtureTest, "throwsWhenTryingToRemovePersonWithBadIds", null);
+__decorate([
+    test()
+], LocationFixtureTest, "canRemoveRole", null);
+LocationFixtureTest = LocationFixtureTest_1 = __decorate([
+    fake.login(DEMO_NUMBER_LOCATION_FIXTURE)
+], LocationFixtureTest);
+export default LocationFixtureTest;

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

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

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

@@ -0,0 +1,38 @@
+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 { AuthService } from '@sprucelabs/spruce-skill-utils';
+import { assert, test } from '@sprucelabs/test';
+import { AbstractSpruceFixtureTest, login, MercuryFixture } from '../../index.js';
+import { DEMO_NUMBER_HANDLING_EVENTS_LOCALLY } from '../../tests/constants.js';
+let MakingSureLocalEventsAreHandledLocallyTest = class MakingSureLocalEventsAreHandledLocallyTest extends AbstractSpruceFixtureTest {
+    static throwsWhenNoListenerSetForLocalEvent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.SkillFromTestDir('skill');
+            const skill = yield this.Fixture('skill').seedDemoSkill();
+            AuthService.Auth(this.cwd).updateCurrentSkill(skill);
+            yield MercuryFixture.beforeEach(this.cwd);
+            assert.isEqualDeep(MercuryTestClient.getNamespacesThatMustBeHandledLocally(), [skill.slug]);
+        });
+    }
+};
+__decorate([
+    test()
+], MakingSureLocalEventsAreHandledLocallyTest, "throwsWhenNoListenerSetForLocalEvent", null);
+MakingSureLocalEventsAreHandledLocallyTest = __decorate([
+    login(DEMO_NUMBER_HANDLING_EVENTS_LOCALLY)
+], MakingSureLocalEventsAreHandledLocallyTest);
+export default MakingSureLocalEventsAreHandledLocallyTest;

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

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

@@ -0,0 +1,209 @@
+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 { coreEventContracts } from '@sprucelabs/mercury-core-events';
+import { eventContractUtil } from '@sprucelabs/spruce-event-utils';
+import { diskUtil, HASH_SPRUCE_BUILD_DIR } from '@sprucelabs/spruce-skill-utils';
+import { test, assert } from '@sprucelabs/test';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import FixtureFactory from '../../tests/fixtures/FixtureFactory.js';
+import MercuryFixture from '../../tests/fixtures/MercuryFixture.js';
+export default class MercuryFixtureTest 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.fixture = this.Fixture('mercury');
+        });
+    }
+    static hasDefaultContractByDefault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.fixture.connectToApi();
+            //@ts-ignore
+            assert.isTruthy(client.eventContract);
+            //@ts-ignore
+            assert.isEqual(client.eventContract, coreEventContracts[0]);
+        });
+    }
+    static canGetMoreThanOneClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.fixture.connectToApi({ shouldReUseClient: false });
+            yield this.fixture.connectToApi({ shouldReUseClient: false });
+        });
+    }
+    static canCreateMercuryFixture() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTruthy(this.fixture);
+        });
+    }
+    static returnsConnectedClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.fixture.connectToApi();
+            assert.isTrue(client.isConnected());
+            yield client.disconnect();
+        });
+    }
+    static returnsSameClientOnSecondConnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.fixture.connectToApi();
+            //@ts-ignore
+            client.__monkeyPatch = true;
+            const client2 = yield this.fixture.connectToApi();
+            //@ts-ignore
+            assert.isTrue(client2.__monkeyPatch);
+            yield client.disconnect();
+            assert.isFalse(client2.isConnected());
+        });
+    }
+    static importsContractIfLocalOneIsGenerated(sigs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.createDirWriteContractFileAndSetCwd(sigs);
+            const client = yield this.connectToApi();
+            //@ts-ignore
+            assert.isTruthy(client.eventContract);
+            assert.doesInclude(
+            //@ts-ignore
+            client.eventContract.eventSignatures, sigs[0].eventSignatures);
+            eventContractUtil.getSignatureByName(
+            //@ts-ignore
+            client.eventContract, 'add-role::v2020_12_25');
+        });
+    }
+    static beforeEachResetsBackToSavedContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.createDirWriteContractFileAndSetCwd([
+                {
+                    eventSignatures: {
+                        ['new-event']: true,
+                    },
+                },
+            ]);
+            const client = (yield this.connectToApi());
+            yield MercuryFixture.beforeEach(this.cwd);
+            yield client.on('new-event', () => { });
+        });
+    }
+    static typesTestProperly() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const test = () => {
+                return {};
+            };
+            const value = test();
+            assert.isTruthy(value);
+        });
+    }
+    static canSetDefaultClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isFunction(MercuryFixture.setDefaultClient);
+            const client = yield this.connectToApi();
+            MercuryFixture.setDefaultClient(client);
+            assert.isEqual(MercuryFixture.getDefaultClient(), client);
+        });
+    }
+    static allClientsGoingForwardUseThatClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.connectToApi();
+            MercuryFixture.setDefaultClient(client);
+            const client2 = yield this.connectToApi();
+            assert.isEqual(client, client2);
+        });
+    }
+    static resetsDefaultClientBeforeEach() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.connectToApi();
+            MercuryFixture.setDefaultClient(client);
+            yield MercuryFixture.beforeEach(this.cwd);
+            const client2 = yield this.connectToApi();
+            assert.isNotEqual(client, client2);
+        });
+    }
+    static canForceNewClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.connectToApi();
+            MercuryFixture.setDefaultClient(client);
+            const client2 = yield this.Fixture('mercury').connectToApi({
+                shouldReUseClient: false,
+            });
+            assert.isNotEqual(client, client2);
+        });
+    }
+    static connectToApi(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new FixtureFactory({ cwd: this.cwd })
+                .Fixture('mercury')
+                .connectToApi(options);
+        });
+    }
+    static createDirWriteContractFileAndSetCwd(sigs) {
+        this.cwd = diskUtil.createRandomTempDir();
+        const destination = diskUtil.resolvePath(this.cwd, HASH_SPRUCE_BUILD_DIR, 'events/events.contract.js');
+        const contents = `exports["default"] = ${JSON.stringify([
+            ...coreEventContracts,
+            ...sigs,
+        ])};`;
+        diskUtil.writeFile(destination, contents);
+    }
+}
+__decorate([
+    test()
+], MercuryFixtureTest, "hasDefaultContractByDefault", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "canGetMoreThanOneClient", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "canCreateMercuryFixture", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "returnsConnectedClient", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "returnsSameClientOnSecondConnect", null);
+__decorate([
+    test('auto imports signature 1', [
+        {
+            eventSignatures: {
+                ['taco-bravo']: true,
+            },
+        },
+    ]),
+    test('auto imports signature 2', [
+        {
+            eventSignatures: {
+                ['taco-bravo2']: true,
+            },
+        },
+    ])
+], MercuryFixtureTest, "importsContractIfLocalOneIsGenerated", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "beforeEachResetsBackToSavedContract", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "typesTestProperly", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "canSetDefaultClient", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "allClientsGoingForwardUseThatClient", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "resetsDefaultClientBeforeEach", null);
+__decorate([
+    test()
+], MercuryFixtureTest, "canForceNewClient", null);

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

@@ -0,0 +1,31 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+import { RoleBase } from '../../types/fixture.types';
+export default class OrganizationFixtureTest extends AbstractSpruceFixtureTest {
+    protected static canCreateOrganizationFixture(): Promise<void>;
+    protected static canSeedOrg(): Promise<void>;
+    protected static orgFixtureDestroysOrgs(): Promise<void>;
+    protected static isNotPartOfOrgtoStart(): Promise<void>;
+    protected static updatingBadOrgTHrows(): Promise<void>;
+    protected static canUpdateOrg(): Promise<void>;
+    protected static canUpdateOrgAddress(): Promise<void>;
+    protected static canMakeOrgPublicAndPrivate(): Promise<void>;
+    protected static canAddPersonToOrg(base: RoleBase): Promise<void>;
+    private static isPersonPartOfOrg;
+    protected static isNotInstalledByDefault(): Promise<void>;
+    protected static showsAsInstalled(): Promise<void>;
+    protected static cantInstallWithBadSkill(): Promise<void>;
+    protected static canInstallWithSlug(): Promise<void>;
+    protected static canInstallSkillFromAnotherPerson(): Promise<void>;
+    protected static canDeleteAllExistingOrgs(): Promise<void>;
+    protected static passesThroughAllFieldsToRequest(): Promise<void>;
+    protected static canPassPersonFixture(): void;
+    protected static canSeedOrgWithNoOptions(): Promise<void>;
+    protected static removePersonThrowsWithBadIds(): Promise<void>;
+    protected static canRemovePersonFromOrg(roleBase: RoleBase): Promise<void>;
+    private static Org;
+    private static seedOrgAndHirePerson;
+    private static assertSkillIsInstalled;
+    private static seedOrgAndSkill;
+    private static assertOrgIsPublicValue;
+    private static setAndAssertOrgIsPublic;
+}