匹配 Chai 断言中的部分对象？

Question

我正在寻找匹配以下内容的最佳方法：

expect([
    {
        C1: 'xxx',
        C0: 'this causes it not to match.'
    }
]).to.deep.include.members([
    {
        C1: 'xxx'
    }
]);

上面的方法不起作用，因为 C0 存在于实际中，而不是预期中。简而言之，我希望这个期望能够通过，但我不知道如何在不编写一堆自定义代码的情况下做到这一点......

Answer 1

chai-subset 或 chai-fuzzy 也可能执行您正在寻找的操作。

Chai 子集应该像这样工作：

expect([
  {
    C1: 'xxx',
    C0: 'this causes it not to match.'
  }
]).to.containSubset([{C1: 'xxx'}]);

就个人而言，如果我不想包含另一个插件，我将使用 chai 包含的

property

或

keys

匹配器：

([
  {
    C1: 'xxx',
    C0: 'this causes it not to match.'
  }
]).forEach(obj => {
  expect(obj).to.have.key('C1'); // or...
  expect(obj).to.have.property('C1', 'xxx');
});

Answer 2

无插件： http://chaijs.com/api/bdd/#method_property

  expect([
    {
      C1: 'xxx',
      C0: 'this causes it not to match.'
    }
  ]).to.have.deep.property('[0].C1', 'xxx');

Answer 3

干净、实用且无依赖

只需使用地图来过滤您要检查的键

类似：

const array = [
    {
        C1: 'xxx',
        C0: 'this causes it not to match.'
    }
];

expect(array.map(e=>e.C1)).to.include("xxx");

https://www.chaijs.com/api/bdd/

======

编辑：为了提高可读性，将其抽象为实用函数：

// test/utils.js

export const subKey = (array, key) => array.map(e=>e[key]);

然后将其导入到您的测试中，可以将其读作句子：

expect(subKey(array,"C1")).to.include("xxx");

Answer 4

有几个不同的 chai 插件都可以解决这个问题。我是浅-深-平等的粉丝。你会像这样使用它：

expect([
    {
      C1: 'xxx',
      C0: 'this causes it not to match.'
    }
  ]).to.shallowDeepEqual([
    {
      C1: 'xxx'
    }
  ]);

Answer 5

您可以使用

pick

和

omit

下划线功能来选择/拒绝要测试的属性：

const { pick, omit } = require('underscore');

const obj = {
  C1: 'xxx',
  C0: 'this causes it not to match.',
};

it('tests sparse object with pick', () => {
  expect(pick(obj, 'C1')).to.eql({ C1: 'xxx' });
});

it('tests sparse object with omit', () => {
  expect(omit(obj, 'C0')).to.eql({ C1: 'xxx' });
});

Answer 6

我相信最简单（当然也是最简单）的方法是：

var actual=[
  {
    C1:'xxx',
    C0:'yyy'
  }
];

actual.forEach(function(obj){
  expect(obj).to.have.property('C1','xxx');
});

Answer 7

我编写了 chai-match-pattern 和 lodash-match-pattern 来处理部分匹配（以及更多）深度匹配场景。

var chai = require('chai');
var chaiMatchPattern = require('chai-match-pattern');
chai.use(chaiMatchPattern);

// Using JDON pattern in expectation
chai.expect([
  {
    C1: 'xxx',
    C0: 'this causes it not to match.'
  }
]).to.matchPattern([
  {
    C1: 'xxx',
    '...': ''
  }
]);

// Using the slightly cleaner string pattern notation in expectation
chai.expect([
  {
    C1: 'xxx',
    C0: 'this causes it not to match.'
  }
]).to.matchPattern(`
  [
    {
      C1: 'xxx',
      ...
    }
  ]
  `
);

Answer 8

如果您需要将其与 spy 和 called.with 一起使用，请检查此答案：https://stackoverflow.com/a/58940221/1151741

例如

expect(spy1).to.have.been.called.with.objectContaining({ a: 1 });

Answer 9

稍微更新了 #RobRaisch 的版本，因为对于空比较会给出错误，因为 '' 不等于“”

let expected = {
            dateOfBirth: '',
            admissionDate: '',
            dischargeDate: '',
            incidentLocation: null
        };
        Object.keys(expected).forEach(function(key) {
            expect(actual[key]).to.equal(expected[key]);
        });

Answer 10

我知道这是一个旧线程，但没有一个无插件的答案对我有用。

您需要使用

to.have.nested.property

，例如：

expect([{ foo: "bar" }]).to.have.nested.property("[0].foo", "bar");

.deep

用于深入比较对象相等性，而不是部分相等性。所以这也验证了：

expect([{ foo: "bar" }]).to.have.deep.nested.property("[0]", { foo: "bar" });