Provide a helper to copy args

[blueyed]

mock will store references in call_args and call_args_list (see https://docs.python.org/3/library/unittest.mock-examples.html#coping-with-mutable-arguments).

I think that pytest-mock could provide a helper based on the example from the doc:

from copy import deepcopy
>>> class CopyingMock(MagicMock):
...     def __call__(self, *args, **kwargs):
...         args = deepcopy(args)
...         kwargs = deepcopy(kwargs)
...         return super(CopyingMock, self).__call__(*args, **kwargs)

The following works (by extending the pytest-mock mocker fixture).

@pytest.fixture
def mocker(mocker):
    from copy import deepcopy
    from mock import MagicMock

    class CopyingMock(MagicMock):
        def __call__(self, *args, **kwargs):
            args = deepcopy(args)
            kwargs = deepcopy(kwargs)
            return super(CopyingMock, self).__call__(*args, **kwargs)

    mocker.CopyingMock = CopyingMock
    return mocker

    patched = mocker.patch('foo.bar', new_callable=mocker.CopyingMock)

Not sure if that's helpful enough and/or if there could be a mocker_copy fixture instead, which would handle new_callable not only for patch().

[blueyed]

This is how a mocker_copy fixture could look like:

@pytest.fixture
def mocker_copy(mocker):
    from copy import deepcopy
    from functools import partial
    from mock import MagicMock

    class CopyingMock(MagicMock):
        def __call__(self, *args, **kwargs):
            args = deepcopy(args)
            kwargs = deepcopy(kwargs)
            return super(CopyingMock, self).__call__(*args, **kwargs)

    mocker.patch._start_patch = partial(mocker.patch._start_patch,
                                        new_callable=CopyingMock)
    return mocker

[nicoddemus]

Hi @blueyed, thanks for the suggestion. I think adding this functionality to pytest-mock is a good idea.

I've never needed this functionality myself so I can't judge which approach would feel best from the user point of view, but if I have to choose I would rather have the first approach as it doesn't introduce a new fixture to a feature which I believe is not used that much. What do you think?

[blueyed]

@nicoddemus
Thanks for considering it.
I've went with the 2nd approach, since it's much easier to use and provides good separation.

You can easily run into this issue when checking calls that happen in a loop and use e.g. a dict as arg, which gets (re-)assigned in the loop.

Please note that the new_callable=CopyingMock can still be overridden, and new_callable=MagicMock would cause the default behavior again.

We could also consider to have this for the current mocker fixture by default, but that would break is checks etc and is probably therefore not a good idea.

[nicoddemus]

We could also consider to have this for the current mocker fixture by default, but that would break is checks etc and is probably therefore not a good idea.

I agree.

Are you working on a PR?

[blueyed]

@nicoddemus
Nope.

Feel free to take my patch from above.

[nicoddemus]

OK, thanks for the suggestion and patch. 😄