@sprucelabs/spruce-conversation-plugin 45.2.8 → 46.0.1

package/build/__tests__/behavioral/CheckingHealth.test.d.ts

@@ -0,0 +1,10 @@
+import AbstractConversationTest from '../../tests/AbstractConversationTest';
+export default class CheckingHealthTest extends AbstractConversationTest {
+    protected static pluginReturnsInstance(): Promise<void>;
+    protected static registersWithSkill(): Promise<void>;
+    protected static throwsWhenExecutingIfEventPluginMissing(): Promise<void>;
+    protected static returnsZeroStateResponseFromHealthCheckWhenNoConversations(): Promise<void>;
+    private static checkHealth;
+    protected static returnsHelpfulErrorWHenPassedBadConvos(): Promise<void>;
+    protected static getsTopicsFromHealthCheck(): Promise<void>;
+}

package/build/__tests__/behavioral/CheckingHealth.test.js

@@ -0,0 +1,87 @@
+"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 conversation_plugin_1 = __importDefault(require("../../plugins/conversation.plugin"));
+const AbstractConversationTest_1 = __importDefault(require("../../tests/AbstractConversationTest"));
+class CheckingHealthTest extends AbstractConversationTest_1.default {
+    static async pluginReturnsInstance() {
+        test_1.assert.isTrue(conversation_plugin_1.default instanceof Function);
+    }
+    static async registersWithSkill() {
+        const skill = await this.Skill();
+        const features = skill.getFeatures();
+        test_1.assert.isLength(features, 2);
+    }
+    static async throwsWhenExecutingIfEventPluginMissing() {
+        var _a;
+        const health = await this.checkHealth({ plugins: [conversation_plugin_1.default] });
+        test_1.assert.isTruthy(health.conversation);
+        test_1.assert.isEqual(health.conversation.status, 'failed');
+        const err = (_a = health.conversation.errors) === null || _a === void 0 ? void 0 : _a[0];
+        test_1.assert.isTruthy(err);
+        test_utils_1.errorAssert.assertError(err, 'MISSING_DEPENDENCIES', {
+            dependencies: ['event.plugin'],
+        });
+    }
+    static async returnsZeroStateResponseFromHealthCheckWhenNoConversations() {
+        const healthCheck = await this.checkHealth();
+        test_1.assert.isTruthy(healthCheck.conversation);
+        test_1.assert.isEqual(healthCheck.conversation.status, 'passed');
+        test_1.assert.isEqualDeep(healthCheck.conversation.topics, []);
+    }
+    static async checkHealth(options) {
+        const skill = await this.Skill(options);
+        const healthCheck = await skill.checkHealth();
+        return healthCheck;
+    }
+    static async returnsHelpfulErrorWHenPassedBadConvos() {
+        var _a, _b;
+        const healthCheck = await this.checkHealth({
+            activeDir: this.resolvePath(__dirname, '..', 'testDirsAndFiles', 'bad-missing-params'),
+        });
+        test_1.assert.isTruthy(healthCheck.conversation);
+        test_1.assert.isEqual(healthCheck.conversation.status, 'failed');
+        test_utils_1.errorAssert.assertError((_a = healthCheck.conversation.errors) === null || _a === void 0 ? void 0 : _a[0], 'CONVERSATION_PLUGIN_ERROR');
+        test_utils_1.errorAssert.assertError((_b = healthCheck.conversation.errors) === null || _b === void 0 ? void 0 : _b[0].originalError, 'INVALID_TOPIC');
+    }
+    static async getsTopicsFromHealthCheck() {
+        const healthCheck = await this.checkHealth({
+            activeDir: this.resolvePath(__dirname, '..', 'testDirsAndFiles', 'good'),
+        });
+        test_1.assert.isTruthy(healthCheck.conversation);
+        test_1.assert.isLength(healthCheck.conversation.topics, 2);
+        test_1.assert.isEqualDeep(healthCheck.conversation.topics, [
+            'bookAppointment',
+            'cancelAppointment',
+        ]);
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], CheckingHealthTest, "pluginReturnsInstance", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingHealthTest, "registersWithSkill", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingHealthTest, "throwsWhenExecutingIfEventPluginMissing", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingHealthTest, "returnsZeroStateResponseFromHealthCheckWhenNoConversations", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingHealthTest, "returnsHelpfulErrorWHenPassedBadConvos", null);
+__decorate([
+    (0, test_1.test)()
+], CheckingHealthTest, "getsTopicsFromHealthCheck", null);
+exports.default = CheckingHealthTest;

