@sprucelabs/spruce-calendar-components 22.4.6 → 22.4.9

package/build/__tests__/support/SpyRemoteEventStore.d.ts

@@ -0,0 +1,18 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas';
+import RemoteEventStoreImpl, { RemoteEventStoreOptions } from '../../stores/RemoteEventStore';
+import { Calendar, UpdateEvent } from '../../types/calendar.types';
+export default class SpyRemoteEventStore extends RemoteEventStoreImpl {
+    private calendars?;
+    lastPersistedEvent?: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+    constructor(options: Omit<RemoteEventStoreOptions, 'connectToApi'> & {
+        calendars?: Calendar[];
+        locationId?: string;
+        organizationId?: string;
+        client: MercuryClient;
+    });
+    setOrganizationId(id: string): void;
+    cancelEvent(_id: string): Promise<void>;
+    getCalendars(): Promise<SpruceSchemas.Calendar.v2021_05_19.Calendar[] | import("@sprucelabs/schema").SchemaStaticValues<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema, false, import("@sprucelabs/schema").SchemaOptionalFieldNames<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema>, import("@sprucelabs/schema").StaticSchemaAllValues<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema, false>>[]>;
+    persist(event: UpdateEvent): Promise<SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent>;
+}

package/build/__tests__/support/SpyRemoteEventStore.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = require("@sprucelabs/test-utils");
+const RemoteEventStore_1 = __importDefault(require("../../stores/RemoteEventStore"));
+class SpyRemoteEventStore extends RemoteEventStore_1.default {
+    constructor(options) {
+        const { calendars, client, locationId, organizationId } = options;
+        super({ connectToApi: async () => client });
+        this.client = client;
+        this.calendars = calendars;
+        this.locationId = locationId !== null && locationId !== void 0 ? locationId : (0, test_utils_1.generateId)();
+        this.organizationId = organizationId !== null && organizationId !== void 0 ? organizationId : (0, test_utils_1.generateId)();
+    }
+    setOrganizationId(id) {
+        this.organizationId = id;
+    }
+    async cancelEvent(_id) { }
+    async getCalendars() {
+        var _a;
+        return (_a = this.calendars) !== null && _a !== void 0 ? _a : super.getCalendars();
+    }
+    async persist(event) {
+        const results = await super.persist(event);
+        this.lastPersistedEvent = results;
+        return results;
+    }
+}
+exports.default = SpyRemoteEventStore;

package/build/__tests__/support/SpyRemotePreferencesStore.d.ts

@@ -0,0 +1,9 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import RemotePreferencesStore from '../../stores/RemotePreferencesStore';
+export default class SpyRemotePreferencesStore extends RemotePreferencesStore {
+    constructor(options: {
+        client: MercuryClient;
+        visibleCalendarIds?: string[];
+    });
+    protected save(): Promise<void>;
+}

package/build/__tests__/support/SpyRemotePreferencesStore.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RemotePreferencesStore_1 = __importDefault(require("../../stores/RemotePreferencesStore"));
+class SpyRemotePreferencesStore extends RemotePreferencesStore_1.default {
+    constructor(options) {
+        const { visibleCalendarIds, client } = options;
+        super({ connectToApi: async () => client });
+        this.client = client;
+        this.isLoaded = true;
+        this.visibleCalendarIds = visibleCalendarIds;
+    }
+    async save() { }
+}
+exports.default = SpyRemotePreferencesStore;

package/build/__tests__/support/utilities/calendarAssert.d.ts

@@ -0,0 +1,13 @@
+import { CalendarEvent, SpruceSchemas, ViewController } from '@sprucelabs/heartwood-view-controllers';
+declare type Calendar = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Calendar;
+declare type Event = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+declare const calendarAssert: {
+    rendersTotalEvents(vc: ViewController<Calendar>, expected: number): void;
+    hasEvent(vc: ViewController<Calendar>, lookup: Partial<Event>): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+    eventsAreEqual(actual: Event[], expected: Event[]): void;
+    includesInEvent(events: Event[], lookup: Partial<Event>): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+    eventIsDuration(event: Event, expectedDuration: number): void;
+    eventsFallOnDows(events: CalendarEvent[], expectedDows: string[]): void;
+    eventEquals(actual: Partial<CalendarEvent> | undefined | null, expected: Partial<CalendarEvent> | undefined | null): void;
+};
+export default calendarAssert;

