如何让摩卡在断言错误的情况下显示整个对象？

Question

我有一个用mocha和chai的expect创建的单元测试用例，其中我将一个值对象数组与一个JSON文件的解析内容进行了深入的比较。

我的记录对象有大约20个属性，目前只有价格才可能导致不匹配。不同的是，我只看到其中的五个。

 expect(records).to.deep.equal(expected);

       "data": {
  -      "price": 3578
  +      "price": 3438
         "not_important": "foo"
         "also_not_important": "bar"
       }
       "data": {
  -      "price": 1828
  +      "price": 1698
         "not_important": "foo"
         "also_not_important": "bar"
       }

这在大多数情况下都是有用的默认情况，但在这一种情况下，它混淆了哪个特定的数据对象正在破坏断言，因为我在这里只看到多余的数据。

假设数据对象中有一个important属性，它将非常清楚什么期望破坏了测试。因此，我希望能够配置显示哪些属性，或者在diff中显示整个对象。

我如何配置摩卡的差异显示？

下面是一个精心设计的元句法示例，展示了这个问题：

import {expect} from "chai";

describe(("diff problem"), () => {
    it("should show case that the diff is not shown properly", () => {
        const actual = {
            a: 1,
            troiz: 0,
            bar: 0,
            baz: 2,
            poit: 3,
            narf: 4,
            fizzbuzz: 117,
            fizz: 5,
            buzz: 4,
            waldo: 115,
            mos: 85465,
            important: "THIS IS IMPORTANT",
        };

        const expected = {
            ...actual,
            a: 0,
        };

        return expect(actual).to.deep.equal(expected);
    });
});

该测试案例的输出将是：

