eventric-testing/build/release/eventric_testing.js

Testing helpers for eventric.js

require.register("eventric-testing/index", function(exports, require, module){
  module.exports = require('./src');

  
});

require.register("eventric-testing/src/aggregate_factory", function(exports, require, module){
  var AggregateFactory, eventric;

eventric = require('eventric');

AggregateFactory = (function() {
  function AggregateFactory() {}

  AggregateFactory.prototype.createAggregateInstance = function(context, aggregateName) {
    context;
    context = eventric.context(Math.random());
    context.defineDomainEvents(domainEvents);
    context.addAggregate('test', AggregateClass);
    context.addCommandHandlers({
      CreateAggregate: function() {}
    });
    return aggregate.instance;
  };

  return AggregateFactory;

})();

module.exports = new AggregateFactory;

  
});

require.register("eventric-testing/src/eventual_consistency_utilities", function(exports, require, module){
  var EventualConsistencyUtilities;

EventualConsistencyUtilities = (function() {
  function EventualConsistencyUtilities() {}

  EventualConsistencyUtilities.prototype.waitForQueryToReturnResult = function(context, queryName, params, timeout) {
    if (timeout == null) {
      timeout = 5000;
    }
    return this.waitForResult(function() {
      return context.query(queryName, params);
    }, timeout)["catch"](function(error) {
      var ref;
      if ((error != null ? (ref = error.message) != null ? ref.indexOf('waitForResult') : void 0 : void 0) > -1) {
        throw new Error("waitForQueryToReturnResult timed out for query '" + queryName + "' on context '" + context.name + "'\nwith params " + (JSON.stringify(params)));
      } else {
        throw error;
      }
    });
  };

  EventualConsistencyUtilities.prototype.waitForCommandToResolve = function(context, commandName, params, timeout) {
    if (timeout == null) {
      timeout = 5000;
    }
    return this.waitForResult(function() {
      return context.command(commandName, params).then(function(result) {
        return result || true;
      })["catch"](function() {
        return void 0;
      });
    }, timeout)["catch"](function() {
      throw new Error("waitForCommandToResolve timed out for command '" + commandName + "' on context '" + context.name + "'\nwith params " + (JSON.stringify(params)));
    });
  };

  EventualConsistencyUtilities.prototype.waitForResult = function(promiseFactory, timeout) {
    if (timeout == null) {
      timeout = 5000;
    }
    return new Promise(function(resolve, reject) {
      var pollPromise, startTime;
      startTime = new Date();
      pollPromise = function() {
        return promiseFactory().then(function(result) {
          var timeoutExceeded;
          if (result != null) {
            resolve(result);
            return;
          }
          timeoutExceeded = (new Date() - startTime) >= timeout;
          if (!timeoutExceeded) {
            setTimeout(pollPromise, 15);
            return;
          }
          return reject(new Error("waitForResult timed out for '" + (promiseFactory.toString()) + "'"));
        })["catch"](reject);
      };
      return pollPromise();
    });
  };

  return EventualConsistencyUtilities;

})();

module.exports = new EventualConsistencyUtilities;

  
});

require.register("eventric-testing/src/fake_promise", function(exports, require, module){
  var FakePromise, _isPromise,
  slice = [].slice;

_isPromise = function(promise) {
  return promise && typeof promise.then === 'function' && typeof promise["catch"] === 'function';
};

FakePromise = (function() {
  function FakePromise() {}

  FakePromise.prototype.resolve = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return {
      then: function(callback) {
        var promise;
        if (callback == null) {
          callback = function() {};
        }
        promise = callback.apply(this, args);
        if (_isPromise(promise)) {
          return promise;
        } else {
          return this;
        }
      },
      "catch": function() {
        return this;
      }
    };
  };

  FakePromise.prototype.reject = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return {
      then: function() {
        return this;
      },
      "catch": function(callback) {
        var promise;
        if (callback == null) {
          callback = function() {};
        }
        promise = callback.apply(this, args);
        if (_isPromise(promise)) {
          promise;
        } else {
          this;
        }
        return this;
      }
    };
  };

  FakePromise.prototype.resolveAsync = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return {
      then: function(callback) {
        if (callback == null) {
          callback = function() {};
        }
        setTimeout(function() {
          return callback.apply(this, args);
        }, 0);
        return this;
      },
      "catch": function() {
        return this;
      }
    };
  };

  FakePromise.prototype.rejectAsync = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return {
      then: function() {
        return this;
      },
      "catch": function(callback) {
        if (callback == null) {
          callback = function() {};
        }
        setTimeout(function() {
          return callback.apply(this, args);
        }, 0);
        return this;
      }
    };
  };

  return FakePromise;

})();

module.exports = new FakePromise;

  
});

