When `assert_called_with` is used with mutable object, test fails if the object has changed. I think this is not what it meant to do.

https://docs.python.org/dev/library/unittest.mock-examples.html#coping-with-mutable-arguments

The same situation is explained in this document. But I don't understand why they did not fix and just are proposing some solutions to the users.

I don't see what the "fix" should be. Python doesn't have value semantics. Functions are called with objects, not with their values.

Imagine a was global variable, and then you say:
    a = mutable_object()
    f(a)
    a.mutate()
    f.assert_called_with(a)

In your view of the world, this should raise??

As explained copy would cause backwards incompatible change on objects that depend on identity comparison. I am not sure if this can be fixed in a backwards compatible manner.

> One possibility would be for mock to copy the arguments you pass in. This could then cause problems if you do assertions that rely on object identity for equality.

See also https://bugs.python.org/issue28848

This might be painful in certain scenarios, like when using wraps on functions that modify the arguments:

```
def func(d):
  return d.pop("key")
>>> def func(d):
...   return d.pop("key")
...
>>> m = Mock(wraps=func)
>>> m({"key": 1})
1
>>> m.assert_called_with({"key": 1})
#raises
```

But I think "not fixing" this through copy is reasonable, especially when doing copy can also break assertions on objects that cannot be copied, which can happen if they implement their own __copy__ and some other situations. Additionally, copy does not fully capture "the value of the object when it was passed" for custom types.

A copying mock was published under pypi in https://github.com/wimglenn/copyingmock but doesn't seem to get a lot of attention, if this was interesting by users it could be added as a new type of Mock, or maybe just a mixin that users could add to any existing mock if they wished.

Thank you all for the kind answers.
I didn't know copying could cause so many problems.

@veky
Thank you for the example.
But it seems that the example will actually raise and I think it should.
I am talking f.assert_called_with(b) when `b` has same values of `a` before it is mutated. I thought the function's purpose is to check values of the exact moment the function is called.

@xtreak
Thanks for the related issue. I didn't consider `identity comparison` situations. Definitely that could cause problems.

@mariocj89
> copy does not fully capture "the value of the object when it was passed" for custom types.
Thank you for the kind answer, it was really helpful to me. Now I understand why copying is so dangerous.

> when `b` has same values of `a` before it is mutated.

There might be no such object. Or it might exist, but you still wouldn't want it.

Consider the case when a is a coroutine that has just started (a=coro()). You call f with a, and then advance a to the next yielding point. Is f called with a? You say no. Ok. But imagine you call coro again, and call that b (b=coro()). Is f called with b? Do you really want to say yes to that?

Thanks! We can look at adding a copying mock if we see people needing it, but yeah, adding copy by default would be quite complex if we don't want to break existing users.