@sprucelabs/spruce-cli 15.2.17 → 15.2.20

package/build/__tests__/behavioral/skill/UpgradingASkill3.test.js

@@ -23,41 +23,43 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 
 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 _fs = _interopRequireDefault(require("fs"));
+var _spruceEventUtils = require("@sprucelabs/spruce-event-utils");
 
 var _spruceSkillUtils = require("@sprucelabs/spruce-skill-utils");
 
 var _test = require("@sprucelabs/test");
 
-var _CommandService = _interopRequireDefault(require("../../../services/CommandService"));
+var _SyncAction = _interopRequireDefault(require("../../../features/error/actions/SyncAction"));
 
-var _AbstractCliTest2 = _interopRequireDefault(require("../../../tests/AbstractCliTest"));
+var _UpdateDependenciesAction = _interopRequireDefault(require("../../../features/node/actions/UpdateDependenciesAction"));
 
-var _dec, _dec2, _dec3, _class;
+var _CommandService = _interopRequireDefault(require("../../../services/CommandService"));
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+var _AbstractCliTest2 = _interopRequireDefault(require("../../../tests/AbstractCliTest"));
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+var _test2 = _interopRequireDefault(require("../../../tests/utilities/test.utility"));
 
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _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 UpgradingASkillTest = (_dec = (0, _test.test)(), _dec2 = (0, _test.test)(), _dec3 = (0, _test.test)(), (_class = /*#__PURE__*/function (_AbstractCliTest) {
-  (0, _inherits2["default"])(UpgradingASkillTest, _AbstractCliTest);
+var UpgradingASkill3Test = (_dec = (0, _test.test)(), _dec2 = (0, _test.test)(), _dec3 = (0, _test.test)(), _dec4 = (0, _test.test)(), _dec5 = (0, _test.test)(), _dec6 = (0, _test.test)(), _dec7 = (0, _test.test)('sync with errors installed'), _dec8 = (0, _test.test)('sync with errors not installed', false), _dec9 = (0, _test.test)(), _dec10 = (0, _test.test)(), (_class = (_class2 = /*#__PURE__*/function (_AbstractCliTest) {
+  (0, _inherits2["default"])(UpgradingASkill3Test, _AbstractCliTest);
 
-  var _super = _createSuper(UpgradingASkillTest);
+  var _super = _createSuper(UpgradingASkill3Test);
 
-  function UpgradingASkillTest() {
-    (0, _classCallCheck2["default"])(this, UpgradingASkillTest);
+  function UpgradingASkill3Test() {
+    (0, _classCallCheck2["default"])(this, UpgradingASkill3Test);
     return _super.apply(this, arguments);
   }
 
-  (0, _createClass2["default"])(UpgradingASkillTest, null, [{
+  (0, _createClass2["default"])(UpgradingASkill3Test, null, [{
     key: "beforeEach",
     value: function () {
       var _beforeEach = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
@@ -65,15 +67,21 @@ var UpgradingASkillTest = (_dec = (0, _test.test)(), _dec2 = (0, _test.test)(),
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                _context.next = 2;
-                return (0, _get2["default"])((0, _getPrototypeOf2["default"])(UpgradingASkillTest), "beforeEach", this).call(this);
+                if (!this.originalErrorSyncExecute) {
+                  this.originalErrorSyncExecute = _SyncAction["default"].prototype.execute;
+                } else {
+                  _SyncAction["default"].prototype.execute = this.originalErrorSyncExecute;
+                }
 
-              case 2:
+                _context.next = 3;
+                return (0, _get2["default"])((0, _getPrototypeOf2["default"])(UpgradingASkill3Test), "beforeEach", this).call(this);
+
+              case 3:
                 _CommandService["default"].setMockResponse(new RegExp(/yarn rebuild/gi), {
                   code: 0
                 });
 
-              case 3:
+              case 4:
               case "end":
                 return _context.stop();
             }
@@ -88,79 +96,29 @@ var UpgradingASkillTest = (_dec = (0, _test.test)(), _dec2 = (0, _test.test)(),
       return beforeEach;
     }()
   }, {
-    key: "restoresMissingPackagesAndPlugins",
+    key: "doesNotAddResolvePathAliasesToDependenciesAfterUpgrade",
     value: function () {
-      var _restoresMissingPackagesAndPlugins = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-        var features, pkg, checks, _iterator, _step, feat, code, nodeModule, path, plugin, _i, _checks, check, _i2, _checks2, _check;
-
+      var _doesNotAddResolvePathAliasesToDependenciesAfterUpgrade = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var dependencies;
         return _regenerator["default"].wrap(function _callee2$(_context2) {
           while (1) {
             switch (_context2.prev = _context2.next) {
               case 0:
-                _context2.next = 2;
-                return this.FeatureFixture().installCachedFeatures('views');
-
-              case 2:
-                features = this.Service('pkg', process.cwd()).get('testSkillCache.everything');
-                pkg = this.Service('pkg');
-                checks = [];
-                _iterator = _createForOfIteratorHelper(features);
-
-                try {
-                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                    feat = _step.value;
-                    code = feat.code;
-                    nodeModule = "@sprucelabs/spruce-".concat(code, "-plugin");
-                    path = this.resolveHashSprucePath('features', "".concat(code, ".plugin.ts"));
-                    plugin = _spruceSkillUtils.diskUtil.doesFileExist(path) ? path : undefined;
-                    checks.push({
-                      nodeModule: pkg.get(['dependencies', nodeModule]) ? nodeModule : undefined,
-                      plugin: plugin
-                    });
-                  }
-                } catch (err) {
-                  _iterator.e(err);
-                } finally {
-                  _iterator.f();
-                }
-
-                for (_i = 0, _checks = checks; _i < _checks.length; _i++) {
-                  check = _checks[_i];
-
-                  if (check.nodeModule) {
-                    pkg.unset(['dependencies', check.nodeModule]);
-                  }
-
-                  if (check.plugin) {
-                    _spruceSkillUtils.diskUtil.deleteFile(check.plugin);
-                  }
-                }
-
-                _CommandService["default"].setMockResponse(/yarn clean/, {
-                  code: 0
-                });
+                _CommandService["default"].clearMockResponses();
 
-                _CommandService["default"].setMockResponse(/yarn build.dev/, {
-                  code: 0
-                });
+                _context2.next = 3;
+                return this.FeatureFixture().installCachedFeatures('views');
 
-                _context2.next = 12;
+              case 3:
+                _context2.next = 5;
                 return this.Action('node', 'upgrade').execute({});
 
-              case 12:
-                for (_i2 = 0, _checks2 = checks; _i2 < _checks2.length; _i2++) {
-                  _check = _checks2[_i2];
-
-                  if (_check.nodeModule) {
-                    _test.assert.isTruthy(pkg.get(['dependencies', _check.nodeModule]), "".concat(_check.nodeModule, " was not added back as a dependencies."));
-                  }
+              case 5:
+                dependencies = this.Service('pkg').get('dependencies');
 
-                  if (_check.plugin) {
-                    _test.assert.isTrue(_spruceSkillUtils.diskUtil.doesFileExist(_check.plugin), "".concat(_check.plugin, " was not rewritten."));
-                  }
-                }
+                _test.assert.isFalsy(dependencies['@sprucelabs/resolve-path-aliases']);
 
-              case 13:
+              case 7:
               case "end":
                 return _context2.stop();
             }
@@ -168,37 +126,41 @@ var UpgradingASkillTest = (_dec = (0, _test.test)(), _dec2 = (0, _test.test)(),
         }, _callee2, this);
       }));
 
-      function restoresMissingPackagesAndPlugins() {
-        return _restoresMissingPackagesAndPlugins.apply(this, arguments);
+      function doesNotAddResolvePathAliasesToDependenciesAfterUpgrade() {
+        return _doesNotAddResolvePathAliasesToDependenciesAfterUpgrade.apply(this, arguments);
       }
 
-      return restoresMissingPackagesAndPlugins;
+      return doesNotAddResolvePathAliasesToDependenciesAfterUpgrade;
     }()
   }, {
-    key: "doesNotAskIfNewScriptsAreAddedToSkillFeature",
+    key: "featuresNotEnabledDontInstall",
     value: function () {
-      var _doesNotAskIfNewScriptsAreAddedToSkillFeature = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
-        var cli, pkg, skillFeature;
+      var _featuresNotEnabledDontInstall = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var results, dependencies;
         return _regenerator["default"].wrap(function _callee3$(_context3) {
           while (1) {
             switch (_context3.prev = _context3.next) {
               case 0:
-                _context3.next = 2;
-                return this.FeatureFixture().installCachedFeatures('skills');
+                _CommandService["default"].clearMockResponses();
 
-              case 2:
-                cli = _context3.sent;
-                pkg = this.Service('pkg');
-                skillFeature = cli.getFeature('skill'); //@ts-ignore
+                _context3.next = 3;
+                return this.FeatureFixture().installCachedFeatures('schemas');
 
-                skillFeature.scripts['taco'] = 'bravo';
-                _context3.next = 8;
+              case 3:
+                _context3.next = 5;
                 return this.Action('node', 'upgrade').execute({});
 
-              case 8:
-                _test.assert.isEqual(pkg.get(['scripts', 'taco']), 'bravo');
+              case 5:
+                results = _context3.sent;
+                dependencies = this.Service('pkg').get('dependencies');
+
+                _test.assert.isFalsy(dependencies['@sprucelabs/resolve-path-aliases']);
 
-                this.assertSandboxListenerNotWritten();
+                _test.assert.doesThrow(function () {
+                  return _test2["default"].assertFileByNameInGeneratedFiles('events.contract.ts', results.files);
+                });
+
+                this.assertViewPluginNotWritten();
 
               case 10:
               case "end":
@@ -208,92 +170,405 @@ var UpgradingASkillTest = (_dec = (0, _test.test)(), _dec2 = (0, _test.test)(),
         }, _callee3, this);
       }));
 
-      function doesNotAskIfNewScriptsAreAddedToSkillFeature() {
-        return _doesNotAskIfNewScriptsAreAddedToSkillFeature.apply(this, arguments);
+      function featuresNotEnabledDontInstall() {
+        return _featuresNotEnabledDontInstall.apply(this, arguments);
       }
 
-      return doesNotAskIfNewScriptsAreAddedToSkillFeature;
+      return featuresNotEnabledDontInstall;
     }()
   }, {
-    key: "canOverwriteMultipleChangedScript",
+    key: "upgradingSkillSyncsEvents",
     value: function () {
-      var _canOverwriteMultipleChangedScript = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
-        var pkg, promise, last;
+      var _upgradingSkillSyncsEvents = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var results, events;
         return _regenerator["default"].wrap(function _callee4$(_context4) {
           while (1) {
             switch (_context4.prev = _context4.next) {
               case 0:
                 _context4.next = 2;
+                return this.FeatureFixture().installCachedFeatures('events');
+
+              case 2:
+                _context4.next = 4;
+                return this.Action('node', 'upgrade').execute({});
+
+              case 4:
+                results = _context4.sent;
+                events = _spruceEventUtils.eventDiskUtil.resolveCombinedEventsContractFile(this.cwd);
+
+                _test.assert.isTrue(_spruceSkillUtils.diskUtil.doesFileExist(events));
+
+                _test2["default"].assertFileByNameInGeneratedFiles('events.contract.ts', results.files);
+
+              case 8:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function upgradingSkillSyncsEvents() {
+        return _upgradingSkillSyncsEvents.apply(this, arguments);
+      }
+
+      return upgradingSkillSyncsEvents;
+    }()
+  }, {
+    key: "upgradeCallsUpdateDependencies",
+    value: function () {
+      var _upgradeCallsUpdateDependencies = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        var results;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this.FeatureFixture().installCachedFeatures('skills');
+
+              case 2:
+                _UpdateDependenciesAction["default"].prototype.execute = function () {
+                  throw new Error('baaaaad');
+                };
+
+                _context5.next = 5;
+                return this.Action('node', 'upgrade').execute({});
+
+              case 5:
+                results = _context5.sent;
+
+                _test.assert.isTruthy(results.errors);
+
+                _test.assert.doesInclude(results.errors[0].message, 'baaaaad');
+
+              case 8:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function upgradeCallsUpdateDependencies() {
+        return _upgradeCallsUpdateDependencies.apply(this, arguments);
+      }
+
+      return upgradeCallsUpdateDependencies;
+    }()
+  }, {
+    key: "callsCleanFixAndBuildDev",
+    value: function () {
+      var _callsCleanFixAndBuildDev = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+        var wasCleanBuildCalled, wasBuildDevCalled, results;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _context7.next = 2;
                 return this.FeatureFixture().installCachedFeatures('skills');
 
               case 2:
-                pkg = this.Service('pkg');
-                pkg.set({
-                  path: ['scripts', 'build.dev'],
-                  value: 'taco'
+                wasCleanBuildCalled = false;
+                _UpdateDependenciesAction["default"].prototype.execute = /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+                  return _regenerator["default"].wrap(function _callee6$(_context6) {
+                    while (1) {
+                      switch (_context6.prev = _context6.next) {
+                        case 0:
+                          return _context6.abrupt("return", {});
+
+                        case 1:
+                        case "end":
+                          return _context6.stop();
+                      }
+                    }
+                  }, _callee6);
+                }));
+
+                _CommandService["default"].setMockResponse('yarn clean.build', {
+                  code: 0,
+                  callback: function callback() {
+                    wasCleanBuildCalled = true;
+                  }
                 });
-                pkg.set({
-                  path: ['scripts', 'watch.build.dev'],
-                  value: 'taco'
+
+                wasBuildDevCalled = false;
+
+                _CommandService["default"].setMockResponse('yarn build.dev', {
+                  code: 0,
+                  callback: function callback() {
+                    wasBuildDevCalled = true;
+                  }
                 });
-                promise = this.Action('node', 'upgrade').execute({});
-                _context4.next = 8;
-                return this.waitForInput();
+
+                _context7.next = 9;
+                return this.Action('node', 'upgrade').execute({});
+
+              case 9:
+                results = _context7.sent;
+
+                _test.assert.isFalsy(results.errors);
+
+                _test.assert.isTrue(wasCleanBuildCalled);
+
+                _test.assert.isTrue(wasBuildDevCalled);
+
+              case 13:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+
+      function callsCleanFixAndBuildDev() {
+        return _callsCleanFixAndBuildDev.apply(this, arguments);
+      }
+
+      return callsCleanFixAndBuildDev;
+    }()
+  }, {
+    key: "writesViewPlugin",
+    value: function () {
+      var _writesViewPlugin = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+        var plugin;
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _context8.next = 2;
+                return this.FeatureFixture().installCachedFeatures('views');
+
+              case 2:
+                plugin = this.getViewsPluginPath();
+
+                _test.assert.isTrue(_spruceSkillUtils.diskUtil.doesFileExist(plugin));
+
+                _spruceSkillUtils.diskUtil.deleteFile(plugin);
+
+                _test.assert.isFalse(_spruceSkillUtils.diskUtil.doesFileExist(plugin));
+
+                _context8.next = 8;
+                return this.Action('node', 'upgrade').execute({});
+
+              case 8:
+                _test.assert.isTrue(_spruceSkillUtils.diskUtil.doesFileExist(plugin));
+
+              case 9:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function writesViewPlugin() {
+        return _writesViewPlugin.apply(this, arguments);
+      }
+
+      return writesViewPlugin;
+    }()
+  }, {
+    key: "upgradeSyncsErrors",
+    value: function () {
+      var _upgradeSyncsErrors = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+        var isInstalled,
+            wasHit,
+            _args10 = arguments;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                isInstalled = _args10.length > 0 && _args10[0] !== undefined ? _args10[0] : true;
+                _context10.next = 3;
+                return this.FeatureFixture().installCachedFeatures(isInstalled ? 'errors' : 'schemas');
+
+              case 3:
+                wasHit = false;
+                _SyncAction["default"].prototype.execute = /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+                  return _regenerator["default"].wrap(function _callee9$(_context9) {
+                    while (1) {
+                      switch (_context9.prev = _context9.next) {
+                        case 0:
+                          wasHit = true;
+                          return _context9.abrupt("return", {});
+
+                        case 2:
+                        case "end":
+                          return _context9.stop();
+                      }
+                    }
+                  }, _callee9);
+                }));
+                this.disableCleanBuildAndYarnAdd();
+                _context10.next = 8;
+                return this.Action('node', 'upgrade').execute({});
 
               case 8:
-                last = this.ui.getLastInvocation();
+                _test.assert.isEqual(wasHit, isInstalled);
 
-                _test.assert.isEqual(last.command, 'prompt');
+              case 9:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this);
+      }));
 
-                _context4.next = 12;
-                return this.ui.sendInput('overwrite');
+      function upgradeSyncsErrors() {
+        return _upgradeSyncsErrors.apply(this, arguments);
+      }
 
-              case 12:
-                last = this.ui.getLastInvocation();
+      return upgradeSyncsErrors;
+    }()
+  }, {
+    key: "resetsErrorPluginInSkill",
+    value: function () {
+      var _resetsErrorPluginInSkill = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+        var _this$destroyErrorPlu, plugin, expectedContents, promise, actualContents;
+
+        return _regenerator["default"].wrap(function _callee11$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                _context11.next = 2;
+                return this.FeatureFixture().installCachedFeatures('skills');
 
-                _test.assert.isEqual(last.command, 'prompt');
+              case 2:
+                _this$destroyErrorPlu = this.destroyErrorPlugin(), plugin = _this$destroyErrorPlu.plugin, expectedContents = _this$destroyErrorPlu.expectedContents;
+                _context11.next = 5;
+                return this.disableCleanBuildAndYarnAdd();
+
+              case 5:
+                promise = this.Action('node', 'upgrade').execute({
+                  upgradeMode: 'askForChanged'
+                });
+                _context11.next = 8;
+                return this.waitForInput();
 
-                _context4.next = 16;
+              case 8:
+                _context11.next = 10;
                 return this.ui.sendInput('overwrite');
 
-              case 16:
-                _context4.next = 18;
+              case 10:
+                _context11.next = 12;
                 return promise;
 
-              case 18:
-                _test.assert.isNotEqual(pkg.get(['scripts', 'build.dev']), 'taco');
+              case 12:
+                actualContents = _spruceSkillUtils.diskUtil.readFile(plugin);
 
-                _test.assert.isNotEqual(pkg.get(['scripts', 'watch.build.dev']), 'taco');
+                _test.assert.isEqual(actualContents, expectedContents);
 
-              case 20:
+              case 14:
               case "end":
-                return _context4.stop();
+                return _context11.stop();
             }
           }
-        }, _callee4, this);
+        }, _callee11, this);
       }));
 
-      function canOverwriteMultipleChangedScript() {
-        return _canOverwriteMultipleChangedScript.apply(this, arguments);
+      function resetsErrorPluginInSkill() {
+        return _resetsErrorPluginInSkill.apply(this, arguments);
       }
 
-      return canOverwriteMultipleChangedScript;
+      return resetsErrorPluginInSkill;
     }()
   }, {
-    key: "assertSandboxListenerNotWritten",
-    value: function assertSandboxListenerNotWritten() {
-      var listeners = this.resolvePath('src', 'listeners');
+    key: "resetsErrorPluginWhenErrorInstalled",
+    value: function () {
+      var _resetsErrorPluginWhenErrorInstalled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+        var _this$destroyErrorPlu2, plugin, expectedContents, results, actualContents;
+
+        return _regenerator["default"].wrap(function _callee12$(_context12) {
+          while (1) {
+            switch (_context12.prev = _context12.next) {
+              case 0:
+                _context12.next = 2;
+                return this.FeatureFixture().installCachedFeatures('errors');
+
+              case 2:
+                _context12.next = 4;
+                return this.Action('error', 'create').execute({
+                  nameReadable: 'Test pass',
+                  nameCamel: 'testPass'
+                });
+
+              case 4:
+                _this$destroyErrorPlu2 = this.destroyErrorPlugin(), plugin = _this$destroyErrorPlu2.plugin, expectedContents = _this$destroyErrorPlu2.expectedContents;
+                this.disableCleanAndBuild();
+                _context12.next = 8;
+                return this.Action('node', 'upgrade').execute({
+                  upgradeMode: 'askForChanged'
+                });
 
-      if (!_spruceSkillUtils.diskUtil.doesDirExist(listeners)) {
-        return;
+              case 8:
+                results = _context12.sent;
+
+                _test.assert.isFalsy(results.errors);
+
+                actualContents = _spruceSkillUtils.diskUtil.readFile(plugin);
+
+                _test.assert.isEqual(actualContents, expectedContents);
+
+              case 12:
+              case "end":
+                return _context12.stop();
+            }
+          }
+        }, _callee12, this);
+      }));
+
+      function resetsErrorPluginWhenErrorInstalled() {
+        return _resetsErrorPluginWhenErrorInstalled.apply(this, arguments);
       }
 
-      var matches = _fs["default"].readdirSync(listeners);
+      return resetsErrorPluginWhenErrorInstalled;
+    }()
+  }, {
+    key: "destroyErrorPlugin",
+    value: function destroyErrorPlugin() {
+      var plugin = this.resolveHashSprucePath('errors', 'options.types.ts');
+
+      var expectedContents = _spruceSkillUtils.diskUtil.readFile(plugin);
+
+      _spruceSkillUtils.diskUtil.writeFile(plugin, 'waka');
+
+      return {
+        plugin: plugin,
+        expectedContents: expectedContents
+      };
+    }
+  }, {
+    key: "getViewsPluginPath",
+    value: function getViewsPluginPath() {
+      return this.resolveHashSprucePath('features', 'view.plugin.ts');
+    }
+  }, {
+    key: "assertViewPluginNotWritten",
+    value: function assertViewPluginNotWritten() {
+      _test.assert.isFalse(_spruceSkillUtils.diskUtil.doesFileExist(this.getViewsPluginPath()));
+    }
+  }, {
+    key: "disableCleanBuildAndYarnAdd",
+    value: function disableCleanBuildAndYarnAdd() {
+      this.disableCleanAndBuild();
 
-      _test.assert.isLength(matches, 0, 'A sandbox listeners was written and it should not have been.');
+      _CommandService["default"].setMockResponse(/yarn[\s\S]*?add/gi, {
+        code: 0
+      });
+    }
+  }, {
+    key: "disableCleanAndBuild",
+    value: function disableCleanAndBuild() {
+      _CommandService["default"].setMockResponse('yarn clean.build', {
+        code: 0
+      });
+
+      _CommandService["default"].setMockResponse('yarn build.dev', {
+        code: 0
+      });
     }
   }]);
-  return UpgradingASkillTest;
-}(_AbstractCliTest2["default"]), ((0, _applyDecoratedDescriptor2["default"])(_class, "restoresMissingPackagesAndPlugins", [_dec], Object.getOwnPropertyDescriptor(_class, "restoresMissingPackagesAndPlugins"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "doesNotAskIfNewScriptsAreAddedToSkillFeature", [_dec2], Object.getOwnPropertyDescriptor(_class, "doesNotAskIfNewScriptsAreAddedToSkillFeature"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "canOverwriteMultipleChangedScript", [_dec3], Object.getOwnPropertyDescriptor(_class, "canOverwriteMultipleChangedScript"), _class)), _class));
-exports["default"] = UpgradingASkillTest;
+  return UpgradingASkill3Test;
+}(_AbstractCliTest2["default"]), (0, _defineProperty2["default"])(_class2, "originalErrorSyncExecute", void 0), _class2), ((0, _applyDecoratedDescriptor2["default"])(_class, "doesNotAddResolvePathAliasesToDependenciesAfterUpgrade", [_dec], Object.getOwnPropertyDescriptor(_class, "doesNotAddResolvePathAliasesToDependenciesAfterUpgrade"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "featuresNotEnabledDontInstall", [_dec2], Object.getOwnPropertyDescriptor(_class, "featuresNotEnabledDontInstall"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "upgradingSkillSyncsEvents", [_dec3], Object.getOwnPropertyDescriptor(_class, "upgradingSkillSyncsEvents"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "upgradeCallsUpdateDependencies", [_dec4], Object.getOwnPropertyDescriptor(_class, "upgradeCallsUpdateDependencies"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "callsCleanFixAndBuildDev", [_dec5], Object.getOwnPropertyDescriptor(_class, "callsCleanFixAndBuildDev"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "writesViewPlugin", [_dec6], Object.getOwnPropertyDescriptor(_class, "writesViewPlugin"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "upgradeSyncsErrors", [_dec7, _dec8], Object.getOwnPropertyDescriptor(_class, "upgradeSyncsErrors"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "resetsErrorPluginInSkill", [_dec9], Object.getOwnPropertyDescriptor(_class, "resetsErrorPluginInSkill"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "resetsErrorPluginWhenErrorInstalled", [_dec10], Object.getOwnPropertyDescriptor(_class, "resetsErrorPluginWhenErrorInstalled"), _class)), _class));
+exports["default"] = UpgradingASkill3Test;
 //# sourceMappingURL=UpgradingASkill3.test.js.map