The Tor Browser / file comparison
comparison: python/mock-1.0.0/html/mock.html
python/mock-1.0.0/html/mock.html
- branch
- TOR_BUG_9701
- changeset 9
- a63d609f5ebe
equal
deleted
inserted
replaced
| -1:000000000000 | 0:2a905d3313a0 |
|---|---|
| 1 | |
| 2 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" | |
| 3 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> | |
| 4 | |
| 5 | |
| 6 <html xmlns="http://www.w3.org/1999/xhtml"> | |
| 7 <head> | |
| 8 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> | |
| 9 | |
| 10 <title>The Mock Class — Mock 1.0.0 documentation</title> | |
| 11 | |
| 12 <link rel="stylesheet" href="_static/nature.css" type="text/css" /> | |
| 13 <link rel="stylesheet" href="_static/pygments.css" type="text/css" /> | |
| 14 | |
| 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> | |
| 47 | |
| 48 <div class="document"> | |
| 49 <div class="documentwrapper"> | |
| 50 <div class="bodywrapper"> | |
| 51 <div class="body"> | |
| 52 | |
| 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> | |
| 132 | |
| 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> | |
| 149 | |
| 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> | |
| 164 | |
| 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> | |
| 187 | |
| 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> | |
| 207 | |
| 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> | |
| 216 | |
| 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> | |
| 224 | |
| 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> | |
| 259 | |
| 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> | |
| 269 | |
| 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> | |
| 280 | |
| 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> | |
| 294 | |
| 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> | |
| 309 | |
| 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> | |
| 338 | |
| 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> | |
| 403 | |
| 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> | |
| 436 | |
| 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> | |
| 460 | |
| 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> | |
| 479 | |
| 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> | |
| 505 | |
| 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> | |
| 527 | |
| 528 </dd></dl> | |
| 529 | |
| 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> | |
| 537 | |
| 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> | |
| 604 | |
| 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> | |
| 811 | |
| 812 | |
| 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> | |
| 825 | |
| 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> |
