mirror of
https://github.com/bower/bower.git
synced 2026-02-11 22:44:58 -05:00
Add initial tests for the Resolver, fix some bugs.
This commit is contained in:
André Cruz
417
test/resolve/resolver.js
Normal file
417
test/resolve/resolver.js
Normal file
@@ -0,0 +1,417 @@
|
||||
var expect = require('expect.js');
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var util = require('util');
|
||||
var mkdirp = require('mkdirp');
|
||||
var rimraf = require('rimraf');
|
||||
var Resolver = require('../../lib/resolve/Resolver');
|
||||
|
||||
describe('Resolver', function () {
|
||||
describe('.getSource', function () {
|
||||
it('should return the resolver source', function () {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
expect(resolver.getSource()).to.equal('foo');
|
||||
});
|
||||
});
|
||||
|
||||
describe('.getName', function () {
|
||||
it('should return the resolver name', function () {
|
||||
var resolver = new Resolver('foo', { name: 'bar' });
|
||||
|
||||
expect(resolver.getName()).to.equal('bar');
|
||||
});
|
||||
|
||||
it('should return the resolver source if none is specified (default guess mechanism)', function () {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
expect(resolver.getName()).to.equal('foo');
|
||||
});
|
||||
});
|
||||
|
||||
describe('.getTarget', function () {
|
||||
it('should return the resolver target', function () {
|
||||
var resolver = new Resolver('foo', { target: '~2.1.0' });
|
||||
|
||||
expect(resolver.getTarget()).to.equal('~2.1.0');
|
||||
});
|
||||
|
||||
it('should return * if none was configured', function () {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
expect(resolver.getTarget()).to.equal('*');
|
||||
});
|
||||
});
|
||||
|
||||
describe('.hasNew', function () {
|
||||
it('should return a promise', function (done) {
|
||||
var resolver = new Resolver('foo'),
|
||||
promise = resolver.hasNew('.');
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.an('function');
|
||||
promise.then(done.bind(done, null), done.bind(done, null));
|
||||
});
|
||||
|
||||
it('should resolve to true by default', function (next) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver.hasNew('.')
|
||||
.then(function (hasNew) {
|
||||
expect(hasNew).to.equal(true);
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('.resolve', function () {
|
||||
it('should return a promise', function (done) {
|
||||
var resolver = new Resolver('foo'),
|
||||
promise = resolver.resolve();
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.an('function');
|
||||
promise.then(done.bind(done, null), done.bind(done, null));
|
||||
});
|
||||
|
||||
it('should reject the promise if _resolveSelf is not implemented', function (done) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver.resolve()
|
||||
.then(function () {
|
||||
done(new Error('Should have rejected the promise'));
|
||||
}, function (err) {
|
||||
expect(err).to.be.an(Error);
|
||||
expect(err.message).to.contain('not implemented');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should call all the functions necessary to resolve by the correct order', function (next) {
|
||||
function DummyResolver() {
|
||||
Resolver.apply(this, arguments);
|
||||
this._stack = [];
|
||||
}
|
||||
|
||||
util.inherits(DummyResolver, Resolver);
|
||||
|
||||
DummyResolver.prototype.getStack = function () {
|
||||
return this._stack;
|
||||
};
|
||||
|
||||
DummyResolver.prototype.resolve = function () {
|
||||
this._stack = [];
|
||||
return Resolver.prototype.resolve.apply(this, arguments);
|
||||
};
|
||||
|
||||
DummyResolver.prototype._createTempDir = function () {
|
||||
this._stack.push('before _createTempDir');
|
||||
return Resolver.prototype._createTempDir.apply(this, arguments)
|
||||
.then(function (val) {
|
||||
this._stack.push('after _createTempDir');
|
||||
return val;
|
||||
}.bind(this));
|
||||
};
|
||||
DummyResolver.prototype._resolveSelf = function () {};
|
||||
DummyResolver.prototype._readJson = function () {
|
||||
this._stack.push('before _readJson');
|
||||
return Resolver.prototype._readJson.apply(this, arguments)
|
||||
.then(function (val) {
|
||||
this._stack.push('after _readJson');
|
||||
return val;
|
||||
}.bind(this));
|
||||
};
|
||||
DummyResolver.prototype._applyPkgMeta = function () {
|
||||
this._stack.push('before _applyPkgMeta');
|
||||
return Resolver.prototype._applyPkgMeta.apply(this, arguments)
|
||||
.then(function (val) {
|
||||
this._stack.push('after _applyPkgMeta');
|
||||
return val;
|
||||
}.bind(this));
|
||||
};
|
||||
DummyResolver.prototype._savePkgMeta = function () {
|
||||
this._stack.push('before _savePkgMeta');
|
||||
return Resolver.prototype._savePkgMeta.apply(this, arguments)
|
||||
.then(function (val) {
|
||||
this._stack.push('after _savePkgMeta');
|
||||
return val;
|
||||
}.bind(this));
|
||||
};
|
||||
|
||||
var resolver = new DummyResolver('foo');
|
||||
|
||||
resolver.resolve()
|
||||
.then(function () {
|
||||
expect(resolver.getStack()).to.eql([
|
||||
'before _createTempDir',
|
||||
'after _createTempDir',
|
||||
'before _readJson',
|
||||
'after _readJson',
|
||||
// Both below are called in parallel
|
||||
'before _applyPkgMeta',
|
||||
'before _savePkgMeta',
|
||||
'after _applyPkgMeta',
|
||||
'after _savePkgMeta'
|
||||
]);
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
it('should resolve with the canonical package (folder)', function (next) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver._resolveSelf = function () {};
|
||||
|
||||
resolver.resolve()
|
||||
.then(function (folder) {
|
||||
expect(folder).to.be.a('string');
|
||||
expect(fs.existsSync(folder)).to.be(true);
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('.getTempDir', function () {
|
||||
it('should return null if resolver is not yet resolved', function () {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
expect(resolver.getTempDir() == null).to.be(true);
|
||||
});
|
||||
|
||||
it('should still return null if resolved failed', function () {
|
||||
it('should still return null', function (next) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver._resolveSelf = function () {
|
||||
throw new Error('I\'ve failed to resolve');
|
||||
};
|
||||
|
||||
resolver.resolve()
|
||||
.then(null, function () {
|
||||
expect(resolver.getTempDir() == null).to.be(true);
|
||||
next();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should return the canonical package (folder) if resolve succeeded', function (next) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver._resolveSelf = function () {};
|
||||
|
||||
resolver.resolve()
|
||||
.then(function () {
|
||||
var dir = resolver.getTempDir();
|
||||
|
||||
expect(dir).to.be.a('string');
|
||||
expect(fs.existsSync(dir)).to.be(true);
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('.getPkgMeta', function () {
|
||||
it('should return null if resolver is not yet resolved', function () {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
expect(resolver.getPkgMeta() == null).to.be(true);
|
||||
});
|
||||
|
||||
it('should still return null if resolved failed', function () {
|
||||
it('should still return null', function (next) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver._resolveSelf = function () {
|
||||
throw new Error('I\'ve failed to resolve');
|
||||
};
|
||||
|
||||
resolver.resolve()
|
||||
.then(null, function () {
|
||||
expect(resolver.getPkgMeta() == null).to.be(true);
|
||||
next();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should return the package meta if resolve succeeded', function (next) {
|
||||
var resolver = new Resolver('foo');
|
||||
|
||||
resolver._resolveSelf = function () {};
|
||||
|
||||
resolver.resolve()
|
||||
.then(function () {
|
||||
expect(resolver.getPkgMeta()).to.be.an('object');
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('_createTempDir', function () {
|
||||
it('should return a promise', function (done) {
|
||||
var resolver = new Resolver('foo'),
|
||||
promise = resolver._createTempDir();
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.an('function');
|
||||
promise.then(done.bind(done, null), done.bind(done, null));
|
||||
});
|
||||
it.skip('should create a directory inside a bower folder, located within the OS temp folder');
|
||||
it.skip('should set the dir mode the same as the process');
|
||||
it.skip('should remove the folder after execution');
|
||||
it.skip('should set _tempDir with the created directory');
|
||||
});
|
||||
|
||||
describe('_readJson', function () {
|
||||
it('should return a promise', function (done) {
|
||||
var resolver = new Resolver('foo'),
|
||||
promise = resolver._readJson();
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.an('function');
|
||||
promise.then(done.bind(done, null), done.bind(done, null));
|
||||
});
|
||||
it.skip('should read the bower.json file');
|
||||
it.skip('should fallback to component.json');
|
||||
it.skip('should resolve to an inferred json if no json file was found');
|
||||
it.skip('should apply normalisation, defaults and validation to the json object');
|
||||
});
|
||||
|
||||
describe('_applyPkgMeta', function () {
|
||||
it('should return a promise', function (done) {
|
||||
var resolver = new Resolver('foo'),
|
||||
promise = resolver._applyPkgMeta({ name: 'foo' });
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.an('function');
|
||||
promise.then(done.bind(done, null), done.bind(done, null));
|
||||
});
|
||||
|
||||
it('should resolve with the the same package meta', function (next) {
|
||||
var resolver = new Resolver('foo'),
|
||||
meta = { name: 'foo' };
|
||||
|
||||
resolver._applyPkgMeta(meta)
|
||||
.then(function (retMeta) {
|
||||
expect(retMeta).to.equal(meta);
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
it('should fire the "name_change" event if the json name is different than the guessed one', function (next) {
|
||||
var resolver = new Resolver('foo'),
|
||||
newName;
|
||||
|
||||
resolver.on('name_change', function (name) {
|
||||
newName = name;
|
||||
});
|
||||
|
||||
resolver._applyPkgMeta({ name: 'bar' })
|
||||
.then(function (retMeta) {
|
||||
expect(retMeta.name).to.equal('bar');
|
||||
expect(resolver.getName()).to.equal('bar');
|
||||
expect(newName).to.equal('bar');
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
it('should not fire the "name_change" event if the json name is different but the name was not guessed', function (next) {
|
||||
var resolver = new Resolver('foo', { name: 'foo' }),
|
||||
newName;
|
||||
|
||||
resolver.on('name_change', function (name) {
|
||||
newName = name;
|
||||
});
|
||||
|
||||
resolver._applyPkgMeta({ name: 'bar' })
|
||||
.then(function (retMeta) {
|
||||
expect(retMeta.name).to.equal('foo');
|
||||
expect(resolver.getName()).to.equal('foo');
|
||||
expect(newName).to.not.be.ok();
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
it('should not fire the "name_change" event the json name is the same', function (next) {
|
||||
var resolver = new Resolver('foo'),
|
||||
newName;
|
||||
|
||||
resolver.on('name_change', function (name) {
|
||||
newName = name;
|
||||
});
|
||||
|
||||
resolver._applyPkgMeta({ name: 'foo' })
|
||||
.then(function (retMeta) {
|
||||
expect(retMeta.name).to.equal('foo');
|
||||
expect(resolver.getName()).to.equal('foo');
|
||||
expect(newName).to.not.be.ok();
|
||||
|
||||
resolver = new Resolver('foo', { name: 'foo' });
|
||||
|
||||
resolver.on('name_change', function (name) {
|
||||
newName = name;
|
||||
});
|
||||
|
||||
resolver._applyPkgMeta({ name: 'foo' })
|
||||
.then(function (retMeta) {
|
||||
expect(retMeta.name).to.equal('foo');
|
||||
expect(resolver.getName()).to.equal('foo');
|
||||
expect(newName).to.not.be.ok();
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
|
||||
describe('handling of ignore property according to the .gitignore spec', function () {
|
||||
it.skip('A blank line matches no files, so it can serve as a separator for readability.');
|
||||
it.skip('A line starting with # serves as a comment.');
|
||||
it.skip('An optional prefix ! which negates the pattern; any matching file excluded by a previous pattern will become included again...', function () {
|
||||
// If a negated pattern matches, this will override lower precedence patterns sources. Put a backslash ("\") in front of the first "!" for patterns that begin with a literal "!", for example, "\!important!.txt".
|
||||
});
|
||||
it.skip('If the pattern ends with a slash, it is removed for the purpose of the following description, but it would only find a match with a directory...', function () {
|
||||
// In other words, foo/ will match a directory foo and paths underneath it, but will not match a regular file or a symbolic link foo (this is consistent with the way how pathspec works in general in git).
|
||||
});
|
||||
it.skip('If the pattern does not contain a slash /, git treats it as a shell glob pattern and checks for a match against the pathname without leading directories.');
|
||||
it.skip('Otherwise, git treats the pattern as a shell glob suitable for consumption by fnmatch(3) with the FNM_PATHNAME flag..', function () {
|
||||
// wildcards in the pattern will not match a / in the pathname. For example, "Documentation/*.html" matches "Documentation/git.html" but not "Documentation/ppc/ppc.html" or "tools/perf/Documentation/perf.html".
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('_savePkgMeta', function () {
|
||||
var tempDir = path.normalize(__dirname + '/../assets/tmp');
|
||||
|
||||
beforeEach(function (next) {
|
||||
mkdirp(tempDir, next);
|
||||
});
|
||||
|
||||
afterEach(function (next) {
|
||||
rimraf(tempDir, next);
|
||||
});
|
||||
|
||||
it('should return a promise', function (done) {
|
||||
var resolver = new Resolver('foo'),
|
||||
promise;
|
||||
|
||||
resolver._tempDir = tempDir;
|
||||
promise = resolver._savePkgMeta({ name: 'foo' });
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.an('function');
|
||||
promise.then(done.bind(done, null), done.bind(done, null));
|
||||
});
|
||||
|
||||
it.skip('should resolve with the the same package meta');
|
||||
it.skip('should save the package meta to the package meta file (.bower.json)');
|
||||
});
|
||||
});
|
||||
@@ -1,6 +1,6 @@
|
||||
var expect = require('expect.js');
|
||||
var Q = require('Q');
|
||||
var Worker = require('../lib/resolve/Worker');
|
||||
var Worker = require('../../lib/resolve/Worker');
|
||||
|
||||
describe('Worker', function () {
|
||||
var timeout;
|
||||
@@ -19,71 +19,74 @@ describe('Worker', function () {
|
||||
|
||||
promise = worker.enqueue(function () { return Q.resolve('foo'); });
|
||||
|
||||
expect(promise).to.be.an('object');
|
||||
expect(promise.then).to.be.a('function');
|
||||
});
|
||||
|
||||
it('should call the function and resolve', function (done) {
|
||||
it('should call the function and resolve', function (next) {
|
||||
var worker = new Worker();
|
||||
|
||||
worker.enqueue(function () { return Q.resolve('foo'); })
|
||||
.then(function (ret) {
|
||||
expect(ret).to.equal('foo');
|
||||
done();
|
||||
});
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
it('should work with functions that return values syncronously', function (done) {
|
||||
it('should work with functions that return values syncronously', function (next) {
|
||||
var worker = new Worker();
|
||||
|
||||
worker.enqueue(function () { return 'foo'; })
|
||||
.then(function (ret) {
|
||||
expect(ret).to.equal('foo');
|
||||
done();
|
||||
});
|
||||
next();
|
||||
})
|
||||
.done();
|
||||
});
|
||||
|
||||
it('should assume the default concurrency when a type is not specified', function (done) {
|
||||
it('should assume the default concurrency when a type is not specified', function (next) {
|
||||
var worker = new Worker(1),
|
||||
calls = 0;
|
||||
|
||||
worker.enqueue(function () { calls++; return Q.defer().promise; });
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); });
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(1);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should assume the default concurrency when a type is not known', function (done) {
|
||||
it('should assume the default concurrency when a type is not known', function (next) {
|
||||
var worker = new Worker(1),
|
||||
calls = 0;
|
||||
|
||||
worker.enqueue(function () { calls++; return Q.defer().promise; }, 'foo_type');
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); }, 'foo_type');
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); }, 'foo_type');
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(1);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should have different slots when type is not passed or is not known', function (done) {
|
||||
it('should have different slots when type is not passed or is not known', function (next) {
|
||||
var worker = new Worker(1),
|
||||
calls = 0;
|
||||
|
||||
worker.enqueue(function () { calls++; return Q.defer().promise; });
|
||||
worker.enqueue(function () { calls++; return Q.defer().promise; }, 'foo_type');
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); }, 'foo_type');
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); }, 'foo_type');
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(2);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should use the configured concurrency for the type', function (done) {
|
||||
it('should use the configured concurrency for the type', function (next) {
|
||||
var worker = new Worker(1, {
|
||||
foo: 2,
|
||||
bar: 3
|
||||
@@ -95,35 +98,35 @@ describe('Worker', function () {
|
||||
};
|
||||
|
||||
worker.enqueue(function () { calls.def++; return Q.defer().promise; });
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { calls.foo++; return Q.defer().promise; }, 'foo');
|
||||
worker.enqueue(function () { calls.foo++; return Q.defer().promise; }, 'foo');
|
||||
worker.enqueue(function () { calls.bar++; return Q.defer().promise; }, 'bar');
|
||||
worker.enqueue(function () { calls.bar++; return Q.defer().promise; }, 'bar');
|
||||
worker.enqueue(function () { calls.bar++; return Q.defer().promise; }, 'bar');
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); }, 'bar');
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); }, 'bar');
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls.def).to.equal(1);
|
||||
expect(calls.foo).to.equal(2);
|
||||
expect(calls.bar).to.equal(3);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
});
|
||||
|
||||
describe('.abort', function () {
|
||||
it('should clear the whole queue', function (done) {
|
||||
it('should clear the whole queue', function (next) {
|
||||
var worker = new Worker(1, {
|
||||
foo: 2
|
||||
}),
|
||||
calls = 0;
|
||||
|
||||
worker.enqueue(function () { calls++; return Q.resolve(); });
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); });
|
||||
worker.enqueue(function () { calls++; return Q.resolve(); }, 'foo');
|
||||
worker.enqueue(function () { calls++; return Q.resolve(); }, 'foo');
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); }, 'foo');
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); }, 'foo');
|
||||
|
||||
worker.abort();
|
||||
|
||||
@@ -131,11 +134,11 @@ describe('Worker', function () {
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(4);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should wait for currently running functions to finish', function (done) {
|
||||
it('should wait for currently running functions to finish', function (next) {
|
||||
var worker = new Worker(1, {
|
||||
foo: 2
|
||||
}),
|
||||
@@ -157,7 +160,7 @@ describe('Worker', function () {
|
||||
timeout = setTimeout(function () {
|
||||
worker.abort().then(function () {
|
||||
expect(calls).to.eql([1, 2, 3]);
|
||||
done();
|
||||
next();
|
||||
});
|
||||
}, 30);
|
||||
});
|
||||
@@ -165,7 +168,7 @@ describe('Worker', function () {
|
||||
|
||||
|
||||
describe('scheduler', function () {
|
||||
it('should start remaining tasks when one ends', function (done) {
|
||||
it('should start remaining tasks when one ends', function (next) {
|
||||
var worker = new Worker(1, {
|
||||
foo: 2
|
||||
}),
|
||||
@@ -179,11 +182,11 @@ describe('Worker', function () {
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(5);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should respect the enqueue order', function (done) {
|
||||
it('should respect the enqueue order', function (next) {
|
||||
var worker = new Worker(1),
|
||||
defCalls = [],
|
||||
fooCalls = [];
|
||||
@@ -221,11 +224,11 @@ describe('Worker', function () {
|
||||
timeout = setTimeout(function () {
|
||||
expect(defCalls).to.eql([1, 2, 3]);
|
||||
expect(fooCalls).to.eql([1, 2, 3]);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should wait for one slot in every type on a multi-type function', function (done) {
|
||||
it('should wait for one slot in every type on a multi-type function', function (next) {
|
||||
var worker = new Worker(1, {
|
||||
foo: 1,
|
||||
bar: 2
|
||||
@@ -236,17 +239,17 @@ describe('Worker', function () {
|
||||
worker.enqueue(function () { return Q.defer().promise; }, 'bar');
|
||||
|
||||
worker.enqueue(function () { calls++; return Q.resolve(); }, 'bar');
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); }, ['foo', 'bar']);
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); }, ['foo', 'bar']);
|
||||
worker.enqueue(function () { calls++; return Q.resolve(); }, 'bar');
|
||||
worker.enqueue(function () { done(new Error('Should not be called!')); }, 'foo');
|
||||
worker.enqueue(function () { next(new Error('Should not be called!')); }, 'foo');
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(2);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
|
||||
it('should free all type slots when finished running a function', function (done) {
|
||||
it('should free all type slots when finished running a function', function (next) {
|
||||
var worker = new Worker(1, {
|
||||
foo: 1,
|
||||
bar: 2
|
||||
@@ -260,7 +263,7 @@ describe('Worker', function () {
|
||||
|
||||
timeout = setTimeout(function () {
|
||||
expect(calls).to.equal(3);
|
||||
done();
|
||||
next();
|
||||
}, 100);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -48,4 +48,7 @@ if (process.argv[1] && !/mocha/.test(process.argv[1])) {
|
||||
|
||||
//testGitFsResolver();
|
||||
//testGitRemoteResolverNoTags();
|
||||
} else {
|
||||
require('./resolve/resolver');
|
||||
require('./resolve/worker');
|
||||
}
|
||||
Reference in New Issue
Block a user