@sprucelabs/spruce-test-fixtures 45.2.9 → 46.0.0

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

@@ -0,0 +1,42 @@
+"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 });
+exports.ResettingLocalEventListeningBeforeSeedingTest = void 0;
+const test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+const constants_1 = require("../../tests/constants");
+let ResettingLocalEventListeningBeforeSeedingTest = class ResettingLocalEventListeningBeforeSeedingTest extends __1.AbstractSpruceFixtureTest {
+    static async beforeEach() {
+        await super.beforeEach();
+    }
+    static async testClientIsResetBeforeSeeding() {
+        await __1.login.getClient().on('create-organization::v2020_12_25', () => {
+            this.hitCount++;
+            return {
+                organization: {},
+            };
+        });
+    }
+    static async hitCountShouldBeZero() {
+        test_1.assert.isEqual(this.hitCount, 0);
+    }
+};
+ResettingLocalEventListeningBeforeSeedingTest.hitCount = 0;
+__decorate([
+    (0, __1.seed)('organizations', 1)
+], ResettingLocalEventListeningBeforeSeedingTest, "beforeEach", null);
+__decorate([
+    (0, test_1.test)()
+], ResettingLocalEventListeningBeforeSeedingTest, "testClientIsResetBeforeSeeding", null);
+__decorate([
+    (0, test_1.test)()
+], ResettingLocalEventListeningBeforeSeedingTest, "hitCountShouldBeZero", null);
+ResettingLocalEventListeningBeforeSeedingTest = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER_TEST_CLIENT_RECENT)
+], ResettingLocalEventListeningBeforeSeedingTest);
+exports.ResettingLocalEventListeningBeforeSeedingTest = ResettingLocalEventListeningBeforeSeedingTest;

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

@@ -0,0 +1,6 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class RetainsContractWhenLoggingInUsingDecorator extends AbstractSpruceFixtureTest {
+    private static client;
+    protected static beforeEach(): Promise<void>;
+    protected static clientStillHasContract(): Promise<void>;
+}

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

@@ -0,0 +1,37 @@
+"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 test_1 = require("@sprucelabs/test");
+const __1 = require("../..");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const constants_1 = require("../../tests/constants");
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+const Good_store_1 = __importDefault(require("../testDirsAndFiles/one-good-store-skill/build/stores/Good.store"));
+let RetainsContractWhenLoggingInUsingDecorator = class RetainsContractWhenLoggingInUsingDecorator extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.client = __1.login.getClient();
+    }
+    static async clientStillHasContract() {
+        await this.client.on('whoami::v2020_12_25', () => ({
+            auth: {},
+            type: 'authenticated',
+        }));
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], RetainsContractWhenLoggingInUsingDecorator, "clientStillHasContract", null);
+RetainsContractWhenLoggingInUsingDecorator = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER_ACCOUNT_RESET)
+], RetainsContractWhenLoggingInUsingDecorator);
+exports.default = RetainsContractWhenLoggingInUsingDecorator;
+__1.StoreFixture.setStore('good', Good_store_1.default);

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

@@ -0,0 +1,15 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class RoleFixtureTest extends AbstractSpruceFixtureTest {
+    private static fixture;
+    private static client;
+    protected static beforeEach(): Promise<void>;
+    protected static hasRoleFixture(): void;
+    protected static cantListRolesWithoutOrg(): Promise<void>;
+    protected static listsValidRoles(): Promise<void>;
+    protected static listsWorkingRolesByDefault(): Promise<void>;
+    protected static listMetaRolesWithOptions(): Promise<void>;
+    protected static canPassOwnOrg(): Promise<void>;
+    private static getNewestOrg;
+    private static assertListedRolesMatchExpected;
+    private static listRoles;
+}

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

