test.js

describe('mana', function () {
  'use strict';

  var assume = require('assume')
    , sinon = require('sinon')
    , Mana = require('./')
    , Token = Mana.Token;

  assume.use(require('assume-sinon'));

  var sandbox = sinon.sandbox.create();
  var mana = new Mana();

  describe('construction', function () {
    afterEach(function () {
      sandbox.reset();
    });

    it('is exposed as a function', function() { 
      assume(Mana).is.a('function'); 
    }); 
 
    it('exposes the token interface', function() { 
      assume(Mana.Token).is.a('function'); 
    }); 
 
    it('exposes a `new` function that returns an instance of mana', function() { 
      assume(Mana.new).is.a('function'); 
      assume(Mana.new()).is.instanceOf(Mana); 
    }); 
    
    it('calls the initialise function');
  });

  describe('.initialise', function () {
    it('correctly receives all arguments', function (done) {
      var Init = Mana.extend({
        initialise: function (foo, bar) {
          assume(foo).to.equal('bar');
          assume(bar).to.equal('foo');

          done();
        }
      });

      new Init('bar', 'foo');
    });
  });

  describe('#args', function () {
    it('aliases types', function () {
      assume(mana.args([function () {}])).to.have.property('fn');
      assume(mana.args([function () {}])).to.have.property('function');

      assume(mana.args([{}])).to.have.property('options');
      assume(mana.args([{}])).to.have.property('object');

      assume(mana.args(['foo'])).to.have.property('str');
      assume(mana.args(['foo'])).to.have.property('string');

      assume(mana.args([0])).to.have.property('nr');
      assume(mana.args([0])).to.have.property('number');

      assume(mana.args([[]])).to.have.property('array');
      assume(mana.args([new Date])).to.have.property('date');
    });

    it('parses multiple types correctly', function () {
      var types = mana.args([{}, 'str']);

      assume(types).to.have.property('string');
      assume(types).to.have.property('object');
    });
  });

  describe('#querystring, #json', function () {
    it('returns an empty string if no querystring can be made', function () {
      assume(mana.querystring({}, {})).to.equal('');
      assume(mana.querystring({}, [])).to.equal('');
      assume(mana.querystring({}, ['foo'])).to.equal('');
    });

    it('prefixes the querystring with a ?', function () {
      assume(mana.querystring({ foo: 'bar' }, ['foo'])).to.equal('?foo=bar');
    });

    it('supports default query strings but ignores `undefined` as value', function () {
      assume(mana.querystring({}, { foo: 'bar' })).to.equal('?foo=bar');
      assume(mana.querystring({}, { foo: undefined })).to.equal('');
      assume(mana.querystring({}, { foo: 0 })).to.equal('?foo=0');
      assume(mana.querystring({}, { foo: 0, bar: 'bar' })).to.equal('?foo=0&bar=bar');
    });

    it('removes the found querystrings from the first options argument', function () {
      var options = {
        foo: 'bar',
        bar: 'foo'
      }, query = mana.querystring(options, ['foo']);

      assume(query).to.equal('?foo=bar');
      assume(options).to.not.have.property('foo');
      assume(options.bar).to.equal('foo');
      assume(Object.keys(options).length).to.equal(1);
    });
  });

  describe('#type', function () {
    it('detects array', function () {
      assume(mana.type([])).to.equal('array');
    });

    it('detects regexp', function () {
      assume(mana.type(/\//)).to.equal('regexp');
    });

    it('detects function', function () {
      assume(mana.type(function() {})).to.equal('function');
    });

    it('detects string', function () {
      assume(mana.type('string')).to.equal('string');
    });

    it('detects error', function () {
      assume(mana.type(new Error())).to.equal('error');
    });

    it('detects date', function () {
      assume(mana.type(new Date())).to.equal('date');
    });

    it('detects object', function () {
      assume(mana.type({})).to.equal('object');
    });
  });

  describe('#setRatelimit', function () {
    beforeEach(function () {
      mana.ratereset = 0;
      mana.ratelimit = 0;
      mana.remaining = 0;
    });

    it('sets the rate limit on mana', function () {
      mana.setRatelimit(1000, 2000, 3000);

      assume(mana.ratereset).equals(1000);
      assume(mana.ratelimit).equals(2000);
      assume(mana.remaining).equals(3000);
    });

    it('does not set nan values', function () {
      mana.setRatelimit(NaN, NaN, NaN);

      assume(mana.ratereset).equals(0);
      assume(mana.ratelimit).equals(0);
      assume(mana.remaining).equals(0);
    });
  });

  describe('#setRatelimitParser', function () {
    it('sets the ratelimit parser', function () {
      var parseFunction = function() {};

      mana.setRatelimitParser(parseFunction);

      assume(mana.ratelimitParser).equals(parseFunction);
    });

    it('does not set a non function as the ratelimit parser', function () {
      mana.setRatelimitParser(12);
      
      assume(mana.ratelimitParser).not.equals(12);
    });
  });

  describe('#ratelimitHeader', function () {
    it('gets the rate limit info from the headers and sets it on mana', function () {
      mana.ratelimitHeader({
        'x-ratelimit-reset': '4000',
        'x-ratelimit-limit': '5000',
        'x-ratelimit-remaining': '6000'
      });

      assume(mana.ratereset).equals(4000);
      assume(mana.ratelimit).equals(5000);
      assume(mana.remaining).equals(6000);
    });
  });

  describe('#send', function () {
    var sendMana;

    this.timeout(500);

    beforeEach(function () {
      sendMana = new Mana();
    });

    it('calls ratelimitParser with res, body, and setRatelimit', function (done) {
      sendMana.setRatelimitParser(sandbox.stub());
      sendMana.send(
        ['users', 'octocat', 'orgs'],
        { api: 'https://api.github.com/' },
        function handler(err, body) {
          if (err) return done(err);
    
          assume(sendMana.ratelimitParser).is.calledWith(sinon.match.has('headers'), body, sendMana.setRatelimit);

          done();
      });
    });

    it('correctly handles concurrent POSTs to the same endpoint', function (done) {
      this.timeout(1000);
      var fooDone = false;
      var barDone = false;

      sendMana.setRatelimitParser(sandbox.stub());

      sendMana.send(
        ['posts'],
        { 
          api: 'https://jsonplaceholder.typicode.com/', 
          method: 'POST', 
          params: { title: 'foo' } 
        },
        function handler(err, body) {
          if (err) return done(err);

          assume(body[0].title).equals('foo');
          fooDone = true;
          if(barDone) done();
      });

      sendMana.send(
        ['posts'],
        { 
          api: 'https://jsonplaceholder.typicode.com/', 
          method: 'POST', 
          params: { title: 'bar' } 
        },
        function handler(err, body) {
          if (err) return done(err);

          assume(body[0].title).equals('bar');
          barDone = true;
          if(fooDone) done();
      });
    });
  });

  describe('tokenizer', function () {
    it('prefixes tokens with a custom prefix', function () {
      var NaNa = Mana.extend({
        prefix: 'hello-world '
      });

      var nana = new NaNa();
      nana.tokens = ['foo', 'bar'];
      nana.tokenizer();

      assume(nana.tokens.length).to.equal(2);
      nana.tokens.forEach(function (token) {
        assume(token).to.be.instanceOf(Token);
        assume(/hello-world (foo|bar)/i.test(token.authorization)).to.equal(true);
      });
    });

    it('transforms all tokens to Token instances', function () {
      mana.tokens = ['foo', 'bar'];
      mana.tokenizer();

      assume(mana.tokens.length).to.equal(2);
      mana.tokens.forEach(function (token) {
        assume(token).to.be.instanceOf(Token);
        assume(/token (foo|bar)/i.test(token.authorization)).to.equal(true);
      });
    });

    it('removes undefined values', function () {
      mana.tokens = ['foo', undefined];
      mana.tokenizer();

      assume(mana.tokens.length).to.equal(1);
    });

    it('prevents duplicate tokens', function () {
      mana.tokens =  ['foo', 'foo', 'bar'];
      mana.tokenizer().tokenizer().tokens.forEach(function (token) {
        assume(/foo|bar/.test(token.authorization)).to.equal(true);
      });
    });

    it('allows multiple invocations', function () {
      mana.tokens = ['foo', 'bar'];
      mana.tokenizer().tokenizer().tokens.forEach(function (token) {
        assume(token).to.be.instanceOf(Token);
      });
    });

    it('accepts strings and Token instances', function () {
      mana.tokens = ['foo', new Token('banana'), 'bar'];
      mana.tokenizer().tokenizer().tokens.forEach(function (token) {
        assume(token).to.be.instanceOf(Token);
      });
    });
  });

  describe('#roll', function () {
    beforeEach(function () {
      mana.tokens = ['foo'];
      mana.tokenizer();
      mana.authorization = mana.tokens[0].authorization;

      mana.ratelimit = 9000;
      mana.remaining = 0;
      mana.ratereset = Date.now() / 1000;
    });

    it('resets the current token to the current rate limit', function () {
      mana.roll();
      var token = mana.tokens[0];

      assume(token.ratelimit).to.equal(mana.ratelimit);
      assume(token.remaining).to.equal(9000);
      assume(token.ratereset).to.equal(mana.ratereset);
    });

    it('returns boolean values indicating a working token', function () {
      assume(mana.roll()).to.equal(true);

      mana.remaining = 0;
      mana.ratereset = (Date.now() / 1000) + 100;
      assume(mana.roll()).to.equal(false);
    });

    it('returns the most optimal token', function () {
      mana.tokens = ['foob', 'bar', 'baz', 'oof', 'zab'];
      mana.tokenizer();
      mana.tokens.forEach(function (token) {
        token.ratelimit = 9000;
        token.remaining = 10;
        token.ratereset = Date.now();
      });

      var token = mana.tokens[2];
      mana.tokens[1].remaining = token.remaining = 1000;
      token.ratelimit = 10000;

      assume(mana.roll()).to.equal(true);
      assume(token.authorization).to.equal(mana.authorization);
    });
  });

  describe('#downgrade', function () {
    it('calls the function with the first item of the mirror');
    it('continues gets the next mirror on another invocation');
    it('gives an error when its out of mirrors');
  });
});

describe('Tokens', function () {
  'use strict';

  var assume = require('assume')
    , Mana = require('./')
    , Token = Mana.Token;

  var token = new Token('foo')
    , mana = new Mana();

  it('sets all values to Infinity', function () {
    assume(token.ratelimit).to.equal(Infinity);
    assume(token.ratereset).to.equal(Infinity);
    assume(token.remaining).to.equal(Infinity);
  });

  it('transforms the given token to an correct Authorization header value', function () {
    assume(token.authorization).to.equal('token foo');
  });

  it('can set a custom prefix for the token', function () {
    var token = new Token('foo', 'prefix-lol ');
    assume(token.authorization).equals('prefix-lol foo');
  });

  describe("#available", function () {
    beforeEach(function () {
      token.ratelimit = 0;
      token.ratereset = (Date.now() / 1000) + 100;
      token.remaining = 0;
    });

    it('is unavailable if values are zero', function () {
      assume(token.available()).to.equal(false);
    });

    it('is available when fist initialised', function () {
      assume((new Token()).available()).to.equal(true);
    });

    it('is available if it has remaining rates', function () {
      assume(token.available()).to.equal(false);

      token.remaining = 1;
      assume(token.available()).to.equal(true);
    });

    it('is available if our rate has been reset', function () {
      assume(token.available()).to.equal(false);

      token.ratereset = (Date.now() / 1000) - 10;
      assume(token.available()).to.equal(true);

      token.ratereset = (Date.now() / 1000) + 10;
      assume(token.available()).to.equal(false);
    });
  });
});