package/build/__tests__/behavioral/KillingASkill.test.d.ts

@@ -0,0 +1,4 @@
+import AbstractConversationTest from '../../tests/AbstractConversationTest';
+export default class KillingASkillTest extends AbstractConversationTest {
+    protected static killingASkillKillsConversation(): Promise<void>;
+}

package/build/__tests__/behavioral/KillingASkill.test.js

@@ -0,0 +1,27 @@
+"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 AbstractConversationTest_1 = __importDefault(require("../../tests/AbstractConversationTest"));
+class KillingASkillTest extends AbstractConversationTest_1.default {
+    static async killingASkillKillsConversation() {
+        this.cwd = this.resolveTestPath('empty-skill');
+        const { skill } = await this.bootAndRegisterNewSkill({
+            name: 'great skill dude!',
+        });
+        await skill.kill();
+        test_1.assert.isFalse(skill.isRunning());
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], KillingASkillTest, "killingASkillKillsConversation", null);
+exports.default = KillingASkillTest;

package/build/__tests__/behavioral/RegisteringConversationsOnBoot.test.d.ts

@@ -0,0 +1,11 @@
+import AbstractConversationTest from '../../tests/AbstractConversationTest';
+export default class RegisteringConversationsOnBootTest extends AbstractConversationTest {
+    protected static throwsWhenExecutingIfEventPluginMissing(): Promise<void>;
+    protected static noConvosToStart(): Promise<void>;
+    protected static registersConvosOnBoot(): Promise<void>;
+    protected static skillShutsDownWhenConvosFailToRegister(): Promise<void>;
+    protected static canBootASecondTime(): Promise<void>;
+    protected static skillCanBootASecondTime(): Promise<void>;
+    private static assertExpectedTopics;
+    private static registerAndBoot;
+}

package/build/__tests__/behavioral/RegisteringConversationsOnBoot.test.js

