joe.describe('extract-opts', function (describe, it) {
// Prepare
function cb () {}
const fixtures = {
empty: {
in: [],
out: [{}, null]
},
opts: {
in: [{a:1}],
out: [{a:1}, null]
},
cb: {
in: [null, cb],
out: [{}, cb]
},
both: {
in: [{a:1}, cb],
out: [{a:1}, cb]
},
mixed: {
in: [{a:1, next:cb}],
out: [{a:1}, cb]
},
rename: {
in: [{a:1, asd:cb}, null, {completionCallbackNames: ['asd']}],
out: [{a:1}, cb]
}
}
// Test
eachr(fixtures, function (value, key) {
it(key, function () {
const actual = extractOpts.apply(extractOpts, value.in)
deepEqual(actual, value.out, 'result comparison')
})
})
})
// Import
var expect = require('chai').expect;
var joe = require('joe');
var domain = require('./');
// =====================================
// Tests
joe.describe('domain-browser', function(describe,it){
it('should work on throws', function(done){
var d = domain.create();
d.on('error', function(err){
expect(err && err.message).to.eql('a thrown error');
done();
});
d.run(function(){
throw new Error('a thrown error');
});
});
});
joe.describe('domain-browser', function(describe,it){
it('should work on throws', function(done){
var d = domain.create()
d.on('error', function(err){
expect(err && err.message).to.eql('a thrown error')
done()
})
d.run(function(){
throw new Error('a thrown error')
})
})
it('should be able to add emitters', function(done){
var d = domain.create()
var emitter = new events.EventEmitter()
d.add(emitter)
d.on('error', function (err) {
expect(err && err.message).to.eql('an emitted error')
done()
})
emitter.emit('error', new Error('an emitted error'))
})
it('should be able to remove emitters', function (done){
var emitter = new events.EventEmitter()
var d = domain.create()
d.add(emitter)
var domainGotError = false
d.on('error', function (err) {
domainGotError = true
})
emitter.on('error', function (err) {
expect(err && err.message).to.eql('This error should not go to the domain')
// Make sure nothing race condition-y is happening
setTimeout(function () {
expect(domainGotError).to.eql(false)
done()
}, 0)
})
d.remove(emitter)
emitter.emit('error', new Error('This error should not go to the domain'))
})
it('bind should work', function(done){
var d = domain.create()
d.on('error', function(err){
expect(err && err.message).to.eql('a thrown error')
done()
})
d.bind(function(err, a, b){
expect(err && err.message).to.equal('a passed error')
expect(a).to.equal(2)
expect(b).to.equal(3)
throw new Error('a thrown error')
})(new Error('a passed error'), 2, 3)
})
it('intercept should work', function(done){
var d = domain.create()
var count = 0
d.on('error', function(err){
if ( count === 0 ) {
expect(err && err.message).to.eql('a thrown error')
} else if ( count === 1 ) {
expect(err && err.message).to.eql('a passed error')
done()
}
count++
})
d.intercept(function(a, b){
expect(a).to.equal(2)
expect(b).to.equal(3)
throw new Error('a thrown error')
})(null, 2, 3)
d.intercept(function(a, b){
throw new Error('should never reach here')
})(new Error('a passed error'), 2, 3)
})
})
joe.describe('domain-browser', function (describe, it) {
it('should work on throws', function (done) {
const d = domain.create();
d.on('error', function (err) {
equal(err && err.message, 'a thrown error', 'error message');
done()
});
d.run(function () {
throw new Error('a thrown error')
})
});
it('should be able to add emitters', function (done) {
const d = domain.create();
const emitter = new events.EventEmitter();
d.add(emitter);
d.on('error', function (err) {
equal(err && err.message, 'an emitted error', 'error message');
done()
});
emitter.emit('error', new Error('an emitted error'))
});
it('should be able to remove emitters', function (done) {
const emitter = new events.EventEmitter();
const d = domain.create();
let domainGotError = false;
d.add(emitter);
d.on('error', function (err) {
domainGotError = true
});
emitter.on('error', function (err) {
equal(err && err.message, 'This error should not go to the domain', 'error message');
// Make sure nothing race condition-y is happening
setTimeout(function () {
equal(domainGotError, false, 'no domain error');
done()
}, 0)
});
d.remove(emitter);
emitter.emit('error', new Error('This error should not go to the domain'))
});
it('bind should work', function (done) {
const d = domain.create();
d.on('error', function (err) {
equal(err && err.message, 'a thrown error', 'error message');
done()
});
d.bind(function (err, a, b) {
equal(err && err.message, 'a passed error', 'error message');
equal(a, 2, 'value of a');
equal(b, 3, 'value of b');
throw new Error('a thrown error')
})(new Error('a passed error'), 2, 3)
});
it('intercept should work', function (done) {
const d = domain.create();
let count = 0;
d.on('error', function (err) {
if ( count === 0 ) {
equal(err && err.message, 'a thrown error', 'error message')
}
else if ( count === 1 ) {
equal(err && err.message, 'a passed error', 'error message');
done()
}
count++
});
d.intercept(function (a, b) {
equal(a, 2, 'value of a');
equal(b, 3, 'value of b');
throw new Error('a thrown error')
})(null, 2, 3);
d.intercept(function (a, b) {
throw new Error('should never reach here')
})(new Error('a passed error'), 2, 3)
})
});
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
var joe = require('joe');
var should = require('chai').should();
var sfmt = require('..');
joe.describe('indexed string format', function (describe, it) {
it('should default to strings when no format is specified', function () {
sfmt('a %{2} b %{0} c%{1} d%{3}', 'a', 'b', 'c', 'd').should.equal('a c b a cb dd');
});
it('should use formats when specified', function () {
sfmt('a %{2:s} b %{0} c%{1:d} d%{3:j}', 'a', 12, 'c', 'd').should.equal('a c b a c12 d"d"');
});
it('should ignore unknown type format', function () {
sfmt('a %{0:q}', 'hello').should.equal('a hello');
});
it('should be escaped with double percents', function () {
sfmt('%%{0} bc', 'one').should.equal('%{0} bc');
})
});
"use strict";
// Import
var expect = require('chai').expect,
joe = require('joe')
// Test
joe.describe('feed plugin', function(describe,it){
var Chainy = require('chainy-core').subclass().require('set').addExtension('feed', require('../'))
it("should work", function(next){
Chainy.create()
.set('https://raw.githubusercontent.com/chainy-plugins/set/master/package.json')
.feed()
.done(function(err, result){
if (err) return next(err)
expect(result && result.name).to.equal('chainy-plugin-set')
return next()
})
})
})
joe.describe('Object', function (describe, it) {
describe('construction', function (describe, it) {
it('should construct empty object', function () {
var obj = mjo.o();
expect(obj).to.be.an('object');
expect(Object.keys(obj)).to.have.length(0);
});
it('should construct object with given properties', function () {
var obj = mjo.o({a: 1, b: '2'});
expect(obj).to.be.an('object');
expect(obj.a).to.equal(1);
expect(obj.b).to.equal('2');
expect(Object.keys(obj)).to.have.length(2);
});
it('should construct from multiple source objects', function () {
var obj = mjo.o({a: 1}, {b: '2'});
expect(obj).to.be.an('object');
expect(obj.a).to.equal(1);
expect(obj.b).to.equal('2');
expect(Object.keys(obj)).to.have.length(2);
});
it('should allow null in parameter list', function () {
var obj = mjo.o({a: 1}, null, {b: '2'});
expect(obj).to.be.an('object');
expect(obj.a).to.equal(1);
expect(obj.b).to.equal('2');
expect(Object.keys(obj)).to.have.length(2);
});
it('should flatten array in parameter list', function () {
var obj = mjo.o({a: 1}, [{b: '2'}, {c: 3}], {d: 4});
expect(obj).to.be.an('object');
expect(obj).to.have.all.keys({a:0, b:0, c:0, d:0});
});
it('should flatten arbitrarily deep arrays and ignore nulls and empty arrays', function () {
var obj = mjo.o([[[{a:1}], [[null, {b: '2'}], {c: 3}], null], [{d: 4}], []]);
expect(obj).to.be.an('object');
expect(obj).to.have.all.keys({a:0, b:0, c:0, d:0});
expect(obj).to.have.property('a', 1);
expect(obj).to.have.property('b', '2');
expect(obj).to.have.property('c', 3);
expect(obj).to.have.property('d', 4);
});
});
describe('extension', function (describe, it) {
it('should return original object', function () {
var obj = {a: 1};
var o2 = mjo.extend(obj, {});
expect(o2).equals(obj);
});
it('should add properties to original object', function () {
var obj = {a: 1};
mjo.extend(obj, {b: '2'}, [{c: 3, d: 4}]);
expect(obj).to.have.all.keys(['a', 'b', 'c', 'd']);
expect(obj).to.have.property('a', 1);
expect(obj).to.have.property('b', '2');
expect(obj).to.have.property('c', 3);
expect(obj).to.have.property('d', 4);
});
});
});
joe.describe('chainy', function(describe,it){
var Chainy = require('../')
it("should fail when attempting to extend the base class", function(){
var err = null
try {
Chainy.addExtension('test', 'action', function(){})
}
catch (_err) {
err = _err
}
expect(err && err.message).to.contain('frozen')
})
it("should pass when attempting to extend a child class", function(){
var extension = function(){}
var MyChainy = Chainy.subclass().addExtension('test', 'utility', extension)
expect(MyChainy.prototype.test).to.eql(extension)
})
it("it should have autoloaded the set plugin", function(next){
var a = [1,[2,3]]
Chainy.create()
.set(a)
.done(function(err, result){
if (err) return next(err)
expect(result).to.equal(a)
return next()
})
})
/*
test currently disabled until we figure out how to prevent this from adding flatten to the dependencies in package.json
it("it should autoinstall the flatten plugin on node v0.11+", function(next){
var a = [1,[2,3]]
try {
Chainy.create().require('flatten')
.set(a)
.flatten()
.done(function(err, result){
if (err) return next(err)
expect(result).to.deep.equal([1,2,3])
return next()
})
} catch ( err ) {
if ( require('semver').satisfies(process.version, '>=0.11') === false ) {
console.log('error expected as we are on node <0.11')
next()
} else {
next(err)
}
}
})
*/
})
joe.describe('domain-browser', function(describe,it){
it('should work on throws', function(done){
var d = domain.create();
d.on('error', function(err){
expect(err && err.message).to.eql('a thrown error');
done();
});
d.run(function(){
throw new Error('a thrown error');
});
});
it('should be able to add emitters', function(done){
var d = domain.create();
var emitter = new events.EventEmitter();
d.add(emitter);
d.on('error', function (err) {
expect(err && err.message).to.eql('an emitted error');
done();
});
emitter.emit('error', new Error('an emitted error'));
});
it('should be able to remove emitters', function (done){
var emitter = new events.EventEmitter();
var d = domain.create();
d.add(emitter);
var domainGotError = false;
d.on('error', function (err) {
domainGotError = true
});
emitter.on('error', function (err) {
expect(err && err.message).to.eql('This error should not go to the domain')
// Make sure nothing race condition-y is happening
setTimeout(function () {
expect(domainGotError).to.eql(false)
done()
}, 0)
})
d.remove(emitter);
emitter.emit('error', new Error('This error should not go to the domain'));
})
});
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
var joe = require('joe');
var should = require('chai').should();
var sfmt = require('..');
joe.describe('named string format', function (describe, it) {
it('should get values from object by name', function () {
sfmt('a: %{name} b: %{value}', { name: 'chris', value: 'dev'})
.should.equal('a: chris b: dev');
});
it('should return undefined in string for missing values', function () {
sfmt('a: %{something} b: %{nothing}', { something: 5})
.should.equal('a: 5 b: undefined');
});
});
// Test
joe.describe('pipe plugin', function(describe,it){
var Chainy = require('chainy-core').subclass().require('set').addExtension('pipe', require('../'))
var file = __dirname+'/.log'
var cleanup = function(task, next){
fsUtil.exists(file, function(exists){
if ( exists ) {
fsUtil.unlink(file, next)
} else {
next()
}
})
}
this.on('test.before', cleanup).on('test.after', cleanup)
it("should work", function(next){
var outputStream = fsUtil.createWriteStream(file)
Chainy.create()
.set('some data')
.pipe(outputStream)
.done(function(err, result){
if (err) return next(err)
expect(result).to.equal('some data')
fsUtil.readFile(file, function(err, data){
expect(data.toString()).to.equal('some data')
return next()
})
})
})
})
joe.describe('Maybeish', function (describe, it) {
describe('dealing with null at root', function (describe, it) {
it('should return null when wrapping null', function () {
expect(maybe(null)()).to.be.null;
});
it('should return value when wrapping value', function () {
expect(maybe(5)()).to.equal(5);
});
it('should return null when wrapping undefined', function () {
expect(maybe(undefined)()).to.be.null;
});
it('should return null when accessing nested properties', function () {
expect(maybe(null, 'no.properties.on.null')()).to.be.null;
});
it('should return null when accessing nested properties via calls', function () {
expect(maybe(null)('no')('properties')()).to.be.null;
});
it('should not invoke value callback', function () {
var spy = sinon.spy();
maybe(null)(spy);
spy.called.should.be.false;
});
it('should invoke null callback and return its result', function () {
var valueSpy = sinon.stub().returns('should not be called');
var nullSpy = sinon.stub().returns('called');
var result = maybe(null)(valueSpy, nullSpy);
valueSpy.called.should.be.false;
nullSpy.callCount.should.equal(1);
expect(result).to.equal('called');
});
});
describe('dealing with an object', function () {
// Sample object to use
var obj = {
one: 1,
nested: {
a: 2,
b: 'three'
},
two: 2
};
it('should return obj when wrapping obj', function () {
expect(maybe(obj)()).to.equal(obj);
});
it('should return property when accessing nested properties', function () {
expect(maybe(obj, 'nested.b')()).to.equal(obj.nested.b);
});
it('should return property when accessing nested properties via calls', function () {
expect(maybe(obj)('nested')('a')()).to.equal(obj.nested.a);
});
it('should not invoke null callback', function () {
var valueSpy = sinon.spy();
var nullSpy = sinon.spy();
maybe(obj)(valueSpy, nullSpy);
nullSpy.called.should.be.false;
});
it('should invoke value callback passing value and return its result', function () {
var valueSpy = sinon.stub().returns('called');
var nullSpy = sinon.stub().returns('not called');
var result = maybe(obj, 'two')(valueSpy, nullSpy);
nullSpy.called.should.be.false;
valueSpy.callCount.should.equal(1);
expect(result).to.equal('called');
valueSpy.firstCall.calledWith(obj.two).should.be.true;
});
it('should be null if accessing property that does not exist', function () {
expect(maybe(obj, 'notReal.b')()).to.be.null;
});
});
});