@sprucelabs/spruce-test-fixtures 45.2.7 → 46.0.0

package/build/esm/__tests__/behavioral/faking/UsingFakesOnIncompatibleClass.test.js

@@ -0,0 +1,31 @@
+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 AbstractSpruceTest, { test, assert } from '@sprucelabs/test';
+import fake from '../../../tests/decorators/fake.js';
+let UsingFakesOnIncompatibleClassTest = class UsingFakesOnIncompatibleClassTest extends AbstractSpruceTest {
+    static shouldNotCrash() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTrue(true);
+        });
+    }
+};
+__decorate([
+    test()
+], UsingFakesOnIncompatibleClassTest, "shouldNotCrash", null);
+UsingFakesOnIncompatibleClassTest = __decorate([
+    fake.login()
+], UsingFakesOnIncompatibleClassTest);
+export default UsingFakesOnIncompatibleClassTest;

package/build/esm/__tests__/behavioral/faking/WhoAmI.test.d.ts

@@ -0,0 +1,19 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+export default class WhoAmITest extends AbstractSpruceFixtureTest {
+    private static auth;
+    private static didLoginCount;
+    protected static beforeEach(): Promise<void>;
+    protected static afterEach(): Promise<void>;
+    protected static afterAll(): Promise<void>;
+    protected static canWhoAmI(): Promise<void>;
+    protected static canWhoAmI2(): Promise<void>;
+    protected static canRegisterProxyToken(): Promise<void>;
+    protected static canUseProxyToEmitAsOtherPerson(): Promise<void>;
+    protected static canUseProxyAsSecondPerson(): Promise<void>;
+    private static loginAsOutsider;
+    private static emitWhoAmI;
+    private static registerOwnerProxy;
+    private static get client();
+    protected static resolveTestPath(...pathAfterTestDirsAndFiles: string[]): string;
+    private static emitRegister;
+}

package/build/esm/__tests__/behavioral/faking/WhoAmI.test.js

@@ -0,0 +1,140 @@
+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 { assert, test } from '@sprucelabs/test';
+import { fake } from '../../../index.js';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest.js';
+let WhoAmITest = class WhoAmITest 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.cwd = this.resolveTestPath('skill');
+            yield this.emitRegister();
+        });
+    }
+    static afterEach() {
+        const _super = Object.create(null, {
+            afterEach: { get: () => super.afterEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.afterEach.call(this);
+            yield this.emitRegister();
+        });
+    }
+    static afterAll() {
+        const _super = Object.create(null, {
+            afterAll: { get: () => super.afterAll }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.afterAll.call(this);
+            yield this.emitRegister();
+        });
+    }
+    static canWhoAmI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.auth = this.views.getAuthenticator();
+            yield fake.getClient().emitAndFlattenResponses('whoami::v2020_12_25');
+            this.views.getAuthenticator().addEventListener('did-login', () => __awaiter(this, void 0, void 0, function* () {
+                this.didLoginCount++;
+            }));
+        });
+    }
+    static canWhoAmI2() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isNotEqual(this.views.getAuthenticator(), this.auth);
+            yield fake.getClient().emitAndFlattenResponses('whoami::v2020_12_25');
+            assert.isEqual(this.didLoginCount, 0);
+        });
+    }
+    static canRegisterProxyToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proxy = yield this.registerOwnerProxy();
+            assert.isTruthy(proxy);
+            const proxy2 = yield this.registerOwnerProxy();
+            assert.isNotEqual(proxy, proxy2);
+        });
+    }
+    static canUseProxyToEmitAsOtherPerson() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client } = yield this.loginAsOutsider();
+            const proxy = yield this.registerOwnerProxy();
+            client.setProxyToken(proxy);
+            const auth = yield this.emitWhoAmI(client);
+            assert.isEqualDeep(auth.person, this.fakedPerson);
+        });
+    }
+    static canUseProxyAsSecondPerson() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client, person } = yield this.loginAsOutsider();
+            const proxy = yield client.registerProxyToken();
+            this.client.setProxyToken(proxy);
+            const auth = yield this.emitWhoAmI();
+            assert.isEqualDeep(auth.person, person);
+        });
+    }
+    static loginAsOutsider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { client, person } = yield this.people.loginAsDemoPerson('555-555-1234');
+            return { client, person };
+        });
+    }
+    static emitWhoAmI(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [{ auth }] = yield (client !== null && client !== void 0 ? client : this.client).emitAndFlattenResponses('whoami::v2020_12_25');
+            return auth;
+        });
+    }
+    static registerOwnerProxy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.registerProxyToken();
+        });
+    }
+    static get client() {
+        return fake.getClient();
+    }
+    static resolveTestPath(...pathAfterTestDirsAndFiles) {
+        return this.resolvePath(__dirname, '..', '..', 'testDirsAndFiles', ...pathAfterTestDirsAndFiles);
+    }
+    static emitRegister() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield fake
+                .getClient()
+                .emitAndFlattenResponses('register-proxy-token::v2020_12_25');
+        });
+    }
+};
+WhoAmITest.didLoginCount = 0;
+__decorate([
+    test()
+], WhoAmITest, "canWhoAmI", null);
+__decorate([
+    test()
+], WhoAmITest, "canWhoAmI2", null);
+__decorate([
+    test()
+], WhoAmITest, "canRegisterProxyToken", null);
+__decorate([
+    test()
+], WhoAmITest, "canUseProxyToEmitAsOtherPerson", null);
+__decorate([
+    test()
+], WhoAmITest, "canUseProxyAsSecondPerson", null);
+WhoAmITest = __decorate([
+    fake.login()
+], WhoAmITest);
+export default WhoAmITest;

