@sprucelabs/spruce-test-fixtures 45.2.9 → 46.0.2

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

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

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

@@ -0,0 +1,200 @@
+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 { test, assert } from '@sprucelabs/test';
+import { errorAssert, generateId } from '@sprucelabs/test-utils';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest.js';
+import ViewFixture from '../../../tests/fixtures/ViewFixture.js';
+import SpyAuthorizer from '../../../tests/SpyAuthorizer.js';
+export default class CheckingPermissionsTest 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.contractId = generateId();
+        });
+    }
+    static canCreateCheckingPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = CheckingPermissionsTest.getInstance();
+            assert.isTrue(instance instanceof SpyAuthorizer);
+        });
+    }
+    static sharesInstances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isEqual(this.getInstance(), this.getInstance());
+        });
+    }
+    static viewsFixtureResetsInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = this.getInstance();
+            yield ViewFixture.beforeEach();
+            assert.isNotEqual(this.getInstance(), instance);
+        });
+    }
+    static throwsWhenMissingOnCan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const err = yield assert.doesThrowAsync(() => 
+            //@ts-ignore
+            this.getInstance().can());
+            errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+                parameters: ['contractId', 'permissionIds'],
+            });
+        });
+    }
+    static throwsWhenNotSettingResponse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertThrowsFakeError();
+        });
+    }
+    static throwsWhenContractIdNotFaked() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fakePermissions([{ id: 'test', can: true }]);
+            this.changeContractId();
+            yield this.assertThrowsFakeError();
+        });
+    }
+    static doesNotThrowWhenMatchingSecondContractId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fakePermissions([{ id: 'test', can: true }]);
+            this.changeContractId();
+            this.fakePermissions([{ id: 'test2', can: true }]);
+            yield this.can(['test2']);
+        });
+    }
+    static throwsWhenNotFindingPermissionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fakePermissions([{ id: 'test', can: true }]);
+            yield this.assertPermNotFound(['test2'], 'test2');
+        });
+    }
+    static throwsWhenFindingLaterMissingPermId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fakePermissions([{ id: 'test', can: true }]);
+            yield this.assertPermNotFound(['test', 'test2'], 'test2');
+        });
+    }
+    static returnsFakedResponses(permissionIds, can) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const faked = [];
+            const expected = {};
+            permissionIds.forEach((id) => ((expected[id] = can), faked.push({ id, can })));
+            this.fakePermissions(faked);
+            const results = yield this.can(permissionIds);
+            assert.isEqualDeep(results, expected);
+        });
+    }
+    static fixtureAndLoadOptionsShareAuthorizer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.views = this.Fixture('view', {
+                controllerMap: {},
+            });
+            const auth = this.views.getAuthorizer();
+            const router = this.views.getRouter();
+            assert.isEqual(auth, router.buildLoadOptions().authorizer);
+        });
+    }
+    static authorizerClobbersMatchingContracts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fakePermissions([{ id: 'test', can: true }]);
+            this.fakePermissions([{ id: 'test', can: false }]);
+            const perms = yield this.can(['test']);
+            assert.isFalse(perms['test']);
+        });
+    }
+    static canHandleMulplePermissionsWithDifferentContracts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const firstId = this.contractId;
+            this.fakePermissions([{ id: 'test', can: true }]);
+            this.changeContractId();
+            this.fakePermissions([{ id: 'test', can: false }]);
+            this.contractId = firstId;
+            const perms = yield this.can(['test']);
+            assert.isTrue(perms['test']);
+        });
+    }
+    static assertPermNotFound(checkIds, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield assert.doesThrowAsync(() => this.can(checkIds), id);
+        });
+    }
+    static changeContractId() {
+        this.contractId = generateId();
+    }
+    static assertThrowsFakeError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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.getInstance();
+    }
+}
+__decorate([
+    test()
+], CheckingPermissionsTest, "canCreateCheckingPermissions", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "sharesInstances", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "viewsFixtureResetsInstance", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "throwsWhenMissingOnCan", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "throwsWhenNotSettingResponse", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "throwsWhenContractIdNotFaked", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "doesNotThrowWhenMatchingSecondContractId", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "throwsWhenNotFindingPermissionId", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "throwsWhenFindingLaterMissingPermId", null);
+__decorate([
+    test('returns false on can 1', ['first', 'second', 'third'], false),
+    test('returns false on can 2', ['third', 'fourth'], false),
+    test('returns false on can 3', ['first', 'second', 'third'], true),
+    test('returns false on can 4', ['third', 'fourth'], true)
+], CheckingPermissionsTest, "returnsFakedResponses", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "fixtureAndLoadOptionsShareAuthorizer", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "authorizerClobbersMatchingContracts", null);
+__decorate([
+    test()
+], CheckingPermissionsTest, "canHandleMulplePermissionsWithDifferentContracts", null);

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

@@ -0,0 +1,69 @@
+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 { skillViewSchema } from '@sprucelabs/heartwood-view-controllers';
+import { validateSchemaValues } from '@sprucelabs/schema';
+import { assert, test } from '@sprucelabs/test';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest.js';
+import FakeSkillViewController from '../../../tests/Fake.svc.js';
+export default class FakingSkillViewControllersTest 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.viewFixture = this.Fixture('view', {
+                controllerMap: {
+                    fake: FakeSkillViewController,
+                },
+            });
+        });
+    }
+    static canRenderkFakeSkillViewController() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vc = this.viewFixture.Controller('fake', {});
+            const model = this.viewFixture.render(vc);
+            validateSchemaValues(skillViewSchema, model);
+        });
+    }
+    static passesThroughConstructorAptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vc = this.viewFixture.Controller('fake', options);
+            assert.doesInclude(vc.constructorOptions, options);
+        });
+    }
+    static passesThroughLoadArgs(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vc = this.viewFixture.Controller('fake', {});
+            yield this.viewFixture.load(vc, args);
+            assert.isEqualDeep(vc.args, args);
+        });
+    }
+}
+FakingSkillViewControllersTest.controllerMap = {
+    fake: FakeSkillViewController,
+};
+__decorate([
+    test()
+], FakingSkillViewControllersTest, "canRenderkFakeSkillViewController", null);
+__decorate([
+    test('passed constructor options 1', { hello: 'world' }),
+    test('passed constructor options 2', { taco: 'bell' })
+], FakingSkillViewControllersTest, "passesThroughConstructorAptions", null);
+__decorate([
+    test('passes args 1', { hello: 'world' }),
+    test('passes args 2', { cheesey: 'burrito' })
+], FakingSkillViewControllersTest, "passesThroughLoadArgs", null);

package/build/esm/__tests__/behavioral/views/Routing.test.d.ts

@@ -0,0 +1,31 @@
+import { SkillViewControllerId } from '@sprucelabs/heartwood-view-controllers';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+import BookSkillViewController from '../../testDirsAndFiles/skill/build/skillViewControllers/Book.svc';
+import SpySkillViewController from '../../testDirsAndFiles/skill/build/skillViewControllers/Spy.svc';
+declare module '@sprucelabs/heartwood-view-controllers/build/types/heartwood.types' {
+    interface ViewControllerMap {
+        'spruceTestFixtures.book': BookSkillViewController;
+        'spruceTestFixtures.spy': SpySkillViewController;
+    }
+    interface SkillViewControllerMap {
+        'spruceTestFixtures.book': BookSkillViewController;
+        'spruceTestFixtures.spy': SpySkillViewController;
+    }
+}
+export default class RoutingTest extends AbstractSpruceFixtureTest {
+    private static router;
+    private static factory;
+    protected static vcDir: string;
+    protected static beforeEach(): Promise<void>;
+    protected static throwsWithBadDestination(): Promise<void>;
+    protected static getPresentVcIsEmptyToStart(): Promise<void>;
+    protected static canRedirectToGoodSvcWithoutNamespace(id: SkillViewControllerId, Vc: any): Promise<void>;
+    protected static redirectTriggersLoadWithExpectedItems(args: any): Promise<void>;
+    protected static redirectByDefaultDoesNotLoadWithExpectedItems(args: any): Promise<void>;
+    protected static canHookIntoRedirectEvents(expectedArgs: any): Promise<void>;
+    protected static canFakeRedirectToHeartwoodRoot(): Promise<void>;
+    protected static canSuppressBadControllerIdOnRedirect(): Promise<void>;
+    protected static shouldThrowWithBadSvcBecauseTestRouterIsReset(): Promise<void>;
+    protected static testRouterBuildsOptionsWithLocaleAndAuthorizer(): void;
+    private static assertRedirects;
+}

