node.js - framework - node test before

TDD/prueba con transmisiones en NodeJS

Question

He estado tratando de encontrar una forma razonable de probar el código que usa transmisiones. ¿Alguien ha encontrado una forma / marco razonable para ayudar a probar el código que usa flujos en nodejs?

Por ejemplo:

var fs = require(''fs''),
    request = require(''request'');

module.exports = function (url, path, callback) {
  request(url)
    .pipe(fs.createWriteStream(path))
    .on(''finish'', function () {
      callback();
    });
};

Mi forma actual de probar este tipo de código implica tanto simplificar el código con transmisiones que puedo resumirlo en un fragmento de código no probado o escribiendo algo como esto:

var rewire = require(''rewire''),
    download = rewire(''../lib/download''),
    stream = require(''stream''),
    util = require(''util'');

describe(''download'', function () {
  it(''should download a url'', function (done) {
    var fakeRequest, fakeFs, FakeStream;

    FakeStream = function () {
      stream.Writable.call(this);
    };

    util.inherits(FakeStream, stream.Writable);

    FakeStream.prototype._write = function (data, encoding, cb) {
      expect(data.toString()).toEqual("hello world")
      cb();
    };

    fakeRequest = function (url) {
      var output = new stream.Readable();

      output.push("hello world");
      output.push(null);

      expect(url).toEqual(''http://hello'');

      return output;
    };

    fakeFs = {
      createWriteStream: function (path) {
        expect(path).toEqual(''hello.txt'');
        return new FakeStream();
      }
    };

    download.__set__(''fs'', fakeFs);
    download.__set__(''request'', fakeRequest);

    download(''http://hello'', ''hello.txt'', function () {
      done();
    });

  });
});

¿Alguien ha encontrado formas más elegantes de probar transmisiones?

Answer 1

Hecho streamtest para ese propósito. No solo hace que las pruebas de flujo sean más limpias, sino que también permite probar flujos de V1 y V2 https://www.npmjs.com/package/streamtest

Answer 2

La mejor forma que he encontrado es usar eventos

const byline = require(''byline'');
const fs = require(''fs'');

it(''should process all lines in file'', function(done){
   //arrange
   let lines = 0;
   //file with 1000 lines
   let reader = fs.readFileStream(''./input.txt'');
   let writer = fs.writeFileStream(''./output.txt'');
   //act
   reader.pipe(byline).pipe(writer);
   byline.on(''line'', function() {
     lines++;
   });
   //assert
   writer.on(''close'', function() {
     expect(lines).to.equal(1000);
     done();
   });
});

al pasar hecho como una devolución de llamada, mocha espera hasta que se llame antes de continuar.

Answer 3

Lee el flujo en la memoria y compáralo con el búfer esperado.

it(''should output a valid Stream'', (done) => {
  const stream = getStreamToTest();
  const expectedBuffer = Buffer.from(...);
  let bytes = new Buffer('''');

  stream.on(''data'', (chunk) => {
    bytes = Buffer.concat([bytes, chunk]);
  });

  stream.on(''end'', () => {
    try {
      expect(bytes).to.deep.equal(expectedBuffer);
      done();
    } catch (err) {
      done(err);
    }
  });
});

Answer 4

No he usado esto, y es bastante viejo, pero https://github.com/dominictarr/stream-spec podría ayudar.

Answer 5

Puede probar secuencias utilizando MemoryStream y sinon mediante el uso de espías. Así es como probé algunos de mis códigos.

describe(''some spec'', function() {
    it(''some test'', function(done) {
        var outputStream = new MemoryStream();

        var spyCB = sinon.spy();

        outputStream.on(''data'', spyCB);

        doSomething(param, param2, outputStream, function() {
            sinon.assert.calledWith(spyCB, ''blah'');

            done();
        });
    });
});

Answer 6

También he estado usando memorystream , pero luego he puesto mis aserciones en el evento finish . De esta forma, se parece más a un uso real de la secuencia que se prueba:

require(''chai'').should();

var fs = require(''fs'');
var path = require(''path'');

var MemoryStream = require(''memorystream'');
var memStream = MemoryStream.createWriteStream();

/**
 * This is the Transform that we want to test:
 */

var Parser = require(''../lib/parser'');
var parser = new Parser();

describe(''Parser'', function(){
  it(''something'', function(done){
    fs.createReadStream(path.join(__dirname, ''something.txt''))
      .pipe(parser)
      .pipe(memStream)
      .on(''finish'', function() {

        /**
         * Check that our parser has created the right output:
         */

        memStream
          .toString()
          .should.eql(''something'');
        done();
      });
  });
});

La comprobación de los objetos se puede hacer así:

var memStream = MemoryStream.createWriteStream(null, {objectMode: true});
.
.
.
      .on(''finish'', function() {
        memStream
          .queue[0]
          .should.eql({ some: ''thing'' });
        done();
      });
.
.
.

Answer 7

Te siento dolor

No conozco ningún marco para ayudarme con las pruebas con transmisiones, pero si echas un vistazo here , donde estoy desarrollando una biblioteca de transmisión, puedes ver cómo abordo este problema.

Aquí hay una idea de lo que estoy haciendo.

var chai = require("chai")
, sinon = require("sinon")
, chai.use(require("sinon-chai"))
, expect = chai.expect
, through2 = require(''through2'')
;

chai.config.showDiff = false

function spy (stream) {
  var agent, fn
  ;
  if (spy.free.length === 0) {
    agent = sinon.spy();
  } else {
    agent = spy.free.pop();
    agent.reset();
  }
  spy.used.push(agent);
  fn = stream._transform;
  stream.spy = agent;
  stream._transform =  function(c) {
    agent(c);
    return fn.apply(this, arguments);
  };
  stream._transform = transform;
  return agent;
};

spy.free = [];
spy.used = [];


describe(''basic through2 stream'', function(){

  beforeEach(function(){
    this.streamA = through2()
    this.StreamB = through2.obj()
    // other kind of streams...

    spy(this.streamA)
    spy(this.StreamB)

  })

  afterEach(function(){
    spy.used.map(function(agent){
      spy.free.push(spy.used.pop())
    })
  })

  it("must call transform with the data", function(){
    var ctx = this
    , dataA = new Buffer(''some data'')
    , dataB = ''some data''
    ;

    this.streamA.pipe(through2(function(chunk, enc, next){
      expect(ctx.streamA.spy).to.have.been.calledOnce.and.calledWidth(dataA)
    }))

    this.streamB.pipe(through2(function(chunk, enc, next){
      expect(ctx.streamB.spy).to.have.been.calledOnce.and.calledWidth(dataB)
    }))

    this.streamA.write(dataA)
    this.streamB.write(dataB)

  })

})

Tenga en cuenta que mi función de espía ajusta el método _transform y llama a mi espía y llama a la _transform original

Además, la función afterEach es reciclar los espías, porque puedes terminar creando cientos de ellos.

El problema se pone difícil cuando quieres probar el código asíncrono. Entonces promete a tu mejor amigo. El enlace que di más arriba tiene algo de muestra.