package/build/esm/__tests__/behavioral/maps/SpyingMapUtil.test.d.ts

@@ -0,0 +1,10 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+export default class SpyingMapUtilTest extends AbstractSpruceFixtureTest {
+    protected static beforeEach(): Promise<void>;
+    protected static canCreateSpyingMapUtil(): Promise<void>;
+    protected static dropsIntoViewFixture(): Promise<void>;
+    protected static dropsSpyIntoVc(): Promise<void>;
+    protected static redirectingIsTracked(): Promise<void>;
+    protected static resetsLastOpenNavBetweenTests(): Promise<void>;
+    private static get maps();
+}

package/build/esm/__tests__/behavioral/maps/SpyingMapUtil.test.js

@@ -0,0 +1,94 @@
+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 { CardViewControllerImpl } from '@sprucelabs/heartwood-view-controllers';
+import { test, assert } from '@sprucelabs/test';
+import { generateId } from '@sprucelabs/test-utils';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest.js';
+import spyMapUtil from '../../../utilities/SpyMapUtil.js';
+class SpyCard extends CardViewControllerImpl {
+    getMaps() {
+        return this.maps;
+    }
+}
+export default class SpyingMapUtilTest 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.views = this.Fixture('view', {
+                controllerMap: {
+                    spy: SpyCard,
+                },
+            });
+        });
+    }
+    static canCreateSpyingMapUtil() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTruthy(spyMapUtil);
+        });
+    }
+    static dropsIntoViewFixture() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isEqual(this.maps, spyMapUtil);
+        });
+    }
+    static dropsSpyIntoVc() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vc = this.views.Controller('spy', {});
+            assert.isEqual(vc.getMaps(), this.maps);
+        });
+    }
+    static redirectingIsTracked() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = {
+                city: generateId(),
+                country: generateId(),
+                province: generateId(),
+                street1: generateId(),
+                street2: generateId(),
+                zip: generateId(),
+            };
+            this.maps.openNavigation({ to: address });
+            assert.isEqualDeep((_a = this.maps.lastOpenNavigationOptions) === null || _a === void 0 ? void 0 : _a.to, address);
+        });
+    }
+    static resetsLastOpenNavBetweenTests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isFalsy(this.maps.lastOpenNavigationOptions);
+        });
+    }
+    static get maps() {
+        return this.views.getMaps();
+    }
+}
+__decorate([
+    test()
+], SpyingMapUtilTest, "canCreateSpyingMapUtil", null);
+__decorate([
+    test()
+], SpyingMapUtilTest, "dropsIntoViewFixture", null);
+__decorate([
+    test()
+], SpyingMapUtilTest, "dropsSpyIntoVc", null);
+__decorate([
+    test()
+], SpyingMapUtilTest, "redirectingIsTracked", null);
+__decorate([
+    test()
+], SpyingMapUtilTest, "resetsLastOpenNavBetweenTests", null);

