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,
10 return_value=DEFAULT, wraps=None, name=None,
11 spec_set=None, **kwargs)'''
12 import unittest
13 import calculation
14 
15 from unittest.mock import Mock
16 
17 class test_mock_args(unittest.TestCase):
18 
19     def test_mock_fun(self):      #mock一个函数   值为return_value
20         calculation.cal_fun1=Mock(return_value=7)
21         result = calculation.cal_fun1(2, 3)
22         print(result)
23         self.assertEqual(5,result)
24 
25     def test_mock_fun2(self):  # mock 一个函数 值为side_effect
26         calculation.cal_fun1 = Mock(side_effect=calculation.cal_fun2)
27         result = calculation.cal_fun1(2, 3)
28         print(result)
29         self.assertEqual(5, result)
30 
31     def test_mock_class(self):      #mock一个类实例  1return_value
32         count=calculation.count(3,2)
33         count.add_fun1=Mock(return_value=9)
34         result = count.add_fun1()
35         print(result)
36         self.assertEqual(5,result)
37     def test_mock_class2(self):      #类实例1side_effect
38         count=calculation.count(3,2)
39         count.add_fun1=Mock(side_effect=count.add_fun2)
40         result = count.add_fun1()
41         print(result)
43         self.assertEqual(5,result)
44 
45     def test_mock_zlass3(self):      #mock一个类
46         count=calculation.count(3,2)
47         print(count)                      #<calculation.count object at 0x00000060142EEF60>
48         mock_count=Mock(return_value=count)
49         print(mock_count)                 #<Mock id='385928260576'>
50 
51         count2=mock_count()
52         print(count2)                    #<calculation.count object at 0x00000060142EEF60>
53         result=count2.add_fun1()
54         print(result)

方式二:

 1 class test_mock(unittest.TestCase):
 2     '''mock一个函数'''
 3     @mock.patch('calculation.cal_fun1')        #1 写入被替代的 意思是用mock_cal_fun 来替代calculation.cal_fun1
 4     def test_mock_fun(self,mock_1):      #2 写入替代的
 5 
 6         mock_1.return_value=9            #3替代方式一
 7         mock_1.side_effect= calculation.cal_fun2     #3替代方式二:不需要写入参数  用mock_cal_fun=calculation.cal_fun1 =calculation.cal_fun1
 8         #mock_cal_fun.side_effect=calculation.cal_fun2(2,3)  #报错
 9 
10         result = calculation.cal_fun1(2, 3)
11         self.assertEqual(5,result)
12 
13     '''mock一个类中的方法'''
14     @mock.patch.object(calculation.count,'add_fun1') #1  前面是类名,后面是方法名  方法名需要加引号
15     def test_mock_class(self,mock_1):          #2   写入变量 用于 替代类中 的方法
16         mock_1.return_value=90
17         mock_1.side_effect=calculation.count(4,5).add_fun2 #3
18 
19 
20         result=calculation.count(5,4).add_fun1()
21         self.assertEqual(9,result)
22 
23     '''mock的顺序'''
24     @mock.patch('calculation.cal_fun1')
25     @mock.patch('calculation.cal_fun2')
26     @mock.patch.object(calculation.count,'add_fun1')
27     def  test_mocks(self,mock_1,mock_2,mock_3):   #注意;装饰器中的顺序与self中的相反
28         mock_1.return_value=100
29         mock_2.return_value=200
30         mock_3.return_value=300
31         result1=calculation.count(4,5).add_fun1()
32         result2=calculation.cal_fun2(2,3)
33         result3=calculation.cal_fun1(4,5)
34 
35         print(result1)  #>>>>>100
36         print(result2)  #>>>>>200
37         print(result3)  #>>>>>300

断言和统计:

 1 """
 2 unittest 断言主要是检查结果的正确性
 3 mock断言用于检查mock对象调用过程中,传入的参数 或者调用方法是否正确
 4 两者可协调使用
 5 
 6 1.assert_called_with(*args,**argkw),检查传入的参数是否正确,如个数,类型,顺序等
 7 2.assert_called_once_with(),        1.检查传入的参数是否正确2.检查是否只被调用了一次
 8 3.assert_any_call(),                检查曾经传输的参数
 9 4.assert_has_calls(argcalls,any_order=false),检查多个参数前后调用是否正确,any_order为true时,忽略顺序
10 """
11 '''
12 mock统计
13 
14 '''
15 import unittest
16 import calculation
17 from unittest.mock import Mock
18 
19 class test_mock_args(unittest.TestCase):
20     def test_mock_fun(self):      #函数1return_value
21         count=calculation.count2()
22 
23         count.add=Mock(name='add_fun1',return_value=7)
24         result=count.add(2,4)
25         count.add.assert_called_with(2,4)              #1
26         result = count.add(3, 4)
27         count.add.assert_called_with(3, 4)
28 
29         #count.add.assert_called_once_with(3,4) #>>报错,因为被调用了两次 #2
30         count.add.assert_any_call(3,4)                                   #3
31 

36         self.assertEqual(7,result)
37 
38 
39         '''统计'''
40         print(count.add.called)           #true  MOCK对象是否被调用过
41         print(count.add.call_count)       #2     调用的次数
42         print(count.add.call_args_list)   #[call(2, 4), call(3, 4)] 所有调用过的参数
43         print(count.add.call_args)        #call(3, 4)  最近调用的参数
44 
45         print(count.add.method_calls)     #[]   调用的方法(此处没有调用方法)
46         mockfoo=Mock(spec=count)           #mock一个类
47         result=mockfoo.add_fun1(3,4)
48         result2 = mockfoo.add_fun1(2, 4)
49         print(result)
50         print(mockfoo.method_calls)       #[call.add_fun1(3, 4), call.add_fun1(2, 4)] 调用了一次add_fun1方法

 

posted @ 2017-10-11 14:56  必有回响  阅读(158)  评论(0编辑  收藏  举报