测试使用mochachai的mongoDB的ejsnodejs函数。

Question

mongo在homeController.js中是这样设置的。

const MongoDB = require("mongodb").MongoClient,
  dbURL = "mongodb://localhost:27017",
  dbName = "usersdb";
const collectionName = "contacts";
var test = require('assert');
var col;

var usersArray = []; // define an empty array as a placeholder
var gradesArray = [];

MongoDB.connect(dbURL, {
    useUnifiedTopology: true,
    useNewUrlParser: true,
    useCreateIndex: true
  },
  (error, client) => {
    if (error) throw error;
    let db = client.db(dbName);
    col = db.collection(collectionName, {
      safe: false,
      useUnifiedTechnology: true
    }, (err, r) => {
      if (err) {
        console.log("Something is wrong in db.collection");
      }
    });

    col.find()
      .toArray((error, userData) => {
        if (error) throw error;
        usersArray = userData; // store all users in the array users[]
        //console.log(userData);
      });
    //  console.log(`All users: ${usersArray}`);
  });

我想在homeController.js中测试一个函数，它接收一个名字和成绩数组，转换成绩，检查它们是否有效，并将它们推送到数据库中。这个函数看起来像这样，使用了 col 变量。

router.addUsers = (req, res) => {
  console.log("in homeController addUser");

  var newUserName = req.body.name;
  var newUsergrade = req.body.grade;

  var temp = 0;
  newUsergrade.forEach(letter => {
    letter = letter.toUpperCase();
    switch (letter) {
      case 'A':
        letter = 4.0
        break
      case 'A-':
        letter = 3.7
        break
      case 'B+':
        letter = 3.3
        break
      case 'B':
        letter = 3.0
        break
      case 'B-':
        letter = 2.7
        break
      case 'C+':
        letter = 2.3
        break
      case 'C':
        letter = 2.0
        break
      case 'C-':
        letter = 1.7
        break
      case 'D+':
        letter = 1.3
        break
      case 'D':
        letter = 1.0
        break
      case 'F':
        letter = 0.0
        break
    }
    temp += letter;
  });
 var valid = false;
  if (temp / 4 >= 2.5) {
    valid = true;
  } else {
    vaild = false;
  }
  col.insertOne({
    name: newUserName,
    grade: newUsergrade,
    isValid: valid
  }, function(err, r) {
    test.equal(null, err);
    test.equal(1, r.insertedCount);
    col.find({}).toArray((err, userData) => {
      console.log("record found: ", userData);
      usersArray = userData;
    });

  });

最后，我的router. test. js是这样的。

describe("addUsers", () => {
  it("should make sure a user can be added to the array", () => {
    const fakeReq = {
        body: {
          name: 'something',
          grade: ["a", "b", "a", "a"]
        }
      },
      fakeRes = {
        render: () => {}
      };


    router.addUsers(fakeReq, fakeRes);


    //  console.log(router.addUsers(fakeReq, fakeRes))

    expect(usersArray).to.deep.include({
      name: 'something'
    });
  });
});

我收到一个错误，说它不能 insertOne 的undefined，这意味着我需要在测试中使用mongoDB部分。我如何将其纳入我的测试中，以测试这个函数是否增加了一个条目？

Answer 1

你是在测试一个中间件，好像它是一个独立的函数。在这种情况下，你应该测试路由端点。比如说，你应该测试路由端点。

const request = require("supertest");
const expect = require("chai").expect;
const app = require('../app');
const mongoose = require('mongoose');
const faker = require("faker"); // to generate fake data
const Entity = require('../entities/discount'); // import schema
require('dotenv').config();


describe("GET /Entity/{entityID}", () => {
    let body 

    beforeEach(async () => {
        await Entity.deleteMany()

        body = {
            name: faker.name.title(),
            image: faker.image.imageUrl()
        }

        const entity = new Entity({
            _id: new mongoose.Types.ObjectId(),
            ...body
        })

        await entity.save()

    })

    describe("case of success", () => {
        it("should work and return status 200 and message ...", async () => {
            const res = await request(app)
                .get("/entity /" + entityID )

            expect(res.status).to.equal(200);
            expect(res.body).to.exist

            expect(res.body._id).to.exist
            expect(res.body).to.have.property("name", body.name);
            expect(res.body).to.have.property("image", body.image);

        })
    })

})

但如果你想测试每一个具体的函数， 你应该生成处理某个动作的函数 并特别测试这些动作。