1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Examples — Mock v0.6.0 documentation</title>
<link rel="stylesheet" href="_static/default.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '0.6.0',
COLLAPSE_MODINDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<link rel="top" title="Mock v0.6.0 documentation" href="index.html" />
<link rel="next" title="TODO and Limitations" href="todo.html" />
<link rel="prev" title="Getting Started with Mock" href="getting-started.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="todo.html" title="TODO and Limitations"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="getting-started.html" title="Getting Started with Mock"
accesskey="P">previous</a> |</li>
<li><a href="index.html">Mock v0.6.0 documentation</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="examples">
<h1>Examples<a class="headerlink" href="#examples" title="Permalink to this headline">¶</a></h1>
<p>For comprehensive examples, see the unit tests included in the full source distribution.</p>
<div class="section" id="mock-examples">
<h2>Mock Examples<a class="headerlink" href="#mock-examples" title="Permalink to this headline">¶</a></h2>
<div class="section" id="mock-patching-methods">
<h3>Mock Patching Methods<a class="headerlink" href="#mock-patching-methods" title="Permalink to this headline">¶</a></h3>
<p><tt class="docutils literal"><span class="pre">Mock</span></tt> is callable. If it is called then it sets a <tt class="docutils literal"><span class="pre">called</span></tt> attribute to <tt class="xref docutils literal"><span class="pre">True</span></tt>.</p>
<p>This example tests that calling <tt class="docutils literal"><span class="pre">method</span></tt> results in a call to <tt class="docutils literal"><span class="pre">something</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">test_method_calls_something</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">real</span> <span class="o">=</span> <span class="n">ProductionClass</span><span class="p">()</span>
<span class="n">real</span><span class="o">.</span><span class="n">something</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="n">real</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">something</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"method didn't call something"</span><span class="p">)</span>
</pre></div>
</div>
<p>If you want to catch the arguments then there is other information exposed:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">test_method_calls_something</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">real</span> <span class="o">=</span> <span class="n">ProductionClass</span><span class="p">()</span>
<span class="n">real</span><span class="o">.</span><span class="n">something</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="n">real</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">something</span><span class="o">.</span><span class="n">call_count</span><span class="p">,</span> <span class="mf">1</span><span class="p">,</span> <span class="s">"something called incorrect number of times"</span><span class="p">)</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">()</span>
<span class="n">keywargs</span> <span class="o">=</span> <span class="p">{}</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">something</span><span class="o">.</span><span class="n">call_args</span><span class="p">,</span> <span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">keywargs</span><span class="p">),</span> <span class="s">"something called with incorrect arguments"</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">something</span><span class="o">.</span><span class="n">call_args_list</span><span class="p">,</span> <span class="p">[(</span><span class="n">args</span><span class="p">,</span> <span class="n">keywargs</span><span class="p">)],</span>
<span class="s">"something called with incorrect arguments"</span><span class="p">)</span>
</pre></div>
</div>
<p>Checking <tt class="docutils literal"><span class="pre">call_args_list</span></tt> tests how many times the mock was called, and the arguments for each call, in a single assertion.</p>
</div>
<div class="section" id="mock-for-method-calls-on-an-object">
<h3>Mock for Method Calls on an Object<a class="headerlink" href="#mock-for-method-calls-on-an-object" title="Permalink to this headline">¶</a></h3>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">test_closer_closes_something</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">real</span> <span class="o">=</span> <span class="n">ProductionClass</span><span class="p">()</span>
<span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="n">real</span><span class="o">.</span><span class="n">closer</span><span class="p">(</span><span class="n">mock</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mock</span><span class="o">.</span><span class="n">close</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"closer didn't close something"</span><span class="p">)</span>
</pre></div>
</div>
<p>We don’t have to do any work to provide the ‘close’ method on our mock. Accessing close creates it. So, if ‘close’ hasn’t already been called then accessing it in the test will create it - but <tt class="docutils literal"><span class="pre">called</span></tt> will be <tt class="xref docutils literal"><span class="pre">False</span></tt>.</p>
<p>As <tt class="docutils literal"><span class="pre">close</span></tt> is a mock object is has all the attributes from the previous example.</p>
</div>
<div class="section" id="limiting-available-methods">
<h3>Limiting Available Methods<a class="headerlink" href="#limiting-available-methods" title="Permalink to this headline">¶</a></h3>
<p>The disadvantage of the approach above is that <em>all</em> method access creates a new mock. This means that you can’t tell if any methods were called that shouldn’t have been. There are two ways round this. The first is by restricting the methods available on your mock.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">test_closer_closes_something</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">real</span> <span class="o">=</span> <span class="n">ProductionClass</span><span class="p">()</span>
<span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">(</span><span class="n">spec</span><span class="o">=</span><span class="p">[</span><span class="s">'close'</span><span class="p">])</span>
<span class="n">real</span><span class="o">.</span><span class="n">closer</span><span class="p">(</span><span class="n">mock</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mock</span><span class="o">.</span><span class="n">close</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"closer didn't close something"</span><span class="p">)</span>
</pre></div>
</div>
<p>If <tt class="docutils literal"><span class="pre">closer</span></tt> calls any methods on <tt class="docutils literal"><span class="pre">mock</span></tt> <em>other</em> than close, then an <tt class="docutils literal"><span class="pre">AttributeError</span></tt> will be raised.</p>
</div>
<div class="section" id="tracking-all-method-calls">
<h3>Tracking all Method Calls<a class="headerlink" href="#tracking-all-method-calls" title="Permalink to this headline">¶</a></h3>
<p>An alternative way to verify that only the expected methods have been accessed is to use the <tt class="docutils literal"><span class="pre">method_calls</span></tt> attribute of the mock. This records all calls to child attributes of the mock - and also to their children.</p>
<p>This is useful if you have a mock where you expect an attribute method to be called. You could access the attribute directly, but <tt class="docutils literal"><span class="pre">method_calls</span></tt> provides a convenient way of looking at all method calls:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
<span class="go"><mock.Mock object at 0x...></span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">Property</span><span class="o">.</span><span class="n">method</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="mf">53</span><span class="p">)</span>
<span class="go"><mock.Mock object at 0x...></span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method_calls</span>
<span class="go">[('method', (), {}), ('Property.method', (10,), {'x': 53})]</span>
<span class="go">>>></span>
</pre></div>
</div>
<p>If you make an assertion about <tt class="docutils literal"><span class="pre">method_calls</span></tt> and any unexpected methods have been called, then the assertion will fail.</p>
</div>
<div class="section" id="setting-return-values-and-attributes">
<h3>Setting Return Values and Attributes<a class="headerlink" href="#setting-return-values-and-attributes" title="Permalink to this headline">¶</a></h3>
<p>Setting the return values on a mock object is trivially easy:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="mf">3</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
<span class="go">3</span>
</pre></div>
</div>
<p>Of course you can do the same for methods on the mock:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="mf">3</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
<span class="go">3</span>
</pre></div>
</div>
<p>If you need an attribute setting on your mock, just do it:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mf">3</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">x</span>
<span class="go">3</span>
</pre></div>
</div>
<p>Sometimes you want to mock up a more complex situation, like for example <tt class="docutils literal"><span class="pre">mock.connection.cursor().execute("SELECT</span> <span class="pre">1")</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">cursor</span> <span class="o">=</span> <span class="n">mock</span><span class="o">.</span><span class="n">connection</span><span class="o">.</span><span class="n">cursor</span><span class="o">.</span><span class="n">return_value</span>
<span class="gp">>>> </span><span class="n">cursor</span><span class="o">.</span><span class="n">execute</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="bp">None</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">connection</span><span class="o">.</span><span class="n">cursor</span><span class="p">()</span><span class="o">.</span><span class="n">execute</span><span class="p">(</span><span class="s">"SELECT 1"</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method_calls</span>
<span class="go">[('connection.cursor', (), {})]</span>
<span class="gp">>>> </span><span class="n">cursor</span><span class="o">.</span><span class="n">method_calls</span>
<span class="go">[('execute', ('SELECT 1',), {})]</span>
</pre></div>
</div>
</div>
<div class="section" id="creating-a-mock-from-an-existing-object">
<h3>Creating a Mock from an Existing Object<a class="headerlink" href="#creating-a-mock-from-an-existing-object" title="Permalink to this headline">¶</a></h3>
<p>One problem with over use of mocking is that it couples your tests to the implementation of your mocks rather than your real code. Suppose you have a class that implements <tt class="docutils literal"><span class="pre">some_method</span></tt>. In a test for another class, you provide a mock of this object that <em>also</em> provides <tt class="docutils literal"><span class="pre">some_method</span></tt>. If later you refactor the first class, so that it no longer has <tt class="docutils literal"><span class="pre">some_method</span></tt> - then your tests will continue to pass even though your code is now broken!</p>
<p><tt class="docutils literal"><span class="pre">Mock</span></tt> allows you to provide an object as a specification for the mock, using the <tt class="docutils literal"><span class="pre">spec</span></tt> keyword argument. Accessing methods / attributes on the mock that don’t exist on your specification object will immediately raise an attribute error. If you change the implementation of your specification, then tests that use that class will start failing immediately without you having to instantiate the class in those tests.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">(</span><span class="n">spec</span><span class="o">=</span><span class="n">SomeClass</span><span class="p">)</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">old_method</span><span class="p">()</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">AttributeError</span>: <span class="n-Identifier">object has no attribute 'old_method'</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="patch-decorator-examples">
<h2>Patch Decorator Examples<a class="headerlink" href="#patch-decorator-examples" title="Permalink to this headline">¶</a></h2>
<p>A common need in tests is to patch a class attribute or a module attribute, for example patching a builtin or patching a class in a module to test that it is instantiated. Modules and classes are effectively global, so patching on them has to be undone after the test or the patch will persist into other tests and cause hard to diagnose problems.</p>
<p>The <tt class="docutils literal"><span class="pre">patch</span></tt> and <tt class="docutils literal"><span class="pre">patch_object</span></tt> decorators provide a convenient way of doing this.</p>
<p><tt class="docutils literal"><span class="pre">patch_object</span></tt> patches attributes on objects within the scope of a function they decorate:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="nd">@patch_object</span><span class="p">(</span><span class="n">SomeClass</span><span class="p">,</span> <span class="s">'class_method'</span><span class="p">,</span> <span class="n">mock</span><span class="p">)</span>
<span class="gp">... </span><span class="k">def</span> <span class="nf">test</span><span class="p">():</span>
<span class="gp">... </span> <span class="n">SomeClass</span><span class="o">.</span><span class="n">class_method</span><span class="p">()</span>
<span class="gp">...</span>
<span class="gp">>>> </span><span class="n">test</span><span class="p">()</span>
<span class="gp">>>> </span><span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mock</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"class_method not called"</span><span class="p">)</span>
</pre></div>
</div>
<p>The decorator is applied to a function (called <tt class="docutils literal"><span class="pre">test</span></tt> above). The patching only applies inside the body of the function. You have to call the function explicitly, this can be useful as the test function can take arguments and be used to implement several tests, it can also return values.</p>
<p>They can be stacked to perform multiple simultaneous patches:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock1</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock2</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="nd">@patch_object</span><span class="p">(</span><span class="n">SomeClass</span><span class="p">,</span> <span class="s">'class_method'</span><span class="p">,</span> <span class="n">mock1</span><span class="p">)</span>
<span class="gp">... </span><span class="nd">@patch_object</span><span class="p">(</span><span class="n">SomeClass</span><span class="p">,</span> <span class="s">'static_method'</span><span class="p">,</span> <span class="n">mock2</span><span class="p">)</span>
<span class="gp">... </span><span class="k">def</span> <span class="nf">test</span><span class="p">():</span>
<span class="gp">... </span> <span class="n">SomeClass</span><span class="o">.</span><span class="n">class_method</span><span class="p">()</span>
<span class="gp">... </span> <span class="n">SomeClass</span><span class="o">.</span><span class="n">static_method</span><span class="p">()</span>
<span class="gp">...</span>
<span class="gp">>>> </span><span class="n">test</span><span class="p">()</span>
<span class="gp">>>> </span><span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mock1</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"class_method not called"</span><span class="p">)</span>
<span class="gp">>>> </span><span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mock2</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"static_method not called"</span><span class="p">)</span>
</pre></div>
</div>
<p>If you are patching a module (including <tt class="docutils literal"><span class="pre">__builtin__</span></tt>) then use patch instead of patch_object:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="n">sentinel</span><span class="o">.</span><span class="n">Handle</span>
<span class="gp">>>> </span><span class="nd">@patch</span><span class="p">(</span><span class="s">'__builtin__.open'</span><span class="p">,</span> <span class="n">mock</span><span class="p">)</span>
<span class="gp">... </span><span class="k">def</span> <span class="nf">test</span><span class="p">():</span>
<span class="gp">... </span> <span class="k">return</span> <span class="nb">open</span><span class="p">(</span><span class="s">'filename'</span><span class="p">,</span> <span class="s">'r'</span><span class="p">)</span>
<span class="gp">...</span>
<span class="gp">>>> </span><span class="n">handle</span> <span class="o">=</span> <span class="n">test</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="s">'filename'</span><span class="p">,</span> <span class="s">'r'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">assert</span> <span class="n">handle</span> <span class="o">==</span> <span class="n">sentinel</span><span class="o">.</span><span class="n">Handle</span><span class="p">,</span> <span class="s">"incorrect file handle returned"</span>
</pre></div>
</div>
<p>The module name can be ‘dotted’, in the form <tt class="docutils literal"><span class="pre">package.module</span></tt> if needed.</p>
<p>If you don’t want to call the decorated test function yourself, you can add <tt class="docutils literal"><span class="pre">apply</span></tt> as a decorator on top:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@apply</span>
<span class="nd">@patch</span><span class="p">(</span><span class="s">'Package.Module.attribute'</span><span class="p">,</span> <span class="n">sentinel</span><span class="o">.</span><span class="n">Attribute</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">test</span><span class="p">():</span>
<span class="s">"do something"</span>
</pre></div>
</div>
<p>A nice pattern is to actually decorate test methods themselves:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@patch_object</span><span class="p">(</span><span class="n">SomeClass</span><span class="p">,</span> <span class="s">'attribute'</span><span class="p">,</span> <span class="n">sentinel</span><span class="o">.</span><span class="n">Attribute</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">testMethod</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">SomeClass</span><span class="o">.</span><span class="n">attribute</span><span class="p">,</span> <span class="n">sentinel</span><span class="o">.</span><span class="n">Attribute</span><span class="p">,</span> <span class="s">"SomeClass not patched"</span><span class="p">)</span>
</pre></div>
</div>
<p>If you omit the second argument to <tt class="docutils literal"><span class="pre">patch</span></tt> (or the third argument to <tt class="docutils literal"><span class="pre">patch_object</span></tt>) then the attribute will be patched with a mock for you. The mock will be passed in as extra argument(s) to the function / method under test:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@patch_object</span><span class="p">(</span><span class="n">SomeClass</span><span class="p">,</span> <span class="s">'staticmethod'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">testMethod</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mockMethod</span><span class="p">):</span>
<span class="n">SomeClass</span><span class="o">.</span><span class="n">staticmethod</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mockMethod</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"SomeClass not patched with a mock"</span><span class="p">)</span>
</pre></div>
</div>
<p>You can stack up multiple patch decorators using this pattern:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@patch</span><span class="p">(</span><span class="s">'Module.ClassName1'</span><span class="p">)</span>
<span class="nd">@patch</span><span class="p">(</span><span class="s">'Module.ClassName2'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">testMethod</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">MockClass1</span><span class="p">,</span> <span class="n">MockClass2</span><span class="p">):</span>
<span class="n">ClassName1</span><span class="p">()</span>
<span class="n">ClassName2</span><span class="p">()</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">MockClass1</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"ClassName1 not patched"</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">assertEquals</span><span class="p">(</span><span class="n">MockClass2</span><span class="o">.</span><span class="n">called</span><span class="p">,</span> <span class="s">"ClassName2 not patched"</span><span class="p">)</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference external" href="">Examples</a><ul>
<li><a class="reference external" href="#mock-examples">Mock Examples</a><ul>
<li><a class="reference external" href="#mock-patching-methods">Mock Patching Methods</a></li>
<li><a class="reference external" href="#mock-for-method-calls-on-an-object">Mock for Method Calls on an Object</a></li>
<li><a class="reference external" href="#limiting-available-methods">Limiting Available Methods</a></li>
<li><a class="reference external" href="#tracking-all-method-calls">Tracking all Method Calls</a></li>
<li><a class="reference external" href="#setting-return-values-and-attributes">Setting Return Values and Attributes</a></li>
<li><a class="reference external" href="#creating-a-mock-from-an-existing-object">Creating a Mock from an Existing Object</a></li>
</ul>
</li>
<li><a class="reference external" href="#patch-decorator-examples">Patch Decorator Examples</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="getting-started.html"
title="previous chapter">Getting Started with Mock</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="todo.html"
title="next chapter">TODO and Limitations</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/examples.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="todo.html" title="TODO and Limitations"
>next</a> |</li>
<li class="right" >
<a href="getting-started.html" title="Getting Started with Mock"
>previous</a> |</li>
<li><a href="index.html">Mock v0.6.0 documentation</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2009, Michael Foord.
Last updated on Aug 22, 2009.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.1.
</div>
</body>
</html>
|
