@mindhive/mock-aws/dist/index.js

'use strict';

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _fromPairs = require('lodash/fromPairs');

var _fromPairs2 = _interopRequireDefault(_fromPairs);

var _last = require('lodash/last');

var _last2 = _interopRequireDefault(_last);

var _awsSdk = require('aws-sdk');

var _awsSdk2 = _interopRequireDefault(_awsSdk);

var _sinon = require('sinon');

var _sinon2 = _interopRequireDefault(_sinon);

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

var defaultApiVersion = function defaultApiVersion(service) {
  return (0, _last2.default)(service.apiVersions);
}; // default to latest version

var loadApi = function loadApi(service, version) {
  return new _awsSdk2.default.Model.Api(_awsSdk2.default.apiLoader.services[service.serviceIdentifier][version]);
};

var mockMethod = exports.mockMethod = function mockMethod(awsService, method) {
  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
      _ref$apiVersion = _ref.apiVersion,
      apiVersion = _ref$apiVersion === undefined ? defaultApiVersion(awsService) : _ref$apiVersion,
      _ref$api = _ref.api,
      api = _ref$api === undefined ? loadApi(awsService, apiVersion) : _ref$api;

  var requestStub = _sinon2.default.stub();
  var func = _sinon2.default.spy(function (params) {
    for (var _len = arguments.length, otherArgs = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      otherArgs[_key - 1] = arguments[_key];
    }

    var apiOperation = api.operations && api.operations[method];
    if (apiOperation) {
      new _awsSdk2.default.ParamValidator(true).validate(apiOperation.input, params);
    }
    var requestResultPromisify = function () {
      var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                return _context.abrupt('return', requestStub.apply(undefined, [params].concat(otherArgs)));

              case 1:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, undefined);
      }));

      return function requestResultPromisify() {
        return _ref2.apply(this, arguments);
      };
    }();
    var resultPromise = requestResultPromisify();
    var callback = typeof (0, _last2.default)(otherArgs) === 'function' ? (0, _last2.default)(otherArgs) : null;
    if (callback) {
      resultPromise.then(function (result) {
        return callback(null, result);
      }, function (error) {
        return callback(error);
      });
    }
    return {
      promise: function promise() {
        return resultPromise;
      }
    };
  });
  func.request = requestStub;
  return func;
};

var mockService = exports.mockService = function mockService(awsService, methods) {
  var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
      _ref3$apiVersion = _ref3.apiVersion,
      apiVersion = _ref3$apiVersion === undefined ? defaultApiVersion(awsService) : _ref3$apiVersion;

  return (0, _fromPairs2.default)(methods.map(function (method) {
    return [method, mockMethod(awsService, method, { apiVersion: apiVersion, api: loadApi(awsService, apiVersion) })];
  }));
};