Kuasai penggunaan blok chai test.catch() yang betul

Question

Saya cuba mencapai liputan yang baik dengan ujian hujung ke hujung pangkalan kod saya, jadi saya mahu menguji kod .catch()

API saya menggunakan node.js dan mongoose.

Saya menggunakan chai dan mocha untuk ujian.

Saya mencuba sesuatu seperti:

Fail src/controllers/user.controller.js:

const Pengguna = memerlukan("../models/user.model");

const getUser = async(req, res) =>
  cuba {
    const user = tunggu User.findOne({name: req.name});
    return res.status(200).json(user);
  } tangkap (err) {
    //Ini adalah kod yang saya ingin uji
    console.error(`Ralat mencari pengguna ${req.name}:`, err);
    kembalikan res.status(err.code).json({mesej: err });
  }
}

Fail src/models/user.model.js:

const mongoose = require("mongoose");

const UserSchema = mongoose.Schema({
  nama: {
    jenis: rentetan,
    diperlukan: "Nama diperlukan",
  },
});
module.exports = mongoose.model("Pengguna", UserSchema);

Ujian fail/user.test.js:

const chai = memerlukan("chai");
 const chaiHttp = memerlukan("chai-http");
 const spies = memerlukan("chai-spies");
 const Pengguna = memerlukan("../src/models/user.model");
 chai.use(chaiHttp);
 chai.use(mata-mata);
 chai.should();

 huraikan("ralat mongoose harus ditangani", function() {
    huraikan("Kaedah Pengguna Bermasalah.findOne", fungsi() {
      const _User_findOne_Backup = Pengguna.findOne;
      beforeEach(fungsi() {
        // Fungsi ini harus mengatasi fungsi findOne sebenar, tetapi ia tidak berjaya!User.findOne = function() {
          return Promise.reject("Kesilapan paksa");
        };
      });
      afterEach(function() { //Pulihkan fungsi sebenar selepas setiap ujian
        User.findOne = _User_findOne_Backup;
      });

      it("Pendaftaran harus mengembalikan ralat pelayan", function() {
        const spy = chai.spy();
        pulangkan chai
          .request(server)
          .post("/api/getUser")
          .hantar({nama: "Alice"})
          .then(spy)
          .catch((err) => {
            const res = err.response;
            res.should.have.status(500);
          })
          .then(() => {
            spy.should.not.have.been.called();
          })
        ;
      });
    });
  });

Masalahnya ialah dalam ujian saya, kaedah User.findOne() tidak pernah dipanggil: kaedah findOne jadi kaedah getUser tidak pernah membuang pengecualian, menyebabkan ujian saya gagal...

Mungkin saya kehilangan sesuatu yang jelas, tetapi saya benar-benar tidak dapat menemuinya... :-(

Jika lebih banyak kod atau konteks diperlukan, sila beritahu saya...

Kemas kini: Mengikuti cadangan @Bergi, saya menambah maklumat lengkap tentang model (dipermudahkan) saya dan modul yang diperlukan...

Answer 1

Berfungsi hebat untuk saya.

Contohnya:

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

Keputusan ujian:

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

Versi pakej:

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