require.register("eventric-testing/src/index", function(exports, require, module){
  var EventricTesting, aggregateFactory, eventualConsistencyUtilities, fakePromise, remoteFactory, wiredRemotes,
  slice = [].slice;

aggregateFactory = require('./aggregate_factory');

fakePromise = require('./fake_promise');

eventualConsistencyUtilities = require('./eventual_consistency_utilities');

remoteFactory = require('./remote_factory');

wiredRemotes = [];

EventricTesting = (function() {
  function EventricTesting() {}

  EventricTesting.prototype.resolve = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return fakePromise.resolve.apply(fakePromise, args);
  };

  EventricTesting.prototype.reject = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return fakePromise.reject.apply(fakePromise, args);
  };

  EventricTesting.prototype.resolveAsync = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return fakePromise.resolveAsync.apply(fakePromise, args);
  };

  EventricTesting.prototype.rejectAsync = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return fakePromise.rejectAsync.apply(fakePromise, args);
  };

  EventricTesting.prototype.wiredAggregate = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return aggregateFactory.wiredAggregate.apply(aggregateFactory, args);
  };

  EventricTesting.prototype.wiredRemote = function() {
    var args, wiredRemote;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    wiredRemote = remoteFactory.wiredRemote.apply(remoteFactory, args);
    wiredRemotes.push(wiredRemote);
    return wiredRemote;
  };

  EventricTesting.prototype.destroy = function() {
    var i, len, wiredRemote;
    for (i = 0, len = wiredRemotes.length; i < len; i++) {
      wiredRemote = wiredRemotes[i];
      wiredRemote.$destroy();
    }
    return wiredRemotes = [];
  };

  EventricTesting.prototype.waitForQueryToReturnResult = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return eventualConsistencyUtilities.waitForQueryToReturnResult.apply(eventualConsistencyUtilities, args);
  };

  EventricTesting.prototype.waitForCommandToResolve = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return eventualConsistencyUtilities.waitForCommandToResolve.apply(eventualConsistencyUtilities, args);
  };

  EventricTesting.prototype.waitForResult = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return eventualConsistencyUtilities.waitForResult.apply(eventualConsistencyUtilities, args);
  };

  return EventricTesting;

})();

module.exports = new EventricTesting;

  
});

