859 lines
25 KiB
JavaScript
859 lines
25 KiB
JavaScript
const { Provider } = require('nconf');
|
|
const nconf = new Provider();
|
|
const { assert } = require('chai');
|
|
const Promise = require('bluebird');
|
|
const _ = require('lodash');
|
|
|
|
const { TorPool } = require('../');
|
|
const { WAIT_FOR_CREATE } = require('./constants');
|
|
|
|
nconf.use('memory');
|
|
require(`${__dirname}/../src/nconf_load_env.js`)(nconf);
|
|
nconf.defaults(require(`${__dirname}/../src/default_config.js`));
|
|
|
|
describe('TorPool', function () {
|
|
const torPoolFactory = () => new TorPool(nconf.get('torPath'), {}, nconf.get('parentDataDirectory'), 'round_robin', null);
|
|
|
|
describe('#default_tor_config', function () {
|
|
let tor_pool;
|
|
let cfg = { "TestSocks": 1, "Log": "notice stdout", "NewCircuitPeriod": "10" };
|
|
|
|
before('create tor config based on nconf', function () {
|
|
nconf.set('torConfig', cfg);
|
|
tor_pool = new TorPool(nconf.get('torPath'), (() => nconf.get('torConfig')), nconf.get('parentDataDirectory'), 'round_robin', null);
|
|
});
|
|
|
|
it('the tor config should have the same value as set in nconf', function () {
|
|
assert.deepEqual(nconf.get('torConfig'), tor_pool.default_tor_config);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
|
|
before('create tor config based on nconf', function () {
|
|
tor_pool = new TorPool(nconf.get('torPath'), cfg, nconf.get('parentDataDirectory'), 'round_robin', null);
|
|
});
|
|
|
|
it('the tor config should have the same value as set', function () {
|
|
assert.deepEqual(cfg, tor_pool.default_tor_config);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#create_instance(instance_defintion)', function () {
|
|
|
|
let instance_defintion = {
|
|
Name: 'instance-1',
|
|
Config: {
|
|
ProtocolWarnings: 1
|
|
}
|
|
};
|
|
|
|
let torPool;
|
|
before('create tor pool', () => { torPool = torPoolFactory(); })
|
|
|
|
it('should create one tor instance based on the provided definition', async function () {
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create_instance(instance_defintion);
|
|
});
|
|
|
|
it('one instance should exist in the instances collection', function () {
|
|
assert.equal(1, torPool.instances.length);
|
|
});
|
|
|
|
it('the created instance should have the defintion properties as the input definition', function () {
|
|
assert.deepEqual(instance_defintion, torPool.instances[0].definition);
|
|
});
|
|
|
|
it('the created instance should have the same config properties specified in the definiton', async function () {
|
|
let value = await torPool.instances[0].get_config('ProtocolWarnings');
|
|
assert.equal(value, instance_defintion.Config.ProtocolWarnings);
|
|
});
|
|
|
|
it('should not be able to create an instance with an existing name', async function () {
|
|
this.timeout(WAIT_FOR_CREATE * 2);
|
|
let fn = () => {}
|
|
|
|
try {
|
|
await torPool.create_instance({ Name: 'foo' });
|
|
await torPool.create_instance({ Name: 'foo' });
|
|
}
|
|
catch (error) {
|
|
fn = () => { throw error };
|
|
} finally {
|
|
assert.throws(fn);
|
|
}
|
|
});
|
|
|
|
after('shutdown tor pool', async function () {
|
|
await torPool.exit();
|
|
});
|
|
});
|
|
|
|
describe('#add(instance_defintions)', function () {
|
|
let instance_defintions = [
|
|
{ Name: 'instance-1', Group: [], Config: { ProtocolWarnings: 1} },
|
|
{ Name: 'instance-2', Group: [], Config: { ProtocolWarnings: 1 } }
|
|
];
|
|
|
|
let torPool;
|
|
before('create tor pool', () => { torPool = torPoolFactory(); })
|
|
|
|
it('should throw if the "instance_defintions" field is falsy', async function () {
|
|
let fn = () => {};
|
|
try {
|
|
await torPool.add();
|
|
} catch (error) {
|
|
fn = () => { throw error };
|
|
}
|
|
finally {
|
|
assert.throws(fn);
|
|
}
|
|
});
|
|
|
|
it('should create instances from several instance definitions', async function () {
|
|
this.timeout(WAIT_FOR_CREATE*2);
|
|
await torPool.add(_.cloneDeep(instance_defintions))
|
|
});
|
|
|
|
it('2 instances should exist in the pool', function () {
|
|
assert.equal(2, torPool.instances.length);
|
|
});
|
|
|
|
it('the created instances should have the same defintion properties as the input definitions', function () {
|
|
let live_instance_definitions = torPool.instances.map((instance) => {
|
|
let def_clone = _.cloneDeep(instance.definition);
|
|
delete def_clone.Config.DataDirectory;
|
|
return def_clone;
|
|
}).sort((a,b) => (a.Name > b.Name) ? 1 : ((b.Name > a.Name) ? -1 : 0));
|
|
|
|
assert.deepEqual(instance_defintions, live_instance_definitions);
|
|
});
|
|
|
|
it('the created instances should have the same config properties specified in the definiton', async function () {
|
|
this.timeout(10000);
|
|
|
|
let values = await Promise.all(torPool.instances.map((instance) => instance.get_config('ProtocolWarnings')));
|
|
values = _.flatten(values);
|
|
assert.isTrue( values.every((value) => value === "1") );
|
|
});
|
|
|
|
after('shutdown tor pool', async function () {
|
|
await torPool.exit();
|
|
});
|
|
});
|
|
|
|
describe('#create(instances)', function () {
|
|
let torPool;
|
|
|
|
before('create tor pool', () => {
|
|
torPool = torPoolFactory();
|
|
torPool.default_tor_config = { TestSocks: 1 };
|
|
});
|
|
|
|
it('should throw if the "number_of_instances" field is falsy', async function () {
|
|
let fn = () => {};
|
|
try {
|
|
await torPool.create();
|
|
} catch (error) {
|
|
fn = () => { throw error; }
|
|
}
|
|
finally {
|
|
assert.throws(fn);
|
|
}
|
|
});
|
|
|
|
it('should create 2 instances with the default config', async function () {
|
|
this.timeout(WAIT_FOR_CREATE*2);
|
|
await torPool.create(2);
|
|
});
|
|
|
|
it('2 instances should exist in the pool', function () {
|
|
assert.equal(2, torPool.instances.length);
|
|
});
|
|
|
|
it('the created instances should have the same config properties specified in the default config', async function () {
|
|
this.timeout(10000);
|
|
|
|
let values = await Promise.all(torPool.instances.map((instance) => instance.get_config('TestSocks')));
|
|
values = _.flatten(values);
|
|
assert.isTrue( values.every((value) => value === "1") );
|
|
});
|
|
|
|
after('shutdown tor pool', async function () {
|
|
torPool.default_tor_config = {};
|
|
await torPool.exit();
|
|
});
|
|
});
|
|
|
|
describe('#instances_by_group(group)', function () {
|
|
let tor_pool;
|
|
let instances;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instances = (await tor_pool.add([ { Name: 'instance-1', Group: [ "bar", "foo" ] }, { Name: 'instance-2', Group: ["foo", "bar"] } ]));
|
|
});
|
|
|
|
it('should throw if the provided group does not exist', function () {
|
|
assert.throws(() => {
|
|
tor_pool.instances_by_group('baz');
|
|
});
|
|
});
|
|
|
|
it('should return both instances', function () {
|
|
assert.deepEqual(tor_pool.instances_by_group('bar'), instances);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#next()', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE * 3);
|
|
await torPool.add([
|
|
{
|
|
Name: 'instance-1',
|
|
Weight: 50,
|
|
Group: 'foo'
|
|
},
|
|
{
|
|
Name: 'instance-2',
|
|
Weight: 25,
|
|
Group: 'bar'
|
|
},
|
|
{
|
|
Name: 'instance-3',
|
|
Weight: 2,
|
|
Group: 'bar'
|
|
}
|
|
]);
|
|
});
|
|
|
|
it('result of next should be different if run twice', function () {
|
|
let t1 = torPool.next().instance_name;
|
|
let t2 = torPool.next().instance_name;
|
|
assert.notEqual(t1, t2);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
|
|
describe('#next_by_group(group)', function () {
|
|
let tor_pool;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = new TorPool(nconf.get('torPath'), (() => nconf.get('torConfig')), nconf.get('parentDataDirectory'), 'round_robin', null);
|
|
this.timeout(WAIT_FOR_CREATE * 3);
|
|
await tor_pool.add([
|
|
{ Group: 'foo' },
|
|
{ Group: 'bar' },
|
|
{ Group: 'bar' }
|
|
]);
|
|
});
|
|
|
|
it('after rotating the first instance in group should be different', function () {
|
|
let first_instance_name_before = tor_pool.groups['bar'][0].instance_name;
|
|
|
|
tor_pool.next_by_group('bar');
|
|
|
|
let first_instance_name_after = tor_pool.groups['bar'][0].instance_name;
|
|
|
|
assert.notEqual(first_instance_name_after, first_instance_name_before);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#instance_by_name(instance_name)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add([
|
|
{
|
|
Name: 'instance-1'
|
|
}
|
|
]);
|
|
});
|
|
|
|
it('should retrieve instance by name', function () {
|
|
assert.ok(torPool.instance_by_name('instance-1'));
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#remove_by_name(instance_name)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add([
|
|
{
|
|
Name: 'instance-3'
|
|
}
|
|
]);
|
|
});
|
|
|
|
it('should remove instance by name', async function () {
|
|
this.timeout(5000);
|
|
|
|
await torPool.remove_by_name('instance-3');
|
|
|
|
assert.notInclude(torPool.instance_names, "instance-3");
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#instance_at(index)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create(1);
|
|
|
|
});
|
|
|
|
it('should retrieve an instance by id', function () {
|
|
this.timeout(5000);
|
|
assert.ok(torPool.instance_at(0));
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#remove_at(index)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE );
|
|
await torPool.create(1);
|
|
|
|
});
|
|
|
|
it('should remove an instance by id', async function () {
|
|
this.timeout(5000);
|
|
await torPool.remove_at(0);
|
|
|
|
assert.notOk(torPool.instances[0]);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
|
|
describe('#new_identites()', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE * 2);
|
|
await torPool.create(2);
|
|
|
|
});
|
|
|
|
it('should signal to retrieve a new identity to all instances', async function () {
|
|
this.timeout(5000);
|
|
await torPool.new_identites();
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#new_identites_by_group(group)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE * 3);
|
|
await torPool.add([
|
|
{ Name: 'instance-1', Group: 'bar' },
|
|
{ Name: 'instance-2', Group: 'foo' }
|
|
]);
|
|
|
|
});
|
|
|
|
it('should signal to retrieve a new identity to all instances', async function () {
|
|
this.timeout(5000);
|
|
await torPool.new_identites_by_group('bar');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#new_identity_at(index)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create(1);
|
|
|
|
});
|
|
|
|
it('should signal to retrieve a new identity identified by index', async function () {
|
|
this.timeout(5000);
|
|
await torPool.new_identity_at(0);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#new_identity_by_name(instance_name)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add({ Name: 'instance-1' });
|
|
});
|
|
|
|
it('should signal to retrieve a new identity identified by name', async function () {
|
|
this.timeout(5000);
|
|
await torPool.new_identity_by_name('instance-1');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
|
|
describe('#set_config_all(keyword, value)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE * 2);
|
|
await torPool.create(2);
|
|
});
|
|
|
|
it('should set configuration on all active instances', async function () {
|
|
this.timeout(5000);
|
|
await torPool.set_config_all('TestSocks', 1);
|
|
});
|
|
|
|
it('all instances should contain the same changed configuration', async function () {
|
|
this.timeout(5000);
|
|
|
|
let values = await Promise.all(torPool.instances.map((instance) => instance.get_config('TestSocks')));
|
|
values = _.flatten(values);
|
|
assert.isTrue( values.every((value) => value === "1") );
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#set_config_by_group(group, keyword, value)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add([ { Name: 'instance-1', Group: 'foo' }, { Name: 'instance-2', Group: 'bar' } ]);
|
|
|
|
});
|
|
|
|
it('should set configuration on all active instances', async function () {
|
|
this.timeout(5000);
|
|
await torPool.set_config_by_group('bar', 'TestSocks', 1);
|
|
});
|
|
|
|
it('all instances should contain the same changed configuration', async function () {
|
|
this.timeout(5000);
|
|
|
|
let values_from_bar = await Promise.all(torPool.instances_by_group('bar').map((instance) => instance.get_config('TestSocks')));
|
|
values_from_bar = _.flatten(values_from_bar);
|
|
assert.isTrue( values_from_bar.every((value) => value === "1") );
|
|
|
|
let values_from_foo = await Promise.all(torPool.instances_by_group('foo').map((instance) => instance.get_config('TestSocks')));
|
|
values_from_foo = _.flatten(values_from_foo);
|
|
assert.isTrue( values_from_foo.every((value) => value !== "1") );
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#set_config_by_name(name, keyword, value)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add({ Name: 'instance-1' });
|
|
|
|
});
|
|
|
|
it('should set a configuration property of an instance identified by name', async function () {
|
|
this.timeout(5000);
|
|
await torPool.set_config_by_name('instance-1', 'ProtocolWarnings', 1);
|
|
});
|
|
|
|
it('should have the set value', async function () {
|
|
this.timeout(5000);
|
|
let value = _.flatten(await torPool.get_config_by_name('instance-1', 'ProtocolWarnings'))[0];
|
|
assert.equal(value, '1');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#get_config_by_name(name, keyword)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add({ Name: 'instance-1', Config: { ProtocolWarnings: 1 } });
|
|
});
|
|
|
|
it('should get retrieve the configuration of an instance identified by name', async function () {
|
|
this.timeout(5000);
|
|
let value = _.flatten(await torPool.get_config_by_name('instance-1', 'ProtocolWarnings'))[0];
|
|
assert.equal(value, '1');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#set_config_at(index, keyword, value)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create(1);
|
|
});
|
|
|
|
it('should set a configuration property of an instance identified by index', async function () {
|
|
this.timeout(5000);
|
|
await torPool.set_config_at(0, 'ProtocolWarnings', 1);
|
|
});
|
|
|
|
it('should have the set value', async function () {
|
|
this.timeout(5000);
|
|
let value = _.flatten(await torPool.get_config_at(0, 'ProtocolWarnings'))[0];
|
|
assert.equal(value, '1');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#get_config_at(index, keyword)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.add({ Config: { ProtocolWarnings: 1 } });
|
|
});
|
|
|
|
it('should get retrieve the configuration of an instance identified by name', async function () {
|
|
this.timeout(5000);
|
|
let value = _.flatten(await torPool.get_config_at(0, 'ProtocolWarnings'))[0];
|
|
|
|
assert.equal(value, '1');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#signal_all(signal)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create(1);
|
|
|
|
});
|
|
|
|
it('should send a signal to all instances', async function () {
|
|
this.timeout(5000);
|
|
await torPool.signal_all('DEBUG');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#signal_by_name(name, signal)', async function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create({ Name: 'instance-1' });
|
|
});
|
|
|
|
it('should send a signal to an instance identified by name', async function () {
|
|
this.timeout(5000);
|
|
await torPool.signal_by_name('instance-1', 'DEBUG');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#signal_by_group(group, name, signal)', async function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create([ { "Name": "instance-1", "Group": ["foo"] }, { "Name": "instance-2", "Group": ["foo"] } ]);
|
|
});
|
|
|
|
it('should send a signal to a group of instances', async function () {
|
|
this.timeout(5000);
|
|
await torPool.signal_by_group('foo', 'DEBUG');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#signal_at(index, signal)', function () {
|
|
let torPool;
|
|
before('create tor pool', async function () {
|
|
torPool = torPoolFactory();
|
|
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
await torPool.create(1);
|
|
});
|
|
|
|
it('should send a signal to an instance identified by index', async function () {
|
|
this.timeout(5000);
|
|
await torPool.signal_at(0, 'DEBUG');
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await torPool.exit(); });
|
|
});
|
|
|
|
describe('#group_names', function () {
|
|
let tor_pool;
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE * 2);
|
|
await tor_pool.add([
|
|
{ Name: 'instance-1', Group: [ "foo", "bar" ] },
|
|
{ Name: 'instance-2', Group: "baz" }
|
|
]);
|
|
});
|
|
|
|
it('the pool should contain three groups, bar, baz and foo', function () {
|
|
assert.deepEqual(tor_pool.group_names, (new Set([ "bar", "baz", "foo" ])));
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#add_instance_to_group(group, instance)', function () {
|
|
let tor_pool;
|
|
let instance;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instance = (await tor_pool.create(1))[0];
|
|
});
|
|
|
|
it('should add the instance to the group successfully', function () {
|
|
tor_pool.add_instance_to_group("foo", instance);
|
|
});
|
|
|
|
it('the instance should be added to the group', function () {
|
|
assert.deepEqual(instance.instance_group, ["foo"]);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#add_instance_to_group_by_name(group, instance_name)', function () {
|
|
let tor_pool;
|
|
let instance;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instance = (await tor_pool.add({ Name: 'instance-1' }))[0];
|
|
});
|
|
|
|
it('should add the instance to the group successfully', function () {
|
|
tor_pool.add_instance_to_group_by_name("foo", instance.definition.Name);
|
|
});
|
|
|
|
it('the instance should be added to the group', function () {
|
|
assert.deepEqual(instance.instance_group, ["foo"]);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#add_instance_to_group_at(group, instance_index)', function () {
|
|
let tor_pool;
|
|
let instance;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instance = (await tor_pool.create(1))[0];
|
|
});
|
|
|
|
it('should add the instance to the group successfully', function () {
|
|
tor_pool.add_instance_to_group_at("foo", 0);
|
|
});
|
|
|
|
it('the instance should be added to the group', function () {
|
|
assert.deepEqual(instance.instance_group, ["foo"]);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#remove_instance_from_group(group, instance)', function () {
|
|
let tor_pool;
|
|
let instance;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instance = (await tor_pool.add({ Group: "foo" }))[0];
|
|
});
|
|
|
|
it('should remove the instance from the group successfully', function () {
|
|
tor_pool.remove_instance_from_group("foo", instance);
|
|
});
|
|
|
|
it('the instance should be no longer be in the group', function () {
|
|
assert.notInclude(instance.instance_group, "foo");
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#remove_instance_from_group_by_name(group, instance_name)', function () {
|
|
let tor_pool;
|
|
let instance;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instance = (await tor_pool.add({ Name: 'instance-1', Group: "foo" }))[0];
|
|
});
|
|
|
|
it('should remove the instance from the group successfully', function () {
|
|
tor_pool.remove_instance_from_group_by_name("foo", instance.definition.Name);
|
|
});
|
|
|
|
it('the instance should no longer be in the group', function () {
|
|
assert.notInclude(instance.instance_group, "foo");
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#remove_instance_from_group_at(group, instance_index)', function () {
|
|
let tor_pool;
|
|
let instance;
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE);
|
|
instance = (await tor_pool.add({ Group: "foo" }))[0];
|
|
});
|
|
|
|
it('should remove the instance from the group successfully', function () {
|
|
tor_pool.remove_instance_from_group_at("foo", 0);
|
|
});
|
|
|
|
it('the instance should no longer be in the group', function () {
|
|
assert.notInclude(instance.instance_group, "foo");
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
|
|
describe('#groups', function () {
|
|
let tor_pool;
|
|
let instances;
|
|
|
|
let get_instance_names = (group_name) => {
|
|
let instances = [];
|
|
let group = tor_pool.groups[group_name];
|
|
for (let i = 0; i < group.length; i++)
|
|
instances.push(group[i]);
|
|
|
|
return instances.map((i) => i.instance_name).sort();
|
|
};
|
|
|
|
before('create tor pool', async function () {
|
|
tor_pool = torPoolFactory();
|
|
this.timeout(WAIT_FOR_CREATE * 3);
|
|
instances = (await tor_pool.add([
|
|
{ Group: ["foo", "flob"], Name: 'instance-1' },
|
|
{ Group: ["bar", "baz"], Name: 'instance-2' },
|
|
{ Group: ["flob"], Name: 'instance-3' }
|
|
]));
|
|
});
|
|
|
|
|
|
it('should contain three groups, bar, baz and foo', function () {
|
|
assert.deepEqual(Array.from(tor_pool.group_names).sort(), [ "bar", "baz", "flob", "foo" ]);
|
|
});
|
|
|
|
it('#[Number] - the 1st element should be "instance-1"', function () {
|
|
assert.equal(tor_pool.groups["foo"][0], instances[0]);
|
|
});
|
|
|
|
it('#length() - group "foo" should contain 1 instance', function () {
|
|
assert.equal(tor_pool.groups["foo"].length, 1);
|
|
});
|
|
|
|
it('#add() - adding "instance-1" to "baz" should result in "baz" having "instance-1" and "instance-2"', function () {
|
|
tor_pool.groups["baz"].add(instances[0]);
|
|
|
|
assert.deepEqual(get_instance_names("baz"), [ "instance-1", "instance-2" ] );
|
|
});
|
|
|
|
it('#remove() - removing "instance-1" firom "baz" should result in "baz" having just "instance-2"', function () {
|
|
tor_pool.groups["baz"].remove(instances[0]);
|
|
|
|
assert.deepEqual(get_instance_names("baz"), [ "instance-2" ] );
|
|
});
|
|
|
|
it('#add_by_name() - adding "instance-1" to "baz" should result in "baz" having "instance-1" and "instance-2"', function () {
|
|
tor_pool.groups["baz"].add_by_name('instance-1');
|
|
|
|
assert.deepEqual(get_instance_names("baz"), [ "instance-1", "instance-2" ] );
|
|
});
|
|
|
|
it('#remove_by_name() - removing "instance-1" from "baz" should result in "baz" having just "instance-2"', function () {
|
|
tor_pool.groups["baz"].remove_by_name('instance-1');
|
|
|
|
assert.deepEqual(get_instance_names("baz"), [ "instance-2" ] );
|
|
});
|
|
|
|
it('#remove_at() - removing "instance-1" from "baz" should result in "baz" having just "instance-2"', function () {
|
|
tor_pool.groups["baz"].add_by_name('instance-1');
|
|
tor_pool.groups["baz"].remove_at(0);
|
|
|
|
assert.deepEqual(get_instance_names("baz"), [ "instance-1" ] );
|
|
});
|
|
|
|
it('#rotate() - the name of the first instance should change', function () {
|
|
let first_instance_name_before = tor_pool.groups["flob"][0].instance_name;
|
|
tor_pool.groups["flob"].rotate();
|
|
let first_instance_name_after = tor_pool.groups["flob"][0].instance_name;
|
|
assert.notEqual(first_instance_name_after, first_instance_name_before);
|
|
});
|
|
|
|
after('shutdown tor pool', async function () { await tor_pool.exit(); });
|
|
});
|
|
}); |