@sprucelabs/mercury-client 42.0.557 → 42.0.559

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

@@ -1,662 +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 error_1 = __importDefault(require("@sprucelabs/error"));
-const spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
-const test_utils_1 = require("@sprucelabs/test-utils");
-const MercuryClientFactory_1 = __importDefault(require("../../clients/MercuryClientFactory"));
-const MercurySocketIoClient_1 = __importDefault(require("../../clients/MercurySocketIoClient"));
-const SpruceError_1 = __importDefault(require("../../errors/SpruceError"));
-const AbstractClientTest_1 = __importDefault(require("../../tests/AbstractClientTest"));
-const constants_1 = require("../../tests/constants");
-require('dotenv').config();
-class UsingMercuryClient extends AbstractClientTest_1.default {
-    static async afterEach() {
-        if (this.timeoutClient) {
-            this.timeoutClient.socket = null;
-        }
-        await super.afterEach();
-    }
-    static async factoryCanCreateClient() {
-        test_utils_1.assert.isTruthy(MercuryClientFactory_1.default.Client);
-    }
-    static async allowsEmptyContracts() {
-        const client = await MercuryClientFactory_1.default.Client({
-            host: constants_1.TEST_HOST,
-            allowSelfSignedCrt: true,
-        });
-        this.clients.push(client);
-    }
-    static async factoryClientCountStartsAtZero() {
-        test_utils_1.assert.isFunction(MercuryClientFactory_1.default.getTotalClients);
-        test_utils_1.assert.isEqual(MercuryClientFactory_1.default.getTotalClients(), 0);
-        test_utils_1.assert.isLength(MercuryClientFactory_1.default.getClients(), 0);
-        const client = await this.connectToApi();
-        test_utils_1.assert.isEqual(MercuryClientFactory_1.default.getTotalClients(), 1);
-        test_utils_1.assert.isEqual(MercuryClientFactory_1.default.getClients()[0], client);
-        const client2 = await this.connectToApi();
-        test_utils_1.assert.isEqual(MercuryClientFactory_1.default.getTotalClients(), 2);
-        test_utils_1.assert.isEqual(MercuryClientFactory_1.default.getClients()[1], client2);
-    }
-    static async connectingToBadProtocolThrows() {
-        const err = await test_utils_1.assert.doesThrowAsync(() => MercuryClientFactory_1.default.Client({
-            host: 'aoeu://tasty.org',
-            contracts: [],
-        }));
-        test_utils_1.errorAssert.assertError(err, 'INVALID_PROTOCOL');
-    }
-    static async factoryReturnsSocketIoClient() {
-        const client = await this.connectToApi();
-        test_utils_1.assert.isTruthy(client instanceof MercurySocketIoClient_1.default);
-        test_utils_1.assert.isTrue(client.isConnected());
-        await client.disconnect();
-        test_utils_1.assert.isFalse(client.isConnected());
-    }
-    static async throwsWithBadEventName() {
-        const client = await this.connectToApi();
-        //@ts-ignore
-        const err = await test_utils_1.assert.doesThrowAsync(() => client.emit('health2'));
-        test_utils_1.errorAssert.assertError(err, 'INVALID_EVENT_NAME');
-    }
-    static async throwsWithHelpfulErrorWithInvalidPayload() {
-        const client = await this.connectToApi();
-        const err = await test_utils_1.assert.doesThrowAsync(() => 
-        //@ts-ignore
-        client.emit('get-skill::v2020_12_25', { taco: 'true' }));
-        test_utils_1.assert.doesInclude(err.message, 'taco');
-    }
-    static async throwsHelpfulErrorWhenCantReachHost() {
-        const host = 'https://wontfindthisanywhere.com';
-        const err = await test_utils_1.assert.doesThrowAsync(() => this.connectToApi({
-            host,
-            reconnectDelayMs: 10,
-            connectionRetries: 0,
-        }));
-        test_utils_1.errorAssert.assertError(err, 'CONNECTION_FAILED', {
-            host,
-            statusCode: 503,
-        });
-    }
-    static async triesToReconnect5TimesMax() {
-        const client = await this.connectToApi({ reconnectDelayMs: 100 });
-        let count = 0;
-        //@ts-ignore
-        client.connect = () => {
-            count++;
-            throw new SpruceError_1.default({
-                code: 'CONNECTION_FAILED',
-                host: 'no-found',
-                statusCode: 305,
-            });
-        };
-        //@ts-ignore
-        await test_utils_1.assert.doesThrowAsync(() => client.attemptReconnectAfterDelay());
-        test_utils_1.assert.isEqual(count, 5);
-    }
-    static async getsAccessDeniedWhenTryingToListenToUnknownEventAnonymously() {
-        const client = await this.connectToApi();
-        const err = await test_utils_1.assert.doesThrowAsync(() => 
-        //@ts-ignore
-        client.on('waka-waka', () => { }));
-        test_utils_1.errorAssert.assertError(err, 'UNAUTHORIZED_ACCESS');
-    }
-    static async cantEmitEventWithWithInvalidPayload() {
-        const client = await this.connectToApi();
-        const err = await test_utils_1.assert.doesThrowAsync(() => 
-        //@ts-ignore
-        client.emit('request-pin::v2020_12_25', {}));
-        test_utils_1.errorAssert.assertError(err, 'INVALID_PAYLOAD', {
-            eventName: 'request-pin',
-        });
-    }
-    static async canRunHealthCheck() {
-        const client = await this.connectToApi();
-        const results = await client.emit('health::v2020_12_25');
-        test_utils_1.assert.isEqualDeep(results.responses[0].payload, {
-            skill: { status: 'passed' },
-            mercury: { status: 'passed' },
-        });
-        await client.disconnect();
-    }
-    static async skillsCanListenToEachOther() {
-        const { org, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent();
-        let newEventTriggered = false;
-        //@ts-ignore
-        await skill2Client.on(`${skill1.slug}.will-send-vip::v1`, () => {
-            newEventTriggered = true;
-            return {
-                messages: ['hello world'],
-            };
-        });
-        const results = await skill1Client.emit(
-        //@ts-ignore
-        `${skill1.slug}.will-send-vip::v1`, {
-            target: {
-                organizationId: org.id,
-            },
-        });
-        test_utils_1.assert.isEqual(results.totalErrors, 0);
-        test_utils_1.assert.isTrue(newEventTriggered);
-    }
-    static async errorsInListenersRetainOptions() {
-        const error = new SpruceError_1.default({
-            code: 'UNKNOWN_ERROR',
-            //@ts-ignore
-            param: 1,
-            test: 1,
-        });
-        const results = await this.setup2Skills1EventAddThrowingListenerAndEmit(
-        //@ts-ignore
-        error);
-        test_utils_1.assert.isEqual(results.totalErrors, 1);
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'UNKNOWN_ERROR', {
-            param: 1,
-            test: 1,
-        });
-    }
-    static async retainsGeneratedFriendlyMessage() {
-        class TestError extends error_1.default {
-            friendlyMessage() {
-                return 'test this dude!';
-            }
-        }
-        const results = await this.setup2Skills1EventAddThrowingListenerAndEmit(
-        //@ts-ignore
-        new TestError({ code: 'INVALID_PARAMETERS' }));
-        test_utils_1.assert.isEqual(
-        //@ts-ignore
-        results.responses[0].errors[0].message, 'test this dude!');
-    }
-    static async nonSpruceErrorsArePassedBackAsListenerErrors() {
-        const { org, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent();
-        const fqen = `${skill1.slug}.will-send-vip::v1`;
-        //@ts-ignore
-        await skill2Client.on(fqen, () => {
-            throw new Error('oh shoot');
-        });
-        //@ts-ignore
-        const results = await skill1Client.emit(fqen, {
-            target: {
-                organizationId: org.id,
-            },
-        });
-        test_utils_1.assert.isEqual(results.totalErrors, 1);
-        const err = spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'LISTENER_ERROR');
-        //@ts-ignore
-        test_utils_1.assert.isEqual(err.options.fqen, fqen);
-        test_utils_1.assert.doesInclude(results.responses[0].errors?.[0].message, 'oh shoot');
-    }
-    static async emitterGetsCalledBackForEachListener(shouldDisconnect = false) {
-        const { org, client, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent(constants_1.DEMO_PHONE_RECONNECT);
-        const { client: skill3Client } = await this.seedInstallAndLoginAsSkill(client, org.id);
-        const { client: skill4Client } = await this.seedInstallAndLoginAsSkill(client, org.id);
-        let listenTriggerCount = 0;
-        //@ts-ignore
-        await skill2Client.on(`${skill1.slug}.will-send-vip::v1`, () => {
-            listenTriggerCount++;
-            return {
-                messages: ['hello from skill 2'],
-            };
-        });
-        //@ts-ignore
-        await skill3Client.on(`${skill1.slug}.will-send-vip::v1`, () => {
-            listenTriggerCount++;
-            return {
-                messages: ['hello from skill 3'],
-            };
-        });
-        //@ts-ignore
-        await skill4Client.on(`${skill1.slug}.will-send-vip::v1`, () => {
-            listenTriggerCount++;
-            return {
-                messages: ['hello from skill 4'],
-            };
-        });
-        if (shouldDisconnect) {
-            //@ts-ignore
-            client.socket.disconnect();
-            //@ts-ignore
-            skill1Client.socket.disconnect();
-            //@ts-ignore
-            skill2Client.socket.disconnect();
-            do {
-                await this.wait(1000);
-            } while (!skill1Client.isConnected() ||
-                !skill2Client.isConnected() ||
-                !client.isConnected());
-        }
-        let responseTriggerCount = 0;
-        await skill1Client.emit(
-        //@ts-ignore
-        `${skill1.slug}.will-send-vip::v1`, {
-            //@ts-ignore
-            target: {
-                organizationId: org.id,
-            },
-        }, () => {
-            responseTriggerCount++;
-        });
-        test_utils_1.assert.isEqual(listenTriggerCount, 3);
-        test_utils_1.assert.isEqual(responseTriggerCount, 3);
-    }
-    static async eachResponseMustFinishBeforeEmitReturns() {
-        const { org, client, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent(constants_1.DEMO_PHONE_RECONNECT);
-        const { client: skill3Client } = await this.seedInstallAndLoginAsSkill(client, org.id);
-        //@ts-ignore
-        await skill2Client.on(`${skill1.slug}.will-send-vip::v1`, async () => {
-            return {
-                messages: ['hello from skill 2'],
-            };
-        });
-        //@ts-ignore
-        await skill3Client.on(`${skill1.slug}.will-send-vip::v1`, async () => {
-            return {
-                messages: ['hello from skill 2'],
-            };
-        });
-        let ttl = 1000;
-        let hitCount = 0;
-        let wasHit = false;
-        await skill1Client.emit(
-        //@ts-ignore
-        `${skill1.slug}.will-send-vip::v1`, {
-            //@ts-ignore
-            target: {
-                organizationId: org.id,
-            },
-        }, async () => {
-            if (!wasHit) {
-                wasHit = true;
-                await new Promise((r) => setTimeout(r, ttl));
-            }
-            hitCount++;
-        });
-        test_utils_1.assert.isEqual(hitCount, 2);
-    }
-    static async offRemovesListener() {
-        const { org, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent();
-        let listenerTriggerCount = 0;
-        const eventName = `${skill1.slug}.will-send-vip::v1`;
-        //@ts-ignore
-        await skill2Client.on(eventName, () => {
-            listenerTriggerCount++;
-            return {
-                messages: ['hello world'],
-            };
-        });
-        //@ts-ignore
-        await skill1Client.emit(eventName, {
-            target: {
-                organizationId: org.id,
-            },
-        });
-        //@ts-ignore
-        const offCount = await skill2Client.off(eventName);
-        test_utils_1.assert.isEqual(offCount, 1);
-        //@ts-ignore
-        await skill1Client.emit(eventName, {
-            target: {
-                organizationId: org.id,
-            },
-        });
-        test_utils_1.assert.isEqual(listenerTriggerCount, 1);
-    }
-    static async throwsWhenEmittingWhenNotConnected() {
-        const client = await this.connectToApi();
-        await client.disconnect();
-        const err = await test_utils_1.assert.doesThrowAsync(() => client.emit('health::v2020_12_25'));
-        test_utils_1.errorAssert.assertError(err, 'NOT_CONNECTED');
-    }
-    static async serverSideErrorsMappedToSpruceErrors() {
-        const client = await this.connectToApi();
-        const response = await client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        });
-        const errors = response.responses[0].errors;
-        test_utils_1.assert.isTruthy(errors);
-        test_utils_1.errorAssert.assertError(errors[0], 'UNAUTHORIZED_ACCESS');
-    }
-    static async timesOutWhenEmittingEventThatIsNeverHandled(maxEmitRetries) {
-        const client = await this.TimeoutClient(undefined, maxEmitRetries);
-        const err = await test_utils_1.assert.doesThrowAsync(() => client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        }));
-        test_utils_1.errorAssert.assertError(err, 'TIMEOUT', {
-            eventName: 'register-skill::v2020_12_25',
-        });
-        test_utils_1.assert.isEqual(client.socket.invocationCounts.off, maxEmitRetries + 1);
-    }
-    static async timeoutMakesEventualResponseNotCount() {
-        const client = await this.TimeoutClient(12000);
-        const err = await test_utils_1.assert.doesThrowAsync(() => client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        }));
-        test_utils_1.errorAssert.assertError(err, 'TIMEOUT', {
-            eventName: 'register-skill::v2020_12_25',
-        });
-        await this.wait(4000);
-        test_utils_1.assert.isEqual(client.socket.invocationCounts.off, 6);
-    }
-    static async emitTimeoutsAreResetAfterEmit(maxEmitRetries) {
-        const client = await this.TimeoutClient(undefined, maxEmitRetries);
-        await test_utils_1.assert.doesThrowAsync(() => client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        }));
-        test_utils_1.assert.isEqual(client.socket.invocationCounts.off, maxEmitRetries + 1);
-        client.socket.invocationCounts.off = 0;
-        await test_utils_1.assert.doesThrowAsync(() => client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        }));
-        test_utils_1.assert.isEqual(client.socket.invocationCounts.off, maxEmitRetries + 1);
-    }
-    static async emitTimeoutsAreScopedPerEmit() {
-        const client = await this.TimeoutClient();
-        const promise1 = client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        });
-        const promise2 = client.emit('register-skill::v2020_12_25', {
-            payload: { name: 'test' },
-        });
-        await test_utils_1.assert.doesThrowAsync(() => promise1);
-        await test_utils_1.assert.doesThrowAsync(() => promise2);
-        test_utils_1.assert.isEqual(client.socket.invocationCounts.off, 12);
-    }
-    static async canRegisterEventsSimultaneously() {
-        const { client } = await this.loginAsDemoPerson();
-        const org = await this.seedDummyOrg(client);
-        const { client: originalSkillClient } = await this.seedInstallAndLoginAsSkill(client, org.id);
-        const eventsToCheck = [];
-        await Promise.all(new Array(20).fill(0).map(async (_, idx) => {
-            this.skillName = `Simultanious skill ${idx}`;
-            const { skill, client: skillClient } = await this.seedInstallAndLoginAsSkill(client, org.id);
-            await skillClient.emitAndFlattenResponses('register-events::v2020_12_25', {
-                payload: {
-                    contract: this.generateWillSendVipEventSignature(),
-                },
-            });
-            const [{ contracts }] = await originalSkillClient.emitAndFlattenResponses('get-event-contracts::v2020_12_25');
-            let found = false;
-            for (const contract of contracts) {
-                if (contract.eventSignatures?.[`${skill.slug}.will-send-vip::v1`]) {
-                    found = true;
-                    break;
-                }
-            }
-            test_utils_1.assert.isTrue(found);
-        }));
-        const results = await originalSkillClient.emit('get-event-contracts::v2020_12_25');
-        const { contracts } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
-        do {
-            const checking = eventsToCheck[eventsToCheck.length - 1];
-            for (const contract of contracts) {
-                if (contract.eventSignatures[checking]) {
-                    eventsToCheck.pop();
-                    break;
-                }
-            }
-        } while (eventsToCheck.length > 0);
-    }
-    static async handlesCantEmitElegantly() {
-        const client = await this.connectToApi();
-        const results = await client.emit('did-message::v2020_12_25', {
-            target: {},
-            payload: {
-                message: {
-                    id: '13234',
-                    target: {},
-                    source: {},
-                    classification: 'incoming',
-                    body: 'go team!',
-                    dateCreated: new Date().getTime(),
-                },
-            },
-        });
-        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'UNAUTHORIZED_ACCESS');
-    }
-    static async canDisableAutoRegisterListener() {
-        const { org, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent();
-        let listenerTriggerCount = 0;
-        const eventName = `${skill1.slug}.will-send-vip::v1`;
-        skill2Client.setShouldAutoRegisterListeners(false);
-        //@ts-ignore
-        await skill2Client.on(eventName, () => {
-            listenerTriggerCount++;
-            return {
-                messages: ['hello world'],
-            };
-        });
-        //@ts-ignore
-        await skill1Client.emit(eventName, {
-            target: {
-                organizationId: org.id,
-            },
-        });
-        test_utils_1.assert.isEqual(listenerTriggerCount, 0);
-    }
-    static async notAuthenticatedToStart() {
-        const client = await this.connectToApi();
-        test_utils_1.assert.isFalse(client.isAuthenticated());
-    }
-    static async knowsWhenAuthenticated() {
-        const { client } = await this.loginAsDemoPerson();
-        test_utils_1.assert.isTrue(client.isAuthenticated());
-    }
-    static async noProxyTokenToStart() {
-        const client = await this.connectToApi();
-        test_utils_1.assert.isFalsy(client.getProxyToken());
-    }
-    static async canSetProxyToken() {
-        const client = await this.connectToApi();
-        test_utils_1.assert.isFalsy(client.getProxyToken());
-        client.setProxyToken('yummy');
-        test_utils_1.assert.isEqual(client.getProxyToken(), 'yummy');
-    }
-    static async requestsAreMadeWithProxyGoingForward() {
-        const { client2, token, person1 } = await this.loginAndRegisterToken();
-        client2.setProxyToken(token);
-        const results = await client2.emit('whoami::v2020_12_25');
-        this.assertPerson1ComesBack(results, person1);
-    }
-    static async prefersProxyPassedInSource() {
-        const { client2, token, person1 } = await this.loginAndRegisterToken();
-        client2.setProxyToken('aoeuaoeuaoeu');
-        const results = await client2.emit('whoami::v2020_12_25', {
-            source: {
-                proxyToken: token,
-            },
-        });
-        this.assertPerson1ComesBack(results, person1);
-    }
-    static assertPerson1ComesBack(results, person1) {
-        const { auth } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
-        test_utils_1.assert.isTruthy(auth.person);
-        test_utils_1.assert.isEqual(auth.person.id, person1.id);
-    }
-    static async loginAndRegisterToken() {
-        const { client: client1, person: person1 } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE);
-        const { client: client2 } = await this.loginAsDemoPerson(constants_1.DEMO_PHONE_PROXY);
-        const results = await client1.emit('register-proxy-token::v2020_12_25');
-        const { token } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
-        return { client2, token, person1 };
-    }
-    static async TimeoutClient(emitDelay, maxEmitRetries) {
-        const client = await this.connectToApi({
-            emitTimeoutMs: 100,
-            shouldReconnect: false,
-            maxEmitRetries,
-        });
-        //@ts-ignore
-        const socket = client.socket;
-        await new Promise((resolve) => {
-            socket?.once('disconnect', () => {
-                socket?.removeAllListeners();
-                resolve(undefined);
-            });
-            socket?.disconnect();
-        });
-        //@ts-ignore
-        client.socket = {
-            connected: true,
-            invocationCounts: {
-                off: 0,
-            },
-            emit: (_, __, cb) => {
-                if (emitDelay && emitDelay > 0) {
-                    setTimeout(cb, emitDelay);
-                }
-            },
-            on: () => { },
-            off() {
-                this.invocationCounts.off++;
-            },
-            once: () => { },
-            disconnect: () => { },
-        };
-        this.timeoutClient = client;
-        return client;
-    }
-    static async setup2Skills1EventAddThrowingListenerAndEmit(error) {
-        const { org, skill1, skill1Client, skill2Client } = await this.setup2SkillsAndOneEvent();
-        //@ts-ignore
-        await this.throwOnWillSendVip(skill2Client, skill1.slug, error);
-        const results = await skill1Client.emit(
-        //@ts-ignore
-        `${skill1.slug}.will-send-vip::v1`, {
-            target: {
-                organizationId: org.id,
-            },
-        });
-        return results;
-    }
-    static async throwOnWillSendVip(client, namespace, error) {
-        //@ts-ignore
-        await client.on(`${namespace}.will-send-vip::v1`, () => {
-            //@ts-ignore
-            throw error;
-        });
-    }
-    static async setup2SkillsAndOneEvent(phone) {
-        const { client } = await this.loginAsDemoPerson(phone);
-        const org = await this.seedDummyOrg(client);
-        const createLogin = this.seedInstallAndLoginAsSkill(client, org.id);
-        const createLogin2 = this.seedInstallAndLoginAsSkill(client, org.id);
-        const { skill: skill1, client: skill1Client } = await createLogin;
-        const { client: skill2Client } = await createLogin2;
-        await this.registerEvent(skill1.slug, skill1Client);
-        return { client, org, skill1, skill1Client, skill2Client };
-    }
-}
-exports.default = UsingMercuryClient;
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "factoryCanCreateClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "allowsEmptyContracts", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "factoryClientCountStartsAtZero", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "connectingToBadProtocolThrows", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "factoryReturnsSocketIoClient", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "throwsWithBadEventName", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "throwsWithHelpfulErrorWithInvalidPayload", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "throwsHelpfulErrorWhenCantReachHost", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "triesToReconnect5TimesMax", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "getsAccessDeniedWhenTryingToListenToUnknownEventAnonymously", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "cantEmitEventWithWithInvalidPayload", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "canRunHealthCheck", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "skillsCanListenToEachOther", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "errorsInListenersRetainOptions", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "retainsGeneratedFriendlyMessage", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "nonSpruceErrorsArePassedBackAsListenerErrors", null);
-__decorate([
-    (0, test_utils_1.test)('each listener gets fired'),
-    (0, test_utils_1.test)('each listener gets fired after lost connection', true)
-], UsingMercuryClient, "emitterGetsCalledBackForEachListener", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "eachResponseMustFinishBeforeEmitReturns", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "offRemovesListener", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "throwsWhenEmittingWhenNotConnected", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "serverSideErrorsMappedToSpruceErrors", null);
-__decorate([
-    (0, test_utils_1.test)('times out when giving up on 1 retry on emit', 1),
-    (0, test_utils_1.test)('times out when giving up on 5 retries on emit', 5)
-], UsingMercuryClient, "timesOutWhenEmittingEventThatIsNeverHandled", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "timeoutMakesEventualResponseNotCount", null);
-__decorate([
-    (0, test_utils_1.test)('emit timeouts are reset after each emit with 5 retries', 5),
-    (0, test_utils_1.test)('emit timeouts are reset after each emit with 3 retries', 3)
-], UsingMercuryClient, "emitTimeoutsAreResetAfterEmit", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "emitTimeoutsAreScopedPerEmit", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "canRegisterEventsSimultaneously", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "handlesCantEmitElegantly", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "canDisableAutoRegisterListener", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "notAuthenticatedToStart", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "knowsWhenAuthenticated", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "noProxyTokenToStart", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "canSetProxyToken", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "requestsAreMadeWithProxyGoingForward", null);
-__decorate([
-    (0, test_utils_1.test)()
-], UsingMercuryClient, "prefersProxyPassedInSource", null);