Jasmine: Testing toHaveBeenCalledWith(params) where params is an object

Question

I'm doing some testing with Jasmine, having a strange result when looking for expected params as a result of a Spy.

I'm testing using the toHaveBeenCalledWith() method and looking for something like this:

{
  foo: bar,
  thing: [1,2,3],
  etc: function() { blah; }
}

It gives a fail, but the error message seems to confirm the exact same object is actually being found.

Any reasons why this might be the case?

Solution 1

Equivalent function definitions are not equal. So,

function() { return 'blah'; } == function() { return 'blah'; } // returns false

You have to reference the same function definition when using toHaveBeenCalledWith() for Jasmine to consider it equal to the argument passed to the spied object's method. Are you maybe passing in a new object definition (like the object you included in your question) to toHaveBeenCalledWith()? That will not pass the Jasmine assertion.

Here is the Jasmine spec I ran which illustrates what I said. There is a succeeding example and a failing example:

describe("A spy example", function() {
    var baz  = {
        foo: 'bar',
        thing: [1,2,3],
        etc: function() { }
    };

    beforeEach(function() {
        spyOn(baz, 'etc');
        baz.etc(baz);
    });

    it("succeeds", function() {
        expect(baz.etc).toHaveBeenCalledWith(baz);
    });

    it("fails", function() {
        expect(baz.etc).toHaveBeenCalledWith({
            foo: 'bar',
            thing: [1,2,3],
            etc: function() { }
        });
    });
});

Solution 2

A possible solution is to use: Custom asymmetric equality tester. Which let's the tester decide how to determine equality. Example:

describe("A spy example", function() {

var baz  = {
    foo: 'bar',
    thing: [1,2,3],
    etc: function() { }
};

beforeEach(function() {
    spyOn(baz, 'etc');
    baz.etc(baz);
});

it("succeeds", function() {
    expect(baz.etc).toHaveBeenCalledWith(baz);
});

var customTester = {
  asymmetricMatch: function(actual) {
    return actual.foo === 'bar' && 
           actual.thing.length === 3 // && ... ( any deep comparison method you wish to use)
  }
};

it("succeeds too", function() {
    expect(baz.etc).toHaveBeenCalledWith(customTester);
});

});

Hope this helps.

Comments

[Don H]

Thanks so much. I replaced the inline function with a reference to a specific method, and now all works.

[tytyryty]

How to make it works if my function definition is constructed inside function call? Like I have '''function F(param) { return { constructed: function() { return param; } } }'''. How to test that function was constructed properly?