@sprucelabs/spruce-cli 19.1.22 → 19.1.23

package/build/__tests__/behavioral/events/CreatingAListener.test.js

@@ -0,0 +1,739 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
+var _mercuryClient = require("@sprucelabs/mercury-client");
+var _mercuryCoreEvents = require("@sprucelabs/mercury-core-events");
+var _schema = require("@sprucelabs/schema");
+var _spruceEventUtils = require("@sprucelabs/spruce-event-utils");
+var _spruceSkillUtils = require("@sprucelabs/spruce-skill-utils");
+var _spruceTestFixtures = require("@sprucelabs/spruce-test-fixtures");
+var _testUtils = require("@sprucelabs/test-utils");
+var _ListenAction = require("../../../features/event/actions/ListenAction");
+var _AbstractEventTest2 = _interopRequireDefault(require("../../../tests/AbstractEventTest"));
+var _test = _interopRequireDefault(require("../../../tests/utilities/test.utility"));
+var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _class, _class2;
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+var CreatingAListenerTest = (_dec = (0, _testUtils.test)(), _dec2 = (0, _testUtils.test)(), _dec3 = (0, _testUtils.test)(), _dec4 = (0, _testUtils.test)(), _dec5 = (0, _testUtils.test)(), _dec6 = (0, _testUtils.test)(), _dec7 = (0, _testUtils.test)(), _dec8 = (0, _testUtils.test)(), _dec9 = (0, _testUtils.test)(), _dec10 = (0, _testUtils.test)(), _dec11 = (0, _testUtils.test)(), (_class = (_class2 = /*#__PURE__*/function (_AbstractEventTest) {
+  (0, _inherits2["default"])(CreatingAListenerTest, _AbstractEventTest);
+  var _super = _createSuper(CreatingAListenerTest);
+  function CreatingAListenerTest() {
+    (0, _classCallCheck2["default"])(this, CreatingAListenerTest);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2["default"])(CreatingAListenerTest, null, [{
+    key: "beforeEach",
+    value: function () {
+      var _beforeEach = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return (0, _get2["default"])((0, _getPrototypeOf2["default"])(CreatingAListenerTest), "beforeEach", this).call(this);
+            case 2:
+              this.listen = this.Action('event', 'listen');
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function beforeEach() {
+        return _beforeEach.apply(this, arguments);
+      }
+      return beforeEach;
+    }()
+  }, {
+    key: "throwsWithBadNamespace",
+    value: function () {
+      var _throwsWithBadNamespace = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var results, err;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.installEventFeature('events');
+            case 2:
+              _context2.next = 4;
+              return this.listen.execute({
+                namespace: 'taco-bell'
+              });
+            case 4:
+              results = _context2.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              err = results.errors[0];
+              _testUtils.errorAssert.assertError(err, 'INVALID_NAMESPACES', {
+                namespaces: ['taco-bell']
+              });
+            case 8:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function throwsWithBadNamespace() {
+        return _throwsWithBadNamespace.apply(this, arguments);
+      }
+      return throwsWithBadNamespace;
+    }()
+  }, {
+    key: "throwsWithBadEventName",
+    value: function () {
+      var _throwsWithBadEventName = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var results, err;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.installEventFeature('events');
+            case 2:
+              _context3.next = 4;
+              return this.listen.execute({
+                namespace: 'heartwood',
+                eventName: 'bad-time'
+              });
+            case 4:
+              results = _context3.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              err = results.errors[0];
+              _testUtils.errorAssert.assertError(err, 'INVALID_PARAMETERS', {
+                parameters: ['eventName']
+              });
+            case 8:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function throwsWithBadEventName() {
+        return _throwsWithBadEventName.apply(this, arguments);
+      }
+      return throwsWithBadEventName;
+    }()
+  }, {
+    key: "generatesMapFile",
+    value: function () {
+      var _generatesMapFile = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var match;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.installEventsCreateListenerAndGetListenerMap();
+            case 2:
+              match = _context4.sent;
+              _context4.next = 5;
+              return this.Service('typeChecker').check(match);
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function generatesMapFile() {
+        return _generatesMapFile.apply(this, arguments);
+      }
+      return generatesMapFile;
+    }()
+  }, {
+    key: "createsValidListener",
+    value: function () {
+      var _createsValidListener = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        var _health$event;
+        var _yield$this$installEv, version, results, cli, match, health;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.installEventsAndCreateListener();
+            case 2:
+              _yield$this$installEv = _context5.sent;
+              version = _yield$this$installEv.version;
+              results = _yield$this$installEv.results;
+              cli = _yield$this$installEv.cli;
+              match = _test["default"].assertFileByNameInGeneratedFiles("will-boot.".concat(version, ".listener.ts"), results.files);
+              _testUtils.assert.doesInclude(match, version);
+              _context5.next = 10;
+              return this.Service('typeChecker').check(match);
+            case 10:
+              _context5.next = 12;
+              return cli.checkHealth();
+            case 12:
+              health = _context5.sent;
+              _testUtils.assert.isFalsy(health === null || health === void 0 || (_health$event = health.event) === null || _health$event === void 0 ? void 0 : _health$event.errors);
+              _testUtils.assert.isTruthy(health.skill);
+              _testUtils.assert.isUndefined(health.skill.errors);
+              _testUtils.assert.isTruthy(health.event);
+              _testUtils.assert.doesInclude(health.event.listeners, {
+                eventName: 'will-boot',
+                eventNamespace: 'skill',
+                version: version
+              });
+            case 18:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function createsValidListener() {
+        return _createsValidListener.apply(this, arguments);
+      }
+      return createsValidListener;
+    }()
+  }, {
+    key: "creatingANewListenerAsksWhichEventToListenTo",
+    value: function () {
+      var _creatingANewListenerAsksWhichEventToListenTo = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+        var lastInvocation;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return this.installEventFeature('events');
+            case 2:
+              _context6.next = 4;
+              return this.executeAndWaitForInput();
+            case 4:
+              lastInvocation = this.ui.getLastInvocation();
+              _testUtils.assert.isEqual(lastInvocation.command, 'prompt');
+              _testUtils.assert.doesInclude(lastInvocation.options.label, 'namespace');
+              _context6.next = 9;
+              return this.ui.sendInput(_spruceSkillUtils.MERCURY_API_NAMESPACE);
+            case 9:
+              _context6.next = 11;
+              return this.waitForInput();
+            case 11:
+              lastInvocation = this.ui.getLastInvocation();
+              _testUtils.assert.doesInclude(lastInvocation.options.label, 'event');
+              this.ui.reset();
+            case 14:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function creatingANewListenerAsksWhichEventToListenTo() {
+        return _creatingANewListenerAsksWhichEventToListenTo.apply(this, arguments);
+      }
+      return creatingANewListenerAsksWhichEventToListenTo;
+    }()
+  }, {
+    key: "loadsContractsFilteringByDependencies",
+    value: function () {
+      var _loadsContractsFilteringByDependencies = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+        var passedTarget, namespace;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _mercuryClient.MercuryClientFactory.setIsTestMode(true);
+              _mercuryClient.MercuryTestClient.setShouldRequireLocalListeners(true);
+              _context7.next = 4;
+              return this.fakeGetEventContracts(function (target) {
+                passedTarget = target;
+              });
+            case 4:
+              namespace = (0, _testUtils.generateId)();
+              _context7.next = 7;
+              return this.installAddDependencyExecuteAndWaitForInput(namespace);
+            case 7:
+              _testUtils.assert.isEqualDeep(passedTarget, {
+                namespaces: [namespace, _ListenAction.CORE_EVENT_NAMESPACE]
+              });
+              this.ui.reset();
+            case 9:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function loadsContractsFilteringByDependencies() {
+        return _loadsContractsFilteringByDependencies.apply(this, arguments);
+      }
+      return loadsContractsFilteringByDependencies;
+    }()
+  }, {
+    key: "fakeGetEventContracts",
+    value: function () {
+      var _fakeGetEventContracts = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(cb, results) {
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return _spruceTestFixtures.eventFaker.on('get-event-contracts::v2020_12_25', function (_ref) {
+                var target = _ref.target;
+                cb === null || cb === void 0 || cb(target);
+                return {
+                  contracts: results !== null && results !== void 0 ? results : (0, _toConsumableArray2["default"])(_mercuryCoreEvents.coreEventContracts)
+                };
+              });
+            case 2:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function fakeGetEventContracts(_x, _x2) {
+        return _fakeGetEventContracts.apply(this, arguments);
+      }
+      return fakeGetEventContracts;
+    }()
+  }, {
+    key: "generatesTypedListenerWithoutPayloads",
+    value: function () {
+      var _generatesTypedListenerWithoutPayloads = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+        var _yield$this$setupSkil, contents;
+        return _regenerator["default"].wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.next = 2;
+              return this.setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener({
+                isGlobal: true
+              });
+            case 2:
+              _yield$this$setupSkil = _context9.sent;
+              contents = _yield$this$setupSkil.contents;
+              _testUtils.assert.doesInclude(contents, 'export default async (event: SpruceEvent): SpruceEventResponse');
+            case 5:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function generatesTypedListenerWithoutPayloads() {
+        return _generatesTypedListenerWithoutPayloads.apply(this, arguments);
+      }
+      return generatesTypedListenerWithoutPayloads;
+    }()
+  }, {
+    key: "generatesTypedListenerWithEmitPayload",
+    value: function () {
+      var _generatesTypedListenerWithEmitPayload = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+        var _yield$this$setupSkil2, contents, skill2;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.next = 2;
+              return this.setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener({
+                emitPayloadSchema: (0, _spruceEventUtils.buildEmitTargetAndPayloadSchema)({
+                  eventName: 'my-new-event',
+                  targetSchema: _spruceEventUtils.eventTargetSchema,
+                  payloadSchema: {
+                    id: 'myNewEventEmitPayload',
+                    fields: {
+                      booleanField: {
+                        type: 'boolean'
+                      }
+                    }
+                  }
+                })
+              });
+            case 2:
+              _yield$this$setupSkil2 = _context10.sent;
+              contents = _yield$this$setupSkil2.contents;
+              skill2 = _yield$this$setupSkil2.skill2;
+              _testUtils.assert.doesInclude(contents, 'event: SpruceEvent<SkillEventContract, EmitPayload>');
+              _testUtils.assert.doesInclude(contents, "fullyQualifiedEventName: '".concat(skill2.slug, ".my-new-event::").concat(this.expectedVersion, "'"));
+            case 7:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function generatesTypedListenerWithEmitPayload() {
+        return _generatesTypedListenerWithEmitPayload.apply(this, arguments);
+      }
+      return generatesTypedListenerWithEmitPayload;
+    }()
+  }, {
+    key: "emittingEventTriggersListenerAndCrashesWithListenerNotImplemented",
+    value: function () {
+      var _emittingEventTriggersListenerAndCrashesWithListenerNotImplemented = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+        var _boot$meta, _boot$meta2;
+        var _yield$this$setupSkil3, currentSkill, skill2, eventContract, org, currentClient, boot, client, eventName, results, error, responderRef;
+        return _regenerator["default"].wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.next = 2;
+              return this.setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener({
+                emitPayloadSchema: (0, _spruceEventUtils.buildEmitTargetAndPayloadSchema)({
+                  eventName: 'my-new-event',
+                  targetSchema: {
+                    id: 'myNewEventEmitTarget',
+                    fields: {
+                      organizationId: {
+                        type: 'id',
+                        isRequired: true
+                      }
+                    }
+                  },
+                  payloadSchema: {
+                    id: 'myNewEventEmitPayload',
+                    fields: {
+                      booleanField: {
+                        type: 'boolean'
+                      }
+                    }
+                  }
+                }),
+                responsePayloadSchema: (0, _schema.buildSchema)({
+                  id: 'myNewEventResponsePayload',
+                  fields: {
+                    booleanField: {
+                      type: 'boolean'
+                    }
+                  }
+                })
+              });
+            case 2:
+              _yield$this$setupSkil3 = _context11.sent;
+              currentSkill = _yield$this$setupSkil3.currentSkill;
+              skill2 = _yield$this$setupSkil3.skill2;
+              eventContract = _yield$this$setupSkil3.eventContract;
+              org = _yield$this$setupSkil3.org;
+              _context11.next = 9;
+              return this.connectToApi({
+                shouldAuthAsCurrentSkill: true
+              });
+            case 9:
+              currentClient = _context11.sent;
+              _context11.next = 12;
+              return currentClient.disconnect();
+            case 12:
+              _context11.next = 14;
+              return this.Action('skill', 'boot').execute({
+                local: true
+              });
+            case 14:
+              boot = _context11.sent;
+              _testUtils.assert.isFalsy(boot.errors);
+
+              //give the skill time to boot
+              _context11.next = 18;
+              return this.wait(20000);
+            case 18:
+              _context11.next = 20;
+              return this.connectToApi({
+                skillId: skill2.id,
+                apiKey: skill2.apiKey
+              });
+            case 20:
+              client = _context11.sent;
+              eventName = "".concat(skill2.slug, ".my-new-event::").concat(this.expectedVersion);
+              client.mixinContract({
+                eventSignatures: (0, _defineProperty2["default"])({}, eventName, eventContract.eventSignatures["my-new-event::".concat(this.expectedVersion)])
+              });
+            case 23:
+              _context11.next = 25;
+              return this.wait(5000);
+            case 25:
+              _context11.next = 27;
+              return client.emit(eventName, {
+                target: {
+                  organizationId: org.id
+                },
+                payload: {
+                  booleanField: true
+                }
+              });
+            case 27:
+              results = _context11.sent;
+            case 28:
+              if (results.totalContracts < 1) {
+                _context11.next = 23;
+                break;
+              }
+            case 29:
+              _testUtils.assert.isEqual(results.totalContracts, 1);
+              _testUtils.assert.isEqual(results.totalErrors, 1);
+              _testUtils.assert.isEqual(results.totalResponses, 1);
+              (_boot$meta = boot.meta) === null || _boot$meta === void 0 || (_boot$meta = _boot$meta.promise) === null || _boot$meta === void 0 || _boot$meta["catch"](function (err) {
+                _testUtils.assert.fail(err.stack);
+              });
+              _context11.next = 35;
+              return (_boot$meta2 = boot.meta) === null || _boot$meta2 === void 0 ? void 0 : _boot$meta2.kill();
+            case 35:
+              error = _testUtils.assert.doesThrow(function () {
+                return _spruceEventUtils.eventResponseUtil.getFirstResponseOrThrow(results);
+              });
+              _spruceEventUtils.eventAssertUtil.assertError(error, 'LISTENER_NOT_IMPLEMENTED');
+              responderRef = results.responses[0].responderRef;
+              _testUtils.assert.isEqual(responderRef, "skill:".concat(currentSkill.id, ":").concat(currentSkill.slug));
+            case 39:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function emittingEventTriggersListenerAndCrashesWithListenerNotImplemented() {
+        return _emittingEventTriggersListenerAndCrashesWithListenerNotImplemented.apply(this, arguments);
+      }
+      return emittingEventTriggersListenerAndCrashesWithListenerNotImplemented;
+    }()
+  }, {
+    key: "listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener",
+    value: function () {
+      var _listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+        var _yield$this$setupSkil4, listenerPath;
+        return _regenerator["default"].wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              _context12.next = 2;
+              return this.setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener({
+                isGlobal: true,
+                responsePayloadSchema: {
+                  id: 'test',
+                  fields: {
+                    id: {
+                      type: 'id'
+                    }
+                  }
+                }
+              });
+            case 2:
+              _yield$this$setupSkil4 = _context12.sent;
+              listenerPath = _yield$this$setupSkil4.listenerPath;
+              _context12.next = 6;
+              return this.Service('typeChecker').check(listenerPath);
+            case 6:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener() {
+        return _listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener.apply(this, arguments);
+      }
+      return listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener;
+    }()
+  }, {
+    key: "hasIsGlobalCheck",
+    value: function () {
+      var _hasIsGlobalCheck = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
+        var match, contents;
+        return _regenerator["default"].wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _context13.next = 2;
+              return this.installEventsCreateListenerAndGetListenerMap();
+            case 2:
+              match = _context13.sent;
+              contents = _spruceSkillUtils.diskUtil.readFile(match);
+              _testUtils.assert.doesInclude(contents, "isGlobal: require('../../listeners/skill/will-boot.v2020_01_01.listener').isGlobal,");
+            case 5:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function hasIsGlobalCheck() {
+        return _hasIsGlobalCheck.apply(this, arguments);
+      }
+      return hasIsGlobalCheck;
+    }()
+  }, {
+    key: "installAddDependencyExecuteAndWaitForInput",
+    value: function () {
+      var _installAddDependencyExecuteAndWaitForInput = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14(namespace) {
+        return _regenerator["default"].wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              _context14.next = 2;
+              return this.installEventFeature('events');
+            case 2:
+              this.addDependency(namespace);
+              _context14.next = 5;
+              return this.executeAndWaitForInput();
+            case 5:
+              return _context14.abrupt("return", this.ui.getLastInvocation());
+            case 6:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function installAddDependencyExecuteAndWaitForInput(_x3) {
+        return _installAddDependencyExecuteAndWaitForInput.apply(this, arguments);
+      }
+      return installAddDependencyExecuteAndWaitForInput;
+    }()
+  }, {
+    key: "executeAndWaitForInput",
+    value: function () {
+      var _executeAndWaitForInput = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee15() {
+        var _this = this;
+        return _regenerator["default"].wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              void this.listen.execute({}).then(function (results) {
+                if (results.errors) {
+                  _this.ui.setError(results.errors[0]);
+                }
+              });
+              _context15.next = 3;
+              return this.waitForInput();
+            case 3:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function executeAndWaitForInput() {
+        return _executeAndWaitForInput.apply(this, arguments);
+      }
+      return executeAndWaitForInput;
+    }()
+  }, {
+    key: "addDependency",
+    value: function addDependency(namespace) {
+      var dependencies = this.Service('dependency');
+      dependencies.add({
+        id: namespace,
+        namespace: namespace
+      });
+    }
+  }, {
+    key: "installEventsAndCreateListener",
+    value: function () {
+      var _installEventsAndCreateListener = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee16() {
+        var cli, version, results;
+        return _regenerator["default"].wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              _context16.next = 2;
+              return this.installEventFeature('events');
+            case 2:
+              cli = _context16.sent;
+              version = 'v2020_01_01';
+              _context16.next = 6;
+              return this.listen.execute({
+                namespace: 'skill',
+                eventName: 'will-boot',
+                version: version
+              });
+            case 6:
+              results = _context16.sent;
+              _testUtils.assert.isFalsy(results.errors);
+              return _context16.abrupt("return", {
+                version: version,
+                results: results,
+                cli: cli
+              });
+            case 9:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function installEventsAndCreateListener() {
+        return _installEventsAndCreateListener.apply(this, arguments);
+      }
+      return installEventsAndCreateListener;
+    }()
+  }, {
+    key: "setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener",
+    value: function () {
+      var _setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee17(eventSignature) {
+        var expectedVersion, eventContract, _yield$this$seedDummy, skillFixture, skill2, currentSkill, cli, org, results, listener, contents;
+        return _regenerator["default"].wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              expectedVersion = this.expectedVersion;
+              eventContract = {
+                eventSignatures: (0, _defineProperty2["default"])({}, "my-new-event::".concat(expectedVersion), eventSignature)
+              };
+              _context17.next = 4;
+              return this.seedDummySkillRegisterCurrentSkillAndInstallToOrg();
+            case 4:
+              _yield$this$seedDummy = _context17.sent;
+              skillFixture = _yield$this$seedDummy.skillFixture;
+              skill2 = _yield$this$seedDummy.skill2;
+              currentSkill = _yield$this$seedDummy.currentSkill;
+              cli = _yield$this$seedDummy.cli;
+              org = _yield$this$seedDummy.org;
+              _context17.next = 12;
+              return skillFixture.registerEventContract(skill2, eventContract);
+            case 12:
+              this.Service('dependency').add({
+                id: skill2.id,
+                namespace: skill2.slug
+              });
+              _context17.next = 15;
+              return this.listen.execute({
+                namespace: skill2.slug,
+                eventName: "my-new-event",
+                version: expectedVersion
+              });
+            case 15:
+              results = _context17.sent;
+              _testUtils.assert.isFalsy(results.errors);
+              listener = _test["default"].assertFileByNameInGeneratedFiles("my-new-event.".concat(expectedVersion, ".listener.ts"), results.files);
+              _context17.next = 20;
+              return this.Service('typeChecker').check(listener);
+            case 20:
+              contents = _spruceSkillUtils.diskUtil.readFile(listener);
+              return _context17.abrupt("return", {
+                contents: contents,
+                skill2: skill2,
+                listenerPath: listener,
+                cli: cli,
+                eventContract: eventContract,
+                org: org,
+                currentSkill: currentSkill
+              });
+            case 22:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener(_x4) {
+        return _setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener.apply(this, arguments);
+      }
+      return setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener;
+    }()
+  }, {
+    key: "installEventsCreateListenerAndGetListenerMap",
+    value: function () {
+      var _installEventsCreateListenerAndGetListenerMap = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee18() {
+        var _yield$this$installEv2, results, match;
+        return _regenerator["default"].wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              _context18.next = 2;
+              return this.installEventsAndCreateListener();
+            case 2:
+              _yield$this$installEv2 = _context18.sent;
+              results = _yield$this$installEv2.results;
+              match = _test["default"].assertFileByNameInGeneratedFiles("listeners.ts", results.files);
+              return _context18.abrupt("return", match);
+            case 6:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function installEventsCreateListenerAndGetListenerMap() {
+        return _installEventsCreateListenerAndGetListenerMap.apply(this, arguments);
+      }
+      return installEventsCreateListenerAndGetListenerMap;
+    }()
+  }]);
+  return CreatingAListenerTest;
+}(_AbstractEventTest2["default"]), (0, _defineProperty2["default"])(_class2, "expectedVersion", _spruceSkillUtils.versionUtil.generateVersion().constValue), (0, _defineProperty2["default"])(_class2, "listen", void 0), _class2), ((0, _applyDecoratedDescriptor2["default"])(_class, "throwsWithBadNamespace", [_dec], Object.getOwnPropertyDescriptor(_class, "throwsWithBadNamespace"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "throwsWithBadEventName", [_dec2], Object.getOwnPropertyDescriptor(_class, "throwsWithBadEventName"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "generatesMapFile", [_dec3], Object.getOwnPropertyDescriptor(_class, "generatesMapFile"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "createsValidListener", [_dec4], Object.getOwnPropertyDescriptor(_class, "createsValidListener"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "creatingANewListenerAsksWhichEventToListenTo", [_dec5], Object.getOwnPropertyDescriptor(_class, "creatingANewListenerAsksWhichEventToListenTo"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "loadsContractsFilteringByDependencies", [_dec6], Object.getOwnPropertyDescriptor(_class, "loadsContractsFilteringByDependencies"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "generatesTypedListenerWithoutPayloads", [_dec7], Object.getOwnPropertyDescriptor(_class, "generatesTypedListenerWithoutPayloads"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "generatesTypedListenerWithEmitPayload", [_dec8], Object.getOwnPropertyDescriptor(_class, "generatesTypedListenerWithEmitPayload"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "emittingEventTriggersListenerAndCrashesWithListenerNotImplemented", [_dec9], Object.getOwnPropertyDescriptor(_class, "emittingEventTriggersListenerAndCrashesWithListenerNotImplemented"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener", [_dec10], Object.getOwnPropertyDescriptor(_class, "listeningToAnEventWithNoEmitTargetOrPayloadGeneratesValidListener"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "hasIsGlobalCheck", [_dec11], Object.getOwnPropertyDescriptor(_class, "hasIsGlobalCheck"), _class)), _class));
+exports["default"] = CreatingAListenerTest;
+//# sourceMappingURL=CreatingAListener.test.js.map