@@ -0,0 +1,118 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
+const test_1 = require("@sprucelabs/test");
+const 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"));
+const seed_1 = __importDefault(require("../../tests/decorators/seed"));
+let RoleFixtureTest = class RoleFixtureTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.fixture = this.Fixture('role');
+        this.client = fake_1.default.getClient();
+    }
+    static hasRoleFixture() {
+        test_1.assert.isTruthy(this.fixture);
+    }
+    static async cantListRolesWithoutOrg() {
+        const err = await test_1.assert.doesThrowAsync(() => this.fixture.listRoles());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['organizationId'],
+        });
+    }
+    static async listsValidRoles() {
+        const roles = await this.fixture.listRoles();
+        test_1.assert.isArray(roles);
+        test_1.assert.isAbove(roles.length, 0);
+        for (const role of roles) {
+            const results = await this.client.emit('get-role::v2020_12_25', {
+                target: {
+                    roleId: role.id,
+                },
+            });
+            spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        }
+    }
+    static async listsWorkingRolesByDefault() {
+        const allRoles = await this.listRoles();
+        const expectedRoles = allRoles.filter((role) => role.base !== 'anonymous' && role.base !== 'loggedIn');
+        await this.assertListedRolesMatchExpected(expectedRoles);
+    }
+    static async listMetaRolesWithOptions() {
+        const allRoles = await this.listRoles();
+        await this.assertListedRolesMatchExpected(allRoles, {
+            shouldIncludeMetaRoles: true,
+        });
+    }
+    static async canPassOwnOrg() {
+        const orgs = await this.organizations.listOrganizations();
+        const org = orgs[2];
+        const roles = await this.fixture.listRoles({ organizationId: org.id });
+        test_1.assert.isEqual(roles[0].organizationId, org.id);
+    }
+    static async getNewestOrg() {
+        const org = await this.organizations.getNewestOrganization();
+        test_1.assert.isTruthy(org, `You gotta @seed('organizations',1) to continue.`);
+        return org;
+    }
+    static async assertListedRolesMatchExpected(expectedRoles, options) {
+        const roles = await this.fixture.listRoles(options);
+        function sort(a, b) {
+            return a.name > b.name ? 1 : -1;
+        }
+        roles.sort(sort);
+        expectedRoles.sort(sort);
+        test_1.assert.isEqualDeep(roles, expectedRoles);
+    }
+    static async listRoles() {
+        const org = await this.getNewestOrg();
+        const roleResults = await this.client.emit('list-roles::v2020_12_25', {
+            target: {
+                organizationId: org.id,
+            },
+            payload: {
+                shouldIncludePrivateRoles: true,
+                shouldIncludeMetaRoles: true,
+            },
+        });
+        const { roles: allRoles } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(roleResults);
+        return allRoles;
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], RoleFixtureTest, "hasRoleFixture", null);
+__decorate([
+    (0, test_1.test)()
+], RoleFixtureTest, "cantListRolesWithoutOrg", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 1)
+], RoleFixtureTest, "listsValidRoles", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 1)
+], RoleFixtureTest, "listsWorkingRolesByDefault", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 1)
+], RoleFixtureTest, "listMetaRolesWithOptions", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 3)
+], RoleFixtureTest, "canPassOwnOrg", null);
+RoleFixtureTest = __decorate([
+    fake_1.default.login(constants_1.DEMO_NUMBER_ROLE_FIXTURE)
+], RoleFixtureTest);
+exports.default = RoleFixtureTest;

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

@@ -0,0 +1,24 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class SeedingDataTest extends AbstractSpruceFixtureTest {
+    private static fixture;
+    private static client;
+    protected static beforeEach(): Promise<void>;
+    protected static hasSeedFixture(): void;
+    protected static canSeedManyOrgs(): Promise<void>;
+    protected static actuallyCreatesOrgs(): Promise<void>;
+    protected static canSeedLocations(): Promise<void>;
+    protected static seedingOrgsCreatesOrganization(): Promise<void>;
+    protected static canPassOrgToLocationSeeder(): Promise<void>;
+    protected static throwsWhenSeedingWithoutCount(): Promise<void>;
+    protected static actuallyCreatesLocations(): Promise<void>;
+    protected static needsStartingPhoneWhenSeedingPeople(options: any): Promise<void>;
+    protected static returnsSeededGuests(options: any, expectedCount: number, base: string): Promise<void>;
+    protected static setsFirstPersonsNumberToTheStartingPhone(phone: string): Promise<void>;
+    protected static canSeedMultipleRolesAtOnce(): Promise<void>;
+    protected static seededPeopleHaveNames(): Promise<void>;
+    protected static peopleAllHaveUniqueNames(): Promise<void>;
+    protected static namesAreOnlyAssignedIfNotYetAssigned(): Promise<void>;
+    private static listPeople;
+    private static seedLocations;
+    private static assertOnlyOneOrgExists;
+}

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

