legos/test/legos.coffee

Snap your streams together

#
#         _______
#        /\      \
#       /  \      \        _
#      / O  \      \      | |
#     /      \      \     | |     ___  __ _  ___  ___
#    /      O \______\    | |    / _ \/ _` |/ _ \/ __|
#    \ O      /      /    | |___|  __/ (_| | (_) \__ \
#     \      /      /     |______\___|\__, |\___/|___/
#      \  O /      /                   __/ |
#       \  /      /                   |___/
#        \/______/
#

should = require 'should'
async = require 'async'
common = require './common'
legos = require '../'
suite = require './suite'

suite legos.Lego, ->
  common.testWrite 'should pass elements through',
    legos: [new legos.Lego]
    write: [1, 2, 3, 4, 5, 'hello', [1, 2, 3], {}]
    read : [1, 2, 3, 4, 5, 'hello', [1, 2, 3], {}]

  common.testWrite 'should split/join elements',
    legos: [new legos.Lego, [new legos.Lego, new legos.Lego], new legos.Lego]
    write: [1, 2, 3, 4, 'hello', [1, 2, 3], {}]
    read : [1, 1, 2, 2, 3, 3, 4, 4, 'hello', 'hello',
      [1, 2, 3], [1, 2, 3], {}, {}]

suite legos.LegoAccumulator, ->
  acc = new legos.LegoAccumulator
  common.testWrite 'should buffer elements',
    legos: [acc]
    write: [1, 2, 3, 4, 5, 'hello', false, true]
    read : [[1, 2, 3, 4, 5, 'hello', false, true]]

  common.testWrite 'should successfully reset upon flush',
    legos: [acc]
    write: [1, 2, 3, 4, 3, 2, 1]
    read : [[1, 2, 3, 4, 3, 2, 1]]

  it 'should remain open after hard flush', ->
    cache = null
    reader = new legos.Lego
    reader.write = (item)-> cache = item

    acc.snap reader

    acc._open.should.equal no
    acc.open()
    acc._open.should.equal yes

    acc.write item for item in [1, 2, 3, 4, 5, 'hello']

    acc.flush()
    cache.should.deepEqual [1, 2, 3, 4, 5, 'hello']
    acc._open.should.equal yes

    acc.close()
    cache.should.eql [1, 2, 3, 4, 5, 'hello']

  common.testWrite 'should honor emitEmpty',
    legos: [new legos.LegoAccumulator yes]
    write: []
    read : [[]]

suite legos.LegoContainer, ->
  container = new legos.LegoContainer
  link1 = new legos.Lego
  link2 = new legos.Lego
  link3 = new legos.Lego
  out = new legos.Lego

  container.push link1, link2, link3

  count = 0
  out.write = (i)-> ++count

  link1.snap out
  link2.snap out
  link3.snap out

  describe 'basic', ->
    common.testWrite 'should pass items in series',
      legos: [container]
      write: [1, 2]
      read : [1, 2]

    it 'should have counted the elements', ->
      count.should.equal 6

    it 'should have closed the links', ->
      link1._open.should.equal no
      link2._open.should.equal no
      link3._open.should.equal no
      out._open.should.equal no

  describe 'pop()', ->
    it 'should honor pop', ->
      count = 0
      container.pop()

    common.testWrite 'should pass items in a series',
      legos: [container]
      write: [1, 2]
      read : [1, 2]

    it 'should have counted the elements', ->
      count.should.equal 4

    it 'should have closed the links', ->
      link1._open.should.equal no
      link2._open.should.equal no
      link3._open.should.equal no
      out._open.should.equal no

  describe 'remove()', ->
    it 'should honor remove', ->
      count = 0
      container.remove link1

    common.testWrite 'should pass items in a series',
      legos: [container]
      write: [1, 2]
      read : [1, 2]

    it 'should have counted the elements', ->
      count.should.equal 2

    it 'should have closed the links', ->
      link1._open.should.equal no
      link2._open.should.equal no
      link3._open.should.equal no
      out._open.should.equal no

