bower/test/core/packageRepository.js

var expect = require('expect.js');
var Q = require('q');
var path = require('path');
var mout = require('mout');
var fs = require('../../lib/util/fs');
var rimraf = require('../../lib/util/rimraf');
var RegistryClient = require('bower-registry-client');
var Logger = require('bower-logger');
var proxyquire = require('proxyquire');
var defaultConfig = require('../../lib/config');
var ResolveCache = require('../../lib/core/ResolveCache');
var resolvers = require('../../lib/core/resolvers');
var copy = require('../../lib/util/copy');
var helpers = require('../helpers');

describe('PackageRepository', function() {
    var packageRepository;
    var resolver;
    var resolverFactoryHook;
    var resolverFactoryClearHook;
    var testPackage = path.resolve(__dirname, '../assets/package-a');
    var tempPackage = path.resolve(__dirname, '../tmp/temp-package');
    var packagesCacheDir = path.join(__dirname, '../tmp/temp-resolve-cache');
    var registryCacheDir = path.join(__dirname, '../tmp/temp-registry-cache');
    var mockSource = helpers.localSource(testPackage);

    var forceCaching = true;

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

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

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

        // Mock the resolver factory to always return a resolver for the test package
        function resolverFactory(decEndpoint, options, _registryClient) {
            var _config = options.config;
            var _logger = options.logger;

            expect(_config).to.eql(config);
            expect(_logger).to.be.an(Logger);
            expect(_registryClient).to.be.an(RegistryClient);

            decEndpoint = mout.object.deepMixIn({}, decEndpoint);
            decEndpoint.source = mockSource;

            resolver = new resolvers.GitRemote(decEndpoint, _config, _logger);

            if (forceCaching) {
                // Force to use cache even for local resources
                resolver.isCacheable = function() {
                    return true;
                };
            }

            resolverFactoryHook(resolver);

            return Q.resolve(resolver);
        }
        resolverFactory.getConstructor = function() {
            return Q.resolve([
                resolvers.GitRemote,
                {
                    source: helpers.localSource(testPackage)
                }
            ]);
        };
        resolverFactory.clearRuntimeCache = function() {
            resolverFactoryClearHook();
        };

        PackageRepository = proxyquire('../../lib/core/PackageRepository', {
            './resolverFactory': resolverFactory
        });
        packageRepository = new PackageRepository(config, logger);

        // Reset hooks
        resolverFactoryHook = resolverFactoryClearHook = function() {};

        // Remove temp package
        rimraf.sync(tempPackage);

        // Clear the repository
        packageRepository.clear().then(next.bind(next, null), next);
    });

    describe('.constructor', function() {
        it('should pass the config correctly to the registry client, including its cache folder', function() {
            expect(packageRepository._registryClient._config.cache).to.equal(
                registryCacheDir
            );
        });
    });

    describe('.fetch', function() {
        it('should call the resolver factory to get the appropriate resolver', function(next) {
            var called;

            resolverFactoryHook = function() {
                called = true;
            };

            packageRepository
                .fetch({ name: '', source: 'foo', target: '~0.1.0' })
                .spread(function(canonicalDir, pkgMeta) {
                    expect(called).to.be(true);
                    expect(fs.existsSync(canonicalDir)).to.be(true);
                    expect(pkgMeta).to.be.an('object');
                    expect(pkgMeta.name).to.be('package-a');
                    expect(pkgMeta.version).to.be('0.1.1');
                    next();
                })
                .done();
        });

        it('should just call the resolver resolve method if force was specified', function(next) {
            var called = [];

            resolverFactoryHook = function(resolver) {
                var originalResolve = resolver.resolve;

                resolver.resolve = function() {
                    called.push('resolve');
                    return originalResolve.apply(this, arguments);
                };

                resolver.hasNew = function() {
                    called.push('hasNew');
                    return Q.resolve(false);
                };
            };

            packageRepository._resolveCache.retrieve = function() {
                called.push('retrieve');
                return Q.resolve([]);
            };

            packageRepository._config.force = true;
            packageRepository
                .fetch({ name: '', source: 'foo', target: ' ~0.1.0' })
                .spread(function(canonicalDir, pkgMeta) {
                    expect(called).to.eql(['resolve']);
                    expect(fs.existsSync(canonicalDir)).to.be(true);
                    expect(pkgMeta).to.be.an('object');
                    expect(pkgMeta.name).to.be('package-a');
                    expect(pkgMeta.version).to.be('0.1.1');
                    next();
                })
                .done();
        });

        it('should attempt to retrieve a resolved package from the resolve package', function(next) {
            var called = false;
            var originalRetrieve = packageRepository._resolveCache.retrieve;

            packageRepository._resolveCache.retrieve = function(source) {
                called = true;
                expect(source).to.be(mockSource);
                return originalRetrieve.apply(this, arguments);
            };

            packageRepository
                .fetch({ name: '', source: 'foo', target: '~0.1.0' })
                .spread(function(canonicalDir, pkgMeta) {
                    expect(called).to.be(true);
                    expect(fs.existsSync(canonicalDir)).to.be(true);
                    expect(pkgMeta).to.be.an('object');
                    expect(pkgMeta.name).to.be('package-a');
                    expect(pkgMeta.version).to.be('0.1.1');
                    next();
                })
                .done();
        });

        it('should avoid using cache for local resources', function(next) {
            forceCaching = false;

            var called = false;
            var originalRetrieve = packageRepository._resolveCache.retrieve;

            packageRepository._resolveCache.retrieve = function(source) {
                called = true;
                expect(source).to.be(mockSource);
                return originalRetrieve.apply(this, arguments);
            };

            packageRepository
                .fetch({
                    name: '',
                    source: helpers.localSource(testPackage),
                    target: '~0.1.0'
                })
                .spread(function(canonicalDir, pkgMeta) {
                    expect(called).to.be(false);
                    expect(fs.existsSync(canonicalDir)).to.be(true);
                    expect(pkgMeta).to.be.an('object');
                    expect(pkgMeta.name).to.be('package-a');
                    expect(pkgMeta.version).to.be('0.1.1');
                    forceCaching = true;
                    next();
                })
                .done();
        });

        it('should just call the resolver resolve method if no appropriate package was found in the resolve cache', function(next) {
            var called = [];

            resolverFactoryHook = function(resolver) {
                var originalResolve = resolver.resolve;

                resolver.resolve = function() {
                    called.push('resolve');
                    return originalResolve.apply(this, arguments);
                };

                resolver.hasNew = function() {
                    called.push('hasNew');
                };
            };

            packageRepository._resolveCache.retrieve = function() {
                return Q.resolve([]);
            };

            packageRepository
                .fetch({ name: '', source: 'foo', target: ' ~0.1.0' })
                .spread(function(canonicalDir, pkgMeta) {
                    expect(called).to.eql(['resolve']);
                    expect(fs.existsSync(canonicalDir)).to.be(true);
                    expect(pkgMeta).to.be.an('object');
                    expect(pkgMeta.name).to.be('package-a');
                    expect(pkgMeta.version).to.be('0.1.1');
                    next();
                })
                .done();
        });

        it('should call the resolver hasNew method if an appropriate package was found in the resolve cache', function(next) {
            var json = {
                name: 'a',
                version: '0.2.1'
            };
            var called;

            resolverFactoryHook = function(resolver) {
                var originalHasNew = resolver.hasNew;

                resolver.hasNew = function(pkgMeta) {
                    expect(pkgMeta).to.eql(json);
                    called = true;
                    return originalHasNew.apply(this, arguments);
                };
            };

            packageRepository._resolveCache.retrieve = function() {
                return Q.resolve([tempPackage, json]);
            };

            copy.copyDir(testPackage, tempPackage, { ignore: ['.git'] })
                .then(function() {
                    fs.writeFileSync(
                        path.join(tempPackage, '.bower.json'),
                        JSON.stringify(json)
                    );

                    return packageRepository
                        .fetch({ name: '', source: 'foo', target: '~0.1.0' })
                        .spread(function(canonicalDir, pkgMeta) {
                            expect(called).to.be(true);
                            expect(fs.existsSync(canonicalDir)).to.be(true);
                            expect(pkgMeta).to.be.an('object');
                            expect(pkgMeta.name).to.be('package-a');
                            expect(pkgMeta.version).to.be('0.1.1');
                            next();
                        });
                })
                .done();
        });

        it('should call the resolver resolve method if hasNew resolved to true', function(next) {
            var json = {
                name: 'a',
                version: '0.2.0'
            };
            var called = [];

            resolverFactoryHook = function(resolver) {
                var originalResolve = resolver.resolve;

                resolver.resolve = function() {
                    called.push('resolve');
                    return originalResolve.apply(this, arguments);
                };

                resolver.hasNew = function(pkgMeta) {
                    expect(pkgMeta).to.eql(json);
                    called.push('hasNew');
                    return Q.resolve(true);
                };
            };

            packageRepository._resolveCache.retrieve = function() {
                return Q.resolve([tempPackage, json]);
            };

            copy.copyDir(testPackage, tempPackage, { ignore: ['.git'] })
                .then(function() {
                    fs.writeFileSync(
                        path.join(tempPackage, '.bower.json'),
                        JSON.stringify(json)
                    );

                    return packageRepository
                        .fetch({ name: '', source: 'foo', target: '~0.2.0' })
                        .spread(function(canonicalDir, pkgMeta) {
                            expect(called).to.eql(['hasNew', 'resolve']);
                            expect(fs.existsSync(canonicalDir)).to.be(true);
                            expect(pkgMeta).to.be.an('object');
                            expect(pkgMeta.name).to.be('a');
                            expect(pkgMeta.version).to.be('0.2.2');
                            next();
                        });
                })
                .done();
        });

        it('should resolve to the cached package if hasNew resolve to false', function(next) {
            var json = {
                name: 'a',
                version: '0.2.0'
            };
            var called = [];

            resolverFactoryHook = function(resolver) {
                var originalResolve = resolver.resolve;

                resolver.resolve = function() {
                    called.push('resolve');
                    return originalResolve.apply(this, arguments);
                };

                resolver.hasNew = function(pkgMeta) {
                    expect(pkgMeta).to.eql(json);
                    called.push('hasNew');
                    return Q.resolve(false);
                };
            };

            packageRepository._resolveCache.retrieve = function() {
                return Q.resolve([tempPackage, json]);
            };

            copy.copyDir(testPackage, tempPackage, { ignore: ['.git'] })
                .then(function() {
                    fs.writeFileSync(
                        path.join(tempPackage, '.bower.json'),
                        JSON.stringify(json)
                    );

                    return packageRepository
                        .fetch({ name: '', source: 'foo', target: '~0.2.0' })
                        .spread(function(canonicalDir, pkgMeta) {
                            expect(called).to.eql(['hasNew']);
                            expect(canonicalDir).to.equal(tempPackage);
                            expect(pkgMeta).to.eql(json);
                            next();
                        });
                })
                .done();
        });

        it('should just use the cached package if offline was specified', function(next) {
            var json = {
                name: 'a',
                version: '0.2.0'
            };
            var called = [];

            resolverFactoryHook = function(resolver) {
                var originalResolve = resolver.resolve;

                resolver.hasNew = function(pkgMeta) {
                    expect(pkgMeta).to.eql(json);
                    called.push('resolve');
                    return originalResolve.apply(this, arguments);
                };

                resolver.hasNew = function() {
                    called.push('hasNew');
                    return Q.resolve(false);
                };
            };

            packageRepository._resolveCache.retrieve = function() {
                return Q.resolve([tempPackage, json]);
            };

            copy.copyDir(testPackage, tempPackage, { ignore: ['.git'] })
                .then(function() {
                    fs.writeFileSync(
                        path.join(tempPackage, '.bower.json'),
                        JSON.stringify(json)
                    );

                    packageRepository._config.offline = true;
                    return packageRepository
                        .fetch({ name: '', source: 'foo', target: '~0.2.0' })
                        .spread(function(canonicalDir, pkgMeta) {
                            expect(called.length).to.be(0);
                            expect(canonicalDir).to.equal(tempPackage);
                            expect(pkgMeta).to.eql(json);
                            next();
                        });
                })
                .done();
        });

        it('should error out if there is no appropriate package in the resolve cache and offline was specified', function(next) {
            packageRepository._config.offline = true;
            packageRepository
                .fetch({ name: '', source: 'foo', target: '~0.2.0' })
                .then(
                    function() {
                        throw new Error('Should have failed');
                    },
                    function(err) {
                        expect(err).to.be.an(Error);
                        expect(err.code).to.equal('ENOCACHE');

                        next();
                    }
                )
                .done();
        });
    });

    describe('.versions', function() {
        it('should call the versions method on the concrete resolver', function(next) {
            var called = [];
            var originalVersions = resolvers.GitRemote.versions;

            resolvers.GitRemote.versions = function(source) {
                expect(source).to.equal(mockSource);
                called.push('resolver');
                return Q.resolve([]);
            };

            packageRepository._resolveCache.versions = function() {
                called.push('resolve-cache');
                return Q.resolve([]);
            };

            packageRepository
                .versions('foo')
                .then(function(versions) {
                    expect(called).to.eql(['resolver']);
                    expect(versions).to.be.an('array');
                    expect(versions.length).to.be(0);

                    next();
                })
                .fin(function() {
                    resolvers.GitRemote.versions = originalVersions;
                })
                .done();
        });

        it('should call the versions method on the resolve cache if offline was specified', function(next) {
            var called = [];
            var originalVersions = resolvers.GitRemote.versions;

            resolvers.GitRemote.versions = function() {
                called.push('resolver');
                return Q.resolve([]);
            };

            packageRepository._resolveCache.versions = function(source) {
                expect(source).to.equal(mockSource);
                called.push('resolve-cache');
                return Q.resolve([]);
            };

            packageRepository._config.offline = true;
            packageRepository
                .versions('foo')
                .then(function(versions) {
                    expect(called).to.eql(['resolve-cache']);
                    expect(versions).to.be.an('array');
                    expect(versions.length).to.be(0);

                    next();
                })
                .fin(function() {
                    resolvers.GitRemote.versions = originalVersions;
                })
                .done();
        });
    });

    describe('.eliminate', function() {
        it('should call the eliminate method from the resolve cache', function(next) {
            var called;
            var json = {
                name: 'a',
                version: '0.2.0',
                _source: 'foo'
            };

            packageRepository._resolveCache.eliminate = function(pkgMeta) {
                expect(pkgMeta).to.eql(json);
                called = true;
                return Q.resolve();
            };

            packageRepository
                .eliminate(json)
                .then(function() {
                    expect(called).to.be(true);
                    next();
                })
                .done();
        });

        it('should call the clearCache method with the name from the registry client', function(next) {
            var called;
            var json = {
                name: 'a',
                version: '0.2.0',
                _source: 'foo'
            };

            packageRepository._registryClient.clearCache = function(
                name,
                callback
            ) {
                expect(name).to.eql(json.name);
                called = true;
                callback();
            };

            packageRepository
                .eliminate(json)
                .then(function() {
                    expect(called).to.be(true);
                    next();
                })
                .done();
        });
    });

    describe('.list', function() {
        it('should proxy to the resolve cache list method', function(next) {
            var called;
            var originalList = packageRepository._resolveCache.list;

            packageRepository._resolveCache.list = function() {
                called = true;
                return originalList.apply(this, arguments);
            };

            packageRepository
                .list()
                .then(function(entries) {
                    expect(called).to.be(true);
                    expect(entries).to.be.an('array');
                    next();
                })
                .done();
        });
    });

    describe('.clear', function() {
        it('should call the clear method from the resolve cache', function(next) {
            var called;

            packageRepository._resolveCache.clear = function() {
                called = true;
                return Q.resolve();
            };

            packageRepository
                .clear()
                .then(function() {
                    expect(called).to.be(true);
                    next();
                })
                .done();
        });

        it('should call the clearCache method without name from the registry client', function(next) {
            var called;

            packageRepository._registryClient.clearCache = function(callback) {
                called = true;
                callback();
            };

            packageRepository
                .clear()
                .then(function() {
                    expect(called).to.be(true);
                    next();
                })
                .done();
        });
    });

    describe('.reset', function() {
        it('should call the reset method from the resolve cache', function() {
            var called;

            packageRepository._resolveCache.reset = function() {
                called = true;
                return packageRepository._resolveCache;
            };

            packageRepository.reset();
            expect(called).to.be(true);
        });

        it('should call the resetCache method without name from the registry client', function() {
            var called;

            packageRepository._registryClient.resetCache = function() {
                called = true;
                return packageRepository._registryClient;
            };

            packageRepository.reset();
            expect(called).to.be(true);
        });
    });

    describe('.getRegistryClient', function() {
        it('should return the underlying registry client', function() {
            expect(packageRepository.getRegistryClient()).to.be.an(
                RegistryClient
            );
        });
    });

    describe('.getResolveCache', function() {
        it('should return the underlying resolve cache', function() {
            expect(packageRepository.getResolveCache()).to.be.an(ResolveCache);
        });
    });

    describe('#clearRuntimeCache', function() {
        it('should clear the resolve cache runtime cache', function() {
            var called;
            var originalClearRuntimeCache = ResolveCache.clearRuntimeCache;

            // No need to restore the original method since the constructor
            // gets re-assigned every time in beforeEach
            ResolveCache.clearRuntimeCache = function() {
                called = true;
                return originalClearRuntimeCache.apply(ResolveCache, arguments);
            };

            packageRepository.constructor.clearRuntimeCache();
            expect(called).to.be(true);
        });

        it('should clear the resolver factory runtime cache', function() {
            var called;

            resolverFactoryClearHook = function() {
                called = true;
            };

            packageRepository.constructor.clearRuntimeCache();
            expect(called).to.be(true);
        });

        it('should clear the registry runtime cache', function() {
            var called;
            var originalClearRuntimeCache = RegistryClient.clearRuntimeCache;

            // No need to restore the original method since the constructor
            // gets re-assigned every time in beforeEach
            RegistryClient.clearRuntimeCache = function() {
                called = true;
                return originalClearRuntimeCache.apply(
                    RegistryClient,
                    arguments
                );
            };

            packageRepository.constructor.clearRuntimeCache();
            expect(called).to.be(true);
        });
    });
});