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