node.js - pruebas - nodejs mocha chai test

Configuración/desmontaje de la aplicación express.js con mocha

Question

Estoy tratando de crear una suite de prueba independiente usando mocha, que en un mundo perfecto podría iniciar mi aplicación express.js, usar zombie para renderizar una página, revisar un montón de cosas y luego eliminar / matar la aplicación express.js.

¿Hay una manera fácil / mejor de hacer esto?

NÓTESE BIEN. Podría tener el servidor de aplicaciones Express en ejecución antes de ejecutar las pruebas, pero ¿de qué sirven los Yaks si no los va a afeitar?

Answer 1

Además de la respuesta de Oved D.

Describe tu aplicación en express-app.js o algún otro archivo:

module.exports = function (o) {
  o = o || {};
  var app = express();

  // app.configure
  // configure routes
  if (o.someOption) {
    // some additional test code
  }

  return app;
}

Describe pruebas en test / 01-some.js:

var expressApp = require(''../express-app'');
describe(''some'', function () {

  // just describe needed vars
  var app, server, port;

  // describe setup
  before(function (next) {
    // create app when 
    app = expressApp({routes: /api//some//.*/ /* put here some test options ...*/});
    // creating listener with random port
    server = app.listen(function () {
      // store port when it ready
      port = server.address().port;
      // and go to tests
      next();
    });
  });

  // tests
  it(''should return valid result'', function (done) {
    // do a simple request to /api/some
    http.request({
      host: ''localhost'',
      port: port,
      path: ''/api/some''
    }, function (res) {
      if (res.err) throw new Error(res.err);
      done();
    });
  });

  // teardown
  after(function () {
    // stop listening that port
    server.close();
  });

});

Hecho. ;-)

Ahora puedes crear cualquier cuenta de pruebas como esa. Recomiéndale que habilite solo las URL y los servicios necesarios en las pruebas, definiéndolos pasando los parámetros al módulo express-app.js.

Actualizar:

No estoy seguro de cómo funciona en mocha pero es mejor moverse before y after llamadas a init.js y cargarlo con mocha --require init.js

El archivo debería ser así:

// use it in your mocha tests
global.setupEnv = function setupEnv (o, before, after) {

    // just describe needed vars
    var env = Object.create(null);

    // setup
    before(function (next) {
        // create app
        env.app = expressApp(o);
        // creating listener with random port
        env.server = env.app.listen(function () {
            // store port when it ready
            port = env.server.address().port;
            env.app.log(''Listening on '', env.port);
            // and go to tests
            next();
        });
    });

    // teardown
    after(function () {
        // stop listening that port
        env.server.close();
    });

    return env;
}

Y en tus pruebas:

// requiring dependencies
var request = require(''request'');

describe(''api'', function () {

    // describe setup
    var env = global.setupEnv({
            routes: ''api/some''
        }, before, after);

    // tests
    it(''should pass'', function (done) {
        request(''http://localhost:'' + env.port, function (error, response, body) {
            done();
        });
    });

});

Answer 2

Primero, debe mover la configuración real de la aplicación a un módulo e importarla al archivo que realmente inicia su aplicación. Ahora que está separado, puede tener la aplicación en su estado completo antes de escucharla.

Debería mover la configuración real de su aplicación a un archivo separado, llamémosla app.js, podemos llamar a escuchar desde el archivo que ejecuta el nodo, llamémosle index.js.

Entonces, app.js se vería como:

    var express = require(''express'')
  , routes = require(''./routes'');

var app = module.exports = express.createServer();

// Configuration

app.configure(function(){
  app.set(''views'', __dirname + ''/views'');
  app.set(''view engine'', ''jade'');
  app.use(express.bodyParser());
  app.use(express.methodOverride());
  app.use(app.router);
  app.use(express.static(__dirname + ''/public''));
});

app.configure(''development'', function(){
  app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});

app.configure(''production'', function(){
  app.use(express.errorHandler());
});

// Routes

app.get(''/'', routes.index);

e index.js se vería como:

var app = require(''./app'');

app.listen(3000, function(){
  console.log("Express server listening on port %d in %s mode", app.address().port, app.settings.env);
});

Esto separa la carga de su aplicación para que no la escuche, lo que le permite cargar esa aplicación en sus pruebas unitarias.

En sus pruebas de unidad, haría algo con un método de configuración y un método de desmontaje para activar y desactivar el servidor.

En el archivo test / app_tests.js:

describe(''app'', function(){
  var app = require(''../app'');
  beforeEach(function(){
    app.listen(3000);
  });
  // tests here
  afterEach(function(){
    app.close();
  })
});