@@ -0,0 +1,271 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const spruce_event_utils_1 = 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"));
+const sorter = (a, b) => (a.id > b.id ? 1 : -1);
+let SeedingDataTest = class SeedingDataTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.client = fake_1.default.getClient();
+        this.fixture = this.Fixture('seed');
+        await this.fixture.resetAccount(constants_1.DEMO_NUMBER_SEED_FIXTURE);
+    }
+    static hasSeedFixture() {
+        test_1.assert.isTruthy(this.fixture);
+    }
+    static async canSeedManyOrgs() {
+        const organizations = await this.fixture.seedOrganizations({
+            totalOrganizations: 5,
+        });
+        test_1.assert.isLength(organizations, 5);
+    }
+    static async actuallyCreatesOrgs() {
+        const organizations = await this.fixture.seedOrganizations({
+            totalOrganizations: 3,
+        });
+        const results = await this.client.emit('list-organizations::v2020_12_25', {
+            payload: {
+                shouldOnlyShowMine: true,
+            },
+        });
+        const { organizations: matched } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isLength(matched, 3);
+        test_1.assert.isLength(organizations, 3);
+        for (const org of organizations) {
+            const results = await this.client.emit('get-organization::v2020_12_25', {
+                target: {
+                    organizationId: org.id,
+                },
+            });
+            spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        }
+    }
+    static async canSeedLocations() {
+        const { locations } = await this.fixture.seedAccount({
+            totalLocations: 5,
+        });
+        test_1.assert.isLength(locations, 5);
+    }
+    static async seedingOrgsCreatesOrganization() {
+        const { locations } = await this.fixture.seedAccount({
+            totalLocations: 3,
+        });
+        test_1.assert.isLength(locations, 3);
+        await this.assertOnlyOneOrgExists();
+    }
+    static async canPassOrgToLocationSeeder() {
+        const org = await this.organizations.seedDemoOrganization();
+        await this.fixture.seedAccount({
+            totalLocations: 3,
+            organizationId: org.id,
+        });
+        await this.assertOnlyOneOrgExists();
+    }
+    static async throwsWhenSeedingWithoutCount() {
+        //@ts-ignore
+        const err = await test_1.assert.doesThrowAsync(() => this.fixture.seedAccount({}));
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['totalLocations'],
+        });
+    }
+    static async actuallyCreatesLocations() {
+        const { organization, locations } = await this.seedLocations();
+        const results = await this.client.emit('list-locations::v2020_12_25', {
+            target: {
+                organizationId: organization.id,
+            },
+        });
+        const { locations: matches } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isLength(matches, 3);
+        for (const location of locations) {
+            const results = await this.client.emit('get-location::v2020_12_25', {
+                target: {
+                    locationId: location.id,
+                },
+            });
+            spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        }
+    }
+    static async needsStartingPhoneWhenSeedingPeople(options) {
+        const err = await test_1.assert.doesThrowAsync(() => this.seedLocations(Object.assign({}, options)));
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['startingPhone'],
+        });
+    }
+    static async returnsSeededGuests(options, expectedCount, base) {
+        var _a;
+        const _b = await this.seedLocations(Object.assign({ totalLocations: 1, startingPhone: constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE }, options)), { locations } = _b, rest = __rest(_b, ["locations"]);
+        const withoutOwner = await this.listPeople(locations[0], base);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const withoutOwnerCleaned = withoutOwner.map((_a) => {
+            var { roleIds } = _a, rest = __rest(_a, ["roleIds"]);
+            return rest;
+        });
+        //@ts-ignore
+        const people = (_a = rest[base + 's']) !== null && _a !== void 0 ? _a : [];
+        people.sort(sorter);
+        withoutOwnerCleaned.sort(sorter);
+        test_1.assert.isLength(withoutOwner, expectedCount);
+        test_1.assert.isEqualDeep(people, withoutOwnerCleaned);
+    }
+    static async setsFirstPersonsNumberToTheStartingPhone(phone) {
+        const { guests } = await this.seedLocations({
+            totalLocations: 1,
+            totalGuests: 1,
+            startingPhone: phone,
+        });
+        test_1.assert.isEqual(guests[0].phone, (0, schema_1.formatPhoneNumber)(phone));
+    }
+    static async canSeedMultipleRolesAtOnce() {
+        const { locations } = await this.seedLocations({
+            startingPhone: constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+            totalLocations: 1,
+            totalGuests: 3,
+            totalManagers: 2,
+        });
+        const people = await this.listPeople(locations[0], ['guest', 'manager']);
+        test_1.assert.isLength(people, 5);
+    }
+    static async seededPeopleHaveNames() {
+        const { teammates } = await this.seedLocations({
+            startingPhone: constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+            totalLocations: 1,
+            totalTeammates: 2,
+        });
+        test_1.assert.isTruthy(teammates[0].firstName);
+    }
+    static async peopleAllHaveUniqueNames() {
+        const { teammates } = await this.seedLocations({
+            startingPhone: constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+            totalLocations: 1,
+            totalTeammates: 2,
+        });
+        const names = teammates.map((t) => t.casualName);
+        const unique = [...new Set(names)];
+        test_1.assert.isLength(unique, names.length);
+    }
+    static async namesAreOnlyAssignedIfNotYetAssigned() {
+        const { client } = await this.people.loginAsDemoPerson(constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE);
+        const firstName = `Test person:: ${Math.random()}`;
+        const lastName = `${Math.random()}`;
+        await client.emitAndFlattenResponses('update-person::v2020_12_25', {
+            payload: {
+                firstName,
+                lastName,
+            },
+        });
+        const { teammates } = await this.seedLocations({
+            startingPhone: constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+            totalLocations: 1,
+            totalTeammates: 1,
+        });
+        const [tm1] = teammates;
+        test_1.assert.isEqual(tm1.casualName, firstName + ' ' + lastName[0] + '.');
+    }
+    static async listPeople(location, base) {
+        const people = await this.people.listPeople({
+            locationId: location.id,
+            organizationId: location.organizationId,
+            roleBases: Array.isArray(base) ? base : [base],
+            shouldIncludePrivateFields: true,
+        });
+        const withoutOwner = people.filter((p) => p.id !== fake_1.default.getPerson().id);
+        return withoutOwner;
+    }
+    static async seedLocations(options) {
+        const org = await this.organizations.seedDemoOrganization();
+        const results = await this.fixture.seedAccount(Object.assign({ totalLocations: 3, organizationId: org.id }, options));
+        return Object.assign({ organization: org }, results);
+    }
+    static async assertOnlyOneOrgExists() {
+        const results = await this.client.emit('list-organizations::v2020_12_25', {
+            payload: {
+                shouldOnlyShowMine: true,
+            },
+        });
+        const { organizations } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isLength(organizations, 1);
+        test_1.assert.isObject(organizations[0].address);
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "hasSeedFixture", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "canSeedManyOrgs", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "actuallyCreatesOrgs", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "canSeedLocations", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "seedingOrgsCreatesOrganization", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "canPassOrgToLocationSeeder", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "throwsWhenSeedingWithoutCount", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "actuallyCreatesLocations", null);
+__decorate([
+    (0, test_1.test)('missing starting phone with totalGuests', { totalGuests: 10 }),
+    (0, test_1.test)('missing starting phone with totalTeammates', { totalTeammates: 10 })
+], SeedingDataTest, "needsStartingPhoneWhenSeedingPeople", null);
+__decorate([
+    (0, test_1.test)('can seed 3 guests', { totalGuests: 3 }, 3, 'guest'),
+    (0, test_1.test)('can seed 5 guests', { totalGuests: 5 }, 5, 'guest'),
+    (0, test_1.test)('can seed 2 teammates', { totalTeammates: 2 }, 2, 'teammate'),
+    (0, test_1.test)('can seed 3 managers', { totalManagers: 3 }, 3, 'manager'),
+    (0, test_1.test)('can seed 3 groupManager', { totalGroupManagers: 3 }, 3, 'groupManager'),
+    (0, test_1.test)('can seed 1 owners', { totalOwners: 1 }, 1, 'owner')
+], SeedingDataTest, "returnsSeededGuests", null);
+__decorate([
+    (0, test_1.test)('seeds with starting phone 1', constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE),
+    (0, test_1.test)('seeds with starting phone 2', constants_1.DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE_ALT)
+], SeedingDataTest, "setsFirstPersonsNumberToTheStartingPhone", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "canSeedMultipleRolesAtOnce", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "seededPeopleHaveNames", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "peopleAllHaveUniqueNames", null);
+__decorate([
+    (0, test_1.test)()
+], SeedingDataTest, "namesAreOnlyAssignedIfNotYetAssigned", null);
+SeedingDataTest = __decorate([
+    fake_1.default.login(constants_1.DEMO_NUMBER_SEED_FIXTURE)
+], SeedingDataTest);
+exports.default = SeedingDataTest;

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

