diff options
Diffstat (limited to 'third_party/py/mock/html/examples.html')
| -rw-r--r-- | third_party/py/mock/html/examples.html | 1006 |
1 files changed, 1006 insertions, 0 deletions
diff --git a/third_party/py/mock/html/examples.html b/third_party/py/mock/html/examples.html new file mode 100644 index 0000000000..3e17247346 --- /dev/null +++ b/third_party/py/mock/html/examples.html @@ -0,0 +1,1006 @@ + +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + + +<html xmlns="http://www.w3.org/1999/xhtml"> + <head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + + <title>Further Examples — Mock 1.0.1 documentation</title> + + <link rel="stylesheet" href="_static/nature.css" type="text/css" /> + <link rel="stylesheet" href="_static/pygments.css" type="text/css" /> + + <script type="text/javascript"> + var DOCUMENTATION_OPTIONS = { + URL_ROOT: '', + VERSION: '1.0.1', + COLLAPSE_INDEX: false, + FILE_SUFFIX: '.html', + HAS_SOURCE: true + }; + </script> + <script type="text/javascript" src="_static/jquery.js"></script> + <script type="text/javascript" src="_static/underscore.js"></script> + <script type="text/javascript" src="_static/doctools.js"></script> + <link rel="top" title="Mock 1.0.1 documentation" href="index.html" /> + <link rel="next" title="Mock Library Comparison" href="compare.html" /> + <link rel="prev" title="Getting Started with Mock" href="getting-started.html" /> + </head> + <body> + <div class="related"> + <h3>Navigation</h3> + <ul> + <li class="right" style="margin-right: 10px"> + <a href="genindex.html" title="General Index" + accesskey="I">index</a></li> + <li class="right" > + <a href="compare.html" title="Mock Library Comparison" + accesskey="N">next</a> |</li> + <li class="right" > + <a href="getting-started.html" title="Getting Started with Mock" + accesskey="P">previous</a> |</li> + <li><a href="index.html">Mock 1.0.1 documentation</a> »</li> + </ul> + </div> + + <div class="document"> + <div class="documentwrapper"> + <div class="bodywrapper"> + <div class="body"> + + <div class="section" id="further-examples"> +<span id="id1"></span><h1>Further Examples<a class="headerlink" href="#further-examples" title="Permalink to this headline">¶</a></h1> +<p>For comprehensive examples, see the unit tests included in the full source +distribution.</p> +<p>Here are some more examples for some slightly more advanced scenarios than in +the <a class="reference internal" href="getting-started.html#getting-started"><em>getting started</em></a> guide.</p> +<div class="section" id="mocking-chained-calls"> +<h2>Mocking chained calls<a class="headerlink" href="#mocking-chained-calls" title="Permalink to this headline">¶</a></h2> +<p>Mocking chained calls is actually straightforward with mock once you +understand the <a class="reference internal" href="mock.html#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. When a mock is called for +the first time, or you fetch its <cite>return_value</cite> before it has been called, a +new <cite>Mock</cite> is created.</p> +<p>This means that you can see how the object returned from a call to a mocked +object has been used by interrogating the <cite>return_value</cite> mock:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span><span class="o">.</span><span class="n">foo</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span> +<span class="go"><Mock name='mock().foo()' id='...'></span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">return_value</span><span class="o">.</span><span class="n">foo</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span> +</pre></div> +</div> +<p>From here it is a simple step to configure and then make assertions about +chained calls. Of course another alternative is writing your code in a more +testable way in the first place...</p> +<p>So, suppose we have some code that looks a little bit like this:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">Something</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">backend</span> <span class="o">=</span> <span class="n">BackendProvider</span><span class="p">()</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">method</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="n">response</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">backend</span><span class="o">.</span><span class="n">get_endpoint</span><span class="p">(</span><span class="s">'foobar'</span><span class="p">)</span><span class="o">.</span><span class="n">create_call</span><span class="p">(</span><span class="s">'spam'</span><span class="p">,</span> <span class="s">'eggs'</span><span class="p">)</span><span class="o">.</span><span class="n">start_call</span><span class="p">()</span> +<span class="gp">... </span> <span class="c"># more code</span> +</pre></div> +</div> +<p>Assuming that <cite>BackendProvider</cite> is already well tested, how do we test +<cite>method()</cite>? Specifically, we want to test that the code section <cite># more +code</cite> uses the response object in the correct way.</p> +<p>As this chain of calls is made from an instance attribute we can monkey patch +the <cite>backend</cite> attribute on a <cite>Something</cite> instance. In this particular case +we are only interested in the return value from the final call to +<cite>start_call</cite> so we don’t have much configuration to do. Let’s assume the +object it returns is ‘file-like’, so we’ll ensure that our response object +uses the builtin <cite>file</cite> as its <cite>spec</cite>.</p> +<p>To do this we create a mock instance as our mock backend and create a mock +response object for it. To set the response as the return value for that final +<cite>start_call</cite> we could do this:</p> +<blockquote> +<div><cite>mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response</cite>.</div></blockquote> +<p>We can do that in a slightly nicer way using the <a class="reference internal" href="mock.html#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 to directly set the return value for us:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">something</span> <span class="o">=</span> <span class="n">Something</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock_response</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="nb">file</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock_backend</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">config</span> <span class="o">=</span> <span class="p">{</span><span class="s">'get_endpoint.return_value.create_call.return_value.start_call.return_value'</span><span class="p">:</span> <span class="n">mock_response</span><span class="p">}</span> +<span class="gp">>>> </span><span class="n">mock_backend</span><span class="o">.</span><span class="n">configure_mock</span><span class="p">(</span><span class="o">**</span><span class="n">config</span><span class="p">)</span> +</pre></div> +</div> +<p>With these we monkey patch the “mock backend” in place and can make the real +call:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">something</span><span class="o">.</span><span class="n">backend</span> <span class="o">=</span> <span class="n">mock_backend</span> +<span class="gp">>>> </span><span class="n">something</span><span class="o">.</span><span class="n">method</span><span class="p">()</span> +</pre></div> +</div> +<p>Using <a class="reference internal" href="mock.html#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> we can check the chained call with a single +assert. A chained call is several calls in one line of code, so there will be +several entries in <cite>mock_calls</cite>. We can use <a class="reference internal" href="helpers.html#mock.call.call_list" title="mock.call.call_list"><tt class="xref py py-meth docutils literal"><span class="pre">call.call_list()</span></tt></a> to create +this list of calls for us:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">chained</span> <span class="o">=</span> <span class="n">call</span><span class="o">.</span><span class="n">get_endpoint</span><span class="p">(</span><span class="s">'foobar'</span><span class="p">)</span><span class="o">.</span><span class="n">create_call</span><span class="p">(</span><span class="s">'spam'</span><span class="p">,</span> <span class="s">'eggs'</span><span class="p">)</span><span class="o">.</span><span class="n">start_call</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">call_list</span> <span class="o">=</span> <span class="n">chained</span><span class="o">.</span><span class="n">call_list</span><span class="p">()</span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="n">mock_backend</span><span class="o">.</span><span class="n">mock_calls</span> <span class="o">==</span> <span class="n">call_list</span> +</pre></div> +</div> +</div> +<div class="section" id="partial-mocking"> +<h2>Partial mocking<a class="headerlink" href="#partial-mocking" title="Permalink to this headline">¶</a></h2> +<p>In some tests I wanted to mock out a call to <a class="reference external" href="http://docs.python.org/library/datetime.html#datetime.date.today">datetime.date.today()</a> to return +a known date, but I didn’t want to prevent the code under test from +creating new date objects. Unfortunately <cite>datetime.date</cite> is written in C, and +so I couldn’t just monkey-patch out the static <cite>date.today</cite> method.</p> +<p>I found a simple way of doing this that involved effectively wrapping the date +class with a mock, but passing through calls to the constructor to the real +class (and returning real instances).</p> +<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> <span class="pre">decorator</span></tt></a> is used here to +mock out the <cite>date</cite> class in the module under test. The <tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt> +attribute on the mock date class is then set to a lambda function that returns +a real date. When the mock date class is called a real date will be +constructed and returned by <cite>side_effect</cite>.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">datetime</span> <span class="kn">import</span> <span class="n">date</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.date'</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_date</span><span class="p">:</span> +<span class="gp">... </span> <span class="n">mock_date</span><span class="o">.</span><span class="n">today</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="n">date</span><span class="p">(</span><span class="mi">2010</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">8</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">mock_date</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="k">lambda</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">:</span> <span class="n">date</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">kw</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">date</span><span class="o">.</span><span class="n">today</span><span class="p">()</span> <span class="o">==</span> <span class="n">date</span><span class="p">(</span><span class="mi">2010</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">8</span><span class="p">)</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">2009</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">8</span><span class="p">)</span> <span class="o">==</span> <span class="n">date</span><span class="p">(</span><span class="mi">2009</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">8</span><span class="p">)</span> +<span class="gp">...</span> +</pre></div> +</div> +<p>Note that we don’t patch <cite>datetime.date</cite> globally, we patch <cite>date</cite> in the +module that <em>uses</em> it. See <a class="reference internal" href="patch.html#where-to-patch"><em>where to patch</em></a>.</p> +<p>When <cite>date.today()</cite> is called a known date is returned, but calls to the +<cite>date(...)</cite> constructor still return normal dates. Without this you can find +yourself having to calculate an expected result using exactly the same +algorithm as the code under test, which is a classic testing anti-pattern.</p> +<p>Calls to the date constructor are recorded in the <cite>mock_date</cite> attributes +(<cite>call_count</cite> and friends) which may also be useful for your tests.</p> +<p>An alternative way of dealing with mocking dates, or other builtin classes, +is discussed in <a class="reference external" href="http://williamjohnbert.com/2011/07/how-to-unit-testing-in-django-with-mocking-and-patching/">this blog entry</a>.</p> +</div> +<div class="section" id="mocking-a-generator-method"> +<h2>Mocking a Generator Method<a class="headerlink" href="#mocking-a-generator-method" title="Permalink to this headline">¶</a></h2> +<p>A Python generator is a function or method that uses the <a class="reference external" href="http://docs.python.org/reference/simple_stmts.html#the-yield-statement">yield statement</a> to +return a series of values when iterated over <a class="footnote-reference" href="#id3" id="id2">[1]</a>.</p> +<p>A generator method / function is called to return the generator object. It is +the generator object that is then iterated over. The protocol method for +iteration is <a class="reference external" href="http://docs.python.org/library/stdtypes.html#container.__iter__">__iter__</a>, so we can +mock this using a <cite>MagicMock</cite>.</p> +<p>Here’s an example class with an “iter” method implemented as a generator:</p> +<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> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">iter</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</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="gp">... </span> <span class="k">yield</span> <span class="n">i</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">foo</span> <span class="o">=</span> <span class="n">Foo</span><span class="p">()</span> +<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">foo</span><span class="o">.</span><span class="n">iter</span><span class="p">())</span> +<span class="go">[1, 2, 3]</span> +</pre></div> +</div> +<p>How would we mock this class, and in particular its “iter” method?</p> +<p>To configure the values returned from the iteration (implicit in the call to +<cite>list</cite>), we need to configure the object returned by the call to <cite>foo.iter()</cite>.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock_foo</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock_foo</span><span class="o">.</span><span class="n">iter</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="nb">iter</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="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">mock_foo</span><span class="o">.</span><span class="n">iter</span><span class="p">())</span> +<span class="go">[1, 2, 3]</span> +</pre></div> +</div> +<table class="docutils footnote" frame="void" id="id3" rules="none"> +<colgroup><col class="label" /><col /></colgroup> +<tbody valign="top"> +<tr><td class="label"><a class="fn-backref" href="#id2">[1]</a></td><td>There are also generator expressions and more <a class="reference external" href="http://www.dabeaz.com/coroutines/index.html">advanced uses</a> of generators, but we aren’t +concerned about them here. A very good introduction to generators and how +powerful they are is: <a class="reference external" href="http://www.dabeaz.com/generators/">Generator Tricks for Systems Programmers</a>.</td></tr> +</tbody> +</table> +</div> +<div class="section" id="applying-the-same-patch-to-every-test-method"> +<h2>Applying the same patch to every test method<a class="headerlink" href="#applying-the-same-patch-to-every-test-method" title="Permalink to this headline">¶</a></h2> +<p>If you want several patches in place for multiple test methods the obvious way +is to apply the patch decorators to every method. This can feel like unnecessary +repetition. For Python 2.6 or more recent you can use <cite>patch</cite> (in all its +various forms) as a class decorator. This applies the patches to all test +methods on the class. A test method is identified by methods whose names start +with <cite>test</cite>:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nd">@patch</span><span class="p">(</span><span class="s">'mymodule.SomeClass'</span><span class="p">)</span> +<span class="gp">... </span><span class="k">class</span> <span class="nc">MyTest</span><span class="p">(</span><span class="n">TestCase</span><span class="p">):</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">test_one</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">MockSomeClass</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mymodule</span><span class="o">.</span><span class="n">SomeClass</span> <span class="ow">is</span> <span class="n">MockSomeClass</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">test_two</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">MockSomeClass</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mymodule</span><span class="o">.</span><span class="n">SomeClass</span> <span class="ow">is</span> <span class="n">MockSomeClass</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">not_a_test</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="s">'something'</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_one'</span><span class="p">)</span><span class="o">.</span><span class="n">test_one</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_two'</span><span class="p">)</span><span class="o">.</span><span class="n">test_two</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_two'</span><span class="p">)</span><span class="o">.</span><span class="n">not_a_test</span><span class="p">()</span> +<span class="go">'something'</span> +</pre></div> +</div> +<p>An alternative way of managing patches is to use the <a class="reference internal" href="patch.html#start-and-stop"><em>patch methods: start and stop</em></a>. +These allow you to move the patching into your <cite>setUp</cite> and <cite>tearDown</cite> methods.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">MyTest</span><span class="p">(</span><span class="n">TestCase</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">setUp</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">patcher</span> <span class="o">=</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.foo'</span><span class="p">)</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">mock_foo</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">patcher</span><span class="o">.</span><span class="n">start</span><span class="p">()</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">test_foo</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mymodule</span><span class="o">.</span><span class="n">foo</span> <span class="ow">is</span> <span class="bp">self</span><span class="o">.</span><span class="n">mock_foo</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">tearDown</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">patcher</span><span class="o">.</span><span class="n">stop</span><span class="p">()</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_foo'</span><span class="p">)</span><span class="o">.</span><span class="n">run</span><span class="p">()</span> +</pre></div> +</div> +<p>If you use this technique you must ensure that the patching is “undone” by +calling <cite>stop</cite>. This can be fiddlier than you might think, because if an +exception is raised in the setUp then tearDown is not called. <a class="reference external" href="http://pypi.python.org/pypi/unittest2">unittest2</a> cleanup functions make this simpler:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">MyTest</span><span class="p">(</span><span class="n">TestCase</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">setUp</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="n">patcher</span> <span class="o">=</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.foo'</span><span class="p">)</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">addCleanup</span><span class="p">(</span><span class="n">patcher</span><span class="o">.</span><span class="n">stop</span><span class="p">)</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">mock_foo</span> <span class="o">=</span> <span class="n">patcher</span><span class="o">.</span><span class="n">start</span><span class="p">()</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">test_foo</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">assertTrue</span><span class="p">(</span><span class="n">mymodule</span><span class="o">.</span><span class="n">foo</span> <span class="ow">is</span> <span class="bp">self</span><span class="o">.</span><span class="n">mock_foo</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_foo'</span><span class="p">)</span><span class="o">.</span><span class="n">run</span><span class="p">()</span> +</pre></div> +</div> +</div> +<div class="section" id="mocking-unbound-methods"> +<h2>Mocking Unbound Methods<a class="headerlink" href="#mocking-unbound-methods" title="Permalink to this headline">¶</a></h2> +<p>Whilst writing tests today I needed to patch an <em>unbound method</em> (patching the +method on the class rather than on the instance). I needed self to be passed +in as the first argument because I want to make asserts about which objects +were calling this particular method. The issue is that you can’t patch with a +mock for this, because if you replace an unbound method with a mock it doesn’t +become a bound method when fetched from the instance, and so it doesn’t get +self passed in. The workaround is to patch the unbound method with a real +function instead. 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> decorator makes it so simple to +patch out methods with a mock that having to create a real function becomes a +nuisance.</p> +<p>If you pass <cite>autospec=True</cite> to patch then it does the patching with a +<em>real</em> function object. This function object has the same signature as the one +it is replacing, but delegates to a mock under the hood. You still get your +mock auto-created in exactly the same way as before. What it means though, is +that if you use it to patch out an unbound method on a class the mocked +function will be turned into a bound method if it is fetched from an instance. +It will have <cite>self</cite> passed in as the first argument, which is exactly what I +wanted:</p> +<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> +<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="gp">... </span> <span class="k">pass</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="o">.</span><span class="n">object</span><span class="p">(</span><span class="n">Foo</span><span class="p">,</span> <span class="s">'foo'</span><span class="p">,</span> <span class="n">autospec</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_foo</span><span class="p">:</span> +<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">'foo'</span> +<span class="gp">... </span> <span class="n">foo</span> <span class="o">=</span> <span class="n">Foo</span><span class="p">()</span> +<span class="gp">... </span> <span class="n">foo</span><span class="o">.</span><span class="n">foo</span><span class="p">()</span> +<span class="gp">...</span> +<span class="go">'foo'</span> +<span class="gp">>>> </span><span class="n">mock_foo</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">(</span><span class="n">foo</span><span class="p">)</span> +</pre></div> +</div> +<p>If we don’t use <cite>autospec=True</cite> then the unbound method is patched out +with a Mock instance instead, and isn’t called with <cite>self</cite>.</p> +</div> +<div class="section" id="checking-multiple-calls-with-mock"> +<h2>Checking multiple calls with mock<a class="headerlink" href="#checking-multiple-calls-with-mock" title="Permalink to this headline">¶</a></h2> +<p>mock has a nice API for making assertions about how your mock objects are used.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">foo_bar</span><span class="o">.</span><span class="n">return_value</span> <span class="o">=</span> <span class="bp">None</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">foo_bar</span><span class="p">(</span><span class="s">'baz'</span><span class="p">,</span> <span class="n">spam</span><span class="o">=</span><span class="s">'eggs'</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">foo_bar</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="s">'baz'</span><span class="p">,</span> <span class="n">spam</span><span class="o">=</span><span class="s">'eggs'</span><span class="p">)</span> +</pre></div> +</div> +<p>If your mock is only being called once you can use the +<tt class="xref py py-meth docutils literal"><span class="pre">assert_called_once_with()</span></tt> method that also asserts that the +<tt class="xref py py-attr docutils literal"><span class="pre">call_count</span></tt> is one.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">foo_bar</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">(</span><span class="s">'baz'</span><span class="p">,</span> <span class="n">spam</span><span class="o">=</span><span class="s">'eggs'</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">foo_bar</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">foo_bar</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">(</span><span class="s">'baz'</span><span class="p">,</span> <span class="n">spam</span><span class="o">=</span><span class="s">'eggs'</span><span class="p">)</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">AssertionError</span>: <span class="n">Expected to be called once. Called 2 times.</span> +</pre></div> +</div> +<p>Both <cite>assert_called_with</cite> and <cite>assert_called_once_with</cite> make assertions about +the <em>most recent</em> call. If your mock is going to be called several times, and +you want to make assertions about <em>all</em> those calls you can use +<a class="reference internal" href="mock.html#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> +<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> +<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="mi">3</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock</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="mi">6</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">call_args_list</span> +<span class="go">[call(1, 2, 3), call(4, 5, 6), call()]</span> +</pre></div> +</div> +<p>The <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> helper makes it easy to make assertions about these calls. You +can build up a list of expected calls and compare it to <cite>call_args_list</cite>. This +looks remarkably similar to the repr of the <cite>call_args_list</cite>:</p> +<div class="highlight-python"><div class="highlight"><pre><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="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">),</span> <span class="n">call</span><span class="p">()]</span> +<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> +<span class="go">True</span> +</pre></div> +</div> +</div> +<div class="section" id="coping-with-mutable-arguments"> +<h2>Coping with mutable arguments<a class="headerlink" href="#coping-with-mutable-arguments" title="Permalink to this headline">¶</a></h2> +<p>Another situation is rare, but can bite you, is when your mock is called with +mutable arguments. <cite>call_args</cite> and <cite>call_args_list</cite> store <em>references</em> to the +arguments. If the arguments are mutated by the code under test then you can no +longer make assertions about what the values were when the mock was called.</p> +<p>Here’s some example code that shows the problem. Imagine the following functions +defined in ‘mymodule’:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">frob</span><span class="p">(</span><span class="n">val</span><span class="p">):</span> + <span class="k">pass</span> + +<span class="k">def</span> <span class="nf">grob</span><span class="p">(</span><span class="n">val</span><span class="p">):</span> + <span class="s">"First frob and then clear val"</span> + <span class="n">frob</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> + <span class="n">val</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span> +</pre></div> +</div> +<p>When we try to test that <cite>grob</cite> calls <cite>frob</cite> with the correct argument look +what happens:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.frob'</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_frob</span><span class="p">:</span> +<span class="gp">... </span> <span class="n">val</span> <span class="o">=</span> <span class="nb">set</span><span class="p">([</span><span class="mi">6</span><span class="p">])</span> +<span class="gp">... </span> <span class="n">mymodule</span><span class="o">.</span><span class="n">grob</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">val</span> +<span class="go">set([])</span> +<span class="gp">>>> </span><span class="n">mock_frob</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="nb">set</span><span class="p">([</span><span class="mi">6</span><span class="p">]))</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">AssertionError: Expected</span>: <span class="n">((set([6]),), {})</span> +<span class="go">Called with: ((set([]),), {})</span> +</pre></div> +</div> +<p>One possibility would be for mock to copy the arguments you pass in. This +could then cause problems if you do assertions that rely on object identity +for equality.</p> +<p>Here’s one solution that uses the <tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt> +functionality. If you provide a <cite>side_effect</cite> function for a mock then +<cite>side_effect</cite> will be called with the same args as the mock. This gives us an +opportunity to copy the arguments and store them for later assertions. In this +example I’m using <em>another</em> mock to store the arguments so that I can use the +mock methods for doing the assertion. Again a helper function sets this up for +me.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">copy</span> <span class="kn">import</span> <span class="n">deepcopy</span> +<span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mock</span> <span class="kn">import</span> <span class="n">Mock</span><span class="p">,</span> <span class="n">patch</span><span class="p">,</span> <span class="n">DEFAULT</span> +<span class="gp">>>> </span><span class="k">def</span> <span class="nf">copy_call_args</span><span class="p">(</span><span class="n">mock</span><span class="p">):</span> +<span class="gp">... </span> <span class="n">new_mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<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> +<span class="gp">... </span> <span class="n">args</span> <span class="o">=</span> <span class="n">deepcopy</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">kwargs</span> <span class="o">=</span> <span class="n">deepcopy</span><span class="p">(</span><span class="n">kwargs</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">new_mock</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> +<span class="gp">... </span> <span class="k">return</span> <span class="n">DEFAULT</span> +<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> +<span class="gp">... </span> <span class="k">return</span> <span class="n">new_mock</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.frob'</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_frob</span><span class="p">:</span> +<span class="gp">... </span> <span class="n">new_mock</span> <span class="o">=</span> <span class="n">copy_call_args</span><span class="p">(</span><span class="n">mock_frob</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">val</span> <span class="o">=</span> <span class="nb">set</span><span class="p">([</span><span class="mi">6</span><span class="p">])</span> +<span class="gp">... </span> <span class="n">mymodule</span><span class="o">.</span><span class="n">grob</span><span class="p">(</span><span class="n">val</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">new_mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="nb">set</span><span class="p">([</span><span class="mi">6</span><span class="p">]))</span> +<span class="gp">>>> </span><span class="n">new_mock</span><span class="o">.</span><span class="n">call_args</span> +<span class="go">call(set([6]))</span> +</pre></div> +</div> +<p><cite>copy_call_args</cite> is called with the mock that will be called. It returns a new +mock that we do the assertion on. The <cite>side_effect</cite> function makes a copy of +the args and calls our <cite>new_mock</cite> with the copy.</p> +<div class="admonition note"> +<p class="first admonition-title">Note</p> +<p>If your mock is only going to be used once there is an easier way of +checking arguments at the point they are called. You can simply do the +checking inside a <cite>side_effect</cite> function.</p> +<div class="last 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">arg</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">arg</span> <span class="o">==</span> <span class="nb">set</span><span class="p">([</span><span class="mi">6</span><span class="p">])</span> +<span class="gp">...</span> +<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> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="nb">set</span><span class="p">([</span><span class="mi">6</span><span class="p">]))</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="nb">set</span><span class="p">())</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">AssertionError</span> +</pre></div> +</div> +</div> +<p>An alternative approach is to create a subclass of <cite>Mock</cite> or <cite>MagicMock</cite> that +copies (using <a class="reference external" href="http://docs.python.org/library/copy.html#copy.deepcopy">copy.deepcopy</a>) the arguments. +Here’s an example implementation:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">copy</span> <span class="kn">import</span> <span class="n">deepcopy</span> +<span class="gp">>>> </span><span class="k">class</span> <span class="nc">CopyingMock</span><span class="p">(</span><span class="n">MagicMock</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</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> +<span class="gp">... </span> <span class="n">args</span> <span class="o">=</span> <span class="n">deepcopy</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">kwargs</span> <span class="o">=</span> <span class="n">deepcopy</span><span class="p">(</span><span class="n">kwargs</span><span class="p">)</span> +<span class="gp">... </span> <span class="k">return</span> <span class="nb">super</span><span class="p">(</span><span class="n">CopyingMock</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">__call__</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> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">c</span> <span class="o">=</span> <span class="n">CopyingMock</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="gp">>>> </span><span class="n">arg</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">c</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">arg</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">c</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="nb">set</span><span class="p">())</span> +<span class="gp">>>> </span><span class="n">c</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">AssertionError: Expected call</span>: <span class="n">mock(set([1]))</span> +<span class="go">Actual call: mock(set([]))</span> +<span class="gp">>>> </span><span class="n">c</span><span class="o">.</span><span class="n">foo</span> +<span class="go"><CopyingMock name='mock.foo' id='...'></span> +</pre></div> +</div> +<p>When you subclass <cite>Mock</cite> or <cite>MagicMock</cite> all dynamically created attributes, +and the <cite>return_value</cite> will use your subclass automatically. That means all +children of a <cite>CopyingMock</cite> will also have the type <cite>CopyingMock</cite>.</p> +</div> +<div class="section" id="raising-exceptions-on-attribute-access"> +<h2>Raising exceptions on attribute access<a class="headerlink" href="#raising-exceptions-on-attribute-access" title="Permalink to this headline">¶</a></h2> +<p>You can use <a class="reference internal" href="mock.html#mock.PropertyMock" title="mock.PropertyMock"><tt class="xref py py-class docutils literal"><span class="pre">PropertyMock</span></tt></a> to mimic the behaviour of properties. This +includes raising exceptions when an attribute is accessed.</p> +<p>Here’s an example raising a <cite>ValueError</cite> when the ‘foo’ attribute is accessed:</p> +<div class="highlight-python"><pre>>>> m = MagicMock() +>>> p = PropertyMock(side_effect=ValueError) +>>> type(m).foo = p +>>> m.foo +Traceback (most recent call last): +.... +ValueError</pre> +</div> +<p>Because every mock object has its own type, a new subclass of whichever mock +class you’re using, all mock objects are isolated from each other. You can +safely attach properties (or other descriptors or whatever you want in fact) +to <cite>type(mock)</cite> without affecting other mock objects.</p> +</div> +<div class="section" id="multiple-calls-with-different-effects"> +<h2>Multiple calls with different effects<a class="headerlink" href="#multiple-calls-with-different-effects" title="Permalink to this headline">¶</a></h2> +<div class="admonition note"> +<p class="first admonition-title">Note</p> +<p class="last">In mock 1.0 the handling of iterable <cite>side_effect</cite> was changed. Any +exceptions in the iterable will be raised instead of returned.</p> +</div> +<p>Handling code that needs to behave differently on subsequent calls during the +test can be tricky. For example you may have a function that needs to raise +an exception the first time it is called but returns a response on the second +call (testing retry behaviour).</p> +<p>One approach is to use a <tt class="xref py py-attr docutils literal"><span class="pre">side_effect</span></tt> function that replaces itself. The +first time it is called the <cite>side_effect</cite> sets a new <cite>side_effect</cite> that will +be used for the second call. It then raises an exception:</p> +<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="o">*</span><span class="n">args</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">second_call</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="s">'response'</span> +<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">second_call</span> +<span class="gp">... </span> <span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s">'boom'</span><span class="p">)</span> +<span class="gp">...</span> +<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> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'first'</span><span class="p">)</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">Exception</span>: <span class="n">boom</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'second'</span><span class="p">)</span> +<span class="go">'response'</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="s">'second'</span><span class="p">)</span> +</pre></div> +</div> +<p>Another perfectly valid way would be to pop return values from a list. If the +return value is an exception, raise it instead of returning it:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">returns</span> <span class="o">=</span> <span class="p">[</span><span class="ne">Exception</span><span class="p">(</span><span class="s">'boom'</span><span class="p">),</span> <span class="s">'response'</span><span class="p">]</span> +<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="gp">... </span> <span class="n">result</span> <span class="o">=</span> <span class="n">returns</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> +<span class="gp">... </span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="ne">Exception</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">raise</span> <span class="n">result</span> +<span class="gp">... </span> <span class="k">return</span> <span class="n">result</span> +<span class="gp">...</span> +<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> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'first'</span><span class="p">)</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">Exception</span>: <span class="n">boom</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="s">'second'</span><span class="p">)</span> +<span class="go">'response'</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="s">'second'</span><span class="p">)</span> +</pre></div> +</div> +<p>Which approach you prefer is a matter of taste. The first approach is actually +a line shorter but maybe the second approach is more readable.</p> +</div> +<div class="section" id="nesting-patches"> +<h2>Nesting Patches<a class="headerlink" href="#nesting-patches" title="Permalink to this headline">¶</a></h2> +<p>Using patch as a context manager is nice, but if you do multiple patches you +can end up with nested with statements indenting further and further to the +right:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">MyTest</span><span class="p">(</span><span class="n">TestCase</span><span class="p">):</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">test_foo</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.Foo'</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_foo</span><span class="p">:</span> +<span class="gp">... </span> <span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.Bar'</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_bar</span><span class="p">:</span> +<span class="gp">... </span> <span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.Spam'</span><span class="p">)</span> <span class="k">as</span> <span class="n">mock_spam</span><span class="p">:</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Foo</span> <span class="ow">is</span> <span class="n">mock_foo</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Bar</span> <span class="ow">is</span> <span class="n">mock_bar</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Spam</span> <span class="ow">is</span> <span class="n">mock_spam</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">original</span> <span class="o">=</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Foo</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_foo'</span><span class="p">)</span><span class="o">.</span><span class="n">test_foo</span><span class="p">()</span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Foo</span> <span class="ow">is</span> <span class="n">original</span> +</pre></div> +</div> +<p>With <a class="reference external" href="http://pypi.python.org/pypi/unittest2">unittest2</a> <cite>cleanup</cite> functions and the <a class="reference internal" href="patch.html#start-and-stop"><em>patch methods: start and stop</em></a> we can +achieve the same effect without the nested indentation. A simple helper +method, <cite>create_patch</cite>, puts the patch in place and returns the created mock +for us:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">MyTest</span><span class="p">(</span><span class="n">TestCase</span><span class="p">):</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">create_patch</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span> +<span class="gp">... </span> <span class="n">patcher</span> <span class="o">=</span> <span class="n">patch</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">thing</span> <span class="o">=</span> <span class="n">patcher</span><span class="o">.</span><span class="n">start</span><span class="p">()</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">addCleanup</span><span class="p">(</span><span class="n">patcher</span><span class="o">.</span><span class="n">stop</span><span class="p">)</span> +<span class="gp">... </span> <span class="k">return</span> <span class="n">thing</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">test_foo</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="n">mock_foo</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">create_patch</span><span class="p">(</span><span class="s">'mymodule.Foo'</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">mock_bar</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">create_patch</span><span class="p">(</span><span class="s">'mymodule.Bar'</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">mock_spam</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">create_patch</span><span class="p">(</span><span class="s">'mymodule.Spam'</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Foo</span> <span class="ow">is</span> <span class="n">mock_foo</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Bar</span> <span class="ow">is</span> <span class="n">mock_bar</span> +<span class="gp">... </span> <span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Spam</span> <span class="ow">is</span> <span class="n">mock_spam</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">original</span> <span class="o">=</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Foo</span> +<span class="gp">>>> </span><span class="n">MyTest</span><span class="p">(</span><span class="s">'test_foo'</span><span class="p">)</span><span class="o">.</span><span class="n">run</span><span class="p">()</span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="n">mymodule</span><span class="o">.</span><span class="n">Foo</span> <span class="ow">is</span> <span class="n">original</span> +</pre></div> +</div> +</div> +<div class="section" id="mocking-a-dictionary-with-magicmock"> +<h2>Mocking a dictionary with MagicMock<a class="headerlink" href="#mocking-a-dictionary-with-magicmock" title="Permalink to this headline">¶</a></h2> +<p>You may want to mock a dictionary, or other container object, recording all +access to it whilst having it still behave like a dictionary.</p> +<p>We can do this with <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>, which will behave like a dictionary, +and using <a class="reference internal" href="mock.html#mock.Mock.side_effect" title="mock.Mock.side_effect"><tt class="xref py py-data docutils literal"><span class="pre">side_effect</span></tt></a> to delegate dictionary access to a real +underlying dictionary that is under our control.</p> +<p>When the <cite>__getitem__</cite> and <cite>__setitem__</cite> methods of our <cite>MagicMock</cite> are called +(normal dictionary access) then <cite>side_effect</cite> is called with the key (and in +the case of <cite>__setitem__</cite> the value too). We can also control what is returned.</p> +<p>After the <cite>MagicMock</cite> has been used we can use attributes like +<a class="reference internal" href="mock.html#mock.Mock.call_args_list" title="mock.Mock.call_args_list"><tt class="xref py py-data docutils literal"><span class="pre">call_args_list</span></tt></a> to assert about how the dictionary was used:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">my_dict</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">'b'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">'c'</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span> +<span class="gp">>>> </span><span class="k">def</span> <span class="nf">getitem</span><span class="p">(</span><span class="n">name</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="n">my_dict</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="k">def</span> <span class="nf">setitem</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">val</span><span class="p">):</span> +<span class="gp">... </span> <span class="n">my_dict</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">val</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__getitem__</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">getitem</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__setitem__</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">setitem</span> +</pre></div> +</div> +<div class="admonition note"> +<p class="first admonition-title">Note</p> +<p>An alternative to using <cite>MagicMock</cite> is to use <cite>Mock</cite> and <em>only</em> provide +the magic methods you specifically want:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__setitem__</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">getitem</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__getitem__</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">setitem</span><span class="p">)</span> +</pre></div> +</div> +<p>A <em>third</em> option is to use <cite>MagicMock</cite> but passing in <cite>dict</cite> as the <cite>spec</cite> +(or <cite>spec_set</cite>) argument so that the <cite>MagicMock</cite> created only has +dictionary magic methods available:</p> +<div class="last 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><span class="n">spec_set</span><span class="o">=</span><span class="nb">dict</span><span class="p">)</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__getitem__</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">getitem</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__setitem__</span><span class="o">.</span><span class="n">side_effect</span> <span class="o">=</span> <span class="n">setitem</span> +</pre></div> +</div> +</div> +<p>With these side effect functions in place, the <cite>mock</cite> will behave like a normal +dictionary but recording the access. It even raises a <cite>KeyError</cite> if you try +to access a key that doesn’t exist.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'a'</span><span class="p">]</span> +<span class="go">1</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'c'</span><span class="p">]</span> +<span class="go">3</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'d'</span><span class="p">]</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">KeyError</span>: <span class="n">'d'</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'b'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'fish'</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'d'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'eggs'</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'b'</span><span class="p">]</span> +<span class="go">'fish'</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">[</span><span class="s">'d'</span><span class="p">]</span> +<span class="go">'eggs'</span> +</pre></div> +</div> +<p>After it has been used you can make assertions about the access using the normal +mock methods and attributes:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__getitem__</span><span class="o">.</span><span class="n">call_args_list</span> +<span class="go">[call('a'), call('c'), call('d'), call('b'), call('d')]</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">__setitem__</span><span class="o">.</span><span class="n">call_args_list</span> +<span class="go">[call('b', 'fish'), call('d', 'eggs')]</span> +<span class="gp">>>> </span><span class="n">my_dict</span> +<span class="go">{'a': 1, 'c': 3, 'b': 'fish', 'd': 'eggs'}</span> +</pre></div> +</div> +</div> +<div class="section" id="mock-subclasses-and-their-attributes"> +<h2>Mock subclasses and their attributes<a class="headerlink" href="#mock-subclasses-and-their-attributes" title="Permalink to this headline">¶</a></h2> +<p>There are various reasons why you might want to subclass <cite>Mock</cite>. One reason +might be to add helper methods. Here’s a silly example:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">MyMock</span><span class="p">(</span><span class="n">MagicMock</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">has_been_called</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">called</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">mymock</span> <span class="o">=</span> <span class="n">MyMock</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="gp">>>> </span><span class="n">mymock</span> +<span class="go"><MyMock id='...'></span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">has_been_called</span><span class="p">()</span> +<span class="go">False</span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">has_been_called</span><span class="p">()</span> +<span class="go">True</span> +</pre></div> +</div> +<p>The standard behaviour for <cite>Mock</cite> instances is that attributes and the return +value mocks are of the same type as the mock they are accessed on. This ensures +that <cite>Mock</cite> attributes are <cite>Mocks</cite> and <cite>MagicMock</cite> attributes are <cite>MagicMocks</cite> +<a class="footnote-reference" href="#id5" id="id4">[2]</a>. So if you’re subclassing to add helper methods then they’ll also be +available on the attributes and return value mock of instances of your +subclass.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">foo</span> +<span class="go"><MyMock name='mock.foo' id='...'></span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">foo</span><span class="o">.</span><span class="n">has_been_called</span><span class="p">()</span> +<span class="go">False</span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">foo</span><span class="p">()</span> +<span class="go"><MyMock name='mock.foo()' id='...'></span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">foo</span><span class="o">.</span><span class="n">has_been_called</span><span class="p">()</span> +<span class="go">True</span> +</pre></div> +</div> +<p>Sometimes this is inconvenient. For example, <a class="reference external" href="https://code.google.com/p/mock/issues/detail?id=105">one user</a> is subclassing mock to +created a <a class="reference external" href="http://twistedmatrix.com/documents/11.0.0/api/twisted.python.components.html">Twisted adaptor</a>. +Having this applied to attributes too actually causes errors.</p> +<p><cite>Mock</cite> (in all its flavours) uses a method called <cite>_get_child_mock</cite> to create +these “sub-mocks” for attributes and return values. You can prevent your +subclass being used for attributes by overriding this method. The signature is +that it takes arbitrary keyword arguments (<cite>**kwargs</cite>) which are then passed +onto the mock constructor:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">Subclass</span><span class="p">(</span><span class="n">MagicMock</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">_get_child_mock</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="n">MagicMock</span><span class="p">(</span><span class="o">**</span><span class="n">kwargs</span><span class="p">)</span> +<span class="gp">...</span> +<span class="gp">>>> </span><span class="n">mymock</span> <span class="o">=</span> <span class="n">Subclass</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mymock</span><span class="o">.</span><span class="n">foo</span> +<span class="go"><MagicMock name='mock.foo' id='...'></span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mymock</span><span class="p">,</span> <span class="n">Subclass</span><span class="p">)</span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mymock</span><span class="o">.</span><span class="n">foo</span><span class="p">,</span> <span class="n">Subclass</span><span class="p">)</span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mymock</span><span class="p">(),</span> <span class="n">Subclass</span><span class="p">)</span> +</pre></div> +</div> +<table class="docutils footnote" frame="void" id="id5" rules="none"> +<colgroup><col class="label" /><col /></colgroup> +<tbody valign="top"> +<tr><td class="label"><a class="fn-backref" href="#id4">[2]</a></td><td>An exception to this rule are the non-callable mocks. Attributes use the +callable variant because otherwise non-callable mocks couldn’t have callable +methods.</td></tr> +</tbody> +</table> +</div> +<div class="section" id="mocking-imports-with-patch-dict"> +<h2>Mocking imports with patch.dict<a class="headerlink" href="#mocking-imports-with-patch-dict" title="Permalink to this headline">¶</a></h2> +<p>One situation where mocking can be hard is where you have a local import inside +a function. These are harder to mock because they aren’t using an object from +the module namespace that we can patch out.</p> +<p>Generally local imports are to be avoided. They are sometimes done to prevent +circular dependencies, for which there is <em>usually</em> a much better way to solve +the problem (refactor the code) or to prevent “up front costs” by delaying the +import. This can also be solved in better ways than an unconditional local +import (store the module as a class or module attribute and only do the import +on first use).</p> +<p>That aside there is a way to use <cite>mock</cite> to affect the results of an import. +Importing fetches an <em>object</em> from the <cite>sys.modules</cite> dictionary. Note that it +fetches an <em>object</em>, which need not be a module. Importing a module for the +first time results in a module object being put in <cite>sys.modules</cite>, so usually +when you import something you get a module back. This need not be the case +however.</p> +<p>This means you can use <a class="reference internal" href="patch.html#mock.patch.dict" title="mock.patch.dict"><tt class="xref py py-func docutils literal"><span class="pre">patch.dict()</span></tt></a> to <em>temporarily</em> put a mock in place +in <cite>sys.modules</cite>. Any imports whilst this patch is active will fetch the mock. +When the patch is complete (the decorated function exits, the with statement +body is complete or <cite>patcher.stop()</cite> is called) then whatever was there +previously will be restored safely.</p> +<p>Here’s an example that mocks out the ‘fooble’ module.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="o">.</span><span class="n">dict</span><span class="p">(</span><span class="s">'sys.modules'</span><span class="p">,</span> <span class="p">{</span><span class="s">'fooble'</span><span class="p">:</span> <span class="n">mock</span><span class="p">}):</span> +<span class="gp">... </span> <span class="kn">import</span> <span class="nn">fooble</span> +<span class="gp">... </span> <span class="n">fooble</span><span class="o">.</span><span class="n">blob</span><span class="p">()</span> +<span class="gp">...</span> +<span class="go"><Mock name='mock.blob()' id='...'></span> +<span class="gp">>>> </span><span class="k">assert</span> <span class="s">'fooble'</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">sys</span><span class="o">.</span><span class="n">modules</span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">blob</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">()</span> +</pre></div> +</div> +<p>As you can see the <cite>import fooble</cite> succeeds, but on exit there is no ‘fooble’ +left in <cite>sys.modules</cite>.</p> +<p>This also works for the <cite>from module import name</cite> form:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="o">.</span><span class="n">dict</span><span class="p">(</span><span class="s">'sys.modules'</span><span class="p">,</span> <span class="p">{</span><span class="s">'fooble'</span><span class="p">:</span> <span class="n">mock</span><span class="p">}):</span> +<span class="gp">... </span> <span class="kn">from</span> <span class="nn">fooble</span> <span class="kn">import</span> <span class="n">blob</span> +<span class="gp">... </span> <span class="n">blob</span><span class="o">.</span><span class="n">blip</span><span class="p">()</span> +<span class="gp">...</span> +<span class="go"><Mock name='mock.blob.blip()' id='...'></span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">blob</span><span class="o">.</span><span class="n">blip</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">()</span> +</pre></div> +</div> +<p>With slightly more work you can also mock package imports:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mock</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">modules</span> <span class="o">=</span> <span class="p">{</span><span class="s">'package'</span><span class="p">:</span> <span class="n">mock</span><span class="p">,</span> <span class="s">'package.module'</span><span class="p">:</span> <span class="n">mock</span><span class="o">.</span><span class="n">module</span><span class="p">}</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="o">.</span><span class="n">dict</span><span class="p">(</span><span class="s">'sys.modules'</span><span class="p">,</span> <span class="n">modules</span><span class="p">):</span> +<span class="gp">... </span> <span class="kn">from</span> <span class="nn">package.module</span> <span class="kn">import</span> <span class="n">fooble</span> +<span class="gp">... </span> <span class="n">fooble</span><span class="p">()</span> +<span class="gp">...</span> +<span class="go"><Mock name='mock.module.fooble()' id='...'></span> +<span class="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">module</span><span class="o">.</span><span class="n">fooble</span><span class="o">.</span><span class="n">assert_called_once_with</span><span class="p">()</span> +</pre></div> +</div> +</div> +<div class="section" id="tracking-order-of-calls-and-less-verbose-call-assertions"> +<h2>Tracking order of calls and less verbose call assertions<a class="headerlink" href="#tracking-order-of-calls-and-less-verbose-call-assertions" title="Permalink to this headline">¶</a></h2> +<p>The <a class="reference internal" href="mock.html#mock.Mock" title="mock.Mock"><tt class="xref py py-class docutils literal"><span class="pre">Mock</span></tt></a> class allows you to track the <em>order</em> of method calls on +your mock objects through the <a class="reference internal" href="mock.html#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> attribute. This +doesn’t allow you to track the order of calls between separate mock objects, +however we can use <a class="reference internal" href="mock.html#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> to achieve the same effect.</p> +<p>Because mocks track calls to child mocks in <cite>mock_calls</cite>, and accessing an +arbitrary attribute of a mock creates a child mock, we can create our separate +mocks from a parent one. Calls to those child mock will then all be recorded, +in order, in the <cite>mock_calls</cite> of the parent:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">manager</span> <span class="o">=</span> <span class="n">Mock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">mock_foo</span> <span class="o">=</span> <span class="n">manager</span><span class="o">.</span><span class="n">foo</span> +<span class="gp">>>> </span><span class="n">mock_bar</span> <span class="o">=</span> <span class="n">manager</span><span class="o">.</span><span class="n">bar</span> + +<span class="gp">>>> </span><span class="n">mock_foo</span><span class="o">.</span><span class="n">something</span><span class="p">()</span> +<span class="go"><Mock name='mock.foo.something()' id='...'></span> +<span class="gp">>>> </span><span class="n">mock_bar</span><span class="o">.</span><span class="n">other</span><span class="o">.</span><span class="n">thing</span><span class="p">()</span> +<span class="go"><Mock name='mock.bar.other.thing()' id='...'></span> + +<span class="gp">>>> </span><span class="n">manager</span><span class="o">.</span><span class="n">mock_calls</span> +<span class="go">[call.foo.something(), call.bar.other.thing()]</span> +</pre></div> +</div> +<p>We can then assert about the calls, including the order, by comparing with +the <cite>mock_calls</cite> attribute on the manager mock:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">expected_calls</span> <span class="o">=</span> <span class="p">[</span><span class="n">call</span><span class="o">.</span><span class="n">foo</span><span class="o">.</span><span class="n">something</span><span class="p">(),</span> <span class="n">call</span><span class="o">.</span><span class="n">bar</span><span class="o">.</span><span class="n">other</span><span class="o">.</span><span class="n">thing</span><span class="p">()]</span> +<span class="gp">>>> </span><span class="n">manager</span><span class="o">.</span><span class="n">mock_calls</span> <span class="o">==</span> <span class="n">expected_calls</span> +<span class="go">True</span> +</pre></div> +</div> +<p>If <cite>patch</cite> is creating, and putting in place, your mocks then you can attach +them to a manager mock using the <a class="reference internal" href="mock.html#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> method. After +attaching calls will be recorded in <cite>mock_calls</cite> of the manager.</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">manager</span> <span class="o">=</span> <span class="n">MagicMock</span><span class="p">()</span> +<span class="gp">>>> </span><span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.Class1'</span><span class="p">)</span> <span class="k">as</span> <span class="n">MockClass1</span><span class="p">:</span> +<span class="gp">... </span> <span class="k">with</span> <span class="n">patch</span><span class="p">(</span><span class="s">'mymodule.Class2'</span><span class="p">)</span> <span class="k">as</span> <span class="n">MockClass2</span><span class="p">:</span> +<span class="gp">... </span> <span class="n">manager</span><span class="o">.</span><span class="n">attach_mock</span><span class="p">(</span><span class="n">MockClass1</span><span class="p">,</span> <span class="s">'MockClass1'</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">manager</span><span class="o">.</span><span class="n">attach_mock</span><span class="p">(</span><span class="n">MockClass2</span><span class="p">,</span> <span class="s">'MockClass2'</span><span class="p">)</span> +<span class="gp">... </span> <span class="n">MockClass1</span><span class="p">()</span><span class="o">.</span><span class="n">foo</span><span class="p">()</span> +<span class="gp">... </span> <span class="n">MockClass2</span><span class="p">()</span><span class="o">.</span><span class="n">bar</span><span class="p">()</span> +<span class="gp">...</span> +<span class="go"><MagicMock name='mock.MockClass1().foo()' id='...'></span> +<span class="go"><MagicMock name='mock.MockClass2().bar()' id='...'></span> +<span class="gp">>>> </span><span class="n">manager</span><span class="o">.</span><span class="n">mock_calls</span> +<span class="go">[call.MockClass1(),</span> +<span class="go"> call.MockClass1().foo(),</span> +<span class="go"> call.MockClass2(),</span> +<span class="go"> call.MockClass2().bar()]</span> +</pre></div> +</div> +<p>If many calls have been made, but you’re only interested in a particular +sequence of them then an alternative is to use the +<a class="reference internal" href="mock.html#mock.Mock.assert_has_calls" title="mock.Mock.assert_has_calls"><tt class="xref py py-meth docutils literal"><span class="pre">assert_has_calls()</span></tt></a> method. This takes a list of calls (constructed +with the <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). If that sequence of calls are in +<a class="reference internal" href="mock.html#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> then the assert succeeds.</p> +<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="gp">>>> </span><span class="n">m</span><span class="p">()</span><span class="o">.</span><span class="n">foo</span><span class="p">()</span><span class="o">.</span><span class="n">bar</span><span class="p">()</span><span class="o">.</span><span class="n">baz</span><span class="p">()</span> +<span class="go"><MagicMock name='mock().foo().bar().baz()' id='...'></span> +<span class="gp">>>> </span><span class="n">m</span><span class="o">.</span><span class="n">one</span><span class="p">()</span><span class="o">.</span><span class="n">two</span><span class="p">()</span><span class="o">.</span><span class="n">three</span><span class="p">()</span> +<span class="go"><MagicMock name='mock.one().two().three()' id='...'></span> +<span class="gp">>>> </span><span class="n">calls</span> <span class="o">=</span> <span class="n">call</span><span class="o">.</span><span class="n">one</span><span class="p">()</span><span class="o">.</span><span class="n">two</span><span class="p">()</span><span class="o">.</span><span class="n">three</span><span class="p">()</span><span class="o">.</span><span class="n">call_list</span><span class="p">()</span> +<span class="gp">>>> </span><span class="n">m</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> +</pre></div> +</div> +<p>Even though the chained call <cite>m.one().two().three()</cite> aren’t the only calls that +have been made to the mock, the assert still succeeds.</p> +<p>Sometimes a mock may have several calls made to it, and you are only interested +in asserting about <em>some</em> of those calls. You may not even care about the +order. In this case you can pass <cite>any_order=True</cite> to <cite>assert_has_calls</cite>:</p> +<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="gp">>>> </span><span class="n">m</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="n">m</span><span class="o">.</span><span class="n">two</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">m</span><span class="o">.</span><span class="n">seven</span><span class="p">(</span><span class="mi">7</span><span class="p">),</span> <span class="n">m</span><span class="o">.</span><span class="n">fifty</span><span class="p">(</span><span class="s">'50'</span><span class="p">)</span> +<span class="go">(...)</span> +<span class="gp">>>> </span><span class="n">calls</span> <span class="o">=</span> <span class="p">[</span><span class="n">call</span><span class="o">.</span><span class="n">fifty</span><span class="p">(</span><span class="s">'50'</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="n">call</span><span class="o">.</span><span class="n">seven</span><span class="p">(</span><span class="mi">7</span><span class="p">)]</span> +<span class="gp">>>> </span><span class="n">m</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> +</pre></div> +</div> +</div> +<div class="section" id="more-complex-argument-matching"> +<h2>More complex argument matching<a class="headerlink" href="#more-complex-argument-matching" title="Permalink to this headline">¶</a></h2> +<p>Using the same basic concept as <cite>ANY</cite> we can implement matchers to do more +complex assertions on objects used as arguments to mocks.</p> +<p>Suppose we expect some object to be passed to a mock that by default +compares equal based on object identity (which is the Python default for user +defined classes). To use <a class="reference internal" href="mock.html#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> we would need to pass +in the exact same object. If we are only interested in some of the attributes +of this object then we can create a matcher that will check these attributes +for us.</p> +<p>You can see in this example how a ‘standard’ call to <cite>assert_called_with</cite> isn’t +sufficient:</p> +<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> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">a</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">b</span> <span class="o">=</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> +<span class="gp">...</span> +<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> +<span class="gp">>>> </span><span class="n">mock</span><span class="p">(</span><span class="n">Foo</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="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="n">Foo</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="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">AssertionError: Expected</span>: <span class="n">call(<__main__.Foo object at 0x...>)</span> +<span class="go">Actual call: call(<__main__.Foo object at 0x...>)</span> +</pre></div> +</div> +<p>A comparison function for our <cite>Foo</cite> class might look something like this:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">def</span> <span class="nf">compare</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">if</span> <span class="ow">not</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">==</span> <span class="nb">type</span><span class="p">(</span><span class="n">other</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="bp">False</span> +<span class="gp">... </span> <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">a</span> <span class="o">!=</span> <span class="n">other</span><span class="o">.</span><span class="n">a</span><span class="p">:</span> +<span class="gp">... </span> <span class="k">return</span> <span class="bp">False</span> +<span class="gp">... </span> <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">b</span> <span class="o">!=</span> <span class="n">other</span><span class="o">.</span><span class="n">b</span><span class="p">:</span> +<span class="gp">... </span> <span class="k">return</span> <span class="bp">False</span> +<span class="gp">... </span> <span class="k">return</span> <span class="bp">True</span> +<span class="gp">...</span> +</pre></div> +</div> +<p>And a matcher object that can use comparison functions like this for its +equality operation would look something like this:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">class</span> <span class="nc">Matcher</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">compare</span><span class="p">,</span> <span class="n">some_obj</span><span class="p">):</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">compare</span> <span class="o">=</span> <span class="n">compare</span> +<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">some_obj</span> <span class="o">=</span> <span class="n">some_obj</span> +<span class="gp">... </span> <span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> +<span class="gp">... </span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">compare</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">some_obj</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span> +<span class="gp">...</span> +</pre></div> +</div> +<p>Putting all this together:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">match_foo</span> <span class="o">=</span> <span class="n">Matcher</span><span class="p">(</span><span class="n">compare</span><span class="p">,</span> <span class="n">Foo</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="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="n">match_foo</span><span class="p">)</span> +</pre></div> +</div> +<p>The <cite>Matcher</cite> is instantiated with our compare function and the <cite>Foo</cite> object +we want to compare against. In <cite>assert_called_with</cite> the <cite>Matcher</cite> equality +method will be called, which compares the object the mock was called with +against the one we created our matcher with. If they match then +<cite>assert_called_with</cite> passes, and if they don’t an <cite>AssertionError</cite> is raised:</p> +<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">match_wrong</span> <span class="o">=</span> <span class="n">Matcher</span><span class="p">(</span><span class="n">compare</span><span class="p">,</span> <span class="n">Foo</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="gp">>>> </span><span class="n">mock</span><span class="o">.</span><span class="n">assert_called_with</span><span class="p">(</span><span class="n">match_wrong</span><span class="p">)</span> +<span class="gt">Traceback (most recent call last):</span> + <span class="o">...</span> +<span class="gr">AssertionError: Expected</span>: <span class="n">((<Matcher object at 0x...>,), {})</span> +<span class="go">Called with: ((<Foo object at 0x...>,), {})</span> +</pre></div> +</div> +<p>With a bit of tweaking you could have the comparison function raise the +<cite>AssertionError</cite> directly and provide a more useful failure message.</p> +<p>As of version 1.5, the Python testing library <a class="reference external" href="http://pypi.python.org/pypi/PyHamcrest">PyHamcrest</a> provides similar functionality, +that may be useful here, in the form of its equality matcher +(<a class="reference external" href="http://packages.python.org/PyHamcrest/integration.html#hamcrest.library.integration.match_equality">hamcrest.library.integration.match_equality</a>).</p> +</div> +<div class="section" id="less-verbose-configuration-of-mock-objects"> +<h2>Less verbose configuration of mock objects<a class="headerlink" href="#less-verbose-configuration-of-mock-objects" title="Permalink to this headline">¶</a></h2> +<p>This recipe, for easier configuration of mock objects, is now part of <cite>Mock</cite>. +See the <a class="reference internal" href="mock.html#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.</p> +</div> +<div class="section" id="matching-any-argument-in-assertions"> +<h2>Matching any argument in assertions<a class="headerlink" href="#matching-any-argument-in-assertions" title="Permalink to this headline">¶</a></h2> +<p>This example is now built in to mock. See <a class="reference internal" href="helpers.html#mock.ANY" title="mock.ANY"><tt class="xref py py-data docutils literal"><span class="pre">ANY</span></tt></a>.</p> +</div> +<div class="section" id="mocking-properties"> +<h2>Mocking Properties<a class="headerlink" href="#mocking-properties" title="Permalink to this headline">¶</a></h2> +<p>This example is now built in to mock. See <a class="reference internal" href="mock.html#mock.PropertyMock" title="mock.PropertyMock"><tt class="xref py py-class docutils literal"><span class="pre">PropertyMock</span></tt></a>.</p> +</div> +<div class="section" id="mocking-open"> +<h2>Mocking open<a class="headerlink" href="#mocking-open" title="Permalink to this headline">¶</a></h2> +<p>This example is now built in to mock. See <a class="reference internal" href="helpers.html#mock.mock_open" title="mock.mock_open"><tt class="xref py py-func docutils literal"><span class="pre">mock_open()</span></tt></a>.</p> +</div> +<div class="section" id="mocks-without-some-attributes"> +<h2>Mocks without some attributes<a class="headerlink" href="#mocks-without-some-attributes" title="Permalink to this headline">¶</a></h2> +<p>This example is now built in to mock. See <a class="reference internal" href="mock.html#deleting-attributes"><em>Deleting Attributes</em></a>.</p> +</div> +</div> + + + </div> + </div> + </div> + <div class="sphinxsidebar"> + <div class="sphinxsidebarwrapper"> + <h3><a href="index.html">Table Of Contents</a></h3> + <ul> +<li><a class="reference internal" href="#">Further Examples</a><ul> +<li><a class="reference internal" href="#mocking-chained-calls">Mocking chained calls</a></li> +<li><a class="reference internal" href="#partial-mocking">Partial mocking</a></li> +<li><a class="reference internal" href="#mocking-a-generator-method">Mocking a Generator Method</a></li> +<li><a class="reference internal" href="#applying-the-same-patch-to-every-test-method">Applying the same patch to every test method</a></li> +<li><a class="reference internal" href="#mocking-unbound-methods">Mocking Unbound Methods</a></li> +<li><a class="reference internal" href="#checking-multiple-calls-with-mock">Checking multiple calls with mock</a></li> +<li><a class="reference internal" href="#coping-with-mutable-arguments">Coping with mutable arguments</a></li> +<li><a class="reference internal" href="#raising-exceptions-on-attribute-access">Raising exceptions on attribute access</a></li> +<li><a class="reference internal" href="#multiple-calls-with-different-effects">Multiple calls with different effects</a></li> +<li><a class="reference internal" href="#nesting-patches">Nesting Patches</a></li> +<li><a class="reference internal" href="#mocking-a-dictionary-with-magicmock">Mocking a dictionary with MagicMock</a></li> +<li><a class="reference internal" href="#mock-subclasses-and-their-attributes">Mock subclasses and their attributes</a></li> +<li><a class="reference internal" href="#mocking-imports-with-patch-dict">Mocking imports with patch.dict</a></li> +<li><a class="reference internal" href="#tracking-order-of-calls-and-less-verbose-call-assertions">Tracking order of calls and less verbose call assertions</a></li> +<li><a class="reference internal" href="#more-complex-argument-matching">More complex argument matching</a></li> +<li><a class="reference internal" href="#less-verbose-configuration-of-mock-objects">Less verbose configuration of mock objects</a></li> +<li><a class="reference internal" href="#matching-any-argument-in-assertions">Matching any argument in assertions</a></li> +<li><a class="reference internal" href="#mocking-properties">Mocking Properties</a></li> +<li><a class="reference internal" href="#mocking-open">Mocking open</a></li> +<li><a class="reference internal" href="#mocks-without-some-attributes">Mocks without some attributes</a></li> +</ul> +</li> +</ul> + + <h4>Previous topic</h4> + <p class="topless"><a href="getting-started.html" + title="previous chapter">Getting Started with Mock</a></p> + <h4>Next topic</h4> + <p class="topless"><a href="compare.html" + title="next chapter">Mock Library Comparison</a></p> + <h3>This Page</h3> + <ul class="this-page-menu"> + <li><a href="_sources/examples.txt" + rel="nofollow">Show Source</a></li> + </ul> +<div id="searchbox" style="display: none"> + <h3>Quick search</h3> + <form class="search" action="search.html" method="get"> + <input type="text" name="q" /> + <input type="submit" value="Go" /> + <input type="hidden" name="check_keywords" value="yes" /> + <input type="hidden" name="area" value="default" /> + </form> + <p class="searchtip" style="font-size: 90%"> + Enter search terms or a module, class or function name. + </p> +</div> +<script type="text/javascript">$('#searchbox').show(0);</script> + </div> + </div> + <div class="clearer"></div> + </div> + <div class="related"> + <h3>Navigation</h3> + <ul> + <li class="right" style="margin-right: 10px"> + <a href="genindex.html" title="General Index" + >index</a></li> + <li class="right" > + <a href="compare.html" title="Mock Library Comparison" + >next</a> |</li> + <li class="right" > + <a href="getting-started.html" title="Getting Started with Mock" + >previous</a> |</li> + <li><a href="index.html">Mock 1.0.1 documentation</a> »</li> + </ul> + </div> + <div class="footer"> + © Copyright 2007-2012, Michael Foord & the mock team. + Last updated on Nov 05, 2012. + Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3. + </div> + </body> +</html>
\ No newline at end of file |