@sprucelabs/spruce-conversation-plugin 45.2.7 → 46.0.0

package/build/__tests__/testDirsAndFiles/skill/build/conversations/favoriteColor.topic.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const topicDefinition = {
+    label: 'favorite color',
+    utterances: ['favorite color'],
+    script: [
+        'what is your favorite color?',
+        async (options) => {
+            const answer = await options.ui.prompt({ type: 'text', isRequired: true });
+            options.ui.renderLine(answer);
+            return {
+                transitionConversationTo: 'discovery',
+                repairs: ['go', 'team'],
+            };
+        },
+    ],
+};
+exports.default = topicDefinition;

package/build/__tests__/testDirsAndFiles/skill/build/conversations/favoriteColorTopicChanger.topic.d.ts

@@ -0,0 +1,3 @@
+import { TopicDefinition } from '../../../../../types/conversation.types';
+declare const topicDefinition: TopicDefinition;
+export default topicDefinition;

package/build/__tests__/testDirsAndFiles/skill/build/conversations/favoriteColorTopicChanger.topic.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const topicDefinition = {
+    label: 'favorite color',
+    utterances: ['favorite color'],
+    script: [
+        'what is your favorite color?',
+        async (options) => {
+            const answer = await options.ui.prompt({ type: 'text', isRequired: true });
+            options.ui.renderLine(answer);
+            return {
+                transitionConversationTo: 'discovery',
+                topicChangers: ['now', 'this'],
+            };
+        },
+    ],
+};
+exports.default = topicDefinition;

package/build/__tests__/testDirsAndFiles/skill/build/conversations/mixedStringsAndCallbacks.topic.d.ts

@@ -0,0 +1,3 @@
+import { TopicDefinition } from '../../../../../types/conversation.types';
+declare const topicDefinition: TopicDefinition;
+export default topicDefinition;

package/build/__tests__/testDirsAndFiles/skill/build/conversations/mixedStringsAndCallbacks.topic.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const topicDefinition = {
+    label: 'mixed strings and callback',
+    utterances: ['mixed'],
+    script: [
+        'string 1',
+        async (options) => {
+            const answer = await options.ui.prompt({
+                type: 'text',
+                isRequired: true,
+                label: 'prompt 1',
+            });
+            options.ui.renderLine(answer);
+        },
+        'string 2',
+        async (options) => {
+            const answer = await options.ui.prompt({
+                type: 'text',
+                isRequired: true,
+                label: 'prompt 2',
+            });
+            options.ui.renderLine(answer);
+            return {};
+        },
+        ['and done', 'and done', 'and done'],
+    ],
+};
+exports.default = topicDefinition;

package/build/__tests__/testDirsAndFiles/skill-assertions/build/.spruce/events/listeners.d.ts

@@ -0,0 +1,2 @@
+declare const _default: never[];
+export default _default;

package/build/__tests__/testDirsAndFiles/skill-assertions/build/.spruce/events/listeners.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [];

package/build/__tests__/testDirsAndFiles/skill-assertions/build/conversations/assertsScriptCallbackOptions.topic.d.ts

@@ -0,0 +1,3 @@
+import { TopicDefinition } from '../../../../../types/conversation.types';
+declare const topicDefinition: TopicDefinition;
+export default topicDefinition;

package/build/__tests__/testDirsAndFiles/skill-assertions/build/conversations/assertsScriptCallbackOptions.topic.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@sprucelabs/test");
+const topicDefinition = {
+    label: 'asserts good callback options',
+    utterances: ['good options'],
+    script: [
+        async (options) => {
+            test_1.assert.isTruthy(options);
+            test_1.assert.isFunction(options.rand);
+            test_1.assert.isTruthy(options.message);
+            test_1.assert.isEqual(options.message.body, 'hello');
+        },
+        async (options) => {
+            test_1.assert.isTruthy(options);
+            test_1.assert.isFunction(options.rand);
+            test_1.assert.isTruthy(options.message);
+            test_1.assert.isEqual(options.message.body, 'hello');
+        },
+    ],
+};
+exports.default = topicDefinition;

package/build/__tests__/testDirsAndFiles/skill-assertions/build/conversations/assertsScriptOnlyCalledOnce.topic.d.ts

@@ -0,0 +1,3 @@
+import { TopicDefinition } from '../../../../../types/conversation.types';
+declare const topicDefinition: TopicDefinition;
+export default topicDefinition;

package/build/__tests__/testDirsAndFiles/skill-assertions/build/conversations/assertsScriptOnlyCalledOnce.topic.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@sprucelabs/test");
+const topicDefinition = {
+    label: 'asserts only called once',
+    utterances: ['only called once'],
+    script: [
+        async (options) => {
+            test_1.assert.isFalsy(options.state.hasBeenRun);
+            options.state.hasBeenRun = true;
+        },
+    ],
+};
+exports.default = topicDefinition;

package/build/__tests__/testDirsAndFiles/skill-with-script-that-throws/build/.spruce/events/listeners.d.ts

@@ -0,0 +1,2 @@
+declare const _default: never[];
+export default _default;

package/build/__tests__/testDirsAndFiles/skill-with-script-that-throws/build/.spruce/events/listeners.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [];

package/build/__tests__/testDirsAndFiles/skill-with-script-that-throws/build/conversations/cancelAppointment.topic.d.ts

@@ -0,0 +1,3 @@
+import { TopicDefinition } from '../../../../../types/conversation.types';
+declare const topicDefinition: TopicDefinition;
+export default topicDefinition;

package/build/__tests__/testDirsAndFiles/skill-with-script-that-throws/build/conversations/cancelAppointment.topic.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const topicDefinition = {
+    label: 'Cancel appointment',
+    utterances: ['Cancel appointment', 'Can i cancel my appointment?', 'cancel'],
+    script: [
+        () => {
+            throw new Error('In Script');
+        },
+    ],
+};
+exports.default = topicDefinition;

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

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

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

@@ -0,0 +1,32 @@
+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 AbstractConversationTest from '../../tests/AbstractConversationTest.js';
+export default class KillingASkillTest extends AbstractConversationTest {
+    static killingASkillKillsConversation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cwd = this.resolveTestPath('empty-skill');
+            const { skill } = yield this.bootAndRegisterNewSkill({
+                name: 'great skill dude!',
+            });
+            yield skill.kill();
+            assert.isFalse(skill.isRunning());
+        });
+    }
+}
+__decorate([
+    test()
+], KillingASkillTest, "killingASkillKillsConversation", null);

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

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

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

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

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