it('will retry listening a specified number of times', function (done) {
var seneca1 = Seneca({
log: 'silent',
default_plugins: {
transport: false
}
})
var seneca2 = Seneca({
log: 'silent',
default_plugins: {
transport: false
}
})
var settings1 = {
tcp: {
port: 0
}
}
var callmap = {}
var transportUtil1 = new TransportUtil({
callmap: callmap,
seneca: seneca1,
options: settings1
})
var tcp1 = Tcp.listen(settings1, transportUtil1)
expect(typeof tcp1).to.equal('function')
tcp1.call(seneca1, { type: 'tcp' }, function (err, address) {
expect(err).to.not.exist()
var settings2 = {
tcp: {
port: address.port,
max_listen_attempts: 10,
attempt_delay: 10
}
}
var transportUtil2 = new TransportUtil({
callmap: callmap,
seneca: seneca2,
options: settings2
})
var tcp2 = Tcp.listen(settings2, transportUtil2)
expect(typeof tcp2).to.equal('function')
setTimeout(function () {
seneca1.close()
}, 20)
tcp2.call(seneca2, { type: 'tcp' }, function (err, address) {
expect(err).to.not.exist()
done()
})
})
})
it('verify content', function (done) {
var si = seneca()
.use('..', {folder: './email-templates', content: {bar: {a: 1, b: 0}}})
si.ready(function () {
var mail = si.pin({role: 'mail', cmd: '*'})
;
mail.generate({code: 'bar'}, function (err, out) {
assert.isNull(err)
//console.dir(out)
assert.equal('<div>a:1,b:0</div>', out.html)
assert.equal('a:1,b:0', out.text)
si.add({role: 'mail', hook: 'content'}, function (args, done) {
args.content = args.content || {}
args.content.b = 2
this.parent(args, done)
})
;
mail.generate({code: 'bar'}, function (err, out) {
assert.isNull(err)
assert.equal('<div>a:1,b:2</div>', out.html)
assert.equal('a:1,b:2', out.text)
done()
})
})
})
})
beforeEach( function () {
seneca = Seneca()
.use( 'entity' )
.use( require( '../feeds' ) )
.use( 'mesh' )
.error( expect.fail );
} );
module.exports = function (lab) {
var Seneca = require('seneca')
var Code = require('code')
var describe = lab.describe
var it = lab.it
var before = lab.before
var expect = Code.expect
var si = Seneca({log: 'silent', strict: {result: false}})
if (si.version >= '2.0.0') {
si.use(require('seneca-entity'))
}
si
.use('cache')
.use('../token')
describe('cmd:clear, token: string,required$', function () {
before(function (done) {
si.ready(function (err) {
if (err) return process.exit(!console.error(err))
done()
})
})
it('responds { ok: true} in anyways, do not depend on token is existing or not', function (done) {
si.act('role:token, cmd:generate, data: true, duration: 10', function (err, respond) {
expect(err).to.not.exist()
var token = respond.token
si.act({role: 'token', cmd: 'clear', token: token}, function (err, respond) {
expect(err).to.not.exist()
var tokenent = si.make('sys', 'token')
tokenent.load$(token, function (err, tokenData) {
expect(err).to.not.exist()
expect(tokenData).to.not.exist()
done()
})
})
})
})
it('can remove token in cache and in entity', function (done) {
si.act('role:token, cmd:generate, data: true, cache: true, duration: 10', function (err, respond) {
expect(err).to.not.exist()
var token = respond.token
si.act({role: 'token', cmd: 'clear', token: token}, function (err, respond) {
expect(err).to.not.exist()
si.act({role: 'cache', cmd: 'get', token: token}, function (err, respond) {
expect(err).to.not.exist()
expect(respond).to.not.exist()
done()
})
})
})
})
})
}
const main = function () {
loadSerializer();
loadSensor();
const server = Seneca();
let offset = 100;
server.add({ role: 'temperature', cmd: 'offset' }, (args, cb) => {
offset = parseInt(args.offset, 10);
cb();
});
setInterval(() => {
sensor.act({ role: 'temperature', cmd: 'read', offset: offset }, (err, args) => {
if (err) {
console.error(err);
return;
}
serializer.act({ role: 'serialize', cmd: 'write', temperature: args.temperature, sensorId: args.sensorId }, () => {});
});
}, 2000);
server.listen({ port: 8000 });
};
it('can listen on ephemeral port', function (done) {
var seneca = Seneca({
log: 'silent',
default_plugins: {
transport: false
}
})
var settings = {
tcp: {
port: 0,
host: 'localhost'
}
}
var callmap = {}
var transportUtil = new TransportUtil({
callmap: callmap,
seneca: seneca,
options: settings
})
var tcp = Tcp.listen(settings, transportUtil)
expect(typeof tcp).to.equal('function')
tcp.call(seneca, { type: 'tcp' }, function (err) {
expect(err).to.not.exist()
done()
})
})
function legacy_false () {
Seneca({log: 'silent', legacy: {error_codes: false, validate: false}})
.use('../joi', {legacy: false})
.add({
a: 0
}, function (msg, done) {
done(null, {c: 0})
})
.add({
a: 1,
b: {c: 2}
}, function (msg, done) {
done(null, {c: 1})
})
.act('a:0,b:1', function (err, out) {
if (err) return done(err)
Assert.equal(0, out.c)
this.act('a:1,b:{c:2}', function (err, out) {
if (err) return done(err)
Assert.equal(1, out.c)
this.act('a:1,b:2', function (err, out) {
Assert.equal('act_invalid_msg', err.code)
done()
})
})
})
}
describe('github', function() {
var si = seneca({log:'silent',from:'./mine.options.js'})
.use('jsonfile-store')
.use('../github.js')
it('parse', function( fin ) {
si.options({errhandler:make_errhandler(fin)})
si.act(
'role:github,cmd:parse',
{giturl:'git://github.com/rjrodger/norma.git'}, function(err,out){
assert.equal('rjrodger',out.user)
assert.equal('norma',out.repo)
fin()
})
})
it('query', function( fin ) {
si.options({errhandler:make_errhandler(fin)})
si.act(
'role:github,cmd:query',
{name:'norma',user:'******',repo:'norma'}, function(err,out){
assert.equal(out.id,'norma')
assert.equal(out.repo,'norma')
assert.equal(out.user,'rjrodger')
fin()
})
})
it('get', function( fin ) {
si.options({errhandler:make_errhandler(fin)})
si.make$('mod').load$('gex',function(err,out){
if( out ) {
out.remove$(do_get)
}
else do_get()
function do_get() {
si.act(
'role:github,cmd:get',
{name:'gex',giturl:'https://github.com/rjrodger/gex.git'},
function(err,out){
assert.equal( out.id, 'gex')
assert.equal( out.repo, 'gex')
assert.equal( out.user, 'rjrodger')
fin()
})
}
})
})
})
app.register(Basic, (err) => {
if (err) throw err
app.auth.strategy('simple', 'basic', {validateFunc: validate})
// The config we will pass to seneca-web
var config = {
adapter: require('seneca-web-adapter-hapi'),
context: app,
routes: Routes
}
// Server and start as usual.
var seneca = Seneca()
.use(Plugin)
.use(Web, config)
.ready(() => {
var server = seneca.export('web/context')()
server.start((err) => {
console.log(err || 'server started on: ' + server.info.uri)
})
})
})
it('handles errors lower priority entity service', function(done) {
var seneca = Seneca().test()
seneca.use('entity')
seneca.use(SENECA_CACHE_PLUGIN)
seneca.ready(function() {
seneca.add({ role: 'entity', cmd: 'save' }, function bad_entity_save(
ignore,
callback
) {
return callback(new Error('Bad entity service'))
})
seneca.use('..')
seneca.ready(function() {
var type = internals.type()
var entry = seneca.make(type, { a: 1 })
// Save
entry.save$(function(err, saved) {
expect(err).to.exist()
done()
})
})
})
})
it('should get and set context', function (testDone) {
var seneca = createSeneca();
var context = {a: {b: {c: 1}}, d: [2, 3, 4]};
var context2 = {test: 'data'};
seneca.add('role:test,cmd:run', function (msg, done) {
expect(senecaContext.getContext(this)).to.be.null;
senecaContext.setContext(this, context);
expect(senecaContext.getContext(this)).to.deep.equal(context);
this.act({role: 'test', cmd: 'run2'}, done);
});
seneca.add('role:test,cmd:run2', function (msg, done) {
expect(senecaContext.getContext(this)).to.deep.equal(context);
senecaContext.setContext(this, context2);
expect(senecaContext.getContext(this)).to.deep.equal(context2);
// If possible, a cached context from context$ property is returned.
// Check, if it can be recreated from tx$.
expect(this.fixedargs.context$).to.deep.equal(context2);
delete this.fixedargs.context$;
expect(senecaContext.getContext(this)).to.deep.equal(context2);
expect(this.fixedargs.context$).to.deep.equal(context2);
done();
});
seneca.act({role: 'test', cmd: 'run'}, testDone);
});
Consul.getService('broker', (err, brokerService) => {
if (err || !brokerService || !brokerService.address) {
return retry(loadBroker);
}
broker = Seneca().client({ host: brokerService.address, port: brokerService.port });
loading = false;
});
function seneca_instance(opts) {
var seneca = Seneca().test()
//.quiet()
seneca.use('entity')
seneca.use(SENECA_CACHE_PLUGIN)
seneca.use('..', opts)
return seneca
}
describe('npm', function() {
var si = seneca({log:'silent',from:'./mine.options.js'})
.use('jsonfile-store')
.use('../npm.js')
it('extract', function( fin ) {
si.options({errhandler:make_errhandler(fin)})
si.act(
'role:npm,cmd:extract',
{data:test_data}, function(err,out){
//console.log(out)
assert.equal('npm-version-verify-test',out.name)
assert.equal('0.0.2',out.version)
fin()
})
})
it('query', function( fin ) {
si.options({errhandler:make_errhandler(fin)})
si.act(
'role:npm,cmd:query',
{name:'npm-version-verify-test'},
function(err,out){
assert.equal('npm-version-verify-test',out.name)
assert.equal('0.0.2',out.version)
fin()
})
})
it('get', function( fin ) {
si.options({errhandler:make_errhandler(fin)})
si.make$('npm').load$('npm-version-verify-test',function(err,out){
if( out ) {
out.remove$(do_get)
}
else do_get()
function do_get() {
si.act(
'role:npm,cmd:get',
{name:'npm-version-verify-test'},
function(err,out){
assert.equal('npm-version-verify-test',out.name)
assert.equal('0.0.2',out.version)
fin()
})
}
})
})
})
it('handles upstream error when updating a record (writeData) - qqq', function(done) {
var seneca = Seneca().test()
//.quiet()
seneca.use('entity')
seneca.use('./broken')
seneca.use('..')
seneca.ready(function() {
var control = this.export(SENECA_CACHE_PLUGIN + '/control')
var type = internals.type()
var entry = seneca.make(type, { a: 1 })
// Save
entry.save$(function(err, saved) {
var id = saved.id
saved.b = 5
// Update
control.set = true
saved.save$(function(err, modified) {
expect(err).to.exist()
// Remove
control.set = false
saved.remove$(function(err, out) {
expect(err).to.not.exist()
seneca.act({ plugin: 'vcache', cmd: 'stats' }, function(
err,
stats
) {
expect(stats).to.contain({
set: 1,
get: 0,
vadd: 1,
vmiss: 0,
vhit: 0,
lru_hit: 0,
net_hit: 0,
lru_miss: 0,
net_miss: 0,
drop: 1,
cache_errs: 1
})
done()
})
})
})
})
})
})
fs.close(info.fd, function (err)
{
var c0 = Seneca({});
c0.use(require("seneca-balance-client")).client({type: 'balance', pin: 'role:test'});
c0.use('..', {pin: 'role:test', localfile: info.path, port: 47111});
setTimeout(function ()
{
c0.act({role: "test"}, function (err, result)
{
if (result.result == 'ok')
{
fs.open(info.path, 'w', function (err, fd)
{
if (!err)
{
fs.write(fd, JSON.stringify([{"primary_ip": "127.0.0.1"}]));
fs.close(fd, function (err)
{
setTimeout(function ()
{
c0.act({role: "test"}, function (err, result)
{
if (result.result == 'ok')
{
fs.open(info.path, "w", function (err, fd)
{
if (!err)
{
fs.write(fd, JSON.stringify([{"primary_ip": "localhost"}]));
fs.close(fd, function (err)
{
setTimeout(function ()
{
c0.act({role: "test"}, function (err, result)
{
if (result.result == 'ok')
{
done();
}
else done(new Error('fail'));
});
}, 2000);
});
}
});
}
else done(new Error('fail'));
});
}, 2000);
});
}
});
}
else done(new Error('fail'));
});
}, 2000);
});
it('Create Game and get Game ID',function(done){
this.timeout(100000);
var gameConsumer = seneca();
gameConsumer.use('../.././microservices/gameplay/gameManagerPlugin',{player1:player1,player2:player2,player3:player3});
gameConsumer.act('role:gameManager,action:create',function(err,response){
if(err) return done(err);
response.should.have.property('gameId');
done();
});
});
it('can be used by seneca', function (done) {
var seneca = Seneca({ log: 'silent', default_plugins: { cluster: false } })
var fn = function () {
seneca.use(senecaCluster)
}
expect(fn).to.not.throw()
done()
})
internals.availablePort(function (port) {
var seneca = Seneca({ log: 'all', default_plugins: { repl: false } })
seneca
.use(SenecaRepl, { port: port })
.ready(function () {
seneca.repl()
setTimeout(function () {
var sock = Net.connect(port)
var state = 0
sock.on('readable', function () {
var buffer = sock.read()
if (!buffer) {
return
}
var result = buffer.toString('ascii')
if (state === 0) {
state++
expect(result).to.contain('seneca')
sock.write('console.log(this)\n')
}
else if (state === 1) {
state++
expect(result).to.contain('{')
sock.write('set foo.bar 1\n')
sock.write('this.options().foo\n')
}
else if (state === 2) {
state++
expect(result).to.contain('bar')
sock.write('list\n')
}
else if (state === 3) {
state++
expect(result).to.contain("{ role: 'seneca', stats: 'true' }")
sock.write('role:seneca,stats:true\n')
}
else if (state === 4) {
state++
expect(result).to.contain('OUT 000000')
sock.write('seneca.quit\n')
}
else if (state === 5) {
state++
expect(result).to.contain('seneca')
done()
}
}, 2000)
})
})
})
it('should have the name middleware.io', function (done) {
seneca({ log: 'silent', errhandler: done })
.use('../lib/middleware.io')
.act('role:middleware.io, cmd:info', function (err, infoText) {
infoText.should.equal('middleware version: 0.0.3');
done();
});
});
Consul.getService('sensor', (err, sensorService) => {
if (err || !sensorService || !sensorService.address) {
return retry(loadSensor);
}
sensor = Seneca();
sensor.client({
host: sensorService.address,
port: sensorService.port
});
loadingSensor = false;
});
it('happy', function( fin){
seneca({log:'silent',errhandler:fin})
.use('..')
.act('role:simple,cmd:foo,text:red',
function( err, out ) {
if( err ) return fin(err);
assert.equal( out.text, 'foo-red-zed' )
fin()
})
})
module.exports = function (options) {
var si = Seneca()
if (si.version >= '2.0.0') {
si
.use(require('seneca-entity'))
}
si
.use(require('seneca-user'), options)
return si
}
}, { type: 'activemq' }, function () {
var seneca = Seneca()
.use(require('../'))
.client({ type: 'activemq' })
.ready(function () {
seneca.act('role:calc, cmd:add', { a:1, b:3 }, function (err, res) {
if (err) throw err;
assert.equal(4, res.result);
done();
});
});
});
it('verify default generate', function (done) {
var si = seneca()
.use('..')
si.ready(function () {
var mail = si.pin({role: 'mail', cmd: '*'})
mail.generate({code: 'foo', content: {foo: 'bar'}}, function (err, out) {
assert.isNotNull(err)
done()
})
})
})
it('query', {timeout: 8888}, function (done) {
var seen = {}
Seneca()
// Place Seneca into test mode. Errors will be passed to done callback,
// so no need to handle them in callbacks.
.test(done)
// Uncomment if you want to see detailed logs
//.test(done, 'print')
.use('entity')
// Load the github plugin
.use('..')
// Subscribe to internal messages in order to count calls
.sub('role:entity', function (msg) {
seen[msg.cmd] = 1 + (seen[msg.cmd]||0)
})
.gate()
.act('role:github,cmd:query,owner:senecajs,repo:seneca,name:seneca', function (ignore, out) {
expect(out.owner).equal('senecajs')
expect(out.repo).equal('seneca')
expect(out.stars).above(0)
expect(seen).to.equal({ load: 1, save: 1 })
})
.act('role:github,cmd:get,name:seneca', function (ignore, out) {
expect(out.owner).equal('senecajs')
expect(out.repo).equal('seneca')
expect(out.stars).above(0)
expect(seen).to.equal({ load: 2, save: 1 })
})
.act('role:github,cmd:get,name:seneca', function (ignore, out) {
expect(out.owner).equal('senecajs')
expect(out.repo).equal('seneca')
expect(out.stars).above(0)
expect(seen).to.equal({ load: 3, save: 1 })
})
.ready(done)
})
it('cluster errors when node version is less than 0.12.0', function (done) {
var version = process.versions.node
var seneca = Seneca({ log: 'silent', default_plugins: { cluster: false } })
seneca.use(senecaCluster)
seneca.die = function (err) {
process.versions.node = version
expect(err.code).to.equal('bad_cluster_version')
done()
}
delete process.versions.node
process.versions.node = '0.11.99'
seneca.cluster()
})
it('verify template generate', function (done) {
var si = seneca()
.use('..', {folder: './email-templates'})
si.ready(function () {
var mail = si.pin({role: 'mail', cmd: '*'})
mail.generate({code: 'foo', content: {foo: 'bar'}}, function (err, out) {
console.log(err + ':' + JSON.stringify(out))
assert.isNull(err)
assert.equal('<h1>Foo: bar</h1>\n', out.html)
assert.equal('Foo: bar\n', out.text)
done()
})
})
})
it('plugin', function(fin) {
var si = seneca({log:'silent'})
si.use('../web.js')
si.use(function qaz(){
this.add('role:foo,cmd:zig',function(args,done){
done(null,{bar:args.zoo+'g'})
})
this.add('role:foo,cmd:bar',function(args,done){
done(null,{bar:args.zoo+'b'})
})
this.add('role:foo,cmd:qaz',function(args,done){
done(null,{qaz:args.zoo+'z'})
})
this.act('role:web',{use:function(req,res,next){next();}}, function(err){
assert.isNull(err)
})
this.act('role:web',{use:{
prefix:'/foo',
pin:{role:'foo',cmd:'*'},
map:{
zig: true,
bar: {GET:true},
qaz: {GET:true,HEAD:true}
}
}}, function(err){
assert.isNull(err)
})
})
si.act('role:web,cmd:list',success(fin,function(out){
//console.log(out)
assert.equal(out.length,4)
si.act('role:web,cmd:routes',success(fin,function(out){
//console.log(util.inspect(out,{depth:null}))
assert.equal(out.length,3)
si.act({role:'web',stats:true},success(fin,function(out){
//console.dir(out)
assert.equal(3,_.keys(out).length)
fin()
}))
}))
}))
})
it('edge', function (done) {
Seneca({log: 'silent', legacy: {error_codes: false, validate: false}})
.use('../joi')
.add({
a: 1,
joi$: 1
}, function (msg, done) {
done(null, {c: 3})
})
.act('a:1,b:2', function (err, out) {
if (err) return done(err)
Assert.equal(3, out.c)
done()
})
})