Clone arguments before passing into the original function?

function fn(options) {
  options.foo = 1;
}
spy = chai.spy(fn);
spy({ bar : 1 });
spy.should.be.called.with({ bar : 1 }); // fail

This happens because the function fn modifies the argument, and the spy compares the modified object instead of the original version. Do you think it makes sense if we store a shallow cloned argument instead of using the argument directly?

[keithamus]

It’s been a while on this one, but I agree with your points. Personally I think we should wait a while for this one, but eventually do some breaking changes - so a course of action is like this:

1. called.with should work by reference using strict equality - currently this is not true, this would be a breaking change.
2. deep.called.with should modify this to use deep.equal which is what today’s behavior is.
3. For other edge caes, chai 5 will introduce matchers, which will solve this. If we add matcher support to chai-spies, then in you’d be able to do stuff like: expect(spy).to.be.called.with(expect.a('promise')).

I think this gives us full flexibility without compromising on quality. I’m happy to make breaking changes if it means good progress.

[b123400]

@keithamus thanks for the quick reply.

It will involve comparing look-alike objects in solution 2, and that is a problem as well.

I am not expert in writing test, so please correct me if there is any mistake. Your first code example requires the arg1 object to be shared between the function and the testing context, which is not the case for me. Consider this example:

function runFast(speed) {
  run({ speed: speed });
}
function run(options){
  if (!('direction' in options.direction)) {
    options.direction = "left";
  }
}
run = chai.spy(run)
runFast(10);
run.should.be.called.with({ speed: 10 }) // fail
run.should.be.called.with({ speed: 10, direction: "left" }) // pass

The actual argument passed to run in is created inside the runFast and I cannot access it from the testing context.

Maybe we can conclude this programming style is bad for testing, and I should not modify arguments directly?