@sprucelabs/mercury-client 42.0.557 → 42.0.558

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

@@ -1,821 +0,0 @@
-"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_core_events_1 = require("@sprucelabs/mercury-core-events");
-const mercury_types_1 = require("@sprucelabs/mercury-types");
-const spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
-const test_utils_1 = require("@sprucelabs/test-utils");
-const test_utils_2 = require("@sprucelabs/test-utils");
-const __1 = require("../..");
-const SpruceError_1 = __importDefault(require("../../errors/SpruceError"));
-const AbstractClientTest_1 = __importDefault(require("../../tests/AbstractClientTest"));
-const constants_1 = require("../../tests/constants");
-class SimulatingEventsForTestingTest extends AbstractClientTest_1.default {
-    static async beforeEach() {
-        await super.beforeEach();
-        __1.MercuryTestClient.setShouldRequireLocalListeners(false);
-    }
-    static testModeFalseByDefault() {
-        test_utils_1.assert.isFalse(__1.MercuryClientFactory.isInTestMode());
-    }
-    static async canSetTestMode() {
-        this.enableTestMode();
-        test_utils_1.assert.isTrue(__1.MercuryClientFactory.isInTestMode());
-    }
-    static async testClientHandlesDefaultContracts() {
-        const client = await this.connectToApiAsTestClient(true);
-        test_utils_1.assert.isTrue(client.doesHandleEvent(this.eventName));
-        test_utils_1.assert.isFalse(client.doesHandleEvent('taco-bravo'));
-        await client.disconnect();
-    }
-    static async clientKnowsIfIsTestClient() {
-        __1.MercuryClientFactory.setIsTestMode(false);
-        const client = await __1.MercuryClientFactory.Client({
-            host: constants_1.TEST_HOST,
-            allowSelfSignedCrt: true,
-        });
-        test_utils_1.assert.isFalse(client.getIsTestClient());
-        this.enableTestMode();
-        const client2 = await __1.MercuryClientFactory.Client({
-            host: constants_1.TEST_HOST,
-            allowSelfSignedCrt: true,
-        });
-        test_utils_1.assert.isTrue(client2.getIsTestClient());
-    }
-    static async canEmitEventToSelfForTesting(shouldSetDefaultContract) {
-        const client = await this.connectToApiAsTestClient(shouldSetDefaultContract);
-        let wasFired = false;
-        await client.on('did-message::v2020_12_25', async () => {
-            wasFired = true;
-        });
-        await client.emit('did-message::v2020_12_25', {
-            target: {},
-            payload: {
-                message: {
-                    id: 'test',
-                    source: {},
-                    target: {},
-                    body: 'message body',
-                    classification: 'incoming',
-                    dateCreated: 1,
-                },
-            },
-        });
-        test_utils_1.assert.isTrue(wasFired);
-    }
-    static async canEmitToApiWhenNoLocalListenerIsSet() {
-        const client = await this.connectToApiAsTestClient();
-        const results = await client.emit('get-event-contracts::v2020_12_25');
-        const { contracts } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
-        test_utils_1.assert.isArray(contracts);
-        test_utils_1.assert.isObject(contracts[0]);
-        test_utils_1.assert.isObject(contracts[0].eventSignatures['get-event-contracts::v2020_12_25']);
-    }
-    static async canHandleRapidFireConnectsToApi() {
-        const client = await this.connectToApiAsTestClient();
-        await Promise.all([
-            client.emit('get-event-contracts::v2020_12_25'),
-            client.emit('get-event-contracts::v2020_12_25'),
-            client.emit('get-event-contracts::v2020_12_25'),
-        ]);
-    }
-    static async canEmitToSelfUsingToClients() {
-        const [client1, client2] = await Promise.all([
-            this.connectToApiAsTestClient(),
-            this.connectToApiAsTestClient(),
-        ]);
-        let wasFired = false;
-        await client1.on('did-message::v2020_12_25', async () => {
-            wasFired = true;
-        });
-        await client2.emit('did-message::v2020_12_25', {
-            target: {},
-            payload: {
-                message: {
-                    id: 'test',
-                    source: {},
-                    target: {},
-                    body: 'message body',
-                    classification: 'incoming',
-                    dateCreated: 1,
-                },
-            },
-        });
-        test_utils_1.assert.isTrue(wasFired);
-    }
-    static async factoryReturnsSocketIoClient() {
-        const client = await this.connectToApiAsTestClient();
-        test_utils_1.assert.isTrue(client.isConnected());
-        await client.disconnect();
-        test_utils_1.assert.isFalse(client.isConnected());
-    }
-    static async canResetClient() {
-        const client = await this.connectToApiAsTestClient();
-        __1.MercuryTestClient.reset();
-        const err = await test_utils_1.assert.doesThrowAsync(() => client.on('did-message::v2020_12_25', async () => { }));
-        test_utils_2.errorAssert.assertError(err, 'INVALID_EVENT_NAME');
-    }
-    static async canMixinContractsToTestClient() {
-        const [client1, client2] = await Promise.all([
-            this.connectToApiAsTestClient(),
-            this.connectToApiAsTestClient(),
-        ]);
-        this.mixinPayloadLessTestEvent(client1);
-        let hit = false;
-        //@ts-ignore
-        await client2.on(this.testEventName, () => {
-            hit = true;
-        });
-        //@ts-ignore
-        await client1.emit(this.testEventName);
-        test_utils_1.assert.isTruthy(hit);
-    }
-    static async firstTestClientAddsEventToSecondTestClient() {
-        const client1 = await this.connectToApiAsTestClient(false, {
-            eventSignatures: {
-                'my-new-event': {},
-            },
-        });
-        const client2 = await this.connectToApiAsTestClient();
-        test_utils_1.assert.isTrue(client1.doesHandleEvent('my-new-event'));
-        test_utils_1.assert.isTrue(client2.doesHandleEvent('my-new-event'));
-    }
-    static async secondTestClientAddsEventToFirstTestClient() {
-        const client1 = await this.connectToApiAsTestClient();
-        const client2 = await this.connectToApiAsTestClient(false, {
-            eventSignatures: {
-                'my-new-event': {},
-            },
-        });
-        test_utils_1.assert.isTrue(client1.doesHandleEvent('my-new-event'));
-        test_utils_1.assert.isTrue(client2.doesHandleEvent('my-new-event'));
-    }
-    static async includesSourceInEventsEmittedByPerson() {
-        const [client2, { client: client1, person }] = await Promise.all([
-            this.connectToApiAsTestClient(),
-            this.loginAsDemoPerson(),
-        ]);
-        this.mixinPayloadLessTestEvent(client1);
-        let s;
-        //@ts-ignore
-        await client2.on(this.testEventName, ({ source }) => {
-            s = source;
-        });
-        //@ts-ignore
-        await client1.emit(this.testEventName);
-        test_utils_1.assert.isTruthy(s.personId);
-        test_utils_1.assert.isEqual(s.personId, person.id);
-        test_utils_1.assert.isUndefined(s.skillId);
-    }
-    static async doesCheckPermsIfPermissionsIsEmptyArrayOnContract(expected) {
-        __1.MercuryTestClient.setShouldCheckPermissionsOnLocalEvents(expected);
-        const [client2, { client: client1 }] = await Promise.all([
-            this.connectToApiAsTestClient(),
-            this.loginAsDemoPerson(),
-        ]);
-        const contract = {
-            eventSignatures: {
-                [this.testEventName]: {
-                    isGlobal: true,
-                    emitPermissionContract: {
-                        id: 'test',
-                        name: 'Can emit',
-                        permissions: [],
-                    },
-                    responsePayloadSchema: {
-                        id: 'response',
-                        fields: {
-                            hit: {
-                                type: 'boolean',
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        client2.mixinContract(contract);
-        let wasHit = false;
-        await client1.on('does-honor-permission-contract::v2020_12_25', () => {
-            wasHit = true;
-            return {
-                doesHonor: false,
-            };
-        });
-        let s;
-        //@ts-ignore
-        await client1.on(this.testEventName, ({ source }) => {
-            s = source;
-        });
-        //@ts-ignore
-        const results = await client1.emit(this.testEventName);
-        if (expected) {
-            test_utils_1.assert.isAbove(results.totalErrors, 0);
-            test_utils_1.assert.isFalsy(s);
-        }
-        else {
-            test_utils_1.assert.isTruthy(s);
-            test_utils_1.assert.isEqual(results.totalErrors, 0);
-        }
-        test_utils_1.assert.isEqual(wasHit, expected);
-    }
-    static async stillValidatesPayloads() {
-        const [client1, client2] = await Promise.all([
-            this.connectToApiAsTestClient(true),
-            this.connectToApiAsTestClient(true),
-        ]);
-        let hit = false;
-        await client2.on('confirm-pin::v2020_12_25', async () => {
-            hit = true;
-            return {
-                token: 'yes!',
-                person: {},
-            };
-        });
-        const err = await test_utils_1.assert.doesThrowAsync(() => client1.emit('confirm-pin::v2020_12_25', {
-            //@ts-ignore
-            fails: true,
-        }));
-        test_utils_2.errorAssert.assertError(err, 'INVALID_PAYLOAD');
-        test_utils_1.assert.isFalse(hit);
-    }
-    static async includesSourceInEventsEmittedBySkill() {
-        const { personClient, skill1Client, skill2Client, skill1 } = await this.setupOrgAndInstall2Skills();
-        this.mixinPayloadLessTestEvent(personClient);
-        let s;
-        //@ts-ignore
-        await skill2Client.on(this.testEventName, ({ source }) => {
-            s = source;
-        });
-        //@ts-ignore
-        await skill1Client.emit(this.testEventName);
-        test_utils_1.assert.isTruthy(s.skillId);
-        test_utils_1.assert.isEqual(s.skillId, skill1.id);
-        test_utils_1.assert.isUndefined(s.personId);
-    }
-    static async checksPermissionsWhenEmitting() {
-        __1.MercuryTestClient.setShouldCheckPermissionsOnLocalEvents(true);
-        const { skill1, skill1Client, skill2Client, org, personClient } = await this.setupOrgAndInstall2Skills();
-        const eventName = 'event-with-emit-permissions::v2020_05_19';
-        const fqen = `${skill1.slug}.event-with-emit-permissions::v2020_05_19`;
-        const targetWithOrgId = (0, spruce_event_utils_1.buildEmitTargetAndPayloadSchema)({
-            eventName,
-            targetSchema: {
-                id: 'test-target',
-                fields: {
-                    organizationId: {
-                        type: 'id',
-                        isRequired: true,
-                    },
-                },
-            },
-        });
-        //@ts-ignore
-        skill1Client.mixinContract({
-            eventSignatures: {
-                [fqen]: {
-                    emitPayloadSchema: targetWithOrgId,
-                    emitPermissionContract: this.buildEmitPermContract(),
-                },
-            },
-        });
-        const registerEventResults = await skill1Client.emit('register-events::v2020_12_25', {
-            payload: {
-                contract: {
-                    eventSignatures: {
-                        [eventName]: {
-                            emitPayloadSchema: targetWithOrgId,
-                            emitPermissionContract: this.buildEmitPermContract(),
-                        },
-                    },
-                },
-            },
-        });
-        spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(registerEventResults);
-        await skill1Client.on(fqen, async () => { });
-        await this.assertGuestCantEmit(fqen, org.id);
-        await this.assertAnonCantEmit(fqen, org.id);
-        await this.assertAnotherSkillCantEmit(fqen, skill2Client, org.id);
-        await this.assertTeammateCanEmit({
-            fqen,
-            ownerClient: personClient,
-            organizationId: org.id,
-        });
-    }
-    static async localResponsesAreValidated() {
-        const [client1, client2] = await Promise.all([
-            this.connectToApiAsTestClient(true),
-            this.connectToApiAsTestClient(true),
-        ]);
-        //@ts-ignore
-        await client2.on('confirm-pin::v2020_12_25', async () => {
-            return {
-                token: 'yes!',
-                taco: {},
-            };
-        });
-        const results = await client1.emit('confirm-pin::v2020_12_25', {
-            payload: {
-                challenge: '1234',
-                pin: '0000',
-            },
-        });
-        test_utils_1.assert.isEqual(results.totalErrors, 1);
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'INVALID_RESPONSE_PAYLOAD');
-    }
-    static async responseThrowingAnErrorIsPassedThrough() {
-        const [client1, client2] = await Promise.all([
-            this.connectToApiAsTestClient(true),
-            this.connectToApiAsTestClient(true),
-        ]);
-        //@ts-ignore
-        await client2.on('confirm-pin::v2020_12_25', async () => {
-            //@ts-ignore
-            throw new SpruceError_1.default({ code: 'TEST' });
-        });
-        const results = await client1.emit('confirm-pin::v2020_12_25', {
-            payload: {
-                challenge: '1234',
-                pin: '0000',
-            },
-        });
-        test_utils_1.assert.isEqual(results.totalErrors, 1);
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'TEST');
-    }
-    static async testClientWrapsUnknownEventNameInHelpfulDebugError() {
-        const client = await this.connectToApiAsTestClient(true);
-        //@ts-ignore
-        const err = await test_utils_1.assert.doesThrowAsync(() => client.emit('waka-waka'));
-        test_utils_1.assert.doesInclude(err.message, 'spruce create.event');
-    }
-    static async returnsHelpfulErrorIfEventExistsLocallyButNotRemotely() {
-        const client = await this.connectToApiAsTestClient(true);
-        __1.MercuryTestClient.getInternalEmitter().mixinContract({
-            eventSignatures: {
-                ['waka-waka']: {},
-            },
-        });
-        //@ts-ignore
-        const results = await client.emit('waka-waka');
-        const err = spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'INVALID_EVENT_NAME');
-        test_utils_1.assert.doesInclude(err.message, 'create.listener');
-    }
-    static async passesThroughProxyIfSetOnClient() {
-        const { personClient, skill1Client, skill2Client, skill1 } = await this.setupOrgAndInstall2Skills();
-        this.mixinPayloadLessTestEvent(personClient);
-        let s;
-        //@ts-ignore
-        await skill2Client.on(this.testEventName, ({ source }) => {
-            s = source;
-        });
-        const proxyToken = 'toast-cheese';
-        skill1Client.setProxyToken(proxyToken);
-        //@ts-ignore
-        await skill1Client.emit(this.testEventName);
-        test_utils_1.assert.isTruthy(s.skillId);
-        test_utils_1.assert.isEqual(s.skillId, skill1.id);
-        test_utils_1.assert.isUndefined(s.personId);
-        test_utils_1.assert.isEqual(s.proxyToken, proxyToken);
-    }
-    static async passesThroughProxyIfSentWithPayload() {
-        const { personClient, skill1Client, skill2Client, skill1 } = await this.setupOrgAndInstall2Skills();
-        this.mixinPayloadLessTestEventWithSource(personClient);
-        let s;
-        //@ts-ignore
-        await skill2Client.on(this.testEventName, ({ source }) => {
-            s = source;
-        });
-        const proxyToken = 'waste-taco';
-        skill1Client.setProxyToken('this-should-be-ignored-now');
-        //@ts-ignore
-        await skill1Client.emit(this.testEventName, {
-            source: {
-                proxyToken,
-            },
-        });
-        test_utils_1.assert.isTruthy(s.skillId);
-        test_utils_1.assert.isEqual(s.skillId, skill1.id);
-        test_utils_1.assert.isUndefined(s.personId);
-        test_utils_1.assert.isEqual(s.proxyToken, proxyToken);
-    }
-    static async throwsIfEmitsIsNotGlobalAndTargetDoesNotIncludeOrganizationIdOrLocationId() {
-        __1.MercuryTestClient.setShouldCheckPermissionsOnLocalEvents(false);
-        const client = await this.connectToApiAsTestClient(true);
-        const client2 = await this.connectToApiAsTestClient(true);
-        const contract = {
-            eventSignatures: {
-                [this.testEventName]: {
-                    emitPermissionContract: {
-                        id: 'test',
-                        name: 'Can emit',
-                        permissions: [],
-                    },
-                },
-            },
-        };
-        client.mixinContract(contract);
-        await client.on(this.testEventName, () => { });
-        const err = await test_utils_1.assert.doesThrowAsync(() => client2.emit(this.testEventName));
-        test_utils_2.errorAssert.assertError(err, 'INVALID_EVENT_SIGNATURE');
-    }
-    static async passesThroughTestProxy() {
-        this.enableTestMode();
-        const { client: teammateClient } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE_TEAMMATE);
-        const { client: guestClient } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE_GUEST);
-        const client = await this.connectToApiAsTestClient();
-        let passedSource;
-        await client.on('whoami::v2020_12_25', async ({ source }) => {
-            passedSource = source;
-            return {};
-        });
-        const teammateToken = await teammateClient.registerProxyToken();
-        guestClient.setProxyToken(teammateToken);
-        await guestClient.emit('whoami::v2020_12_25');
-        test_utils_1.assert.isEqual(passedSource.proxyToken, teammateToken);
-    }
-    static async proxyNotSentToAuthenticate() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        const token = await client.registerProxyToken();
-        let passedSource;
-        //@ts-ignore
-        await client.on('authenticate::v2020_12_25', ({ source }) => {
-            passedSource = source;
-            return {
-                type: 'authenticated',
-                auth: {},
-            };
-        });
-        const anon = await this.connectToApiAsTestClient();
-        anon.setProxyToken(token);
-        await anon.authenticate({
-            token: '234234234234',
-        });
-        test_utils_1.assert.isFalsy(passedSource?.proxyToken);
-    }
-    static async throwsWhenPassingEmptyTargetAndPayloadToEVentWithNoEmitPayloadSchema() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        //@ts-ignore
-        delete client.eventContract.eventSignatures['whoami::v2020_12_25']
-            .emitPayloadSchema;
-        await client.on('whoami::v2020_12_25', () => ({
-            type: 'anonymous',
-            auth: {},
-        }));
-        await test_utils_1.assert.doesThrowAsync(() => client.emit('whoami::v2020_12_25', {}));
-    }
-    static async callbackInvokedForEachResponse() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        await client.on('list-organizations::v2020_12_25', () => {
-            return {
-                organizations: [],
-            };
-        });
-        let wasHit = false;
-        await client.emit('list-organizations::v2020_12_25', () => {
-            wasHit = true;
-        });
-        test_utils_1.assert.isTrue(wasHit);
-    }
-    static async fakedResponsesAreCloned() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        const org = {
-            id: '1234',
-            name: 'Pal',
-            dateCreated: 0,
-            slug: 'buddy',
-        };
-        await client.on('list-organizations::v2020_12_25', () => {
-            return {
-                organizations: [org],
-            };
-        });
-        const [{ organizations }] = await client.emitAndFlattenResponses('list-organizations::v2020_12_25');
-        test_utils_1.assert.isNotEqual(organizations[0], org);
-    }
-    static async offHonorsCb() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        let cb1Hit = 0;
-        let cb2Hit = 0;
-        const cb1 = () => {
-            cb1Hit++;
-            return {
-                type: 'anonymous',
-                auth: {},
-            };
-        };
-        const cb2 = () => {
-            cb2Hit++;
-            return {
-                type: 'anonymous',
-                auth: {},
-            };
-        };
-        await client.on('whoami::v2020_12_25', cb1);
-        await client.on('whoami::v2020_12_25', cb2);
-        await client.off('whoami::v2020_12_25', cb2);
-        await client.emit('whoami::v2020_12_25');
-        test_utils_1.assert.isEqual(cb1Hit, 1);
-        test_utils_1.assert.isEqual(cb2Hit, 0);
-    }
-    static async canEmitStatusChangeEventForTesting() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        let hit = false;
-        await client.on('connection-status-change', () => {
-            hit = true;
-        });
-        await client.emitAndFlattenResponses('connection-status-change', {
-            payload: {
-                status: 'connected',
-            },
-        });
-        test_utils_1.assert.isTrue(hit);
-    }
-    static async payloadsAndResponsesAreCloned() {
-        const client = await this.enableTestModeAndLoginAsGuest();
-        const city = (0, test_utils_1.generateId)();
-        const location1 = {
-            id: (0, test_utils_1.generateId)(),
-            dateCreated: 0,
-            slug: (0, test_utils_1.generateId)(),
-            name: (0, test_utils_1.generateId)(),
-            organizationId: (0, test_utils_1.generateId)(),
-            address: {
-                city,
-                country: (0, test_utils_1.generateId)(),
-                province: (0, test_utils_1.generateId)(),
-                street1: (0, test_utils_1.generateId)(),
-                zip: (0, test_utils_1.generateId)(),
-            },
-        };
-        let passedTarget;
-        await client.on('get-location::v2020_12_25', ({ target }) => {
-            passedTarget = target;
-            return {
-                location: location1,
-            };
-        });
-        const target = {
-            locationId: (0, test_utils_1.generateId)(),
-        };
-        const [{ location: results }] = await client.emitAndFlattenResponses('get-location::v2020_12_25', {
-            target,
-        });
-        results.address.city = 'changed';
-        test_utils_1.assert.isEqual(city, location1.address.city);
-        test_utils_1.assert.isNotEqual(results.address, location1.address);
-        test_utils_1.assert.isNotEqual(passedTarget, target);
-    }
-    static async loginAsGuest() {
-        const { client } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE_GUEST);
-        return client;
-    }
-    static async assertTeammateCanEmit(options) {
-        const { fqen, ownerClient, organizationId } = options;
-        const { person: teammate, client: teammateClient } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE_TEAMMATE);
-        const roleResults = await ownerClient.emit('list-roles::v2020_12_25', {
-            target: {
-                organizationId,
-            },
-            payload: {
-                shouldIncludePrivateRoles: true,
-            },
-        });
-        const { roles } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(roleResults);
-        const teammateRole = roles.find((r) => r.base === 'teammate');
-        test_utils_1.assert.isTruthy(teammateRole);
-        try {
-            const roleSetResults = await ownerClient.emit('add-role::v2020_12_25', {
-                target: {
-                    organizationId,
-                },
-                payload: {
-                    personId: teammate.id,
-                    roleId: teammateRole.id,
-                },
-            });
-            spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(roleSetResults);
-        }
-        catch { }
-        //@ts-ignore
-        const response = await teammateClient.emit(fqen, {
-            target: {
-                organizationId,
-            },
-        });
-        spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(response);
-    }
-    static async assertAnotherSkillCantEmit(fqen, skill2Client, orgId) {
-        const results = await skill2Client.emit(fqen, {
-            target: {
-                organizationId: orgId,
-            },
-        });
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'UNAUTHORIZED_ACCESS');
-    }
-    static async assertGuestCantEmit(fqen, orgId) {
-        const { client: personClient } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE_GUEST);
-        //@ts-ignore
-        const response = await personClient.emit(fqen, {
-            target: {
-                organizationId: orgId,
-            },
-        });
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(response, 'UNAUTHORIZED_ACCESS');
-    }
-    static async assertAnonCantEmit(fqen, orgId) {
-        const client = await this.connectToApiAsTestClient();
-        //@ts-ignore
-        const response = await client.emit(fqen, {
-            target: {
-                organizationId: orgId,
-            },
-        });
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(response, 'UNAUTHORIZED_ACCESS');
-    }
-    static buildEmitPermContract() {
-        return (0, mercury_types_1.buildPermissionContract)({
-            name: 'Can emit contract',
-            id: 'can-do-something-contract',
-            permissions: [
-                {
-                    id: 'can-create',
-                    name: 'Can create',
-                    defaults: {
-                        teammate: {
-                            default: true,
-                        },
-                    },
-                },
-            ],
-        });
-    }
-    static async setupOrgAndInstall2Skills() {
-        this.enableTestMode();
-        const { client: personClient } = await this.loginAsDemoPerson();
-        const org = await this.seedDummyOrg(personClient);
-        const { client: skill1Client, skill: skill1 } = await this.seedInstallAndLoginAsSkill(personClient, org.id);
-        const { client: skill2Client } = await this.seedInstallAndLoginAsSkill(personClient, org.id);
-        return { personClient, skill1, skill1Client, skill2Client, org };
-    }
-    static async connectToApiAsTestClient(shouldSetDefaultContract = false, contract) {
-        this.enableTestMode();
-        shouldSetDefaultContract &&
-            __1.MercuryClientFactory.setDefaultContract(mercury_core_events_1.coreEventContracts[0]);
-        const allContracts = [];
-        if (!shouldSetDefaultContract) {
-            allContracts.push(...mercury_core_events_1.coreEventContracts);
-        }
-        if (contract) {
-            allContracts.push(contract);
-        }
-        const client = await __1.MercuryClientFactory.Client({
-            host: constants_1.TEST_HOST,
-            contracts: allContracts.length > 0 ? allContracts : undefined,
-            allowSelfSignedCrt: true,
-        });
-        this.clients.push(client);
-        return client;
-    }
-    static mixinPayloadLessTestEvent(client) {
-        const contract = {
-            eventSignatures: {
-                [this.testEventName]: {
-                    isGlobal: true,
-                },
-            },
-        };
-        client.mixinContract(contract);
-    }
-    static enableTestMode() {
-        __1.MercuryClientFactory.setIsTestMode(true);
-    }
-    static mixinPayloadLessTestEventWithSource(client) {
-        const contract = {
-            eventSignatures: {
-                [this.testEventName]: {
-                    isGlobal: true,
-                    emitPayloadSchema: (0, spruce_event_utils_1.buildEmitTargetAndPayloadSchema)({
-                        eventName: this.testEventName,
-                    }),
-                },
-            },
-        };
-        client.mixinContract(contract);
-    }
-    static async enableTestModeAndLoginAsGuest() {
-        this.enableTestMode();
-        const client = await this.loginAsGuest();
-        return client;
-    }
-}
-SimulatingEventsForTestingTest.eventName = 'whoami::v2020_12_25';
-SimulatingEventsForTestingTest.testEventName = 'my-skill.test-event::v2020_02_02';
-exports.default = SimulatingEventsForTestingTest;
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "testModeFalseByDefault", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canSetTestMode", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "testClientHandlesDefaultContracts", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "clientKnowsIfIsTestClient", null);
-__decorate([
-    (0, test_utils_1.test)('can emit to self with default contract', true),
-    (0, test_utils_1.test)('can emit to self without default contract', false)
-], SimulatingEventsForTestingTest, "canEmitEventToSelfForTesting", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canEmitToApiWhenNoLocalListenerIsSet", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canHandleRapidFireConnectsToApi", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canEmitToSelfUsingToClients", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "factoryReturnsSocketIoClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canResetClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canMixinContractsToTestClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "firstTestClientAddsEventToSecondTestClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "secondTestClientAddsEventToFirstTestClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "includesSourceInEventsEmittedByPerson", null);
-__decorate([
-    (0, test_utils_1.test)('does not check permissions by default', false),
-    (0, test_utils_1.test)('does check permissions by default if array is empty', true)
-], SimulatingEventsForTestingTest, "doesCheckPermsIfPermissionsIsEmptyArrayOnContract", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "stillValidatesPayloads", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "includesSourceInEventsEmittedBySkill", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "checksPermissionsWhenEmitting", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "localResponsesAreValidated", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "responseThrowingAnErrorIsPassedThrough", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "testClientWrapsUnknownEventNameInHelpfulDebugError", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "returnsHelpfulErrorIfEventExistsLocallyButNotRemotely", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "passesThroughProxyIfSetOnClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "passesThroughProxyIfSentWithPayload", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "throwsIfEmitsIsNotGlobalAndTargetDoesNotIncludeOrganizationIdOrLocationId", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "passesThroughTestProxy", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "proxyNotSentToAuthenticate", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "throwsWhenPassingEmptyTargetAndPayloadToEVentWithNoEmitPayloadSchema", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "callbackInvokedForEachResponse", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "fakedResponsesAreCloned", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "offHonorsCb", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "canEmitStatusChangeEventForTesting", null);
-__decorate([
-    (0, test_utils_1.test)()
-], SimulatingEventsForTestingTest, "payloadsAndResponsesAreCloned", null);