Test delle unità in node.js e moduli di simulazione

Se il tuo modulo ha un costruttore che accetta l'app e richiede come argomenti del costruttore (in altre parole l'integrazione delle dipendenze), puoi semplicemente fornire un'implementazione di richiesta stoppia / derisa nel test.
In caso contrario: so che è possibile ignorare nei test ciò che RequireJS restituisce quando si richiede qualcosa, quindi suppongo che lo stesso sarebbe possibile in node.js. Pertanto, se è possibile modificare la configurazione del caricatore di moduli in un test, è possibile configurarlo per restituire un'implementazione di richiesta con stucco / derisione.
Personalmente, farei il percorso di iniezione delle dipendenze. Dover configurare il modulo loader nei test è un fastidio sul retro ...

L'ho fatto di recente. Hai dimenticato dove ho letto ma è piuttosto facile.

Ecco le basi del mio codice.

var express = require('express');
var http    = require('http');

var MyServer = function(options) {
  var app = express();
  app.get(/^\/foo.html/, sendFoo);
  app.get(/^\/bar.html/, sendBar);
  var server = options.server || http.createServer(app);
  server.listen(options.port);

  function sendFoo(req, res) {
     res.writeHead(200);
     res.write("foo");
     res.end();
  }

  function sendBar(req, res) {
     res.writeHead(200);
     res.write("bar");
     res.end();
  }

  this.close = function() {
     server.close();
  }
};

Come puoi vedere sul mio server sia http.createServer che quello che ho passato. Forse dovrei sempre passarlo? Ma in ogni caso. Ho creato un server fittizio

var events = require('events');

var MockHTTPServer = function() {
  var eventEmitter = new events.EventEmitter();
  var self = this;

  this.once = eventEmitter.once.bind(eventEmitter);

  this.listen = function() {
    eventEmitter.emit('listening', self, 0);
  };

  this.close = function() {
  };
};

E a MockResponse

var MockResponse = function(callback) {
  this.headers = {};
  this.statusCode = -1;
  this.body = undefined;

  this.setHeader = function(key, value) {
    this.headers[key] = value;
  }.bind(this);

  this.writeHead = function(statusCode, headers) {
    this.statusCode = statusCode;
    Object.keys(headers).forEach(function(key) {
      this.headers[key] = headers[key];
    }.bind(this));
  }.bind(this);

  this.write = function(data, encoding) {
    this.body = data.toString(encoding);
  }.bind(this);

  this.end = function() {
    var fn = callback;
    callback = undefined;
    fn(this);
  }.bind(this);
};

Nota che questa non è una risposta completa. L'ho appena provato nei miei test e ho aggiunto solo le funzioni che sono state chiamate.

Per testare effettivamente ho creato un server di test

var Promise = require('promise');

var TestServer = function(callback) {
  var server = new MyServer({
    server: new MockHTTPServer,
  }, callback);

  this.close = function() {
    server.close();
  };

  var request = function(req, callback) {
    var res = new MockResponse(callback);
    server.handleRequest(req, res);
  };

  var getP = function(url) {
    return new Promise(function(resolve, reject) {
      request({ url: url, method: 'GET'}, resolve);
    });
  };

  this.getP = getP;
  this.request = request;
};

Che, usando la moka, posso testare così

describe('test server', function() {

  var server;

  before(function(done) {
    server = new TestServer(done);
  });

  describe('test', function() {
    it('serves bar', function(done) {
      server.getP("http://localhost/bar.html").then(function(res) {
        res.body.should.containEql("bar");
      }).then(done, done);
    });

    it('serves foo', function(done) {
      server.getP("http://localhost/foo.html").then(function(res) {
        res.body.should.containEql("foo");
      }).then(done, done);
    });
  });

  after(function(done) {
    server.close();
    done();
  });

});

Puoi vedere che ho appena creato gli oggetti richiesta al volo