@sprucelabs/spruce-test-fixtures 45.2.7 → 46.0.0

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

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

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

package/build/__tests__/behavioral/seeding/UsingDecoratorsToInstallSkills.test.js

@@ -0,0 +1,113 @@
+"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 AbstractSpruceFixtureTest_1 = __importDefault(require("../../../tests/AbstractSpruceFixtureTest"));
+const constants_1 = require("../../../tests/constants");
+const install_1 = __importDefault(require("../../../tests/decorators/install"));
+const login_1 = __importDefault(require("../../../tests/decorators/login"));
+const seed_1 = __importDefault(require("../../../tests/decorators/seed"));
+let UsingDecoratorsToInstallSkills = class UsingDecoratorsToInstallSkills extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.skill = await this.skills.seedDemoSkill();
+    }
+    static throwsWhenMissingNamespaces() {
+        test_1.assert.doesThrow(() => install_1.default.skills());
+    }
+    static returnsDecorator() {
+        const decorator = this.getDecorator();
+        test_1.assert.isFunction(decorator);
+    }
+    static async callsOriginalTestMethod() {
+        let wasHit = false;
+        await this.executeDecorator({
+            testFunction: async () => {
+                wasHit = true;
+            },
+        });
+        test_1.assert.isTrue(wasHit);
+    }
+    static async passesThroughOriginalArgs(args) {
+        let passedArgs;
+        await this.executeDecorator({
+            testFunction: async (...args) => {
+                passedArgs = args;
+            },
+            args,
+        });
+        test_1.assert.isEqualDeep(passedArgs, args);
+    }
+    static async throwsWithoutSeedingOrg() {
+        await test_1.assert.doesThrowAsync(() => this.executeDecorator({ testFunction: async () => { } }));
+    }
+    static async throwsWhenInstallingBadSkill() {
+        await test_1.assert.doesThrowAsync(() => this.executeDecorator({
+            testFunction: async () => { },
+            namespaces: ['not-found'],
+        }));
+    }
+    static async doesNotEmitDidInstall() {
+        let passedPayload;
+        await login_1.default.getClient().on('install-skill::v2020_12_25', ({ payload }) => {
+            passedPayload = payload;
+            return {};
+        });
+        await this.executeDecorator({
+            testFunction: async () => { },
+        });
+        test_1.assert.isFalse(passedPayload.shouldNotifySkillOfInstall);
+    }
+    static async executeDecorator(options) {
+        const { testFunction, args, namespaces } = options;
+        const mockDescriptor = {
+            value: testFunction,
+        };
+        const decorator = this.getDecorator(namespaces);
+        decorator(this, 'myTest', mockDescriptor);
+        //@ts-ignore
+        await mockDescriptor.value(...(args ? args : []));
+    }
+    static getDecorator(namespaces) {
+        const slugs = namespaces !== null && namespaces !== void 0 ? namespaces : [this.skill.slug];
+        return install_1.default.skills(...slugs);
+    }
+};
+__decorate([
+    (0, test_1.test)()
+], UsingDecoratorsToInstallSkills, "throwsWhenMissingNamespaces", null);
+__decorate([
+    (0, test_1.test)()
+], UsingDecoratorsToInstallSkills, "returnsDecorator", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 1)
+], UsingDecoratorsToInstallSkills, "callsOriginalTestMethod", null);
+__decorate([
+    (0, test_1.test)('passes args 1', [1]),
+    (0, test_1.test)('passes args 1', ['hello', 'world']),
+    (0, seed_1.default)('organizations', 1)
+], UsingDecoratorsToInstallSkills, "passesThroughOriginalArgs", null);
+__decorate([
+    (0, test_1.test)()
+], UsingDecoratorsToInstallSkills, "throwsWithoutSeedingOrg", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 1)
+], UsingDecoratorsToInstallSkills, "throwsWhenInstallingBadSkill", null);
+__decorate([
+    (0, test_1.test)(),
+    (0, seed_1.default)('organizations', 1)
+], UsingDecoratorsToInstallSkills, "doesNotEmitDidInstall", null);
+UsingDecoratorsToInstallSkills = __decorate([
+    (0, login_1.default)(constants_1.DEMO_NUMBER_SKILL_DECORATORS)
+], UsingDecoratorsToInstallSkills);
+exports.default = UsingDecoratorsToInstallSkills;

package/build/__tests__/behavioral/views/CheckingPermissions.test.d.ts

