Beherrschen Sie die korrekte Verwendung des chai test.catch()-Blocks

Question

Ich versuche eine gute Abdeckung durch End-to-End-Tests meiner Codebasis zu erreichen, daher möchte ich auch den .catch()-Code testen.

Meine API verwendet node.js und mongoose.

Zum Testen verwende ich Chai und Mokka.

Ich habe etwas versucht wie:

Datei src/controllers/user.controller.js:

const User = require("../models/user.model");

const getUser = async(req, res) =>
  versuchen {
    const user = waiting User.findOne({name: req.name});
    return res.status(200).json(user);
  } Catch (Err) {
    //Dies ist der Code, den ich testen möchte
    console.error(`Fehler beim Finden des Benutzers ${req.name}:`, err);
    return res.status(err.code).json({ message: err });
  }
}

Datei src/models/user.model.js:

const mongoose = require("mongoose");

const UserSchema = mongoose.Schema({
  Name: {
    Typ: Zeichenfolge,
    erforderlich: "Name ist erforderlich",
  },
});
module.exports = mongoose.model("Benutzer", UserSchema);

Datei test/user.test.js:

const chai = require("chai");
 const chaiHttp = require("chai-http");
 const spies = require("chai-spies");
 const User = require("../src/models/user.model");
 chai.use(chaiHttp);
 chai.use(Spione);
 chai.should();

 beschreiben("Mongoose-Fehler sollten behandelt werden", function() {
    beschreiben("Problematische User.findOne-Methode", function() {
      const _User_findOne_Backup = User.findOne;
      beforeEach(function() {
        // Diese Funktion sollte die echte findOne-Funktion überladen, aber es war nicht erfolgreich!User.findOne = function() {
          return Promise.reject("Erzwungener Fehler");
        };
      });
      afterEach(function() { //Stellen Sie die echte Funktion nach jedem Test wieder her
        User.findOne = _User_findOne_Backup;
      });

      it("Die Registrierung sollte einen Serverfehler zurückgeben", function() {
        const spy = chai.spy();
        Chai zurückgeben
          .request(server)
          .post("/api/getUser")
          .send({Name: "Alice"})
          .dann(Spion)
          .catch((err) => {
            const res = err.response;
            res.should.have.status(500);
          })
          .then(() => {
            spy.should.not.haven.called();
          })
        ;
      });
    });
  });

Das Problem ist, dass in meinen Tests die gefälschte Methode User.findOne() nie aufgerufen wird: Die ursprüngliche mongoose-Methode findOne Daher löst die Methode getUser nie eine Ausnahme aus, was dazu führt, dass mein Test fehlschlägt...

Vielleicht übersehe ich etwas Offensichtliches, aber ich kann es wirklich nicht finden ... :-(

Wenn Sie mehr Code oder Kontext benötigen, lassen Sie es mich bitte wissen...

Update: Dem Vorschlag von @Bergi folgend, habe ich vollständige Informationen zu meinem (vereinfachten) Modell und den erforderlichen Modulen hinzugefügt...

Answer 1

对我来说很好用。

例如：

user.model.js：

const mongoose = require("mongoose");

const UserSchema = mongoose.Schema({
  name: {
    type: String,
    required: "Name is required",
  },
});
module.exports = mongoose.model("User", UserSchema);

user.controller.js：

const User = require("./user.model");

const getUser = async (req, res) => {
  try {
    const user = await User.findOne({ name: req.body.name });
    return res.status(200).json(user);
  } catch (err) {
    console.error(`Error finding user ${req.body.name}:`, err);
    return res.status(500).json({ message: err });
  }
}

module.exports = {
  getUser
}

server.js：

const express = require('express');
const userController = require('./user.controller');

const app = express();

app.use(express.json())
app.post('/api/getUser', userController.getUser)

module.exports = app;

user.test.js：

const chai = require("chai");
const chaiHttp = require("chai-http");
const User = require("./user.model");
const server = require('./server');
chai.use(chaiHttp);
chai.should();

describe("should handle mongoose errors", function () {
  describe("faulty User.findOne method", function () {
    const _User_findOne_Backup = User.findOne;
    beforeEach(function () {
      User.findOne = function () {
        return Promise.reject("forced error");
      };
    });
    afterEach(function () {
      User.findOne = _User_findOne_Backup;
    });

    it("signup should respond with a server error", function () {
      return chai
        .request(server)
        .post("/api/getUser")
        .send({ name: "Alice" })
        .catch((err) => {
          const res = err.response;
          res.should.have.status(500);
        })
        ;
    });
  });
});

测试结果：

  should handle mongoose errors
    faulty User.findOne method
Error finding user Alice: forced error
      ✓ signup should respond with a server error


  1 passing (21ms)

--------------------|----------|----------|----------|----------|-------------------|
File                |  % Stmts | % Branch |  % Funcs |  % Lines | Uncovered Line #s |
--------------------|----------|----------|----------|----------|-------------------|
All files           |    89.19 |      100 |    88.89 |    88.57 |                   |
 server.js          |      100 |      100 |      100 |      100 |                   |
 user.controller.js |       80 |      100 |      100 |       75 |               6,7 |
 user.model.js      |      100 |      100 |      100 |      100 |                   |
 user.test.js       |    88.89 |      100 |    85.71 |    88.89 |             26,27 |
--------------------|----------|----------|----------|----------|-------------------|

软件包版本：

"chai": "^4.2.0",
"chai-http": "^4.3.0",
"mongodb": "^3.6.3",
"mongoose": "^5.11.9",
"express": "^4.17.1"