Javascript Chai expect：数组包含至少具有这些属性和值的对象

我试图验证如下对象数组：

[
    {
        a: 1,
        b: 2,
        c: 3
    },
    {
        a: 4,
        b: 5,
        c: 6
    },
    ...
]

至少包含一个同时具有

{a:1}

和

{c:3}

的对象：

我想我可以用它来做这件事，但我不知道该对象的所有属性

expect(array).to.include.something.that.deep.equals({ ??, a: 1, c: 3});

和

contain.a.thing.with.property

不适用于多个属性：/

---

测试此类内容的最佳方法是什么？

您可以编写自己的函数来测试阵列。在本例中，传入数组和包含相关键/值对的对象：

function deepContains(arr, search) {

  // first grab the keys from the search object
  // we'll use the length later to check to see if we can
  // break out of the loop
  var searchKeys = Object.keys(search);

  // loop over the array, setting our check variable to 0
  for (var check = 0, i = 0; i < arr.length; i++) {
    var el = arr[i], keys = Object.keys(el);

    // loop over each array object's keys
    for (var ii = 0; ii < keys.length; ii++) {
      var key = keys[ii];

      // if there is a corresponding key/value pair in the
      // search object increment the check variable
      if (search[key] && search[key] === el[key]) check++;
    }

    // if we have found an object that contains a match
    // for the search object return from the function, otherwise
    // iterate again
    if (check === searchKeys.length) return true;
  }
  return false;
}

deepContains(data, { a: 4, c: 6 }); // true
deepContains(data, { a: 1, c: 6 }); // false

函数包含（arr、搜索）{
//首先从搜索对象中获取关键点
//稍后我们将使用长度来检查是否可以
//跳出循环
var searchKeys=Object.keys（搜索）；
//循环数组，将check变量设置为0
对于（变量检查=0，i=0；i

---

我能想出的最优雅的解决方案（在lodash的帮助下）：

---

expected（u.some（数组，{'a'：1，'c'：3}））.to.be.true

理想的解决方案似乎是：

expect(array).to.include.something.that.includes({a: 1, c: 3});

即，

数组

包含包含这些属性的项。不幸的是，目前似乎是这样。在可预见的未来

经过多次尝试，我发现转换原始数组会使任务更容易。这应该在没有其他库的情况下工作：

// Get items that interest us/remove items that don't.
const simplifiedArray = array.map(x => ({a: x.a, c: x.c}));
// Now we can do a simple comparison.
expect(simplifiedArray).to.deep.include({a: 1, c: 3});

这还允许您同时检查多个对象（我的用例）

---

似乎是来自

chai

的

chai子集

插件完成了这个任务。以下是我的一些工作：

const chai = require('chai');
const chaiSubset = require('chai-subset');
chai.use(chaiSubset);
const expect = chai.expect;

 expect([ { type: 'text',
    id: 'name',
    name: 'name',
    placeholder: 'John Smith',
    required: 'required' },
  { type: 'email',
    id: 'email',
    name: 'email',
    placeholder: 'example@gmail.com',
    required: 'required' },
  { type: 'submit' } ]).containSubset([{ type: 'text', type: 'email', type: 'submit' }]);

---

我能想到的最直接的方法是：

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

chai.use(require('chai-like'));
chai.use(require('chai-things'));

expect([
  {
    a: 1,
    b: 2,
    c: 3,
  },
  {
    a: 4,
    b: 5,
    c: 6,
  },
]).to.be.an('array').that.contains.something.like({ a: 1, c: 3 });

---

我认为这不是一个正确的测试。如果对象具有多个同名关键点，则最后一个关键点将获胜。所以

{type:'text'，type:'email'，type:'submit'}

实际上与

{type:'submit'}

什么是

some

。请看，这也是一个普通的JavaScript函数，您可以使用它检查列表中是否有具有指定约束的项。将其视为

数组。查找

，除非在完成回调而不是项时返回true@Mikey谢谢，我还以为lodash是这个问题的用户呢。：）

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

chai.use(require('chai-like'));
chai.use(require('chai-things'));

expect([
  {
    a: 1,
    b: 2,
    c: 3,
  },
  {
    a: 4,
    b: 5,
    c: 6,
  },
]).to.be.an('array').that.contains.something.like({ a: 1, c: 3 });