@mindhive/di/dist/mockAppContext.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.resetAppContext = undefined;

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _appContext = require('./appContext');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var recursiveDepth = 0;

/*
Add to appContext for testFunc and clean it up at the end

Arguments are: ([contextGeneratingFunc | contextObj], testFunc)

Most commonly generate the context using a function. It can either return the context object
directly or use initModules internally.

Note: this can't be called wrapping a 'describe' function. It only works on 'it'.
 */

var resetAppContext = exports.resetAppContext = function resetAppContext() {
  Object.keys(_appContext.appContext).forEach(function (key) {
    delete _appContext.appContext[key];
  });
};

exports.default = function () {
  for (var _len = arguments.length, contextAndFunc = Array(_len), _key = 0; _key < _len; _key++) {
    contextAndFunc[_key] = arguments[_key];
  }

  return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
    var existingKeys, _ref2, _ref3, contextObjOrFunc, testFunc, originalAppContext, context;

    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(recursiveDepth === 0)) {
              _context.next = 5;
              break;
            }

            existingKeys = Object.keys(_appContext.appContext);

            if (!existingKeys.length) {
              _context.next = 5;
              break;
            }

            resetAppContext();
            throw new Error('appContext appears to have objects leftover from a previous test: ' + existingKeys + '\n' + 'Did you forget to use mockAppContext() around code that modified the context?');

          case 5:
            _ref2 = contextAndFunc.length <= 1 ? [{}].concat(contextAndFunc) : contextAndFunc, _ref3 = (0, _slicedToArray3.default)(_ref2, 2), contextObjOrFunc = _ref3[0], testFunc = _ref3[1];
            originalAppContext = (0, _extends3.default)({}, _appContext.appContext);

            recursiveDepth += 1;
            _context.prev = 8;

            if (!(typeof contextObjOrFunc === 'function')) {
              _context.next = 15;
              break;
            }

            _context.next = 12;
            return contextObjOrFunc();

          case 12:
            _context.t0 = _context.sent;
            _context.next = 16;
            break;

          case 15:
            _context.t0 = contextObjOrFunc;

          case 16:
            context = _context.t0;

            if (context) {
              Object.assign(_appContext.appContext, context);
            }
            _context.next = 20;
            return testFunc(_appContext.appContext);

          case 20:
            return _context.abrupt('return', _context.sent);

          case 21:
            _context.prev = 21;

            recursiveDepth -= 1;
            resetAppContext();
            Object.assign(_appContext.appContext, originalAppContext);
            return _context.finish(21);

          case 26:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined, [[8,, 21, 26]]);
  }));
};