Python 返回 MagicMock 对象而不是 return_value

Question

I have a python file a.py which contains two classes A and B .

class A(object):
    def method_a(self):
        return "Class A method a"

class B(object):
    def method_b(self):
        a = A()
        print a.method_a()

I would like to unittest method_b in class B by mocking A . Here is the content of the file testa.py for this purpose:

import unittest
import mock
import a


class TestB(unittest.TestCase):

    @mock.patch('a.A')
    def test_method_b(self, mock_a):
        mock_a.method_a.return_value = 'Mocked A'
        b = a.B()
        b.method_b()


if __name__ == '__main__':
    unittest.main()

I expect to get Mocked A in the output. But what I get is:

<MagicMock name='A().method_a()' id='4326621392'>

Where am I doing wrong?

Answer 1

When you @mock.patch('a.A') , you are replacing the class A in the code under test with mock_a .

In B.method_b you then set a = A() , which is now a = mock_a() - ie a is the return_value of mock_a . As you haven't specified this value, it's a regular MagicMock ; this isn't configured either, so you get the default response (yet another MagicMock ) when calling methods on it.

Instead, you want to configure the return_value of mock_a to have the appropriate method, which you can do as either:

mock_a().method_a.return_value = 'Mocked A' 
    # ^ note parentheses

or, perhaps more explicitly:

mock_a.return_value.method_a.return_value = 'Mocked A'

Your code would have worked in the case a = A (assigning the class, not creating an instance), as then a.method_a() would have triggered your mock method.

Answer 2

I prefer pytest with mocker fixture . Here is the same test, using pytest and mocker:

import a


class TestB:
    def test_method_b(self, mocker):
        mock_A = mocker.MagicMock(name='A', spec=a.A)
        mocker.patch('a.A', new=mock_A)
        mock_A.return_value.method_a.return_value = 'Mocked A'

        b = a.B()
        b.method_b()

You may find the way I wrote the test more interesting than the test itself - I have created a python library to help me with the syntax.

Here is how I approached your problem in a systematic way:

We start with the test you want and my helper library:

import a

from mock_autogen.pytest_mocker import PytestMocker


class TestB:
    def test_method_b(self, mocker):
        # this would output the mocks we need
        print(PytestMocker(a).mock_classes().prepare_asserts_calls().generate())

        # your original test, without the mocks
        b = a.B()
        b.method_b()

Now the test doesn't do much, but the print output is useful:

# mocked classes
mock_A = mocker.MagicMock(name='A', spec=a.A)
mocker.patch('a.A', new=mock_A)
mock_B = mocker.MagicMock(name='B', spec=a.B)
mocker.patch('a.B', new=mock_B)
# calls to generate_asserts, put this after the 'act'
import mock_autogen
print(mock_autogen.generator.generate_asserts(mock_A, name='mock_A'))
print(mock_autogen.generator.generate_asserts(mock_B, name='mock_B'))

Now, I'm placing a single mock for A before the call to B() and the generate_asserts section after, like so (no need for the previous print, so I removed it):

def test_method_b(self, mocker):
    # mocked classes
    mock_A = mocker.MagicMock(name='A', spec=a.A)
    mocker.patch('a.A', new=mock_A)

    # your original test, without the mocks
    b = a.B()
    b.method_b()

    # calls to generate_asserts, put this after the 'act'
    import mock_autogen
    print(mock_autogen.generator.generate_asserts(mock_A, name='mock_A'))

After this test execution we have gained some valuable input:

assert 1 == mock_A.call_count
mock_A.assert_called_once_with()
mock_A.return_value.method_a.assert_called_once_with()
mock_A.return_value.method_a.return_value.__str__.assert_called_once_with()

The first two lines verifies the A mock was initialized once, without parameters. The third line verifies method_a was called, while the 4th line may be the most helpful for you and could have saved you much time figuring this on your own:

mock_A.return_value.method_a.return_value.__str__.assert_called_once_with()

You see that the returned value of method_a has been applied with str (due to the print function). replacing that with your desired string is pretty easy:

mock_A.return_value.method_a.return_value = 'Mocked A'

And that's how I got to the full test method mentioned above.

Answer 3

In case of mocking an object I use this syntax:

@mock.patch.object(
    a.A,
    'method_a',
    lambda a: "Mocked A")
def test_method_b(self):
    b = a.B()
    b.method_b()

In this case the method_a is mocked by the lambda function.