Jest: Partial matching for mock assertions

[jwbay]

Do you want to request a feature or report a bug?
Feature

What is the current behavior?
Asserting on parts of calls to mocks requires inspecting arguments or using a jasmine API

What is the expected behavior?
Asserting on parts of calls to mocks has a first-class API

Related - https://github.com/facebook/jest/pull/1843

Currently, asserting that a mock was called with a complex object is less than ideal because you have to either supply the entire matching object, use jasmine.objectContaining, or inspect the calls yourself with .mock.calls[x][y]. I'd like to propose an API like the following.

const mock = jest.fn();
mock({
    one: 'very long string',
    two: 2,
    three: '',
    four: {
        x: '42'
    }
});

expect(mock).toHaveBeenCalledWithMatch({
    one: 'very long string',
    two: 2
});

expect(mock).toHaveBeenCalledWithMatch({
    two: jest.any(Number) //like jasmine.any(Class)
});

Ideally we could go even further and add some meta-matchers to the jest object (inspired by sinon's matchers) to unlock some powerful assertions.

expect(mock).toHaveBeenCalledWithMatch({
    one: jest.match(value => value.startsWith('very')),
    two: jest.match.number(), //instead of jest.any(Number)
    three: jest.match.falsy(),
    four: jest.match.has('x')
});

[thymikee]

Have you tried using asymmetric matchers? They are exposed through expect. http://facebook.github.io/jest/docs/api.html#asymmetric-jest-matchers

[thymikee]

Worth noting they're available since Jest 18.
And will be provided with pretty-printing soon

[thymikee]

Disregard my previous comments.

Nevertheless I'm not convinced we need another type of matchers, because it's all possible through asymmetric matchers (now ported to Jest) without much more typing.

e.g. you can use

expect(mock).toHaveBeenCalledWith(expect.objectContaining({
  two: expect.any(Number)
}));

[cpojer]

yep, agree with @thymikee here.

[andyearnshaw]

@thymikee @cpojer that's a shame. Doing something like this is not as simple with jest matchers alone:

expect(mock).toHaveBeenCalledWith(expect.objectContaining({
    value: sinon.match(v => v >= 100 && v < 200)
});

There are times when .any() just doesn't cut it.

[benmvp]

Thanks @thymikee! This solved my problem! 😄

[alfechner]

@andyearnshaw your example is the first thing which came to my mind when I read the solution provided by @thymikee.

I currently have an object which I expect to be passed to my mocked method. It's not the same instance, though. It just represents the same value and has the same internal state. A method like sinon.match would be super handy for this use case.

[SimenB]

You can add custom asymmetric matchers today (toBeWithinRange in the docs: https://jestjs.io/docs/en/expect#expectextendmatchers). expect.match or expect.predicate sounds pretty cool.

[briantical]

@thymikee you just saved me after countless hours of coding. Thanks. Your solution worked for me.

[tabrez96]

@thymikee You made my day