TDD/ Tests mit streams in NodeJS

Ich habe versucht zu finden, eine vernünftige Weg, um test-code, der verwendet streams. Hat jemand gefunden, einen vernünftigen Weg/Rahmen für die Unterstützung der Prüf-code, der verwendet streams in nodejs?

Beispiel:

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

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

Meine aktuelle Art und Weise der Prüfung dieser Art von code, der entweder die Vereinfachung der code mit streams so viel, dass ich Abstrakt und es sich um ein nicht getesteter code oder durch das schreiben etwas wie dieses:

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

  });
});

Hat jemand weitere elegante Art des streams testen?

InformationsquelleAutor Michael Wasser | 2014-04-17

11

Gemacht streamtest für diesen Zweck. Es machen nicht nur streams tests Reiniger, aber auch erlaubt zu testen, V1-und V2-streams https://www.npmjs.com/package/streamtest
- Danke für die lib. Es war genau das, was ich brauchte und es funktioniert Super.
InformationsquelleAutor nfroidure

Hab ich auch schon mit memorystream, dann aber, dass meine Behauptungen in die finish Veranstaltung. So sieht es eher aus wie eine Reale Nutzung der stream getestet:

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

Prüfen von Objekten werden wie folgt vorgenommen:

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

InformationsquelleAutor Mark Birbeck

Fühle ich mich Ihr Schmerz.

Ich kenne keinen Rahmen, um zu helfen, die Tests mit streams, aber wenn nehmen Sie einen Blick hier,
wo entwickle ich einen stream-Bibliothek können Sie sehen, wie ich an dieses problem.

hier ist eine Idee von dem, was ich Tue.

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)

  })

})

Hinweis, dass mein Spion-Funktion umschließt die _transform - Methode, und rufen Sie meine spy und rufen Sie die original - _transform

Auch, Die afterEach Funktion ist die wiederverwertung der Spione, weil Sie am Ende Hunderte von Ihnen.

Das problem wird hart, wenn Sie möchten, um zu testen, async-code. Dann verspricht Ihre beste Freundin. Der link, den ich oben gab, haben einige Beispiel, die.

InformationsquelleAutor markuz-gj

Lesen Sie den Stream in den Speicher, und vergleichen Sie Sie mit den erwarteten Puffer.

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);
    }
  });
});

InformationsquelleAutor Westy92

2

Habe ich nicht verwendet, und es ist schon ziemlich alt, aber https://github.com/dominictarr/stream-spec helfen könnte.

InformationsquelleAutor Martin Cleaver

Können Sie test-streams mit MemoryStream und sinon durch die Verwendung von Spionen. Hier ist, wie ich getestet habe einige meiner code.

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

InformationsquelleAutor nacholibre

Beste Weg, die ich gefunden habe, ist die Verwendung von Veranstaltungen

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

durch die übergabe erfolgt als callback, Mokka wartet, bis er aufgerufen wird, bevor Sie fortfahren.

InformationsquelleAutor dmo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.