错误：超过 2000 毫秒的超时。承诺在测试运行前不返回答案

【问题标题】：Error: Timeout of 2000ms exceeded. promise not returning before test runs错误：超过 2000 毫秒的超时。承诺在测试运行前不返回
【发布时间】：2019-05-19 01:33:13
【问题描述】：

我收到Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. 的错误

这是有道理的，如果返回一个承诺以确保它解决，但我真的认为我已经这样做了（通过使用 await 关键字）。这里似乎有一个我不明白的竞争条件

我正在为数据库连接模块编写单元测试：

states.js

const sqlite3 = require('sqlite3').verbose();
const util = require('util');

async function getDB() {
    return new Promise(function(resolve, reject) {
        let db = new sqlite3.Database('./project.db', (err) => {
          if (err) {
            console.error(err.message);
                reject(err)
          } else {
            console.log('Connected to the project database.');
                resolve(db)
        }
        });
        return db
    });
}

exports.getDB = getDB

try {
        // run these statements once to set up the db
        // let db = getDB();
        // db.run(`CREATE TABLE services(id INTEGER PRIMARY KEY, service text, date text)`);
        // db.run(`INSERT INTO services(id, service, date) VALUES (1, 'blah', '01-23-1987')`)
} catch(err) {
    console.log(err)
}


exports.get = async function(service) {
     function getResults(service) {
     return new Promise(async function (resolve, reject) {
                const db = await getDB();
                let sql = `SELECT Id id,
                               Service service,
                                                Date date
                        FROM services
                        WHERE service  = ?`;
                 db.get(sql, [service], (err, row) => {
                    if (err) {
                     console.error(err.message);
                     reject(err)
                 } else {
                     if (row) {
                         let this_row = {'id': row.id, 'service': row.service, 'date': row.date};
                         this_row ? console.log(row.id, row.service, row.date) : console.log(`No service found with the name ${service}`);
                         resolve(this_row)
                     } else {
                         resolve(null)
                     }
                 }
                })
     });
  }
    let row = await getResults(service)
    return row
}

exports.clear = async function(service) {
    function deleteResults(service) {
        return new Promise(async function (resolve, reject) {
             const db = await getDB();
             let sql = `DELETE from services
                                  WHERE service  = ?`;
                db.run(sql, [service]);
        });
    }
    await deleteResults(service)
}

我的 testStates.js：

const mocha = require('mocha');

const assert = require('assert');
const expect = require('chai').expect;
const should = require('chai').should();

const state = require('../state');

let deletion_sql = `DELETE from services WHERE service  = ?`;


it("get() should return the expected row", async function() {
    let db = await state.getDB()
    await db.run(deletion_sql, 'blah')
    await db.run(`INSERT INTO services(id, service, date) VALUES (1, 'blah', '01-23-1987')`)
    let result = await state.get('blah')
    console.log("get test result is")
    console.log(result)
    assert.deepEqual(result, { 'id': 1, 'service': 'blah', 'date': '01-23-1987' })
});


it("clear() should delete row from db", async function() {
  await state.clear('blah')
  let result = await state.get('blah')
  assert.equal(result, null)
})

测试clear() should delete row fromdb` 每次都失败，同样的错误，一次都没有通过。由于我刚开始学习 JavaScript 中的 Promise，因此我使用这些 Promise 的方式存在根本性的问题。

【问题讨论】：

done 是一个函数，它作为参数传递给您的函数，它不是 Promise 对象的一部分。您必须自己调用它或将其设置为 Promise 的回调之一，例如 .then(done) / .finally(done)
我不明白。可以举个例子吗
我看到你给了.then一个成功回调和可能的错误回调，这里我给它一个所以只是成功回调stackoverflow.com/questions/5436327/…
您还将异步函数传递给您的 new Promise 调用。使用异步函数时，您不需要构造 Promise，只需返回执行异步函数的结果
好的谢谢我会重构

标签： javascript node.js mocha.js

【解决方案1】：

我能够通过使用 .then() 而不是 await 关键字来运行测试：

it("clear() should delete row from db", async function() {
  state.clear('blah').then(async function() {
    let result = await state.get('blah')
    assert.equal(result, null)
  })
})

我很想知道为什么 await 关键字在这里不起作用，因为它在另一个测试中起作用；我很乐意接受这个答案。

【讨论】：