Wie testet man Routen mit Express?

Ich bin gerade dabei, Node.js zu lernen und habe mit Express herumgespielt . Ich mag das Framework wirklich, aber ich habe Probleme herauszufinden, wie man einen Einheits- / Integrationstest für eine Route schreibt.

Es ist einfach, einfache Module zu testen, und das mit Mocha . Meine Komponententests mit Express schlagen jedoch fehl, da das von mir übergebene Antwortobjekt die Werte nicht beibehält.

Zu testende Routenfunktion (route / index.js):

exports.index = function(req, res){
  res.render('index', { title: 'Express' })
};

Unit Test Modul:

var should = require("should")
    , routes = require("../routes");

var request = {};
var response = {
    viewName: ""
    , data : {}
    , render: function(view, viewData) {
        viewName = view;
        data = viewData;
    }
};

describe("Routing", function(){
    describe("Default Route", function(){
        it("should provide the a title and the index view name", function(){
        routes.index(request, response);
        response.viewName.should.equal("index");
        });

    });
});

Wenn ich dies ausführe, schlägt es fehl für "Fehler: Globale Lecks erkannt: Ansichtsname, Daten".

1. Wo mache ich etwas falsch, damit das funktioniert?

2. Gibt es eine bessere Möglichkeit für mich, meinen Code auf dieser Ebene zu testen?

Update 1. Code-Snippet korrigiert, da ich "it ()" ursprünglich vergessen habe.

Ändern Sie Ihr Antwortobjekt:

var response = {
    viewName: ""
    , data : {}
    , render: function(view, viewData) {
        this.viewName = view;
        this.data = viewData;
    }
};

Und es wird funktionieren.

Wie andere in Kommentaren empfohlen haben, sieht es so aus, als ob der kanonische Weg zum Testen von Express-Controllern der Supertest ist .

Ein Beispieltest könnte folgendermaßen aussehen:

describe('GET /users', function(){
  it('respond with json', function(done){
    request(app)
      .get('/users')
      .set('Accept', 'application/json')
      .expect(200)
      .end(function(err, res){
        if (err) return done(err);
        done()
      });
  })
});

Vorteil: Sie können Ihren gesamten Stack auf einmal testen.

Nachteil: Es fühlt sich an und verhält sich ein bisschen wie Integrationstests.

Ich bin zu dem Schluss gekommen, dass der einzige Weg, um Express-Anwendungen wirklich zu testen, darin besteht, eine große Trennung zwischen den Anforderungshandlern und Ihrer Kernlogik aufrechtzuerhalten.

Daher sollte sich Ihre Anwendungslogik in separaten Modulen befinden, die requiregetestet und einheitlich getestet werden können, und eine minimale Abhängigkeit von den Express-Anforderungs- und Antwortklassen als solchen aufweisen.

Dann müssen Sie in den Anforderungshandlern die entsprechenden Methoden Ihrer Kernlogikklassen aufrufen.

Ich werde ein Beispiel aufstellen, sobald ich meine aktuelle App umstrukturiert habe!

Ich denke so etwas ? (Fühlen Sie sich frei, das Wesentliche oder den Kommentar zu teilen, ich untersuche dies immer noch).

Bearbeiten

Hier ist ein kleines Beispiel, Inline. Ein detaillierteres Beispiel finden Sie in der Übersicht .

/// usercontroller.js
var UserController = {
   _database: null,
   setDatabase: function(db) { this._database = db; },

   findUserByEmail: function(email, callback) {
       this._database.collection('usercollection').findOne({ email: email }, callback);
   }
};

module.exports = UserController;

/// routes.js

/* GET user by email */
router.get('/:email', function(req, res) {
    var UserController = require('./usercontroller');
    UserController.setDB(databaseHandleFromSomewhere);
    UserController.findUserByEmail(req.params.email, function(err, result) {
        if (err) throw err;
        res.json(result);
    });
});

Der einfachste Weg, HTTP mit Express zu testen, besteht darin, den http-Helfer von TJ zu stehlen

Ich persönlich benutze seinen Helfer

it("should do something", function (done) {
    request(app())
    .get('/session/new')
    .expect('GET', done)
})

Wenn Sie Ihr Routenobjekt speziell testen möchten, übergeben Sie die richtigen Mocks

describe("Default Route", function(){
    it("should provide the a title and the index view name", function(done){
        routes.index({}, {
            render: function (viewName) {
                viewName.should.equal("index")
                done()
            }
        })
    })
})

Wenn Unit-Tests mit Express 4 durchgeführt werden, beachten Sie dieses Beispiel von Gjohnson :

var express = require('express');
var request = require('supertest');
var app = express();
var router = express.Router();
router.get('/user', function(req, res){
  res.send(200, { name: 'tobi' });
});
app.use(router);
request(app)
  .get('/user')
  .expect('Content-Type', /json/)
  .expect('Content-Length', '15')
  .expect(200)
  .end(function(err, res){
    if (err) throw err;
  });

