123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

from mock import Mock, patchimport requests

class User(object):    def __init__(self):        """

        """

class Admin(User):    table = "admin"

    def __init__(self):        super(Admin, self).__init__()

    def list(self):        return []

# 对类进行mock@patch("__main__.Admin")def do(cls):    mock = Mock(table="Admin")    mock.list.return_value = ["A", ]    cls.return_value = mock # __init__

    a = Admin()    return a.list()

# 对方法进行mockdef send_request():    return requests.request('GET', "http://www.baidu.com/")

@patch("__main__.send_request")def do2(method):    mock = Mock(status_code=200)    mock.json.return_value = {}

    method.return_value = mock

    a = send_request()    return a.status_code, a.json()

if __name__ == '__main__':    l = do()    status_code, json = do2()    print(l)    print(status_code, json)

12345678

a.py

    -> Defines SomeClass

b.py

    -> from a import SomeClass    -> some_function instantiates SomeClass

12345678

# b.py

from a import SomeClass

def func():    s = SomeClass()    s.do_something()

123456789101112

# test.py

class Test1(TestCase):    # 这里对？    @patch("a.SomeClass")    def do1(self,cls):        # todo    # 还是这里对？    @patch("b.SomeClass")    def do2(self,cls):        # todo

12345678

Now we want to test some_function but we want to mock out SomeClass using patch. The problem is that when we import module b, which we will have to do then it imports SomeClass from module a. If we use patch to mock out a.SomeClass then it will have no effect on our test; module b already has a reference to the real SomeClass and it looks like our patching had no effect.

The key is to patch out SomeClass where it is used (or where it is looked up ). In this case some_function will actually look up SomeClass in module b, where we have imported it. The patching should look like:

@patch(‘b.SomeClass’)However, consider the alternative scenario where instead of from a import SomeClass module b does import a and some_function uses a.SomeClass. Both of these import forms are common. In this case the class we want to patch is being looked up on the a module and so we have to patch a.SomeClass instead:

@patch(‘a.SomeClass’)

12345678

现在我们想使用patch mock SomeClass测试some_function，但是问题是，当我们导入模块b时，我们将不得不从模块a导入SomeClass,如果我们想patch a.SomeClass发现他对于我们的测试没有任何影响，模块b已经从真正的SomeClass中引用，看起来我们的patch没有被影响。

关键是SomeClass从哪里进行patch,或者从哪里进行查找。在这个示例some_function会从模块b中查找SomeClass,我们也已经导入了，故修改后看起来应该是这样:

@patch(‘b.SomeClass’)

后面就不翻译了...

123456789

class Payroll(object):    @staticmethod    def hello():        pass

@patch("where.Payroll.hello")def test_hello(self, mock_hello):    mock_hello.return_value = lambda x: x # example

1234

with patch(    "addons.hcm.models.payroll.grpc_service.call") as mock_ar:    mock_ar.side_effect = Exception("i wanted.")

123456789

class UserResource(object):    def _add(self):        pass

@mock.patch.object(UserResource, "_add")def test_mock_add(self, mock_add):    mock_add.return_value = {} # anything u want.