package/build/esm/__tests__/behavioral/seeding/UsingDecorators.test.d.ts

@@ -0,0 +1,37 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+import { DummyStore } from '../DummyStore';
+export default class UsingDecoratorsTest extends AbstractSpruceFixtureTest {
+    private static lastClient;
+    private static goodStore;
+    protected static beforeEach(): Promise<void>;
+    protected static afterAll(): Promise<void>;
+    protected static loginSetsDefaultClient(): Promise<void>;
+    protected static retainsClientBetweenTests(): Promise<void>;
+    protected static canSeedThreeOrgs(): Promise<void>;
+    protected static canSeedFiveOrgs(): Promise<void>;
+    protected static canSeedTwoLocations(): Promise<void>;
+    protected static seededLocationsArePublic(): Promise<void>;
+    protected static canSeedTenLocations(): Promise<void>;
+    protected static locationUsesLatestOrg(): Promise<void>;
+    protected static canSeedStores(): Promise<void>;
+    protected static logsInViewAuthenticator(): void;
+    protected static passesThroughArgs(one: number, two: number, three: number): void;
+    protected static passesThroughArgs2(one: any): void;
+    protected static seedsAddToBeforeEach(): Promise<void>;
+    protected static seedsAddToBeforeEachButNotLastRun(): Promise<void>;
+    protected static canGetClientOffLogin(): Promise<void>;
+    protected static storeGetsVariablesPassed(): Promise<void>;
+    protected static storeGetsVariablesPassed2(): Promise<void>;
+    protected static canSeedPeople(baseCounts: Record<string, number>): Promise<void>;
+    private static assertExpectedSeededPeople;
+    protected static canSeedMorePeople(baseCounts: Record<string, number>): Promise<void>;
+    private static assertCountOrgs;
+    private static assertCountLocations;
+    private static assertCountGoods;
+    private static assertTotalPeopleByRole;
+}
+declare module '@sprucelabs/data-stores/build/types/stores.types' {
+    interface StoreMap {
+        dummies: DummyStore;
+    }
+}

package/build/esm/__tests__/behavioral/seeding/UsingDecorators.test.js

