Added node_modules for the updating to work properly.

1 files changed, 716 insertions, 0 deletions

diff --git a/node_modules/jest-jasmine2/build/jasmine/Env.js b/node_modules/jest-jasmine2/build/jasmine/Env.js
new file mode 100644
index 0000000..382c9c2
--- /dev/null
+++ b/node_modules/jest-jasmine2/build/jasmine/Env.js
@@ -0,0 +1,716 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = jasmineEnv;
+
+var _assert = require('assert');
+
+var _jestUtil = require('jest-util');
+
+var _assertionErrorMessage = _interopRequireDefault(
+  require('../assertionErrorMessage')
+);
+
+var _isError = _interopRequireDefault(require('../isError'));
+
+var _queueRunner = _interopRequireDefault(require('../queueRunner'));
+
+var _treeProcessor = _interopRequireDefault(require('../treeProcessor'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function jasmineEnv(j$) {
+  return class Env {
+    constructor() {
+      _defineProperty(this, 'specFilter', void 0);
+
+      _defineProperty(this, 'catchExceptions', void 0);
+
+      _defineProperty(this, 'throwOnExpectationFailure', void 0);
+
+      _defineProperty(this, 'catchingExceptions', void 0);
+
+      _defineProperty(this, 'topSuite', void 0);
+
+      _defineProperty(this, 'fail', void 0);
+
+      _defineProperty(this, 'pending', void 0);
+
+      _defineProperty(this, 'afterAll', void 0);
+
+      _defineProperty(this, 'fit', void 0);
+
+      _defineProperty(this, 'throwingExpectationFailures', void 0);
+
+      _defineProperty(this, 'randomizeTests', void 0);
+
+      _defineProperty(this, 'randomTests', void 0);
+
+      _defineProperty(this, 'seed', void 0);
+
+      _defineProperty(this, 'execute', void 0);
+
+      _defineProperty(this, 'fdescribe', void 0);
+
+      _defineProperty(this, 'spyOn', void 0);
+
+      _defineProperty(this, 'beforeEach', void 0);
+
+      _defineProperty(this, 'afterEach', void 0);
+
+      _defineProperty(this, 'clearReporters', void 0);
+
+      _defineProperty(this, 'addReporter', void 0);
+
+      _defineProperty(this, 'it', void 0);
+
+      _defineProperty(this, 'xdescribe', void 0);
+
+      _defineProperty(this, 'xit', void 0);
+
+      _defineProperty(this, 'beforeAll', void 0);
+
+      _defineProperty(this, 'todo', void 0);
+
+      _defineProperty(this, 'provideFallbackReporter', void 0);
+
+      _defineProperty(this, 'allowRespy', void 0);
+
+      _defineProperty(this, 'describe', void 0);
+
+      let totalSpecsDefined = 0;
+      let catchExceptions = true;
+      const realSetTimeout = global.setTimeout;
+      const realClearTimeout = global.clearTimeout;
+      const runnableResources = {};
+      const currentlyExecutingSuites = [];
+      let currentSpec = null;
+      let throwOnExpectationFailure = false;
+      let random = false;
+      let seed = null;
+      let nextSpecId = 0;
+      let nextSuiteId = 0;
+
+      const getNextSpecId = function () {
+        return 'spec' + nextSpecId++;
+      };
+
+      const getNextSuiteId = function () {
+        return 'suite' + nextSuiteId++;
+      };
+
+      const topSuite = new j$.Suite({
+        id: getNextSuiteId(),
+        description: '',
+
+        getTestPath() {
+          return j$.testPath;
+        }
+      });
+      let currentDeclarationSuite = topSuite;
+
+      const currentSuite = function () {
+        return currentlyExecutingSuites[currentlyExecutingSuites.length - 1];
+      };
+
+      const currentRunnable = function () {
+        return currentSpec || currentSuite();
+      };
+
+      const reporter = new j$.ReportDispatcher([
+        'jasmineStarted',
+        'jasmineDone',
+        'suiteStarted',
+        'suiteDone',
+        'specStarted',
+        'specDone'
+      ]);
+
+      this.specFilter = function () {
+        return true;
+      };
+
+      const defaultResourcesForRunnable = function (id, _parentRunnableId) {
+        const resources = {
+          spies: []
+        };
+        runnableResources[id] = resources;
+      };
+
+      const clearResourcesForRunnable = function (id) {
+        spyRegistry.clearSpies();
+        delete runnableResources[id];
+      };
+
+      const beforeAndAfterFns = function (suite) {
+        return function () {
+          let afters = [];
+          let befores = [];
+
+          while (suite) {
+            befores = befores.concat(suite.beforeFns);
+            afters = afters.concat(suite.afterFns);
+            suite = suite.parentSuite;
+          }
+
+          return {
+            befores: befores.reverse(),
+            afters
+          };
+        };
+      };
+
+      const getSpecName = function (spec, suite) {
+        const fullName = [spec.description];
+        const suiteFullName = suite.getFullName();
+
+        if (suiteFullName !== '') {
+          fullName.unshift(suiteFullName);
+        }
+
+        return fullName.join(' ');
+      };
+
+      this.catchExceptions = function (value) {
+        catchExceptions = !!value;
+        return catchExceptions;
+      };
+
+      this.catchingExceptions = function () {
+        return catchExceptions;
+      };
+
+      this.throwOnExpectationFailure = function (value) {
+        throwOnExpectationFailure = !!value;
+      };
+
+      this.throwingExpectationFailures = function () {
+        return throwOnExpectationFailure;
+      };
+
+      this.randomizeTests = function (value) {
+        random = !!value;
+      };
+
+      this.randomTests = function () {
+        return random;
+      };
+
+      this.seed = function (value) {
+        if (value) {
+          seed = value;
+        }
+
+        return seed;
+      };
+
+      const queueRunnerFactory = options => {
+        options.clearTimeout = realClearTimeout;
+        options.fail = this.fail;
+        options.setTimeout = realSetTimeout;
+        return (0, _queueRunner.default)(options);
+      };
+
+      this.topSuite = function () {
+        return topSuite;
+      };
+
+      const uncaught = err => {
+        if (currentSpec) {
+          currentSpec.onException(err);
+          currentSpec.cancel();
+        } else {
+          console.error('Unhandled error');
+          console.error(err.stack);
+        }
+      };
+
+      let oldListenersException;
+      let oldListenersRejection;
+
+      const executionSetup = function () {
+        // Need to ensure we are the only ones handling these exceptions.
+        oldListenersException = process.listeners('uncaughtException').slice();
+        oldListenersRejection = process.listeners('unhandledRejection').slice();
+        j$.process.removeAllListeners('uncaughtException');
+        j$.process.removeAllListeners('unhandledRejection');
+        j$.process.on('uncaughtException', uncaught);
+        j$.process.on('unhandledRejection', uncaught);
+      };
+
+      const executionTeardown = function () {
+        j$.process.removeListener('uncaughtException', uncaught);
+        j$.process.removeListener('unhandledRejection', uncaught); // restore previous exception handlers
+
+        oldListenersException.forEach(listener => {
+          j$.process.on('uncaughtException', listener);
+        });
+        oldListenersRejection.forEach(listener => {
+          j$.process.on('unhandledRejection', listener);
+        });
+      };
+
+      this.execute = async function (runnablesToRun, suiteTree = topSuite) {
+        if (!runnablesToRun) {
+          if (focusedRunnables.length) {
+            runnablesToRun = focusedRunnables;
+          } else {
+            runnablesToRun = [suiteTree.id];
+          }
+        }
+
+        if (currentlyExecutingSuites.length === 0) {
+          executionSetup();
+        }
+
+        const lastDeclarationSuite = currentDeclarationSuite;
+        await (0, _treeProcessor.default)({
+          nodeComplete(suite) {
+            if (!suite.disabled) {
+              clearResourcesForRunnable(suite.id);
+            }
+
+            currentlyExecutingSuites.pop();
+
+            if (suite === topSuite) {
+              reporter.jasmineDone({
+                failedExpectations: topSuite.result.failedExpectations
+              });
+            } else {
+              reporter.suiteDone(suite.getResult());
+            }
+          },
+
+          nodeStart(suite) {
+            currentlyExecutingSuites.push(suite);
+            defaultResourcesForRunnable(
+              suite.id,
+              suite.parentSuite && suite.parentSuite.id
+            );
+
+            if (suite === topSuite) {
+              reporter.jasmineStarted({
+                totalSpecsDefined
+              });
+            } else {
+              reporter.suiteStarted(suite.result);
+            }
+          },
+
+          queueRunnerFactory,
+          runnableIds: runnablesToRun,
+          tree: suiteTree
+        });
+        currentDeclarationSuite = lastDeclarationSuite;
+
+        if (currentlyExecutingSuites.length === 0) {
+          executionTeardown();
+        }
+      };
+
+      this.addReporter = function (reporterToAdd) {
+        reporter.addReporter(reporterToAdd);
+      };
+
+      this.provideFallbackReporter = function (reporterToAdd) {
+        reporter.provideFallbackReporter(reporterToAdd);
+      };
+
+      this.clearReporters = function () {
+        reporter.clearReporters();
+      };
+
+      const spyRegistry = new j$.SpyRegistry({
+        currentSpies() {
+          if (!currentRunnable()) {
+            throw new Error(
+              'Spies must be created in a before function or a spec'
+            );
+          }
+
+          return runnableResources[currentRunnable().id].spies;
+        }
+      });
+
+      this.allowRespy = function (allow) {
+        spyRegistry.allowRespy(allow);
+      };
+
+      this.spyOn = function (...args) {
+        return spyRegistry.spyOn.apply(spyRegistry, args);
+      };
+
+      const suiteFactory = function (description) {
+        const suite = new j$.Suite({
+          id: getNextSuiteId(),
+          description,
+          parentSuite: currentDeclarationSuite,
+          throwOnExpectationFailure,
+
+          getTestPath() {
+            return j$.testPath;
+          }
+        });
+        return suite;
+      };
+
+      this.describe = function (description, specDefinitions) {
+        const suite = suiteFactory(description);
+
+        if (specDefinitions === undefined) {
+          throw new Error(
+            'Missing second argument. It must be a callback function.'
+          );
+        }
+
+        if (typeof specDefinitions !== 'function') {
+          throw new Error(
+            `Invalid second argument, ${specDefinitions}. It must be a callback function.`
+          );
+        }
+
+        if (specDefinitions.length > 0) {
+          throw new Error('describe does not expect any arguments');
+        }
+
+        if (currentDeclarationSuite.markedPending) {
+          suite.pend();
+        }
+
+        if (currentDeclarationSuite.markedTodo) {
+          // @ts-expect-error TODO Possible error: Suite does not have todo method
+          suite.todo();
+        }
+
+        addSpecsToSuite(suite, specDefinitions);
+        return suite;
+      };
+
+      this.xdescribe = function (description, specDefinitions) {
+        const suite = suiteFactory(description);
+        suite.pend();
+        addSpecsToSuite(suite, specDefinitions);
+        return suite;
+      };
+
+      const focusedRunnables = [];
+
+      this.fdescribe = function (description, specDefinitions) {
+        const suite = suiteFactory(description);
+        suite.isFocused = true;
+        focusedRunnables.push(suite.id);
+        unfocusAncestor();
+        addSpecsToSuite(suite, specDefinitions);
+        return suite;
+      };
+
+      const addSpecsToSuite = (suite, specDefinitions) => {
+        const parentSuite = currentDeclarationSuite;
+        parentSuite.addChild(suite);
+        currentDeclarationSuite = suite;
+        let declarationError = undefined;
+        let describeReturnValue;
+
+        try {
+          describeReturnValue = specDefinitions.call(suite);
+        } catch (e) {
+          declarationError = e;
+        }
+
+        if ((0, _jestUtil.isPromise)(describeReturnValue)) {
+          declarationError = new Error(
+            'Returning a Promise from "describe" is not supported. Tests must be defined synchronously.'
+          );
+        } else if (describeReturnValue !== undefined) {
+          declarationError = new Error(
+            'A "describe" callback must not return a value.'
+          );
+        }
+
+        if (declarationError) {
+          this.it('encountered a declaration exception', () => {
+            throw declarationError;
+          });
+        }
+
+        currentDeclarationSuite = parentSuite;
+      };
+
+      function findFocusedAncestor(suite) {
+        while (suite) {
+          if (suite.isFocused) {
+            return suite.id;
+          }
+
+          suite = suite.parentSuite;
+        }
+
+        return null;
+      }
+
+      function unfocusAncestor() {
+        const focusedAncestor = findFocusedAncestor(currentDeclarationSuite);
+
+        if (focusedAncestor) {
+          for (let i = 0; i < focusedRunnables.length; i++) {
+            if (focusedRunnables[i] === focusedAncestor) {
+              focusedRunnables.splice(i, 1);
+              break;
+            }
+          }
+        }
+      }
+
+      const specFactory = (description, fn, suite, timeout) => {
+        totalSpecsDefined++;
+        const spec = new j$.Spec({
+          id: getNextSpecId(),
+          beforeAndAfterFns: beforeAndAfterFns(suite),
+          resultCallback: specResultCallback,
+
+          getSpecName(spec) {
+            return getSpecName(spec, suite);
+          },
+
+          getTestPath() {
+            return j$.testPath;
+          },
+
+          onStart: specStarted,
+          description,
+          queueRunnerFactory,
+
+          userContext() {
+            return suite.clonedSharedUserContext();
+          },
+
+          queueableFn: {
+            fn,
+
+            timeout() {
+              return timeout || j$._DEFAULT_TIMEOUT_INTERVAL;
+            }
+          },
+          throwOnExpectationFailure
+        });
+
+        if (!this.specFilter(spec)) {
+          spec.disable();
+        }
+
+        return spec;
+
+        function specResultCallback(result) {
+          clearResourcesForRunnable(spec.id);
+          currentSpec = null;
+          reporter.specDone(result);
+        }
+
+        function specStarted(spec) {
+          currentSpec = spec;
+          defaultResourcesForRunnable(spec.id, suite.id);
+          reporter.specStarted(spec.result);
+        }
+      };
+
+      this.it = function (description, fn, timeout) {
+        if (typeof description !== 'string') {
+          throw new Error(
+            `Invalid first argument, ${description}. It must be a string.`
+          );
+        }
+
+        if (fn === undefined) {
+          throw new Error(
+            'Missing second argument. It must be a callback function. Perhaps you want to use `test.todo` for a test placeholder.'
+          );
+        }
+
+        if (typeof fn !== 'function') {
+          throw new Error(
+            `Invalid second argument, ${fn}. It must be a callback function.`
+          );
+        }
+
+        const spec = specFactory(
+          description,
+          fn,
+          currentDeclarationSuite,
+          timeout
+        );
+
+        if (currentDeclarationSuite.markedPending) {
+          spec.pend();
+        } // When a test is defined inside another, jasmine will not run it.
+        // This check throws an error to warn the user about the edge-case.
+
+        if (currentSpec !== null) {
+          throw new Error(
+            `Tests cannot be nested. Test "${spec.description}" cannot run because it is nested within "${currentSpec.description}".`
+          );
+        }
+
+        currentDeclarationSuite.addChild(spec);
+        return spec;
+      };
+
+      this.xit = function (...args) {
+        const spec = this.it.apply(this, args);
+        spec.pend('Temporarily disabled with xit');
+        return spec;
+      };
+
+      this.todo = function () {
+        const description = arguments[0];
+
+        if (arguments.length !== 1 || typeof description !== 'string') {
+          throw new _jestUtil.ErrorWithStack(
+            'Todo must be called with only a description.',
+            this.todo
+          );
+        }
+
+        const spec = specFactory(
+          description,
+          () => {},
+          currentDeclarationSuite
+        );
+
+        if (currentDeclarationSuite.markedPending) {
+          spec.pend();
+        } else {
+          spec.todo();
+        }
+
+        currentDeclarationSuite.addChild(spec);
+        return spec;
+      };
+
+      this.fit = function (description, fn, timeout) {
+        const spec = specFactory(
+          description,
+          fn,
+          currentDeclarationSuite,
+          timeout
+        );
+        currentDeclarationSuite.addChild(spec);
+
+        if (currentDeclarationSuite.markedPending) {
+          spec.pend();
+        } else {
+          focusedRunnables.push(spec.id);
+        }
+
+        unfocusAncestor();
+        return spec;
+      };
+
+      this.beforeEach = function (beforeEachFunction, timeout) {
+        currentDeclarationSuite.beforeEach({
+          fn: beforeEachFunction,
+
+          timeout() {
+            return timeout || j$._DEFAULT_TIMEOUT_INTERVAL;
+          }
+        });
+      };
+
+      this.beforeAll = function (beforeAllFunction, timeout) {
+        currentDeclarationSuite.beforeAll({
+          fn: beforeAllFunction,
+
+          timeout() {
+            return timeout || j$._DEFAULT_TIMEOUT_INTERVAL;
+          }
+        });
+      };
+
+      this.afterEach = function (afterEachFunction, timeout) {
+        currentDeclarationSuite.afterEach({
+          fn: afterEachFunction,
+
+          timeout() {
+            return timeout || j$._DEFAULT_TIMEOUT_INTERVAL;
+          }
+        });
+      };
+
+      this.afterAll = function (afterAllFunction, timeout) {
+        currentDeclarationSuite.afterAll({
+          fn: afterAllFunction,
+
+          timeout() {
+            return timeout || j$._DEFAULT_TIMEOUT_INTERVAL;
+          }
+        });
+      };
+
+      this.pending = function (message) {
+        let fullMessage = j$.Spec.pendingSpecExceptionMessage;
+
+        if (message) {
+          fullMessage += message;
+        }
+
+        throw fullMessage;
+      };
+
+      this.fail = function (error) {
+        let checkIsError;
+        let message;
+
+        if (
+          error instanceof _assert.AssertionError ||
+          (error && error.name === _assert.AssertionError.name)
+        ) {
+          checkIsError = false; // @ts-expect-error TODO Possible error: j$.Spec does not have expand property
+
+          message = (0, _assertionErrorMessage.default)(error, {
+            expand: j$.Spec.expand
+          });
+        } else {
+          const check = (0, _isError.default)(error);
+          checkIsError = check.isError;
+          message = check.message;
+        }
+
+        const errorAsErrorObject = checkIsError ? error : new Error(message);
+        const runnable = currentRunnable();
+
+        if (!runnable) {
+          errorAsErrorObject.message =
+            'Caught error after test environment was torn down\n\n' +
+            errorAsErrorObject.message;
+          throw errorAsErrorObject;
+        }
+
+        runnable.addExpectationResult(false, {
+          matcherName: '',
+          passed: false,
+          expected: '',
+          actual: '',
+          message,
+          error: errorAsErrorObject
+        });
+      };
+    }
+  };
+}