使用sinon进行回调的单元测试mysql查询

我有一个用于创建mysql连接池和在数据库中插入记录的类。插入工作正常，但我无法通过单元测试获得完整覆盖

以下是连接类：

const mysql2 = require('mysql2');

class Connection {
    constructor(options = {}) {
        this.options = options;
    }

    createPool () {
        this.pool = mysql2.createPool({
            host: this.options.host,
            user: this.options.user,
            database:  'my_database',
            ssl: 'Amazon RDS',
            password: this.options.password,
            authPlugins: {
                mysql_clear_password: () => () => Buffer.from(this.options.password + '\0')
            }
        });
    }

    async insert (sql, values) {
        const promise = new Promise( (resolve, reject) => {

            try {
                this.pool.query(sql, [values],function (error, results, fields) {
                    if (error) throw error;
                    console.log(results.affectedRows); //Show 1
                    resolve (results.affectedRows);
                });
            } catch (e) {
                reject(e);
            }

        })
        return promise;
    }
}

module.exports = { Connection };

下面是我的失败测试：

const conns = require('../src/connection');
const sinon = require('sinon');
const mysql2 = require('mysql2');

describe('handler', () => {

    test('Test insert from Connection', async () => {
        const options = {
            host: 'testHost',
            user: 'testUser',
            password: 'testPassword'
        };

        const poolStub = {
            getConnection: sinon.stub().returnsThis(),
            query: sinon.stub().returnsThis(),
        };

        const createPoolStub = sinon.stub(mysql2, 'createPool').returns(poolStub);
        const conn = new conns.Connection(options);
        await conn.createPool();
        await conn.insert( 'select 1 + 1 as solution', [])

        sinon.restore();
    });
});

考试就要结束了

: Timeout - Async callback was not invoked within the 5000ms timeout specified by jest.setTimeout.

---

我很确定我没有在

poolStub

中正确地存根

query

，但我不确定如何解释回调方法。如何对这个

insert

方法进行单元测试，以便获得完整的覆盖范围？

以下是单元测试解决方案：

connection.js

：

const mysql2=require（'mysql2'）；
类连接{
构造函数（选项={}）{
this.options=选项；
}
createPool（）{
this.pool=mysql2.createPool({
主机：this.options.host，
用户：this.options.user，
数据库：“我的数据库”，
ssl:“亚马逊RDS”，
密码：this.options.password，
authPlugins：{
mysql\u清除\u密码：（）=>（）=>缓冲区。从（this.options.password+'\0'），
},
});
}
异步插入（sql、值）{
持续承诺=新承诺（（解决、拒绝）=>{
试一试{
this.pool.query（sql，[values]，函数（错误、结果、字段）{
如果（错误）抛出错误；
console.log（results.affectedRows）；//显示1
解决（结果、受影响的行为）；
});
}捕获（e）{
拒绝（e）；
}
});
回报承诺；
}
}
module.exports={Connection}；

connection.test.js

：

const conns=require（'./connection'）；
const sinon=要求（“sinon”）；
const mysql2=require（'mysql2'）；
const{expect}=require（'chai'）；
描述（'handler'，（）=>{
它（'testinsert from Connection'，async（）=>{
常量选项={
主机：“testHost”，
用户：“testUser”，
密码：“testPassword”，
};
const results={affectedRows:1}；
常量池存根={
getConnection:sinon.stub（）.returnsThis（），
查询：sinon.stub（）.callsFake（（sql、值、回调）=>{
回调（空，结果）；
}),
};
const createPoolStub=sinon.stub（mysql2，'createPool'）。返回（poolStub）；
const conn=新连接（选项）；
conn.createPool（）；
const actual=await conn.insert（'选择1+1作为解决方案'，[]）；
expect（实际）.to.be.eql（1）；
sinon.assert.calledWithjustice（poolStub.query，'select 1+1 as solution'，[[]]，sinon.match.func）；
sinon.assert.calledWithJustice（createPoolStub{
主机：“testHost”，
用户：“testUser”，
密码：“testPassword”，
数据库：“我的数据库”，
ssl:“亚马逊RDS”，
authPlugins：{
mysql\u清除\u密码：sinon.match.func，
},
});
sinon.restore（）；
});
});

单元测试结果和覆盖率报告：

  handler
1
    ✓ Test insert from Connection


  1 passing (15ms)

---------------|---------|----------|---------|---------|-------------------
File           | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
---------------|---------|----------|---------|---------|-------------------
All files      |   73.33 |    33.33 |   71.43 |   84.62 |                   
 connection.js |   73.33 |    33.33 |   71.43 |   84.62 | 16,30