Esiste un modulo per simulare facilmente oggetti req/res per l'unità che verifica un gestore di stile di connessione?

Question

Sto scrivendo un'app in node.js che include alcuni gestori di endpoint di tipo connect (funzione (req, resp)) e vorrei scrivere alcuni test di unità contro di essi senza richiedere l'esecuzione dell'app completa.

So che posso "semplicemente" spingere qualsiasi dispositivo in cui scrivo manualmente, ma mi chiedevo se ci fosse qualche libreria là fuori per aiutarmi a generare questi proiettori più velocemente.

MODIFICA: per spiegare ulteriormente cosa voglio, mi piacerebbe nel mio test di unità eseguire solo il mio gestore (non la mia app) e per quello, avrei bisogno di un req falso e res. Questi sono i 2 oggetti che mi piacerebbe prendere in giro.

Attualmente sto usando mocha come test runner e il modulo core assert.

Answer 1

Se è stato definito tuoi percorsi in un modo in cui si passa app a una funzione, allora si potrebbe usare supertest per testare un percorso.

prova

var app = require('./real-or-fixture-app'); //depends on your setup 

require('routeToTest')(app); 

var request = require("supertest"); 

describe("Test", function(){ 
    it("should test a route", function(done){ 
     request(app) 
      .post("/route") 
      .send({data:1}) 
      .expect(200, done); 
    }); 
}); 

definizione della rotta

module.exports = function(app){ 
    app.get("/route", .... 
}; 

Non sono del tutto sicuro che questo è davvero quello che stai cercando, ma è un modo per testare i percorsi separatamente .

Answer 2

So che questa domanda è vecchio, ma un ottimo modo per fare questo ora è con Supertest https://github.com/visionmedia/supertest

Se avete mai usato la libreria di test client Django, funziona un po 'come quella. Simula l'esecuzione di visualizzazioni/percorsi in modo da ottenere uno scenario di test più simile a un vero browser che sta colpendo la vista. Ciò significa che req e res vengono presi in giro ma che si comportano in modo atteso. È molto più veloce del selenio (o, ad esempio, del goniometro, che usa Webdriver sotto le coperte).

Come probabilmente sapete, è una buona idea spostare la maggior parte della logica fuori dalle rotte in modo che possa essere testata separatamente. Non considero davvero l'uso di Supertest come test unitario, dal momento che testate invariabilmente più di una singola unità di codice.

Answer 3

Potrebbe essere interessato a un piccolo pacchetto che ho messo insieme che rende la creazione di una richiesta/risposta di simulazione un po 'più semplice con Sinon.

In sostanza crea solo un oggetto che simula lo standard req/res da espresso e sostituisce il metodo con spys che è possibile esaminare.

Dal README:

Il test:

import route from '../src/foo' 
import { mockReq, mockRes } from 'sinon-express-mock' 

describe('my route',() => { 
    it('should foo the bar',() => { 

    const body = { 
     body: { 
     foo: 'bar', 
     }, 
    } 
    const req = mockReq(body) 
    const res = mockRes() 

    route(req, res) 

    expect(res.json).to.be.calledWith({ foo: body.foo.bar }) 
    }) 
}) 

Contenuto del src/foo.js:

export default (req, res) => { 
    res.json({ foo: req.body.bar }) 
} 

https://github.com/danawoodman/sinon-express-mock