regard/test/manager.js

Sugar-interface to access multiple data sources.

var _ = require('lodash'),
    Chai = require('chai'),
    Manager = require('../lib/manager'),
    Connector = require('../lib/connector'),
    ConnectorsManager = require('../lib/managers/connectors'),
    EndpointsManager = require('../lib/managers/endpoints');

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

function BadConnector() {
  if (!(this instanceof BadConnector)) {
    return new BadConnector();
  }
  Connector.call(this, 'bad');
}

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

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

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

describe('Manager', function () {
  beforeEach(function () {
    foo = clazz();
  });
  it('should return Manager instance', function () {
    foo = clazz();
    expect(foo).is.be.instanceof(Manager);
    foo = new clazz();
    expect(foo).is.be.instanceof(Manager);
  });
  it('should have connectors and endpoints managers', function () {
    expect(foo).to.have.property('connectors');
    expect(foo.connectors).is.be.instanceof(ConnectorsManager);
    expect(foo).to.have.property('endpoints');
    expect(foo.endpoints).is.be.instanceof(EndpointsManager);
  });
  it('should create connector from connector factory', function () {
    expect(foo.connectors.has('foo')).to.not.be.ok;
    expect(_.partial(foo.createConnector, BadConnector)).to.throw();
    foo.createConnector(CustomConnector);
    expect(foo.connectors.has('foo')).to.be.ok;
  });
  it('should create endpoint if a connector was found', function () {
    expect(_.bind(foo.createEndpoint, foo, 'foo', ['foo'])).to.throw();
    foo.createConnector(foo.connectors.core('fs'));
    foo.createEndpoint('foo', ['/foo']);
    foo.createEndpoint('foo/bar', ['bar']);
    foo.createEndpoint('foo/bar/baz', ['baz']);
    expect(foo.api.foo).to.be.ok;
    expect(foo.api.foo.bar).to.be.ok;
    expect(foo.api.foo.bar.baz).to.be.ok;
  });
  it('should create request to an endpoint', function () {
    expect(foo.requests.data.itemCount).to.eql(0);
    foo.createConnector(foo.connectors.core('fs'));
    bar = foo.createEndpoint('foo', ['/foo']);
    foo.createRequest(bar, 'default', ['foo']);
    expect(foo.requests.data.itemCount).to.eql(1);
  });
  it('should have sugar api', function (done) {
    expect(foo.api.$$).to.throw();
    foo.api.$$('fs');
    expect(foo.connectors.data.length).to.eql(1);
    expect(foo.api.$).to.throw();
    foo.api.$('bar', __dirname);
    expect(foo.endpoints.data.length).to.eql(1);
    foo.api.bar.$('baz', 'foo');
    expect(foo.endpoints.data.length).to.eql(2);
    expect(foo.endpoints.get('bar/baz').parent.key).to.eql('bar');
    expect(foo.api.to(__dirname)).to.be.a('function');
    expect(foo.endpoints.data.length).to.eql(3);
    expect(foo.api).to.throw();
    foo.api('bar', '../package.json').then(function () {
      foo.api('bar:read', '../package.json').then(function () {
        expect(_.partial(foo.api, 'bar:readx')).to.throw();
        foo.api('bar', '../package.json');
        done();
      });
    });
  });
});