chushihua
This commit is contained in:
li
+80
@@ -0,0 +1,80 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const modulePath = '../../src/error'
|
||||
|
||||
suite('error:', () => {
|
||||
let log
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
})
|
||||
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns object', () => {
|
||||
assert.isObject(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let error
|
||||
|
||||
setup(() => {
|
||||
error = require(modulePath)
|
||||
})
|
||||
|
||||
test('error has create method', () => {
|
||||
assert.isFunction(error.create)
|
||||
})
|
||||
|
||||
test('error has no other methods', () => {
|
||||
assert.lengthOf(Object.keys(error), 1)
|
||||
})
|
||||
|
||||
test('create expects four arguments', () => {
|
||||
assert.lengthOf(error.create, 4)
|
||||
})
|
||||
|
||||
test('create does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
error.create()
|
||||
})
|
||||
})
|
||||
|
||||
test('create returns Error', () => {
|
||||
assert.instanceOf(error.create(), Error)
|
||||
})
|
||||
|
||||
suite('create:', () => {
|
||||
let created
|
||||
|
||||
setup(() => {
|
||||
created = error.create('foo', 'bar', 'baz', 'qux')
|
||||
})
|
||||
|
||||
test('created has correct actual property', () => {
|
||||
assert.strictEqual(created.actual, 'foo')
|
||||
})
|
||||
|
||||
test('created has correct expected property', () => {
|
||||
assert.strictEqual(created.expected, 'bar')
|
||||
})
|
||||
|
||||
test('created has correct lineNumber property', () => {
|
||||
assert.strictEqual(created.lineNumber, 'baz')
|
||||
})
|
||||
|
||||
test('created has correct columnNumber property', () => {
|
||||
assert.strictEqual(created.columnNumber, 'qux')
|
||||
})
|
||||
|
||||
test('created has correct message property', () => {
|
||||
assert.strictEqual(created.message, 'JSON error: encountered `foo` at line baz, column qux where `bar` was expected.')
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
+1946
File diff suppressed because it is too large
Load Diff
+95
@@ -0,0 +1,95 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const spooks = require('spooks')
|
||||
|
||||
const modulePath = '../../src/jsonstream'
|
||||
|
||||
suite('jsonstream:', () => {
|
||||
let log
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
})
|
||||
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns function', () => {
|
||||
assert.isFunction(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let Stream
|
||||
|
||||
setup(() => {
|
||||
Stream = require(modulePath)
|
||||
})
|
||||
|
||||
test('Stream expects one argument', () => {
|
||||
assert.lengthOf(Stream, 1)
|
||||
})
|
||||
|
||||
test('calling Stream with function argument doesNotThrow', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
Stream(() => {})
|
||||
})
|
||||
})
|
||||
|
||||
test('calling Stream with object argument throws', () => {
|
||||
assert.throws(() => {
|
||||
Stream({ read: () => {} })
|
||||
})
|
||||
})
|
||||
|
||||
test('calling Stream with new returns Stream instance', () => {
|
||||
assert.instanceOf(new Stream(() => {}), Stream)
|
||||
})
|
||||
|
||||
test('calling Stream with new returns Readable instance', () => {
|
||||
assert.instanceOf(new Stream(() => {}), require('stream').Readable)
|
||||
})
|
||||
|
||||
test('calling Stream without new returns Stream instance', () => {
|
||||
assert.instanceOf(Stream(() => {}), Stream)
|
||||
})
|
||||
|
||||
suite('instantiate:', () => {
|
||||
let jsonstream
|
||||
|
||||
setup(() => {
|
||||
jsonstream = new Stream(spooks.fn({ name: 'read', log: log }))
|
||||
})
|
||||
|
||||
test('jsonstream has _read method', () => {
|
||||
assert.isFunction(jsonstream._read)
|
||||
})
|
||||
|
||||
test('_read expects no arguments', () => {
|
||||
assert.lengthOf(jsonstream._read, 0)
|
||||
})
|
||||
|
||||
test('read was not called', () => {
|
||||
assert.strictEqual(log.counts.read, 0)
|
||||
})
|
||||
|
||||
suite('jsonstream._read:', () => {
|
||||
setup(() => {
|
||||
jsonstream._read()
|
||||
})
|
||||
|
||||
test('read was called once', () => {
|
||||
assert.strictEqual(log.counts.read, 1)
|
||||
assert.isUndefined(log.these.read[0])
|
||||
})
|
||||
|
||||
test('read was called correctly', () => {
|
||||
assert.lengthOf(log.args.read[0], 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
+1011
File diff suppressed because it is too large
Load Diff
+102
@@ -0,0 +1,102 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const proxyquire = require('proxyquire')
|
||||
const spooks = require('spooks')
|
||||
|
||||
const modulePath = '../../src/read'
|
||||
|
||||
suite('read:', () => {
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns function', () => {
|
||||
assert.isFunction(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let log, results, read
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
results = {
|
||||
parse: [ {} ],
|
||||
createReadStream: [ {} ]
|
||||
}
|
||||
read = proxyquire(modulePath, {
|
||||
fs: {
|
||||
createReadStream: spooks.fn({
|
||||
name: 'createReadStream',
|
||||
log: log,
|
||||
results: results.createReadStream
|
||||
})
|
||||
},
|
||||
'./parse': spooks.fn({
|
||||
name: 'parse',
|
||||
log: log,
|
||||
results: results.parse
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
test('read expects two arguments', () => {
|
||||
assert.lengthOf(read, 2)
|
||||
})
|
||||
|
||||
test('read does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
read()
|
||||
})
|
||||
})
|
||||
|
||||
test('parse was not called', () => {
|
||||
assert.strictEqual(log.counts.parse, 0)
|
||||
})
|
||||
|
||||
test('fs.createReadStream was not called', () => {
|
||||
assert.strictEqual(log.counts.createReadStream, 0)
|
||||
})
|
||||
|
||||
suite('read:', () => {
|
||||
let path, options, result
|
||||
|
||||
setup(() => {
|
||||
path = {}
|
||||
options = { foo: 'bar', ndjson: true }
|
||||
result = read(path, options)
|
||||
})
|
||||
|
||||
test('fs.createReadStream was called once', () => {
|
||||
assert.strictEqual(log.counts.createReadStream, 1)
|
||||
})
|
||||
|
||||
test('fs.createReadStream was called correctly', () => {
|
||||
assert.lengthOf(log.args.createReadStream[0], 2)
|
||||
assert.strictEqual(log.args.createReadStream[0][0], path)
|
||||
assert.lengthOf(Object.keys(log.args.createReadStream[0][0]), 0)
|
||||
assert.strictEqual(log.args.createReadStream[0][1], options)
|
||||
assert.lengthOf(Object.keys(log.args.createReadStream[0][1]), 2)
|
||||
})
|
||||
|
||||
test('parse was called once', () => {
|
||||
assert.strictEqual(log.counts.parse, 1)
|
||||
})
|
||||
|
||||
test('parse was called correctly', () => {
|
||||
assert.isUndefined(log.these.parse[0])
|
||||
assert.lengthOf(log.args.parse[0], 2)
|
||||
assert.strictEqual(log.args.parse[0][0], results.createReadStream[0])
|
||||
assert.lengthOf(Object.keys(log.args.parse[0][0]), 0)
|
||||
assert.notStrictEqual(log.args.parse[0][1], options)
|
||||
assert.deepEqual(log.args.parse[0][1], { foo: 'bar', ndjson: false })
|
||||
})
|
||||
|
||||
test('parse result was returned', () => {
|
||||
assert.strictEqual(result, results.parse[0])
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
+981
@@ -0,0 +1,981 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const proxyquire = require('proxyquire')
|
||||
const spooks = require('spooks')
|
||||
|
||||
const modulePath = '../../src/streamify'
|
||||
|
||||
suite('streamify:', () => {
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns function', () => {
|
||||
assert.isFunction(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let log, results, streamify
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
results = {
|
||||
eventify: [
|
||||
{ on: spooks.fn({ name: 'on', log: log }) }
|
||||
],
|
||||
push: [ true ]
|
||||
}
|
||||
streamify = proxyquire(modulePath, {
|
||||
'./eventify': spooks.fn({
|
||||
name: 'eventify',
|
||||
log: log,
|
||||
results: results.eventify
|
||||
}),
|
||||
'./jsonstream': spooks.ctor({
|
||||
name: 'JsonStream',
|
||||
log: log,
|
||||
archetype: { instance: { push: () => {}, emit: () => {} } },
|
||||
results: results
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
test('streamify expects two arguments', () => {
|
||||
assert.lengthOf(streamify, 2)
|
||||
})
|
||||
|
||||
test('streamify does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
streamify()
|
||||
})
|
||||
})
|
||||
|
||||
test('streamify returns stream', () => {
|
||||
assert.isFunction(streamify().push)
|
||||
assert.isFunction(streamify().emit)
|
||||
})
|
||||
|
||||
test('JsonStream was not called', () => {
|
||||
assert.strictEqual(log.counts.JsonStream, 0)
|
||||
})
|
||||
|
||||
test('eventify was not called', () => {
|
||||
assert.strictEqual(log.counts.eventify, 0)
|
||||
})
|
||||
|
||||
test('EventEmitter.on was not called', () => {
|
||||
assert.strictEqual(log.counts.on, 0)
|
||||
})
|
||||
|
||||
suite('streamify:', () => {
|
||||
let data, options, result
|
||||
|
||||
setup(() => {
|
||||
data = {}
|
||||
options = {}
|
||||
result = streamify(data, options)
|
||||
})
|
||||
|
||||
test('JsonStream was called once', () => {
|
||||
assert.strictEqual(log.counts.JsonStream, 1)
|
||||
assert.isObject(log.these.JsonStream[0])
|
||||
})
|
||||
|
||||
test('JsonStream was called correctly', () => {
|
||||
assert.lengthOf(log.args.JsonStream[0], 1)
|
||||
assert.isFunction(log.args.JsonStream[0][0])
|
||||
})
|
||||
|
||||
test('eventify was called once', () => {
|
||||
assert.strictEqual(log.counts.eventify, 1)
|
||||
assert.isUndefined(log.these.eventify[0])
|
||||
})
|
||||
|
||||
test('eventify was called correctly', () => {
|
||||
assert.lengthOf(log.args.eventify[0], 2)
|
||||
assert.strictEqual(log.args.eventify[0][0], data)
|
||||
assert.lengthOf(Object.keys(log.args.eventify[0][0]), 0)
|
||||
assert.strictEqual(log.args.eventify[0][1], options)
|
||||
assert.lengthOf(Object.keys(log.args.eventify[0][1]), 0)
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called ten times', () => {
|
||||
assert.strictEqual(log.counts.on, 10)
|
||||
assert.strictEqual(log.these.on[0], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[1], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[2], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[3], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[4], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[5], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[6], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[7], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[8], results.eventify[0])
|
||||
assert.strictEqual(log.these.on[9], results.eventify[0])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly first time', () => {
|
||||
assert.lengthOf(log.args.on[0], 2)
|
||||
assert.strictEqual(log.args.on[0][0], 'arr')
|
||||
assert.isFunction(log.args.on[0][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly second time', () => {
|
||||
assert.lengthOf(log.args.on[1], 2)
|
||||
assert.strictEqual(log.args.on[1][0], 'obj')
|
||||
assert.isFunction(log.args.on[1][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly third time', () => {
|
||||
assert.lengthOf(log.args.on[2], 2)
|
||||
assert.strictEqual(log.args.on[2][0], 'pro')
|
||||
assert.isFunction(log.args.on[2][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly fourth time', () => {
|
||||
assert.lengthOf(log.args.on[3], 2)
|
||||
assert.strictEqual(log.args.on[3][0], 'str')
|
||||
assert.isFunction(log.args.on[3][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly fifth time', () => {
|
||||
assert.lengthOf(log.args.on[4], 2)
|
||||
assert.strictEqual(log.args.on[4][0], 'num')
|
||||
assert.isFunction(log.args.on[4][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly sixth time', () => {
|
||||
assert.lengthOf(log.args.on[5], 2)
|
||||
assert.strictEqual(log.args.on[5][0], 'lit')
|
||||
assert.isFunction(log.args.on[5][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly seventh time', () => {
|
||||
assert.lengthOf(log.args.on[6], 2)
|
||||
assert.strictEqual(log.args.on[6][0], 'end-arr')
|
||||
assert.isFunction(log.args.on[6][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly eighth time', () => {
|
||||
assert.lengthOf(log.args.on[7], 2)
|
||||
assert.strictEqual(log.args.on[7][0], 'end-obj')
|
||||
assert.isFunction(log.args.on[7][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly ninth time', () => {
|
||||
assert.lengthOf(log.args.on[8], 2)
|
||||
assert.strictEqual(log.args.on[8][0], 'end')
|
||||
assert.isFunction(log.args.on[8][1])
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called correctly tenth time', () => {
|
||||
assert.lengthOf(log.args.on[9], 2)
|
||||
assert.strictEqual(log.args.on[9][0], 'err')
|
||||
assert.isFunction(log.args.on[9][1])
|
||||
})
|
||||
|
||||
suite('array event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[0][1]()
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 0)
|
||||
})
|
||||
|
||||
suite('end event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[8][1]()
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 0)
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly first time', () => {
|
||||
assert.lengthOf(log.args.push[0], 2)
|
||||
assert.strictEqual(log.args.push[0][0], '[')
|
||||
assert.strictEqual(log.args.push[0][1], 'utf8')
|
||||
})
|
||||
|
||||
test('stream.push was called correctly second time', () => {
|
||||
assert.lengthOf(log.args.push[1], 1)
|
||||
assert.isNull(log.args.push[1][0])
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 0)
|
||||
})
|
||||
|
||||
suite('end event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[8][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly first time', () => {
|
||||
assert.strictEqual(log.args.push[0][0], '[')
|
||||
})
|
||||
|
||||
test('stream.push was called correctly second time', () => {
|
||||
assert.isNull(log.args.push[1][0])
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('foo')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[0][0], '[')
|
||||
assert.strictEqual(log.args.push[1][0], '"foo"')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('bar')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 4)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[2][0], ',')
|
||||
assert.strictEqual(log.args.push[3][0], '"bar"')
|
||||
})
|
||||
})
|
||||
|
||||
suite('array event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[0][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 4)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[2][0], ',')
|
||||
assert.strictEqual(log.args.push[3][0], '[')
|
||||
})
|
||||
|
||||
suite('array event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[0][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 5)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[4][0], '[')
|
||||
})
|
||||
|
||||
suite('endArray event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[6][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 6)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[5][0], ']')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('bar')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 8)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[6][0], ',')
|
||||
assert.strictEqual(log.args.push[7][0], '"bar"')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('baz')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 10)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[8][0], ',')
|
||||
assert.strictEqual(log.args.push[9][0], '"baz"')
|
||||
})
|
||||
})
|
||||
|
||||
suite('endArray event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[6][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 9)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[8][0], ']')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('baz')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 11)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[9][0], ',')
|
||||
assert.strictEqual(log.args.push[10][0], '"baz"')
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('object event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[1][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 4)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[2][0], ',')
|
||||
assert.strictEqual(log.args.push[3][0], '{')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('bar')
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 5)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[4][0], '"bar":')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('baz')
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 6)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[5][0], '"baz"')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('nested')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 8)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[6][0], ',')
|
||||
assert.strictEqual(log.args.push[7][0], '"nested":')
|
||||
})
|
||||
|
||||
suite('object event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[1][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 9)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[8][0], '{')
|
||||
})
|
||||
|
||||
suite('endObject event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[7][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 10)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[9][0], '}')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('qux')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 12)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[10][0], ',')
|
||||
assert.strictEqual(log.args.push[11][0], '"qux":')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('wibble')
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 13)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[12][0], '"wibble"')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('endObject event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[7][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 11)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[10][0], '}')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('wibble')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 13)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[11][0], ',')
|
||||
assert.strictEqual(log.args.push[12][0], '"wibble"')
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('string event, push returns false:', () => {
|
||||
setup(() => {
|
||||
results.push[0] = false
|
||||
return log.args.on[3][1]('foo')
|
||||
})
|
||||
|
||||
teardown(() => {
|
||||
results.push[0] = true
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 1)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[0][0], '[')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('bar')
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 1)
|
||||
})
|
||||
|
||||
suite('read stream, endArrayEvent:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
return log.args.on[6][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[1][0], '"foo"')
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('end event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[8][1]()
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 1)
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[1][0], '"foo"')
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 3)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[2][0], ',')
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 4)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[3][0], '"bar"')
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 5)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.isNull(log.args.push[4][0])
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('read stream, push returns true:', () => {
|
||||
setup(() => {
|
||||
results.push[0] = true
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was called four times', () => {
|
||||
assert.strictEqual(log.counts.push, 5)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[1][0], '"foo"')
|
||||
assert.strictEqual(log.args.push[2][0], ',')
|
||||
assert.strictEqual(log.args.push[3][0], '"bar"')
|
||||
assert.isNull(log.args.push[4][0])
|
||||
})
|
||||
|
||||
suite('read stream:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 5)
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('object event:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
return log.args.on[1][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 2)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[0][0], '[')
|
||||
assert.strictEqual(log.args.push[1][0], '{')
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('streamify with space option:', () => {
|
||||
let data, options, result
|
||||
|
||||
setup(() => {
|
||||
data = {}
|
||||
options = { space: 2 }
|
||||
result = streamify(data, options)
|
||||
})
|
||||
|
||||
test('JsonStream was called once', () => {
|
||||
assert.strictEqual(log.counts.JsonStream, 1)
|
||||
})
|
||||
|
||||
test('eventify was called once', () => {
|
||||
assert.strictEqual(log.counts.eventify, 1)
|
||||
})
|
||||
|
||||
test('EventEmitter.on was called ten times', () => {
|
||||
assert.strictEqual(log.counts.on, 10)
|
||||
})
|
||||
|
||||
test('stream.push was not called', () => {
|
||||
assert.strictEqual(log.counts.push, 0)
|
||||
})
|
||||
|
||||
suite('read stream, object event:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
return log.args.on[1][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 1)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[0][0], '{')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('foo')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 3)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[1][0], '\n ')
|
||||
assert.strictEqual(log.args.push[2][0], '"foo":')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('bar')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 5)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[3][0], ' ')
|
||||
assert.strictEqual(log.args.push[4][0], '"bar"')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('baz')
|
||||
})
|
||||
|
||||
test('stream.push was called three times', () => {
|
||||
assert.strictEqual(log.counts.push, 8)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[5][0], ',')
|
||||
assert.strictEqual(log.args.push[6][0], '\n ')
|
||||
assert.strictEqual(log.args.push[7][0], '"baz":')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('qux')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 10)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[8][0], ' ')
|
||||
assert.strictEqual(log.args.push[9][0], '"qux"')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('wibble')
|
||||
})
|
||||
|
||||
test('stream.push was called three times', () => {
|
||||
assert.strictEqual(log.counts.push, 13)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[10][0], ',')
|
||||
assert.strictEqual(log.args.push[11][0], '\n ')
|
||||
assert.strictEqual(log.args.push[12][0], '"wibble":')
|
||||
})
|
||||
|
||||
suite('array event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[0][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 15)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[13][0], ' ')
|
||||
assert.strictEqual(log.args.push[14][0], '[')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('0')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 17)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[15][0], '\n ')
|
||||
assert.strictEqual(log.args.push[16][0], '"0"')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('1')
|
||||
})
|
||||
|
||||
test('stream.push was called three times', () => {
|
||||
assert.strictEqual(log.counts.push, 20)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[17][0], ',')
|
||||
assert.strictEqual(log.args.push[18][0], '\n ')
|
||||
assert.strictEqual(log.args.push[19][0], '"1"')
|
||||
})
|
||||
|
||||
suite('endArray event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[6][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 22)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[20][0], '\n ')
|
||||
assert.strictEqual(log.args.push[21][0], ']')
|
||||
})
|
||||
|
||||
suite('property event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[2][1]('a')
|
||||
})
|
||||
|
||||
test('stream.push was called three times', () => {
|
||||
assert.strictEqual(log.counts.push, 25)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[22][0], ',')
|
||||
assert.strictEqual(log.args.push[23][0], '\n ')
|
||||
assert.strictEqual(log.args.push[24][0], '"a":')
|
||||
})
|
||||
|
||||
suite('string event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[3][1]('b')
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 27)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[25][0], ' ')
|
||||
assert.strictEqual(log.args.push[26][0], '"b"')
|
||||
})
|
||||
|
||||
suite('endObject event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[7][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called twice', () => {
|
||||
assert.strictEqual(log.counts.push, 29)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.strictEqual(log.args.push[27][0], '\n')
|
||||
assert.strictEqual(log.args.push[28][0], '}')
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('read stream, end event:', () => {
|
||||
setup(() => {
|
||||
log.args.JsonStream[0][0]()
|
||||
return log.args.on[8][1]()
|
||||
})
|
||||
|
||||
test('stream.push was called once', () => {
|
||||
assert.strictEqual(log.counts.push, 1)
|
||||
})
|
||||
|
||||
test('stream.push was called correctly', () => {
|
||||
assert.isNull(log.args.push[0][0])
|
||||
})
|
||||
|
||||
test('stream.emit was not called', () => {
|
||||
assert.strictEqual(log.counts.emit, 0)
|
||||
})
|
||||
})
|
||||
|
||||
suite('error event:', () => {
|
||||
setup(() => {
|
||||
return log.args.on[9][1]('foo')
|
||||
})
|
||||
|
||||
test('stream.emit was called once', () => {
|
||||
assert.strictEqual(log.counts.emit, 1)
|
||||
})
|
||||
|
||||
test('stream.emit was called correctly', () => {
|
||||
assert.lengthOf(log.args.emit[0], 2)
|
||||
assert.strictEqual(log.args.emit[0][0], 'dataError')
|
||||
assert.strictEqual(log.args.emit[0][1], 'foo')
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
+178
@@ -0,0 +1,178 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const proxyquire = require('proxyquire')
|
||||
const spooks = require('spooks')
|
||||
const Promise = require('bluebird')
|
||||
|
||||
const modulePath = '../../src/stringify'
|
||||
|
||||
suite('stringify:', () => {
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns function', () => {
|
||||
assert.isFunction(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let log, stringify
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
|
||||
stringify = proxyquire(modulePath, {
|
||||
'./streamify': spooks.fn({
|
||||
name: 'streamify',
|
||||
log: log,
|
||||
results: [
|
||||
{ on: spooks.fn({ name: 'on', log: log }) }
|
||||
]
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
test('stringify expects two arguments', () => {
|
||||
assert.lengthOf(stringify, 2)
|
||||
})
|
||||
|
||||
test('stringify does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
stringify()
|
||||
})
|
||||
})
|
||||
|
||||
test('stringify returns promise', () => {
|
||||
assert.instanceOf(stringify(), Promise)
|
||||
})
|
||||
|
||||
test('streamify was not called', () => {
|
||||
assert.strictEqual(log.counts.streamify, 0)
|
||||
})
|
||||
|
||||
suite('stringify:', () => {
|
||||
let data, options, resolved, rejected, result, done
|
||||
|
||||
setup(() => {
|
||||
data = {}
|
||||
options = {}
|
||||
stringify(data, options)
|
||||
.then(res => {
|
||||
resolved = res
|
||||
done()
|
||||
})
|
||||
.catch(rej => {
|
||||
rejected = rej
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
teardown(() => {
|
||||
resolved = rejected = undefined
|
||||
})
|
||||
|
||||
test('streamify was called once', () => {
|
||||
assert.strictEqual(log.counts.streamify, 1)
|
||||
assert.isUndefined(log.these.streamify[0])
|
||||
})
|
||||
|
||||
test('streamify was called correctly', () => {
|
||||
assert.lengthOf(log.args.streamify[0], 2)
|
||||
assert.strictEqual(log.args.streamify[0][0], data)
|
||||
assert.lengthOf(Object.keys(log.args.streamify[0][0]), 0)
|
||||
assert.strictEqual(log.args.streamify[0][1], options)
|
||||
assert.lengthOf(Object.keys(log.args.streamify[0][1]), 0)
|
||||
})
|
||||
|
||||
test('stream.on was called three times', () => {
|
||||
assert.strictEqual(log.counts.on, 3)
|
||||
})
|
||||
|
||||
test('stream.on was called correctly first time', () => {
|
||||
assert.lengthOf(log.args.on[0], 2)
|
||||
assert.strictEqual(log.args.on[0][0], 'data')
|
||||
assert.isFunction(log.args.on[0][1])
|
||||
})
|
||||
|
||||
test('stream.on was called correctly second time', () => {
|
||||
assert.strictEqual(log.args.on[1][0], 'end')
|
||||
assert.isFunction(log.args.on[1][1])
|
||||
assert.notStrictEqual(log.args.on[1][1], log.args.on[0][1])
|
||||
})
|
||||
|
||||
test('stream.on was called correctly third time', () => {
|
||||
assert.strictEqual(log.args.on[2][0], 'dataError')
|
||||
assert.isFunction(log.args.on[2][1])
|
||||
assert.notStrictEqual(log.args.on[2][1], log.args.on[0][1])
|
||||
assert.notStrictEqual(log.args.on[2][1], log.args.on[1][1])
|
||||
})
|
||||
|
||||
test('promise is unfulfilled', () => {
|
||||
assert.isUndefined(resolved)
|
||||
assert.isUndefined(rejected)
|
||||
})
|
||||
|
||||
suite('data event:', () => {
|
||||
setup(() => {
|
||||
log.args.on[0][1]('foo')
|
||||
})
|
||||
|
||||
test('promise is unfulfilled', () => {
|
||||
assert.isUndefined(resolved)
|
||||
assert.isUndefined(rejected)
|
||||
})
|
||||
|
||||
suite('end event:', () => {
|
||||
setup(d => {
|
||||
done = d
|
||||
log.args.on[1][1]()
|
||||
})
|
||||
|
||||
test('promise is resolved', () => {
|
||||
assert.strictEqual(resolved, 'foo')
|
||||
})
|
||||
|
||||
test('promise is not rejected', () => {
|
||||
assert.isUndefined(rejected)
|
||||
})
|
||||
})
|
||||
|
||||
suite('data event:', () => {
|
||||
setup(() => {
|
||||
log.args.on[0][1]('bar')
|
||||
})
|
||||
|
||||
test('promise is unfulfilled', () => {
|
||||
assert.isUndefined(resolved)
|
||||
assert.isUndefined(rejected)
|
||||
})
|
||||
|
||||
suite('end event:', () => {
|
||||
setup(d => {
|
||||
done = d
|
||||
log.args.on[1][1]()
|
||||
})
|
||||
|
||||
test('promise is resolved', () => {
|
||||
assert.strictEqual(resolved, 'foobar')
|
||||
})
|
||||
})
|
||||
|
||||
suite('dataError event:', () => {
|
||||
setup(d => {
|
||||
done = d
|
||||
log.args.on[2][1]('wibble')
|
||||
})
|
||||
|
||||
test('promise is rejected', () => {
|
||||
assert.strictEqual(rejected, 'wibble')
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
+125
@@ -0,0 +1,125 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const proxyquire = require('proxyquire')
|
||||
const spooks = require('spooks')
|
||||
const Promise = require('bluebird')
|
||||
|
||||
const modulePath = '../../src/unpipe'
|
||||
|
||||
suite('unpipe:', () => {
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns function', () => {
|
||||
assert.isFunction(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let log, results, unpipe
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
results = {
|
||||
parse: [ Promise.resolve() ]
|
||||
}
|
||||
unpipe = proxyquire(modulePath, {
|
||||
'./parse': spooks.fn({
|
||||
name: 'parse',
|
||||
log: log,
|
||||
results: results.parse
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
test('unpipe expects two arguments', () => {
|
||||
assert.lengthOf(unpipe, 2)
|
||||
})
|
||||
|
||||
test('unpipe does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
unpipe(() => {})
|
||||
})
|
||||
})
|
||||
|
||||
test('unpipe throws if callback is not provided', () => {
|
||||
assert.throws(() => {
|
||||
unpipe()
|
||||
})
|
||||
})
|
||||
|
||||
test('parse was not called', () => {
|
||||
assert.strictEqual(log.counts.parse, 0)
|
||||
})
|
||||
|
||||
suite('unpipe success:', () => {
|
||||
let result, error, options
|
||||
|
||||
setup(done => {
|
||||
results.parse[0] = Promise.resolve('foo')
|
||||
options = { foo: 'bar', ndjson: true }
|
||||
unpipe((err, res) => {
|
||||
error = err
|
||||
result = res
|
||||
done()
|
||||
}, options)
|
||||
})
|
||||
|
||||
test('parse was called once', () => {
|
||||
assert.strictEqual(log.counts.parse, 1)
|
||||
})
|
||||
|
||||
test('parse was called correctly', () => {
|
||||
assert.isUndefined(log.these.parse[0])
|
||||
assert.lengthOf(log.args.parse[0], 2)
|
||||
assert.isObject(log.args.parse[0][0])
|
||||
assert.isTrue(log.args.parse[0][0].readable)
|
||||
assert.isTrue(log.args.parse[0][0].writable)
|
||||
assert.isFunction(log.args.parse[0][0].pipe)
|
||||
assert.isFunction(log.args.parse[0][0].read)
|
||||
assert.isFunction(log.args.parse[0][0]._read)
|
||||
assert.isFunction(log.args.parse[0][0].write)
|
||||
assert.isFunction(log.args.parse[0][0]._write)
|
||||
assert.notStrictEqual(log.args.parse[0][1], options)
|
||||
assert.deepEqual(log.args.parse[0][1], { foo: 'bar', ndjson: false })
|
||||
})
|
||||
|
||||
test('parse result was returned', () => {
|
||||
assert.strictEqual(result, 'foo')
|
||||
})
|
||||
|
||||
test('did not fail', () => {
|
||||
assert.isNull(error)
|
||||
})
|
||||
})
|
||||
|
||||
suite('unpipe error:', () => {
|
||||
let result, error, options
|
||||
|
||||
setup(done => {
|
||||
results.parse[0] = Promise.reject('bar')
|
||||
options = {}
|
||||
unpipe((err, res) => {
|
||||
error = err
|
||||
result = res
|
||||
done()
|
||||
}, options)
|
||||
})
|
||||
|
||||
test('parse was called once', () => {
|
||||
assert.strictEqual(log.counts.parse, 1)
|
||||
})
|
||||
|
||||
test('parse result was not returned', () => {
|
||||
assert.isUndefined(result)
|
||||
})
|
||||
|
||||
test('failed', () => {
|
||||
assert.strictEqual(error, 'bar')
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
+3096
File diff suppressed because it is too large
Load Diff
+260
@@ -0,0 +1,260 @@
|
||||
'use strict'
|
||||
|
||||
const assert = require('chai').assert
|
||||
const proxyquire = require('proxyquire')
|
||||
const spooks = require('spooks')
|
||||
const Promise = require('bluebird')
|
||||
|
||||
const modulePath = '../../src/write'
|
||||
|
||||
suite('write:', () => {
|
||||
test('require does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
require(modulePath)
|
||||
})
|
||||
})
|
||||
|
||||
test('require returns function', () => {
|
||||
assert.isFunction(require(modulePath))
|
||||
})
|
||||
|
||||
suite('require:', () => {
|
||||
let log, results, write
|
||||
|
||||
setup(() => {
|
||||
log = {}
|
||||
results = {
|
||||
createWriteStream: [ {} ]
|
||||
}
|
||||
|
||||
write = proxyquire(modulePath, {
|
||||
'fs': {
|
||||
createWriteStream: spooks.fn({
|
||||
name: 'createWriteStream',
|
||||
log: log,
|
||||
results: results.createWriteStream
|
||||
})
|
||||
},
|
||||
'./streamify': spooks.fn({
|
||||
name: 'streamify',
|
||||
log: log,
|
||||
results: [
|
||||
{
|
||||
pipe: spooks.fn({ name: 'pipe', log: log, chain: true }),
|
||||
on: spooks.fn({ name: 'on', log: log, chain: true })
|
||||
}
|
||||
]
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
test('write expects three arguments', () => {
|
||||
assert.lengthOf(write, 3)
|
||||
})
|
||||
|
||||
test('write does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
write()
|
||||
})
|
||||
})
|
||||
|
||||
test('streamify was not called', () => {
|
||||
assert.strictEqual(log.counts.streamify, 0)
|
||||
})
|
||||
|
||||
test('fs.createWriteStream was not called', () => {
|
||||
assert.strictEqual(log.counts.createWriteStream, 0)
|
||||
})
|
||||
|
||||
test('stream.pipe was not called', () => {
|
||||
assert.strictEqual(log.counts.pipe, 0)
|
||||
})
|
||||
|
||||
test('stream.on was not called', () => {
|
||||
assert.strictEqual(log.counts.on, 0)
|
||||
})
|
||||
|
||||
suite('write:', () => {
|
||||
let path, data, options, result
|
||||
|
||||
setup(() => {
|
||||
path = {}
|
||||
data = {}
|
||||
options = {}
|
||||
result = write(path, data, options)
|
||||
})
|
||||
|
||||
test('streamify was called once', () => {
|
||||
assert.strictEqual(log.counts.streamify, 1)
|
||||
assert.isUndefined(log.these.streamify[0])
|
||||
})
|
||||
|
||||
test('streamify was called correctly', () => {
|
||||
assert.lengthOf(log.args.streamify[0], 2)
|
||||
assert.strictEqual(log.args.streamify[0][0], data)
|
||||
assert.lengthOf(Object.keys(log.args.streamify[0][0]), 0)
|
||||
assert.strictEqual(log.args.streamify[0][1], options)
|
||||
assert.lengthOf(Object.keys(log.args.streamify[0][1]), 0)
|
||||
})
|
||||
|
||||
test('fs.createWriteStream was called once', () => {
|
||||
assert.strictEqual(log.counts.createWriteStream, 1)
|
||||
})
|
||||
|
||||
test('fs.createWriteStream was called correctly', () => {
|
||||
assert.lengthOf(log.args.createWriteStream[0], 2)
|
||||
assert.strictEqual(log.args.createWriteStream[0][0], path)
|
||||
assert.lengthOf(Object.keys(log.args.createWriteStream[0][0]), 0)
|
||||
assert.strictEqual(log.args.createWriteStream[0][1], options)
|
||||
assert.lengthOf(Object.keys(log.args.createWriteStream[0][1]), 0)
|
||||
})
|
||||
|
||||
test('stream.pipe was called once', () => {
|
||||
assert.strictEqual(log.counts.pipe, 1)
|
||||
})
|
||||
|
||||
test('stream.pipe was called correctly', () => {
|
||||
assert.lengthOf(log.args.pipe[0], 1)
|
||||
assert.strictEqual(log.args.pipe[0][0], results.createWriteStream[0])
|
||||
assert.lengthOf(Object.keys(log.args.pipe[0][0]), 0)
|
||||
})
|
||||
|
||||
test('stream.on was called three times', () => {
|
||||
assert.strictEqual(log.counts.on, 3)
|
||||
})
|
||||
|
||||
test('stream.on was called correctly first time', () => {
|
||||
assert.lengthOf(log.args.on[0], 2)
|
||||
assert.strictEqual(log.args.on[0][0], 'finish')
|
||||
assert.isFunction(log.args.on[0][1])
|
||||
})
|
||||
|
||||
test('stream.on was called correctly second time', () => {
|
||||
assert.lengthOf(log.args.on[1], 2)
|
||||
assert.strictEqual(log.args.on[1][0], 'error')
|
||||
assert.isFunction(log.args.on[1][1])
|
||||
assert.notStrictEqual(log.args.on[1][1], log.args.on[0][1])
|
||||
})
|
||||
|
||||
test('stream.on was called correctly third time', () => {
|
||||
assert.lengthOf(log.args.on[2], 2)
|
||||
assert.strictEqual(log.args.on[2][0], 'dataError')
|
||||
assert.isFunction(log.args.on[2][1])
|
||||
assert.notStrictEqual(log.args.on[2][1], log.args.on[0][1])
|
||||
assert.strictEqual(log.args.on[2][1], log.args.on[1][1])
|
||||
})
|
||||
|
||||
test('promise was returned', () => {
|
||||
assert.instanceOf(result, Promise)
|
||||
})
|
||||
|
||||
suite('dispatch finish event:', () => {
|
||||
let resolved, error, passed, failed
|
||||
|
||||
setup(done => {
|
||||
passed = failed = false
|
||||
|
||||
result.then(res => {
|
||||
resolved = res
|
||||
passed = true
|
||||
done()
|
||||
}).catch(err => {
|
||||
error = err
|
||||
failed = true
|
||||
done()
|
||||
})
|
||||
log.args.on[0][1]('foo')
|
||||
})
|
||||
|
||||
test('promise was resolved', () => {
|
||||
assert.isTrue(passed)
|
||||
assert.isFalse(failed)
|
||||
assert.isUndefined(resolved)
|
||||
})
|
||||
})
|
||||
|
||||
suite('dispatch error event:', () => {
|
||||
let resolved, error, passed, failed
|
||||
|
||||
setup(done => {
|
||||
passed = failed = false
|
||||
|
||||
result.then(r => {
|
||||
resolved = r
|
||||
passed = true
|
||||
done()
|
||||
}).catch(e => {
|
||||
error = e
|
||||
failed = true
|
||||
done()
|
||||
})
|
||||
log.args.on[1][1]('foo')
|
||||
})
|
||||
|
||||
test('promise was rejected', () => {
|
||||
assert.isTrue(failed)
|
||||
assert.isFalse(passed)
|
||||
assert.strictEqual(error, 'foo')
|
||||
})
|
||||
})
|
||||
|
||||
suite('dispatch dataError event:', () => {
|
||||
let resolved, error, passed, failed
|
||||
|
||||
setup(done => {
|
||||
passed = failed = false
|
||||
|
||||
result.then(r => {
|
||||
resolved = r
|
||||
passed = true
|
||||
done()
|
||||
}).catch(e => {
|
||||
error = e
|
||||
failed = true
|
||||
done()
|
||||
})
|
||||
log.args.on[2][1]('wibble')
|
||||
})
|
||||
|
||||
test('promise was rejected', () => {
|
||||
assert.isTrue(failed)
|
||||
assert.isFalse(passed)
|
||||
assert.strictEqual(error, 'wibble')
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
suite('write with error thrown by fs.createWriteStream:', () => {
|
||||
let write
|
||||
|
||||
setup(() => {
|
||||
write = proxyquire(modulePath, {
|
||||
fs: {
|
||||
createWriteStream () {
|
||||
throw new Error('foo')
|
||||
}
|
||||
},
|
||||
'./streamify': () => ({
|
||||
pipe: spooks.fn({ name: 'pipe', log: {}, chain: true }),
|
||||
on: spooks.fn({ name: 'on', log: {}, chain: true })
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
test('write does not throw', () => {
|
||||
assert.doesNotThrow(() => {
|
||||
write().catch(() => {})
|
||||
})
|
||||
})
|
||||
|
||||
test('write rejects', () => {
|
||||
write()
|
||||
.then(() => assert.fail('write should reject'))
|
||||
.catch(error => {
|
||||
assert.instanceOf(error, Error)
|
||||
assert.equal(error.message, 'foo')
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user