2) SourceParser diff问题应显示在一个属性的错误上的全部差异：

  AssertionError: expected { Object (a, troiz, ...) } to deeply equal { Object (a, troiz, ...) }
  + expected - actual

   {
  -  "a": 1
  +  "a": 0
     "bar": 0
     "baz": 2
     "buzz": 4
     "fizz": 5

然而，看看important: "THIS IS IMPORTANT"也是有帮助的。

下面是修改后的数组用例：

describe(("diff problem with an array"), () => {
    it("should show case that the diff is not shown properly for deep equal of arrays", () => {
        const anEntity = {
            a: 1,
            troiz: 0,
            bar: 0,
            baz: 2,
            poit: 3,
            narf: 4,
            fizzbuzz: 117,
            fizz: 5,
            buzz: 4,
            waldo: 115,
            mos: 85465,
            important: "IMPORTANT", // assume that each item has a unique important property, which is why it's helpful for it to be shown
        };

        const offendingItem = {
            ...anEntity,
            a: 0,
        };

        const actual = [
            anEntity,
            offendingItem,
            anEntity,
        ];

        const expected = [
            anEntity,
            anEntity,
            anEntity,
        ];

        return expect(actual).to.deep.equal(expected);
    });

产出如下：

  AssertionError: expected [ Array(3) ] to deeply equal [ Array(3) ]
  + expected - actual

       "troiz": 0
       "waldo": 115
     }
     {
  -    "a": 0
  +    "a": 1
       "bar": 0
       "baz": 2
       "buzz": 4
       "fizz": 5

使用Louis的答案修改chai也不会更好，因为它只会先转储整个实际数组，然后显示无帮助的差异：

AssertionError: expected [ { a: 1,
    troiz: 0,
    bar: 0,
    baz: 2,
    poit: 3,
    narf: 4,
    fizzbuzz: 117,
    fizz: 5,
    buzz: 4,
    waldo: 115,
    mos: 85465,
    important: 'IMPORTANT' },
  { a: 0,
    troiz: 0,
    bar: 0,
    baz: 2,
    poit: 3,
    narf: 4,
    fizzbuzz: 117,
    fizz: 5,
    buzz: 4,
    waldo: 115,
    mos: 85465,
    important: 'IMPORTANT' },
  { a: 1,
    troiz: 0,
    bar: 0,
    baz: 2,
    poit: 3,
    narf: 4,
    fizzbuzz: 117,
    fizz: 5,
    buzz: 4,
    waldo: 115,
    mos: 85465,
    important: 'IMPORTANT' } ] to deeply equal [ { a: 1,
    troiz: 0,
    bar: 0,
    baz: 2,
    poit: 3,
    narf: 4,
    fizzbuzz: 117,
    fizz: 5,
    buzz: 4,
    waldo: 115,
    mos: 85465,
    important: 'IMPORTANT' },
  { a: 1,
    troiz: 0,
    bar: 0,
    baz: 2,
    poit: 3,
    narf: 4,
    fizzbuzz: 117,
    fizz: 5,
    buzz: 4,
    waldo: 115,
    mos: 85465,
    important: 'IMPORTANT' },
  { a: 1,
    troiz: 0,
    bar: 0,
    baz: 2,
    poit: 3,
    narf: 4,
    fizzbuzz: 117,
    fizz: 5,
    buzz: 4,
    waldo: 115,
    mos: 85465,
    important: 'IMPORTANT' } ]
      + expected - actual

           "troiz": 0
           "waldo": 115
         }
         {
      -    "a": 0
      +    "a": 1
           "bar": 0
           "baz": 2
           "buzz": 4
           "fizz": 5

Answer 1

您可以将--inline-diffs添加到mocha命令中，该命令将显示带有行号和内联差异的整个对象：

mocha --inline-diffs YourSpec.js

文档有点误导：https://mochajs.org/#diffs

​

​

Answer 2

据我所知，没有内置的方式让柴或摩卡产生的差异，将添加到由diff提供的上下文，一些字段是不负责的测试失败。我不知道你想要的任何扩展。所以我只知道解决办法。

如果将truncateThreshold配置设置设置为更大的值，或者设置为0 (如果不需要任何截断)，则在diff之前出现的失败消息将显示整个对象。因此，如果我将这个添加到您的代码中：

chai.config.truncateThreshold = 0; // 0 means "don't truncate, ever".

(这个文件页包含了配置选项。)

那么我得到的错误是：

      AssertionError: expected { a: 1,
  troiz: 0,
  bar: 0,
  baz: 2,
  poit: 3,
  narf: 4,
  fizzbuzz: 117,
  fizz: 5,
  buzz: 4,
  waldo: 115,
  mos: 85465,
  important: 'THIS IS IMPORTANT' } to deeply equal { a: 0,
  troiz: 0,
  bar: 0,
  baz: 2,
  poit: 3,
  narf: 4,
  fizzbuzz: 117,
  fizz: 5,
  buzz: 4,
  waldo: 115,
  mos: 85465,
  important: 'THIS IS IMPORTANT' }
      + expected - actual

       {
      -  "a": 1
      +  "a": 0
         "bar": 0
         "baz": 2
         "buzz": 4
         "fizz": 5

此外，在错误消息中获取自定义信息的一种方法是使用断言设置自定义消息，例如：

expect(actual).to.deep.equal(
            expected,
            `failed equality test on object with important field set to: ${actual.important}`)

自定义消息可以是详细的或简洁的，因为你需要它。

如果只有一个字段对区分对象很重要，那么定制消息可能就足以获得跟踪问题所需的信息。

对于对象数组，可以通过迭代actual和expected数组并比较每个成员来执行比较。然后，它将基本上像上面所描述的那样工作。当然，这也有其缺点:例如，如果项目1和10不同，您将只获得项目1的报告，因为测试将随着比较失败而结束。当您修复此问题并再次运行测试时，您将得到第10项的报告。实际上，这是否是一个主要问题取决于您测试的数据类型。

在默认的diff算法没有做我想做的事情的情况下，我所做的一件事就是导入一个我喜欢配置的差异库，然后使用这个库来执行我关心的对象之间的差异，并将结果合并到一个最后的报告中，然后用断言进行检查。

再说一遍，我不知道有一个库会专门做你要找的东西。但是，我可以想象迭代actual和expected数组，每对生成一个不同的报告，然后将它们组合成包含标识信息的更大的报告。

Answer 3

注:由于所有的下注:我是行动。我想要的解决方案不是解决架构决策的实际问题。有一个比较大型对象的解决方案是一种代码气味。我已经重构了我的代码库，这样我就不再需要这个尝试的解决方案了。

你在试图解决错误的问题。你想要的解决方案只是一个解决办法。

您的实际问题是，首先要依赖于对一组庞大的对象进行深度比较。

您应该重构您的代码库，以允许通过价格计算服务计算价格。使用简单的断言对服务进行单元测试是非常简单的。