@@ -0,0 +1,24 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+export default class CheckingPermissionsTest extends AbstractSpruceFixtureTest {
+    private static contractId;
+    protected static beforeEach(): Promise<void>;
+    protected static canCreateCheckingPermissions(): Promise<void>;
+    protected static sharesInstances(): Promise<void>;
+    protected static viewsFixtureResetsInstance(): Promise<void>;
+    protected static throwsWhenMissingOnCan(): Promise<void>;
+    protected static throwsWhenNotSettingResponse(): Promise<void>;
+    protected static throwsWhenContractIdNotFaked(): Promise<void>;
+    protected static doesNotThrowWhenMatchingSecondContractId(): Promise<void>;
+    protected static throwsWhenNotFindingPermissionId(): Promise<void>;
+    protected static throwsWhenFindingLaterMissingPermId(): Promise<void>;
+    protected static returnsFakedResponses(permissionIds: string[], can: boolean): Promise<void>;
+    protected static fixtureAndLoadOptionsShareAuthorizer(): Promise<void>;
+    protected static authorizerClobbersMatchingContracts(): Promise<void>;
+    protected static canHandleMulplePermissionsWithDifferentContracts(): Promise<void>;
+    private static assertPermNotFound;
+    private static changeContractId;
+    private static assertThrowsFakeError;
+    private static fakePermissions;
+    private static can;
+    private static getInstance;
+}

package/build/__tests__/behavioral/views/CheckingPermissions.test.js

@@ -0,0 +1,162 @@
+"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 test_utils_1 = require("@sprucelabs/test-utils");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../../tests/AbstractSpruceFixtureTest"));
+const ViewFixture_1 = __importDefault(require("../../../tests/fixtures/ViewFixture"));
+const SpyAuthorizer_1 = __importDefault(require("../../../tests/SpyAuthorizer"));
+class CheckingPermissionsTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.contractId = (0, test_utils_1.generateId)();
+    }
+    static async canCreateCheckingPermissions() {
+        const instance = CheckingPermissionsTest.getInstance();
+        test_1.assert.isTrue(instance instanceof SpyAuthorizer_1.default);
+    }
+    static async sharesInstances() {
+        test_1.assert.isEqual(this.getInstance(), this.getInstance());
+    }
+    static async viewsFixtureResetsInstance() {
+        const instance = this.getInstance();
+        await ViewFixture_1.default.beforeEach();
+        test_1.assert.isNotEqual(this.getInstance(), instance);
+    }
+    static async throwsWhenMissingOnCan() {
+        const err = await test_1.assert.doesThrowAsync(() => 
+        //@ts-ignore
+        this.getInstance().can());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['contractId', 'permissionIds'],
+        });
+    }
+    static async throwsWhenNotSettingResponse() {
+        await this.assertThrowsFakeError();
+    }
+    static async throwsWhenContractIdNotFaked() {
+        this.fakePermissions([{ id: 'test', can: true }]);
+        this.changeContractId();
+        await this.assertThrowsFakeError();
+    }
+    static async doesNotThrowWhenMatchingSecondContractId() {
+        this.fakePermissions([{ id: 'test', can: true }]);
+        this.changeContractId();
+        this.fakePermissions([{ id: 'test2', can: true }]);
+        await this.can(['test2']);
+    }
+    static async throwsWhenNotFindingPermissionId() {
+        this.fakePermissions([{ id: 'test', can: true }]);
+        await this.assertPermNotFound(['test2'], 'test2');
+    }
+    static async throwsWhenFindingLaterMissingPermId() {
+        this.fakePermissions([{ id: 'test', can: true }]);
+        await this.assertPermNotFound(['test', 'test2'], 'test2');
+    }
+    static async returnsFakedResponses(permissionIds, can) {
+        const faked = [];
+        const expected = {};
+        permissionIds.forEach((id) => ((expected[id] = can), faked.push({ id, can })));
+        this.fakePermissions(faked);
+        const results = await this.can(permissionIds);
+        test_1.assert.isEqualDeep(results, expected);
+    }
+    static async fixtureAndLoadOptionsShareAuthorizer() {
+        this.views = this.Fixture('view', {
+            controllerMap: {},
+        });
+        const auth = this.views.getAuthorizer();
+        const router = this.views.getRouter();
+        test_1.assert.isEqual(auth, router.buildLoadOptions().authorizer);
+    }
+    static async authorizerClobbersMatchingContracts() {
+        this.fakePermissions([{ id: 'test', can: true }]);
+        this.fakePermissions([{ id: 'test', can: false }]);
+        const perms = await this.can(['test']);
+        test_1.assert.isFalse(perms['test']);
+    }
+    static async canHandleMulplePermissionsWithDifferentContracts() {
+        const firstId = this.contractId;
+        this.fakePermissions([{ id: 'test', can: true }]);
+        this.changeContractId();
+        this.fakePermissions([{ id: 'test', can: false }]);
+        this.contractId = firstId;
+        const perms = await this.can(['test']);
+        test_1.assert.isTrue(perms['test']);
+    }
+    static async assertPermNotFound(checkIds, id) {
+        await test_1.assert.doesThrowAsync(() => this.can(checkIds), id);
+    }
+    static changeContractId() {
+        this.contractId = (0, test_utils_1.generateId)();
+    }
+    static async assertThrowsFakeError() {
+        await test_1.assert.doesThrowAsync(() => this.can(['test']), `Contract by the id '${this.contractId}'`);
+    }
+    static fakePermissions(faked) {
+        this.getInstance().fakePermissions({
+            contractId: this.contractId,
+            permissions: faked,
+        });
+    }
+    static can(permissionIds) {
+        return this.getInstance().can({
+            contractId: this.contractId,
+            permissionIds,
+        });
+    }
+    static getInstance() {
+        return SpyAuthorizer_1.default.getInstance();
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "canCreateCheckingPermissions", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "sharesInstances", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "viewsFixtureResetsInstance", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "throwsWhenMissingOnCan", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "throwsWhenNotSettingResponse", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "throwsWhenContractIdNotFaked", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "doesNotThrowWhenMatchingSecondContractId", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "throwsWhenNotFindingPermissionId", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "throwsWhenFindingLaterMissingPermId", null);
+__decorate([
+    (0, test_1.test)('returns false on can 1', ['first', 'second', 'third'], false),
+    (0, test_1.test)('returns false on can 2', ['third', 'fourth'], false),
+    (0, test_1.test)('returns false on can 3', ['first', 'second', 'third'], true),
+    (0, test_1.test)('returns false on can 4', ['third', 'fourth'], true)
+], CheckingPermissionsTest, "returnsFakedResponses", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "fixtureAndLoadOptionsShareAuthorizer", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "authorizerClobbersMatchingContracts", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingPermissionsTest, "canHandleMulplePermissionsWithDifferentContracts", null);
+exports.default = CheckingPermissionsTest;

