@sprucelabs/spruce-test-fixtures 45.2.7 → 46.0.0

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

@@ -0,0 +1,143 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { eventResponseUtil } from '@sprucelabs/spruce-event-utils';
+import { assert, test } from '@sprucelabs/test';
+import { errorAssert } from '@sprucelabs/test-utils';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER_ROLE_FIXTURE } from '../../tests/constants.js';
+import fake from '../../tests/decorators/fake.js';
+import seed from '../../tests/decorators/seed.js';
+let RoleFixtureTest = class RoleFixtureTest extends AbstractSpruceFixtureTest {
+    static beforeEach() {
+        const _super = Object.create(null, {
+            beforeEach: { get: () => super.beforeEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.beforeEach.call(this);
+            this.fixture = this.Fixture('role');
+            this.client = fake.getClient();
+        });
+    }
+    static hasRoleFixture() {
+        assert.isTruthy(this.fixture);
+    }
+    static cantListRolesWithoutOrg() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const err = yield assert.doesThrowAsync(() => this.fixture.listRoles());
+            errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+                parameters: ['organizationId'],
+            });
+        });
+    }
+    static listsValidRoles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roles = yield this.fixture.listRoles();
+            assert.isArray(roles);
+            assert.isAbove(roles.length, 0);
+            for (const role of roles) {
+                const results = yield this.client.emit('get-role::v2020_12_25', {
+                    target: {
+                        roleId: role.id,
+                    },
+                });
+                eventResponseUtil.getFirstResponseOrThrow(results);
+            }
+        });
+    }
+    static listsWorkingRolesByDefault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allRoles = yield this.listRoles();
+            const expectedRoles = allRoles.filter((role) => role.base !== 'anonymous' && role.base !== 'loggedIn');
+            yield this.assertListedRolesMatchExpected(expectedRoles);
+        });
+    }
+    static listMetaRolesWithOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allRoles = yield this.listRoles();
+            yield this.assertListedRolesMatchExpected(allRoles, {
+                shouldIncludeMetaRoles: true,
+            });
+        });
+    }
+    static canPassOwnOrg() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const orgs = yield this.organizations.listOrganizations();
+            const org = orgs[2];
+            const roles = yield this.fixture.listRoles({ organizationId: org.id });
+            assert.isEqual(roles[0].organizationId, org.id);
+        });
+    }
+    static getNewestOrg() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.organizations.getNewestOrganization();
+            assert.isTruthy(org, `You gotta @seed('organizations',1) to continue.`);
+            return org;
+        });
+    }
+    static assertListedRolesMatchExpected(expectedRoles, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roles = yield this.fixture.listRoles(options);
+            function sort(a, b) {
+                return a.name > b.name ? 1 : -1;
+            }
+            roles.sort(sort);
+            expectedRoles.sort(sort);
+            assert.isEqualDeep(roles, expectedRoles);
+        });
+    }
+    static listRoles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.getNewestOrg();
+            const roleResults = yield this.client.emit('list-roles::v2020_12_25', {
+                target: {
+                    organizationId: org.id,
+                },
+                payload: {
+                    shouldIncludePrivateRoles: true,
+                    shouldIncludeMetaRoles: true,
+                },
+            });
+            const { roles: allRoles } = eventResponseUtil.getFirstResponseOrThrow(roleResults);
+            return allRoles;
+        });
+    }
+};
+__decorate([
+    test()
+], RoleFixtureTest, "hasRoleFixture", null);
+__decorate([
+    test()
+], RoleFixtureTest, "cantListRolesWithoutOrg", null);
+__decorate([
+    test(),
+    seed('organizations', 1)
+], RoleFixtureTest, "listsValidRoles", null);
+__decorate([
+    test(),
+    seed('organizations', 1)
+], RoleFixtureTest, "listsWorkingRolesByDefault", null);
+__decorate([
+    test(),
+    seed('organizations', 1)
+], RoleFixtureTest, "listMetaRolesWithOptions", null);
+__decorate([
+    test(),
+    seed('organizations', 3)
+], RoleFixtureTest, "canPassOwnOrg", null);
+RoleFixtureTest = __decorate([
+    fake.login(DEMO_NUMBER_ROLE_FIXTURE)
+], RoleFixtureTest);
+export default RoleFixtureTest;

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