@@ -0,0 +1,106 @@
+"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 spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
+const test_1 = require("@sprucelabs/test");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const conversation_plugin_1 = __importDefault(require("../../plugins/conversation.plugin"));
+const AbstractConversationTest_1 = __importDefault(require("../../tests/AbstractConversationTest"));
+class RegisteringConversationsOnBootTest extends AbstractConversationTest_1.default {
+    static async throwsWhenExecutingIfEventPluginMissing() {
+        const skill = await this.Skill({ plugins: [conversation_plugin_1.default] });
+        const err = await test_1.assert.doesThrowAsync(() => skill.execute());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_DEPENDENCIES', {
+            dependencies: ['event.plugin'],
+        });
+    }
+    static async noConvosToStart() {
+        this.cwd = this.resolveTestPath('empty-skill');
+        const topics = await this.registerAndBoot();
+        test_1.assert.isLength(topics, 0);
+    }
+    static async registersConvosOnBoot() {
+        this.cwd = this.resolveTestPath('skill');
+        const topics = await this.registerAndBoot();
+        this.assertExpectedTopics(topics);
+    }
+    static async skillShutsDownWhenConvosFailToRegister() {
+        const { skill } = await super.bootSkill({ shouldSuppressBootErrors: true });
+        test_1.assert.isFalse(skill.isRunning());
+        this.clearSkillBootErrors();
+    }
+    static async canBootASecondTime() {
+        this.cwd = this.resolveTestPath('skill');
+        const topics = await this.registerAndBoot();
+        this.assertExpectedTopics(topics);
+        const topics2 = await this.registerAndBoot({
+            skillId: process.env.SKILL_ID,
+            apiKey: process.env.SKILL_API_KEY,
+        });
+        this.assertExpectedTopics(topics2);
+    }
+    static async skillCanBootASecondTime() {
+        this.cwd = this.resolveTestPath('skill');
+        await this.registerAndBoot();
+        await this.registerAndBoot({
+            skillId: process.env.SKILL_ID,
+            apiKey: process.env.SKILL_API_KEY,
+        });
+    }
+    static assertExpectedTopics(topics) {
+        test_1.assert.isLength(topics, 5);
+        test_1.assert.doesInclude(topics, { key: 'bookAppointment' });
+        test_1.assert.doesInclude(topics, { key: 'cancelAppointment' });
+        test_1.assert.doesInclude(topics, { key: 'favoriteColor' });
+        test_1.assert.doesInclude(topics, { key: 'favoriteColorTopicChanger' });
+        test_1.assert.doesInclude(topics, { key: 'mixedStringsAndCallbacks' });
+    }
+    static async registerAndBoot(options) {
+        if (options === null || options === void 0 ? void 0 : options.skillId) {
+            process.env.SKILL_ID = options.skillId;
+            process.env.SKILL_API_KEY = options.apiKey;
+        }
+        else {
+            const registeredSkill = await this.Fixture('skill').seedDemoSkill({
+                name: 'my great skill',
+            });
+            process.env.SKILL_ID = registeredSkill.id;
+            process.env.SKILL_API_KEY = registeredSkill.apiKey;
+        }
+        const { skill } = await this.bootSkill();
+        const eventFeature = skill.getFeatureByCode('event');
+        const client = await eventFeature.connectToApi();
+        let topics;
+        const results = await client.emit('get-conversation-topics::v2020_12_25');
+        const payload = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        topics = payload.topics;
+        return topics;
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], RegisteringConversationsOnBootTest, "throwsWhenExecutingIfEventPluginMissing", null);
+__decorate([
+    (0, test_1.test)()
+], RegisteringConversationsOnBootTest, "noConvosToStart", null);
+__decorate([
+    (0, test_1.test)()
+], RegisteringConversationsOnBootTest, "registersConvosOnBoot", null);
+__decorate([
+    (0, test_1.test)()
+], RegisteringConversationsOnBootTest, "skillShutsDownWhenConvosFailToRegister", null);
+__decorate([
+    (0, test_1.test)()
+], RegisteringConversationsOnBootTest, "canBootASecondTime", null);
+__decorate([
+    (0, test_1.test)()
+], RegisteringConversationsOnBootTest, "skillCanBootASecondTime", null);
+exports.default = RegisteringConversationsOnBootTest;

package/build/__tests__/behavioral/RespondingToMessages.test.d.ts

@@ -0,0 +1,13 @@
+import AbstractConversationTest from '../../tests/AbstractConversationTest';
+export default class RespondingToMessagesTest extends AbstractConversationTest {
+    private static client;
+    protected static beforeEach(): Promise<void>;
+    protected static respondsToFirstMessageWithSuggestedTopics(): Promise<void>;
+    protected static scriptSendsMessages(): Promise<void>;
+    protected static scriptCallbacksCanRespondToEventWithTransitionAndRepairs(): Promise<void>;
+    protected static scriptCallbacksCanRespondToEventWithTransitionAndTopicChangers(): Promise<void>;
+    protected static scriptCallbackGetsRandAndMessage(): Promise<void>;
+    protected static eachPersonGetsTheirOwnConversation(): Promise<void>;
+    private static sendMessage;
+    private static boot;
+}

package/build/__tests__/behavioral/RespondingToMessages.test.js