package/build/__tests__/behavioral/views/FakingSkillViewControllers.test.d.ts

@@ -0,0 +1,12 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+import FakeSkillViewController from '../../../tests/Fake.svc';
+export default class FakingSkillViewControllersTest extends AbstractSpruceFixtureTest {
+    protected static controllerMap: {
+        fake: typeof FakeSkillViewController;
+    };
+    private static viewFixture;
+    protected static beforeEach(): Promise<void>;
+    protected static canRenderkFakeSkillViewController(): Promise<void>;
+    protected static passesThroughConstructorAptions(options: any): Promise<void>;
+    protected static passesThroughLoadArgs(args: any): Promise<void>;
+}

package/build/__tests__/behavioral/views/FakingSkillViewControllers.test.js

@@ -0,0 +1,55 @@
+"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 heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const schema_1 = require("@sprucelabs/schema");
+const test_1 = require("@sprucelabs/test");
+const AbstractSpruceFixtureTest_1 = __importDefault(require("../../../tests/AbstractSpruceFixtureTest"));
+const Fake_svc_1 = __importDefault(require("../../../tests/Fake.svc"));
+class FakingSkillViewControllersTest extends AbstractSpruceFixtureTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.viewFixture = this.Fixture('view', {
+            controllerMap: {
+                fake: Fake_svc_1.default,
+            },
+        });
+    }
+    static async canRenderkFakeSkillViewController() {
+        const vc = this.viewFixture.Controller('fake', {});
+        const model = this.viewFixture.render(vc);
+        (0, schema_1.validateSchemaValues)(heartwood_view_controllers_1.skillViewSchema, model);
+    }
+    static async passesThroughConstructorAptions(options) {
+        const vc = this.viewFixture.Controller('fake', options);
+        test_1.assert.doesInclude(vc.constructorOptions, options);
+    }
+    static async passesThroughLoadArgs(args) {
+        const vc = this.viewFixture.Controller('fake', {});
+        await this.viewFixture.load(vc, args);
+        test_1.assert.isEqualDeep(vc.args, args);
+    }
+}
+FakingSkillViewControllersTest.controllerMap = {
+    fake: Fake_svc_1.default,
+};
+__decorate([
+    (0, test_1.test)()
+], FakingSkillViewControllersTest, "canRenderkFakeSkillViewController", null);
+__decorate([
+    (0, test_1.test)('passed constructor options 1', { hello: 'world' }),
+    (0, test_1.test)('passed constructor options 2', { taco: 'bell' })
+], FakingSkillViewControllersTest, "passesThroughConstructorAptions", null);
+__decorate([
+    (0, test_1.test)('passes args 1', { hello: 'world' }),
+    (0, test_1.test)('passes args 2', { cheesey: 'burrito' })
+], FakingSkillViewControllersTest, "passesThroughLoadArgs", null);
+exports.default = FakingSkillViewControllersTest;