mock_待续

1.Mock对象的一般用法是这样的：

1.找到你要替换的对象，这个对象可以是一个类，或者是一个函数，或者是一个类实例。

2.然后实例化Mock类得到一个mock对象，并且设置这个mock对象的行为，比如被调用的时候返回什么值，被访问成员的时候返回什么值等。

3.使用这个mock对象替换掉我们想替换的对象，也就是步骤1中确定的对象。

4.之后就可以开始写测试代码，这个时候我们可以保证我们替换掉的对象在测试用例执行的过程中行为和我们预设的一样。

2.mock 方式

　　mock方式一：class Mock(spec=None, side_effect=None,return_value=DEFAULT, wraps=None, name=None,spec_set=None, **kwargs)'''

　　mock方式二：@path

3.mock断言和统计
4.待续

 方式一： 9 '''class Mock(spec=None, side_effect=None,
return_value=DEFAULT, wraps=None, name=None,
spec_set=None, **kwargs)'''
import unittest
import calculation

from unittest.mock import Mock

class test_mock_args(unittest.TestCase):

    def test_mock_fun(self):      #mock一个函数   值为return_value
        calculation.cal_fun1=Mock(return_value=7)
        result = calculation.cal_fun1(2, 3)
        print(result)
        self.assertEqual(5,result)

    def test_mock_fun2(self):  # mock 一个函数 值为side_effect
        calculation.cal_fun1 = Mock(side_effect=calculation.cal_fun2)
        result = calculation.cal_fun1(2, 3)
        print(result)
        self.assertEqual(5, result)

    def test_mock_class(self):      #mock一个类实例  1return_value
        count=calculation.count(3,2)
        count.add_fun1=Mock(return_value=9)
        result = count.add_fun1()
        print(result)
        self.assertEqual(5,result)
    def test_mock_class2(self):      #类实例1side_effect
        count=calculation.count(3,2)
        count.add_fun1=Mock(side_effect=count.add_fun2)
        result = count.add_fun1()
        print(result)
        self.assertEqual(5,result)

    def test_mock_zlass3(self):      #mock一个类
        count=calculation.count(3,2)
        print(count)                      #<calculation.count object at 0x00000060142EEF60>
        mock_count=Mock(return_value=count)
        print(mock_count)                 #<Mock id='385928260576'>

        count2=mock_count()
        print(count2)                    #<calculation.count object at 0x00000060142EEF60>
        result=count2.add_fun1()
        print(result)

方式二：

class test_mock(unittest.TestCase):
    '''mock一个函数'''
    @mock.patch('calculation.cal_fun1')        #1 写入被替代的 意思是用mock_cal_fun 来替代calculation.cal_fun1
    def test_mock_fun(self,mock_1):      #2 写入替代的

        mock_1.return_value=9            #3替代方式一
        mock_1.side_effect= calculation.cal_fun2     #3替代方式二：不需要写入参数  用mock_cal_fun=calculation.cal_fun1 =calculation.cal_fun1
        #mock_cal_fun.side_effect=calculation.cal_fun2(2,3)  #报错

        result = calculation.cal_fun1(2, 3)
        self.assertEqual(5,result)

    '''mock一个类中的方法'''
    @mock.patch.object(calculation.count,'add_fun1') #1  前面是类名，后面是方法名  方法名需要加引号
    def test_mock_class(self,mock_1):          #2   写入变量 用于 替代类中 的方法
        mock_1.return_value=90
        mock_1.side_effect=calculation.count(4,5).add_fun2 #3


        result=calculation.count(5,4).add_fun1()
        self.assertEqual(9,result)

    '''mock的顺序'''
    @mock.patch('calculation.cal_fun1')
    @mock.patch('calculation.cal_fun2')
    @mock.patch.object(calculation.count,'add_fun1')
    def  test_mocks(self,mock_1,mock_2,mock_3):   #注意;装饰器中的顺序与self中的相反
        mock_1.return_value=100
        mock_2.return_value=200
        mock_3.return_value=300
        result1=calculation.count(4,5).add_fun1()
        result2=calculation.cal_fun2(2,3)
        result3=calculation.cal_fun1(4,5)

        print(result1)  #>>>>>100
        print(result2)  #>>>>>200
        print(result3)  #>>>>>300

断言和统计：

"""
unittest 断言主要是检查结果的正确性
mock断言用于检查mock对象调用过程中，传入的参数 或者调用方法是否正确
两者可协调使用

1.assert_called_with(*args,**argkw),检查传入的参数是否正确，如个数，类型，顺序等
2.assert_called_once_with(),        1.检查传入的参数是否正确2.检查是否只被调用了一次
3.assert_any_call(),                检查曾经传输的参数
4.assert_has_calls(argcalls,any_order=false),检查多个参数前后调用是否正确，any_order为true时，忽略顺序
"""
'''
mock统计

'''
import unittest
import calculation
from unittest.mock import Mock

class test_mock_args(unittest.TestCase):
    def test_mock_fun(self):      #函数1return_value
        count=calculation.count2()

        count.add=Mock(name='add_fun1',return_value=7)
        result=count.add(2,4)
        count.add.assert_called_with(2,4)              #1
        result = count.add(3, 4)
        count.add.assert_called_with(3, 4)

        #count.add.assert_called_once_with(3,4) #>>报错，因为被调用了两次 #2
        count.add.assert_any_call(3,4)                                   #3


        self.assertEqual(7,result)


        '''统计'''
        print(count.add.called)           #true  MOCK对象是否被调用过
        print(count.add.call_count)       #2     调用的次数
        print(count.add.call_args_list)   #[call(2, 4), call(3, 4)] 所有调用过的参数
        print(count.add.call_args)        #call(3, 4)  最近调用的参数

        print(count.add.method_calls)     #[]   调用的方法（此处没有调用方法）
        mockfoo=Mock(spec=count)           #mock一个类
        result=mockfoo.add_fun1(3,4)
        result2 = mockfoo.add_fun1(2, 4)
        print(result)
        print(mockfoo.method_calls)       #[call.add_fun1(3, 4), call.add_fun1(2, 4)] 调用了一次add_fun1方法