node.js - test - pruebas unitarias node js

¿Cómo pruebo mi aplicación express con mocha?

Question

Acabo de agregar shouldjs y mocha a mi aplicación express para realizar pruebas, pero me pregunto cómo probar mi aplicación. Me gustaría hacerlo así:

app = require ''../app''
routes = require ''../src/routes''
describe ''routes'', ->
describe ''#show_create_user_screen'', ->
it ''should be a function'', ->
routes.show_create_user_screen.should.be.a.function
it ''should return something cool'', ->
routes.show_create_user_screen().should.be.an.object

Por supuesto, la última prueba en ese banco de pruebas simplemente le dice a med que la función res.render (llamada dentro de show_create_user_screen) no está definida, probablemente porque el servidor no se está ejecutando y la configuración no se ha realizado. Entonces me pregunto cómo otras personas preparan sus pruebas.

Answer 1

Descubrí que es más fácil configurar una clase TestServer para usarla como ayudante, así como un cliente HTTP auxiliar, y simplemente hacer solicitudes reales a un servidor http real. Sin embargo, puede haber casos en los que quieras burlar y colgar estas cosas.

// Test file
var http = require(''the/below/code'');
describe(''my_controller'', function() {
var server;
before(function() {
var router = require(''path/to/some/router'');
server = http.server.create(router);
server.start();
});
after(function() {
server.stop();
});
describe("GET /foo", function() {
it(''returns something'', function(done) {
http.client.get(''/foo'', function(err, res) {
// assertions
done();
});
});
});
});
// Test helper file
var express = require(''express'');
var http = require(''http'');
// These could be args passed into TestServer, or settings from somewhere.
var TEST_HOST = ''localhost'';
var TEST_PORT = 9876;
function TestServer(args) {
var self = this;
var express = require(''express'');
self.router = args.router;
self.server = express.createServer();
self.server.use(express.bodyParser());
self.server.use(self.router);
}
TestServer.prototype.start = function() {
var self = this;
if (self.server) {
self.server.listen(TEST_PORT, TEST_HOST);
} else {
throw new Error(''Server not found'');
}
};
TestServer.prototype.stop = function() {
var self = this;
self.server.close();
};
// you would likely want this in another file, and include similar
// functions for post, put, delete, etc.
function http_get(host, port, url, cb) {
var options = {
host: host,
port: port,
path: url,
method: ''GET''
};
var ret = false;
var req = http.request(options, function(res) {
var buffer = '''';
res.on(''data'', function(data) {
buffer += data;
});
res.on(''end'',function(){
cb(null,buffer);
});
});
req.end();
req.on(''error'', function(e) {
if (!ret) {
cb(e, null);
}
});
}
var client = {
get: function(url, cb) {
http_get(TEST_HOST, TEST_PORT, url, cb);
}
};
var http = {
server: {
create: function(router) {
return new TestServer({router: router});
}
},
client: client
};
module.exports = http;

Answer 2

OK, primero aunque probar tu código de enrutamiento es algo que puedes o no quieres hacer, en general, trata de separar tu lógica comercial interesante en un código javascript puro (clases o funciones) que están desacopladas del marco expreso o cualquiera que estés usando y usa pruebas de mocha de vainilla para probar eso. Una vez que haya logrado eso, si realmente quiere probar las rutas que configura en mocha, necesita pasar parámetros de req, res falsa req, res en sus funciones de middleware para imitar la interfaz entre express / connect y su middleware.

Para un caso simple, puede crear un objeto de res simulado con una función de render que se parece a esto.

describe ''routes'', ->
describe ''#show_create_user_screen'', ->
it ''should be a function'', ->
routes.show_create_user_screen.should.be.a.function
it ''should return something cool'', ->
mockReq = null
mockRes =
render: (viewName) ->
viewName.should.exist
viewName.should.match /createuser/
routes.show_create_user_screen(mockReq, mockRes).should.be.an.object

Además, solo las funciones de FYI middleware no necesitan devolver ningún valor en particular, es lo que hacen con los parámetros de req, res, next que debe concentrarse durante las pruebas.

Aquí hay algunos JavaScript como solicitó en los comentarios.

describe(''routes'', function() {
describe(''#show_create_user_screen'', function() {
it(''should be a function'', function() {
routes.show_create_user_screen.should.be.a["function"];
});
it(''should return something cool'', function() {
var mockReq = null;
var mockRes = {
render: function(viewName) {
viewName.should.exist;
viewName.should.match(/createuser/);
}
};
routes.show_create_user_screen(mockReq, mockRes);
});
});
});

Answer 3

Puede probar SuperTest y luego se encargarán de la puesta en marcha y el apagado del servidor:

var request = require(''supertest'')
, app = require(''./anExpressServer'').app
, assert = require("assert");
describe(''POST /'', function(){
it(''should fail bad img_uri'', function(done){
request(app)
.post(''/'')
.send({
''img_uri'' : ''foobar''
})
.expect(500)
.end(function(err, res){
done();
})
})
});

Answer 4

encontró una alternativa en las suites de pruebas connect.js

Están usando supertest para probar una aplicación de conexión sin vincular el servidor a ningún puerto y sin usar maquetas.

Aquí hay un fragmento del conjunto de pruebas de middleware estático de connect (usando mocha como el corredor de prueba y supertest para aserciones)

var connect = require(''connect'');
var app = connect();
app.use(connect.static(staticDirPath));
describe(''connect.static()'', function(){
it(''should serve static files'', function(done){
app.request()
.get(''/todo.txt'')
.expect(''contents'', done);
})
});

Esto también funciona para aplicaciones express

Answer 5

mocha viene con before, beforeEach, after y afterEach para pruebas bdd. En este caso, debe usar antes en su llamada de descripción.

describe ''routes'' ->
before (done) ->
app.listen(3000)
app.on(''connection'', done)