@@ -0,0 +1,139 @@
+"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 spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
+const test_1 = require("@sprucelabs/test");
+const AbstractConversationTest_1 = __importDefault(require("../../tests/AbstractConversationTest"));
+class RespondingToMessagesTest extends AbstractConversationTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        //@ts-ignore
+        this.client = undefined;
+    }
+    static async respondsToFirstMessageWithSuggestedTopics() {
+        this.cwd = this.resolveTestPath('skill');
+        const results = await this.sendMessage();
+        const { suggestedTopics } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isArray(suggestedTopics);
+        test_1.assert.isLength(suggestedTopics, 1);
+    }
+    static async scriptSendsMessages() {
+        this.cwd = this.resolveTestPath('skill');
+        const sentMessages = [];
+        await this.boot();
+        await this.client.on('send-message::v2020_12_25', async (targetAndPayload) => {
+            const { payload } = targetAndPayload;
+            sentMessages.push(payload.message);
+            return { message: payload.message };
+        });
+        await this.sendMessage({ topic: 'bookAppointment' });
+        test_1.assert.isLength(sentMessages, 2);
+    }
+    static async scriptCallbacksCanRespondToEventWithTransitionAndRepairs() {
+        this.cwd = this.resolveTestPath('skill');
+        await this.sendMessage({
+            topic: 'favoriteColor',
+            message: { body: 'favorite color' },
+        });
+        const results = await this.sendMessage({
+            topic: 'favoriteColor',
+            message: { body: 'blue' },
+        });
+        const { transitionConversationTo, repairs } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isEqual(transitionConversationTo, 'discovery');
+        test_1.assert.isEqualDeep(repairs, ['go', 'team']);
+    }
+    static async scriptCallbacksCanRespondToEventWithTransitionAndTopicChangers() {
+        this.cwd = this.resolveTestPath('skill');
+        await this.sendMessage({
+            topic: 'favoriteColorTopicChanger',
+            message: { body: 'favorite color' },
+        });
+        const results = await this.sendMessage({
+            topic: 'favoriteColorTopicChanger',
+            message: { body: 'blue' },
+        });
+        const { transitionConversationTo, topicChangers } = spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+        test_1.assert.isEqual(transitionConversationTo, 'discovery');
+        test_1.assert.isEqualDeep(topicChangers, ['now', 'this']);
+    }
+    static async scriptCallbackGetsRandAndMessage() {
+        this.cwd = this.resolveTestPath('skill-assertions');
+        const results = await this.sendMessage({
+            topic: 'assertsScriptCallbackOptions',
+            message: { body: 'hello' },
+        });
+        spruce_event_utils_1.eventResponseUtil.getFirstResponseOrThrow(results);
+    }
+    static async eachPersonGetsTheirOwnConversation() {
+        this.cwd = this.resolveTestPath('skill-assertions');
+        await this.sendMessage({
+            topic: 'assertsScriptOnlyCalledOnce',
+            message: { body: 'hey hey', source: { personId: '234234234' } },
+        });
+        await this.sendMessage({
+            topic: 'assertsScriptOnlyCalledOnce',
+            message: { body: 'hey hey', source: { personId: '234234' } },
+        });
+        await this.sendMessage({
+            topic: 'assertsScriptOnlyCalledOnce',
+            message: { body: 'hey hey', source: { personId: '323' } },
+        });
+    }
+    static async sendMessage(options) {
+        const client = await this.boot();
+        const results = await client.emit('did-message::v2020_12_25', {
+            target: {},
+            payload: {
+                ...options,
+                message: this.buildMessage({
+                    body: 'I wanna book an appointment!',
+                    source: {
+                        isCore: null,
+                        personId: '12345',
+                    },
+                    ...options === null || options === void 0 ? void 0 : options.message,
+                }),
+            },
+        });
+        return results;
+    }
+    static async boot() {
+        if (!this.client) {
+            const { skill } = await this.bootAndRegisterNewSkill({
+                name: 'my skill yo',
+            });
+            const events = skill.getFeatureByCode('event');
+            const client = await events.connectToApi();
+            this.client = client;
+        }
+        return this.client;
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], RespondingToMessagesTest, "respondsToFirstMessageWithSuggestedTopics", null);
+__decorate([
+    (0, test_1.test)()
+], RespondingToMessagesTest, "scriptSendsMessages", null);
+__decorate([
+    (0, test_1.test)()
+], RespondingToMessagesTest, "scriptCallbacksCanRespondToEventWithTransitionAndRepairs", null);
+__decorate([
+    (0, test_1.test)()
+], RespondingToMessagesTest, "scriptCallbacksCanRespondToEventWithTransitionAndTopicChangers", null);
+__decorate([
+    (0, test_1.test)()
+], RespondingToMessagesTest, "scriptCallbackGetsRandAndMessage", null);
+__decorate([
+    (0, test_1.test)()
+], RespondingToMessagesTest, "eachPersonGetsTheirOwnConversation", null);
+exports.default = RespondingToMessagesTest;

