python/mock-1.0.0/html/mock.html@fc2d59ddac77
python/mock-1.0.0/html/mock.html
Wed, 31 Dec 2014 07:22:50 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 07:22:50 +0100
- branch
- TOR_BUG_3246
- changeset 4
- fc2d59ddac77
- permissions
- -rw-r--r--
Correct previous dual key logic pending first delivery installment.
2 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
3 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
6 <html xmlns="http://www.w3.org/1999/xhtml">
7 <head>
8 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
10 <title>The Mock Class — Mock 1.0.0 documentation</title>
12 <link rel="stylesheet" href="_static/nature.css" type="text/css" />
13 <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
15 <script type="text/javascript">
16 var DOCUMENTATION_OPTIONS = {
17 URL_ROOT: '',
18 VERSION: '1.0.0',
19 COLLAPSE_INDEX: false,
20 FILE_SUFFIX: '.html',
21 HAS_SOURCE: true
22 };
23 </script>
24 <script type="text/javascript" src="_static/jquery.js"></script>
25 <script type="text/javascript" src="_static/underscore.js"></script>
26 <script type="text/javascript" src="_static/doctools.js"></script>
27 <link rel="top" title="Mock 1.0.0 documentation" href="index.html" />
28 <link rel="next" title="Patch Decorators" href="patch.html" />
29 <link rel="prev" title="Mock - Mocking and Testing Library" href="index.html" />
30 </head>
31 <body>
32 <div class="related">
33 <h3>Navigation</h3>
34 <ul>
35 <li class="right" style="margin-right: 10px">
36 <a href="genindex.html" title="General Index"
37 accesskey="I">index</a></li>
38 <li class="right" >
39 <a href="patch.html" title="Patch Decorators"
40 accesskey="N">next</a> |</li>
41 <li class="right" >
42 <a href="index.html" title="Mock - Mocking and Testing Library"
43 accesskey="P">previous</a> |</li>
44 <li><a href="index.html">Mock 1.0.0 documentation</a> »</li>
45 </ul>
46 </div>
48 <div class="document">
49 <div class="documentwrapper">
50 <div class="bodywrapper">
51 <div class="body">
53 <div class="section" id="the-mock-class">
54 <h1>The Mock Class<a class="headerlink" href="#the-mock-class" title="Permalink to this headline">¶</a></h1>
55 <p><cite>Mock</cite> is a flexible mock object intended to replace the use of stubs and
56 test doubles throughout your code. Mocks are callable and create attributes as
57 new mocks when you access them <a class="footnote-reference" href="#id3" id="id1">[1]</a>. Accessing the same attribute will always
58 return the same mock. Mocks record how you use them, allowing you to make
59 assertions about what your code has done to them.</p>
60 <p><a class="reference internal" href="magicmock.html#mock.MagicMock" title="mock.MagicMock"><tt class="xref py py-class docutils literal"><span class="pre">MagicMock</span></tt></a> is a subclass of <cite>Mock</cite> with all the magic methods
61 pre-created and ready to use. There are also non-callable variants, useful
62 when you are mocking out objects that aren’t callable:
63 <a class="reference internal" href="#mock.NonCallableMock" title="mock.NonCallableMock"><tt class="xref py py-class docutils literal"><span class="pre">NonCallableMock</span></tt></a> and <a class="reference internal" href="magicmock.html#mock.NonCallableMagicMock" title="mock.NonCallableMagicMock"><tt class="xref py py-class docutils literal"><span class="pre">NonCallableMagicMock</span></tt></a></p>
64 <p>The <a class="reference internal" href="patch.html#mock.patch" title="mock.patch"><tt class="xref py py-func docutils literal"><span class="pre">patch()</span></tt></a> decorators makes it easy to temporarily replace classes
65 in a particular module with a <cite>Mock</cite> object. By default <cite>patch</cite> will create
66 a <cite>MagicMock</cite> for you. You can specify an alternative class of <cite>Mock</cite> using
67 the <cite>new_callable</cite> argument to <cite>patch</cite>.</p>
68 <span class="target" id="index-0"></span><span class="target" id="index-1"></span><span class="target" id="index-2"></span><span class="target" id="index-3"></span><span class="target" id="index-4"></span><dl class="class">
69 <dt id="mock.Mock">
70 <em class="property">class </em><tt class="descname">Mock</tt><big>(</big><em>spec=None</em>, <em>side_effect=None</em>, <em>return_value=DEFAULT</em>, <em>wraps=None</em>, <em>name=None</em>, <em>spec_set=None</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.Mock" title="Permalink to this definition">¶</a></dt>
71 <dd><p>Create a new <cite>Mock</cite> object. <cite>Mock</cite> takes several optional arguments
72 that specify the behaviour of the Mock object:</p>
73 <ul>
74 <li><p class="first"><cite>spec</cite>: This can be either a list of strings or an existing object (a
75 class or instance) that acts as the specification for the mock object. If
76 you pass in an object then a list of strings is formed by calling dir on
77 the object (excluding unsupported magic attributes and methods).
78 Accessing any attribute not in this list will raise an <cite>AttributeError</cite>.</p>
79 <p>If <cite>spec</cite> is an object (rather than a list of strings) then
80 <a class="reference internal" href="#mock.Mock.__class__" title="mock.Mock.__class__"><tt class="xref py py-attr docutils literal"><span class="pre">__class__</span></tt></a> returns the class of the spec object. This allows mocks
81 to pass <cite>isinstance</cite> tests.</p>
82 </li>
83 <li><p class="first"><cite>spec_set</cite>: A stricter variant of <cite>spec</cite>. If used, attempting to <em>set</em>
84 or get an attribute on the mock that isn’t on the object passed as
85 <cite>spec_set</cite> will raise an <cite>AttributeError</cite>.</p>
86 </li>
87 <li><p class="first"><cite>side_effect</cite>: A function to be called whenever the Mock is called. See
88 the <a class="reference internal" href="#mock.Mock.side_effect" title="mock.Mock.side_effect"><tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt></a> attribute. Useful for raising exceptions or
89 dynamically changing return values. The function is called with the same
90 arguments as the mock, and unless it returns <a class="reference internal" href="sentinel.html#mock.DEFAULT" title="mock.DEFAULT"><tt class="xref py py-data docutils literal"><span class="pre">DEFAULT</span></tt></a>, the return
91 value of this function is used as the return value.</p>
92 <p>Alternatively <cite>side_effect</cite> can be an exception class or instance. In
93 this case the exception will be raised when the mock is called.</p>
94 <p>If <cite>side_effect</cite> is an iterable then each call to the mock will return
95 the next value from the iterable. If any of the members of the iterable
96 are exceptions they will be raised instead of returned.</p>
97 <p>A <cite>side_effect</cite> can be cleared by setting it to <cite>None</cite>.</p>
98 </li>
99 <li><p class="first"><cite>return_value</cite>: The value returned when the mock is called. By default
100 this is a new Mock (created on first access). See the
101 <a class="reference internal" href="#mock.Mock.return_value" title="mock.Mock.return_value"><tt class="xref py py-attr docutils literal"><span class="pre">return_value</span></tt></a> attribute.</p>
102 </li>
103 <li><p class="first"><cite>wraps</cite>: Item for the mock object to wrap. If <cite>wraps</cite> is not None then
104 calling the Mock will pass the call through to the wrapped object
105 (returning the real result and ignoring <cite>return_value</cite>). Attribute access
106 on the mock will return a Mock object that wraps the corresponding
107 attribute of the wrapped object (so attempting to access an attribute
108 that doesn’t exist will raise an <cite>AttributeError</cite>).</p>
109 <p>If the mock has an explicit <cite>return_value</cite> set then calls are not passed
110 to the wrapped object and the <cite>return_value</cite> is returned instead.</p>
111 </li>
112 <li><p class="first"><cite>name</cite>: If the mock has a name then it will be used in the repr of the
113 mock. This can be useful for debugging. The name is propagated to child
114 mocks.</p>
115 </li>
116 </ul>
117 <p>Mocks can also be called with arbitrary keyword arguments. These will be
118 used to set attributes on the mock after it is created. See the
119 <a class="reference internal" href="#mock.Mock.configure_mock" title="mock.Mock.configure_mock"><tt class="xref py py-meth docutils literal"><span class="pre">configure_mock()</span></tt></a> method for details.</p>
120 <dl class="method">
121 <dt id="mock.Mock.assert_called_with">
122 <tt class="descname">assert_called_with</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.Mock.assert_called_with" title="Permalink to this definition">¶</a></dt>
123 <dd><p>This method is a convenient way of asserting that calls are made in a
124 particular way:</p>
125 <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>
126 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="n">test</span><span class="o">=</span><span class="s">'wow'</span><span class="p">)</span>
127 <span class="go"><Mock name='mock.method()' id='...'></span>
128 <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">assert_called_with</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="n">test</span><span class="o">=</span><span class="s">'wow'</span><span class="p">)</span>
129 </pre></div>
130 </div>
131 </dd></dl>
133 <dl class="method">
134 <dt id="mock.Mock.assert_called_once_with">
135 <tt class="descname">assert_called_once_with</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.Mock.assert_called_once_with" title="Permalink to this definition">¶</a></dt>
136 <dd><p>Assert that the mock was called exactly once and with the specified
137 arguments.</p>
138 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
139 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'foo'</span><span class="p">,</span> <span class="n">bar</span><span class="o">=</span><span class="s">'baz'</span><span class="p">)</span>
140 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">(</span><span class="s">'foo'</span><span class="p">,</span> <span class="n">bar</span><span class="o">=</span><span class="s">'baz'</span><span class="p">)</span>
141 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'foo'</span><span class="p">,</span> <span class="n">bar</span><span class="o">=</span><span class="s">'baz'</span><span class="p">)</span>
142 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">(</span><span class="s">'foo'</span><span class="p">,</span> <span class="n">bar</span><span class="o">=</span><span class="s">'baz'</span><span class="p">)</span>
143 <span class="gt">Traceback (most recent call last):</span>
144 <span class="c">...</span>
145 <span class="gr">AssertionError</span>: <span class="n">Expected to be called once. Called 2 times.</span>
146 </pre></div>
147 </div>
148 </dd></dl>
150 <dl class="method">
151 <dt id="mock.Mock.assert_any_call">
152 <tt class="descname">assert_any_call</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.Mock.assert_any_call" title="Permalink to this definition">¶</a></dt>
153 <dd><p>assert the mock has been called with the specified arguments.</p>
154 <p>The assert passes if the mock has <em>ever</em> been called, unlike
155 <a class="reference internal" href="#mock.Mock.assert_called_with" title="mock.Mock.assert_called_with"><tt class="xref py py-meth docutils literal"><span class="pre">assert_called_with()</span></tt></a> and <a class="reference internal" href="#mock.Mock.assert_called_once_with" title="mock.Mock.assert_called_once_with"><tt class="xref py py-meth docutils literal"><span class="pre">assert_called_once_with()</span></tt></a> that
156 only pass if the call is the most recent one.</p>
157 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
158 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">arg</span><span class="o">=</span><span class="s">'thing'</span><span class="p">)</span>
159 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'some'</span><span class="p">,</span> <span class="s">'thing'</span><span class="p">,</span> <span class="s">'else'</span><span class="p">)</span>
160 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_any_call</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">arg</span><span class="o">=</span><span class="s">'thing'</span><span class="p">)</span>
161 </pre></div>
162 </div>
163 </dd></dl>
165 <dl class="method">
166 <dt id="mock.Mock.assert_has_calls">
167 <tt class="descname">assert_has_calls</tt><big>(</big><em>calls</em>, <em>any_order=False</em><big>)</big><a class="headerlink" href="#mock.Mock.assert_has_calls" title="Permalink to this definition">¶</a></dt>
168 <dd><p>assert the mock has been called with the specified calls.
169 The <cite>mock_calls</cite> list is checked for the calls.</p>
170 <p>If <cite>any_order</cite> is False (the default) then the calls must be
171 sequential. There can be extra calls before or after the
172 specified calls.</p>
173 <p>If <cite>any_order</cite> is True then the calls can be in any order, but
174 they must all appear in <a class="reference internal" href="#mock.Mock.mock_calls" title="mock.Mock.mock_calls"><tt class="xref py py-attr docutils literal"><span class="pre">mock_calls</span></tt></a>.</p>
175 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
176 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
177 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
178 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
179 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
180 <span class="gp">>>> </span><span class="n">calls</span> <span class="o">=</span> <span class="p">[</span><span class="n">call</span><span class="p">(</span><span class="mi">2</span><span class="p">),</span> <span class="n">call</span><span class="p">(</span><span class="mi">3</span><span class="p">)]</span>
181 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_has_calls</span><span class="p">(</span><span class="n">calls</span><span class="p">)</span>
182 <span class="gp">>>> </span><span class="n">calls</span> <span class="o">=</span> <span class="p">[</span><span class="n">call</span><span class="p">(</span><span class="mi">4</span><span class="p">),</span> <span class="n">call</span><span class="p">(</span><span class="mi">2</span><span class="p">),</span> <span class="n">call</span><span class="p">(</span><span class="mi">3</span><span class="p">)]</span>
183 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_has_calls</span><span class="p">(</span><span class="n">calls</span><span class="p">,</span> <span class="n">any_order</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
184 </pre></div>
185 </div>
186 </dd></dl>
188 <dl class="method">
189 <dt id="mock.Mock.reset_mock">
190 <tt class="descname">reset_mock</tt><big>(</big><big>)</big><a class="headerlink" href="#mock.Mock.reset_mock" title="Permalink to this definition">¶</a></dt>
191 <dd><p>The reset_mock method resets all the call attributes on a mock object:</p>
192 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
193 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'hello'</span><span class="p">)</span>
194 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">called</span>
195 <span class="go">True</span>
196 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">reset_mock</span><span class="p">()</span>
197 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">called</span>
198 <span class="go">False</span>
199 </pre></div>
200 </div>
201 <p>This can be useful where you want to make a series of assertions that
202 reuse the same object. Note that <cite>reset_mock</cite> <em>doesn’t</em> clear the
203 return value, <a class="reference internal" href="#mock.Mock.side_effect" title="mock.Mock.side_effect"><tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt></a> or any child attributes you have
204 set using normal assignment. Child mocks and the return value mock
205 (if any) are reset as well.</p>
206 </dd></dl>
208 <dl class="method">
209 <dt id="mock.Mock.mock_add_spec">
210 <tt class="descname">mock_add_spec</tt><big>(</big><em>spec</em>, <em>spec_set=False</em><big>)</big><a class="headerlink" href="#mock.Mock.mock_add_spec" title="Permalink to this definition">¶</a></dt>
211 <dd><p>Add a spec to a mock. <cite>spec</cite> can either be an object or a
212 list of strings. Only attributes on the <cite>spec</cite> can be fetched as
213 attributes from the mock.</p>
214 <p>If <cite>spec_set</cite> is <cite>True</cite> then only attributes on the spec can be set.</p>
215 </dd></dl>
217 <dl class="method">
218 <dt id="mock.Mock.attach_mock">
219 <tt class="descname">attach_mock</tt><big>(</big><em>mock</em>, <em>attribute</em><big>)</big><a class="headerlink" href="#mock.Mock.attach_mock" title="Permalink to this definition">¶</a></dt>
220 <dd><p>Attach a mock as an attribute of this one, replacing its name and
221 parent. Calls to the attached mock will be recorded in the
222 <a class="reference internal" href="#mock.Mock.method_calls" title="mock.Mock.method_calls"><tt class="xref py py-attr docutils literal"><span class="pre">method_calls</span></tt></a> and <a class="reference internal" href="#mock.Mock.mock_calls" title="mock.Mock.mock_calls"><tt class="xref py py-attr docutils literal"><span class="pre">mock_calls</span></tt></a> attributes of this one.</p>
223 </dd></dl>
225 <dl class="method">
226 <dt id="mock.Mock.configure_mock">
227 <tt class="descname">configure_mock</tt><big>(</big><em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.Mock.configure_mock" title="Permalink to this definition">¶</a></dt>
228 <dd><p>Set attributes on the mock through keyword arguments.</p>
229 <p>Attributes plus return values and side effects can be set on child
230 mocks using standard dot notation and unpacking a dictionary in the
231 method call:</p>
232 <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>
233 <span class="gp">>>> </span><span class="n">attrs</span> <span class="o">=</span> <span class="p">{</span><span class="s">'method.return_value'</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="s">'other.side_effect'</span><span class="p">:</span> <span class="ne">KeyError</span><span class="p">}</span>
234 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">configure_mock</span><span class="p">(</span><span class="o">**</span><span class="n">attrs</span><span class="p">)</span>
235 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
236 <span class="go">3</span>
237 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">other</span><span class="p">()</span>
238 <span class="gt">Traceback (most recent call last):</span>
239 <span class="c">...</span>
240 <span class="gr">KeyError</span>
241 </pre></div>
242 </div>
243 <p>The same thing can be achieved in the constructor call to mocks:</p>
244 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">attrs</span> <span class="o">=</span> <span class="p">{</span><span class="s">'method.return_value'</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="s">'other.side_effect'</span><span class="p">:</span> <span class="ne">KeyError</span><span class="p">}</span>
245 <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">some_attribute</span><span class="o">=</span><span class="s">'eggs'</span><span class="p">,</span> <span class="o">**</span><span class="n">attrs</span><span class="p">)</span>
246 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">some_attribute</span>
247 <span class="go">'eggs'</span>
248 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
249 <span class="go">3</span>
250 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">other</span><span class="p">()</span>
251 <span class="gt">Traceback (most recent call last):</span>
252 <span class="c">...</span>
253 <span class="gr">KeyError</span>
254 </pre></div>
255 </div>
256 <p><cite>configure_mock</cite> exists to make it easier to do configuration
257 after the mock has been created.</p>
258 </dd></dl>
260 <dl class="method">
261 <dt id="mock.Mock.__dir__">
262 <tt class="descname">__dir__</tt><big>(</big><big>)</big><a class="headerlink" href="#mock.Mock.__dir__" title="Permalink to this definition">¶</a></dt>
263 <dd><p><cite>Mock</cite> objects limit the results of <cite>dir(some_mock)</cite> to useful results.
264 For mocks with a <cite>spec</cite> this includes all the permitted attributes
265 for the mock.</p>
266 <p>See <a class="reference internal" href="helpers.html#mock.FILTER_DIR" title="mock.FILTER_DIR"><tt class="xref py py-data docutils literal"><span class="pre">FILTER_DIR</span></tt></a> for what this filtering does, and how to
267 switch it off.</p>
268 </dd></dl>
270 <dl class="method">
271 <dt id="mock.Mock._get_child_mock">
272 <tt class="descname">_get_child_mock</tt><big>(</big><em>**kw</em><big>)</big><a class="headerlink" href="#mock.Mock._get_child_mock" title="Permalink to this definition">¶</a></dt>
273 <dd><p>Create the child mocks for attributes and return value.
274 By default child mocks will be the same type as the parent.
275 Subclasses of Mock may want to override this to customize the way
276 child mocks are made.</p>
277 <p>For non-callable mocks the callable variant will be used (rather than
278 any custom subclass).</p>
279 </dd></dl>
281 <dl class="attribute">
282 <dt id="mock.Mock.called">
283 <tt class="descname">called</tt><a class="headerlink" href="#mock.Mock.called" title="Permalink to this definition">¶</a></dt>
284 <dd><p>A boolean representing whether or not the mock object has been called:</p>
285 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
286 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">called</span>
287 <span class="go">False</span>
288 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
289 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">called</span>
290 <span class="go">True</span>
291 </pre></div>
292 </div>
293 </dd></dl>
295 <dl class="attribute">
296 <dt id="mock.Mock.call_count">
297 <tt class="descname">call_count</tt><a class="headerlink" href="#mock.Mock.call_count" title="Permalink to this definition">¶</a></dt>
298 <dd><p>An integer telling you how many times the mock object has been called:</p>
299 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
300 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_count</span>
301 <span class="go">0</span>
302 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
303 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
304 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_count</span>
305 <span class="go">2</span>
306 </pre></div>
307 </div>
308 </dd></dl>
310 <dl class="attribute">
311 <dt id="mock.Mock.return_value">
312 <tt class="descname">return_value</tt><a class="headerlink" href="#mock.Mock.return_value" title="Permalink to this definition">¶</a></dt>
313 <dd><p>Set this to configure the value returned by calling the mock:</p>
314 <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>
315 <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="s">'fish'</span>
316 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
317 <span class="go">'fish'</span>
318 </pre></div>
319 </div>
320 <p>The default return value is a mock object and you can configure it in
321 the normal way:</p>
322 <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>
323 <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">attribute</span> <span class="o">=</span> <span class="n">sentinel</span><span class="o">.</span><span class="n">Attribute</span>
324 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">return_value</span><span class="p">()</span>
325 <span class="go"><Mock name='mock()()' id='...'></span>
326 <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">assert_called_with</span><span class="p">()</span>
327 </pre></div>
328 </div>
329 <p><cite>return_value</cite> can also be set in the constructor:</p>
330 <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">return_value</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
331 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">return_value</span>
332 <span class="go">3</span>
333 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
334 <span class="go">3</span>
335 </pre></div>
336 </div>
337 </dd></dl>
339 <dl class="attribute">
340 <dt id="mock.Mock.side_effect">
341 <tt class="descname">side_effect</tt><a class="headerlink" href="#mock.Mock.side_effect" title="Permalink to this definition">¶</a></dt>
342 <dd><p>This can either be a function to be called when the mock is called,
343 or an exception (class or instance) to be raised.</p>
344 <p>If you pass in a function it will be called with same arguments as the
345 mock and unless the function returns the <a class="reference internal" href="sentinel.html#mock.DEFAULT" title="mock.DEFAULT"><tt class="xref py py-data docutils literal"><span class="pre">DEFAULT</span></tt></a> singleton the
346 call to the mock will then return whatever the function returns. If the
347 function returns <a class="reference internal" href="sentinel.html#mock.DEFAULT" title="mock.DEFAULT"><tt class="xref py py-data docutils literal"><span class="pre">DEFAULT</span></tt></a> then the mock will return its normal
348 value (from the <a class="reference internal" href="#mock.Mock.return_value" title="mock.Mock.return_value"><tt class="xref py py-attr docutils literal"><span class="pre">return_value</span></tt></a>.</p>
349 <p>An example of a mock that raises an exception (to test exception
350 handling of an API):</p>
351 <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>
352 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="ne">Exception</span><span class="p">(</span><span class="s">'Boom!'</span><span class="p">)</span>
353 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
354 <span class="gt">Traceback (most recent call last):</span>
355 <span class="c">...</span>
356 <span class="gr">Exception</span>: <span class="n">Boom!</span>
357 </pre></div>
358 </div>
359 <p>Using <cite>side_effect</cite> to return a sequence of values:</p>
360 <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>
361 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
362 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(),</span> <span class="n">mock</span><span class="p">(),</span> <span class="n">mock</span><span class="p">()</span>
363 <span class="go">(3, 2, 1)</span>
364 </pre></div>
365 </div>
366 <p>The <cite>side_effect</cite> function is called with the same arguments as the
367 mock (so it is wise for it to take arbitrary args and keyword
368 arguments) and whatever it returns is used as the return value for
369 the call. The exception is if <cite>side_effect</cite> returns <a class="reference internal" href="sentinel.html#mock.DEFAULT" title="mock.DEFAULT"><tt class="xref py py-data docutils literal"><span class="pre">DEFAULT</span></tt></a>,
370 in which case the normal <a class="reference internal" href="#mock.Mock.return_value" title="mock.Mock.return_value"><tt class="xref py py-attr docutils literal"><span class="pre">return_value</span></tt></a> is used.</p>
371 <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">return_value</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
372 <span class="gp">>>> </span><span class="k">def</span> <span class="nf">side_effect</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
373 <span class="gp">... </span> <span class="k">return</span> <span class="n">DEFAULT</span>
374 <span class="gp">...</span>
375 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">side_effect</span>
376 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
377 <span class="go">3</span>
378 </pre></div>
379 </div>
380 <p><cite>side_effect</cite> can be set in the constructor. Here’s an example that
381 adds one to the value the mock is called with and returns it:</p>
382 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">side_effect</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">value</span><span class="p">:</span> <span class="n">value</span> <span class="o">+</span> <span class="mi">1</span>
383 <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">side_effect</span><span class="o">=</span><span class="n">side_effect</span><span class="p">)</span>
384 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
385 <span class="go">4</span>
386 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">)</span>
387 <span class="go">-7</span>
388 </pre></div>
389 </div>
390 <p>Setting <cite>side_effect</cite> to <cite>None</cite> clears it:</p>
391 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mock</span> <span class="kn">import</span> <span class="n">Mock</span>
392 <span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">(</span><span class="n">side_effect</span><span class="o">=</span><span class="ne">KeyError</span><span class="p">,</span> <span class="n">return_value</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
393 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
394 <span class="gt">Traceback (most recent call last):</span>
395 <span class="c">...</span>
396 <span class="gr">KeyError</span>
397 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="bp">None</span>
398 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
399 <span class="go">3</span>
400 </pre></div>
401 </div>
402 </dd></dl>
404 <dl class="attribute">
405 <dt id="mock.Mock.call_args">
406 <tt class="descname">call_args</tt><a class="headerlink" href="#mock.Mock.call_args" title="Permalink to this definition">¶</a></dt>
407 <dd><p>This is either <cite>None</cite> (if the mock hasn’t been called), or the
408 arguments that the mock was last called with. This will be in the
409 form of a tuple: the first member is any ordered arguments the mock
410 was called with (or an empty tuple) and the second member is any
411 keyword arguments (or an empty dictionary).</p>
412 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
413 <span class="gp">>>> </span><span class="k">print</span> <span class="n">mock</span><span class="o">.</span><span class="n">call_args</span>
414 <span class="go">None</span>
415 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
416 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args</span>
417 <span class="go">call()</span>
418 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args</span> <span class="o">==</span> <span class="p">()</span>
419 <span class="go">True</span>
420 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
421 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args</span>
422 <span class="go">call(3, 4)</span>
423 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args</span> <span class="o">==</span> <span class="p">((</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">),)</span>
424 <span class="go">True</span>
425 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="s">'fish'</span><span class="p">,</span> <span class="nb">next</span><span class="o">=</span><span class="s">'w00t!'</span><span class="p">)</span>
426 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args</span>
427 <span class="go">call(3, 4, 5, key='fish', next='w00t!')</span>
428 </pre></div>
429 </div>
430 <p><cite>call_args</cite>, along with members of the lists <a class="reference internal" href="#mock.Mock.call_args_list" title="mock.Mock.call_args_list"><tt class="xref py py-attr docutils literal"><span class="pre">call_args_list</span></tt></a>,
431 <a class="reference internal" href="#mock.Mock.method_calls" title="mock.Mock.method_calls"><tt class="xref py py-attr docutils literal"><span class="pre">method_calls</span></tt></a> and <a class="reference internal" href="#mock.Mock.mock_calls" title="mock.Mock.mock_calls"><tt class="xref py py-attr docutils literal"><span class="pre">mock_calls</span></tt></a> are <a class="reference internal" href="helpers.html#mock.call" title="mock.call"><tt class="xref py py-data docutils literal"><span class="pre">call</span></tt></a> objects.
432 These are tuples, so they can be unpacked to get at the individual
433 arguments and make more complex assertions. See
434 <a class="reference internal" href="helpers.html#calls-as-tuples"><em>calls as tuples</em></a>.</p>
435 </dd></dl>
437 <dl class="attribute">
438 <dt id="mock.Mock.call_args_list">
439 <tt class="descname">call_args_list</tt><a class="headerlink" href="#mock.Mock.call_args_list" title="Permalink to this definition">¶</a></dt>
440 <dd><p>This is a list of all the calls made to the mock object in sequence
441 (so the length of the list is the number of times it has been
442 called). Before any calls have been made it is an empty list. The
443 <a class="reference internal" href="helpers.html#mock.call" title="mock.call"><tt class="xref py py-data docutils literal"><span class="pre">call</span></tt></a> object can be used for conveniently constructing lists of
444 calls to compare with <cite>call_args_list</cite>.</p>
445 <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">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
446 <span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span>
447 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
448 <span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="n">key</span><span class="o">=</span><span class="s">'fish'</span><span class="p">,</span> <span class="nb">next</span><span class="o">=</span><span class="s">'w00t!'</span><span class="p">)</span>
449 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args_list</span>
450 <span class="go">[call(), call(3, 4), call(key='fish', next='w00t!')]</span>
451 <span class="gp">>>> </span><span class="n">expected</span> <span class="o">=</span> <span class="p">[(),</span> <span class="p">((</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">),),</span> <span class="p">({</span><span class="s">'key'</span><span class="p">:</span> <span class="s">'fish'</span><span class="p">,</span> <span class="s">'next'</span><span class="p">:</span> <span class="s">'w00t!'</span><span class="p">},)]</span>
452 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args_list</span> <span class="o">==</span> <span class="n">expected</span>
453 <span class="go">True</span>
454 </pre></div>
455 </div>
456 <p>Members of <cite>call_args_list</cite> are <a class="reference internal" href="helpers.html#mock.call" title="mock.call"><tt class="xref py py-data docutils literal"><span class="pre">call</span></tt></a> objects. These can be
457 unpacked as tuples to get at the individual arguments. See
458 <a class="reference internal" href="helpers.html#calls-as-tuples"><em>calls as tuples</em></a>.</p>
459 </dd></dl>
461 <dl class="attribute">
462 <dt id="mock.Mock.method_calls">
463 <tt class="descname">method_calls</tt><a class="headerlink" href="#mock.Mock.method_calls" title="Permalink to this definition">¶</a></dt>
464 <dd><p>As well as tracking calls to themselves, mocks also track calls to
465 methods and attributes, and <em>their</em> methods and attributes:</p>
466 <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>
467 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
468 <span class="go"><Mock name='mock.method()' id='...'></span>
469 <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="o">.</span><span class="n">attribute</span><span class="p">()</span>
470 <span class="go"><Mock name='mock.property.method.attribute()' id='...'></span>
471 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method_calls</span>
472 <span class="go">[call.method(), call.property.method.attribute()]</span>
473 </pre></div>
474 </div>
475 <p>Members of <cite>method_calls</cite> are <a class="reference internal" href="helpers.html#mock.call" title="mock.call"><tt class="xref py py-data docutils literal"><span class="pre">call</span></tt></a> objects. These can be
476 unpacked as tuples to get at the individual arguments. See
477 <a class="reference internal" href="helpers.html#calls-as-tuples"><em>calls as tuples</em></a>.</p>
478 </dd></dl>
480 <dl class="attribute">
481 <dt id="mock.Mock.mock_calls">
482 <tt class="descname">mock_calls</tt><a class="headerlink" href="#mock.Mock.mock_calls" title="Permalink to this definition">¶</a></dt>
483 <dd><p><cite>mock_calls</cite> records <em>all</em> calls to the mock object, its methods, magic
484 methods <em>and</em> return value mocks.</p>
485 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
486 <span class="gp">>>> </span><span class="n">result</span> <span class="o">=</span> <span class="n">mock</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
487 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">first</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
488 <span class="go"><MagicMock name='mock.first()' id='...'></span>
489 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">second</span><span class="p">()</span>
490 <span class="go"><MagicMock name='mock.second()' id='...'></span>
491 <span class="gp">>>> </span><span class="nb">int</span><span class="p">(</span><span class="n">mock</span><span class="p">)</span>
492 <span class="go">1</span>
493 <span class="gp">>>> </span><span class="n">result</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
494 <span class="go"><MagicMock name='mock()()' id='...'></span>
495 <span class="gp">>>> </span><span class="n">expected</span> <span class="o">=</span> <span class="p">[</span><span class="n">call</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="n">call</span><span class="o">.</span><span class="n">first</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">3</span><span class="p">),</span> <span class="n">call</span><span class="o">.</span><span class="n">second</span><span class="p">(),</span>
496 <span class="gp">... </span><span class="n">call</span><span class="o">.</span><span class="n">__int__</span><span class="p">(),</span> <span class="n">call</span><span class="p">()(</span><span class="mi">1</span><span class="p">)]</span>
497 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">mock_calls</span> <span class="o">==</span> <span class="n">expected</span>
498 <span class="go">True</span>
499 </pre></div>
500 </div>
501 <p>Members of <cite>mock_calls</cite> are <a class="reference internal" href="helpers.html#mock.call" title="mock.call"><tt class="xref py py-data docutils literal"><span class="pre">call</span></tt></a> objects. These can be
502 unpacked as tuples to get at the individual arguments. See
503 <a class="reference internal" href="helpers.html#calls-as-tuples"><em>calls as tuples</em></a>.</p>
504 </dd></dl>
506 <dl class="attribute">
507 <dt id="mock.Mock.__class__">
508 <tt class="descname">__class__</tt><a class="headerlink" href="#mock.Mock.__class__" title="Permalink to this definition">¶</a></dt>
509 <dd><p>Normally the <cite>__class__</cite> attribute of an object will return its type.
510 For a mock object with a <cite>spec</cite> <cite>__class__</cite> returns the spec class
511 instead. This allows mock objects to pass <cite>isinstance</cite> tests for the
512 object they are replacing / masquerading as:</p>
513 <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="mi">3</span><span class="p">)</span>
514 <span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="n">mock</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
515 <span class="go">True</span>
516 </pre></div>
517 </div>
518 <p><cite>__class__</cite> is assignable to, this allows a mock to pass an
519 <cite>isinstance</cite> check without forcing you to use a spec:</p>
520 <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>
521 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__class__</span> <span class="o">=</span> <span class="nb">dict</span>
522 <span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="n">mock</span><span class="p">,</span> <span class="nb">dict</span><span class="p">)</span>
523 <span class="go">True</span>
524 </pre></div>
525 </div>
526 </dd></dl>
528 </dd></dl>
530 <dl class="class">
531 <dt id="mock.NonCallableMock">
532 <em class="property">class </em><tt class="descname">NonCallableMock</tt><big>(</big><em>spec=None</em>, <em>wraps=None</em>, <em>name=None</em>, <em>spec_set=None</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.NonCallableMock" title="Permalink to this definition">¶</a></dt>
533 <dd><p>A non-callable version of <cite>Mock</cite>. The constructor parameters have the same
534 meaning of <cite>Mock</cite>, with the exception of <cite>return_value</cite> and <cite>side_effect</cite>
535 which have no meaning on a non-callable mock.</p>
536 </dd></dl>
538 <p>Mock objects that use a class or an instance as a <cite>spec</cite> or <cite>spec_set</cite> are able
539 to pass <cite>isintance</cite> tests:</p>
540 <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>
541 <span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="n">mock</span><span class="p">,</span> <span class="n">SomeClass</span><span class="p">)</span>
542 <span class="go">True</span>
543 <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_set</span><span class="o">=</span><span class="n">SomeClass</span><span class="p">())</span>
544 <span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="n">mock</span><span class="p">,</span> <span class="n">SomeClass</span><span class="p">)</span>
545 <span class="go">True</span>
546 </pre></div>
547 </div>
548 <p>The <cite>Mock</cite> classes have support for mocking magic methods. See <a class="reference internal" href="magicmock.html#magic-methods"><em>magic
549 methods</em></a> for the full details.</p>
550 <p>The mock classes and the <a class="reference internal" href="patch.html#mock.patch" title="mock.patch"><tt class="xref py py-func docutils literal"><span class="pre">patch()</span></tt></a> decorators all take arbitrary keyword
551 arguments for configuration. For the <cite>patch</cite> decorators the keywords are
552 passed to the constructor of the mock being created. The keyword arguments
553 are for configuring attributes of the mock:</p>
554 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">attribute</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">other</span><span class="o">=</span><span class="s">'fish'</span><span class="p">)</span>
555 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">attribute</span>
556 <span class="go">3</span>
557 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">other</span>
558 <span class="go">'fish'</span>
559 </pre></div>
560 </div>
561 <p>The return value and side effect of child mocks can be set in the same way,
562 using dotted notation. As you can’t use dotted names directly in a call you
563 have to create a dictionary and unpack it using <cite>**</cite>:</p>
564 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">attrs</span> <span class="o">=</span> <span class="p">{</span><span class="s">'method.return_value'</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="s">'other.side_effect'</span><span class="p">:</span> <span class="ne">KeyError</span><span class="p">}</span>
565 <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">some_attribute</span><span class="o">=</span><span class="s">'eggs'</span><span class="p">,</span> <span class="o">**</span><span class="n">attrs</span><span class="p">)</span>
566 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">some_attribute</span>
567 <span class="go">'eggs'</span>
568 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">method</span><span class="p">()</span>
569 <span class="go">3</span>
570 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">other</span><span class="p">()</span>
571 <span class="gt">Traceback (most recent call last):</span>
572 <span class="c">...</span>
573 <span class="gr">KeyError</span>
574 </pre></div>
575 </div>
576 <dl class="class">
577 <dt id="mock.PropertyMock">
578 <em class="property">class </em><tt class="descname">PropertyMock</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mock.PropertyMock" title="Permalink to this definition">¶</a></dt>
579 <dd><p>A mock intended to be used as a property, or other descriptor, on a class.
580 <cite>PropertyMock</cite> provides <cite>__get__</cite> and <cite>__set__</cite> methods so you can specify
581 a return value when it is fetched.</p>
582 <p>Fetching a <cite>PropertyMock</cite> instance from an object calls the mock, with
583 no args. Setting it calls the mock with the value being set.</p>
584 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">Foo</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
585 <span class="gp">... </span> <span class="nd">@property</span>
586 <span class="gp">... </span> <span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
587 <span class="gp">... </span> <span class="k">return</span> <span class="s">'something'</span>
588 <span class="gp">... </span> <span class="nd">@foo.setter</span>
589 <span class="gp">... </span> <span class="k">def</span> <span class="nf">foo</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
590 <span class="gp">... </span> <span class="k">pass</span>
591 <span class="gp">...</span>
592 <span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'__main__.Foo.foo'</span><span class="p">,</span> <span class="n">new_callable</span><span class="o">=</span><span class="n">PropertyMock</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_foo</span><span class="p">:</span>
593 <span class="gp">... </span> <span class="n">mock_foo</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="s">'mockity-mock'</span>
594 <span class="gp">... </span> <span class="n">this_foo</span> <span class="o">=</span> <span class="n">Foo</span><span class="p">()</span>
595 <span class="gp">... </span> <span class="k">print</span> <span class="n">this_foo</span><span class="o">.</span><span class="n">foo</span>
596 <span class="gp">... </span> <span class="n">this_foo</span><span class="o">.</span><span class="n">foo</span> <span class="o">=</span> <span class="mi">6</span>
597 <span class="gp">...</span>
598 <span class="go">mockity-mock</span>
599 <span class="gp">>>> </span><span class="n">mock_foo</span><span class="o">.</span><span class="n">mock_calls</span>
600 <span class="go">[call(), call(6)]</span>
601 </pre></div>
602 </div>
603 </dd></dl>
605 <p>Because of the way mock attributes are stored you can’t directly attach a
606 <cite>PropertyMock</cite> to a mock object. Instead you can attach it to the mock type
607 object:</p>
608 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
609 <span class="gp">>>> </span><span class="n">p</span> <span class="o">=</span> <span class="n">PropertyMock</span><span class="p">(</span><span class="n">return_value</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
610 <span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">m</span><span class="p">)</span><span class="o">.</span><span class="n">foo</span> <span class="o">=</span> <span class="n">p</span>
611 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">foo</span>
612 <span class="go">3</span>
613 <span class="gp">>>> </span><span class="n">p</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">()</span>
614 </pre></div>
615 </div>
616 <span class="target" id="index-5"></span></div>
617 <div class="section" id="calling">
618 <span id="index-6"></span><h1>Calling<a class="headerlink" href="#calling" title="Permalink to this headline">¶</a></h1>
619 <p>Mock objects are callable. The call will return the value set as the
620 <a class="reference internal" href="#mock.Mock.return_value" title="mock.Mock.return_value"><tt class="xref py py-attr docutils literal"><span class="pre">return_value</span></tt></a> attribute. The default return value is a new Mock
621 object; it is created the first time the return value is accessed (either
622 explicitly or by calling the Mock) - but it is stored and the same one
623 returned each time.</p>
624 <p>Calls made to the object will be recorded in the attributes
625 like <a class="reference internal" href="#mock.Mock.call_args" title="mock.Mock.call_args"><tt class="xref py py-attr docutils literal"><span class="pre">call_args</span></tt></a> and <a class="reference internal" href="#mock.Mock.call_args_list" title="mock.Mock.call_args_list"><tt class="xref py py-attr docutils literal"><span class="pre">call_args_list</span></tt></a>.</p>
626 <p>If <a class="reference internal" href="#mock.Mock.side_effect" title="mock.Mock.side_effect"><tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt></a> is set then it will be called after the call has
627 been recorded, so if <cite>side_effect</cite> raises an exception the call is still
628 recorded.</p>
629 <p>The simplest way to make a mock raise an exception when called is to make
630 <a class="reference internal" href="#mock.Mock.side_effect" title="mock.Mock.side_effect"><tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt></a> an exception class or instance:</p>
631 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">side_effect</span><span class="o">=</span><span class="ne">IndexError</span><span class="p">)</span>
632 <span class="gp">>>> </span><span class="n">m</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
633 <span class="gt">Traceback (most recent call last):</span>
634 <span class="c">...</span>
635 <span class="gr">IndexError</span>
636 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">mock_calls</span>
637 <span class="go">[call(1, 2, 3)]</span>
638 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s">'Bang!'</span><span class="p">)</span>
639 <span class="gp">>>> </span><span class="n">m</span><span class="p">(</span><span class="s">'two'</span><span class="p">,</span> <span class="s">'three'</span><span class="p">,</span> <span class="s">'four'</span><span class="p">)</span>
640 <span class="gt">Traceback (most recent call last):</span>
641 <span class="c">...</span>
642 <span class="gr">KeyError</span>: <span class="n">'Bang!'</span>
643 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">mock_calls</span>
644 <span class="go">[call(1, 2, 3), call('two', 'three', 'four')]</span>
645 </pre></div>
646 </div>
647 <p>If <cite>side_effect</cite> is a function then whatever that function returns is what
648 calls to the mock return. The <cite>side_effect</cite> function is called with the
649 same arguments as the mock. This allows you to vary the return value of the
650 call dynamically, based on the input:</p>
651 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">def</span> <span class="nf">side_effect</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
652 <span class="gp">... </span> <span class="k">return</span> <span class="n">value</span> <span class="o">+</span> <span class="mi">1</span>
653 <span class="gp">...</span>
654 <span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">side_effect</span><span class="o">=</span><span class="n">side_effect</span><span class="p">)</span>
655 <span class="gp">>>> </span><span class="n">m</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
656 <span class="go">2</span>
657 <span class="gp">>>> </span><span class="n">m</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
658 <span class="go">3</span>
659 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">mock_calls</span>
660 <span class="go">[call(1), call(2)]</span>
661 </pre></div>
662 </div>
663 <p>If you want the mock to still return the default return value (a new mock), or
664 any set return value, then there are two ways of doing this. Either return
665 <cite>mock.return_value</cite> from inside <cite>side_effect</cite>, or return <a class="reference internal" href="sentinel.html#mock.DEFAULT" title="mock.DEFAULT"><tt class="xref py py-data docutils literal"><span class="pre">DEFAULT</span></tt></a>:</p>
666 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
667 <span class="gp">>>> </span><span class="k">def</span> <span class="nf">side_effect</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
668 <span class="gp">... </span> <span class="k">return</span> <span class="n">m</span><span class="o">.</span><span class="n">return_value</span>
669 <span class="gp">...</span>
670 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">side_effect</span>
671 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="mi">3</span>
672 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
673 <span class="go">3</span>
674 <span class="gp">>>> </span><span class="k">def</span> <span class="nf">side_effect</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
675 <span class="gp">... </span> <span class="k">return</span> <span class="n">DEFAULT</span>
676 <span class="gp">...</span>
677 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">side_effect</span>
678 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
679 <span class="go">3</span>
680 </pre></div>
681 </div>
682 <p>To remove a <cite>side_effect</cite>, and return to the default behaviour, set the
683 <cite>side_effect</cite> to <cite>None</cite>:</p>
684 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">return_value</span><span class="o">=</span><span class="mi">6</span><span class="p">)</span>
685 <span class="gp">>>> </span><span class="k">def</span> <span class="nf">side_effect</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
686 <span class="gp">... </span> <span class="k">return</span> <span class="mi">3</span>
687 <span class="gp">...</span>
688 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">side_effect</span>
689 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
690 <span class="go">3</span>
691 <span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="bp">None</span>
692 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
693 <span class="go">6</span>
694 </pre></div>
695 </div>
696 <p>The <cite>side_effect</cite> can also be any iterable object. Repeated calls to the mock
697 will return values from the iterable (until the iterable is exhausted and
698 a <cite>StopIteration</cite> is raised):</p>
699 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">side_effect</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
700 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
701 <span class="go">1</span>
702 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
703 <span class="go">2</span>
704 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
705 <span class="go">3</span>
706 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
707 <span class="gt">Traceback (most recent call last):</span>
708 <span class="c">...</span>
709 <span class="gr">StopIteration</span>
710 </pre></div>
711 </div>
712 <p>If any members of the iterable are exceptions they will be raised instead of
713 returned:</p>
714 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iterable</span> <span class="o">=</span> <span class="p">(</span><span class="mi">33</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="mi">66</span><span class="p">)</span>
715 <span class="gp">>>> </span><span class="n">m</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">side_effect</span><span class="o">=</span><span class="n">iterable</span><span class="p">)</span>
716 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
717 <span class="go">33</span>
718 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
719 <span class="gt">Traceback (most recent call last):</span>
720 <span class="c">...</span>
721 <span class="gr">ValueError</span>
722 <span class="gp">>>> </span><span class="n">m</span><span class="p">()</span>
723 <span class="go">66</span>
724 </pre></div>
725 </div>
726 </div>
727 <div class="section" id="deleting-attributes">
728 <span id="id2"></span><h1>Deleting Attributes<a class="headerlink" href="#deleting-attributes" title="Permalink to this headline">¶</a></h1>
729 <p>Mock objects create attributes on demand. This allows them to pretend to be
730 objects of any type.</p>
731 <p>You may want a mock object to return <cite>False</cite> to a <cite>hasattr</cite> call, or raise an
732 <cite>AttributeError</cite> when an attribute is fetched. You can do this by providing
733 an object as a <cite>spec</cite> for a mock, but that isn’t always convenient.</p>
734 <p>You “block” attributes by deleting them. Once deleted, accessing an attribute
735 will raise an <cite>AttributeError</cite>.</p>
736 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
737 <span class="gp">>>> </span><span class="nb">hasattr</span><span class="p">(</span><span class="n">mock</span><span class="p">,</span> <span class="s">'m'</span><span class="p">)</span>
738 <span class="go">True</span>
739 <span class="gp">>>> </span><span class="k">del</span> <span class="n">mock</span><span class="o">.</span><span class="n">m</span>
740 <span class="gp">>>> </span><span class="nb">hasattr</span><span class="p">(</span><span class="n">mock</span><span class="p">,</span> <span class="s">'m'</span><span class="p">)</span>
741 <span class="go">False</span>
742 <span class="gp">>>> </span><span class="k">del</span> <span class="n">mock</span><span class="o">.</span><span class="n">f</span>
743 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">f</span>
744 <span class="gt">Traceback (most recent call last):</span>
745 <span class="o">...</span>
746 <span class="gr">AttributeError</span>: <span class="n">f</span>
747 </pre></div>
748 </div>
749 </div>
750 <div class="section" id="attaching-mocks-as-attributes">
751 <h1>Attaching Mocks as Attributes<a class="headerlink" href="#attaching-mocks-as-attributes" title="Permalink to this headline">¶</a></h1>
752 <p>When you attach a mock as an attribute of another mock (or as the return
753 value) it becomes a “child” of that mock. Calls to the child are recorded in
754 the <a class="reference internal" href="#mock.Mock.method_calls" title="mock.Mock.method_calls"><tt class="xref py py-attr docutils literal"><span class="pre">method_calls</span></tt></a> and <a class="reference internal" href="#mock.Mock.mock_calls" title="mock.Mock.mock_calls"><tt class="xref py py-attr docutils literal"><span class="pre">mock_calls</span></tt></a> attributes of the
755 parent. This is useful for configuring child mocks and then attaching them to
756 the parent, or for attaching mocks to a parent that records all calls to the
757 children and allows you to make assertions about the order of calls between
758 mocks:</p>
759 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">parent</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
760 <span class="gp">>>> </span><span class="n">child1</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
761 <span class="gp">>>> </span><span class="n">child2</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
762 <span class="gp">>>> </span><span class="n">parent</span><span class="o">.</span><span class="n">child1</span> <span class="o">=</span> <span class="n">child1</span>
763 <span class="gp">>>> </span><span class="n">parent</span><span class="o">.</span><span class="n">child2</span> <span class="o">=</span> <span class="n">child2</span>
764 <span class="gp">>>> </span><span class="n">child1</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
765 <span class="gp">>>> </span><span class="n">child2</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
766 <span class="gp">>>> </span><span class="n">parent</span><span class="o">.</span><span class="n">mock_calls</span>
767 <span class="go">[call.child1(1), call.child2(2)]</span>
768 </pre></div>
769 </div>
770 <p>The exception to this is if the mock has a name. This allows you to prevent
771 the “parenting” if for some reason you don’t want it to happen.</p>
772 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
773 <span class="gp">>>> </span><span class="n">not_a_child</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">'not-a-child'</span><span class="p">)</span>
774 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">attribute</span> <span class="o">=</span> <span class="n">not_a_child</span>
775 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">attribute</span><span class="p">()</span>
776 <span class="go"><MagicMock name='not-a-child()' id='...'></span>
777 <span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">mock_calls</span>
778 <span class="go">[]</span>
779 </pre></div>
780 </div>
781 <p>Mocks created for you by <a class="reference internal" href="patch.html#mock.patch" title="mock.patch"><tt class="xref py py-func docutils literal"><span class="pre">patch()</span></tt></a> are automatically given names. To
782 attach mocks that have names to a parent you use the <a class="reference internal" href="#mock.Mock.attach_mock" title="mock.Mock.attach_mock"><tt class="xref py py-meth docutils literal"><span class="pre">attach_mock()</span></tt></a>
783 method:</p>
784 <div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">thing1</span> <span class="o">=</span> <span class="nb">object</span><span class="p">()</span>
785 <span class="gp">>>> </span><span class="n">thing2</span> <span class="o">=</span> <span class="nb">object</span><span class="p">()</span>
786 <span class="gp">>>> </span><span class="n">parent</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span>
787 <span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'__main__.thing1'</span><span class="p">,</span> <span class="n">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span> <span class="k">as</span> <span class="n">child1</span><span class="p">:</span>
788 <span class="gp">... </span> <span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'__main__.thing2'</span><span class="p">,</span> <span class="n">return_value</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span> <span class="k">as</span> <span class="n">child2</span><span class="p">:</span>
789 <span class="gp">... </span> <span class="n">parent</span><span class="o">.</span><span class="n">attach_mock</span><span class="p">(</span><span class="n">child1</span><span class="p">,</span> <span class="s">'child1'</span><span class="p">)</span>
790 <span class="gp">... </span> <span class="n">parent</span><span class="o">.</span><span class="n">attach_mock</span><span class="p">(</span><span class="n">child2</span><span class="p">,</span> <span class="s">'child2'</span><span class="p">)</span>
791 <span class="gp">... </span> <span class="n">child1</span><span class="p">(</span><span class="s">'one'</span><span class="p">)</span>
792 <span class="gp">... </span> <span class="n">child2</span><span class="p">(</span><span class="s">'two'</span><span class="p">)</span>
793 <span class="gp">...</span>
794 <span class="gp">>>> </span><span class="n">parent</span><span class="o">.</span><span class="n">mock_calls</span>
795 <span class="go">[call.child1('one'), call.child2('two')]</span>
796 </pre></div>
797 </div>
798 <hr class="docutils" />
799 <table class="docutils footnote" frame="void" id="id3" rules="none">
800 <colgroup><col class="label" /><col /></colgroup>
801 <tbody valign="top">
802 <tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>The only exceptions are magic methods and attributes (those that have
803 leading and trailing double underscores). Mock doesn’t create these but
804 instead of raises an <tt class="docutils literal"><span class="pre">AttributeError</span></tt>. This is because the interpreter
805 will often implicitly request these methods, and gets <em>very</em> confused to
806 get a new Mock object when it expects a magic method. If you need magic
807 method support see <a class="reference internal" href="magicmock.html#magic-methods"><em>magic methods</em></a>.</td></tr>
808 </tbody>
809 </table>
810 </div>
813 </div>
814 </div>
815 </div>
816 <div class="sphinxsidebar">
817 <div class="sphinxsidebarwrapper">
818 <h3><a href="index.html">Table Of Contents</a></h3>
819 <ul>
820 <li><a class="reference internal" href="#">The Mock Class</a></li>
821 <li><a class="reference internal" href="#calling">Calling</a></li>
822 <li><a class="reference internal" href="#deleting-attributes">Deleting Attributes</a></li>
823 <li><a class="reference internal" href="#attaching-mocks-as-attributes">Attaching Mocks as Attributes</a></li>
824 </ul>
826 <h4>Previous topic</h4>
827 <p class="topless"><a href="index.html"
828 title="previous chapter">Mock - Mocking and Testing Library</a></p>
829 <h4>Next topic</h4>
830 <p class="topless"><a href="patch.html"
831 title="next chapter">Patch Decorators</a></p>
832 <h3>This Page</h3>
833 <ul class="this-page-menu">
834 <li><a href="_sources/mock.txt"
835 rel="nofollow">Show Source</a></li>
836 </ul>
837 <div id="searchbox" style="display: none">
838 <h3>Quick search</h3>
839 <form class="search" action="search.html" method="get">
840 <input type="text" name="q" />
841 <input type="submit" value="Go" />
842 <input type="hidden" name="check_keywords" value="yes" />
843 <input type="hidden" name="area" value="default" />
844 </form>
845 <p class="searchtip" style="font-size: 90%">
846 Enter search terms or a module, class or function name.
847 </p>
848 </div>
849 <script type="text/javascript">$('#searchbox').show(0);</script>
850 </div>
851 </div>
852 <div class="clearer"></div>
853 </div>
854 <div class="related">
855 <h3>Navigation</h3>
856 <ul>
857 <li class="right" style="margin-right: 10px">
858 <a href="genindex.html" title="General Index"
859 >index</a></li>
860 <li class="right" >
861 <a href="patch.html" title="Patch Decorators"
862 >next</a> |</li>
863 <li class="right" >
864 <a href="index.html" title="Mock - Mocking and Testing Library"
865 >previous</a> |</li>
866 <li><a href="index.html">Mock 1.0.0 documentation</a> »</li>
867 </ul>
868 </div>
869 <div class="footer">
870 © Copyright 2007-2012, Michael Foord & the mock team.
871 Last updated on Oct 07, 2012.
872 Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
873 </div>
874 </body>
875 </html>