suite legos.LegoContainerParallel, ->
  lego = new legos.LegoContainerParallel
  lego.push new legos.Lego for [0...3]

  common.testWrite 'should pass elements in parallel',
    legos: [lego],
    write: [1, 2, 3, 4]
    read : [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

suite legos.LegoEmitter, ->
  it 'should emit elements to \'data\' event', (done)->
    lego = new legos.LegoEmitter
    next = new legos.Lego

    results = []
    lego.on 'data', (item)->
      results.push item
    lego.on 'end', ->
      lego._open.should.equal no
      next._open.should.equal no
      return done()

    next.snap lego
    next.open()
    lego._open.should.equal yes
    next.write 1
    next.write 2
    results.should.deepEqual [1, 2]
    next.close()

suite legos.LegoFilter, ->
  testTransform = (description, config)->
    config.legos = [new legos.LegoFilter config.filter, config.negate]
    common.testWrite description, config

  describe 'positive', ->
    testTransform 'should filter a single number',
      filter: 123
      write: [123, 142, 123, 12, 'hello', {}, null, 123]
      read: [123, 123, 123]

    testTransform 'should filter a string',
      filter: 'hello!'
      write: [123, 'hello!', 123, 'jello!', 'hello', {}, null, 'hello!']
      read: ['hello!', 'hello!']

    testTransform 'should filter an object',
      filter: {foo: 'bar'}
      write: [123, {foo: 'bar'}, {foo: 'jar'}, [{foo: 'bar'}], 'hello', 'bar']
      read: [{foo: 'bar'}]

  describe 'negative', ->
    testTransform 'should filter a single number',
      filter: 123
      negate: yes
      write: [123, 142, 123, 12, 'hello', {}, null, 123]
      read: [142, 12, 'hello', {}, null]

    testTransform 'should filter a string',
      filter: 'hello!'
      negate: yes
      write: [123, 'hello!', 123, 'jello!', 'hello', {}, null, 'hello!']
      read: [123, 123, 'jello!', 'hello', {}, null]

    testTransform 'should filter an object',
      filter: {foo: 'bar'}
      negate: yes
      write: [123, {foo: 'bar'}, {foo: 'jar'}, [{foo: 'bar'}], 'hello', 'bar']
      read: [123, {foo: 'jar'}, [{foo: 'bar'}], 'hello', 'bar']

suite legos.LegoFn, (->), ->
  it 'shouldn\'t allow non-functions', ->
    (->
      new legos.LegoFn 1234
    ).should.throw 'argument must be a function'

  duplicator = new legos.LegoFn (item, write)->
    write item
    write item

  common.testWrite 'should duplicate items (twice)',
    legos: [duplicator]
    write: [1, 2, 3, 4, 'hello']
    read : [1, 1, 2, 2, 3, 3, 4, 4, 'hello', 'hello']

suite legos.LegoGlob, null, {autoClose: false},  ->
  it 'should glob and close', (done)->
    lego = new legos.LegoGlob '**/*', {cwd: 'test/fixture'}
    next = new legos.Lego

    results = []
    next.write = (item)-> results.push item
    next.close = ->
      results.should.deepEqual ['bar', 'foo', 'qux', 'qux/qix']
      lego._open.should.equal no
      done()

    lego.snap next
    lego.open()

  it 'should glob and stay open', (done)->
    # this isn't going to be a beautiful test.
    lego = new legos.LegoGlob '**/*', {cwd: 'test/fixture', autoClose: no}
    next = new legos.Lego

    results = []
    next.write = (item)-> results.push item

    lego.snap next

    ###
    # what happens here is kind of terrifying.
    # I overwrite `async.each`, the function LegoGlob uses to iterate
    # over the files, and wrap its "result" function (the function called
    # either on completion or on error), allowing me to make sure it hasn't
    # closed itself.
    #
    # this is in lieu of a timeout or other non-reliable means of checking
    # information upon finishing up the scandir() (glob).
    ###
    _each = async.each
    try
      async.each = (arr, itr, result)->
        _each.call async, arr, itr, (err)->
          async.each = _each
          result err
          lego._open.should.equal yes
          next._open.should.equal yes
          results.should.deepEqual ['bar', 'foo', 'qux', 'qux/qix']
          lego.close()
          lego._open.should.equal no
          next._open.should.equal no
          done()

      lego.open()
    catch e
      async.each = _each

suite legos.LegoTransform, ->
  testTransform = (description, config)->
    config.legos = [new legos.LegoTransform config.transform]
    common.testWrite description, config

  testTransform 'should transform basic numbers',
    transform: 123
    write: ['hello', {}, null, 15, 1555, 1234]
    read: [123, 123, 123, 123, 123, 123]

  testTransform 'should transform basic strings',
    transform: 'hi'
    write: ['hello', {}, null, 15, 1555, 1234]
    read: ['hi', 'hi', 'hi', 'hi', 'hi', 'hi']

  testTransform 'should transform to null',
    transform: null
    write: ['hello', {}, null, 15, 1555, 1234]
    read: [null, null, null, null, null, null]

  testTransform 'should transform complex objects',
    transform: a:b:(v)-> v * 2
    write: [{a: b: 16}, {a: b: 54, c: 15}, {a: b: 14}]
    read: [{a: b: 32}, {a: b: 108, c: 15}, {a: b: 28}]