regard/test/managers/requests.js

Sugar-interface to access multiple data sources.

var _ = require('lodash'),
    Chai = require('chai'),
    AbstractManager = require('../../lib/managers/abstract'),
    Connector = require('../../lib/connector'),
    Endpoint = require('../../lib/endpoint'),
    FsConnector = require('../../lib/connectors/fs'),
    Q = require('q'),
    RequestsManager = require('../../lib/managers/requests');

var clazz = RequestsManager,
    expect = Chai.expect,
    foo, bar;

function CustomConnector() {
  if (!(this instanceof CustomConnector)) {
    return new CustomConnector();
  }
  Connector.call(this, 'foo');
  this.handler(function (request, resolve) {
    resolve();
  });
}

CustomConnector.prototype = _.create(Connector.prototype);

describe('RequestsManager', function () {
  beforeEach(function () {
    foo = clazz();
  });
  it('should return RequestsManager instance', function () {
    foo = clazz();
    expect(foo).is.be.instanceof(RequestsManager);
    foo = new clazz();
    expect(foo).is.be.instanceof(RequestsManager);
  });
  it('should have data and promises properties', function () {
    expect(foo).to.have.property('data');
    expect(foo).to.have.property('promises');
  });
  it('should have add, get and has methods', function () {
    expect(foo.add).to.be.a('function');
    expect(foo.get).to.be.a('function');
    expect(foo.has).to.be.a('function');
  });
  it('should can add, get and test if request exists', function () {
    bar = {key:'bar'};
    expect(foo.has('bar')).to.not.be.ok;
    foo.add(bar);
    expect(foo.has('bar')).to.be.ok;
    expect(foo.get('bar')).to.be.an('object');
  });
  it('should process request', function (done) {
    var connector = FsConnector();
    var endpoint = Endpoint('foo');
    var after = false;
    var before = false;
    endpoint.init({$connector:connector});
    bar = {key:'bar',handler:'default',path:__dirname+'/../../package.json',context:{},endpoint:endpoint};
    expect(foo.prepare(bar).then).to.be.a('function');

    foo.prepare(bar).then(function () {
      expect(after).to.not.be.ok;
      expect(before).to.not.be.ok;

      endpoint.init({$after:function () {
        after = true;
      }, $before:function (req) {
        before = true;
        return req;
      }});

      foo.prepare(bar).then(function () {
        connector = CustomConnector();
        endpoint = Endpoint('bar');
        endpoint.init({$connector:connector});
        bar = {key:'baz',handler:'default',path:__dirname+'/../../package.json',context:{},endpoint:endpoint};

        foo.prepare(bar).then(function () {
          done();
        });
      });
    });
  });
  it('should process cached request', function (done) {
    expect(foo.promises._cache.itemCount).to.eql(0);
    var connector = FsConnector();
    var endpoint = Endpoint('foo');
    endpoint.init({$connector:connector});
    bar = {key:'bar',handler:'default',path:__dirname+'/../../package.json',context:{},endpoint:endpoint};
    foo.add(bar);
    foo.prepare(bar);
    expect(foo.promises._cache.itemCount).to.eql(0);
    bar.context.$cache = true;
    foo.prepare(bar).done(function () {
      expect(foo.promises._cache.itemCount).to.eql(1);
      done();
    });
  });
});