Pytest：如何调用夹具的补丁

Question

pytest 5.0.1 python 3.6

Imagine that you have a class that you import and initialize in another class

from file import Client
class A()

    def __init__(self):
        self.client = Client()

    def call(self):
        self.client.execute()

Now when I want to test it, because this import class touches outside components (eg a database), I want to mock the thing from happening (eg I can't believe you read databases so slowly...). But for reals. So I have a fixture with a patch in it. Yay!

 @pytest.fixture
 def setup_a(self):
    with patch('path_to_patch') as patched:
        a = A()
    return a

However, I can't seem to get the patch out of the fxiture to use it. I've tried creating a new patch, but this doesn't work (eg assert False)

@patch('path_to_patch')
def test_successful_execution(self, new_patch, setup_a):
    setup_a.call()
    assert new_patch.execute.called

I've also tried using the above patch implicitly

@patch('path_to_patch')
def test_successful_execution(self, new_patch, setup_a):
    setup_a.call()
    assert setup_a.execute.called    

What is the right way to do this? Let me know if you need more of an explanation.

Answer 1

I assume you want to patch Client.execute in A , and the fixture shall return an object of type A with that patch in place. The first thing is to make sure that the patching is still active:

 @pytest.fixture
 def mocked_a(self):
     with patch('path_to_a.Client.execute'):
         yield A()

In your example you had the object returned after the patching scope, meaning the patching had already ended at that point. Also note that you have to patch the Client module as imported in the a module (assuming that is where A is defined).

To use the patched object, you can now:

def test_successful_execution(mocked_a):
    mocked_a.call()
    mocked_a.Client.execute.assert_called_once()

Note that you can access the mock the same way you mocked it.

Alternatively, you can return the mock itself in the fixture:

 @pytest.fixture
 def mocked_execute(self):
     with patch('path_to_a.Client.execute') as patched:
         yield patched

def test_successful_execution(mocked_execute):
    a = A()
    a.call()
    mocked_execute.assert_called_once()

This way you explicitely create the object in your test, and the test is more clear, in my opinion.

(this is out of my head, so there may be errors...)