bfj
Version:
Big-friendly JSON. Asynchronous streaming functions for large JSON data sets.
1,845 lines (1,396 loc) • 90.8 kB
JavaScript
'use strict'
const assert = require('chai').assert
const spooks = require('spooks')
const Readable = require('stream').Readable
const events = require('../../src/events')
const modulePath = '../../src/walk'
suite('walk:', () => {
let log
setup(() => {
log = {}
})
test('require does not throw', () => {
assert.doesNotThrow(() => {
require(modulePath)
})
})
test('require returns function', () => {
assert.isFunction(require(modulePath))
})
suite('require:', () => {
let walk
setup(() => {
walk = require(modulePath)
})
test('walk throws without readable stream', () => {
assert.throws(() => {
walk({ on: () => {} })
})
})
test('walk does not throw with readable stream', () => {
assert.doesNotThrow(() => {
walk(new Readable())
})
})
test('walk returns emitter', () => {
assert.instanceOf(walk(new Readable()), require('events').EventEmitter)
})
test('EventEmitter is decorated with pause method', () => {
assert.isFunction(walk(new Readable()).pause)
assert.lengthOf(walk(new Readable()).pause, 0)
})
test('pause method returns continue function', () => {
assert.isFunction(walk(new Readable()).pause())
assert.lengthOf(walk(new Readable()).pause(), 0)
})
suite('empty json:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('end event was dispatched correctly', () => {
assert.lengthOf(log.args.end[0], 0)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('empty array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('array event was dispatched correctly', () => {
assert.lengthOf(log.args.array[0], 0)
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('endArray event was dispatched correctly', () => {
assert.lengthOf(log.args.endArray[0], 0)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('empty object:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('{}')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('object event occurred once', () => {
assert.strictEqual(log.counts.object, 1)
})
test('object event was dispatched correctly', () => {
assert.lengthOf(log.args.object[0], 0)
})
test('endObject event occurred once', () => {
assert.strictEqual(log.counts.endObject, 1)
})
test('endObject event was dispatched correctly', () => {
assert.lengthOf(log.args.endObject[0], 0)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('string:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('"\\"the quick brown fox\r\n\\tjumps\\u00a0over the lazy\\u1680dog\\""')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('string event occurred once', () => {
assert.strictEqual(log.counts.string, 1)
})
test('string event was dispatched correctly', () => {
assert.lengthOf(log.args.string[0], 1)
assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps\u00a0over the lazy\u1680dog"')
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('stringChunk event occured once', () => {
assert.strictEqual(log.counts.stringChunk, 1)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('string (with chunk size):', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream, { stringChunkSize: 8 })
stream.push('"\\"the quick brown fox\r\n\\tjumps\\u00a0over the lazy\\u1680dog\\""')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('stringChunk event occurred seven times', () => {
assert.strictEqual(log.counts.stringChunk, 6)
})
test('stringChunk event was dispatched correctly', () => {
assert.lengthOf(log.args.stringChunk[0], 1)
assert.strictEqual(log.args.stringChunk[0][0], '"the qui')
assert.lengthOf(log.args.stringChunk[1], 1)
assert.strictEqual(log.args.stringChunk[1][0], 'ck brown')
assert.lengthOf(log.args.stringChunk[2], 1)
assert.strictEqual(log.args.stringChunk[2][0], ' fox\r\n\tj')
assert.lengthOf(log.args.stringChunk[3], 1)
assert.strictEqual(log.args.stringChunk[3][0], 'umps\u00a0ove')
assert.lengthOf(log.args.stringChunk[4], 1)
assert.strictEqual(log.args.stringChunk[4][0], 'r the la')
assert.lengthOf(log.args.stringChunk[5], 1)
assert.strictEqual(log.args.stringChunk[5][0], 'zy\u1680dog"')
})
test('string event occurred once', () => {
assert.strictEqual(log.counts.string, 1)
})
test('string event was dispatched correctly', () => {
assert.lengthOf(log.args.string[0], 1)
assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps\u00a0over the lazy\u1680dog"')
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('number:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('-3.14159265359e+42')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('number event occurred once', () => {
assert.strictEqual(log.counts.number, 1)
})
test('number event was dispatched correctly', () => {
assert.lengthOf(log.args.number[0], 1)
assert.strictEqual(log.args.number[0][0], -3.14159265359e+42)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('literal false:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('false')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('literal event occurred once', () => {
assert.strictEqual(log.counts.literal, 1)
})
test('literal event was dispatched correctly', () => {
assert.lengthOf(log.args.literal[0], 1)
assert.strictEqual(log.args.literal[0][0], false)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('literal null:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('null')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('literal event occurred once', () => {
assert.strictEqual(log.counts.literal, 1)
})
test('literal event was dispatched correctly', () => {
assert.strictEqual(log.args.literal[0][0], null)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('literal true:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('true')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('literal event occurred once', () => {
assert.strictEqual(log.counts.literal, 1)
})
test('literal event was dispatched correctly', () => {
assert.strictEqual(log.args.literal[0][0], true)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('property event did not occur', () => {
assert.strictEqual(log.counts.property, 0)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
test('stringChunk event did not occur', () => {
assert.strictEqual(log.counts.stringChunk, 0)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
test('endPrefix event did not occur', () => {
assert.strictEqual(log.counts.endPrefix, 0)
})
})
suite('badly-closed array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[}')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('dataError event occurred twice', () => {
assert.strictEqual(log.counts.dataError, 2)
})
test('dataError event was dispatched correctly first time', () => {
assert.lengthOf(log.args.dataError[0], 1)
assert.instanceOf(log.args.dataError[0][0], Error)
assert.strictEqual(log.args.dataError[0][0].actual, '}')
assert.strictEqual(log.args.dataError[0][0].expected, 'value')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
})
test('dataError event was dispatched correctly second time', () => {
assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[1][0].expected, ']')
assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
})
suite('badly-closed object:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('{]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('object event occurred once', () => {
assert.strictEqual(log.counts.object, 1)
})
test('dataError event occurred three times', () => {
assert.strictEqual(log.counts.dataError, 3)
})
test('dataError event was dispatched correctly first time', () => {
assert.strictEqual(log.args.dataError[0][0].actual, ']')
assert.strictEqual(log.args.dataError[0][0].expected, '"')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
})
test('dataError event was dispatched correctly second time', () => {
assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[1][0].expected, '"')
assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
})
test('dataError event was dispatched correctly third time', () => {
assert.strictEqual(log.args.dataError[2][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[2][0].expected, '}')
assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[2][0].columnNumber, 3)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('array event did not occur', () => {
assert.strictEqual(log.counts.array, 0)
})
test('endArray event did not occur', () => {
assert.strictEqual(log.counts.endArray, 0)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
})
suite('string containing bad escape sequence:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('"\\"the quick brown fox\r\n\\tjumps over the lazy\\xdog\\""')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'x')
assert.strictEqual(log.args.dataError[0][0].expected, 'escape character')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 2)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 23)
})
test('string event occurred once', () => {
assert.strictEqual(log.counts.string, 1)
})
test('string event was dispatched correctly', () => {
assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps over the lazy\\xdog"')
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
})
suite('string containing bad unicode escape sequence:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('"\\u012g"')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'g')
assert.strictEqual(log.args.dataError[0][0].expected, 'hex digit')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 7)
})
test('string event occurred once', () => {
assert.strictEqual(log.counts.string, 1)
})
test('string event was dispatched correctly', () => {
assert.strictEqual(log.args.string[0][0], '\\u012g')
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
})
suite('unterminated string:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('"foo')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[0][0].expected, '"')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 5)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('string event did not occur', () => {
assert.strictEqual(log.counts.string, 0)
})
})
suite('bad number:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('1e')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('number event did not occur', () => {
assert.strictEqual(log.counts.number, 0)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly first time', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[0][0].expected, 'exponent')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
})
suite('alternative bad number:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('42f')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('number event occurred once', () => {
assert.strictEqual(log.counts.number, 1)
})
test('number event was dispatched correctly', () => {
assert.strictEqual(log.args.number[0][0], 42)
})
test('dataError event occurred twice', () => {
assert.strictEqual(log.counts.dataError, 2)
})
test('dataError event was dispatched correctly first time', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'f')
assert.strictEqual(log.args.dataError[0][0].expected, 'EOF')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
})
test('dataError event was dispatched correctly second time', () => {
assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[1][0].expected, 'a')
assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[1][0].columnNumber, 4)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
})
suite('bad literal false:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('falsd')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'd')
assert.strictEqual(log.args.dataError[0][0].expected, 'e')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 5)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
})
suite('bad literal null:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('nul')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[0][0].expected, 'l')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 4)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
})
suite('bad literal true:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('tRue')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('dataError event occurred four times', () => {
assert.strictEqual(log.counts.dataError, 4)
})
test('dataError event was dispatched correctly first time', () => {
assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
assert.strictEqual(log.args.dataError[0][0].expected, 'u')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
})
test('dataError event was dispatched correctly second time', () => {
assert.strictEqual(log.args.dataError[1][0].actual, 'u')
assert.strictEqual(log.args.dataError[1][0].expected, 'EOF')
assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
})
test('dataError event was dispatched correctly third time', () => {
assert.strictEqual(log.args.dataError[2][0].actual, 'u')
assert.strictEqual(log.args.dataError[2][0].expected, 'value')
assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[2][0].columnNumber, 3)
})
test('dataError event was dispatched correctly fourth time', () => {
assert.strictEqual(log.args.dataError[3][0].actual, 'e')
assert.strictEqual(log.args.dataError[3][0].expected, 'value')
assert.strictEqual(log.args.dataError[3][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[3][0].columnNumber, 4)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('literal event did not occur', () => {
assert.strictEqual(log.counts.literal, 0)
})
})
suite('array inside array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[[]]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred twice', () => {
assert.strictEqual(log.counts.array, 2)
})
test('endArray event occurred twice', () => {
assert.strictEqual(log.counts.endArray, 2)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
})
suite('two arrays inside array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[[],[]]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred three times', () => {
assert.strictEqual(log.counts.array, 3)
})
test('endArray event occurred three times', () => {
assert.strictEqual(log.counts.endArray, 3)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
})
suite('two arrays inside array with whitespace:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push(' [ [] , [] ] ')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred three times', () => {
assert.strictEqual(log.counts.array, 3)
})
test('endArray event occurred three times', () => {
assert.strictEqual(log.counts.endArray, 3)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
})
suite('two arrays inside array without comma:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[[][]]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred three times', () => {
assert.strictEqual(log.counts.array, 3)
})
test('endArray event occurred three times', () => {
assert.strictEqual(log.counts.endArray, 3)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, '[')
assert.strictEqual(log.args.dataError[0][0].expected, ',')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 4)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('endObject event did not occur', () => {
assert.strictEqual(log.counts.endObject, 0)
})
})
suite('object inside array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[{}]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('object event occurred once', () => {
assert.strictEqual(log.counts.object, 1)
})
test('endObject event occurred once', () => {
assert.strictEqual(log.counts.endObject, 1)
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
})
suite('two objects inside array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[{},{}]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('object event occurred twice', () => {
assert.strictEqual(log.counts.object, 2)
})
test('endObject event occurred twice', () => {
assert.strictEqual(log.counts.endObject, 2)
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
})
suite('two objects inside array with whitespace:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('\t[\t{}\t,\r{}\n]\r\n')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('object event occurred twice', () => {
assert.strictEqual(log.counts.object, 2)
})
test('endObject event occurred twice', () => {
assert.strictEqual(log.counts.endObject, 2)
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
})
suite('two objects inside array without comma:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('[ {} {} ]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('object event occurred twice', () => {
assert.strictEqual(log.counts.object, 2)
})
test('endObject event occurred twice', () => {
assert.strictEqual(log.counts.endObject, 2)
})
test('dataError event occurred once', () => {
assert.strictEqual(log.counts.dataError, 1)
})
test('dataError event was dispatched correctly', () => {
assert.strictEqual(log.args.dataError[0][0].actual, '{')
assert.strictEqual(log.args.dataError[0][0].expected, ',')
assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
assert.strictEqual(log.args.dataError[0][0].columnNumber, 6)
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
})
suite('string inside array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('["foo"]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('string event occurred once', () => {
assert.strictEqual(log.counts.string, 1)
})
test('string event was dispatched correctly', () => {
assert.strictEqual(log.args.string[0][0], 'foo')
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts.end, 1)
})
test('object event did not occur', () => {
assert.strictEqual(log.counts.object, 0)
})
test('error event did not occur', () => {
assert.strictEqual(log.counts.error, 0)
})
test('dataError event did not occur', () => {
assert.strictEqual(log.counts.dataError, 0)
})
test('endLine event did not occur', () => {
assert.strictEqual(log.counts.endLine, 0)
})
})
suite('two strings inside array:', () => {
let stream, emitter
setup(done => {
stream = new Readable()
stream._read = () => {}
emitter = walk(stream)
stream.push('["foo","bar"]')
stream.push(null)
Object.entries(events).forEach(([ key, value ]) => {
emitter.on(value, spooks.fn({
name: key,
log: log
}))
})
emitter.on(events.end, done)
})
test('array event occurred once', () => {
assert.strictEqual(log.counts.array, 1)
})
test('string event occurred twice', () => {
assert.strictEqual(log.counts.string, 2)
})
test('string event was dispatched correctly first time', () => {
assert.strictEqual(log.args.string[0][0], 'foo')
})
test('string event was dispatched correctly second time', () => {
assert.strictEqual(log.args.string[1][0], 'bar')
})
test('endArray event occurred once', () => {
assert.strictEqual(log.counts.endArray, 1)
})
test('end event occurred once', () => {
assert.strictEqual(log.counts