@@ -0,0 +1,314 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __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;
+};
+import { formatPhoneNumber } from '@sprucelabs/schema';
+import { eventResponseUtil } from '@sprucelabs/spruce-event-utils';
+import { assert, test } from '@sprucelabs/test';
+import { errorAssert } from '@sprucelabs/test-utils';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER_SEED_FIXTURE, DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE, DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE_ALT, } from '../../tests/constants.js';
+import fake from '../../tests/decorators/fake.js';
+const sorter = (a, b) => (a.id > b.id ? 1 : -1);
+let SeedingDataTest = class SeedingDataTest extends AbstractSpruceFixtureTest {
+    static beforeEach() {
+        const _super = Object.create(null, {
+            beforeEach: { get: () => super.beforeEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.beforeEach.call(this);
+            this.client = fake.getClient();
+            this.fixture = this.Fixture('seed');
+            yield this.fixture.resetAccount(DEMO_NUMBER_SEED_FIXTURE);
+        });
+    }
+    static hasSeedFixture() {
+        assert.isTruthy(this.fixture);
+    }
+    static canSeedManyOrgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const organizations = yield this.fixture.seedOrganizations({
+                totalOrganizations: 5,
+            });
+            assert.isLength(organizations, 5);
+        });
+    }
+    static actuallyCreatesOrgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const organizations = yield this.fixture.seedOrganizations({
+                totalOrganizations: 3,
+            });
+            const results = yield this.client.emit('list-organizations::v2020_12_25', {
+                payload: {
+                    shouldOnlyShowMine: true,
+                },
+            });
+            const { organizations: matched } = eventResponseUtil.getFirstResponseOrThrow(results);
+            assert.isLength(matched, 3);
+            assert.isLength(organizations, 3);
+            for (const org of organizations) {
+                const results = yield this.client.emit('get-organization::v2020_12_25', {
+                    target: {
+                        organizationId: org.id,
+                    },
+                });
+                eventResponseUtil.getFirstResponseOrThrow(results);
+            }
+        });
+    }
+    static canSeedLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { locations } = yield this.fixture.seedAccount({
+                totalLocations: 5,
+            });
+            assert.isLength(locations, 5);
+        });
+    }
+    static seedingOrgsCreatesOrganization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { locations } = yield this.fixture.seedAccount({
+                totalLocations: 3,
+            });
+            assert.isLength(locations, 3);
+            yield this.assertOnlyOneOrgExists();
+        });
+    }
+    static canPassOrgToLocationSeeder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.organizations.seedDemoOrganization();
+            yield this.fixture.seedAccount({
+                totalLocations: 3,
+                organizationId: org.id,
+            });
+            yield this.assertOnlyOneOrgExists();
+        });
+    }
+    static throwsWhenSeedingWithoutCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            //@ts-ignore
+            const err = yield assert.doesThrowAsync(() => this.fixture.seedAccount({}));
+            errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+                parameters: ['totalLocations'],
+            });
+        });
+    }
+    static actuallyCreatesLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { organization, locations } = yield this.seedLocations();
+            const results = yield this.client.emit('list-locations::v2020_12_25', {
+                target: {
+                    organizationId: organization.id,
+                },
+            });
+            const { locations: matches } = eventResponseUtil.getFirstResponseOrThrow(results);
+            assert.isLength(matches, 3);
+            for (const location of locations) {
+                const results = yield this.client.emit('get-location::v2020_12_25', {
+                    target: {
+                        locationId: location.id,
+                    },
+                });
+                eventResponseUtil.getFirstResponseOrThrow(results);
+            }
+        });
+    }
+    static needsStartingPhoneWhenSeedingPeople(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const err = yield assert.doesThrowAsync(() => this.seedLocations(Object.assign({}, options)));
+            errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+                parameters: ['startingPhone'],
+            });
+        });
+    }
+    static returnsSeededGuests(options, expectedCount, base) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const _b = yield this.seedLocations(Object.assign({ totalLocations: 1, startingPhone: DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE }, options)), { locations } = _b, rest = __rest(_b, ["locations"]);
+            const withoutOwner = yield 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);
+            assert.isLength(withoutOwner, expectedCount);
+            assert.isEqualDeep(people, withoutOwnerCleaned);
+        });
+    }
+    static setsFirstPersonsNumberToTheStartingPhone(phone) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { guests } = yield this.seedLocations({
+                totalLocations: 1,
+                totalGuests: 1,
+                startingPhone: phone,
+            });
+            assert.isEqual(guests[0].phone, formatPhoneNumber(phone));
+        });
+    }
+    static canSeedMultipleRolesAtOnce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { locations } = yield this.seedLocations({
+                startingPhone: DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+                totalLocations: 1,
+                totalGuests: 3,
+                totalManagers: 2,
+            });
+            const people = yield this.listPeople(locations[0], ['guest', 'manager']);
+            assert.isLength(people, 5);
+        });
+    }
+    static seededPeopleHaveNames() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { teammates } = yield this.seedLocations({
+                startingPhone: DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+                totalLocations: 1,
+                totalTeammates: 2,
+            });
+            assert.isTruthy(teammates[0].firstName);
+        });
+    }
+    static peopleAllHaveUniqueNames() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { teammates } = yield this.seedLocations({
+                startingPhone: DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+                totalLocations: 1,
+                totalTeammates: 2,
+            });
+            const names = teammates.map((t) => t.casualName);
+            const unique = [...new Set(names)];
+            assert.isLength(unique, names.length);
+        });
+    }
+    static namesAreOnlyAssignedIfNotYetAssigned() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = yield this.people.loginAsDemoPerson(DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE);
+            const firstName = `Test person:: ${Math.random()}`;
+            const lastName = `${Math.random()}`;
+            yield client.emitAndFlattenResponses('update-person::v2020_12_25', {
+                payload: {
+                    firstName,
+                    lastName,
+                },
+            });
+            const { teammates } = yield this.seedLocations({
+                startingPhone: DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE,
+                totalLocations: 1,
+                totalTeammates: 1,
+            });
+            const [tm1] = teammates;
+            assert.isEqual(tm1.casualName, firstName + ' ' + lastName[0] + '.');
+        });
+    }
+    static listPeople(location, base) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const people = yield 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.getPerson().id);
+            return withoutOwner;
+        });
+    }
+    static seedLocations(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.organizations.seedDemoOrganization();
+            const results = yield this.fixture.seedAccount(Object.assign({ totalLocations: 3, organizationId: org.id }, options));
+            return Object.assign({ organization: org }, results);
+        });
+    }
+    static assertOnlyOneOrgExists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.client.emit('list-organizations::v2020_12_25', {
+                payload: {
+                    shouldOnlyShowMine: true,
+                },
+            });
+            const { organizations } = eventResponseUtil.getFirstResponseOrThrow(results);
+            assert.isLength(organizations, 1);
+            assert.isObject(organizations[0].address);
+        });
+    }
+};
+__decorate([
+    test()
+], SeedingDataTest, "hasSeedFixture", null);
+__decorate([
+    test()
+], SeedingDataTest, "canSeedManyOrgs", null);
+__decorate([
+    test()
+], SeedingDataTest, "actuallyCreatesOrgs", null);
+__decorate([
+    test()
+], SeedingDataTest, "canSeedLocations", null);
+__decorate([
+    test()
+], SeedingDataTest, "seedingOrgsCreatesOrganization", null);
+__decorate([
+    test()
+], SeedingDataTest, "canPassOrgToLocationSeeder", null);
+__decorate([
+    test()
+], SeedingDataTest, "throwsWhenSeedingWithoutCount", null);
+__decorate([
+    test()
+], SeedingDataTest, "actuallyCreatesLocations", null);
+__decorate([
+    test('missing starting phone with totalGuests', { totalGuests: 10 }),
+    test('missing starting phone with totalTeammates', { totalTeammates: 10 })
+], SeedingDataTest, "needsStartingPhoneWhenSeedingPeople", null);
+__decorate([
+    test('can seed 3 guests', { totalGuests: 3 }, 3, 'guest'),
+    test('can seed 5 guests', { totalGuests: 5 }, 5, 'guest'),
+    test('can seed 2 teammates', { totalTeammates: 2 }, 2, 'teammate'),
+    test('can seed 3 managers', { totalManagers: 3 }, 3, 'manager'),
+    test('can seed 3 groupManager', { totalGroupManagers: 3 }, 3, 'groupManager'),
+    test('can seed 1 owners', { totalOwners: 1 }, 1, 'owner')
+], SeedingDataTest, "returnsSeededGuests", null);
+__decorate([
+    test('seeds with starting phone 1', DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE),
+    test('seeds with starting phone 2', DEMO_NUMBER_SEED_FIXTURE_STARTING_PHONE_ALT)
+], SeedingDataTest, "setsFirstPersonsNumberToTheStartingPhone", null);
+__decorate([
+    test()
+], SeedingDataTest, "canSeedMultipleRolesAtOnce", null);
+__decorate([
+    test()
+], SeedingDataTest, "seededPeopleHaveNames", null);
+__decorate([
+    test()
+], SeedingDataTest, "peopleAllHaveUniqueNames", null);
+__decorate([
+    test()
+], SeedingDataTest, "namesAreOnlyAssignedIfNotYetAssigned", null);
+SeedingDataTest = __decorate([
+    fake.login(DEMO_NUMBER_SEED_FIXTURE)
+], SeedingDataTest);
+export default SeedingDataTest;

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

