Question

我目前正在开发一个nodejs / express rest api（个人项目），我想从这个项目中学到很多东西。

所以在我的项目中我使用sequelize作为ORM层，我有一个名为`bus的模型，我已经为这个模型构建了CRUD端点。

现在我想做一些测试这个模型/ api我已经开发了，我读了一些关于测试的教程，发现有两种类型的测试分为两大类：白盒与黑盒。

所以我写了一些测试我的api的集成测试（集成测试是黑盒测试）

我想知道要写一些单元测试，但我不知道要测试什么，bus模型是Sequelize模型，所以我测试的所有内容都已经过测试了它自己的sequelize库。并通过集成测试来测试api端点。

PS：这是我第一次写测试。

我使用以下技术：nodejs，sequelize，express，mocha，chai。

总线模型定义

const Sequelize = require('sequelize');

module.exports = function(sequelize) {

    let Bus =  sequelize.define('bus', {
        name: {
            type: Sequelize.STRING,
        },
    });


    Bus.associate = function(models) {
        Bus.hasOne(models.LaneBus, {
            foreignKey: 'busId'
        });
    };

    return Bus;
}

总线Api端点测试

const request = require('superagent');
const expect = require('chai').expect;

const app = require('../../src/app');
var http = require('http');

const models = require('../../src/models');


describe("bus", function () {

    var bus_id;

    it('should create bus', function (done) {

        request.post('http://localhost:3000/bus')
            .type('form')
            .send({
                name: 'bus_test_1',
            }).set('Accept', 'application/json')
            .set('Authorization', global.JWT_TOKEN_TEST_ADMIN)
            .end((err, res) => {
                expect(res.status).to.be.eq(201, 'invalid return code');
                expect(res.body.status).to.be.eq('success', 'invalid retun status');

                bus_id = res.body.id;

                done();
            })
    });

    it('should get list of bus', function (done) {

        request.get('http://localhost:3000/bus')
            .set('Accept', 'application/json')
            .end((err, res) => {
                expect(res.status).to.be.eq(200, 'invalid return code');
                expect(res.body.metadata).to.not.be.undefined

                done();
            })
    });


    it('should modify bus', function (done) {

        request.put(`http://localhost:3000/bus/${bus_id}`)
            .type('form')
            .send({
                name: 'bus_test_2'
            })
            .set('Authorization', global.JWT_TOKEN_TEST_ADMIN)
            .end((err, res) => {
                expect(res.status).to.be.eq(200, 'invalid return code');
                expect(res.body.status).to.be.eq('success', 'invalid retun status');
                done();
            });
    });

    it('modify bus should get error because bus dont exists', function (done) {

        request.put(`http://localhost:3000/bus/aaa`)
            .type('form')
            .send({
                name: 'bus_test_2'
            })
            .set('Authorization', global.JWT_TOKEN_TEST_ADMIN)
            .end((err, res) => {
                expect(res.status).to.be.eq(404, 'invalid return code');
                expect(res.body.status).to.be.eq('failure', 'invalid return code');
                done();
            });
    });


    it('should get bus', function (done) {

        request.get(`http://localhost:3000/bus/${bus_id}`)
            .end((err, res) => {
                expect(res.status).to.be.eq(200, 'invalid return code');
                expect(res.body.name).to.be.eq('bus_test_2');
                done();
            });
    });

    it('get bus should return error because bus dont exist', function (done) {

        request.get(`http://localhost:3000/bus/aaaa`)
            .end((err, res) => {
                expect(res.status).to.be.eq(404, 'invalid return code');
                expect(res.body.status).to.be.eq('failure', 'invalid return code');
                done();
            });
    });



    it('user role cannot create bus', function (done) {
        request.post('http://localhost:3000/bus')
            .type('form')
            .send({
                name: 'bus_test_1',
            }).set('Accept', 'application/json')
            .set('Authorization', global.JWT_TOKEN_TEST_USER)
            .end((err, res) => {
                expect(res.body.status).to.be.eq('failure', 'invalid retun status');


                done();
            })
    })

    it('user role cannot modify bus', function (done) {
        request.put(`http://localhost:3000/bus/${bus_id}`)
            .type('form')
            .send({
                name: 'bus_test_2'
            })
            .set('Authorization', global.JWT_TOKEN_TEST_USER)
            .end((err, res) => {
                expect(res.body.status).to.be.eq('failure', 'invalid retun status');
                done();
            });
    })


    it('user role cannot delete bus', function (done) {
        request.delete(`http://localhost:3000/bus/${bus_id}`)
            .set('Authorization', global.JWT_TOKEN_TEST_USER)
            .end((err, res) => {
                expect(res.body.status).to.be.eq('failure', 'invalid return code');
                done();
            });
    })


    it('should delete bus', function (done) {

        request.delete(`http://localhost:3000/bus/${bus_id}`)
            .set('Authorization', global.JWT_TOKEN_TEST_ADMIN)
            .end((err, res) => {
                expect(res.status).to.be.eq(200, 'invalid return code');
                done();
            });
    });

    it('delete bus should get error because bus dont exist', function (done) {

        request.delete(`http://localhost:3000/bus/${bus_id}`)
            .set('Authorization', global.JWT_TOKEN_TEST_ADMIN)
            .end((err, res) => {
                expect(res.status).to.be.eq(404, 'invalid return code');
                expect(res.body.status).to.be.eq('failure', 'invalid return code');
                done();
            });
    });





});

Answer 1

不明确的要求/例外使代码难以测试。有时候，你只是不知道什么会破坏你的代码。这种情况一直发生在现实世界中。你不知道什么会破坏你的代码;否则，你修好了。

在任何情况下，我建议使用代码覆盖率进行测试，例如Istanbul。确保您的代码至少经过80％的测试。稍后当您更新代码或修复错误时，您可以看到未测试的内容，并添加相应的测试。

Answer 2

整合（黑匣子）测试：我建议CucumberJS 集成测试，因为它提供了一种用于定义功能的简单语言，并且可以测试端到端功能，而不仅仅是API端点。例如：
```
Feature: Simple maths
 In order to do maths
 As a developer
 I want to increment variables
```
白盒单元测试：摩卡＆amp;柴是好的，所以你可以继续这些，但我会添加Sinon的存根和模拟。所以你上面的测试可以转化为集成测试（想象Yakbak之类的东西）或者转向其他方式并将它们变成Sinon的单元测试。

这些是我的建议，但随意环顾四周，选择你喜欢的图书馆进行测试。只需确保您在集成和单元测试之间进行区分。

单元测试和集成测试

2 个答案: