@mindhive/di/dist/mockAppContext.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.mockAppContext = 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 func and clean it up at the end

Arguments are: ([context,] func)

Context is optional, so you can just pass: (func)

Note: this can't be called wrapping a 'describe' function. It only works on 'it'.
 */
var clearAppContext = function clearAppContext() {
  Object.keys(_appContext.appContext).forEach(function (key) {
    delete _appContext.appContext[key];
  });
};

var mockAppContext = exports.mockAppContext = function mockAppContext() {
  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, func, 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;
            }

            clearAppContext();
            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], func = _ref3[1];
            originalAppContext = (0, _extends3.default)({}, _appContext.appContext);

            recursiveDepth += 1;
            _context.prev = 8;
            context = typeof contextObjOrFunc === 'function' ? contextObjOrFunc() : contextObjOrFunc;

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

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

          case 14:
            _context.prev = 14;

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

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