@house-agency/brewsession/test/service.js

The Brewery Session Manager

require('@house-agency/brewtils/config').load('test/test.json');
require('@house-agency/brewtils/log').level('fatal');

const expect = require('chai').expect;
const q = require('q');
const service = require('../service');

describe('Session Service', () => {
    it('shall set, get and delete session oriented data', done => {
        service.data('session-token', 'identifier', 'set', 'data')
        .then(() => {
            return service.data(
                'session-token',
                'identifier',
                'get'
            );
        })
        .then(results => {
            expect(results).to.equal('data');

            return service.data(
                'session-token',
                'identifier',
                'del'
            );
        })
        .then(() => {
            return service.data(
                'session-token',
                'identifier',
                'get'
            );
        })
        .catch(error => {
            expect(error).to.be.an.instanceOf(Error);
            expect(error.message).to.equal('Not found');
        })
        .done(done);
    });

    it('shall create, get, match and remove api keys', done => {
        service.generate_apikey()
        .then(key => {
            expect(key).to.match(/^[0-9]+:[0-9a-zA-Z]+$/);

            return service.match_apikey(key);
        })
        .then(key => {
            return service.get_apikeys()
            .then(keys => {
                expect(keys).to.have.lengthOf(1);
                expect(keys[0]).to.equal(key);

                return service.remove_apikey(key);
            });
        })
        .then(() => {
            return service.get_apikeys();
        })
        .then((keys) => {
            expect(keys).to.have.lengthOf(0);
        })
        .done(done);
    });

    it('shall throw an error if api key is not matched', done => {
        service.match_apikey('Some random try of imitate a key')
        .then(() => {
            throw new Error('The key must not get validated!');
        })
        .catch(error => {
            expect(error).to.be.an.instanceOf(Error);
            expect(error.message).to.equal('Invalid key');
        })
        .done(done);
    });

    it('shall create validate the key in config', done => {
        service.match_apikey('test-key')
        .then(key => {
            expect(key).to.equal('test-key');
        })
        .done(done);
    });

    it('shall create api key and let it time out', done => {
        service.generate_apikey()
        .then(key => {
            return q.all([
                q(key),
                service.generate_apikey()
            ]);
        })
        .spread((key1, key2) => {
            if (key2 !== key2) {
                throw new Error('Only one key should\'ve been created!');
            }

            return key1;
        })
        .delay(500)
        .then(key => {
            return q.all([
                q(key),
                service.generate_apikey()
            ]);
        })
        .spread((key1, key2) => {
            return q.delay(500)
            .then(() => {
                return service.generate_apikey();
            })
            .then(() => {
                return q.all([
                    service.get_apikeys(),
                    service.match_apikey(key1)
                    .catch(error => {
                        expect(error).to.be.an.instanceOf(Error);
                        expect(error.message).to.equal('Invalid key');
                    }),
                    service.match_apikey(key2)
                ]);
            });
        })
        .spread(keys => {
            expect(keys).to.have.lengthOf(2);
        })
        .done(done);
    });

    it('shall create api key and create, validate and exceed session', done => {
        service.generate_apikey()
        .then(key => {
            return service.create(
                key,
                'some user-agent',
                'some other stuff'
            );
        })
        .then(token => {
            return service.verify(token, 'failing stuff')
            .then(() => {
                throw new Error('Fail');
            })
            .catch(error => {
                expect(error).to.be.an.instanceOf(Error);
                expect(error.message).to.equal('Invalid session token');
            })
            .then(() => {
                return service.verify(
                    token,
                    'some user-agent',
                    'some other stuff'
                );
            });
        })
        .then(token => {
            return service.exceed(token);
        })
        .catch(() => {
            throw new Error('Fail');
        })
        .delay(500)
        .then(token => {
            return service.verify(token);
        })
        .then(() => {
            throw new Error('Fail');
        })
        .catch(error => {
            expect(error).to.be.an.instanceOf(Error);
            expect(error.message).to.equal('Invalid session token');
        })
        .done(done);
    });
});