package/build/esm/__tests__/behavioral/views/Routing.test.js

@@ -0,0 +1,169 @@
+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());
+    });
+};
+/* eslint-disable spruce/prohibit-import-from-build-folder */
+import { LocaleImpl } from '@sprucelabs/calendar-utils';
+import { vcAssert, } from '@sprucelabs/heartwood-view-controllers';
+import { diskUtil } from '@sprucelabs/spruce-skill-utils';
+import { test, assert } from '@sprucelabs/test';
+import { errorAssert } from '@sprucelabs/test-utils';
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest.js';
+import FakeSkillViewController from '../../../tests/Fake.svc.js';
+import TestRouter from '../../../tests/routers/TestRouter.js';
+import SpyAuthorizer from '../../../tests/SpyAuthorizer.js';
+import BookSkillViewController from '../../testDirsAndFiles/skill/build/skillViewControllers/Book.svc.js';
+import SpySkillViewController from '../../testDirsAndFiles/skill/build/skillViewControllers/Spy.svc.js';
+export default class RoutingTest 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);
+            const fixture = this.Fixture('view', { vcDir: this.vcDir });
+            this.router = fixture.getRouter();
+            this.factory = fixture.getFactory();
+        });
+    }
+    static throwsWithBadDestination() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const err = yield assert.doesThrowAsync(() => 
+            //@ts-ignore
+            this.assertRedirects(() => this.router.redirect('waka.waka')));
+            errorAssert.assertError(err, 'INVALID_VIEW_CONTROLLER_NAME', {
+                name: 'waka.waka',
+            });
+        });
+    }
+    static getPresentVcIsEmptyToStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isFalsy(this.router.getPresentVc());
+        });
+    }
+    static canRedirectToGoodSvcWithoutNamespace(id, Vc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertRedirects(() => this.router.redirect(id, {}));
+            const vc = this.router.getPresentVc();
+            assert.isTrue(vc instanceof Vc);
+        });
+    }
+    static redirectTriggersLoadWithExpectedItems(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            TestRouter.setShouldLoadDestinationVc(false);
+            //@ts-ignore
+            const vc = yield this.assertRedirects(() => this.router.redirect('spruceTestFixtures.spy', args));
+            const lastLoad = vc.loads.pop();
+            assert.isFalsy(lastLoad);
+        });
+    }
+    static redirectByDefaultDoesNotLoadWithExpectedItems(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //@ts-ignore
+            const vc = yield this.assertRedirects(() => this.router.redirect('spruceTestFixtures.spy', args));
+            const lastLoad = vc.loads.pop();
+            assert.isFalsy(lastLoad);
+        });
+    }
+    static canHookIntoRedirectEvents(expectedArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let wasHit = false;
+            let passedId = '';
+            let passedVc = null;
+            let passedArgs = null;
+            yield this.router.on('did-redirect', ({ id, vc, args }) => {
+                wasHit = true;
+                passedId = id;
+                passedVc = vc;
+                passedArgs = args;
+            });
+            yield this.assertRedirects(() => this.router.redirect('spruceTestFixtures.book', expectedArgs));
+            assert.isTrue(wasHit);
+            assert.isEqual(passedId, 'spruceTestFixtures.book');
+            assert.isTruthy(passedVc);
+            assert.isTrue(passedVc instanceof BookSkillViewController);
+            assert.isEqualDeep(passedArgs, expectedArgs);
+        });
+    }
+    static canFakeRedirectToHeartwoodRoot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const svc = yield this.assertRedirects(() => this.router.redirect('heartwood.root'));
+            assert.isTrue(svc instanceof FakeSkillViewController);
+        });
+    }
+    static canSuppressBadControllerIdOnRedirect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            TestRouter.setShouldThrowWhenRedirectingToBadSvc(false);
+            const id = `${new Date().getTime()}.root`;
+            //@ts-ignore
+            this.factory.setController(id, null);
+            yield this.assertRedirects(() => this.router.redirect(id));
+        });
+    }
+    static shouldThrowWithBadSvcBecauseTestRouterIsReset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield assert.doesThrowAsync(() => 
+            //@ts-ignore
+            this.router.redirect('waka.waka'));
+        });
+    }
+    static testRouterBuildsOptionsWithLocaleAndAuthorizer() {
+        const options = this.router.buildLoadOptions();
+        assert.isTrue(options.locale instanceof LocaleImpl);
+        assert.isTrue(options.authorizer instanceof SpyAuthorizer);
+    }
+    static assertRedirects(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return vcAssert.assertActionRedirects({
+                action,
+                router: this.router,
+            });
+        });
+    }
+}
+RoutingTest.vcDir = diskUtil.resolvePath(__dirname, '..', '..', 'testDirsAndFiles', 'skill', 'build');
+__decorate([
+    test()
+], RoutingTest, "throwsWithBadDestination", null);
+__decorate([
+    test()
+], RoutingTest, "getPresentVcIsEmptyToStart", null);
+__decorate([
+    test('can get book svc', 'spruceTestFixtures.book', BookSkillViewController),
+    test('can get spy svc', 'spruceTestFixtures.spy', SpySkillViewController)
+], RoutingTest, "canRedirectToGoodSvcWithoutNamespace", null);
+__decorate([
+    test('redirect calls load on destination vc if set 1', { hey: 'there' }),
+    test('redirect calls load on destination vc if set 2', { what: 'the!?' })
+], RoutingTest, "redirectTriggersLoadWithExpectedItems", null);
+__decorate([
+    test('redirect does not call load on destination vc 1', { hey: 'there' }),
+    test('redirect does not call load on destination vc 2', { what: 'the!?' })
+], RoutingTest, "redirectByDefaultDoesNotLoadWithExpectedItems", null);
+__decorate([
+    test('can hook into redirect no args', undefined),
+    test('can hook into redirect args 1', { taco: 'bell' })
+], RoutingTest, "canHookIntoRedirectEvents", null);
+__decorate([
+    test()
+], RoutingTest, "canFakeRedirectToHeartwoodRoot", null);
+__decorate([
+    test()
+], RoutingTest, "canSuppressBadControllerIdOnRedirect", null);
+__decorate([
+    test()
+], RoutingTest, "shouldThrowWithBadSvcBecauseTestRouterIsReset", null);
+__decorate([
+    test()
+], RoutingTest, "testRouterBuildsOptionsWithLocaleAndAuthorizer", null);

package/build/esm/__tests__/behavioral/views/TestingScope.test.d.ts

@@ -0,0 +1,9 @@
+import AbstractSpruceFixtureTest from '../../../tests/AbstractSpruceFixtureTest';
+export default class TestingScopeTest extends AbstractSpruceFixtureTest {
+    private static scope;
+    protected static beforeEach(): Promise<void>;
+    protected static canResetScope(): Promise<void>;
+    protected static canSetCurrentOrgToNull(): Promise<void>;
+    protected static canSetCurrentLocationToNull(): Promise<void>;
+    protected static clearsLocationIdWhenSettingOrgId(): Promise<void>;
+}