Maîtriser l'utilisation correcte du bloc chai test.catch()

Question

J'essaie d'obtenir une bonne couverture avec des tests de bout en bout de ma base de code, je souhaite donc également tester le code .catch()

Mon API utilise node.js et mangouste.

J'utilise du chai et du moka pour les tests.

J'ai essayé quelque chose comme :

Fichier src/controllers/user.controller.js :

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

const getUser = async(req, res) =>
  essayer {
    const user = wait User.findOne({name: req.name});
    return res.status(200).json(utilisateur);
  } attraper (erreur) {
    //C'est le code que je veux tester
    console.error(`Erreur lors de la recherche de l'utilisateur ${req.name}:`, err);
    return res.status(err.code).json({ message : err });
  }
}</pré>
<p><em>Fichier src/models/user.model.js :</em></p>
<pre class="brush:php;toolbar:false;">const mangouste = require("mangouste");

const UserSchema = mangouste.Schema({
  nom: {
    tapez : chaîne,
    requis : "Le nom est requis",
  },
});
module.exports = mongoose.model("Utilisateur", UserSchema);

Fichier test/user.test.js :

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

 décrire("les erreurs de mangouste doivent être gérées", function() {
    décrire("Méthode problématique User.findOne", fonction() {
      const _User_findOne_Backup = User.findOne;
      avantEach(fonction() {
        // Cette fonction aurait dû surcharger la vraie fonction findOne, mais elle n'a pas réussi !Utilisateur.findOne = fonction() {
          return Promise.reject("Erreur forcée");
        } ;
      });
      afterEach(function() { //Restaurer la vraie fonction après chaque test
        User.findOne = _User_findOne_Backup ;
      });

      it("L'inscription devrait renvoyer une erreur de serveur", function() {
        const espion = chai.spy();
        retour chai
          .request(serveur)
          .post("/api/getUser")
          .send({nom : "Alice"})
          .puis (espion)
          .catch((erreur) => {
            const res = err.response;
            res.devrait.avoir.le statut(500);
          })
          .then(() => {
            spy.ne.aurait.pas.été.appelé();
          })
        ;
      });
    });
  });
Le problème est que dans mes tests, la fausse méthode User.findOne() n'est jamais appelée : la méthode originale mangouste findOne donc la méthode getUser ne lève jamais d'exception, ce qui entraîne l'échec de mon test...
Peut-être qu'il me manque quelque chose d'évident, mais je ne parviens vraiment pas à le trouver... :-(

Si vous avez besoin de plus de code ou de contexte, faites-le moi savoir...
Mise à jour : 
Suite à la suggestion de @Bergi, j'ai ajouté des informations complètes sur mon modèle (simplifié) et les modules requis...

Answer 1

Fonctionne très bien pour moi.

Par exemple :

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);
        })
        ;
    });
  });
});

Résultats des tests :

  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 |
--------------------|----------|----------|----------|----------|-------------------|

Version du package :

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