@leisurelink/trusted-endpoint/test/signature-parser.tests.js

'use strict';

var expect = require('chai').expect;
var winston = require('winston');
var cache = require('../lib/cache');
var errors = require('@leisurelink/http-equiv-errors');
var httpMocks = require('node-mocks-http');

var SignatureParser = require('../lib/signature-parser');

describe('SignatureParser', function(){
  var parser, mockAuthentic, mockHttpSignature;
  var mockRequest, parsedRequest, keyResponse;

  beforeEach(function(){
    cache.disable();
    mockHttpSignature = {
      parseRequest: function() { return parsedRequest; },
      verifySignature: function() { return true; }
    };
    mockAuthentic = {
      getEndpointKey: function(lang, endpointId, keyId, cb) { cb(null, keyResponse.response, keyResponse.body); }
    };

    parsedRequest = { params: { keyId: 'some-endpoint/some-key', headers: ['host', 'date', 'request-line'] } };
    keyResponse = { response: { statusCode: 200 }, body: { result: { key: '---PUBLIC KEY---' } } };
    mockRequest = httpMocks.createRequest({
      method: 'GET',
      url: '/some/endpoint'
    });
    mockRequest.headers.authorization = 'authorization';
    mockRequest.headers.host = 'some host';
    mockRequest.headers.date = '2015-11-01';

  });

  describe('#parse', function(){
    describe('given strict parsing', function(){
      beforeEach(function(){
        parser = SignatureParser(mockHttpSignature, mockAuthentic, winston, false);
      });
      it('should return parsed signature', function(){
        return parser.parse(mockRequest).then(function(val){
          expect(val).to.eql(parsedRequest);
        });
      });
      it('should return null when parsed signature is null', function(){
        parsedRequest = null;
        return parser.parse(mockRequest).then(function(val){
          expect(val).to.be.null;
        });
      });
      it('should return parsed signature when parsed signature is missing params', function(){
        parsedRequest.params = undefined;
        return parser.parse(mockRequest).then(function(val){
          expect(val).to.eql(parsedRequest);
        });
      });
      it('should return parsed signature when parsed signature is missing keyId', function(){
        parsedRequest.params.keyId = undefined;
        return parser.parse(mockRequest).then(function(val){
          expect(val).to.eql(parsedRequest);
        });
      });
      it('should return null when parsing request throws error', function(){
        mockHttpSignature.parseRequest = function(){ throw new Error('fake error'); };
        return parser.parse(mockRequest).then(function(val){
          expect(val).to.be.null;
        });
      });
      it('should return error when authentic returns error', function(){
        mockAuthentic.getEndpointKey = function(_, __, ___, cb) { cb(new Error('fake error')); };
        return parser.parse(mockRequest).then(function(){
          throw new Error('Expected failure, got success');
        }).catch(function(err){
          expect(err).to.be.ok;
        });
      });
      it('should return UnauthorizedError when key is not found', function(){
        keyResponse.body.result.key = undefined;
        return parser.parse(mockRequest).then(function(){
          throw new Error('Expected failure, got success');
        }).catch(errors.UnauthorizedError, function(err){
          expect(err).to.be.ok;
          expect(err.message).to.eql('authentic:signing-key-not-found');
        });
      });
      it('should return null when request is missing required headers', function(){
        parsedRequest.params.headers = ['date'];
        return parser.parse(mockRequest).then(function(val){
          expect(val).to.be.null;
        });
      });
      it('should return UnauthorizedError when signature is not verified', function(){
        mockHttpSignature.verifySignature = function() { return false; };
        return parser.parse(mockRequest).then(function(){
          throw new Error('Expected failure, got success');
        }).catch(errors.UnauthorizedError, function(err){
          expect(err).to.be.ok;
          expect(err.message).to.eql('authentic:signature-inauthentic');
        });
      });
    });

    describe('given lax parsing', function(){
      beforeEach(function(){
        parser = SignatureParser(mockHttpSignature, mockAuthentic, winston, true);
      });
      describe('with request that still contains signature', function(){
        it('should return parsed signature', function(){
          return parser.parse(mockRequest).then(function(val){
            expect(val).to.eql(parsedRequest);
          });
        });
        it('should return parsed signature when signature is not verified', function(){
          mockHttpSignature.verifySignature = function() { return false; };
          return parser.parse(mockRequest).then(function(val){
            expect(val).to.eql(parsedRequest);
          });
        });
      });
      describe('with request that has signature fields in the header', function(){
        var keyId = 'some-endpoint/some-key';
        var jwt = 'somejwt';

        beforeEach(function(){
          mockRequest.headers = {
            'x-lax-key-id': keyId,
            'x-lax-headers': 'host date request-line',
            'x-lax-jwt': jwt
          };
          mockHttpSignature.parseRequest = function() { return null; };
        });
        it('should return parsed request', function(){
          return parser.parse(mockRequest).then(function(val){
            expect(val).to.eql({
              scheme: 'LaxSignature',
              params: {
                keyId: keyId,
                algorithm: 'fake',
                headers: ['host', 'date', 'request-line'],
                jwt: jwt,
                signature: 'fake'
              },
              signingString: 'fake'
            });
          });
        });
        it('should return parsed request when http signature throws error', function(){
          mockHttpSignature.parseRequest = function() { throw new Error('fake error'); };
          return parser.parse(mockRequest).then(function(val){
            expect(val).to.eql({
              scheme: 'LaxSignature',
              params: {
                keyId: keyId,
                algorithm: 'fake',
                headers: ['host', 'date', 'request-line'],
                jwt: jwt,
                signature: 'fake'
              },
              signingString: 'fake'
            });
          });
        });
      });
    });
  });
});