require.register("eventric-testing/src/remote_factory", function(exports, require, module){
  var RemoteFactory, _, eventric, fakePromise, inmemoryRemote;

_ = require('lodash');

eventric = require('eventric');

fakePromise = require('./fake_promise');

inmemoryRemote = require('eventric-remote-inmemory');

RemoteFactory = (function() {
  function RemoteFactory() {}

  RemoteFactory.prototype.wiredRemote = function(contextName, domainEvents) {
    var originalCommand, originalSubscribeToAllDomainEvents, originalSubscribeToDomainEvent, originalSubscribeToDomainEventWithAggregateId, wiredRemote;
    wiredRemote = eventric.remote(contextName);
    wiredRemote._mostCurrentEmitOperation = fakePromise.resolve();
    wiredRemote._domainEvents = [];
    wiredRemote._subscriberIds = [];
    wiredRemote._commandStubs = [];
    wiredRemote._context = eventric.context(contextName);
    wiredRemote.setClient(inmemoryRemote.client);
    wiredRemote.$populateWithDomainEvent = function(domainEventName, aggregateId, domainEventPayload) {
      return this._domainEvents.push(this._createDomainEvent(domainEventName, aggregateId, domainEventPayload));
    };
    wiredRemote.$emitDomainEvent = function(domainEventName, aggregateId, domainEventPayload) {
      var domainEvent, endpoint;
      domainEvent = this._createDomainEvent(domainEventName, aggregateId, domainEventPayload);
      this._domainEvents.push(domainEvent);
      endpoint = inmemoryRemote.endpoint;
      return this._mostCurrentEmitOperation = this._mostCurrentEmitOperation.then(function() {
        var contextAndNameEventPublish, contextEventPublish, fullEventNamePublish;
        contextEventPublish = endpoint.publish(contextName, domainEvent);
        contextAndNameEventPublish = endpoint.publish(contextName, domainEvent.name, domainEvent);
        if (domainEvent.aggregate) {
          fullEventNamePublish = endpoint.publish(contextName, domainEvent.name, domainEvent.aggregate.id, domainEvent);
          return Promise.all([contextEventPublish, contextAndNameEventPublish, fullEventNamePublish]);
        } else {
          return Promise.all([contextEventPublish, contextAndNameEventPublish]);
        }
      });
    };
    wiredRemote.$waitForEmitDomainEvent = function() {
      return wiredRemote._mostCurrentEmitOperation;
    };
    wiredRemote._createDomainEvent = function(domainEventName, aggregateId, domainEventPayload) {
      var DomainEventClass;
      DomainEventClass = domainEvents[domainEventName];
      if (!DomainEventClass) {
        throw new Error('Trying to populate wired remote with unknown domain event ' + domainEventName);
      }
      return wiredRemote._context.createDomainEvent(domainEventName, DomainEventClass, domainEventPayload, {
        id: aggregateId
      });
    };
    wiredRemote.findDomainEventsByName = function(names) {
      if (!(names instanceof Array)) {
        names = [names];
      }
      return fakePromise.resolve(this._domainEvents.filter(function(x) {
        return names.indexOf(x.name) > -1;
      }));
    };
    wiredRemote.findDomainEventsByNameAndAggregateId = function(names, aggregateIds) {
      if (!(names instanceof Array)) {
        names = [names];
      }
      if (!(aggregateIds instanceof Array)) {
        aggregateIds = [aggregateIds];
      }
      return fakePromise.resolve(this._domainEvents.filter(function(x) {
        return names.indexOf(x.name) > -1 && x.aggregate && aggregateIds.indexOf(x.aggregate.id) > -1;
      }));
    };
    originalSubscribeToAllDomainEvents = wiredRemote.subscribeToAllDomainEvents;
    wiredRemote.subscribeToAllDomainEvents = function() {
      return originalSubscribeToAllDomainEvents.apply(this, arguments).then((function(_this) {
        return function(subscriberId) {
          _this._subscriberIds.push(subscriberId);
          return subscriberId;
        };
      })(this));
    };
    originalSubscribeToDomainEvent = wiredRemote.subscribeToDomainEvent;
    wiredRemote.subscribeToDomainEvent = function() {
      return originalSubscribeToDomainEvent.apply(this, arguments).then((function(_this) {
        return function(subscriberId) {
          _this._subscriberIds.push(subscriberId);
          return subscriberId;
        };
      })(this));
    };
    originalSubscribeToDomainEventWithAggregateId = wiredRemote.subscribeToDomainEventWithAggregateId;
    wiredRemote.subscribeToDomainEventWithAggregateId = function() {
      return originalSubscribeToDomainEventWithAggregateId.apply(this, arguments).then((function(_this) {
        return function(subscriberId) {
          _this._subscriberIds.push(subscriberId);
          return subscriberId;
        };
      })(this));
    };
    wiredRemote.$destroy = function() {
      this._domainEvents = [];
      this._commandStubs = [];
      return this._mostCurrentEmitOperation.then((function(_this) {
        return function() {
          var i, len, ref, subscriberId, subscriptionRemovals;
          _this._mostCurrentEmitOperation = fakePromise.resolve();
          subscriptionRemovals = [];
          ref = _this._subscriberIds;
          for (i = 0, len = ref.length; i < len; i++) {
            subscriberId = ref[i];
            subscriptionRemovals.push(wiredRemote.unsubscribeFromDomainEvent(subscriberId));
          }
          _this._subscriberIds = [];
          return Promise.all(subscriptionRemovals);
        };
      })(this));
    };
    wiredRemote.$onCommand = function(command, payload) {
      var commandStub;
      commandStub = {
        command: command,
        payload: payload,
        domainEvents: [],
        yieldsDomainEvent: function(eventName, aggregateId, payload) {
          this.domainEvents.push({
            eventName: eventName,
            aggregateId: aggregateId,
            payload: payload
          });
          return this;
        }
      };
      this._commandStubs.push(commandStub);
      return commandStub;
    };
    originalCommand = wiredRemote.command;
    wiredRemote.command = function(command, payload) {
      var domainEvent, emitDomainEventAsync, filteredCommandStub, filteredCommandStubs, i, j, len, len1, ref;
      filteredCommandStubs = this._commandStubs.filter(function(commandStub) {
        if (command !== commandStub.command) {
          return false;
        }
        return _.isEqual(payload, commandStub.payload);
      });
      if (!filteredCommandStubs.length) {
        return originalCommand.apply(this, arguments);
      }
      emitDomainEventAsync = (function(_this) {
        return function(domainEvent) {
          return setTimeout(function() {
            return _this.$emitDomainEvent(domainEvent.eventName, domainEvent.aggregateId, domainEvent.payload);
          });
        };
      })(this);
      for (i = 0, len = filteredCommandStubs.length; i < len; i++) {
        filteredCommandStub = filteredCommandStubs[i];
        ref = filteredCommandStub.domainEvents;
        for (j = 0, len1 = ref.length; j < len1; j++) {
          domainEvent = ref[j];
          emitDomainEventAsync(domainEvent);
        }
      }
      return fakePromise.resolve();
    };
    return wiredRemote;
  };

  return RemoteFactory;

})();

module.exports = new RemoteFactory;

  
});

require.register("eventric-testing/src/spec_setup", function(exports, require, module){
  var root, sinonChai;

require('es6-promise').polyfill();

if (typeof window !== 'undefined') {
  root = window;
} else {
  root = global;
}

if (!root._spec_setup) {
  root.sinon = require('sinon');
  root.chai = require('chai');
  root.expect = chai.expect;
  root.sandbox = sinon.sandbox.create();
  sinonChai = require('sinon-chai');
  chai.use(sinonChai);
  root._spec_setup = true;
}

afterEach(function() {
  return sandbox.restore();
});

  
});