apollo-passport-local-strategy/lib/index.spec.js

Local strategy using email address and hashed, bcrypted password

"use strict";

var _chai = require("chai");

var _chai2 = _interopRequireDefault(_chai);

var _chaiAsPromised = require("chai-as-promised");

var _chaiAsPromised2 = _interopRequireDefault(_chaiAsPromised);

var _proxyquire = require("proxyquire");

var _proxyquire2 = _interopRequireDefault(_proxyquire);

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

_chai2.default.use(_chaiAsPromised2.default);

var throwErr = false;
var bcrypt = {
  hash: function hash(password, rounds, cb) {
    if (throwErr) {
      cb(throwErr);
      throwErr = false;
    } else cb(null, 'hashed:' + password);
  },
  compare: function compare(password, hash, cb) {
    if (throwErr) {
      cb(throwErr);
      throwErr = false;
    } else cb(null, hash === 'hashed:' + password);
  }
};

var should = _chai2.default.should();
var LocalStrategy = (0, _proxyquire2.default)('./index', { bcrypt: bcrypt }).default;

var apolloPassport = {
  extendWith: function extendWith(obj) {
    for (var key in obj) {
      apolloPassport[key] = obj[key];
    }
  }
};

describe('apollo-passport-loca', function () {

  var ap = apolloPassport;
  var local = void 0;
  before(function () {
    local = new LocalStrategy(ap);
  });

  describe('hashPassword', function () {

    it('works with a callback', function (done) {
      ap.hashPassword('password', function (err, hashed) {
        hashed.should.equal('hashed:password');
        done();
      });
    });

    it('returns a promise if no callback given', function _callee() {
      var hashed;
      return regeneratorRuntime.async(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return regeneratorRuntime.awrap(ap.hashPassword('password'));

            case 2:
              hashed = _context.sent;

              hashed.should.equal('hashed:password');

            case 4:
            case "end":
              return _context.stop();
          }
        }
      }, null, undefined);
    });

    it('the promise rejects on error', function () {
      throwErr = new Error('test');
      ap.hashPassword('a').should.be.rejected;
    });
  });

  describe('comparePassword', function () {

    it('works with a callback', function (done) {
      ap.comparePassword('password', 'hashed:password', function (err, match) {
        match.should.be.true;
      });

      ap.comparePassword('password', 'no-match', function (err, match) {
        match.should.be.false;
        done();
      });
    });

    it('returns a promise if no callback given', function _callee2() {
      var match;
      return regeneratorRuntime.async(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              match = void 0;
              _context2.next = 3;
              return regeneratorRuntime.awrap(ap.comparePassword('password', 'hashed:password'));

            case 3:
              match = _context2.sent;

              match.should.be.true;

              _context2.next = 7;
              return regeneratorRuntime.awrap(ap.comparePassword('password', 'no-match'));

            case 7:
              match = _context2.sent;

              match.should.be.false;

              throwErr = new Error('test');
              ap.comparePassword('a', 'b').should.be.rejected;

            case 11:
            case "end":
              return _context2.stop();
          }
        }
      }, null, undefined);
    });
  });
});