@@ -0,0 +1,13 @@
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest';
+export default class SkillFixtureTest extends AbstractSpruceFixtureTest {
+    private static fixture;
+    protected static beforeEach(): Promise<void>;
+    protected static canCreateSkillFixture(): Promise<void>;
+    protected static canSeedSkill(): Promise<void>;
+    protected static cleansUpSkillsAndNotCrashWithMultileDestroys(): Promise<void>;
+    protected static cantLoginAsCurrentSkillIfSkillNotConfigured(): Promise<void>;
+    protected static cantLoginAsCurrentSkillIfSkillNotConfiguredWithApiKey(): Promise<void>;
+    protected static canLoginAsCurrentSkill(): Promise<void>;
+    protected static shouldUnRegisterDemoSkills(): Promise<void>;
+    protected static canPassThroughPersonFixture(): void;
+}

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

@@ -0,0 +1,116 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
+const test_1 = require("@sprucelabs/test");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const __1 = require("../..");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../tests/AbstractSpruceFixtureTest"));
+const constants_1 = require("../../tests/constants");
+let SkillFixtureTest = class SkillFixtureTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.fixture = this.Fixture('skill');
+        delete process.env.SKILL_ID;
+        delete process.env.SKILL_API_KEY;
+    }
+    static async canCreateSkillFixture() {
+        test_1.assert.isTruthy(this.fixture);
+    }
+    static async canSeedSkill() {
+        const skill = await this.fixture.seedDemoSkill({
+            name: 'skill1',
+        });
+        test_1.assert.isTruthy(skill);
+        test_1.assert.isEqual(skill.name, 'skill1');
+    }
+    static async cleansUpSkillsAndNotCrashWithMultileDestroys() {
+        const skill = await this.fixture.seedDemoSkill({
+            name: 'skill1',
+        });
+        await this.fixture.destroy();
+        await this.fixture.destroy();
+        const client = await this.Fixture('mercury').connectToApi();
+        const results = await client.emit('get-skill::v2020_12_25', {
+            target: {
+                skillId: skill.id,
+            },
+        });
+        spruce_event_utils_1.eventAssertUtil.assertErrorFromResponse(results, 'INVALID_TARGET');
+    }
+    static async cantLoginAsCurrentSkillIfSkillNotConfigured() {
+        const err = await test_1.assert.doesThrowAsync(() => this.fixture.loginAsCurrentSkill());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['env.SKILL_ID', 'env.SKILL_API_KEY'],
+        });
+    }
+    static async cantLoginAsCurrentSkillIfSkillNotConfiguredWithApiKey() {
+        process.env.SKILL_ID = '123';
+        const err = await test_1.assert.doesThrowAsync(() => this.fixture.loginAsCurrentSkill());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['env.SKILL_API_KEY'],
+        });
+    }
+    static async canLoginAsCurrentSkill() {
+        const { skill: demoSkill } = await this.fixture.loginAsDemoSkill({
+            name: 'Demo me!',
+        });
+        process.env.SKILL_ID = demoSkill.id;
+        process.env.SKILL_API_KEY = demoSkill.apiKey;
+        const { skill, client } = await this.fixture.loginAsCurrentSkill();
+        test_1.assert.isTruthy(skill);
+        test_1.assert.isTruthy(client);
+        test_1.assert.isEqual(skill.id, demoSkill.id);
+        test_1.assert.isEqual(skill.apiKey, demoSkill.apiKey);
+    }
+    static async shouldUnRegisterDemoSkills() {
+        const { client } = await this.fixture.loginAsDemoSkill({
+            name: 'Demo me!',
+        });
+        await this.fixture.destroy();
+        const results = await client.emit('whoami::v2020_12_25');
+        test_1.assert.doesThrow(() => spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results));
+    }
+    static canPassThroughPersonFixture() {
+        const personFixture = this.Fixture('person');
+        const fixture = this.Fixture('skill', { personFixture });
+        //@ts-ignore
+        test_1.assert.isEqual(fixture.personFixture, personFixture);
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "canCreateSkillFixture", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "canSeedSkill", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "cleansUpSkillsAndNotCrashWithMultileDestroys", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "cantLoginAsCurrentSkillIfSkillNotConfigured", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "cantLoginAsCurrentSkillIfSkillNotConfiguredWithApiKey", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "canLoginAsCurrentSkill", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "shouldUnRegisterDemoSkills", null);
+__decorate([
+    (0, test_1.test)()
+], SkillFixtureTest, "canPassThroughPersonFixture", null);
+SkillFixtureTest = __decorate([
+    (0, __1.login)(constants_1.DEMO_NUMBER_SKILL_FIXTURE)
+], SkillFixtureTest);
+exports.default = SkillFixtureTest;