@sprucelabs/spruce-cli 19.1.22 → 19.1.24

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

@@ -0,0 +1,806 @@
+"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 _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 _spruceSkillUtils = require("@sprucelabs/spruce-skill-utils");
+var _testUtils = require("@sprucelabs/test-utils");
+var _CommandService = _interopRequireDefault(require("../../services/CommandService"));
+var _AbstractCliTest2 = _interopRequireDefault(require("../../tests/AbstractCliTest"));
+var _test = _interopRequireDefault(require("../../tests/utilities/test.utility"));
+var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _class, _class2, _process$env$HEROKU_T4;
+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 DeployingASkillTest = (_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)(), _dec12 = (0, _testUtils.test)(), _dec13 = (0, _testUtils.test)(), _dec14 = (0, _testUtils.test)(), _dec15 = (0, _testUtils.test)(), _dec16 = (0, _testUtils.test)(), _dec17 = (0, _testUtils.test)(), (_class = (_class2 = /*#__PURE__*/function (_AbstractCliTest) {
+  (0, _inherits2["default"])(DeployingASkillTest, _AbstractCliTest);
+  var _super = _createSuper(DeployingASkillTest);
+  function DeployingASkillTest() {
+    (0, _classCallCheck2["default"])(this, DeployingASkillTest);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2["default"])(DeployingASkillTest, 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"])(DeployingASkillTest), "beforeEach", this).call(this);
+            case 2:
+              _CommandService["default"].fakeCommand('which heroku', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('grep api.heroku.com ~/.netrc', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('git status', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('git init', {
+                code: 0,
+                stdout: 'Initialized empty Git repository in'
+              });
+              _CommandService["default"].fakeCommand('git ls-remote heroku', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('which git', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('heroku create good-heroku-name', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('heroku create bad-heroku-name', {
+                code: 1
+              });
+              _CommandService["default"].fakeCommand('heroku buildpacks:set heroku/nodejs', {
+                code: 0
+              });
+              _CommandService["default"].fakeCommand('git push --set-upstream heroku master', {
+                code: 0
+              });
+              _spruceSkillUtils.diskUtil.writeFile(this.resolvePath('Procfile'), 'web: npm run boot');
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function beforeEach() {
+        return _beforeEach.apply(this, arguments);
+      }
+      return beforeEach;
+    }()
+  }, {
+    key: "hasDeployAction",
+    value: function () {
+      var _hasDeployAction = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _testUtils.assert.isFunction(this.Action('deploy', 'heroku').execute);
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function hasDeployAction() {
+        return _hasDeployAction.apply(this, arguments);
+      }
+      return hasDeployAction;
+    }()
+  }, {
+    key: "deployHaltedBecauseNotRegistered",
+    value: function () {
+      var _deployHaltedBecauseNotRegistered = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var _process$env$HEROKU_T;
+        var results;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 2:
+              _spruceSkillUtils.diskUtil.writeFile(this.resolvePath('src/index.ts'), 'aoeustahoesuntao');
+              _context3.next = 5;
+              return this.Action('deploy', 'heroku').execute({
+                teamName: (_process$env$HEROKU_T = process.env.HEROKU_TEAM_NAME) !== null && _process$env$HEROKU_T !== void 0 ? _process$env$HEROKU_T : ''
+              });
+            case 5:
+              results = _context3.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.assert.isArray(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'skill'
+              });
+            case 9:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function deployHaltedBecauseNotRegistered() {
+        return _deployHaltedBecauseNotRegistered.apply(this, arguments);
+      }
+      return deployHaltedBecauseNotRegistered;
+    }()
+  }, {
+    key: "deployHaltedWithBadBuild",
+    value: function () {
+      var _deployHaltedWithBadBuild = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var _process$env$HEROKU_T2;
+        var results;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 2:
+              _context4.next = 4;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'haulted wth bad build'
+              });
+            case 4:
+              _spruceSkillUtils.diskUtil.writeFile(this.resolvePath('src/index.ts'), 'aoeustahoesuntao');
+              _context4.next = 7;
+              return this.Action('deploy', 'heroku').execute({
+                teamName: (_process$env$HEROKU_T2 = process.env.HEROKU_TEAM_NAME) !== null && _process$env$HEROKU_T2 !== void 0 ? _process$env$HEROKU_T2 : ''
+              });
+            case 7:
+              results = _context4.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.assert.isArray(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'building'
+              });
+            case 11:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function deployHaltedWithBadBuild() {
+        return _deployHaltedWithBadBuild.apply(this, arguments);
+      }
+      return deployHaltedWithBadBuild;
+    }()
+  }, {
+    key: "healthCheckReportsNotDeployed",
+    value: function () {
+      var _healthCheckReportsNotDeployed = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        var cli, health;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 2:
+              cli = _context5.sent;
+              _context5.next = 5;
+              return cli.checkHealth();
+            case 5:
+              health = _context5.sent;
+              _testUtils.assert.isFalsy(health.errors);
+              _testUtils.assert.isTruthy(health.deploy);
+              _testUtils.assert.isEqual(health.deploy.status, 'passed');
+              _testUtils.assert.isLength(health.deploy.deploys, 0);
+            case 10:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function healthCheckReportsNotDeployed() {
+        return _healthCheckReportsNotDeployed.apply(this, arguments);
+      }
+      return healthCheckReportsNotDeployed;
+    }()
+  }, {
+    key: "deployHaltedWithBadTest",
+    value: function () {
+      var _deployHaltedWithBadTest = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+        var _process$env$HEROKU_T3;
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return this.FeatureFixture().installCachedFeatures('deployWithTests');
+            case 2:
+              _context6.next = 4;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'haulted wth bad test'
+              });
+            case 4:
+              promise = this.Action('test', 'create').execute({
+                nameReadable: 'Test failed',
+                nameCamel: 'testFailed',
+                type: 'behavioral'
+              });
+              _context6.next = 7;
+              return this.waitForInput();
+            case 7:
+              _context6.next = 9;
+              return this.ui.sendInput('');
+            case 9:
+              _context6.next = 11;
+              return promise;
+            case 11:
+              _context6.next = 13;
+              return this.Action('deploy', 'heroku').execute({
+                teamName: (_process$env$HEROKU_T3 = process.env.HEROKU_TEAM_NAME) !== null && _process$env$HEROKU_T3 !== void 0 ? _process$env$HEROKU_T3 : ''
+              });
+            case 13:
+              results = _context6.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.assert.isArray(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'TEST_FAILED');
+            case 17:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function deployHaltedWithBadTest() {
+        return _deployHaltedWithBadTest.apply(this, arguments);
+      }
+      return deployHaltedWithBadTest;
+    }()
+  }, {
+    key: "errorsIfHerokuClientNotInstalled",
+    value: function () {
+      var _errorsIfHerokuClientNotInstalled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+        var results;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('which heroku', {
+                code: 1
+              });
+              _context7.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context7.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'heroku not installed'
+              });
+            case 5:
+              _context7.next = 7;
+              return this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+            case 7:
+              results = _context7.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'MISSING_DEPENDENCIES', {
+                'dependencies[0].name': 'heroku'
+              });
+            case 10:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function errorsIfHerokuClientNotInstalled() {
+        return _errorsIfHerokuClientNotInstalled.apply(this, arguments);
+      }
+      return errorsIfHerokuClientNotInstalled;
+    }()
+  }, {
+    key: "errorsIfGitNotInstalled",
+    value: function () {
+      var _errorsIfGitNotInstalled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+        var results;
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('which git', {
+                code: 1
+              });
+              _context8.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context8.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'git not installed'
+              });
+            case 5:
+              _context8.next = 7;
+              return this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+            case 7:
+              results = _context8.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'MISSING_DEPENDENCIES', {
+                'dependencies[0].name': 'git'
+              });
+            case 10:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function errorsIfGitNotInstalled() {
+        return _errorsIfGitNotInstalled.apply(this, arguments);
+      }
+      return errorsIfGitNotInstalled;
+    }()
+  }, {
+    key: "errorsIfNotInGitRepo",
+    value: function () {
+      var _errorsIfNotInGitRepo = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('git status', {
+                code: 128,
+                stderr: 'fatal: not a git repository (or any of the parent directories): .git'
+              });
+              _context9.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context9.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'not in git repo'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context9.next = 8;
+              return this.waitForInput();
+            case 8:
+              _context9.next = 10;
+              return this.ui.sendInput('n');
+            case 10:
+              _context9.next = 12;
+              return promise;
+            case 12:
+              results = _context9.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'git'
+              });
+            case 15:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function errorsIfNotInGitRepo() {
+        return _errorsIfNotInGitRepo.apply(this, arguments);
+      }
+      return errorsIfNotInGitRepo;
+    }()
+  }, {
+    key: "canCreateGitRepoIfNeeded",
+    value: function () {
+      var _canCreateGitRepoIfNeeded = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('git status', {
+                code: 128
+              });
+              _context10.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context10.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'creates git repo'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context10.next = 8;
+              return this.waitForInput();
+            case 8:
+              _CommandService["default"].fakeCommand('git status', {
+                code: 0
+              });
+              _context10.next = 11;
+              return this.ui.sendInput('y');
+            case 11:
+              _context10.next = 13;
+              return promise;
+            case 13:
+              results = _context10.sent;
+              _testUtils.assert.isFalsy(results.errors);
+            case 15:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function canCreateGitRepoIfNeeded() {
+        return _canCreateGitRepoIfNeeded.apply(this, arguments);
+      }
+      return canCreateGitRepoIfNeeded;
+    }()
+  }, {
+    key: "errorsWhenNotLoggedIntoHerkou",
+    value: function () {
+      var _errorsWhenNotLoggedIntoHerkou = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+        var results;
+        return _regenerator["default"].wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('grep api.heroku.com ~/.netrc', {
+                code: 1
+              });
+              _context11.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context11.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'not logged into heroku'
+              });
+            case 5:
+              _context11.next = 7;
+              return this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+            case 7:
+              results = _context11.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'heroku'
+              });
+            case 10:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function errorsWhenNotLoggedIntoHerkou() {
+        return _errorsWhenNotLoggedIntoHerkou.apply(this, arguments);
+      }
+      return errorsWhenNotLoggedIntoHerkou;
+    }()
+  }, {
+    key: "failsWhenDeclineToCreateProcFile",
+    value: function () {
+      var _failsWhenDeclineToCreateProcFile = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              _spruceSkillUtils.diskUtil.deleteFile(this.resolvePath('Procfile'));
+              _context12.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context12.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'decline proc file'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context12.next = 8;
+              return this.waitForInput();
+            case 8:
+              _testUtils.assert.doesInclude(this.ui.invocations, {
+                command: 'confirm'
+              });
+              _context12.next = 11;
+              return this.ui.sendInput('n');
+            case 11:
+              _context12.next = 13;
+              return promise;
+            case 13:
+              results = _context12.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'procfile'
+              });
+            case 16:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function failsWhenDeclineToCreateProcFile() {
+        return _failsWhenDeclineToCreateProcFile.apply(this, arguments);
+      }
+      return failsWhenDeclineToCreateProcFile;
+    }()
+  }, {
+    key: "createsValidProcFile",
+    value: function () {
+      var _createsValidProcFile = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
+        var promise, results, match, contents;
+        return _regenerator["default"].wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _spruceSkillUtils.diskUtil.deleteFile(this.resolvePath('Procfile'));
+              _context13.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context13.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'valid proc file'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context13.next = 8;
+              return this.waitForInput();
+            case 8:
+              _context13.next = 10;
+              return this.ui.sendInput('y');
+            case 10:
+              _context13.next = 12;
+              return promise;
+            case 12:
+              results = _context13.sent;
+              _testUtils.assert.isFalsy(results.errors);
+              match = _test["default"].assertFileByNameInGeneratedFiles('Procfile', results.files);
+              contents = _spruceSkillUtils.diskUtil.readFile(match);
+              _testUtils.assert.isEqual(contents, 'worker: npm run boot');
+            case 17:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function createsValidProcFile() {
+        return _createsValidProcFile.apply(this, arguments);
+      }
+      return createsValidProcFile;
+    }()
+  }, {
+    key: "failsWhenDeclineToCreateRemoteBranch",
+    value: function () {
+      var _failsWhenDeclineToCreateRemoteBranch = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14() {
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('git ls-remote heroku', {
+                code: 128
+              });
+              _context14.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context14.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'decline to create remote branch'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context14.next = 8;
+              return this.waitForInput();
+            case 8:
+              _testUtils.assert.doesInclude(this.ui.invocations, {
+                command: 'confirm'
+              });
+              _context14.next = 11;
+              return this.ui.sendInput('n');
+            case 11:
+              _context14.next = 13;
+              return promise;
+            case 13:
+              results = _context14.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'remote'
+              });
+            case 16:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function failsWhenDeclineToCreateRemoteBranch() {
+        return _failsWhenDeclineToCreateRemoteBranch.apply(this, arguments);
+      }
+      return failsWhenDeclineToCreateRemoteBranch;
+    }()
+  }, {
+    key: "asksForHerokuAppName",
+    value: function () {
+      var _asksForHerokuAppName = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee15() {
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('git ls-remote heroku', {
+                code: 128
+              });
+              _context15.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context15.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'ask for app name'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context15.next = 8;
+              return this.waitForInput();
+            case 8:
+              _context15.next = 10;
+              return this.ui.sendInput('y');
+            case 10:
+              _context15.next = 12;
+              return this.waitForInput();
+            case 12:
+              _testUtils.assert.doesInclude(this.ui.invocations, {
+                command: 'prompt',
+                options: {
+                  type: 'text'
+                }
+              });
+              _context15.next = 15;
+              return this.ui.sendInput("good-heroku-name");
+            case 15:
+              _context15.next = 17;
+              return promise;
+            case 17:
+              results = _context15.sent;
+              _testUtils.assert.isFalsy(results.errors);
+            case 19:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function asksForHerokuAppName() {
+        return _asksForHerokuAppName.apply(this, arguments);
+      }
+      return asksForHerokuAppName;
+    }()
+  }, {
+    key: "keepsAskingForAppNameUntilAGoodOneIsSelected",
+    value: function () {
+      var _keepsAskingForAppNameUntilAGoodOneIsSelected = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee16() {
+        var promise, results;
+        return _regenerator["default"].wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('git ls-remote heroku', {
+                code: 128
+              });
+              _context16.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context16.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'haulted wth bad build'
+              });
+            case 5:
+              promise = this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+              _context16.next = 8;
+              return this.waitForInput();
+            case 8:
+              _testUtils.assert.doesInclude(this.ui.invocations, {
+                command: 'confirm'
+              });
+              _context16.next = 11;
+              return this.ui.sendInput('y');
+            case 11:
+              _context16.next = 13;
+              return this.waitForInput();
+            case 13:
+              _testUtils.assert.doesInclude(this.ui.invocations, {
+                command: 'prompt',
+                options: {
+                  type: 'text'
+                }
+              });
+              _context16.next = 16;
+              return this.ui.sendInput("bad-heroku-name");
+            case 16:
+              _context16.next = 18;
+              return this.waitForInput();
+            case 18:
+              _context16.next = 20;
+              return this.ui.sendInput('bad-heroku-name');
+            case 20:
+              _context16.next = 22;
+              return this.waitForInput();
+            case 22:
+              _context16.next = 24;
+              return this.ui.sendInput('good-heroku-name');
+            case 24:
+              _context16.next = 26;
+              return promise;
+            case 26:
+              results = _context16.sent;
+              _testUtils.assert.isFalsy(results.errors);
+            case 28:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function keepsAskingForAppNameUntilAGoodOneIsSelected() {
+        return _keepsAskingForAppNameUntilAGoodOneIsSelected.apply(this, arguments);
+      }
+      return keepsAskingForAppNameUntilAGoodOneIsSelected;
+    }()
+  }, {
+    key: "failsWithPendingChangesToCommit",
+    value: function () {
+      var _failsWithPendingChangesToCommit = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee17() {
+        var results;
+        return _regenerator["default"].wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              _CommandService["default"].fakeCommand('git status', {
+                code: 0,
+                stdout: 'Changes not staged for commit'
+              });
+              _context17.next = 3;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 3:
+              _context17.next = 5;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'pending changes to commit'
+              });
+            case 5:
+              _context17.next = 7;
+              return this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+            case 7:
+              results = _context17.sent;
+              _testUtils.assert.isTruthy(results.errors);
+              _testUtils.errorAssert.assertError(results.errors[0], 'DEPLOY_FAILED', {
+                stage: 'git'
+              });
+            case 10:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function failsWithPendingChangesToCommit() {
+        return _failsWithPendingChangesToCommit.apply(this, arguments);
+      }
+      return failsWithPendingChangesToCommit;
+    }()
+  }, {
+    key: "canDeploySkill",
+    value: function () {
+      var _canDeploySkill = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee18() {
+        var results;
+        return _regenerator["default"].wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              _context18.next = 2;
+              return this.FeatureFixture().installCachedFeatures('deploy');
+            case 2:
+              _context18.next = 4;
+              return this.getSkillFixture().registerCurrentSkill({
+                name: 'can deploy'
+              });
+            case 4:
+              _context18.next = 6;
+              return this.Action('deploy', 'heroku').execute(this.fastHerokuOptions);
+            case 6:
+              results = _context18.sent;
+              _testUtils.assert.isFalsy(results.errors);
+            case 8:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function canDeploySkill() {
+        return _canDeploySkill.apply(this, arguments);
+      }
+      return canDeploySkill;
+    }()
+  }]);
+  return DeployingASkillTest;
+}(_AbstractCliTest2["default"]), (0, _defineProperty2["default"])(_class2, "fastHerokuOptions", {
+  teamName: (_process$env$HEROKU_T4 = process.env.HEROKU_TEAM_NAME) !== null && _process$env$HEROKU_T4 !== void 0 ? _process$env$HEROKU_T4 : '',
+  shouldBuildAndLint: false,
+  shouldRunTests: false
+}), _class2), ((0, _applyDecoratedDescriptor2["default"])(_class, "hasDeployAction", [_dec], Object.getOwnPropertyDescriptor(_class, "hasDeployAction"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "deployHaltedBecauseNotRegistered", [_dec2], Object.getOwnPropertyDescriptor(_class, "deployHaltedBecauseNotRegistered"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "deployHaltedWithBadBuild", [_dec3], Object.getOwnPropertyDescriptor(_class, "deployHaltedWithBadBuild"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "healthCheckReportsNotDeployed", [_dec4], Object.getOwnPropertyDescriptor(_class, "healthCheckReportsNotDeployed"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "deployHaltedWithBadTest", [_dec5], Object.getOwnPropertyDescriptor(_class, "deployHaltedWithBadTest"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "errorsIfHerokuClientNotInstalled", [_dec6], Object.getOwnPropertyDescriptor(_class, "errorsIfHerokuClientNotInstalled"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "errorsIfGitNotInstalled", [_dec7], Object.getOwnPropertyDescriptor(_class, "errorsIfGitNotInstalled"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "errorsIfNotInGitRepo", [_dec8], Object.getOwnPropertyDescriptor(_class, "errorsIfNotInGitRepo"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "canCreateGitRepoIfNeeded", [_dec9], Object.getOwnPropertyDescriptor(_class, "canCreateGitRepoIfNeeded"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "errorsWhenNotLoggedIntoHerkou", [_dec10], Object.getOwnPropertyDescriptor(_class, "errorsWhenNotLoggedIntoHerkou"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "failsWhenDeclineToCreateProcFile", [_dec11], Object.getOwnPropertyDescriptor(_class, "failsWhenDeclineToCreateProcFile"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "createsValidProcFile", [_dec12], Object.getOwnPropertyDescriptor(_class, "createsValidProcFile"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "failsWhenDeclineToCreateRemoteBranch", [_dec13], Object.getOwnPropertyDescriptor(_class, "failsWhenDeclineToCreateRemoteBranch"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "asksForHerokuAppName", [_dec14], Object.getOwnPropertyDescriptor(_class, "asksForHerokuAppName"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "keepsAskingForAppNameUntilAGoodOneIsSelected", [_dec15], Object.getOwnPropertyDescriptor(_class, "keepsAskingForAppNameUntilAGoodOneIsSelected"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "failsWithPendingChangesToCommit", [_dec16], Object.getOwnPropertyDescriptor(_class, "failsWithPendingChangesToCommit"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "canDeploySkill", [_dec17], Object.getOwnPropertyDescriptor(_class, "canDeploySkill"), _class)), _class));
+exports["default"] = DeployingASkillTest;
+//# sourceMappingURL=DeployingASkill.test.js.map