@@ -0,0 +1,322 @@
+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 { AuthenticatorImpl } from '@sprucelabs/heartwood-view-controllers';
+import { MercuryClientFactory } from '@sprucelabs/mercury-client';
+import { test, assert } from '@sprucelabs/test';
+import { MercuryFixture, StoreFixture } from '../../../index.js';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest.js';
+import { DEMO_NUMBER_DECORATORS } from '../../../tests/constants.js';
+import login from '../../../tests/decorators/login.js';
+import seed from '../../../tests/decorators/seed.js';
+// eslint-disable-next-line spruce/prohibit-import-from-build-folder
+import GoodStore from '../../testDirsAndFiles/one-good-store-skill/build/stores/Good.store.js';
+import { DummyStore } from '../DummyStore.js';
+let UsingDecoratorsTest = class UsingDecoratorsTest extends AbstractSpruceFixtureTest {
+    static beforeEach() {
+        const _super = Object.create(null, {
+            beforeEach: { get: () => super.beforeEach }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTrue(MercuryClientFactory.isInTestMode());
+            this.goodStore = yield this.Fixture('store').Store('good');
+            yield this.assertCountGoods(5);
+            yield _super.beforeEach.call(this);
+            const auth = AuthenticatorImpl.getInstance();
+            assert.isTruthy(auth.getSessionToken());
+            const client = login.getClient();
+            const person = login.getPerson();
+            //@ts-ignore
+            assert.isEqualDeep(person, client.auth.person);
+            assert.isTruthy(client);
+            assert.isTrue(client.isConnected());
+            assert.isTrue(client.getIsTestClient());
+            this.lastClient = client;
+            //@ts-ignore
+            assert.isEqualDeep(auth.getPerson(), client.auth.person);
+            //@ts-ignore
+            assert.isEqualDeep(auth.getSessionToken(), client.auth.token);
+            this.goodStore = yield this.Fixture('store').Store('good');
+            yield this.assertCountGoods(5);
+        });
+    }
+    static afterAll() {
+        const _super = Object.create(null, {
+            afterAll: { get: () => super.afterAll }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.afterAll.call(this);
+            const client = MercuryFixture.getDefaultClient();
+            assert.isFalsy(client);
+            assert.isFalse(this.lastClient.isConnected());
+        });
+    }
+    static loginSetsDefaultClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = MercuryFixture.getDefaultClient();
+            assert.isTruthy(client);
+            assert.isTrue(client.isConnected());
+        });
+    }
+    static retainsClientBetweenTests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = MercuryFixture.getDefaultClient();
+            assert.isTruthy(client);
+            assert.isEqual(this.lastClient, client);
+            assert.isTrue(client.isConnected());
+        });
+    }
+    static canSeedThreeOrgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountOrgs(3);
+        });
+    }
+    static canSeedFiveOrgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountOrgs(5);
+        });
+    }
+    static canSeedTwoLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountLocations(3);
+        });
+    }
+    static seededLocationsArePublic() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const locations = yield this.locations.listLocations();
+            for (const location of locations) {
+                assert.isTrue(location.isPublic);
+            }
+        });
+    }
+    static canSeedTenLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountLocations(10);
+        });
+    }
+    static locationUsesLatestOrg() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountLocations(10);
+            yield this.assertCountOrgs(10);
+        });
+    }
+    static canSeedStores() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isTrue(DummyStore.wasSeedInvoked);
+            assert.isEqualDeep(DummyStore.seedOptions, {
+                totalToSeed: 10,
+                TestClass: this,
+            });
+        });
+    }
+    static logsInViewAuthenticator() {
+        assert.isTruthy(AuthenticatorImpl.getInstance().getSessionToken());
+    }
+    static passesThroughArgs(one, two, three) {
+        assert.isEqual(one, 1);
+        assert.isEqual(two, 1);
+        assert.isEqual(three, 1);
+    }
+    static passesThroughArgs2(one) {
+        assert.isEqualDeep(one, { hello: 'world' });
+    }
+    static seedsAddToBeforeEach() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountGoods(10);
+        });
+    }
+    static seedsAddToBeforeEachButNotLastRun() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertCountGoods(6);
+        });
+    }
+    static canGetClientOffLogin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isFunction(login.getClient);
+            assert.isEqual(login.getClient(), MercuryFixture.getDefaultClient());
+        });
+    }
+    static storeGetsVariablesPassed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isEqualDeep(GoodStore.seedParams, ['hello', 'world']);
+        });
+    }
+    static storeGetsVariablesPassed2() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isEqualDeep(GoodStore.seedParams, ['goodbye', 'people']);
+        });
+    }
+    static canSeedPeople(baseCounts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertExpectedSeededPeople(baseCounts);
+        });
+    }
+    static assertExpectedSeededPeople(baseCounts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bases = Object.keys(baseCounts);
+            for (const base of bases) {
+                const count = baseCounts[base];
+                yield this.assertTotalPeopleByRole(base, count);
+            }
+        });
+    }
+    static canSeedMorePeople(baseCounts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertExpectedSeededPeople(baseCounts);
+        });
+    }
+    static assertCountOrgs(expected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const organizations = yield this.organizations.listOrganizations();
+            assert.isLength(organizations, expected);
+        });
+    }
+    static assertCountLocations(expected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.views.getScope().getCurrentOrganization();
+            assert.isTruthy(org);
+            const organizationId = org.id;
+            const locations = yield this.locations.listLocations(organizationId);
+            assert.isLength(locations, expected);
+        });
+    }
+    static assertCountGoods(expected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const goodStore = yield this.stores.Store('good');
+            const count = yield goodStore.count({});
+            assert.isEqual(count, expected);
+            const localCount = yield this.goodStore.count({});
+            assert.isEqual(localCount, expected, 'The store built in beforeEach is pointing at stale database.');
+        });
+    }
+    static assertTotalPeopleByRole(roleBase, total) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.organizations.getNewestOrganization();
+            assert.isTruthy(org);
+            const teammates = yield this.people.listPeople({
+                organizationId: org.id,
+                roleBases: [roleBase],
+            });
+            assert.isLength(teammates, total);
+        });
+    }
+};
+__decorate([
+    seed('good', 5),
+    seed('dummies', 10)
+], UsingDecoratorsTest, "beforeEach", null);
+__decorate([
+    test()
+], UsingDecoratorsTest, "loginSetsDefaultClient", null);
+__decorate([
+    test()
+], UsingDecoratorsTest, "retainsClientBetweenTests", null);
+__decorate([
+    test(),
+    seed('organizations', 3)
+], UsingDecoratorsTest, "canSeedThreeOrgs", null);
+__decorate([
+    test(),
+    seed('organizations', 5)
+], UsingDecoratorsTest, "canSeedFiveOrgs", null);
+__decorate([
+    test(),
+    seed('locations', 3)
+], UsingDecoratorsTest, "canSeedTwoLocations", null);
+__decorate([
+    test(),
+    seed('locations', 3)
+], UsingDecoratorsTest, "seededLocationsArePublic", null);
+__decorate([
+    test(),
+    seed('locations', 10)
+], UsingDecoratorsTest, "canSeedTenLocations", null);
+__decorate([
+    test(),
+    seed('organizations', 10),
+    seed('locations', 10)
+], UsingDecoratorsTest, "locationUsesLatestOrg", null);
+__decorate([
+    test(),
+    seed('dummies', 10)
+], UsingDecoratorsTest, "canSeedStores", null);
+__decorate([
+    test()
+], UsingDecoratorsTest, "logsInViewAuthenticator", null);
+__decorate([
+    test('passes through args 1', 1, 1, 1),
+    seed('dummies', 3)
+], UsingDecoratorsTest, "passesThroughArgs", null);
+__decorate([
+    test('passes through args 2', { hello: 'world' }),
+    seed('dummies', 3)
+], UsingDecoratorsTest, "passesThroughArgs2", null);
+__decorate([
+    test(),
+    seed('good', 5)
+], UsingDecoratorsTest, "seedsAddToBeforeEach", null);
+__decorate([
+    test(),
+    seed('good', 1)
+], UsingDecoratorsTest, "seedsAddToBeforeEachButNotLastRun", null);
+__decorate([
+    test()
+], UsingDecoratorsTest, "canGetClientOffLogin", null);
+__decorate([
+    test(),
+    seed('good', 1, 'hello', 'world')
+], UsingDecoratorsTest, "storeGetsVariablesPassed", null);
+__decorate([
+    test(),
+    seed('good', 1, 'goodbye', 'people')
+], UsingDecoratorsTest, "storeGetsVariablesPassed2", null);
+__decorate([
+    test('can seed people', {
+        guest: 2,
+        teammate: 2,
+        groupManager: 2,
+        manager: 2,
+        owner: 3,
+    }),
+    seed('organizations', 1),
+    seed('locations', 1),
+    seed('teammates', 2),
+    seed('guests', 2),
+    seed('groupManagers', 2),
+    seed('managers', 2),
+    seed('owners', 2)
+], UsingDecoratorsTest, "canSeedPeople", null);
+__decorate([
+    test('can seed more people', {
+        guest: 5,
+        teammate: 5,
+        groupManager: 3,
+        manager: 4,
+        owner: 6,
+    }),
+    seed('organizations', 1),
+    seed('locations', 1),
+    seed('teammates', 5),
+    seed('guests', 5),
+    seed('groupManagers', 3),
+    seed('managers', 4),
+    seed('owners', 5)
+], UsingDecoratorsTest, "canSeedMorePeople", null);
+UsingDecoratorsTest = __decorate([
+    login(DEMO_NUMBER_DECORATORS)
+], UsingDecoratorsTest);
+export default UsingDecoratorsTest;
+StoreFixture.setStore('dummies', DummyStore);
+StoreFixture.setStore('good', GoodStore);

package/build/esm/__tests__/behavioral/seeding/UsingDecoratorsToInstallSkills.test.d.ts

@@ -0,0 +1,14 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+export default class UsingDecoratorsToInstallSkills extends AbstractSpruceFixtureTest {
+    private static skill;
+    protected static beforeEach(): Promise<void>;
+    protected static throwsWhenMissingNamespaces(): void;
+    protected static returnsDecorator(): void;
+    protected static callsOriginalTestMethod(): Promise<void>;
+    protected static passesThroughOriginalArgs(args: any): Promise<void>;
+    protected static throwsWithoutSeedingOrg(): Promise<void>;
+    protected static throwsWhenInstallingBadSkill(): Promise<void>;
+    protected static doesNotEmitDidInstall(): Promise<void>;
+    private static executeDecorator;
+    private static getDecorator;
+}