python3 mock简单学习

mock含义：mock测试就是在测试过程中，对于某些不容易构造或者不容易获取的对象，用一个虚拟的对象来创建以便测试的测试方法 。

转自：https://blog.csdn.net/qq_27384769/article/details/79796308

二、对mock 进行简单分装
mock_demo.py

mock_method 调用的方法名
request_data 请求值
url请求url
method post/get
response_data 返回值
#coding:utf-8
from mock import mock
#模拟mock 封装
def mock_test(mock_method,request_data,url,method,response_data):
　　mock_method = mock.Mock(return_value=response_data)
　　res = mock_method(url,method,request_data)
　　return res

调用

from mock_demo import mock_test
res = mock_test(self.run.run_main,data,url,"POST",data)

原文链接：https://www.jb51.net/article/164055.htm

mock作用

1. 解决依赖问题：当我们测试一个接口或者功能模块的时候，如果这个接口或者功能模块依赖其他接口或其他模块，那么如果所依赖的接口或功能模块未开发完毕，那么我们就可以使用mock模拟被依赖接口，完成目标接口的测试；

2. 单元测试：如果某个功能未开发完成，我们又要进行测试用例的代码编写，我们也可以先模拟这个功能进行测试；

3. 模拟复杂业务的接口：实际工作中如果我们在测试一个接口功能时，如果这个接口依赖一个非常复杂的接口业务，那么我们完全可以使用mock来模拟这个复杂的业务接口，其实这个和解决接口依赖是一样的原理；

4.前后端联调：如果你是一个前端页面开发，现在需要开发一个功能：根据后台返回的状态展示不同的页面，那么你就需要调用后台的接口，但是后台接口还未开发完成，是不是你就停止这部分工作呢？答案是否定的，你完全可以借助mock来模拟后台这个接口返回你想要的数据。

一个未开发完成的功能如何测试？

假如们现在有一个实现两个数相加的功能需要编写测试用例，但是由于开发进度缓慢，只搭两个简单的框架，并没有内部实现

mport unittest
from unittest import mock
class SubClass(object):
    def add(self, a, b):
        """两个数相加"""
        pass
class TestSub(unittest.TestCase):
    """测试两个数相加用例"""
    def test_sub(self):
        sub = SubClass() # 初始化被测函数类实例
        sub.add = mock.Mock(return_value=10) # mock add方法 返回10
        result = sub.add(5, 5) # 调用被测函数
        self.assertEqual(result, 10) # 断言实际结果和预期结果
if __name__ == '__main__':
    unittest.main()


实际上mock模拟add方法的原理是 使用相同的对象方法接收mock的对象(使用sub.add接收)，那么当mock对象被调用时(sub.add())就会返回return_value参数对应的数据

这样一来，表面看起来就是模拟了add方法

我们用例编写完了，而且开发既然也把功能开发完了(要骂街吗？)，既然真实的功能已经可以测试了，那么我们怎么在上面用例的基础上直接测试真实功能呢？

完整的功能如何测试？

import unittest
from unittest import mock
class SubClass(object):
    def add(self, a, b):
        """两个数相加"""
        return a + b
class TestSub(unittest.TestCase):
    """测试两个数相加"""
    def test_sub(self):
        sub = SubClass() # 初始化被测函数类实例
        sub.add = mock.Mock(return_value=10, side_effect=sub.add) # 传递side_effect关键字参数, 会覆盖return_value参数值, 使用真实的add方法测试
        result = sub.add(5, 11) # 真正的调用被测函数
        self.assertEqual(result, 16) # 断言实际结果和预期结果
if __name__ == '__main__':
    unittest.main()

side_effect参数
代码中我们给Mock方法添加了另一个关键字参数side_effect = sub.add， 这个参数和return_value 正好相反，当传递这个参数的时候return_value 参数就会失效，而side_effect生效，这里我给的参数值是sub.add 相当于add方法的地址，那么当调用add方法时就会真实的使用add方法，也就达到了我们测试实际的add 方法。
你也可以理解为当传递了side_effect参数且值为被测方法地址时，mock就不会起作用
side_effect接收的是一个可迭代序列，当传递多个值时，那么每次调用mock时会返回不同的值

mock_obj = mock.Mock(side_effect= [1,2,3])
print(mock_obj())
print(mock_obj())
print(mock_obj())
print(mock_obj())
输出
Traceback (most recent call last):
1
File "D:/MyThreading/mymock.py", line 37, in <module>
2
print(mock_obj())
3
File "C:\Python36\lib\unittest\mock.py", line 939, in __call__
return _mock_self._mock_call(*args, **kwargs)
File "C:\Python36\lib\unittest\mock.py", line 998, in _mock_call
result = next(effect)
StopIteration
Process finished with exit code 1
当所有值被取完后就会报错(这个地方有点类似生成器的原理)

