test.cb('Sockend simple req&res', (t) => {
t.plan(2);
const responder = new Responder({ name: `${t.title}: simple responder`, respondsTo: ['test', 'test 2'] });
responder.on('test', (req, cb) => cb(req.args));
responder.on('test 2', (req, cb) => cb([1, 2, 3]));
portfinder.getPort({ host: '127.0.0.1', port: 6000 }, (err, port) => {
const server = io(port);
new Sockend(server, { name: 'simple sockend' });
const client = ioClient.connect(`http://0.0.0.0:${port}`);
server.on('connection', (sock) => {
responder.sock.on('connect', () => {
client.emit('test', { args: [4, 5, 6] }, (res) => {
t.deepEqual(res, [4, 5, 6]);
client.emit('test 2', (res) => {
t.deepEqual(res, [1, 2, 3]);
t.end();
});
});
});
});
});
});
exports.create = function (callback) {
testServer = new TestServer({
predictableUrls: config["predictable-urls"],
shutdownOnCampaignEnd: config["shutdown-on-campaign-end"],
frozen: config["server-only"],
flashPolicyPort: config["flash-policy-port"],
flashPolicyServer: config["flash-policy-server"],
taskTimeout: config["task-timeout"]
}, attester.logger);
testServer.server.on("error", function (error) {
testServer.logger.logError("Web server error: %s", [error]);
attester.event.emit("server.error");
});
portfinder.basePort = config.port;
portfinder.getPort(function (err, port) {
if (err) {
attester.event.emit("server.error", "Can't start the server: %s", [err]);
return;
}
if (port != config.port && config.port > 0) {
// logging error instead of a warning so it's more visible in the console
attester.logger.logError("Port %d unavailable; using %d instead.", [config.port, port]);
}
testServer.server.listen(port, function () {
testServerReady = true;
attester.event.emit("server.listening");
callback();
});
});
};
module.exports = new Promise((resolve, reject) => {
portfinder.basePort = process.env.PORT || config.dev.port
portfinder.getPort((err, port) => {
if(err) {
reject(err)
} else {
// publish the new Port, necessary for e2e tests
process.env.PORT = port
// add port to devServer config
devWebpackConfig.devServer.port = port
// Add FriendlyErrorsPlugin
devWebpackConfig.plugins.push(new FriendlyErrorsPlugin({
compilationSuccessInfo: {
messages: [`Your application is running here: http://${devWebpackConfig.devServer.host}:${port}`],
},
onErrors: config.dev.notifyOnErrors ?
utils.createNotifierCallback() :
undefined
}))
resolve(devWebpackConfig)
}
})
})
it('should setup a server with auth and client trying to connect with correct username and password', function (done) {
portfinder.getPort(function (err, freePort) {
if (err) throw err;
larvitsmpp.server({
'port': freePort,
'checkuserpass': checkuserpass
}, function (err, serverSession) {
if (err) throw err;
serverSession.on('close', function () {
// Manually destroy the server socket
serverSession.sock.destroy();
});
});
larvitsmpp.client({
'port': freePort,
'username': '******',
'password': '******'
}, function (err, clientSession) {
if (err) throw err;
// Gracefully close connection
clientSession.unbind();
done();
});
});
});
var Honeypot = function (infoHash, port) {
if (!infoHash) {
logger.warn('Tried creating new honeypot, but didn\'t specify infoHash');
return;
}
logger.info('Creating new honeypot for infoHash ' + this.infoHash + '...');
this.infoHash = infoHash;
this.port = port;
if (!port) {
logger.debug('Searching unused port for honeypot ' + this.infoHash + ' using portfinder...');
portfinder.getPort(function (err, port) {
if (err) {
logger.error('Failed finding port using portfinder: ' + err.message);
logger.error(JSON.stringify(err));
return;
}
this.port = port;
logger.debug('Port ' + this.port + ' for honeypot ' + this.infoHash + ' has been found and provisioned');
_init.call(this);
}.bind(this));
} else {
logger.debug('Port for honeypot ' + this.infoHash + ' specified');
_init.call(this);
}
};
test('`find_node` query (with many in table)', function (t) {
t.plan(4)
var dht1 = new DHT({ bootstrap: false })
var dht2 = new DHT({ bootstrap: false })
common.failOnWarningOrError(dht1, t)
common.failOnWarningOrError(dht2, t)
dht1.addNode('1.1.1.1:6969', common.randomNodeId())
dht1.addNode('10.10.10.10:6969', common.randomNodeId())
dht1.addNode('255.255.255.255:6969', common.randomNodeId())
portfinder.getPort(function (err, port) {
t.error(err)
dht1.listen(port, function () {
var targetNodeId = common.randomNodeId()
dht2._sendFindNode('127.0.0.1:' + port, targetNodeId, function (err, res) {
t.error(err)
t.deepEqual(res.id, dht1.nodeId)
t.deepEqual(
res.nodes.map(function (node) { return node.addr }).sort(),
[ '1.1.1.1:6969', '10.10.10.10:6969', '255.255.255.255:6969' ]
)
dht1.destroy()
dht2.destroy()
})
})
})
})
it('should setup a server with auth and client trying to connect with wrong username and password', function (done) {
portfinder.getPort(function (err, freePort) {
if (err) throw err;
larvitsmpp.server({
'port': freePort,
'checkuserpass': checkuserpass
}, function (err, serverSession) {
if (err) throw err;
serverSession.on('close', function () {
// Manually destroy the server socket
serverSession.sock.destroy();
});
});
larvitsmpp.client({
'port': freePort
}, function (err) {
assert(err, 'Error should be set since login should have failed');
done();
});
});
});
selleck: function(callback) {
var self = this;
portfinder.getPort(function (err, port) {
var project = path.join(__dirname, '../../configs/selleck');
if (util.isYUI()) {
log.info('this is yui, using global path for all docs');
if (self.module.name === 'yui3') {
project = path.join(self.module.dir, 'src/common/docs/');
} else {
project = path.join(self.module.dir, 'common/docs/');
}
}
self.version(function(version) {
if (version) {
var file = path.join(project, 'project.json'),
json = JSON.parse(fs.readFileSync(file, 'utf8'));
json.yuiVersion = version;
try {
fs.writeFileSync(file, JSON.stringify(json, null, 4), 'utf8');
} catch (e) {}
}
self.spawn('selleck', port, ['--server', port, '--project', project], 'docs');
callback();
});
});
},
module.exports.createServer = function (onListening, handler) {
var server = require('../index.js').createServer();
server.on('connection', function (conn) {
conn.on('error', function () {
// we are here when client drops connection
});
var flags = 0xffffff;
flags = flags ^ ClientFlags.COMPRESS;
conn.serverHandshake({
protocolVersion: 10,
serverVersion: 'node.js rocks',
connectionId: 1234,
statusFlags: 2,
characterSet: 8,
capabilityFlags: flags
});
if (handler) {
handler(conn);
}
});
portfinder.getPort(function (err, port) {
server.listen(port, onListening);
});
return server;
};
function makeLiveServer(callback) {
if (weinreServer) return callback(null, weinreServer, weinrePort);
var basePort = fis.media().get('weinre.port', 8081);
// 获取下一个可用端口。
portfinder.getPort({
port: basePort
}, function(error, port) {
if (error) {
fis.log.warn('The port %s for weinre is already in use!', basePort);
return callback(error);
}
weinrePort = port;
weinreServer = weinre.run({
httpPort: weinrePort,
boundHost: defaultHostname,
verbose: false,
debug: false,
readTimeout: 5,
deathTimeout: 15
});
openUrl('http://' + defaultHostname + ':' + weinrePort + '/client/#' + weinreUsername);
process.on('uncaughtException', function(err) {
if (err.message !== 'read ECONNRESET') throw err;
});
callback(null, weinreServer, weinrePort);
});
}
yuidoc: function(callback) {
var self = this;
portfinder.getPort(function (err, port) {
var config = path.join(__dirname, '../../configs/yuidoc/yuidoc.json');
if (util.isYUI()) {
log.info('this is yui, using global path for all docs');
if (self.module.name === 'yui3') {
config = path.join(self.module.dir, 'src/common/api/yuidoc.json');
} else {
config = path.join(self.module.dir, 'common/api/yuidoc.json');
}
}
self.version(function(version) {
if (version) {
var json = JSON.parse(fs.readFileSync(config, 'utf8'));
json.version = version;
try {
fs.writeFileSync(config, JSON.stringify(json, null, 4), 'utf8');
} catch (e) {}
}
self.spawn('yuidoc', port, ['--server', port, '--config', config], 'api');
callback();
});
});
},
beforeEach(function(done) {
var unixSocketPath = path.join(__dirname, 'tmp.sock');
createUnixSocket(unixSocketPath);
protocols = [false, false, false, true].map(function(ret) {
return {
match: sinon.spy(function() { return ret; }),
proxy: {
address: unixSocketPath
}
};
});
portfinder.getPort(function(err, p) {
port = p;
if (err) {
return done(err);
}
listener = new Listener({
port: port,
protocols: protocols
});
return done();
});
});
/*
*/
connect(conf) {
const port = this.localPort === 'auto' ? this.generateRandomPort() : this.localPort;
if (this.reverse || this.localHost !== 'localhost') {
this.execTunnel(() => {
this.pollConnection();
});
}
else {
portfinder.getPort({ port }, (portfinderErr, freePort) => {
if (this.killed)
return;
if (portfinderErr)
this.emit('error', 'Port error: ' + portfinderErr);
if (this.localPort !== 'auto' && this.localPort !== freePort)
this.emit('error', `Port ${this.localPort} is not available`);
else {
this.localPort = freePort;
// creates tunnel and then polls port until connection is established
this.execTunnel(() => {
this.pollConnection();
});
}
});
}
}
test.cb(`Sockend wrong respondsTo configuration`, (t) => {
t.plan(2);
const key = r.generate();
const responder1 = new Responder({ name: `${t.title}: responder1`, respondsTo: ['test1'], key });
const responder2 = new Responder({ name: `${t.title}: responder2`, respondsTo: 'test2', key });
let metResponders = 0;
responder1.on('test', (req, cb) => cb(req.args));
responder2.on('test', (req, cb) => cb(req.args));
portfinder.getPort({ host: '127.0.0.1', port: 28000 }, (err, port) => {
const server = io(port);
const sockend = new Sockend(server, { name: 'sockend for wrong respondsTo configuration', key });
sockend.discovery.on('added', (obj) => {
if (obj.advertisement.axon_type != 'rep') return;
if (obj.advertisement.key != sockend.advertisement.key) return;
metResponders++;
if (obj.advertisement.respondsTo === 'test2') {
t.pass();
}
if (obj.advertisement.respondsTo[0] == 'test1') {
t.pass();
}
if (metResponders == 2) t.end();
});
});
});
test('`announce_peer` query with bad token', function (t) {
t.plan(3)
portfinder.getPort(function (err, port) {
t.error(err)
var dht1 = new DHT({ bootstrap: false })
var dht2 = new DHT({ bootstrap: false })
common.failOnWarningOrError(dht1, t)
common.failOnWarningOrError(dht2, t)
var infoHash = common.randomNodeId()
dht1.listen(port, function () {
var token = new Buffer('bad token')
dht2._sendAnnouncePeer('127.0.0.1:' + port, infoHash, 9999, token, function (err, res) {
t.ok(err, 'got error')
t.ok(err.message.indexOf('bad token') !== -1)
dht1.destroy()
dht2.destroy()
})
})
})
})
prepServer: function(callback) {
log.info('prepping grover tests');
var gbase = path.join(git.findRoot(), '../'),
self = this;
log.debug('setting server root to: ' + gbase);
process.chdir(gbase);
portfinder.getPort(function (err, port) {
self.yogiURL = 'http://127.0.0.1:' + port + '/';
log.debug('startng yogi server at: ' + self.yogiURL);
self.options.grover = true;
self.options.tests = self.resolveTests();
self.options.tests.forEach(function(val, key) {
self.options.tests[key] = val.replace(gbase, 'tests/').split(path.sep).join('/');
});
self.options.callback = function() {
//delete the options callback so that it never fires again
delete self.options.callback;
server.port = port;
server.startServer();
self.yogiServer = server;
var t = ((self.options.parsed.functional) ? 500 : 0);
setTimeout(function() {
callback(port);
}, t);
};
server.init(self.options);
});
},
test('`announce_peer` query gets ack response', function (t) {
t.plan(6)
var dht1 = new DHT({ bootstrap: false })
var dht2 = new DHT({ bootstrap: false })
common.failOnWarningOrError(dht1, t)
common.failOnWarningOrError(dht2, t)
var infoHash = common.randomNodeId()
var host =
portfinder.getPort(function (err, port) {
t.error(err)
dht1.listen(port, function () {
dht2._sendGetPeers('127.0.0.1:' + port, infoHash, function (err, res1) {
t.error(err)
t.deepEqual(res1.id, dht1.nodeId)
t.ok(Buffer.isBuffer(res1.token))
dht2._sendAnnouncePeer('127.0.0.1:' + port, infoHash, 9999, res1.token, function (err, res2) {
t.error(err)
t.deepEqual(res1.id, dht1.nodeId)
dht1.destroy()
dht2.destroy()
}
)
})
})
})
})
function() {
// ifaces
var deferredAddresses = Q.defer();
require('dns').lookup(require('os').hostname(), { family: 4, all: true } , function(err, addresses) {
if (err) {
util.warn(err);
}
deferredAddresses.resolve(addresses || []);
});
// port
var deferredPort = Q.defer();
portfinder.basePort = argv.port || 8000;
portfinder.getPort(function(err, port) {
if (err) {
return deferredPort.reject(err);
}
if (argv.port && argv.port !== port) {
util.warn('The specified port ' + argv.port + ' is already in use. Using available port ' + port + ' instead.\n');
}
deferredPort.resolve(port);
});
return Q.all([deferredAddresses.promise, deferredPort.promise]);
}
it('should setup a basic server and client and then directly unbinding again', function (done) {
portfinder.getPort(function (err, freePort) {
if (err) throw err;
larvitsmpp.server({
'port': freePort
}, function (err, serverSession) {
if (err) throw err;
serverSession.on('close', function () {
// Manually destroy the server socket
serverSession.sock.destroy();
});
});
larvitsmpp.client({
'port': freePort
}, function (err, clientSession) {
if (err) throw err;
// Gracefully close connection
clientSession.unbind();
done();
});
});
});
var prepareTheShop = function (dir) {
var d = new Deferred();
if (fs.existsSync(path.join(dir, 'admin')))
{
if (undefined !== fs.renameSync(path.join(dir, 'admin'), path.join(dir, 'admin-dev')))
{
console.log(path.join(dir, 'admin'), path.join(dir, 'admin-dev'));
d.reject('Could not rename admin to admin-dev.');
}
}
if (fs.existsSync(path.join(dir, 'install')))
{
if (undefined !== fs.renameSync(path.join(dir, 'install'), path.join(dir, 'install-dev')))
{
d.reject('Could not rename install to install-dev.');
}
}
portfinder.getPort(function (error, port) {
if (error)
{
d.reject('Could not find an open port: ' + error);
}
else
{
d.resolve({port: port, path: dir});
}
});
return d.promise;
};
it('should test that a session can recreate SMS with random sequence', function (done) {
portfinder.getPort(function (err, freePort) {
const sockInLog = [], // Log incomming socket messages
sock = new net.Socket();
if (err) throw err;
sock.connect(freePort, 'localhost', function () {
// bind_transceiver - initial call. Subsequent calls should be made on the sock.on('data') thingie
sock.write(new Buffer('0000002100000009000000000000002f666f6f0062617200736d70700034000000', 'hex'));
});
sock.on('data', function (data) {
sockInLog.push(data.toString('hex'));
if (sockInLog.length === 1) {
assert.strictEqual(data.toString('hex'), '0000001480000009000000000000002f666f6f00');
// Send all 4 parts at the same time but random order
// Message Part 2
sock.write(new Buffer('000000de00000004000000000000003100050074657374000201313233343500430000003136303630373136333031333030302b00000000009f0500030204027768656e20616e20756e6b6e6f776e207072696e74657220746f6f6b20612067616c6c6579206f66207479706520616e6420736372616d626c656420697420746f206d616b65206120747970652073706563696d656e20626f6f6b2e20497420686173207375727669766564206e6f74206f6e6c7920666976652063656e7475726965732c2062757420616c736f20746865206c65617020690426000101', 'hex'));
// Message Part 1
sock.write(new Buffer('000000de00000004000000000000003000050074657374000201313233343500430000003136303630373136333031333030302b00000000009f0500030204014c6f72656d20497073756d2069732073696d706c792064756d6d792074657874206f6620746865207072696e74696e6720616e64207479706573657474696e6720696e6475737472792e204c6f72656d20497073756d20686173206265656e2074686520696e6475737472792773207374616e646172642064756d6d79207465787420657665722073696e6365207468652031353030732c200426000101', 'hex'));
// Message Part 4
sock.write(new Buffer('000000b200000004000000000000003300050074657374000201313233343500430000003136303630373136333031333030302b000000000078050003020404617373616765732c20616e64206d6f726520726563656e746c792077697468206465736b746f70207075626c697368696e6720736f667477617265206c696b6520416c64757320506167654d616b657220696e636c7564696e672076657273696f6e73206f66204c6f72656d20497073756d', 'hex'));
// Message Part 3
sock.write(new Buffer('000000de00000004000000000000003200050074657374000201313233343500430000003136303630373136333031333030302b00000000009f0500030204036e746f20656c656374726f6e6963207479706573657474696e672c2072656d61696e696e6720657373656e7469616c6c7920756e6368616e6765642e2049742077617320706f70756c61726973656420696e207468652031393630732077697468207468652072656c65617365206f66204c657472617365742073686565747320636f6e7461696e696e67204c6f72656d20497073756d20700426000101', 'hex'));
} else if (sockInLog.length === 2) {
assert.strictEqual(data.toString('hex'), '000000158000000400000000000000303233343300');
} else if (sockInLog.length === 3) {
// This is actually four different PDUs at the same time, marking the response on all four parts above
assert.strictEqual(data.toString('hex'), '000000158000000400000000000000313233343300000000158000000400000000000000323233343300000000158000000400000000000000333233343300');
done();
} else {
throw new Error('To much data received');
}
});
larvitsmpp.server({
'port': freePort
}, function (err, serverSession) {
if (err) throw err;
serverSession.on('sms', function (sms) {
assert.strictEqual(sms.message, 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry\'s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum');
sms.smsId = 2343;
sms.sendResp(function (err) {
if (err) throw err;
});
});
serverSession.on('close', function () {
// Manually destroy the server socket
serverSession.sock.destroy();
});
});
});
});
test('`get_peers` query to node with *no* peers in table', function (t) {
t.plan(5)
var dht1 = new DHT({ bootstrap: false })
var dht2 = new DHT({ bootstrap: false })
common.failOnWarningOrError(dht1, t)
common.failOnWarningOrError(dht2, t)
dht1.addNode('1.1.1.1:6969', common.randomId())
dht1.addNode('2.2.2.2:6969', common.randomId())
portfinder.getPort(function (err, port) {
t.error(err)
dht1.listen(port, function () {
var targetInfoHash = common.randomId()
dht2._sendGetPeers('127.0.0.1:' + port, targetInfoHash, function (err, res) {
t.error(err)
t.deepEqual(res.id, dht1.nodeId)
t.ok(Buffer.isBuffer(res.token))
t.deepEqual(
res.nodes.map(function (node) { return node.addr }).sort(),
[ '1.1.1.1:6969', '2.2.2.2:6969' ]
)
dht1.destroy()
dht2.destroy()
})
})
})
})
getAvailablePort:function(callback){
var portfinder = require( 'portfinder' );
portfinder.getPort( function(err, port){
err ? port = 9222 : port;
callback( err, port );
} );
}
constructor(advertisement, discoveryOptions = {}, stream) {
advertisement.type = 'monitor';
discoveryOptions = _objectSpread({}, defaultOptions, discoveryOptions);
super(advertisement, discoveryOptions);
this.stream = stream;
this.sock = new axon.SubEmitterSocket();
this.sock.sock.on('bind', () => this.startDiscovery());
this.sock.on('status', status => this.emit('status', status));
const onPort = (err, port) => {
advertisement.port = +port;
this.sock.bind(port);
this.sock.sock.server.on('error', err => {
if (err.code != 'EADDRINUSE') throw err;
portfinder.getPort({
host: this.discoveryOptions.address,
port: this.advertisement.port
}, onPort);
});
};
portfinder.getPort({
host: this.discoveryOptions.address,
port: this.advertisement.port
}, onPort);
}
var Requester = function(advertisement, discoveryOptions) {
EventEmitter.call(this, {
wildcard: true, // should the event emitter use wildcards.
delimiter: '::', // the delimiter used to segment namespaces, defaults to `.`.
newListener: false, // if you want to emit the newListener event set to true.
maxListeners: 2000 // the max number of listeners that can be assigned to an event, defaults to 10.
});
var that = this;
portfinder.getPort(function(err, port) {
advertisement.axon_type = 'req';
advertisement.port = +port;
that.advertisement = advertisement;
var d = that.discovery = Discovery(advertisement, discoveryOptions);
that.sock = new axon.ReqSocket();
that.sock.bind(port);
that.emit('ready', that.sock);
d.on('added', function(obj) {
that.emit('added', obj);
});
d.on('removed', function(obj) {
that.emit('removed', obj);
});
});
};
this.sock.sock.server.on('error', err => {
if (err.code != 'EADDRINUSE') throw err;
portfinder.getPort({
host: this.discoveryOptions.address,
port: this.advertisement.port
}, onPort);
});
return (() => {
var
deferred,
execArgv = process.execArgv.slice();
if (process.debugPort) {
deferred = q.defer();
portfinder.getPort((err, debugPort) => {
execArgv.forEach((v, i) => {
var match = v.match(/^(--debug|--debug-(brk|port))(=\d+)?$/);
if (match) {
execArgv[i] = match[1] + '=' + debugPort;
}
});
deferred.resolve(execArgv);
});
return deferred.promise;
}
return q(execArgv);
})()
test('`get_peers` query to node with peers in table', function (t) {
t.plan(5)
var dht1 = new DHT({ bootstrap: false })
var dht2 = new DHT({ bootstrap: false })
common.failOnWarningOrError(dht1, t)
common.failOnWarningOrError(dht2, t)
var targetInfoHash = common.randomNodeId()
dht1.addPeer('1.1.1.1:6969', targetInfoHash)
dht1.addPeer('10.10.10.10:6969', targetInfoHash)
dht1.addPeer('255.255.255.255:6969', targetInfoHash)
portfinder.getPort(function (err, port) {
t.error(err)
dht1.listen(port, function () {
dht2._sendGetPeers('127.0.0.1:' + port, targetInfoHash, function (err, res) {
t.error(err)
t.deepEqual(res.id, dht1.nodeId)
t.ok(Buffer.isBuffer(res.token))
t.deepEqual(
res.values.sort(),
['1.1.1.1:6969', '10.10.10.10:6969', '255.255.255.255:6969']
)
dht1.destroy()
dht2.destroy()
})
})
})
})
it('should spawn command correctly', function (done) {
portFinder.getPort(function (err, serverPort) {
should.not.exist(err, 'error getting server port: ' + JSON.stringify(err, null, ' '))
var repoDir = path.join(__dirname, 'setup/repos/apples/');
assert.ok(fs.existsSync(repoDir) ,'repo dir not found at path: ' + repoDir)
var data = {
port: port,
host: host,
secret: secret,
repoDir: repoDir,
command: 'node applesServer --port=' + serverPort
}
performSpawn(data, function (err) {
should.not.exist(err, 'error spawning command: ' + JSON.stringify(err, null, ' '))
})
var pattern = /apples server listening on port/;
droneProcess.stdout.on('data', function (stdoutData) {
if (pattern.test(stdoutData)) {
var url = 'http://localhost:' + serverPort + '/ping'
inspect(url,'url')
request(url, function (err, res, body) {
if (err) {
inspect(err, 'server error')
}
should.not.exist(err, 'error in server response: ' + JSON.stringify(err, null, ' '))
res.statusCode.should.eql(200)
body.should.eql('pong')
done()
})
}
})
})
})
test.cb('Sockend pub&sub with __room', (t) => {
t.plan(1);
const key = r.generate();
const publisher = new Publisher({ name: `${t.title}: room publisher`, key, broadcasts: ['published message'] });
portfinder.getPort({ host: '127.0.0.1', port: 2000 }, (err, port) => {
const server = io(port);
new Sockend(server, { name: 'pub&sub sockend', key });
const client = ioClient.connect(`http://0.0.0.0:${port}`);
client.on('published message', (msg) => {
t.deepEqual(msg, { content: 'simple content' });
t.end();
});
server.on('connection', (sock) => {
sock.join('room1');
publisher.sock.sock.on('connect', (sdf) => {
publisher.publish('published message', { content: 'simple content', __room: 'room1' });
});
});
});
});