@@ -0,0 +1,139 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { eventAssertUtil, eventResponseUtil, } from '@sprucelabs/spruce-event-utils';
+import { test, assert } from '@sprucelabs/test';
+import { errorAssert } from '@sprucelabs/test-utils';
+import { login } from '../../index.js';
+import AbstractSpruceFixtureTest from '../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER_SKILL_FIXTURE } from '../../tests/constants.js';
+let SkillFixtureTest = class SkillFixtureTest extends AbstractSpruceFixtureTest {
+    static beforeEach() {
+        const _super = Object.create(null, {
+            beforeEach: { get: () => super.beforeEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.beforeEach.call(this);
+            this.fixture = this.Fixture('skill');
+            delete process.env.SKILL_ID;
+            delete process.env.SKILL_API_KEY;
+        });
+    }
+    static canCreateSkillFixture() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTruthy(this.fixture);
+        });
+    }
+    static canSeedSkill() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const skill = yield this.fixture.seedDemoSkill({
+                name: 'skill1',
+            });
+            assert.isTruthy(skill);
+            assert.isEqual(skill.name, 'skill1');
+        });
+    }
+    static cleansUpSkillsAndNotCrashWithMultileDestroys() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const skill = yield this.fixture.seedDemoSkill({
+                name: 'skill1',
+            });
+            yield this.fixture.destroy();
+            yield this.fixture.destroy();
+            const client = yield this.Fixture('mercury').connectToApi();
+            const results = yield client.emit('get-skill::v2020_12_25', {
+                target: {
+                    skillId: skill.id,
+                },
+            });
+            eventAssertUtil.assertErrorFromResponse(results, 'INVALID_TARGET');
+        });
+    }
+    static cantLoginAsCurrentSkillIfSkillNotConfigured() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const err = yield assert.doesThrowAsync(() => this.fixture.loginAsCurrentSkill());
+            errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+                parameters: ['env.SKILL_ID', 'env.SKILL_API_KEY'],
+            });
+        });
+    }
+    static cantLoginAsCurrentSkillIfSkillNotConfiguredWithApiKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            process.env.SKILL_ID = '123';
+            const err = yield assert.doesThrowAsync(() => this.fixture.loginAsCurrentSkill());
+            errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+                parameters: ['env.SKILL_API_KEY'],
+            });
+        });
+    }
+    static canLoginAsCurrentSkill() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { skill: demoSkill } = yield this.fixture.loginAsDemoSkill({
+                name: 'Demo me!',
+            });
+            process.env.SKILL_ID = demoSkill.id;
+            process.env.SKILL_API_KEY = demoSkill.apiKey;
+            const { skill, client } = yield this.fixture.loginAsCurrentSkill();
+            assert.isTruthy(skill);
+            assert.isTruthy(client);
+            assert.isEqual(skill.id, demoSkill.id);
+            assert.isEqual(skill.apiKey, demoSkill.apiKey);
+        });
+    }
+    static shouldUnRegisterDemoSkills() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = yield this.fixture.loginAsDemoSkill({
+                name: 'Demo me!',
+            });
+            yield this.fixture.destroy();
+            const results = yield client.emit('whoami::v2020_12_25');
+            assert.doesThrow(() => eventResponseUtil.getFirstResponseOrThrow(results));
+        });
+    }
+    static canPassThroughPersonFixture() {
+        const personFixture = this.Fixture('person');
+        const fixture = this.Fixture('skill', { personFixture });
+        //@ts-ignore
+        assert.isEqual(fixture.personFixture, personFixture);
+    }
+};
+__decorate([
+    test()
+], SkillFixtureTest, "canCreateSkillFixture", null);
+__decorate([
+    test()
+], SkillFixtureTest, "canSeedSkill", null);
+__decorate([
+    test()
+], SkillFixtureTest, "cleansUpSkillsAndNotCrashWithMultileDestroys", null);
+__decorate([
+    test()
+], SkillFixtureTest, "cantLoginAsCurrentSkillIfSkillNotConfigured", null);
+__decorate([
+    test()
+], SkillFixtureTest, "cantLoginAsCurrentSkillIfSkillNotConfiguredWithApiKey", null);
+__decorate([
+    test()
+], SkillFixtureTest, "canLoginAsCurrentSkill", null);
+__decorate([
+    test()
+], SkillFixtureTest, "shouldUnRegisterDemoSkills", null);
+__decorate([
+    test()
+], SkillFixtureTest, "canPassThroughPersonFixture", null);
+SkillFixtureTest = __decorate([
+    login(DEMO_NUMBER_SKILL_FIXTURE)
+], SkillFixtureTest);
+export default SkillFixtureTest;

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

@@ -0,0 +1,23 @@
+import AbstractSpruceTest from '@sprucelabs/test';
+declare module '@sprucelabs/data-stores/build/types/stores.types' {
+    interface StoreMap {
+        good: any;
+    }
+}
+export default class StoreFixtureTest extends AbstractSpruceTest {
+    private static originalDestroy;
+    private static originalAfterEach;
+    protected static beforeAll(): Promise<void>;
+    protected static beforeEach(): Promise<void>;
+    protected static canGetFixture(): Promise<void>;
+    protected static canGetFunctioningStores(): Promise<void>;
+    protected static beforeAllCallsBeforeAllOnDatabaseFixture(): Promise<void>;
+    protected static beforeEachCallsDestroyOnDatabaseFixture(): Promise<void>;
+    protected static afterEachCallsAfterEachOnDatabaseFixture(): Promise<void>;
+    protected static storeLoaderUsesNewInstanceOfDbEachRun(): Promise<void>;
+    protected static storeFixtureCallsResetOnStoreFactory(): Promise<void>;
+    protected static callsBeforeEachOnCursorFaker(): Promise<void>;
+    protected static canGetStore(): Promise<void>;
+    private static setStoreDirToOneGoodStore;
+    private static FixtureFactory;
+}