datapumps/lib/spec/Buffer.js

Node.js ETL (Extract, Transform, Load) toolkit for easy data import, export or transfer between systems.

(function() {
  var Buffer, Promise, sinon;

  require('should');

  Promise = require('bluebird');

  sinon = require('sinon');

  Buffer = require('../Buffer');

  describe('Buffer', function() {
    it('should be empty when created', function() {
      var buffer;
      buffer = new Buffer;
      return buffer.isEmpty().should.be["true"];
    });
    describe('#write(data)', function() {
      it('should add the data to the buffer', function() {
        var buffer;
        buffer = new Buffer;
        buffer.write('test');
        return buffer.getContent().should.eql(['test']);
      });
      it('should throw error when the buffer is full', function() {
        var buffer;
        buffer = new Buffer({
          size: 1
        });
        buffer.write('test');
        return (function() {
          return buffer.write('again');
        }).should["throw"]('Buffer is full');
      });
      return it('should emit full event when the buffer becomes full', function(done) {
        var buffer;
        buffer = new Buffer({
          size: 2
        });
        buffer.write('test');
        buffer.on('full', function() {
          return done();
        });
        return buffer.write('test');
      });
    });
    describe('#appendArray(dataArray)', function() {
      it('should add data to the buffer', function() {
        var buffer;
        buffer = new Buffer({
          size: 10
        });
        buffer.write('test');
        buffer.appendArray(['foo', 'bar']);
        buffer.size.should.equal(10);
        return buffer.getContent().should.eql(['test', 'foo', 'bar']);
      });
      return it('should increase buffer size when necessary', function() {
        var buffer;
        buffer = new Buffer({
          size: 2
        });
        buffer.write('test');
        buffer.appendArray(['foo', 'bar']);
        buffer.size.should.equal(3);
        return buffer.getContent().should.eql(['test', 'foo', 'bar']);
      });
    });
    describe('#writeAsync(data)', function() {
      it('should write buffer when not full', function(done) {
        var buffer;
        buffer = new Buffer;
        return buffer.writeAsync('test').then(function() {
          buffer.getContent().should.eql(['test']);
          return done();
        });
      });
      it('should wait for a read event to write the buffer', function(done) {
        var buffer;
        buffer = new Buffer({
          size: 1
        });
        buffer.write('test');
        buffer.writeAsync('test2').then(function() {
          buffer.getContent().should.eql(['test2']);
          return done();
        });
        return buffer.read();
      });
      return it('should return a promise', function() {
        var buffer, promise;
        buffer = new Buffer;
        promise = buffer.writeAsync('test');
        return promise.should.be.an.instanceOf(Promise);
      });
    });
    describe('#writeArrayAsync(dataArray)', function() {
      it('should write every item from dataArray to the buffer', function(done) {
        var buffer, promise;
        buffer = new Buffer;
        promise = buffer.writeArrayAsync(['foo', 'bar']);
        return promise.then(function() {
          if (buffer.getContent().should.eql(['foo', 'bar'])) {
            return done();
          }
        });
      });
      return it('should return a promise that fulfills when the last item of the array is written', function(done) {
        var barIsWritten, buffer, fooIsReleased, fooIsWritten, promise;
        buffer = new Buffer({
          size: 1
        });
        fooIsWritten = fooIsReleased = barIsWritten = false;
        buffer.on('write', function(data) {
          if (data === 'foo') {
            fooIsWritten = true;
            buffer.read();
          }
          if (data === 'bar') {
            return barIsWritten = true;
          }
        });
        buffer.on('release', function(data) {
          if (data === 'foo') {
            return fooIsReleased = true;
          }
        });
        promise = buffer.writeArrayAsync(['foo', 'bar']);
        return promise.then(function() {
          if (fooIsWritten && fooIsReleased && barIsWritten) {
            return done();
          }
        });
      });
    });
    describe('#read()', function() {
      it('should return first data item when not empty', function() {
        var buffer;
        buffer = new Buffer;
        buffer.write('test1');
        buffer.write('test2');
        return buffer.read().should.equal('test1');
      });
      return it('should throw error when buffer is empty', function() {
        var buffer;
        buffer = new Buffer;
        return (function() {
          return buffer.read();
        }).should["throw"]('Buffer is empty');
      });
    });
    describe('#readAsync()', function() {
      return it('should return a promise fulfilled when the buffer is readable', function(done) {
        var buffer;
        buffer = new Buffer;
        buffer.write('test');
        return buffer.readAsync().then(function(result) {
          result.should.equal('test');
          return done();
        });
      });
    });
    describe('that is sealed', function() {
      it('should throw error when trying to write it', function() {
        var buffer;
        buffer = new Buffer;
        buffer.write('test');
        buffer.seal();
        return (function() {
          return buffer.write('test2');
        }).should["throw"]('Cannot write sealed buffer');
      });
      it('should emit end event if becomes empty when sealed', function(done) {
        var buffer;
        buffer = new Buffer;
        buffer.write('test');
        buffer.on('end', function() {
          return done();
        });
        buffer.seal();
        return buffer.read();
      });
      return it('should emit end event if sealed when empty', function(done) {
        var buffer;
        buffer = new Buffer;
        buffer.on('end', function() {
          return done();
        });
        return buffer.seal();
      });
    });
    return describe('Buffer.defaultBufferSize', function() {
      it('should set default buffer size for newly created buffers', function() {
        var buffer;
        Buffer.defaultBufferSize(500);
        buffer = new Buffer;
        return buffer.size.should.equal(500);
      });
      return it('should return default buffer size when called without arguments', function() {
        Buffer.defaultBufferSize(1000);
        return Buffer.defaultBufferSize().should.equal(1000);
      });
    });
  });

}).call(this);