File Manager

Editing File: /home/ubuntu/walnutminds-ecom-frontend-base/node_modules/bfj/test/unit/walk.js

'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('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)
      })