存在依赖关系的功能如何测试？

假设有这样一个场景：我们要测试一个支付接口但是这个支付接口又依赖一个第三方支付接口，那么第三方支付接口我们暂时没有权限使用，那么我们该如何测试我们自己这个接口呢？

看下面的实例

假设第三方接口和我们自己的支付接口如下

import requests
class PayApi(object):
    @staticmethod
    def auth(card, amount):
        """
    第三方支付接口
    :param card: 卡号
    :param amount: 支付金额
    :return:
    """
        pay_url = "http://www.zhifubao.com" # 第三方支付接口地址
        data = {"card": card, "amount": amount}
        response = requests.post(pay_url, data=data) # 请求第三方支付接口
        return response # 返回状态码
    def pay(self, user_id, card, amount):
        """
    我们自己的支付接口
    :param user_id: 用户id
    :param card: 卡号
    :param amount: 支付金额
    :return:
        """
    # 调用第三方支付接口
        response = self.auth(card, amount)
        try:
            if response['status_code'] == '200':
                print('用户{}支付金额{}成功'.format(user_id, amount))
                return '支付成功'
            elif response['status_code'] == '500':
                print('用户{}支付失败, 金额不变'.format(user_id))
                return '支付失败'
            else:
                return '未知错误'
        except Exception:
            return "Error, 服务器异常!"
if __name__ == '__main__':
    pass

很明显第三方支付接口是无法访问的，因为接口的地址是我DIY的，为了模拟实际中我们无法使用的第三方支付接口

import unittest
from unittest import mock
from payment.PayMent import PayApi
class TestPayApi(unittest.TestCase):
    def test_success(self):
        pay = PayApi()
        pay.auth = mock.Mock(return_value={'status_code':'200'})
        status = pay.pay('1000', '12345', '10000')
        self.assertEqual(status, '支付成功')
    def test_fail(self):
        pay = PayApi()
        pay.auth = mock.Mock(return_value={'status_code':'500'})
        status = pay.pay('1000', '12345', '10000')
        self.assertEqual(status, '支付失败')
    def test_error(self):
        pay = PayApi()
        pay.auth = mock.Mock(return_value={'status_code':'300'})
        status = pay.pay('1000', '12345', '10000')
        self.assertEqual(status, '未知错误')
    def test_exception(self):
        pay = PayApi()
        pay.auth = mock.Mock(return_value='200')
        status = pay.pay('1000', '12345', '10000')
        self.assertEqual(status, 'Error, 服务器异常!')
if __name__ == '__main__':
    unittest.main()


从执行结果可以看出，即使第三方支付接口无法使用，但是我们自己的支付接口仍然测试通过了

也许有人会问，第三方支付都不能用，我们的测试结果是否是有效的呢？

通常我们在测试一个模块的时候，我们是可以认为其他模块的功能是正常的，只针对目标模块进行测试是没有任何问题的，所以说测试结果也是正确的

其实上述代码还可以使用另一种方式来写

mock对象的方法

import unittest
from unittest import mock
from unittest.mock import patch
from payment.PayMent import PayApi
class TestPayApi(unittest.TestCase):
    def setUp(self):
        self.pay = PayApi()
        
    @patch.object(PayApi, 'auth')
    def test_success(self, mock_auth):
        mock_auth.return_value = {'status_code':'200'}
        status = self.pay.pay('1000', '12345', '10000')
        self.assertEqual(status, '支付成功')

    @patch.object(PayApi, 'auth')
    def test_fail(self, mock_auth):
        mock_auth.return_value={'status_code':'500'}
        status = self.pay.pay('1000', '12345', '10000')
        self.assertEqual(status, '支付失败')

    @patch.object(PayApi, 'auth')
    def test_error(self, mock_auth):
        mock_auth.return_value={'status_code':'300'}
        status = self.pay.pay('1000', '12345', '10000')
        self.assertEqual(status, '未知错误')

    @patch.object(PayApi, 'auth')
    def test_exception(self, mock_auth):
        mock_auth.return_value='200'
        status = self.pay.pay('1000', '12345', '10000')
        self.assertEqual(status, 'Error, 服务器异常!')
if __name__ == '__main__':
    unittest.main()

 https://www.cnblogs.com/linuxchao/p/linuxchao-mock.html