package/build/__tests__/support/utilities/calendarAssert.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const calendar_utils_1 = require("@sprucelabs/calendar-utils");
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const test_1 = require("@sprucelabs/test");
+const just_clone_1 = __importDefault(require("just-clone"));
+const calendarAssert = {
+    rendersTotalEvents(vc, expected) {
+        const model = heartwood_view_controllers_1.renderUtil.render(vc);
+        test_1.assert.isLength(model.events, expected);
+    },
+    hasEvent(vc, lookup) {
+        const { events } = heartwood_view_controllers_1.renderUtil.render(vc);
+        return this.includesInEvent(events, lookup);
+    },
+    eventsAreEqual(actual, expected) {
+        function sort(a, b) {
+            return a.id > b.id ? 1 : -1;
+        }
+        actual.sort(sort);
+        expected.sort(sort);
+        test_1.assert.isEqualDeep(actual, expected);
+    },
+    includesInEvent(events, lookup) {
+        const match = events.find((e) => {
+            try {
+                test_1.assert.doesInclude(e, lookup);
+                return e;
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+            return null;
+        });
+        test_1.assert.isTruthy(match, `I could not find an event that matched:\n\n${test_1.assertUtil.stringify(lookup)}`);
+        return match;
+    },
+    eventIsDuration(event, expectedDuration) {
+        const duration = event.timeBlocks.reduce((minutes, timeBlock) => {
+            minutes += timeBlock.durationMinutes;
+            return minutes;
+        }, 0);
+        test_1.assert.isEqual(duration, expectedDuration);
+    },
+    eventsFallOnDows(events, expectedDows) {
+        const remaining = [...expectedDows];
+        for (const event of events) {
+            const dow = calendar_utils_1.dateUtil.getDayOfWeek(event.startDateTimeMs);
+            const idx = remaining.indexOf(dow);
+            if (idx === -1) {
+                test_1.assert.fail(`Checking days of week and got ${dow} but it wasn't in the array of expected dows.`);
+            }
+            remaining.splice(idx, 1);
+        }
+        if (remaining.length > 0) {
+            test_1.assert.fail(`Didn't find the following days of week in events:\n\n${test_1.assertUtil.stringify(remaining)}`);
+        }
+    },
+    eventEquals(actual, expected) {
+        var _a, _b, _c;
+        test_1.assert.isTruthy(actual, 'Event is missing');
+        test_1.assert.isTruthy(expected, 'Event is missing');
+        test_1.assert.isEqual(actual.startDateTimeMs, expected.startDateTimeMs, 'startDateTimeMs does not match');
+        test_1.assert.isEqual((_a = actual.isBusy) !== null && _a !== void 0 ? _a : false, (_b = expected.isBusy) !== null && _b !== void 0 ? _b : false, `isBusy does not match, needs to be '${(_c = expected.isBusy) !== null && _c !== void 0 ? _c : false}'`);
+        const cleanedActual = (0, just_clone_1.default)(actual);
+        const cleanedExpected = (0, just_clone_1.default)(expected);
+        cleanEvent(cleanedActual);
+        cleanEvent(cleanedExpected);
+        test_1.assert.isEqualDeep(cleanedActual, cleanedExpected, 'Your event did not equal what I expected!');
+    },
+};
+function cleanEvent(obj, propsToIgnore = [
+    'isSelected',
+    'source',
+    'dateCreated',
+    'isBusy',
+    'controller',
+]) {
+    for (const prop in obj) {
+        const value = obj[prop];
+        if (propsToIgnore.indexOf(prop) > -1 ||
+            value === null ||
+            typeof value === 'undefined') {
+            delete obj[prop];
+        }
+        else if (typeof value === 'object') {
+            cleanEvent(value);
+        }
+    }
+}
+exports.default = calendarAssert;

package/build/__tests__/support/utilities/calendarSkillAssert.d.ts

@@ -0,0 +1,40 @@
+import { ToolBeltState, AbstractCalendarEventViewController, ToolBeltStateMachine, SpruceSchemas } from '@sprucelabs/heartwood-view-controllers';
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { ViewFixture } from '@sprucelabs/spruce-test-fixtures';
+import AbstractCalendarEventToolBeltState from '../../../toolBelt/states/AbstractCalendarEventToolBeltState';
+export interface AssertRemoteToolsOptions {
+    client: MercuryClient;
+    state: ToolBeltState;
+    views: ViewFixture;
+}
+interface TypeWithVcId {
+    typeSlug: string;
+    vcId: string;
+}
+export declare type AssertTypeSlug = string | TypeWithVcId;
+declare const calendarSkillAssert: {
+    createdEventTypes: SpruceSchemas.Calendar.v2021_05_19.CalendarEventType[];
+    createdCalendars: SpruceSchemas.Calendar.v2021_05_19.Calendar[];
+    beforeEach(views: ViewFixture): Promise<void>;
+    createsCalendarOnInstall(calendarSlug: string, client: MercuryClient, typeSlugs?: string[]): Promise<void>;
+    createsCalendarsWithMultipleInstalls(calendarSlug: string, client: MercuryClient): Promise<void>;
+    createsEventTypesOnBoot(types: AssertTypeSlug[], client: MercuryClient, boot: () => Promise<any>): Promise<void>;
+    createsEventTypesWithMultipleBoots(types: AssertTypeSlug[], client: MercuryClient, boot: () => Promise<any>): Promise<void>;
+    isValidEventViewController(options: {
+        views: ViewFixture;
+        CalendarEventClass: typeof AbstractCalendarEventViewController;
+        ToolBeltStateClass: any;
+    }): void;
+    stateFetchesAndRendersRemoteTools(options: AssertRemoteToolsOptions): Promise<{
+        toolId: string;
+        Class: any;
+    }[]>;
+    toolBeltStateProperlyInheritsAbstractToolBeltState(stateMachine: ToolBeltStateMachine, state: AbstractCalendarEventToolBeltState): Promise<void>;
+    toolBeltStateAddsTool(options: {
+        state: AbstractCalendarEventToolBeltState;
+        toolId: string;
+        views: ViewFixture;
+        Class?: any;
+    }): Promise<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool>;
+};
+export default calendarSkillAssert;

package/build/__tests__/support/utilities/calendarSkillAssert.js

@@ -0,0 +1,346 @@
+"use strict";
+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 spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const spruce_test_fixtures_1 = require("@sprucelabs/spruce-test-fixtures");
+const test_1 = require("@sprucelabs/test");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const AbstractCalendarEventToolBeltState_1 = __importDefault(require("../../../toolBelt/states/AbstractCalendarEventToolBeltState"));
+const Calendar_vc_1 = __importDefault(require("../../../viewControllers/Calendar.vc"));
+const EventControlsCard_vc_1 = __importDefault(require("../../../viewControllers/EventControlsCard.vc"));
+const EventDateTimeTool_vc_1 = __importDefault(require("../../../viewControllers/EventDateTimeTool.vc"));
+const EventRepeatingTool_vc_1 = __importDefault(require("../../../viewControllers/EventRepeatingTool.vc"));
+const EventTitleTool_vc_1 = __importDefault(require("../../../viewControllers/EventTitleTool.vc"));
+const RepeatingControlsList_vc_1 = __importDefault(require("../../../viewControllers/RepeatingControlsList.vc"));
+const CalendarToolBeltStateMachineTestFactory_1 = __importDefault(require("../CalendarToolBeltStateMachineTestFactory"));
+class TestTool1 extends heartwood_view_controllers_1.CardViewControllerImpl {
+    async handleUpdateContext() { }
+    getLineIcon() {
+        return 'cellphone';
+    }
+}
+class TestTool2 extends heartwood_view_controllers_1.CardViewControllerImpl {
+    handleUpdateContext() { }
+    getLineIcon() {
+        return 'calendar';
+    }
+}
+const vcs = {
+    ['calendar.repeating-controls-list']: RepeatingControlsList_vc_1.default,
+    ['calendar.event-repeating-tool']: EventRepeatingTool_vc_1.default,
+    ['calendar.calendar']: Calendar_vc_1.default,
+    ['calendar.event-date-time-tool']: EventDateTimeTool_vc_1.default,
+    ['calendar.event-title-tool']: EventTitleTool_vc_1.default,
+    ['calendar.event-controls-card']: EventControlsCard_vc_1.default,
+};
+const calendarSkillAssert = {
+    createdEventTypes: [],
+    createdCalendars: [],
+    async beforeEach(views) {
+        (0, schema_1.assertOptions)({ views }, ['views']);
+        //@ts-ignore
+        this._didBeforeEach = true;
+        this.createdEventTypes = [];
+        this.createdCalendars = [];
+        const factory = views.getFactory();
+        factory.mixinControllers(vcs);
+        await spruce_test_fixtures_1.eventFaker.on('calendar.register-event-tools::v2021_05_19', () => ({
+            vcIds: [],
+        }));
+        await fakeEventTypeEvents(this.createdEventTypes);
+        await fakeCalendarEvents(this.createdCalendars);
+    },
+    async createsCalendarOnInstall(calendarSlug, client, typeSlugs) {
+        var _a, _b, _c, _d;
+        assertRanBeforeEach(this);
+        (0, schema_1.assertOptions)({
+            calendarSlug,
+            client,
+        }, ['calendarSlug', 'client']);
+        const [{ organizations }] = await client.emitAndFlattenResponses('list-organizations::v2020_12_25', {
+            payload: {
+                shouldOnlyShowMine: true,
+            },
+        });
+        const organization = organizations.pop();
+        test_1.assert.isTruthy(organization, `You gotta @seed('organizations', 1) before you can assert a calendar is created on install.`);
+        const skill = spruce_skill_utils_1.AuthService.Auth(process.cwd()).getCurrentSkill();
+        test_1.assert.isTruthy(skill, `Make sure you registered your skill before you can do anything else. Try 'spruce register'.`);
+        const responses = await client.emit('did-install::v2020_12_25', {
+            target: {
+                organizationId: organization.id,
+                skillId: skill.id,
+            },
+        });
+        if (responses.totalErrors > 0) {
+            throw (_b = (_a = responses.responses[0].errors) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : `did-instal error`;
+        }
+        if (responses.totalResponses === 0) {
+            test_1.assert.fail(`did-install listener missing! To get this test passing your skill will need to be listening to did-install, try 'spruce create.listener' and look under Mercury. You may also need to boot your skill with 'await this.bootSkill()'`);
+        }
+        let cal;
+        try {
+            const [{ calendar }] = await client.emitAndFlattenResponses('calendar.get-calendar::v2021_05_19', {
+                target: {
+                    slug: calendarSlug,
+                    organizationId: organization.id,
+                },
+            });
+            cal = calendar;
+        }
+        catch (err) {
+            test_1.assert.fail(`It looks like you still need to create a calendar, maybe the following code will help:
+const events = event.skill.getFeatureByCode('event') as EventFeature
+const client = await events.connectToApi()
+
+await client.emitAndFlattenResponses(
+	'calendar.create-calendar::v2021_05_19',
+	{
+		target: {
+			organizationId,
+		},
+		payload: {
+			availableTimeSlotBehavior: 'exclude or exclude',
+			title: '${calendarSlug}',
+			slug:  '${calendarSlug}',
+		},
+	}
+)\n\nOh, and here's the original error: ${(_d = (_c = err.stack) !== null && _c !== void 0 ? _c : err.message) !== null && _d !== void 0 ? _d : err}`);
+        }
+        if (typeSlugs) {
+            test_1.assert.isEqualDeep(cal.eventTypes, typeSlugs, `Your calendar does not have types set to: [${typeSlugs.join(', ')}]`);
+        }
+    },
+    async createsCalendarsWithMultipleInstalls(calendarSlug, client) {
+        await this.createsCalendarOnInstall(calendarSlug, client);
+        try {
+            await this.createsCalendarOnInstall(calendarSlug, client);
+        }
+        catch (err) {
+            test_1.assert.fail(`You tried to create the same calendar twice! It's time for the next step (don't forget to extract):
+			
+try {
+	await client.emitAndFlattenResponses('calendar.get-calendar::v2021_05_19', {
+		target: {
+			organizationId,
+			slug: 'shifts',
+		},
+	})
+} catch {
+	await client.emitAndFlattenResponses(
+		'calendar.create-calendar::v2021_05_19',
+		{
+			target: {
+				organizationId,
+			},
+			payload: {
+				availableTimeSlotBehavior: 'exclude or include',
+				title: 'Shifts',
+				slug: 'shifts',
+			},
+		}
+	)
+}`);
+        }
+    },
+    async createsEventTypesOnBoot(types, client, boot) {
+        assertRanBeforeEach(this);
+        await (boot === null || boot === void 0 ? void 0 : boot());
+        test_1.assert.isTruthy(
+        //@ts-ignore
+        client.auth.skill, `You gotta be logged in as a skill! Try 'const { client } = await this.skills.loginAsCurrentSkill()'`);
+        const typeSlugs = types.map((t) => (typeof t === 'string' ? t : t.typeSlug));
+        const vcIds = types.map((t) => (typeof t === 'string' ? undefined : t.vcId));
+        function sort(a, b) {
+            return a.typeSlug > b.typeSlug ? 1 : -1;
+        }
+        const normalizedExpected = typeSlugs
+            .map((slug, idx) => ({
+            typeSlug: slug,
+            viewControllerId: vcIds[idx],
+        }))
+            .sort(sort);
+        const [{ calendarEventTypes }] = await client.emitAndFlattenResponses('calendar.list-calendar-event-types::v2021_05_19', {
+            payload: {
+                shouldShowOnlyMine: true,
+            },
+        });
+        test_1.assert.isAbove(calendarEventTypes.length, 0, `No event types were created. Make sure you are listening to the 'did-boot' event and booted. Use 'spruce create.listener' and look under Skill (or await this.bootSkill()). Then, drop in something like this:\n\n
+await client.emitAndFlattenResponses('calendar.create-calendar-event-type::v2021_05_19', {
+	payload: {
+		name: '${typeSlugs[0]}',
+		slug: '${typeSlugs[0]}'
+	}
+})`);
+        const normalizedActual = calendarEventTypes
+            .map((cet) => ({
+            typeSlug: cet.slug,
+            viewControllerId: cet.viewControllerId,
+        }))
+            .sort(sort);
+        test_1.assert.isEqualDeep(normalizedActual, normalizedExpected, 'The event types I was found were not created as expected.');
+    },
+    async createsEventTypesWithMultipleBoots(types, client, boot) {
+        await this.createsEventTypesOnBoot(types, client, boot);
+        await this.createsEventTypesOnBoot(types, client, boot);
+    },
+    isValidEventViewController(options) {
+        const { views, ToolBeltStateClass: ToolBeltClass, CalendarEventClass, } = (0, schema_1.assertOptions)(options, [
+            'views',
+            'CalendarEventClass',
+            'ToolBeltStateClass',
+        ]);
+        const event = heartwood_view_controllers_1.calendarSeeder.generateEventValues();
+        const calendarVc = views.Controller('calendar', {
+            events: [event],
+        });
+        //@ts-ignore
+        views.getFactory().mixinControllers({
+            [event.id]: CalendarEventClass,
+        });
+        calendarVc.setDefaultControllerForEvents(event.id);
+        const vc = calendarVc.getEventVc(event.id);
+        test_1.assert.isFunction(vc.getToolBeltState, `Bad event vc. You need to make sure your event vc extends and implements what it needs to! Try:
+
+class MyEventViewController
+	extends AbstractCalendarEventViewController
+	implements EventWithToolBeltState`);
+        const state = vc.getToolBeltState();
+        test_1.assert.isTrue(state instanceof ToolBeltClass, `Your event vc did not return the state I expected. Make sure getToolBeltState() is returning an instance of ${ToolBeltClass.name}.`);
+    },
+    async stateFetchesAndRendersRemoteTools(options) {
+        assertRanBeforeEach(this);
+        const { views, state } = (0, schema_1.assertOptions)(options, ['state', 'views']);
+        const event = Object.assign(Object.assign({}, heartwood_view_controllers_1.calendarSeeder.generateEventValues()), { eventTypeSlug: (0, test_utils_1.generateId)() });
+        const org = await views.getScope().getCurrentOrganization();
+        test_1.assert.isTruthy(org, `You gotta @seed('organizations', 1) to test fetching and rendering remote tools.`);
+        let passedTargetAndPayload;
+        const VC_NAME_1 = 'calendars.test-one';
+        const VC_NAME_2 = 'calendars.test-two';
+        const vcIds = [VC_NAME_1, VC_NAME_2];
+        const Classes = [TestTool1, TestTool2];
+        views.getFactory().mixinControllers({
+            [VC_NAME_1]: TestTool1,
+            [VC_NAME_2]: TestTool2,
+        });
+        await spruce_test_fixtures_1.eventFaker.on('calendar.register-event-tools::v2021_05_19', (targetAndPayload) => {
+            passedTargetAndPayload = targetAndPayload;
+            return {
+                vcIds,
+            };
+        });
+        const { toolBeltVc, stateMachine } = await CalendarToolBeltStateMachineTestFactory_1.default.StateMachine(views);
+        await stateMachine.updateContext({ event });
+        await stateMachine.transitionTo(state);
+        test_1.assert.isTruthy(passedTargetAndPayload, `You aren't emitting 'calendar.register-event-tools::v2021_05_19'. 
+			
+Try adding the following to your state's load():
+			
+const tools = new CalendarToolRegistrar(stateMachine)
+await tools.fetchAndAddCards()
+`);
+        test_1.assert.isEqualDeep(passedTargetAndPayload.target, { organizationId: org.id, calendarEventId: event.id }, `Your target is not what is expected! Make sure you are sending organizationId and calendarEventId`);
+        test_1.assert.isEqualDeep(passedTargetAndPayload.payload, {
+            eventTypeSlug: event.eventTypeSlug,
+        }, `Your payload does not what is expected! Make sure you pass through eventTypeSlug.`);
+        const tools = toolBeltVc.getTools();
+        test_1.assert.isAbove(tools.length, 0, `It looks like you didn't add any tools to the tool belt! try sm.getToolBeltVc().addTool()`);
+        const results = [];
+        for (let c = 0; c < vcIds.length; c++) {
+            const id = vcIds[c];
+            const tool = toolBeltVc.getTool(id);
+            results.push({
+                toolId: id,
+                Class: Classes[c],
+            });
+            test_1.assert.isTruthy(tool, `You didn't add the tools I expected! Make sure you are using the CalendarToolRegistrar!`);
+        }
+        return results;
+    },
+    async toolBeltStateProperlyInheritsAbstractToolBeltState(stateMachine, state) {
+        assertRanBeforeEach(this);
+        (0, schema_1.assertOptions)({ stateMachine, state }, ['stateMachine', 'state']);
+        test_1.assert.isTrue(state instanceof AbstractCalendarEventToolBeltState_1.default, `Your state does not extend 'AbstractCalendarEventToolBeltState'. Make sure you do that next!`);
+        await stateMachine.transitionTo(state);
+        test_1.assert.isTruthy(state.getIsLoaded(), `You need to call super.load(stateMachine) in your state!`);
+        await stateMachine.on('did-update-context', () => { });
+        const originalListenCount = stateMachine.listenCount('did-update-context');
+        await state.destroy();
+        const count = stateMachine.listenCount('did-update-context');
+        test_1.assert.isAbove(count, originalListenCount - 2, `You 'sm.off(...)'ed too many listeners, make sure you pass the callback to remove to 'this.sm.off(...)'. It's the second param.`);
+        test_1.assert.isEqual(count, originalListenCount - 1, `Don't forget to remove all listeners to the stateMachine. Either implement 'destroy()' and call 'this.sm.off(...)' or try 'await super.destroy()' in your state.`);
+    },
+    async toolBeltStateAddsTool(options) {
+        const { state, toolId, views, Class } = (0, schema_1.assertOptions)(options, [
+            'state',
+            'toolId',
+            'views',
+        ]);
+        const { toolBeltVc, stateMachine } = await CalendarToolBeltStateMachineTestFactory_1.default.StateMachine(views);
+        await stateMachine.transitionTo(state);
+        test_1.assert.isTruthy(toolBeltVc.getTool(toolId), `I could not find the tool with the id '${toolId}', try 'this.addTool(...)' from inside your state!`);
+        //@ts-ignore
+        const match = state.vcs.find((o) => o.toolId === toolId);
+        test_1.assert.isTruthy(match, `It looks like you added your tool directly to the toolBeltVc instead of to your parent class. 'this.addTool(...)'`);
+        if (Class) {
+            heartwood_view_controllers_1.vcAssert.assertToolInstanceOf(toolBeltVc, toolId, Class);
+        }
+        return toolBeltVc.getTool(toolId);
+    },
+};
+exports.default = calendarSkillAssert;
+async function fakeEventTypeEvents(eventTypes) {
+    await spruce_test_fixtures_1.eventFaker.on('calendar.list-calendar-event-types::v2021_05_19', ({ source }) => {
+        const matches = eventTypes.filter((t) => t.source.skillId === (source === null || source === void 0 ? void 0 : source.skillId));
+        return {
+            calendarEventTypes: matches,
+            count: matches.length,
+        };
+    });
+    await spruce_test_fixtures_1.eventFaker.on('calendar.create-calendar-event-type::v2021_05_19', ({ payload, source }) => {
+        const type = Object.assign({ id: (0, test_utils_1.generateId)(), source: source, viewControllerId: null }, payload);
+        eventTypes.push(type);
+        return {
+            calendarEventType: type,
+        };
+    });
+    await spruce_test_fixtures_1.eventFaker.on('calendar.upsert-calendar-event-type::v2021_05_19', ({ payload, source, target }) => {
+        const match = eventTypes.find((t) => t.slug === target.slug);
+        if (match) {
+            match.name = payload.name;
+            return {
+                calendarEventType: match,
+            };
+        }
+        const type = Object.assign({ id: (0, test_utils_1.generateId)(), source: source, viewControllerId: null, slug: target.slug }, payload);
+        eventTypes.push(type);
+        return {
+            calendarEventType: type,
+        };
+    });
+}
+async function fakeCalendarEvents(calendars) {
+    await spruce_test_fixtures_1.eventFaker.on('calendar.create-calendar::v2021_05_19', ({ payload, source, target }) => {
+        const matches = calendars.filter((c) => c.slug === payload.slug);
+        test_1.assert.isLength(matches, 0, `You already created a calendar the slug: ${payload.slug}!`);
+        const calendar = Object.assign({ id: (0, test_utils_1.generateId)(), source: source, target }, payload);
+        calendars.push(calendar);
+        return { calendar };
+    });
+    //@ts-ignore
+    await spruce_test_fixtures_1.eventFaker.on('calendar.get-calendar::v2021_05_19', ({ target }) => {
+        const calendar = calendars.find((c) => c.slug === target.slug);
+        return {
+            calendar,
+        };
+    });
+}
+function assertRanBeforeEach(me) {
+    test_1.assert.isTrue(
+    //@ts-ignore
+    me._didBeforeEach, `You gotta add 'await calendarSkillAssert.beforeEach(...)' to the beforeEach() of your test.`);
+}

package/build/__tests__/support/utilities/calendarToolBeltInteractor.d.ts

@@ -0,0 +1,5 @@
+import { CalendarToolBeltContext, CalendarToolBeltStateMachine } from '../../../types/calendar.types';
+declare const calendarToolBeltInteractor: {
+    simulateRandomContextUpdate(stateMachine: CalendarToolBeltStateMachine): Promise<CalendarToolBeltContext>;
+};
+export default calendarToolBeltInteractor;

package/build/__tests__/support/utilities/calendarToolBeltInteractor.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const calendarToolBeltInteractor = {
+    async simulateRandomContextUpdate(stateMachine) {
+        const context = Object.assign(Object.assign({}, stateMachine.getContext()), { event: Object.assign({}, heartwood_view_controllers_1.calendarSeeder.generateEventValues()) });
+        await stateMachine.updateContext(context);
+        return context;
+    },
+};
+exports.default = calendarToolBeltInteractor;