package/build/__tests__/behavioral/TestingAConversation.test.d.ts

@@ -0,0 +1,10 @@
+import AbstractConversationTest from '../../tests/AbstractConversationTest';
+export default class TestingAConversationTest extends AbstractConversationTest {
+    protected static afterEach(): Promise<void>;
+    protected static afterAll(): Promise<void>;
+    protected static bootingNormallyDoesNotGoToTestMode(): Promise<void>;
+    protected static bootsInTestModeWithProperAction(): Promise<void>;
+    protected static throwsWithBadScript(): Promise<void>;
+    protected static throwsWithThrowsInScript(): Promise<void>;
+    private static bootAndGetConversationFeature;
+}

package/build/__tests__/behavioral/TestingAConversation.test.js

@@ -0,0 +1,70 @@
+"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 AbstractConversationTest_1 = __importDefault(require("../../tests/AbstractConversationTest"));
+class TestingAConversationTest extends AbstractConversationTest_1.default {
+    static async afterEach() {
+        await super.afterEach();
+        process.env.ACTION = undefined;
+    }
+    static async afterAll() {
+        await super.afterAll();
+        process.env.ACTION = undefined;
+    }
+    static async bootingNormallyDoesNotGoToTestMode() {
+        this.cwd = this.resolveTestPath('empty-skill');
+        const conversation = await this.bootAndGetConversationFeature({
+            shouldSuppressBootErrors: true,
+        });
+        test_1.assert.isFalse(conversation.isTesting());
+        this.clearSkillBootErrors();
+    }
+    static async bootsInTestModeWithProperAction() {
+        process.env.ACTION = 'test.conversation';
+        const conversation = await this.bootAndGetConversationFeature();
+        test_1.assert.isTrue(conversation.isTesting());
+    }
+    static async throwsWithBadScript() {
+        this.cwd = this.resolveTestPath('bad-skill');
+        process.env.ACTION = 'test.conversation';
+        const skill = await this.Skill();
+        const err = await test_1.assert.doesThrowAsync(() => skill.execute());
+        test_utils_1.errorAssert.assertError(err, 'INVALID_TOPIC');
+    }
+    static async throwsWithThrowsInScript() {
+        this.cwd = this.resolveTestPath('skill-with-script-that-throws');
+        process.env.ACTION = 'test.conversation';
+        process.env.FIRST_MESSAGE = 'hey there!';
+        const skill = await this.Skill();
+        const err = await test_1.assert.doesThrowAsync(() => skill.execute());
+        test_utils_1.errorAssert.assertError(err, 'CONVERSATION_ABORTED');
+    }
+    static async bootAndGetConversationFeature(options) {
+        const { skill } = await this.bootSkill(options);
+        const conversation = skill.getFeatureByCode('conversation');
+        return conversation;
+    }
+}
+__decorate([
+    (0, test_1.test)()
+], TestingAConversationTest, "bootingNormallyDoesNotGoToTestMode", null);
+__decorate([
+    (0, test_1.test)()
+], TestingAConversationTest, "bootsInTestModeWithProperAction", null);
+__decorate([
+    (0, test_1.test)()
+], TestingAConversationTest, "throwsWithBadScript", null);
+__decorate([
+    (0, test_1.test)()
+], TestingAConversationTest, "throwsWithThrowsInScript", null);
+exports.default = TestingAConversationTest;

package/build/__tests__/implementation/ConversationCoordinator.test.d.ts

@@ -0,0 +1,15 @@
+import AbstractConversationTest from '../../tests/AbstractConversationTest';
+export default class TopicCoordinatorTest extends AbstractConversationTest {
+    private static coordinator;
+    private static sentMessages;
+    protected static beforeEach(): Promise<void>;
+    protected static canCreateTopicCoordinator(): Promise<void>;
+    protected static hasHandleMessage(): Promise<void>;
+    protected static handledMessageMustHaveASource(): Promise<void>;
+    protected static respondsWithSuggestedTopicsToFirstMessage(): Promise<void>;
+    protected static handlesNoSkillWithTopics(): Promise<void>;
+    protected static throwsWhenSentBadTopic(): Promise<void>;
+    protected static playsScriptWhenTopicIsSelected(): Promise<void>;
+    protected static canHandlePromptsInScript(): Promise<void>;
+    protected static canPlaceMixedScriptsUntilTheEndAndStartsOver(): Promise<void>;
+}

