bower/test/core/Manager.js

var expect = require('expect.js');
var path = require('path');
var rimraf = require('../../lib/util/rimraf');
var Logger = require('bower-logger');
var Manager = require('../../lib/core/Manager');
var defaultConfig = require('../../lib/config');

describe('Manager', function() {
    var manager;

    var packagesCacheDir = path.join(__dirname, '../assets/temp-resolve-cache');

    var registryCacheDir = path.join(
        __dirname,
        '../assets/temp-registry-cache'
    );

    after(function() {
        rimraf.sync(registryCacheDir);
        rimraf.sync(packagesCacheDir);
    });

    beforeEach(function(next) {
        var logger = new Logger();

        var config = defaultConfig({
            storage: {
                packages: packagesCacheDir,
                registry: registryCacheDir
            }
        });

        manager = new Manager(config, logger);

        next();
    });

    describe('resolve', function() {
        it('prefers exact versions over ranges', function() {
            manager._resolved = {
                ember: [
                    {
                        target: '>=1.4',
                        pkgMeta: { version: '2.7.0' }
                    },
                    {
                        target: '2.7.0',
                        pkgMeta: { version: '2.7.0' }
                    }
                ]
            };

            return manager.resolve().then(function() {
                expect(manager._dissected).to.eql({
                    ember: {
                        target: '2.7.0',
                        pkgMeta: { version: '2.7.0' }
                    }
                });
            });
        });
    });

    describe('_areCompatible', function() {
        describe('resolved is being fetched', function() {
            it('accepts endpoints with same targets', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: 'xxx' },
                        { name: 'bar', target: 'xxx' }
                    )
                ).to.be(true);
            });

            it('rejects endpoints with different targets', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: 'xxx' },
                        { name: 'bar', target: 'yyy' }
                    )
                ).to.be(false);
            });

            it('accepts with version and matching range', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '0.1.2' },
                        { name: 'bar', target: '~0.1.0' }
                    )
                ).to.be(true);
            });

            it('rejects with version and non-matching range', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '0.1.2' },
                        { name: 'bar', target: '~0.1.3' }
                    )
                ).to.be(false);
            });

            it('accepts with matching range and version', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~0.1.0' },
                        { name: 'bar', target: '0.1.2' }
                    )
                ).to.be(true);
            });

            it('accepts with non-matching range and version', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~0.1.3' },
                        { name: 'bar', target: '0.1.2' }
                    )
                ).to.be(false);
            });

            it('accepts with matching ranges', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~0.1.0' },
                        { name: 'bar', target: '~0.1.3' }
                    )
                ).to.be(true);
            });

            it('rejects with non-matching ranges', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~0.1.0' },
                        { name: 'bar', target: '~0.2.3' }
                    )
                ).to.be(false);
            });

            it('rejects with non-matching ranges', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~0.1.0' },
                        { name: 'bar', target: 'xxx' }
                    )
                ).to.be(false);
            });
        });

        describe('resolved is already fetched', function() {
            var resolved = {
                name: 'foo',
                target: '~1.2.1',
                pkgMeta: {
                    version: '1.2.3'
                }
            };

            it('accepts if the same version as resolved', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '1.2.3' },
                        resolved
                    )
                ).to.be(true);
            });

            it('rejects if different version than resolved', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '1.2.4' },
                        resolved
                    )
                ).to.be(false);
            });

            it('accepts if range matches resolved version', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~1.2.1' },
                        resolved
                    )
                ).to.be(true);
            });

            it('rejects if range does not match', function() {
                expect(
                    manager._areCompatible(
                        { name: 'foo', target: '~1.2.4' },
                        resolved
                    )
                ).to.be(false);
            });
        });
    });

    describe('_getCap', function() {
        it('finds highest bound', function() {
            var highest = manager._getCap(
                [['2.1.1-0', '<2.2.0-0'], '<3.2.0'],
                'highest'
            );

            expect(highest).to.eql({
                version: '3.2.0',
                comparator: '<'
            });
        });

        it('finds lowest bound', function() {
            var highest = manager._getCap(
                [['2.1.1-0', '<2.2.0-0'], '<3.2.0'],
                'lowest'
            );

            expect(highest).to.eql({
                version: '2.1.1-0',
                comparator: ''
            });
        });

        it('defaults to highest bound', function() {
            var highest = manager._getCap(['1.0.0', '2.0.0']);

            expect(highest).to.eql({
                version: '2.0.0',
                comparator: ''
            });
        });

        it('ignores non-semver elements', function() {
            var highest = manager._getCap(['0.9', '>1.0.1', ['<1.0.0', 'lol']]);

            expect(highest).to.eql({
                version: '1.0.1',
                comparator: '>'
            });
        });

        it('returns empty object if cap is not found', function() {
            var highest = manager._getCap(
                ['0.9'] // Not a semver
            );

            expect(highest).to.eql({});
        });
    });

    describe('_uniquify', function() {
        it('leaves last unique element', function() {
            var unique = manager._uniquify([
                { name: 'foo', id: 1 },
                { name: 'foo', id: 2 }
            ]);
            expect(unique).to.eql([{ name: 'foo', id: 2 }]);
        });

        it('compares by name first', function() {
            var unique = manager._uniquify([
                { name: 'foo', source: 'google.com' },
                { name: 'foo', source: 'facebook.com' }
            ]);

            expect(unique).to.eql([{ name: 'foo', source: 'facebook.com' }]);
        });

        it('compares by source if name is not available', function() {
            var unique = manager._uniquify([
                { source: 'facebook.com' },
                { source: 'facebook.com' }
            ]);

            expect(unique).to.eql([{ source: 'facebook.com' }]);
        });

        it('leaves different targets intact', function() {
            var unique = manager._uniquify([
                { source: 'facebook.com', target: 'a1b2c3' },
                { source: 'facebook.com', target: 'ffffff' }
            ]);

            expect(unique).to.eql([
                { source: 'facebook.com', target: 'a1b2c3' },
                { source: 'facebook.com', target: 'ffffff' }
            ]);
        });

        it('removes if same targets', function() {
            var unique = manager._uniquify([
                { source: 'facebook.com', target: 'ffffff' },
                { source: 'facebook.com', target: 'ffffff' }
            ]);

            expect(unique).to.eql([
                { source: 'facebook.com', target: 'ffffff' }
            ]);
        });

        it('ignores other fields', function() {
            var unique = manager._uniquify([
                { source: 'facebook.com', foo: 12 },
                { source: 'facebook.com', bar: 13 }
            ]);

            expect(unique).to.eql([{ source: 'facebook.com', bar: 13 }]);
        });
    });
});