Jest: Array.toContain() with expect.objectContaining

[KeKs0r]

What is the current behavior?
It seems that .toContain() can't be combined with expect.objectContaining. There might be another solution to test if an array of objects contains a specific object, but I somehow thought that combining toContain with expect.objectContaining would do the trick.

Example Test

  test('Array with Object Containing', () => {
    expect(
      [
        { a: 1, b: 2 }, 
        { c: 1, d: 1 }
      ])
      .toContain(
        expect.objectContaining({ a: 1, b: expect.anything() })
      )
  })

Output

 Array with Object Containing

    expect(array).toContain(value)

    Expected array:
      [{"a": 1, "b": 2}, {"c": 1, "d": 1}]
    To contain value:
      ObjectContaining {"a": 1, "b": Anything}

[KarandikarMihir]

FWIW, check out #2143

[KeKs0r]

@KarandikarMihir
I think I am missing something. How can I use Object.keys to find a specific object in my array of objects?

[anilreddykatta]

@KeKs0r If this helps!

test('Array with Object Containing', () => {
  expect(
    [
      { a: 1, b: 2 }, 
      { c: 1, d: 1 }
    ])
    .toContainEqual(
      expect.objectContaining({ a: 1, b: expect.anything() })
    )
})

Is passing without any issues.

[KeKs0r]

@anilreddykatta thanks this is working fine..

[WickyNilliams]

I just ran into the same issue. I find it a little confusing that toContain uses strict equality checks, whereas toContainEqual does not. Their names would imply the converse is true?

[justusromijn]

@WickyNilliams I agree that the naming there is a bit confusing, but you have to think like this: toContain asserts that it contains an exact thing, and in the case of objects, if it isn't the exact same object by reference, it fails. toContainEqual means if it looks the same by shape, it's ok. So it kinda makes sense, but it would have been better to reverse it and have a toContainStrict or something like that.

[WickyNilliams]

Coming back with more experience of jest, I would say the naming is ok. The toEqual matcher is the equivalent of toContainEqual, in that both test deep equality, not reference equality.