Ich habe mich auch gefragt, aber speziell für Unit-Tests und nicht für Integrationstests. Das mache ich gerade,

test('/api base path', function onTest(t) {
  t.plan(1);

  var path = routerObj.path;

  t.equals(path, '/api');
});


test('Subrouters loaded', function onTest(t) {
  t.plan(1);

  var router = routerObj.router;

  t.equals(router.stack.length, 5);
});

Wo der RouterObj gerade ist {router: expressRouter, path: '/api'}. Ich lade dann Subrouter mit ein var loginRouterInfo = require('./login')(express.Router({mergeParams: true}));und dann ruft die Express-App eine Init-Funktion auf, die den Express-Router als Parameter verwendet. Der initRouter ruft dann router.use(loginRouterInfo.path, loginRouterInfo.router);auf, um den Subrouter zu mounten.

Der Subrouter kann getestet werden mit:

var test = require('tape');
var routerInit = require('../login');
var express = require('express');
var routerObj = routerInit(express.Router());

test('/login base path', function onTest(t) {
  t.plan(1);

  var path = routerObj.path;

  t.equals(path, '/login');
});


test('GET /', function onTest(t) {
  t.plan(2);

  var route = routerObj.router.stack[0].route;

  var routeGetMethod = route.methods.get;
  t.equals(routeGetMethod, true);

  var routePath = route.path;
  t.equals(routePath, '/');
});

Um Unit-Tests anstelle von Integrationstests zu erreichen, habe ich das Antwortobjekt des Request-Handlers verspottet.

/* app.js */
import endpointHandler from './endpointHandler';
// ...
app.post('/endpoint', endpointHandler);
// ...

/* endpointHandler.js */
const endpointHandler = (req, res) => {
  try {
    const { username, location } = req.body;

    if (!(username && location)) {
      throw ({ status: 400, message: 'Missing parameters' });
    }

    res.status(200).json({
      location,
      user,
      message: 'Thanks for sharing your location with me.',
    });
  } catch (error) {
    console.error(error);
    res.status(error.status).send(error.message);
  }
};

export default endpointHandler;

/* response.mock.js */
import { EventEmitter } from 'events';

class Response extends EventEmitter {
  private resStatus;

  json(response, status) {
    this.send(response, status);
  }

  send(response, status) {
    this.emit('response', {
      response,
      status: this.resStatus || status,
    });
  }

  status(status) {
    this.resStatus = status;
    return this;
  }
}

export default Response;

/* endpointHandler.test.js */
import Response from './response.mock';
import endpointHandler from './endpointHander';

describe('endpoint handler test suite', () => {
  it('should fail on empty body', (done) => {
    const res = new Response();

    res.on('response', (response) => {
      expect(response.status).toBe(400);
      done();
    });

    endpointHandler({ body: {} }, res);
  });
});

Um dann Integrationstests durchzuführen, können Sie Ihren EndpointHandler verspotten und den Endpunkt mit Supertest aufrufen .

In meinem Fall wollte ich nur testen, ob der richtige Handler aufgerufen wurde. Ich wollte den Supertest verwenden, um die Einfachheit der Anforderungen an die Routing-Middleware zu verdeutlichen. Ich verwende Typescript a und dies ist die Lösung, die für mich funktioniert hat

// ProductController.ts

import { Request, Response } from "express";

class ProductController {
  getAll(req: Request, res: Response): void {
    console.log("this has not been implemented yet");
  }
}
export default ProductController

Die Routen

// routes.ts
import ProductController  from "./ProductController"

const app = express();
const productController = new ProductController();
app.get("/product", productController.getAll);

Die Tests

// routes.test.ts

import request from "supertest";
import { Request, Response } from "express";

const mockGetAll = jest
  .fn()
  .mockImplementation((req: Request, res: Response) => {
    res.send({ value: "Hello visitor from the future" });
  });

jest.doMock("./ProductController", () => {
  return jest.fn().mockImplementation(() => {
    return {
      getAll: mockGetAll,

    };
  });
});

import app from "./routes";

describe("Routes", () => {
  beforeEach(() => {
    mockGetAll.mockImplementation((req: Request, res: Response) => {
      res.send({ value: "You can also change the implementation" });
    });
  });

  it("GET /product integration test", async () => {
    const result = await request(app).get("/product");

    expect(mockGetAll).toHaveBeenCalledTimes(1);

  });



  it("GET an undefined route should return status 404", async () => {
    const response = await request(app).get("/random");
    expect(response.status).toBe(404);
  });
});

Ich hatte einige Probleme, um die Verspottung zum Laufen zu bringen. Aber mit jest.doMock und der spezifischen Reihenfolge, die Sie im Beispiel sehen, funktioniert es.