Question

在我学习TDD的过程中，尝试学习单元测试并使用mock和python。慢慢地掌握它，但不确定我是否正确地这样做。预警：我正在坚持使用python 2.4，因为供应商API是预先编译的2.4 pyc文件，所以我使用的是mock 0.8.0和unittest（不是unittest2）

在'mymodule.py'中给出这个示例代码

import ldap

class MyCustomException(Exception):
    pass

class MyClass:
    def __init__(self, server, user, passwd):
        self.ldap = ldap.initialize(server)
        self.user = user
        self.passwd = passwd

    def connect(self):
        try:
            self.ldap.simple_bind_s(self.user, self.passwd)
        except ldap.INVALID_CREDENTIALS:
            # do some stuff
            raise MyCustomException

现在在我的测试用例文件'test_myclass.py'中，我想模拟ldap对象。 ldap.initialize返回ldap.ldapobject.SimpleLDAPObject，所以我认为这是我必须嘲笑的方法。

import unittest
from ldap import INVALID_CREDENTIALS
from mock import patch, MagicMock
from mymodule import MyClass

class LDAPConnTests(unittest.TestCase):
    @patch('ldap.initialize')
    def setUp(self, mock_obj):
        self.ldapserver = MyClass('myserver','myuser','mypass')
        self.mocked_inst = mock_obj.return_value

    def testRaisesMyCustomException(self):
        self.mocked_inst.simple_bind_s = MagicMock()
        # set our side effect to the ldap exception to raise
        self.mocked_inst.simple_bind_s.side_effect = INVALID_CREDENTIALS
        self.assertRaises(mymodule.MyCustomException, self.ldapserver.connect)

    def testMyNextTestCase(self):
        # blah blah

引出了几个问题：

那看起来不错吗？：）
这是尝试和模拟在我正在测试的类中实例化的对象的正确方法吗？
在setUp上调用@patch装饰器是否可以，否则会导致奇怪的副作用？
无论如何都要模拟提升ldap.INVALID_CREDENTIALS异常而不必将异常导入我的测试用例文件中？
我应该使用patch.object（），如果是，怎么做？

感谢。

Answer 1

您可以使用patch()作为类装饰器，而不仅仅是函数装饰器。然后，您可以像以前一样传入模拟函数：

@patch('mymodule.SomeClass')
class MyTest(TestCase):

    def test_one(self, MockSomeClass):
        self.assertIs(mymodule.SomeClass, MockSomeClass)

请参阅：26.5.3.4. Applying the same patch to every test method（其中还列出了备选方案）

如果您希望对所有测试方法进行修补，那么在setUp上以这种方式设置修补程序更有意义。

Answer 2

如果要申请许多补丁并希望它们适用于setUp方法中初始化的内容，请尝试以下方法：

def setUp(self):
    self.patches = {
        "sut.BaseTestRunner._acquire_slot": mock.Mock(),
        "sut.GetResource": mock.Mock(spec=GetResource),
        "sut.models": mock.Mock(spec=models),
        "sut.DbApi": make_db_api_mock()
    }

    self.applied_patches = [mock.patch(patch, data) for patch, data in self.patches.items()]
    [patch.apply for patch in self.applied_patches]
    .
    . rest of setup
    .


def tearDown(self):
    patch.stopall()

Answer 3

我首先回答您的问题，然后我会详细说明patch()和setUp()如何互动。

我认为它看起来不正确，请参阅此列表中对问题＃3的回答以获取详细信息。
是的，对补丁的实际调用看起来应该模拟你想要的对象。
不，您几乎不想在@patch()上使用setUp()装饰器。你很幸运，因为该对象是在setUp()中创建的，并且永远不会在测试方法中创建。
我不知道如何使模拟对象引发异常而不将该异常导入测试用例文件。
我在这里看不到patch.object()的需要。它只允许您修补对象的属性，而不是将目标指定为字符串。

为了扩展我对问题＃3的回答，问题是patch()装饰器仅在装饰函数运行时应用。只要setUp()返回，修补程序就会被删除。在你的情况下，这是有效的，但我敢打赌，这会让看到这个测试的人感到困惑。如果您真的只希望在setUp()期间发生补丁，我建议使用with语句来明确补丁将被删除。

以下示例包含两个测试用例。 TestPatchAsDecorator表明装饰类会在测试方法期间应用补丁，但不会在setUp()期间应用补丁。 TestPatchInSetUp显示了如何应用修补程序，使其在setUp()和测试方法中都适用。致电self.addCleanUp()可确保在tearDown()期间删除该修补程序。

import unittest
from mock import patch


@patch('__builtin__.sum', return_value=99)
class TestPatchAsDecorator(unittest.TestCase):
    def setUp(self):
        s = sum([1, 2, 3])

        self.assertEqual(6, s)

    def test_sum(self, mock_sum):
        s1 = sum([1, 2, 3])
        mock_sum.return_value = 42
        s2 = sum([1, 2, 3])

        self.assertEqual(99, s1)
        self.assertEqual(42, s2)


class TestPatchInSetUp(unittest.TestCase):
    def setUp(self):
        patcher = patch('__builtin__.sum', return_value=99)
        self.mock_sum = patcher.start()
        self.addCleanup(patcher.stop)

        s = sum([1, 2, 3])

        self.assertEqual(99, s)

    def test_sum(self):
        s1 = sum([1, 2, 3])
        self.mock_sum.return_value = 42
        s2 = sum([1, 2, 3])

        self.assertEqual(99, s1)
        self.assertEqual(42, s2)

Answer 4

我想指出一种可接受的答案的变体，其中将new参数传递给patch()装饰器：

from unittest.mock import patch, Mock

MockSomeClass = Mock()

@patch('mymodule.SomeClass', new=MockSomeClass)
class MyTest(TestCase):
    def test_one(self):
        # Do your test here

请注意，在这种情况下，不再需要在每个测试方法中添加第二个参数MockSomeClass，这样可以节省大量的代码重复。

对此的解释可以在https://docs.python.org/3/library/unittest.mock.html#patch中找到：

如果将patch()用作修饰符，而省略了 new ，则将创建的模拟作为附加参数传递给修饰的函数。

最重要的是，答案省略了 new ，但是将其包括在内可能很方便。

Answer 5

您可以创建一个修补的内部函数，然后从setUp对其进行调用。

如果您原来的setUp函数是：

def setUp(self):
    some_work()

然后您可以将其更改为：

def setUp(self):
    @patch(...)
    def mocked_func():
        some_work()

    mocked_func()

如何在python中使用unittest setUp正确使用mock

5 个答案: