Javascript Mocha测试相同对象的assert.equal失败

我有一些Mocha测试没有通过断言.equal，尽管这两项似乎是相同的。我可能不理解测试是如何运行的，但即使是错误输出也显示了两个类似的东西：

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

// is working
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
}


let row = exports.get('blah')

console.log("Printing out what get returns:")
console.log(row)


exports.set = async function(service, state) {
    function setResults(service) {
        return new Promise(async function (resolve, reject) {
             const db = await getDB();
             let sql = `UPDATE services
                                set id = ?,
                                            service = ?,
                                            date = ?
                                 WHERE service  = ?`;
                try {
                    db.run(sql, [state.id, service, state.date, service]);
                    resolve();
                } catch(err) {
                    reject(err);
                }
    });
  }
    await setResults(service)
}

exports.set('blah', {'id': 1, 'date': '01-23-1987'})

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

tests.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.equal(result, { 'id': 1, 'service': 'blah', 'date': '01-23-1987' })
});


it("set() should set to new values as expected", 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')`)
    await state.set('blah', {'id': 5, 'date': '05-22-2222'})
    let result = await state.get('blah')
    console.log("set test result is")
    console.log(result)
    assert.equal(result, { 'id': 5, 'service': 'blah', 'date': '05-22-2222' })
});

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

结果如下：

get test result is
{ id: 1, service: 'blah', date: '01-23-1987' }
  1) get() should return the expected row
5 'blah' '05-22-2222'

set test result is
{ id: 5, service: 'blah', date: '05-22-2222' }
  2) set() should set to new values as expected

  3) clear() should delete row from db

  0 passing (2s)
  3 failing

  1) get() should return the expected row:

      AssertionError [ERR_ASSERTION]: { id: 1, service: 'blah', date: '01-23-1987' } == { id: 1, service: 'blah', date: '01-23-1987' }
      + expected - actual


      at Context.<anonymous> (src\tests\testStates.js:26:12)
      at process._tickCallback (internal/process/next_tick.js:68:7)

  2) set() should set to new values as expected:

      AssertionError [ERR_ASSERTION]: { id: 5, service: 'blah', date: '05-22-2222' } == { id: 5, service: 'blah', date: '05-22-2222' }
      + expected - actual

get测试结果为
{id:1，服务：'blah'，日期：'01-23-1987'}
1） get（）应返回所需的行
5'废话'05-22-2222'
设置测试结果为
{id:5，服务：'blah'，日期：'05-22-2222'}
2） set（）应按预期设置为新值
3） clear（）应该从数据库中删除行
0通过（2秒）
3失败
1） get（）应返回所需的行：
AssertionError[ERR_ASSERTION]：{id:1，服务：'blah'，日期：'01-23-1987'}={id:1，服务：'blah'，日期：'01-23-1987'}
+预期-实际
在上下文中。（src\tests\testStates.js:26:12）
在进程中。_tick回调（内部/process/next_tick.js:68:7）
2） set（）应按预期设置为新值：
AssertionError[ERR_ASSERTION]：{id:5，服务：'blah'，日期：'05-22-2222'}={id:5，服务：'blah'，日期：'05-22-2222'}
+预期-实际

---

当项目实际不同时，通常会在错误下方显示带有+和-的差异，但此处预期和实际为空，并且==显示测试1和测试2的两个相同项目。为什么相同项的assert.equal测试会失败？这些东西肯定有什么我不知道的。它们之所以不同，是因为它仍然是一种承诺，而不是一种目标？我确实使用了

wait

关键字来表示这两个对象。

我建议您在比较JavaScript对象时将断言更改为使用chai。因此，可以比较对象，使其具有相同的键和值

---

如果使用与示例中相同的方法，则使用

=

比较实际对象和预期对象。通常，在比较JavaScript对象时，这不是您感兴趣的事情（除非您比较两个变量引用同一个对象，但我建议您改用）

注意你自己，因为它也有陷阱。因为NaN不等于NaN，如果您的对象有任何属性为NaN，测试将失败，您将拉扯头发…是的，在手上它是有意义的，因为就像您所说的

NaN！==NaN

。另一方面，由于同样的原因，它没有意义。¯\_(ツ)_/’是的，这是语言的设计行为。然而，人们应该意识到，大量的ppl不会期望这种行为，而是期望其他行为：）这是有道理的，因为equal期望内存中有相同的确切对象，非常感谢