mercurial-bower-resolver/dist/Resolver.spec.js

A HG resolver for Bower

'use strict';

// Test setup:
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _chai = require('chai');

var _chai2 = _interopRequireDefault(_chai);

var _sinon = require('sinon');

var _sinon2 = _interopRequireDefault(_sinon);

var _sinonChai = require('sinon-chai');

var _sinonChai2 = _interopRequireDefault(_sinonChai);

// Dependencies:
var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _mercurial = require('./mercurial');

var _mercurial2 = _interopRequireDefault(_mercurial);

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

// Under test:
var _Resolver = require('./Resolver');

var _Resolver2 = _interopRequireDefault(_Resolver);

var expect = _chai2['default'].expect;

_chai2['default'].use(_sinonChai2['default']);

describe('Resolver:', function () {
    describe('Resolver.match:', function () {
        it('should match any URLs with the "hg+" prefix', function () {
            var URLS = ['hg+ssh://some.repo', 'hg+http://some.repo', 'hg+https://some.repo'];

            var resolver = new _Resolver2['default']();

            URLS.forEach(function (url) {
                expect(resolver.match(url)).to.equal['true'];
            });
        });

        it('should not match anything without the "hg+" prefix', function () {
            var URLS = ['ssh://some.repo', 'svn+http://some.repo'];

            var resolver = new _Resolver2['default']();

            URLS.forEach(function (url) {
                expect(resolver.match(url)).to.equal['false'];
            });
        });
    });

    describe('Resolver.releases:', function () {
        it('should get the available releases from the repo and set the clone directory', function () {
            var directory = { name: directory };
            var versions = [];

            _sinon2['default'].stub(_mercurial2['default'], 'clone').returns(_bluebird2['default'].resolve(directory));
            _sinon2['default'].stub(_mercurial2['default'], 'branches').returns(_bluebird2['default'].resolve(''));
            _sinon2['default'].stub(_mercurial2['default'], 'tags').returns(_bluebird2['default'].resolve(''));
            _sinon2['default'].stub(_parser2['default'], 'versions').returns(versions);

            var resolver = new _Resolver2['default']();

            return resolver.releases().then(function (releases) {
                expect(resolver.directory).to.equal(directory);
                expect(_mercurial2['default'].clone).to.have.been.called;
                expect(_mercurial2['default'].branches).to.have.been.called;
                expect(_mercurial2['default'].tags).to.have.been.called;
                expect(_parser2['default'].versions).to.have.been.called;
                expect(releases).to.equal(versions);

                _mercurial2['default'].clone.restore();
                _mercurial2['default'].branches.restore();
                _mercurial2['default'].tags.restore();
                _parser2['default'].versions.restore();
            });
        });
    });

    describe('Resolver.fetch:', function () {
        it('should fetch the repository at the given target and set the clone directory', function () {
            var directory = { name: directory };
            var endpoint = { source: 'source' };

            _sinon2['default'].stub(_mercurial2['default'], 'clone').returns(_bluebird2['default'].resolve(directory));
            _sinon2['default'].stub(_mercurial2['default'], 'update').returns(_bluebird2['default'].resolve());

            var resolver = new _Resolver2['default']();

            return resolver.fetch(endpoint).then(function () {
                expect(resolver.directory).to.equal(directory);
                expect(_mercurial2['default'].clone).to.have.been.called;
                expect(_mercurial2['default'].update).to.have.been.called;

                _mercurial2['default'].clone.restore();
                _mercurial2['default'].update.restore();
            });
        });

        it('should return `undefined` if the previous fetch returned a semver compliant version', function () {
            var cached = { version: '1.0.0', endpoint: {} };
            var endpoint = { source: 'source' };

            var resolver = new _Resolver2['default']();

            expect(resolver.fetch(endpoint, cached)).to.equal(undefined);
        });

        it('should fetch the repository if the previous fetch returned "default"', function () {
            var cached = { version: '0.0.0', endpoint: { target: "default" } };
            var directory = { name: directory };
            var endpoint = { source: 'source' };

            _sinon2['default'].stub(_mercurial2['default'], 'clone').returns(_bluebird2['default'].resolve(directory));
            _sinon2['default'].stub(_mercurial2['default'], 'update').returns(_bluebird2['default'].resolve());

            var resolver = new _Resolver2['default']();

            return resolver.fetch(endpoint, cached).then(function () {
                expect(_mercurial2['default'].clone).to.have.been.called;

                _mercurial2['default'].clone.restore();
                _mercurial2['default'].update.restore();
            });
        });
    });

    describe('Resolver.error:', function () {
        it('should pass the error through to the bower error logger', function () {
            var logger = { error: function error() {} };
            var bower = { logger: logger };
            var ERROR_TYPE = 'ERROR';

            _sinon2['default'].stub(logger, 'error');

            var resolver = new _Resolver2['default'](bower);

            resolver.error(ERROR_TYPE)('error');

            expect(bower.logger.error).to.have.been.calledWith(ERROR_TYPE, 'error');
        });
    });
});