package/build/__tests__/implementation/ConversationCoordinator.test.js

@@ -0,0 +1,142 @@
+"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 ConversationCoordinator_1 = require("../../conversations/ConversationCoordinator");
+const AbstractConversationTest_1 = __importDefault(require("../../tests/AbstractConversationTest"));
+class TopicCoordinatorTest extends AbstractConversationTest_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.sentMessages = [];
+        this.coordinator = await ConversationCoordinator_1.ConversationCoordinator.Coordinator({
+            lineDelay: 0,
+            sendMessageHandler: async (message) => {
+                this.sentMessages.push(message);
+            },
+            topicLookupPath: this.resolveTestPath('skill', 'build'),
+        });
+    }
+    static async canCreateTopicCoordinator() {
+        test_1.assert.isTruthy(this.coordinator);
+    }
+    static async hasHandleMessage() {
+        test_1.assert.isFunction(this.coordinator.handleMessage);
+    }
+    static async handledMessageMustHaveASource() {
+        const err = await test_1.assert.doesThrowAsync(() => this.coordinator.handleMessage(this.buildMessage({ body: 'waka waka' })));
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['source.personId'],
+        });
+    }
+    static async respondsWithSuggestedTopicsToFirstMessage() {
+        const results = await this.coordinator.handleMessage(this.buildMessage({ body: 'help me book!', source: { personId: '1234' } }));
+        test_1.assert.isArray(results.suggestedTopics);
+        test_1.assert.isLength(results.suggestedTopics, 3);
+    }
+    static async handlesNoSkillWithTopics() {
+        const coordinator = await ConversationCoordinator_1.ConversationCoordinator.Coordinator({
+            topicLookupPath: this.cwd,
+            sendMessageHandler: async () => { },
+        });
+        const results = await coordinator.handleMessage(this.buildMessage({ body: 'help me book!', source: { personId: '1234' } }));
+        test_1.assert.isArray(results.suggestedTopics);
+        test_1.assert.isLength(results.suggestedTopics, 0);
+    }
+    static async throwsWhenSentBadTopic() {
+        const err = await test_1.assert.doesThrowAsync(() => this.coordinator.handleMessage(this.buildMessage({ body: '1', source: { personId: '1234' } }), 'aoeu'));
+        test_utils_1.errorAssert.assertError(err, 'TOPIC_NOT_FOUND', {
+            suppliedTopic: 'aoeu',
+            validTopics: [
+                'bookAppointment',
+                'cancelAppointment',
+                'favoriteColor',
+                'favoriteColorTopicChanger',
+                'mixedStringsAndCallbacks',
+            ],
+        });
+    }
+    static async playsScriptWhenTopicIsSelected() {
+        await this.coordinator.handleMessage(this.buildMessage({ body: '1', source: { personId: '1234' } }), 'bookAppointment');
+        test_1.assert.isLength(this.sentMessages, 2);
+        test_1.assert.isEqual(this.sentMessages[0].body, 'Sweet, lets book!');
+    }
+    static async canHandlePromptsInScript() {
+        var _a;
+        void this.coordinator.handleMessage(this.buildMessage({ body: '1', source: { personId: '1234' } }), 'favoriteColor');
+        await this.wait(10);
+        test_1.assert.isLength(this.sentMessages, 1);
+        test_1.assert.isEqual(this.sentMessages[0].body, 'what is your favorite color?');
+        void this.coordinator.handleMessage(this.buildMessage({ body: 'blue', source: { personId: '1234' } }), 'favoriteColor');
+        await this.wait(10);
+        test_1.assert.isLength(this.sentMessages, 2);
+        test_1.assert.isEqual(this.sentMessages[this.sentMessages.length - 1].body, 'blue');
+        void this.coordinator.handleMessage(this.buildMessage({ body: 'blue', source: { personId: '1234' } }), 'bookAppointment');
+        await this.wait(10);
+        test_1.assert.isLength(this.sentMessages, 4);
+        test_1.assert.isEqual((_a = this.sentMessages.pop()) === null || _a === void 0 ? void 0 : _a.body, 'Lemme find your appointment!');
+    }
+    static async canPlaceMixedScriptsUntilTheEndAndStartsOver() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        await this.coordinator.handleMessage(this.buildMessage({ body: '1', source: { personId: '1234' } }), 'mixedStringsAndCallbacks');
+        await this.wait(10);
+        test_1.assert.isLength(this.sentMessages, 2);
+        test_1.assert.isEqual((_a = this.sentMessages[0]) === null || _a === void 0 ? void 0 : _a.body, 'string 1');
+        test_1.assert.isEqual((_b = this.sentMessages[1]) === null || _b === void 0 ? void 0 : _b.body, 'prompt 1');
+        this.sentMessages = [];
+        await this.coordinator.handleMessage(this.buildMessage({ body: 'answer 1', source: { personId: '1234' } }), 'mixedStringsAndCallbacks');
+        await this.wait(100);
+        test_1.assert.isLength(this.sentMessages, 3);
+        test_1.assert.isEqual((_c = this.sentMessages[0]) === null || _c === void 0 ? void 0 : _c.body, 'answer 1');
+        test_1.assert.isEqual((_d = this.sentMessages[1]) === null || _d === void 0 ? void 0 : _d.body, 'string 2');
+        test_1.assert.isEqual((_e = this.sentMessages[2]) === null || _e === void 0 ? void 0 : _e.body, 'prompt 2');
+        this.sentMessages = [];
+        await this.coordinator.handleMessage(this.buildMessage({ body: 'answer 2', source: { personId: '1234' } }), 'mixedStringsAndCallbacks');
+        test_1.assert.isLength(this.sentMessages, 2);
+        test_1.assert.isEqual((_f = this.sentMessages[0]) === null || _f === void 0 ? void 0 : _f.body, 'answer 2');
+        test_1.assert.isEqual((_g = this.sentMessages[1]) === null || _g === void 0 ? void 0 : _g.body, 'and done');
+        this.sentMessages = [];
+        await this.coordinator.handleMessage(this.buildMessage({ body: 'answer 1', source: { personId: '1234' } }), 'mixedStringsAndCallbacks');
+        await this.wait(100);
+        test_1.assert.isLength(this.sentMessages, 2);
+        test_1.assert.isEqual((_h = this.sentMessages[0]) === null || _h === void 0 ? void 0 : _h.body, 'string 1');
+        test_1.assert.isEqual((_j = this.sentMessages[1]) === null || _j === void 0 ? void 0 : _j.body, 'prompt 1');
+    }
+}
+TopicCoordinatorTest.sentMessages = [];
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "canCreateTopicCoordinator", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "hasHandleMessage", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "handledMessageMustHaveASource", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "respondsWithSuggestedTopicsToFirstMessage", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "handlesNoSkillWithTopics", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "throwsWhenSentBadTopic", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "playsScriptWhenTopicIsSelected", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "canHandlePromptsInScript", null);
+__decorate([
+    (0, test_1.test)()
+], TopicCoordinatorTest, "canPlaceMixedScriptsUntilTheEndAndStartsOver", null);
+exports.default = TopicCoordinatorTest;

package/build/__tests__/implementation/MessageGraphicsInterface/EmailField.test.d.ts

@@ -0,0 +1,7 @@
+import AbstractGraphicsInterfaceTest from '../../../tests/AbstractGraphicsInterfaceTest';
+export default class TextFieldTest extends AbstractGraphicsInterfaceTest {
+    protected static promptSendsLabel(): Promise<void>;
+    protected static noPromptSendsNoMessage(): Promise<void>;
+    protected static respondingWithBadEmailGivesYouAnotherChance(): Promise<void>;
+    protected static respondingWithBadEmail2TimesErrors(): Promise<void>;
+}