@sprucelabs/spruce-test-fixtures 45.2.9 → 46.0.0

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

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

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

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

@@ -0,0 +1,331 @@
+"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 crypto_1 = require("crypto");
+const spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
+const spruce_event_utils_2 = require("@sprucelabs/spruce-event-utils");
+const test_1 = require("@sprucelabs/test");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const constants_1 = require("../../tests/constants");
+const fake_1 = __importDefault(require("../../tests/decorators/fake"));
+let OrganizationFixtureTest = class OrganizationFixtureTest extends AbstractSpruceFixtureTest_1.default {
+    static async canCreateOrganizationFixture() {
+        test_1.assert.isTruthy(this.organizations);
+    }
+    static async canSeedOrg() {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'my org',
+        });
+        test_1.assert.isTruthy(org);
+        test_1.assert.isEqual(org.name, 'my org');
+    }
+    static async orgFixtureDestroysOrgs() {
+        const org = await this.Org();
+        await this.organizations.destroy();
+        await this.organizations.destroy();
+        const client = await this.mercury.connectToApi();
+        const results = await client.emit('get-organization::v2020_12_25', {
+            target: {
+                organizationId: org.id,
+            },
+        });
+        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'INVALID_TARGET');
+    }
+    static async isNotPartOfOrgtoStart() {
+        const org = await this.Org();
+        const { person } = await this.people.loginAsDemoPerson(constants_1.DEMO_NUMBER_HIRING);
+        const isHired = await this.organizations.isPartOfOrg({
+            personId: person.id,
+            organizationId: org.id,
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        test_1.assert.isFalse(isHired);
+    }
+    static async updatingBadOrgTHrows() {
+        await test_1.assert.doesThrowAsync(() => this.organizations.updateOrganization('aoeu', {}));
+    }
+    static async canUpdateOrg() {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'my org',
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        const name = (0, test_utils_1.generateId)();
+        await this.organizations.updateOrganization(org.id, {
+            name,
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        const updated = await this.organizations.getOrganizationById(org.id);
+        test_1.assert.isEqual(updated.name, name);
+    }
+    static async canUpdateOrgAddress() {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'my org',
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        let address = {
+            city: (0, test_utils_1.generateId)(),
+            country: (0, test_utils_1.generateId)(),
+            province: (0, test_utils_1.generateId)(),
+            street1: (0, test_utils_1.generateId)(),
+            zip: (0, crypto_1.randomInt)(44444).toString(),
+        };
+        await this.organizations.updateOrganization(org.id, {
+            address,
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        const updated = await this.organizations.getOrganizationById(org.id);
+        test_1.assert.isEqualDeep(updated.address, address);
+    }
+    static async canMakeOrgPublicAndPrivate() {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'my org',
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        await this.assertOrgIsPublicValue(org.id, false);
+        await this.setAndAssertOrgIsPublic(org.id, true);
+        await this.setAndAssertOrgIsPublic(org.id, false);
+    }
+    static async canAddPersonToOrg(base) {
+        const { person, org } = await this.seedOrgAndHirePerson(base);
+        const isHired = await this.isPersonPartOfOrg(person.id, org.id);
+        test_1.assert.isTrue(isHired);
+        const roles = await this.roles.listRoles({
+            organizationId: org.id,
+            personId: person.id,
+            phone: constants_1.DEMO_NUMBER_HIRING,
+        });
+        test_1.assert.isLength(roles, 1);
+        test_1.assert.isEqual(roles[0].base, base);
+    }
+    static async isPersonPartOfOrg(personId, orgId) {
+        return await this.organizations.isPartOfOrg({
+            personId,
+            organizationId: orgId,
+        });
+    }
+    static async isNotInstalledByDefault() {
+        const { skill, org } = await this.seedOrgAndSkill();
+        const isInstalled = await this.organizations.isSkillInstalled(skill.id, org.id);
+        test_1.assert.isFalse(isInstalled);
+    }
+    static async showsAsInstalled() {
+        const { skill, org } = await this.seedOrgAndSkill();
+        await this.organizations.installSkill(skill.id, org.id);
+        await this.assertSkillIsInstalled(skill.id, org.id);
+    }
+    static async cantInstallWithBadSkill() {
+        const { org } = await this.seedOrgAndSkill();
+        const err = await test_1.assert.doesThrowAsync(() => this.organizations.installSkillsByNamespace({
+            organizationId: org.id,
+            namespaces: ['aoeuaoeu'],
+        }));
+        test_utils_1.errorAssert.assertError(err, 'INVALID_NAMESPACES', {
+            namespaces: ['aoeuaoeu'],
+        });
+    }
+    static async canInstallWithSlug() {
+        const { skill, org } = await this.seedOrgAndSkill();
+        await this.organizations.installSkillsByNamespace({
+            organizationId: org.id,
+            namespaces: [skill.slug],
+        });
+        await this.assertSkillIsInstalled(skill.id, org.id);
+    }
+    static async canInstallSkillFromAnotherPerson() {
+        const { skill, org } = await this.seedOrgAndSkill();
+        const skill2 = await this.skills.seedDemoSkill({
+            name: 'testing testy 2',
+            creatorPhone: constants_1.DEMO_NUMBER_INSTALLING_SKILLS,
+        });
+        await this.organizations.installSkillsByNamespace({
+            organizationId: org.id,
+            namespaces: [skill.slug, skill2.slug],
+        });
+        await this.assertSkillIsInstalled(skill.id, org.id);
+        await this.assertSkillIsInstalled(skill2.id, org.id);
+    }
+    static async canDeleteAllExistingOrgs() {
+        const firstFixture = this.Fixture('organization');
+        await firstFixture.seedDemoOrganization({
+            name: 'org 1',
+            phone: constants_1.DEMO_NUMBER_INSTALLING_SKILLS,
+        });
+        await firstFixture.seedDemoOrganization({
+            name: 'org 2',
+            phone: constants_1.DEMO_NUMBER_INSTALLING_SKILLS,
+        });
+        const secondFixture = this.Fixture('organization');
+        await secondFixture.deleteAllOrganizations(constants_1.DEMO_NUMBER_INSTALLING_SKILLS);
+        const { client } = await this.Fixture('person').loginAsDemoPerson(constants_1.DEMO_NUMBER_INSTALLING_SKILLS);
+        const results = await client.emit('list-organizations::v2020_12_25', {
+            payload: {
+                shouldOnlyShowMine: true,
+            },
+        });
+        const { organizations } = spruce_event_utils_2.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isLength(organizations, 0);
+        //@ts-ignore
+        firstFixture.destroy = () => { };
+        //@ts-ignore
+        secondFixture.destroy = () => { };
+    }
+    static async passesThroughAllFieldsToRequest() {
+        await test_1.assert.doesThrowAsync(() => this.Fixture('organization').seedDemoOrganization({
+            //@ts-ignore
+            waka: 'tacas',
+        }));
+    }
+    static canPassPersonFixture() {
+        const personFixture = this.Fixture('person');
+        const orgFixture = this.Fixture('organization', { people: personFixture });
+        //@ts-ignore
+        test_1.assert.isEqual(orgFixture.people, personFixture);
+    }
+    static async canSeedOrgWithNoOptions() {
+        const org = await this.Fixture('organization').seedDemoOrganization();
+        test_1.assert.isTruthy(org);
+    }
+    static async removePersonThrowsWithBadIds() {
+        await test_1.assert.doesThrowAsync(() => this.organizations.removePerson({
+            phone: constants_1.DEMO_NUMBER_HIRING,
+            roleBase: 'guest',
+            organizationId: 'aoeu',
+            personId: 'aoeu',
+        }));
+    }
+    static async canRemovePersonFromOrg(roleBase) {
+        const { person, org } = await this.seedOrgAndHirePerson(roleBase);
+        await this.organizations.removePerson({
+            phone: constants_1.DEMO_NUMBER_HIRING,
+            roleBase,
+            organizationId: org.id,
+            personId: person.id,
+        });
+        const isHired = await this.isPersonPartOfOrg(person.id, org.id);
+        test_1.assert.isFalse(isHired);
+    }
+    static async Org() {
+        return await this.organizations.seedDemoOrganization({
+            name: 'my org',
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+    }
+    static async seedOrgAndHirePerson(base) {
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'my org',
+            phone: constants_1.DEMO_NUMBER_HIRING,
+        });
+        const { person } = await this.people.loginAsDemoPerson(constants_1.DEMO_NUMBER);
+        await this.organizations.addPerson({
+            personId: person.id,
+            organizationId: org.id,
+            roleBase: base,
+            phone: constants_1.DEMO_NUMBER_HIRING,
+        });
+        return { person, org };
+    }
+    static async assertSkillIsInstalled(skillId, orgId) {
+        const isInstalled = await this.organizations.isSkillInstalled(skillId, orgId);
+        test_1.assert.isTrue(isInstalled);
+    }
+    static async seedOrgAndSkill() {
+        const skill = await this.skills.seedDemoSkill({
+            name: 'testing testy',
+        });
+        const org = await this.organizations.seedDemoOrganization({
+            name: 'my org',
+        });
+        return { skill, org };
+    }
+    static async assertOrgIsPublicValue(orgId, expected) {
+        const org = await this.organizations.getOrganizationById(orgId);
+        if (expected) {
+            test_1.assert.isTrue(org.isPublic);
+        }
+        else {
+            test_1.assert.isFalsy(org.isPublic);
+        }
+    }
+    static async setAndAssertOrgIsPublic(orgId, isPublic) {
+        await this.organizations.updateOrganization(orgId, {
+            isPublic,
+            phone: constants_1.DEMO_NUMBER_ORGANIZATION_FIXTURE,
+        });
+        await this.assertOrgIsPublicValue(orgId, isPublic);
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canCreateOrganizationFixture", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canSeedOrg", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "orgFixtureDestroysOrgs", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "isNotPartOfOrgtoStart", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "updatingBadOrgTHrows", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canUpdateOrg", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canUpdateOrgAddress", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canMakeOrgPublicAndPrivate", null);
+__decorate([
+    (0, test_1.test)('can add as guest', 'guest'),
+    (0, test_1.test)('can add as teammate', 'teammate')
+], OrganizationFixtureTest, "canAddPersonToOrg", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "isNotInstalledByDefault", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "showsAsInstalled", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "cantInstallWithBadSkill", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canInstallWithSlug", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canInstallSkillFromAnotherPerson", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canDeleteAllExistingOrgs", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "passesThroughAllFieldsToRequest", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canPassPersonFixture", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "canSeedOrgWithNoOptions", null);
+__decorate([
+    (0, test_1.test)()
+], OrganizationFixtureTest, "removePersonThrowsWithBadIds", null);
+__decorate([
+    (0, test_1.test)('can remove guest', 'guest'),
+    (0, test_1.test)('can remove teammate', 'teammate')
+], OrganizationFixtureTest, "canRemovePersonFromOrg", null);
+OrganizationFixtureTest = __decorate([
+    fake_1.default.login()
+], OrganizationFixtureTest);
+exports.default = OrganizationFixtureTest;

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

@@ -0,0 +1,4 @@
+import { AbstractSpruceFixtureTest } from '../..';
+export default class PatchingConsoleErrorToErrorStreamTest extends AbstractSpruceFixtureTest {
+    protected static patchesConsoleError(): void;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+class PatchingConsoleErrorToErrorStreamTest extends __1.AbstractSpruceFixtureTest {
+    static patchesConsoleError() {
+        test_1.assert.isEqual(console.error, spruce_skill_utils_1.testLog.error);
+        console.error('Should write to console');
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], PatchingConsoleErrorToErrorStreamTest, "patchesConsoleError", null);
+exports.default = PatchingConsoleErrorToErrorStreamTest;

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

@@ -0,0 +1,22 @@
+import AbstractSpruceTest from '@sprucelabs/test';
+export default class PersonFixtureTest extends AbstractSpruceTest {
+    private static fixture;
+    protected static beforeEach(): Promise<void>;
+    private static Fixture;
+    protected static canCreatePersonFixture(): Promise<void>;
+    protected static throwsWhenNoDummyNumberSetInEnv(): Promise<void>;
+    protected static canLoginAsPerson(): Promise<void>;
+    protected static canLoginAsPersonWithEnv(): Promise<void>;
+    protected static canLoginWith2Numbers(): Promise<void>;
+    protected static loggingInWithoutNumberReturnsSameClientEveryTime(): Promise<void>;
+    protected static staysLoggedInAsThisPerson(): Promise<void>;
+    protected static canOverrideDefaultClient(): Promise<void>;
+    protected static honorsDefaultClientEvenWithoutDemoPhoneSet(): Promise<void>;
+    protected static listPeoplePassesThroughVars(expectedTarget: any, expectedPayload?: {
+        personIds: string[];
+        roleBases: string[];
+        roleIds: string[];
+        shouldIncludePrivateFields: boolean;
+    }): Promise<void>;
+    protected static listPeopleReturnsPeople(expectedPeople: any): Promise<void>;
+}