bug 803654 - Import mock into virtualenv. r=jhammel
authorTed Mielczarek <ted@mielczarek.org>
Mon, 29 Oct 2012 11:12:30 -0400
changeset 120523 5981ff9d3f45de802d956b2f8e064f49b74cb7a6
parent 120522 7e4fa834e25d05972689d3d7c7c7c34f647789e5
child 120524 69b34a83ee61d9aaa35f2d32b0b9db8511e0509e
push idunknown
push userunknown
push dateunknown
reviewersjhammel
bugs803654
milestone19.0a1
bug 803654 - Import mock into virtualenv. r=jhammel
build/virtualenv/packages.txt
python/mock-1.0.0/LICENSE.txt
python/mock-1.0.0/MANIFEST.in
python/mock-1.0.0/PKG-INFO
python/mock-1.0.0/README.txt
python/mock-1.0.0/docs/changelog.txt
python/mock-1.0.0/docs/compare.txt
python/mock-1.0.0/docs/conf.py
python/mock-1.0.0/docs/examples.txt
python/mock-1.0.0/docs/getting-started.txt
python/mock-1.0.0/docs/helpers.txt
python/mock-1.0.0/docs/index.txt
python/mock-1.0.0/docs/magicmock.txt
python/mock-1.0.0/docs/mock.txt
python/mock-1.0.0/docs/patch.txt
python/mock-1.0.0/docs/sentinel.txt
python/mock-1.0.0/html/.doctrees/changelog.doctree
python/mock-1.0.0/html/.doctrees/compare.doctree
python/mock-1.0.0/html/.doctrees/examples.doctree
python/mock-1.0.0/html/.doctrees/getting-started.doctree
python/mock-1.0.0/html/.doctrees/index.doctree
python/mock-1.0.0/html/.doctrees/magicmock.doctree
python/mock-1.0.0/html/.doctrees/mock.doctree
python/mock-1.0.0/html/.doctrees/mocksignature.doctree
python/mock-1.0.0/html/.doctrees/patch.doctree
python/mock-1.0.0/html/.doctrees/sentinel.doctree
python/mock-1.0.0/html/_sources/changelog.txt
python/mock-1.0.0/html/_sources/compare.txt
python/mock-1.0.0/html/_sources/examples.txt
python/mock-1.0.0/html/_sources/getting-started.txt
python/mock-1.0.0/html/_sources/index.txt
python/mock-1.0.0/html/_sources/magicmock.txt
python/mock-1.0.0/html/_sources/mock.txt
python/mock-1.0.0/html/_sources/mocksignature.txt
python/mock-1.0.0/html/_sources/patch.txt
python/mock-1.0.0/html/_sources/sentinel.txt
python/mock-1.0.0/html/_static/adctheme.css
python/mock-1.0.0/html/_static/basic.css
python/mock-1.0.0/html/_static/breadcrumb_background.png
python/mock-1.0.0/html/_static/default.css
python/mock-1.0.0/html/_static/doctools.js
python/mock-1.0.0/html/_static/documentation.png
python/mock-1.0.0/html/_static/file.png
python/mock-1.0.0/html/_static/header_sm_mid.png
python/mock-1.0.0/html/_static/jquery.js
python/mock-1.0.0/html/_static/minus.png
python/mock-1.0.0/html/_static/mobile.css
python/mock-1.0.0/html/_static/plus.png
python/mock-1.0.0/html/_static/pygments.css
python/mock-1.0.0/html/_static/scrn1.png
python/mock-1.0.0/html/_static/scrn2.png
python/mock-1.0.0/html/_static/searchfield_leftcap.png
python/mock-1.0.0/html/_static/searchfield_repeat.png
python/mock-1.0.0/html/_static/searchfield_rightcap.png
python/mock-1.0.0/html/_static/searchtools.js
python/mock-1.0.0/html/_static/sidebar.js
python/mock-1.0.0/html/_static/title_background.png
python/mock-1.0.0/html/_static/toc.js
python/mock-1.0.0/html/_static/triangle_closed.png
python/mock-1.0.0/html/_static/triangle_left.png
python/mock-1.0.0/html/_static/triangle_open.png
python/mock-1.0.0/html/_static/underscore.js
python/mock-1.0.0/html/changelog.html
python/mock-1.0.0/html/compare.html
python/mock-1.0.0/html/examples.html
python/mock-1.0.0/html/genindex.html
python/mock-1.0.0/html/getting-started.html
python/mock-1.0.0/html/index.html
python/mock-1.0.0/html/magicmock.html
python/mock-1.0.0/html/mock.html
python/mock-1.0.0/html/mocksignature.html
python/mock-1.0.0/html/objects.inv
python/mock-1.0.0/html/output.txt
python/mock-1.0.0/html/patch.html
python/mock-1.0.0/html/search.html
python/mock-1.0.0/html/searchindex.js
python/mock-1.0.0/html/sentinel.html
python/mock-1.0.0/mock.egg-info/PKG-INFO
python/mock-1.0.0/mock.egg-info/SOURCES.txt
python/mock-1.0.0/mock.egg-info/dependency_links.txt
python/mock-1.0.0/mock.egg-info/top_level.txt
python/mock-1.0.0/mock.py
python/mock-1.0.0/setup.cfg
python/mock-1.0.0/setup.py
python/mock-1.0.0/tests/__init__.py
python/mock-1.0.0/tests/_testwith.py
python/mock-1.0.0/tests/support.py
python/mock-1.0.0/tests/support_with.py
python/mock-1.0.0/tests/testcallable.py
python/mock-1.0.0/tests/testhelpers.py
python/mock-1.0.0/tests/testmagicmethods.py
python/mock-1.0.0/tests/testmock.py
python/mock-1.0.0/tests/testpatch.py
python/mock-1.0.0/tests/testsentinel.py
python/mock-1.0.0/tests/testwith.py
python/mock-1.0.0/tox.ini
--- a/build/virtualenv/packages.txt
+++ b/build/virtualenv/packages.txt
@@ -12,11 +12,12 @@ mozprofile.pth:testing/mozbase/mozprofil
 mozrunner.pth:testing/mozbase/mozrunner
 marionette.pth:testing/marionette/client
 blessings.pth:python/blessings
 mozbuild.pth:python/mozbuild
 pymake.pth:build/pymake
 optional:setup.py:python/psutil:build_ext:--inplace
 optional:psutil.pth:python/psutil
 which.pth:python/which
+mock.pth:python/mock-1.0.0
 mozilla.pth:build
 mozilla.pth:config
 copy:build/buildconfig.py
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/LICENSE.txt
@@ -0,0 +1,26 @@
+Copyright (c) 2003-2012, Michael Foord
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/MANIFEST.in
@@ -0,0 +1,2 @@
+include LICENSE.txt tox.ini tests/*.py
+recursive-include docs *.txt *.py *.png *.css *.html *.js
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/PKG-INFO
@@ -0,0 +1,208 @@
+Metadata-Version: 1.0
+Name: mock
+Version: 1.0.0
+Summary: A Python Mocking and Patching Library for Testing
+Home-page: http://www.voidspace.org.uk/python/mock/
+Author: Michael Foord
+Author-email: michael@voidspace.org.uk
+License: UNKNOWN
+Description: mock is a library for testing in Python. It allows you to replace parts of
+        your system under test with mock objects and make assertions about how they
+        have been used.
+        
+        mock is now part of the Python standard library, available as `unittest.mock <
+        http://docs.python.org/py3k/library/unittest.mock.html#module-unittest.mock>`_
+        in Python 3.3 onwards.
+        
+        mock provides a core `MagicMock` class removing the need to create a host of
+        stubs throughout your test suite. After performing an action, you can make
+        assertions about which methods / attributes were used and arguments they were
+        called with. You can also specify return values and set needed attributes in
+        the normal way.
+        
+        mock is tested on Python versions 2.4-2.7 and Python 3. mock is also tested
+        with the latest versions of Jython and pypy.
+        
+        The mock module also provides utility functions / objects to assist with
+        testing, particularly monkey patching.
+        
+        * `PDF documentation for 1.0 beta 1
+          <http://www.voidspace.org.uk/downloads/mock-1.0.0.pdf>`_
+        * `mock on google code (repository and issue tracker)
+          <http://code.google.com/p/mock/>`_
+        * `mock documentation
+          <http://www.voidspace.org.uk/python/mock/>`_
+        * `mock on PyPI <http://pypi.python.org/pypi/mock/>`_
+        * `Mailing list (testing-in-python@lists.idyll.org)
+          <http://lists.idyll.org/listinfo/testing-in-python>`_
+        
+        Mock is very easy to use and is designed for use with
+        `unittest <http://pypi.python.org/pypi/unittest2>`_. Mock is based on
+        the 'action -> assertion' pattern instead of 'record -> replay' used by many
+        mocking frameworks. See the `mock documentation`_ for full details.
+        
+        Mock objects create all attributes and methods as you access them and store
+        details of how they have been used. You can configure them, to specify return
+        values or limit what attributes are available, and then make assertions about
+        how they have been used::
+        
+            >>> from mock import Mock
+            >>> real = ProductionClass()
+            >>> real.method = Mock(return_value=3)
+            >>> real.method(3, 4, 5, key='value')
+            3
+            >>> real.method.assert_called_with(3, 4, 5, key='value')
+        
+        `side_effect` allows you to perform side effects, return different values or
+        raise an exception when a mock is called::
+        
+           >>> mock = Mock(side_effect=KeyError('foo'))
+           >>> mock()
+           Traceback (most recent call last):
+            ...
+           KeyError: 'foo'
+           >>> values = {'a': 1, 'b': 2, 'c': 3}
+           >>> def side_effect(arg):
+           ...     return values[arg]
+           ...
+           >>> mock.side_effect = side_effect
+           >>> mock('a'), mock('b'), mock('c')
+           (3, 2, 1)
+           >>> mock.side_effect = [5, 4, 3, 2, 1]
+           >>> mock(), mock(), mock()
+           (5, 4, 3)
+        
+        Mock has many other ways you can configure it and control its behaviour. For
+        example the `spec` argument configures the mock to take its specification from
+        another object. Attempting to access attributes or methods on the mock that
+        don't exist on the spec will fail with an `AttributeError`.
+        
+        The `patch` decorator / context manager makes it easy to mock classes or
+        objects in a module under test. The object you specify will be replaced with a
+        mock (or other object) during the test and restored when the test ends::
+        
+            >>> from mock import patch
+            >>> @patch('test_module.ClassName1')
+            ... @patch('test_module.ClassName2')
+            ... def test(MockClass2, MockClass1):
+            ...     test_module.ClassName1()
+            ...     test_module.ClassName2()
+        
+            ...     assert MockClass1.called
+            ...     assert MockClass2.called
+            ...
+            >>> test()
+        
+        .. note::
+        
+           When you nest patch decorators the mocks are passed in to the decorated
+           function in the same order they applied (the normal *python* order that
+           decorators are applied). This means from the bottom up, so in the example
+           above the mock for `test_module.ClassName2` is passed in first.
+        
+           With `patch` it matters that you patch objects in the namespace where they
+           are looked up. This is normally straightforward, but for a quick guide
+           read `where to patch
+           <http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch>`_.
+        
+        As well as a decorator `patch` can be used as a context manager in a with
+        statement::
+        
+            >>> with patch.object(ProductionClass, 'method') as mock_method:
+            ...     mock_method.return_value = None
+            ...     real = ProductionClass()
+            ...     real.method(1, 2, 3)
+            ...
+            >>> mock_method.assert_called_once_with(1, 2, 3)
+        
+        There is also `patch.dict` for setting values in a dictionary just during the
+        scope of a test and restoring the dictionary to its original state when the
+        test ends::
+        
+           >>> foo = {'key': 'value'}
+           >>> original = foo.copy()
+           >>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
+           ...     assert foo == {'newkey': 'newvalue'}
+           ...
+           >>> assert foo == original
+        
+        Mock supports the mocking of Python magic methods. The easiest way of
+        using magic methods is with the `MagicMock` class. It allows you to do
+        things like::
+        
+            >>> from mock import MagicMock
+            >>> mock = MagicMock()
+            >>> mock.__str__.return_value = 'foobarbaz'
+            >>> str(mock)
+            'foobarbaz'
+            >>> mock.__str__.assert_called_once_with()
+        
+        Mock allows you to assign functions (or other Mock instances) to magic methods
+        and they will be called appropriately. The MagicMock class is just a Mock
+        variant that has all of the magic methods pre-created for you (well - all the
+        useful ones anyway).
+        
+        The following is an example of using magic methods with the ordinary Mock
+        class::
+        
+            >>> from mock import Mock
+            >>> mock = Mock()
+            >>> mock.__str__ = Mock(return_value = 'wheeeeee')
+            >>> str(mock)
+            'wheeeeee'
+        
+        For ensuring that the mock objects your tests use have the same api as the
+        objects they are replacing, you can use "auto-speccing". Auto-speccing can
+        be done through the `autospec` argument to patch, or the `create_autospec`
+        function. Auto-speccing creates mock objects that have the same attributes
+        and methods as the objects they are replacing, and any functions and methods
+        (including constructors) have the same call signature as the real object.
+        
+        This ensures that your mocks will fail in the same way as your production
+        code if they are used incorrectly::
+        
+           >>> from mock import create_autospec
+           >>> def function(a, b, c):
+           ...     pass
+           ...
+           >>> mock_function = create_autospec(function, return_value='fishy')
+           >>> mock_function(1, 2, 3)
+           'fishy'
+           >>> mock_function.assert_called_once_with(1, 2, 3)
+           >>> mock_function('wrong arguments')
+           Traceback (most recent call last):
+            ...
+           TypeError: <lambda>() takes exactly 3 arguments (1 given)
+        
+        `create_autospec` can also be used on classes, where it copies the signature of
+        the `__init__` method, and on callable objects where it copies the signature of
+        the `__call__` method.
+        
+        The distribution contains tests and documentation. The tests require
+        `unittest2 <http://pypi.python.org/pypi/unittest2>`_ to run.
+        
+        Docs from the in-development version of `mock` can be found at
+        `mock.readthedocs.org <http://mock.readthedocs.org>`_.
+        
+Keywords: testing,test,mock,mocking,unittest,patching,stubs,fakes,doubles
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 2.4
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: Jython
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Testing
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/README.txt
@@ -0,0 +1,177 @@
+mock is a library for testing in Python. It allows you to replace parts of
+your system under test with mock objects and make assertions about how they
+have been used.
+
+mock is now part of the Python standard library, available as `unittest.mock <
+http://docs.python.org/py3k/library/unittest.mock.html#module-unittest.mock>`_
+in Python 3.3 onwards.
+
+mock provides a core `MagicMock` class removing the need to create a host of
+stubs throughout your test suite. After performing an action, you can make
+assertions about which methods / attributes were used and arguments they were
+called with. You can also specify return values and set needed attributes in
+the normal way.
+
+mock is tested on Python versions 2.4-2.7 and Python 3. mock is also tested
+with the latest versions of Jython and pypy.
+
+The mock module also provides utility functions / objects to assist with
+testing, particularly monkey patching.
+
+* `PDF documentation for 1.0 beta 1
+  <http://www.voidspace.org.uk/downloads/mock-1.0.0.pdf>`_
+* `mock on google code (repository and issue tracker)
+  <http://code.google.com/p/mock/>`_
+* `mock documentation
+  <http://www.voidspace.org.uk/python/mock/>`_
+* `mock on PyPI <http://pypi.python.org/pypi/mock/>`_
+* `Mailing list (testing-in-python@lists.idyll.org)
+  <http://lists.idyll.org/listinfo/testing-in-python>`_
+
+Mock is very easy to use and is designed for use with
+`unittest <http://pypi.python.org/pypi/unittest2>`_. Mock is based on
+the 'action -> assertion' pattern instead of 'record -> replay' used by many
+mocking frameworks. See the `mock documentation`_ for full details.
+
+Mock objects create all attributes and methods as you access them and store
+details of how they have been used. You can configure them, to specify return
+values or limit what attributes are available, and then make assertions about
+how they have been used::
+
+    >>> from mock import Mock
+    >>> real = ProductionClass()
+    >>> real.method = Mock(return_value=3)
+    >>> real.method(3, 4, 5, key='value')
+    3
+    >>> real.method.assert_called_with(3, 4, 5, key='value')
+
+`side_effect` allows you to perform side effects, return different values or
+raise an exception when a mock is called::
+
+   >>> mock = Mock(side_effect=KeyError('foo'))
+   >>> mock()
+   Traceback (most recent call last):
+    ...
+   KeyError: 'foo'
+   >>> values = {'a': 1, 'b': 2, 'c': 3}
+   >>> def side_effect(arg):
+   ...     return values[arg]
+   ...
+   >>> mock.side_effect = side_effect
+   >>> mock('a'), mock('b'), mock('c')
+   (3, 2, 1)
+   >>> mock.side_effect = [5, 4, 3, 2, 1]
+   >>> mock(), mock(), mock()
+   (5, 4, 3)
+
+Mock has many other ways you can configure it and control its behaviour. For
+example the `spec` argument configures the mock to take its specification from
+another object. Attempting to access attributes or methods on the mock that
+don't exist on the spec will fail with an `AttributeError`.
+
+The `patch` decorator / context manager makes it easy to mock classes or
+objects in a module under test. The object you specify will be replaced with a
+mock (or other object) during the test and restored when the test ends::
+
+    >>> from mock import patch
+    >>> @patch('test_module.ClassName1')
+    ... @patch('test_module.ClassName2')
+    ... def test(MockClass2, MockClass1):
+    ...     test_module.ClassName1()
+    ...     test_module.ClassName2()
+
+    ...     assert MockClass1.called
+    ...     assert MockClass2.called
+    ...
+    >>> test()
+
+.. note::
+
+   When you nest patch decorators the mocks are passed in to the decorated
+   function in the same order they applied (the normal *python* order that
+   decorators are applied). This means from the bottom up, so in the example
+   above the mock for `test_module.ClassName2` is passed in first.
+
+   With `patch` it matters that you patch objects in the namespace where they
+   are looked up. This is normally straightforward, but for a quick guide
+   read `where to patch
+   <http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch>`_.
+
+As well as a decorator `patch` can be used as a context manager in a with
+statement::
+
+    >>> with patch.object(ProductionClass, 'method') as mock_method:
+    ...     mock_method.return_value = None
+    ...     real = ProductionClass()
+    ...     real.method(1, 2, 3)
+    ...
+    >>> mock_method.assert_called_once_with(1, 2, 3)
+
+There is also `patch.dict` for setting values in a dictionary just during the
+scope of a test and restoring the dictionary to its original state when the
+test ends::
+
+   >>> foo = {'key': 'value'}
+   >>> original = foo.copy()
+   >>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
+   ...     assert foo == {'newkey': 'newvalue'}
+   ...
+   >>> assert foo == original
+
+Mock supports the mocking of Python magic methods. The easiest way of
+using magic methods is with the `MagicMock` class. It allows you to do
+things like::
+
+    >>> from mock import MagicMock
+    >>> mock = MagicMock()
+    >>> mock.__str__.return_value = 'foobarbaz'
+    >>> str(mock)
+    'foobarbaz'
+    >>> mock.__str__.assert_called_once_with()
+
+Mock allows you to assign functions (or other Mock instances) to magic methods
+and they will be called appropriately. The MagicMock class is just a Mock
+variant that has all of the magic methods pre-created for you (well - all the
+useful ones anyway).
+
+The following is an example of using magic methods with the ordinary Mock
+class::
+
+    >>> from mock import Mock
+    >>> mock = Mock()
+    >>> mock.__str__ = Mock(return_value = 'wheeeeee')
+    >>> str(mock)
+    'wheeeeee'
+
+For ensuring that the mock objects your tests use have the same api as the
+objects they are replacing, you can use "auto-speccing". Auto-speccing can
+be done through the `autospec` argument to patch, or the `create_autospec`
+function. Auto-speccing creates mock objects that have the same attributes
+and methods as the objects they are replacing, and any functions and methods
+(including constructors) have the same call signature as the real object.
+
+This ensures that your mocks will fail in the same way as your production
+code if they are used incorrectly::
+
+   >>> from mock import create_autospec
+   >>> def function(a, b, c):
+   ...     pass
+   ...
+   >>> mock_function = create_autospec(function, return_value='fishy')
+   >>> mock_function(1, 2, 3)
+   'fishy'
+   >>> mock_function.assert_called_once_with(1, 2, 3)
+   >>> mock_function('wrong arguments')
+   Traceback (most recent call last):
+    ...
+   TypeError: <lambda>() takes exactly 3 arguments (1 given)
+
+`create_autospec` can also be used on classes, where it copies the signature of
+the `__init__` method, and on callable objects where it copies the signature of
+the `__call__` method.
+
+The distribution contains tests and documentation. The tests require
+`unittest2 <http://pypi.python.org/pypi/unittest2>`_ to run.
+
+Docs from the in-development version of `mock` can be found at
+`mock.readthedocs.org <http://mock.readthedocs.org>`_.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/changelog.txt
@@ -0,0 +1,725 @@
+.. currentmodule:: mock
+
+
+CHANGELOG
+=========
+
+2012/10/07 Version 1.0.0
+------------------------
+
+No changes since 1.0.0 beta 1. This version has feature parity with
+`unittest.mock
+<http://docs.python.org/py3k/library/unittest.mock.html#module-unittest.mock>`_
+in Python 3.3.
+
+Full list of changes since 0.8:
+
+* `mocksignature`, along with the `mocksignature` argument to `patch`, removed
+* Support for deleting attributes (accessing deleted attributes will raise an
+  `AttributeError`)
+* Added the `mock_open` helper function for mocking the builtin `open`
+* `__class__` is assignable, so a mock can pass an `isinstance` check without
+  requiring a spec
+* Addition of `PropertyMock`, for mocking properties
+* `MagicMocks` made unorderable by default (in Python 3). The comparison
+  methods (other than equality and inequality) now return `NotImplemented`
+* Propagate traceback info to support subclassing of `_patch` by other
+  libraries
+* `create_autospec` works with attributes present in results of `dir` that
+  can't be fetched from the object's class. Contributed by Konstantine Rybnikov
+* Any exceptions in an iterable `side_effect` will be raised instead of
+  returned
+* In Python 3, `create_autospec` now supports keyword only arguments
+* Added `patch.stopall` method to stop all active patches created by `start`
+* BUGFIX: calling `MagicMock.reset_mock` wouldn't reset magic method mocks
+* BUGFIX: calling `reset_mock` on a `MagicMock` created with autospec could
+  raise an exception
+* BUGFIX: passing multiple spec arguments to patchers (`spec` , `spec_set` and
+  `autospec`) had unpredictable results, now it is an error
+* BUGFIX: using `spec=True` *and* `create=True` as arguments to patchers could
+  result in using `DEFAULT` as the spec. Now it is an error instead
+* BUGFIX: using `spec` or `autospec` arguments to patchers, along with
+  `spec_set=True` did not work correctly
+* BUGFIX: using an object that evaluates to False as a spec could be ignored
+* BUGFIX: a list as the `spec` argument to a patcher would always result in a
+  non-callable mock. Now if `__call__` is in the spec the mock is callable
+
+
+2012/07/13 Version 1.0.0 beta 1
+--------------------------------
+
+* Added `patch.stopall` method to stop all active patches created by `start`
+* BUGFIX: calling `MagicMock.reset_mock` wouldn't reset magic method mocks
+* BUGFIX: calling `reset_mock` on a `MagicMock` created with autospec could
+  raise an exception
+
+
+2012/05/04 Version 1.0.0 alpha 2
+--------------------------------
+
+* `PropertyMock` attributes are now standard `MagicMocks`
+* `create_autospec` works with attributes present in results of `dir` that
+  can't be fetched from the object's class. Contributed by Konstantine Rybnikov
+* Any exceptions in an iterable `side_effect` will be raised instead of
+  returned
+* In Python 3, `create_autospec` now supports keyword only arguments
+
+
+2012/03/25 Version 1.0.0 alpha 1
+--------------------------------
+
+The standard library version!
+
+* `mocksignature`, along with the `mocksignature` argument to `patch`, removed
+* Support for deleting attributes (accessing deleted attributes will raise an
+  `AttributeError`)
+* Added the `mock_open` helper function for mocking the builtin `open`
+* `__class__` is assignable, so a mock can pass an `isinstance` check without
+  requiring a spec
+* Addition of `PropertyMock`, for mocking properties
+* `MagicMocks` made unorderable by default (in Python 3). The comparison
+  methods (other than equality and inequality) now return `NotImplemented`
+* Propagate traceback info to support subclassing of `_patch` by other
+  libraries
+* BUGFIX: passing multiple spec arguments to patchers (`spec` , `spec_set` and
+  `autospec`) had unpredictable results, now it is an error
+* BUGFIX: using `spec=True` *and* `create=True` as arguments to patchers could
+  result in using `DEFAULT` as the spec. Now it is an error instead
+* BUGFIX: using `spec` or `autospec` arguments to patchers, along with
+  `spec_set=True` did not work correctly
+* BUGFIX: using an object that evaluates to False as a spec could be ignored
+* BUGFIX: a list as the `spec` argument to a patcher would always result in a
+  non-callable mock. Now if `__call__` is in the spec the mock is callable
+
+
+2012/02/13 Version 0.8.0
+------------------------
+
+The only changes since 0.8rc2 are:
+
+* Improved repr of :data:`sentinel` objects
+* :data:`ANY` can be used for comparisons against :data:`call` objects
+* The return value of `MagicMock.__iter__` method can be set to
+  any iterable and isn't required to be an iterator
+
+Full List of changes since 0.7:
+
+mock 0.8.0 is the last version that will support Python 2.4.
+
+* Addition of :attr:`~Mock.mock_calls` list for *all* calls (including magic
+  methods and chained calls)
+* :func:`patch` and :func:`patch.object` now create a :class:`MagicMock`
+  instead of a :class:`Mock` by default
+* The patchers (`patch`, `patch.object` and `patch.dict`), plus `Mock` and
+  `MagicMock`, take arbitrary keyword arguments for configuration
+* New mock method :meth:`~Mock.configure_mock` for setting attributes and
+  return values / side effects on the mock and its attributes
+* New mock assert methods :meth:`~Mock.assert_any_call` and
+  :meth:`~Mock.assert_has_calls`
+* Implemented :ref:`auto-speccing` (recursive, lazy speccing of mocks with
+  mocked signatures for functions/methods), as the `autospec` argument to
+  `patch`
+* Added the :func:`create_autospec` function for manually creating
+  'auto-specced' mocks
+* :func:`patch.multiple` for doing multiple patches in a single call, using
+  keyword arguments
+* Setting :attr:`~Mock.side_effect` to an iterable will cause calls to the mock
+  to return the next value from the iterable
+* New `new_callable` argument to `patch` and `patch.object` allowing you to
+  pass in a class or callable object (instead of `MagicMock`) that will be
+  called to replace the object being patched
+* Addition of :class:`NonCallableMock` and :class:`NonCallableMagicMock`, mocks
+  without a `__call__` method
+* Addition of :meth:`~Mock.mock_add_spec` method for adding (or changing) a
+  spec on an existing mock
+* Protocol methods on :class:`MagicMock` are magic mocks, and are created
+  lazily on first lookup. This means the result of calling a protocol method is
+  a `MagicMock` instead of a `Mock` as it was previously
+* Addition of :meth:`~Mock.attach_mock` method
+* Added :data:`ANY` for ignoring arguments in :meth:`~Mock.assert_called_with`
+  calls
+* Addition of :data:`call` helper object
+* Improved repr for mocks
+* Improved repr for :attr:`Mock.call_args` and entries in
+  :attr:`Mock.call_args_list`, :attr:`Mock.method_calls` and
+  :attr:`Mock.mock_calls`
+* Improved repr for :data:`sentinel` objects
+* `patch` lookup is done at use time not at decoration time
+* In Python 2.6 or more recent, `dir` on a mock will report all the dynamically
+  created attributes (or the full list of attributes if there is a spec) as
+  well as all the mock methods and attributes.
+* Module level :data:`FILTER_DIR` added to control whether `dir(mock)` filters
+  private attributes. `True` by default.
+* `patch.TEST_PREFIX` for controlling how patchers recognise test methods when
+  used to decorate a class
+* Support for using Java exceptions as a :attr:`~Mock.side_effect` on Jython
+* `Mock` call lists (`call_args_list`, `method_calls` & `mock_calls`) are now
+  custom list objects that allow membership tests for "sub lists" and have
+  a nicer representation if you `str` or `print` them
+* Mocks attached as attributes or return values to other mocks have calls
+  recorded in `method_calls` and `mock_calls` of the parent (unless a name is
+  already set on the child)
+* Improved failure messages for `assert_called_with` and
+  `assert_called_once_with`
+* The return value of the :class:`MagicMock` `__iter__` method can be set to
+  any iterable and isn't required to be an iterator
+* Added the Mock API (`assert_called_with` etc) to functions created by
+  :func:`mocksignature`
+* Tuples as well as lists can be used to specify allowed methods for `spec` &
+  `spec_set` arguments
+* Calling `stop` on an unstarted patcher fails with  a more meaningful error
+  message
+* Renamed the internal classes `Sentinel` and `SentinelObject` to prevent abuse
+* BUGFIX: an error creating a patch, with nested patch decorators, won't leave
+  patches in place
+* BUGFIX: `__truediv__` and `__rtruediv__` not available as magic methods on
+  mocks in Python 3
+* BUGFIX: `assert_called_with` / `assert_called_once_with` can be used with
+  `self` as a keyword argument
+* BUGFIX: when patching a class with an explicit spec / spec_set (not a
+  boolean) it applies "spec inheritance" to the return value of the created
+  mock (the "instance")
+* BUGFIX: remove the `__unittest` marker causing traceback truncation
+* Removal of deprecated `patch_object`
+* Private attributes `_name`, `_methods`, '_children', `_wraps` and `_parent`
+  (etc) renamed to reduce likelihood of clash with user attributes.
+* Added license file to the distribution
+
+
+2012/01/10 Version 0.8.0 release candidate 2
+--------------------------------------------
+
+* Removed the `configure` keyword argument to `create_autospec` and allow
+  arbitrary keyword arguments (for the `Mock` constructor) instead
+* Fixed `ANY` equality with some types in `assert_called_with` calls
+* Switched to a standard Sphinx theme (compatible with
+  `readthedocs.org <http://mock.readthedocs.org>`_)
+
+
+2011/12/29 Version 0.8.0 release candidate 1
+--------------------------------------------
+
+* `create_autospec` on the return value of a mocked class will use `__call__`
+  for the signature rather than `__init__`
+* Performance improvement instantiating `Mock` and `MagicMock`
+* Mocks used as magic methods have the same type as their parent instead of
+  being hardcoded to `MagicMock`
+
+Special thanks to Julian Berman for his help with diagnosing and improving
+performance in this release.
+
+
+2011/10/09 Version 0.8.0 beta 4
+-------------------------------
+
+* `patch` lookup is done at use time not at decoration time
+* When attaching a Mock to another Mock as a magic method, calls are recorded
+  in mock_calls
+* Addition of `attach_mock` method
+* Renamed the internal classes `Sentinel` and `SentinelObject` to prevent abuse
+* BUGFIX: various issues around circular references with mocks (setting a mock
+  return value to be itself etc)
+
+
+2011/08/15 Version 0.8.0 beta 3
+-------------------------------
+
+* Mocks attached as attributes or return values to other mocks have calls
+  recorded in `method_calls` and `mock_calls` of the parent (unless a name is
+  already set on the child)
+* Addition of `mock_add_spec` method for adding (or changing) a spec on an
+  existing mock
+* Improved repr for `Mock.call_args` and entries in `Mock.call_args_list`,
+  `Mock.method_calls` and `Mock.mock_calls`
+* Improved repr for mocks
+* BUGFIX: minor fixes in the way `mock_calls` is worked out,
+  especially for "intermediate" mocks in a call chain
+
+
+2011/08/05 Version 0.8.0 beta 2
+-------------------------------
+
+* Setting `side_effect` to an iterable will cause calls to the mock to return
+  the next value from the iterable
+* Added `assert_any_call` method
+* Moved `assert_has_calls` from call lists onto mocks
+* BUGFIX: `call_args` and all members of `call_args_list` are two tuples of
+  `(args, kwargs)` again instead of three tuples of `(name, args, kwargs)`
+
+
+2011/07/25 Version 0.8.0 beta 1
+-------------------------------
+
+* `patch.TEST_PREFIX` for controlling how patchers recognise test methods when
+  used to decorate a class
+* `Mock` call lists (`call_args_list`, `method_calls` & `mock_calls`) are now
+  custom list objects that allow membership tests for "sub lists" and have
+  an `assert_has_calls` method for unordered call checks
+* `callargs` changed to *always* be a three-tuple of `(name, args, kwargs)`
+* Addition of `mock_calls` list for *all* calls (including magic methods and
+  chained calls)
+* Extension of `call` object to support chained calls and `callargs` for better
+  comparisons with or without names. `call` object has a `call_list` method for
+  chained calls
+* Added the public `instance` argument to `create_autospec`
+* Support for using Java exceptions as a `side_effect` on Jython
+* Improved failure messages for `assert_called_with` and
+  `assert_called_once_with`
+* Tuples as well as lists can be used to specify allowed methods for `spec` &
+  `spec_set` arguments
+* BUGFIX: Fixed bug in `patch.multiple` for argument passing when creating
+  mocks
+* Added license file to the distribution
+
+
+2011/07/16 Version 0.8.0 alpha 2
+--------------------------------
+
+* `patch.multiple` for doing multiple patches in a single call, using keyword
+  arguments
+* New `new_callable` argument to `patch` and `patch.object` allowing you to
+  pass in a class or callable object (instead of `MagicMock`) that will be
+  called to replace the object being patched
+* Addition of `NonCallableMock` and `NonCallableMagicMock`, mocks without a
+  `__call__` method
+* Mocks created by `patch` have a `MagicMock` as the `return_value` where a
+  class is being patched
+* `create_autospec` can create non-callable mocks for non-callable objects.
+  `return_value` mocks of classes will be non-callable unless the class has
+  a `__call__` method
+* `autospec` creates a `MagicMock` without a spec for properties and slot
+  descriptors, because we don't know the type of object they return
+* Removed the "inherit" argument from `create_autospec`
+* Calling `stop` on an unstarted patcher fails with  a more meaningful error
+  message
+* BUGFIX: an error creating a patch, with nested patch decorators, won't leave
+  patches in place
+* BUGFIX: `__truediv__` and `__rtruediv__` not available as magic methods on
+  mocks in Python 3
+* BUGFIX: `assert_called_with` / `assert_called_once_with` can be used with
+  `self` as a keyword argument
+* BUGFIX: autospec for functions / methods with an argument named self that
+  isn't the first argument no longer broken
+* BUGFIX: when patching a class with an explicit spec / spec_set (not a
+  boolean) it applies "spec inheritance" to the return value of the created
+  mock (the "instance")
+* BUGFIX: remove the `__unittest` marker causing traceback truncation
+
+
+2011/06/14 Version 0.8.0 alpha 1
+--------------------------------
+
+mock 0.8.0 is the last version that will support Python 2.4.
+
+* The patchers (`patch`, `patch.object` and `patch.dict`), plus `Mock` and
+  `MagicMock`, take arbitrary keyword arguments for configuration
+* New mock method `configure_mock` for setting attributes and return values /
+  side effects on the mock and its attributes
+* In Python 2.6 or more recent, `dir` on a mock will report all the dynamically
+  created attributes (or the full list of attributes if there is a spec) as
+  well as all the mock methods and attributes.
+* Module level `FILTER_DIR` added to control whether `dir(mock)` filters
+  private attributes. `True` by default. Note that `vars(Mock())` can still be
+  used to get all instance attributes and `dir(type(Mock())` will still return
+  all the other attributes (irrespective of `FILTER_DIR`)
+* `patch` and `patch.object` now create a `MagicMock` instead of a `Mock` by
+  default
+* Added `ANY` for ignoring arguments in `assert_called_with` calls
+* Addition of `call` helper object
+* Protocol methods on `MagicMock` are magic mocks, and are created lazily on
+  first lookup. This means the result of calling a protocol method is a
+  MagicMock instead of a Mock as it was previously
+* Added the Mock API (`assert_called_with` etc) to functions created by
+  `mocksignature`
+* Private attributes `_name`, `_methods`, '_children', `_wraps` and `_parent`
+  (etc) renamed to reduce likelihood of clash with user attributes.
+* Implemented auto-speccing (recursive, lazy speccing of mocks with mocked
+  signatures for functions/methods)
+
+  Limitations:
+
+  - Doesn't mock magic methods or attributes (it creates MagicMocks, so the
+    magic methods are *there*, they just don't have the signature mocked nor
+    are attributes followed)
+  - Doesn't mock function / method attributes
+  - Uses object traversal on the objects being mocked to determine types - so
+    properties etc may be triggered
+  - The return value of mocked classes (the 'instance') has the same call
+    signature as the class __init__ (as they share the same spec)
+
+  You create auto-specced mocks by passing `autospec=True` to `patch`.
+
+  Note that attributes that are None are special cased and mocked without a
+  spec (so any attribute / method can be used). This is because None is
+  typically used as a default value for attributes that may be of some other
+  type, and as we don't know what type that may be we allow all access.
+
+  Note that the `autospec` option to `patch` obsoletes the `mocksignature`
+  option.
+
+* Added the `create_autospec` function for manually creating 'auto-specced'
+  mocks
+* Removal of deprecated `patch_object`
+
+
+2011/05/30 Version 0.7.2
+------------------------
+
+* BUGFIX: instances of list subclasses can now be used as mock specs
+* BUGFIX: MagicMock equality / inequality protocol methods changed to use the
+  default equality / inequality. This is done through a `side_effect` on
+  the mocks used for `__eq__` / `__ne__`
+
+
+2011/05/06 Version 0.7.1
+------------------------
+
+Package fixes contributed by Michael Fladischer. No code changes.
+
+* Include template in package
+* Use isolated binaries for the tox tests
+* Unset executable bit on docs
+* Fix DOS line endings in getting-started.txt
+
+
+2011/03/05 Version 0.7.0
+------------------------
+
+No API changes since 0.7.0 rc1. Many documentation changes including a stylish
+new `Sphinx theme <https://github.com/coordt/ADCtheme/>`_.
+
+The full set of changes since 0.6.0 are:
+
+* Python 3 compatibility
+* Ability to mock magic methods with `Mock` and addition of `MagicMock`
+  with pre-created magic methods
+* Addition of `mocksignature` and `mocksignature` argument to `patch` and
+  `patch.object`
+* Addition of `patch.dict` for changing dictionaries during a test
+* Ability to use `patch`, `patch.object` and `patch.dict` as class decorators
+* Renamed ``patch_object`` to `patch.object` (``patch_object`` is
+  deprecated)
+* Addition of soft comparisons: `call_args`, `call_args_list` and `method_calls`
+  now return tuple-like objects which compare equal even when empty args
+  or kwargs are skipped
+* patchers (`patch`, `patch.object` and `patch.dict`) have start and stop
+  methods
+* Addition of `assert_called_once_with` method
+* Mocks can now be named (`name` argument to constructor) and the name is used
+  in the repr
+* repr of a mock with a spec includes the class name of the spec
+* `assert_called_with` works with `python -OO`
+* New `spec_set` keyword argument to `Mock` and `patch`. If used,
+  attempting to *set* an attribute on a mock not on the spec will raise an
+  `AttributeError`
+* Mocks created with a spec can now pass `isinstance` tests (`__class__`
+  returns the type of the spec)
+* Added docstrings to all objects
+* Improved failure message for `Mock.assert_called_with` when the mock
+  has not been called at all
+* Decorated functions / methods have their docstring and `__module__`
+  preserved on Python 2.4.
+* BUGFIX: `mock.patch` now works correctly with certain types of objects that
+  proxy attribute access, like the django settings object
+* BUGFIX: mocks are now copyable (thanks to Ned Batchelder for reporting and
+  diagnosing this)
+* BUGFIX: `spec=True` works with old style classes
+* BUGFIX: ``help(mock)`` works now (on the module). Can no longer use ``__bases__``
+  as a valid sentinel name (thanks to Stephen Emslie for reporting and
+  diagnosing this)
+* BUGFIX: ``side_effect`` now works with ``BaseException`` exceptions like
+  ``KeyboardInterrupt``
+* BUGFIX: `reset_mock` caused infinite recursion when a mock is set as its own
+  return value
+* BUGFIX: patching the same object twice now restores the patches correctly
+* with statement tests now skipped on Python 2.4
+* Tests require unittest2 (or unittest2-py3k) to run
+* Tested with `tox <http://pypi.python.org/pypi/tox>`_ on Python 2.4 - 3.2,
+  jython and pypy (excluding 3.0)
+* Added 'build_sphinx' command to setup.py (requires setuptools or distribute)
+  Thanks to Florian Bauer
+* Switched from subversion to mercurial for source code control
+* `Konrad Delong <http://konryd.blogspot.com/>`_ added as co-maintainer
+
+
+2011/02/16 Version 0.7.0 RC 1
+-----------------------------
+
+Changes since beta 4:
+
+* Tested with jython, pypy and Python 3.2 and 3.1
+* Decorated functions / methods have their docstring and `__module__`
+  preserved on Python 2.4
+* BUGFIX: `mock.patch` now works correctly with certain types of objects that
+  proxy attribute access, like the django settings object
+* BUGFIX: `reset_mock` caused infinite recursion when a mock is set as its own
+  return value
+
+
+2010/11/12 Version 0.7.0 beta 4
+-------------------------------
+
+* patchers (`patch`, `patch.object` and `patch.dict`) have start and stop
+  methods
+* Addition of `assert_called_once_with` method
+* repr of a mock with a spec includes the class name of the spec
+* `assert_called_with` works with `python -OO`
+* New `spec_set` keyword argument to `Mock` and `patch`. If used,
+  attempting to *set* an attribute on a mock not on the spec will raise an
+  `AttributeError`
+* Attributes and return value of a `MagicMock` are `MagicMock` objects
+* Attempting to set an unsupported magic method now raises an `AttributeError`
+* `patch.dict` works as a class decorator
+* Switched from subversion to mercurial for source code control
+* BUGFIX: mocks are now copyable (thanks to Ned Batchelder for reporting and
+  diagnosing this)
+* BUGFIX: `spec=True` works with old style classes
+* BUGFIX: `mocksignature=True` can now patch instance methods via
+  `patch.object`
+
+
+2010/09/18 Version 0.7.0 beta 3
+-------------------------------
+
+* Using spec with :class:`MagicMock` only pre-creates magic methods in the spec
+* Setting a magic method on a mock with a ``spec`` can only be done if the
+  spec has that method
+* Mocks can now be named (`name` argument to constructor) and the name is used
+  in the repr
+* `mocksignature` can now be used with classes (signature based on `__init__`)
+  and callable objects (signature based on `__call__`)
+* Mocks created with a spec can now pass `isinstance` tests (`__class__`
+  returns the type of the spec)
+* Default numeric value for MagicMock is 1 rather than zero (because the
+  MagicMock bool defaults to True and 0 is False)
+* Improved failure message for :meth:`~Mock.assert_called_with` when the mock
+  has not been called at all
+* Adding the following to the set of supported magic methods:
+
+  - ``__getformat__`` and ``__setformat__``
+  - pickle methods
+  - ``__trunc__``, ``__ceil__`` and ``__floor__``
+  - ``__sizeof__``
+
+* Added 'build_sphinx' command to setup.py (requires setuptools or distribute)
+  Thanks to Florian Bauer
+* with statement tests now skipped on Python 2.4
+* Tests require unittest2 to run on Python 2.7
+* Improved several docstrings and documentation
+
+
+2010/06/23 Version 0.7.0 beta 2
+-------------------------------
+
+* :func:`patch.dict` works as a context manager as well as a decorator
+* ``patch.dict`` takes a string to specify dictionary as well as a dictionary
+  object. If a string is supplied the name specified is imported
+* BUGFIX: ``patch.dict`` restores dictionary even when an exception is raised
+
+
+2010/06/22 Version 0.7.0 beta 1
+-------------------------------
+
+* Addition of :func:`mocksignature`
+* Ability to mock magic methods
+* Ability to use ``patch`` and ``patch.object`` as class decorators
+* Renamed ``patch_object`` to :func:`patch.object` (``patch_object`` is
+  deprecated)
+* Addition of :class:`MagicMock` class with all magic methods pre-created for you
+* Python 3 compatibility (tested with 3.2 but should work with 3.0 & 3.1 as
+  well)
+* Addition of :func:`patch.dict` for changing dictionaries during a test
+* Addition of ``mocksignature`` argument to ``patch`` and ``patch.object``
+* ``help(mock)`` works now (on the module). Can no longer use ``__bases__``
+  as a valid sentinel name (thanks to Stephen Emslie for reporting and
+  diagnosing this)
+* Addition of soft comparisons: `call_args`, `call_args_list` and `method_calls`
+  now return tuple-like objects which compare equal even when empty args
+  or kwargs are skipped
+* Added docstrings.
+* BUGFIX: ``side_effect`` now works with ``BaseException`` exceptions like
+  ``KeyboardInterrupt``
+* BUGFIX: patching the same object twice now restores the patches correctly
+* The tests now require `unittest2 <http://pypi.python.org/pypi/unittest2>`_
+  to run
+* `Konrad Delong <http://konryd.blogspot.com/>`_ added as co-maintainer
+
+
+2009/08/22 Version 0.6.0
+------------------------
+
+* New test layout compatible with test discovery
+* Descriptors (static methods / class methods etc) can now be patched and
+  restored correctly
+* Mocks can raise exceptions when called by setting ``side_effect`` to an
+  exception class or instance
+* Mocks that wrap objects will not pass on calls to the underlying object if
+  an explicit return_value is set
+
+
+2009/04/17 Version 0.5.0
+------------------------
+
+* Made DEFAULT part of the public api.
+* Documentation built with Sphinx.
+* ``side_effect`` is now called with the same arguments as the mock is called with and
+  if returns a non-DEFAULT value that is automatically set as the ``mock.return_value``.
+* ``wraps`` keyword argument used for wrapping objects (and passing calls through to the wrapped object).
+* ``Mock.reset`` renamed to ``Mock.reset_mock``, as reset is a common API name.
+* ``patch`` / ``patch_object`` are now context managers and can be used with ``with``.
+* A new 'create' keyword argument to patch and patch_object that allows them to patch
+  (and unpatch) attributes that don't exist. (Potentially unsafe to use - it can allow
+  you to have tests that pass when they are testing an API that doesn't exist - use at
+  your own risk!)
+* The methods keyword argument to Mock has been removed and merged with spec. The spec
+  argument can now be a list of methods or an object to take the spec from.
+* Nested patches may now be applied in a different order (created mocks passed
+  in the opposite order). This is actually a bugfix.
+* patch and patch_object now take a spec keyword argument. If spec is
+  passed in as 'True' then the Mock created will take the object it is replacing
+  as its spec object. If the object being replaced is a class, then the return
+  value for the mock will also use the class as a spec.
+* A Mock created without a spec will not attempt to mock any magic methods / attributes
+  (they will raise an ``AttributeError`` instead).
+
+
+2008/10/12 Version 0.4.0
+------------------------
+
+* Default return value is now a new mock rather than None
+* return_value added as a keyword argument to the constructor
+* New method 'assert_called_with'
+* Added 'side_effect' attribute / keyword argument called when mock is called
+* patch decorator split into two decorators:
+
+    - ``patch_object`` which takes an object and an attribute name to patch
+      (plus optionally a value to patch with which defaults to a mock object)
+    - ``patch`` which takes a string specifying a target to patch; in the form
+      'package.module.Class.attribute'. (plus optionally a value to
+      patch with which defaults to a mock object)
+
+* Can now patch objects with ``None``
+* Change to patch for nose compatibility with error reporting in wrapped functions
+* Reset no longer clears children / return value etc - it just resets
+  call count and call args. It also calls reset on all children (and
+  the return value if it is a mock).
+
+Thanks to Konrad Delong, Kevin Dangoor and others for patches and suggestions.
+
+
+2007/12/03  Version 0.3.1
+-------------------------
+
+``patch`` maintains the name of decorated functions for compatibility with nose
+test autodiscovery.
+
+Tests decorated with ``patch`` that use the two argument form (implicit mock
+creation) will receive the mock(s) passed in as extra arguments.
+
+Thanks to Kevin Dangoor for these changes.
+
+
+2007/11/30  Version 0.3.0
+-------------------------
+
+Removed ``patch_module``. ``patch`` can now take a string as the first
+argument for patching modules.
+
+The third argument to ``patch`` is optional - a mock will be created by
+default if it is not passed in.
+
+
+2007/11/21  Version 0.2.1
+-------------------------
+
+Bug fix, allows reuse of functions decorated with ``patch`` and ``patch_module``.
+
+
+2007/11/20  Version 0.2.0
+-------------------------
+
+Added ``spec`` keyword argument for creating ``Mock`` objects from a
+specification object.
+
+Added ``patch`` and ``patch_module`` monkey patching decorators.
+
+Added ``sentinel`` for convenient access to unique objects.
+
+Distribution includes unit tests.
+
+
+2007/11/19  Version 0.1.0
+-------------------------
+
+Initial release.
+
+
+TODO and Limitations
+====================
+
+Contributions, bug reports and comments welcomed!
+
+Feature requests and bug reports are handled on the issue tracker:
+
+ * `mock issue tracker <http://code.google.com/p/mock/issues/list>`_
+
+`wraps` is not integrated with magic methods.
+
+`patch` could auto-do the patching in the constructor and unpatch in the
+destructor. This would be useful in itself, but violates TOOWTDI and would be
+unsafe for IronPython & PyPy (non-deterministic calling of destructors).
+Destructors aren't called in CPython where there are cycles, but a weak
+reference with a callback can be used to get round this.
+
+`Mock` has several attributes. This makes it unsuitable for mocking objects
+that use these attribute names. A way round this would be to provide methods
+that *hide* these attributes when needed. In 0.8 many, but not all, of these
+attributes are renamed to gain a `_mock` prefix, making it less likely that
+they will clash. Any outstanding attributes that haven't been modified with
+the prefix should be changed.
+
+If a patch is started using `patch.start` and then not stopped correctly then
+the unpatching is not done. Using weak references it would be possible to
+detect and fix this when the patch object itself is garbage collected. This
+would be tricky to get right though.
+
+When a `Mock` is created by `patch`, arbitrary keywords can be used to set
+attributes. If `patch` is created with a `spec`, and is replacing a class, then
+a `return_value` mock is created. The keyword arguments are not applied to the
+child mock, but could be.
+
+When mocking a class with `patch`, passing in `spec=True` or `autospec=True`,
+the mock class has an instance created from the same spec. Should this be the
+default behaviour for mocks anyway (mock return values inheriting the spec
+from their parent), or should it be controlled by an additional keyword
+argument (`inherit`) to the Mock constructor? `create_autospec` does this, so
+an additional keyword argument to Mock is probably unnecessary.
+
+The `mocksignature` argument to `patch` with a non `Mock` passed into
+`new_callable` will *probably* cause an error. Should it just be invalid?
+
+Note that `NonCallableMock` and `NonCallableMagicMock` still have the unused
+(and unusable) attributes: `return_value`, `side_effect`, `call_count`,
+`call_args` and `call_args_list`. These could be removed or raise errors on
+getting / setting. They also have the `assert_called_with` and
+`assert_called_once_with` methods. Removing these would be pointless as
+fetching them would create a mock (attribute) that could be called without
+error.
+
+Some outstanding technical debt. The way autospeccing mocks function
+signatures was copied and modified from `mocksignature`. This could all be
+refactored into one set of functions instead of two. The way we tell if
+patchers are started and if a patcher is being used for a `patch.multiple`
+call are both horrible. There are now a host of helper functions that should
+be rationalised. (Probably time to split mock into a package instead of a
+module.)
+
+Passing arbitrary keyword arguments to `create_autospec`, or `patch` with
+`autospec`, when mocking a *function* works fine. However, the arbitrary
+attributes are set on the created mock - but `create_autospec` returns a
+real function (which doesn't have those attributes). However, what is the use
+case for using autospec to create functions with attributes that don't exist
+on the original?
+
+`mocksignature`, plus the `call_args_list` and `method_calls` attributes of
+`Mock` could all be deprecated.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/compare.txt
@@ -0,0 +1,628 @@
+=========================
+ Mock Library Comparison
+=========================
+
+
+.. testsetup::
+
+    def assertEqual(a, b):
+        assert a == b, ("%r != %r" % (a, b))
+
+    def assertRaises(Exc, func):
+        try:
+            func()
+        except Exc:
+            return
+        assert False, ("%s not raised" % Exc)
+
+    sys.modules['somemodule'] = somemodule = mock.Mock(name='somemodule')
+    class SomeException(Exception):
+        some_method = method1 = method2 = None
+    some_other_object = SomeObject = SomeException
+
+
+A side-by-side comparison of how to accomplish some basic tasks with mock and
+some other popular Python mocking libraries and frameworks.
+
+These are:
+
+* `flexmock <http://pypi.python.org/pypi/flexmock>`_
+* `mox <http://pypi.python.org/pypi/mox>`_
+* `Mocker <http://niemeyer.net/mocker>`_
+* `dingus <http://pypi.python.org/pypi/dingus>`_
+* `fudge <http://pypi.python.org/pypi/fudge>`_
+
+Popular python mocking frameworks not yet represented here include
+`MiniMock <http://pypi.python.org/pypi/MiniMock>`_.
+
+`pMock <http://pmock.sourceforge.net/>`_ (last release 2004 and doesn't import
+in recent versions of Python) and
+`python-mock <http://python-mock.sourceforge.net/>`_ (last release 2005) are
+intentionally omitted.
+
+.. note::
+
+    A more up to date, and tested for all mock libraries (only the mock
+    examples on this page can be executed as doctests) version of this
+    comparison is maintained by Gary Bernhardt:
+
+    * `Python Mock Library Comparison
+      <http://garybernhardt.github.com/python-mock-comparison/>`_
+
+This comparison is by no means complete, and also may not be fully idiomatic
+for all the libraries represented. *Please* contribute corrections, missing
+comparisons, or comparisons for additional libraries to the `mock issue
+tracker <https://code.google.com/p/mock/issues/list>`_.
+
+This comparison page was originally created by the `Mox project
+<https://code.google.com/p/pymox/wiki/MoxComparison>`_ and then extended for
+`flexmock and mock <http://has207.github.com/flexmock/compare.html>`_ by
+Herman Sheremetyev. Dingus examples written by `Gary Bernhadt
+<http://garybernhardt.github.com/python-mock-comparison/>`_. fudge examples
+provided by `Kumar McMillan <http://farmdev.com/>`_.
+
+.. note::
+
+    The examples tasks here were originally created by Mox which is a mocking
+    *framework* rather than a library like mock. The tasks shown naturally
+    exemplify tasks that frameworks are good at and not the ones they make
+    harder. In particular you can take a `Mock` or `MagicMock` object and use
+    it in any way you want with no up-front configuration. The same is also
+    true for Dingus.
+
+    The examples for mock here assume version 0.7.0.
+
+
+Simple fake object
+~~~~~~~~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.Mock()
+    >>> my_mock.some_method.return_value = "calculated value"
+    >>> my_mock.some_attribute = "value"
+    >>> assertEqual("calculated value", my_mock.some_method())
+    >>> assertEqual("value", my_mock.some_attribute)
+
+::
+
+    # Flexmock
+    mock = flexmock(some_method=lambda: "calculated value", some_attribute="value")
+    assertEqual("calculated value", mock.some_method())
+    assertEqual("value", mock.some_attribute)
+
+    # Mox
+    mock = mox.MockAnything()
+    mock.some_method().AndReturn("calculated value")
+    mock.some_attribute = "value"
+    mox.Replay(mock)
+    assertEqual("calculated value", mock.some_method())
+    assertEqual("value", mock.some_attribute)
+
+    # Mocker
+    mock = mocker.mock()
+    mock.some_method()
+    mocker.result("calculated value")
+    mocker.replay()
+    mock.some_attribute = "value"
+    assertEqual("calculated value", mock.some_method())
+    assertEqual("value", mock.some_attribute)
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus(some_attribute="value",
+    ...                           some_method__returns="calculated value")
+    >>> assertEqual("calculated value", my_dingus.some_method())
+    >>> assertEqual("value", my_dingus.some_attribute)
+
+::
+
+    >>> # fudge
+    >>> my_fake = (fudge.Fake()
+    ...            .provides('some_method')
+    ...            .returns("calculated value")
+    ...            .has_attr(some_attribute="value"))
+    ...
+    >>> assertEqual("calculated value", my_fake.some_method())
+    >>> assertEqual("value", my_fake.some_attribute)
+
+
+Simple mock
+~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.Mock()
+    >>> my_mock.some_method.return_value = "value"
+    >>> assertEqual("value", my_mock.some_method())
+    >>> my_mock.some_method.assert_called_once_with()
+
+::
+
+    # Flexmock
+    mock = flexmock()
+    mock.should_receive("some_method").and_return("value").once
+    assertEqual("value", mock.some_method())
+
+    # Mox
+    mock = mox.MockAnything()
+    mock.some_method().AndReturn("value")
+    mox.Replay(mock)
+    assertEqual("value", mock.some_method())
+    mox.Verify(mock)
+
+    # Mocker
+    mock = mocker.mock()
+    mock.some_method()
+    mocker.result("value")
+    mocker.replay()
+    assertEqual("value", mock.some_method())
+    mocker.verify()
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus(some_method__returns="value")
+    >>> assertEqual("value", my_dingus.some_method())
+    >>> assert my_dingus.some_method.calls().once()
+
+::
+
+    >>> # fudge
+    >>> @fudge.test
+    ... def test():
+    ...     my_fake = (fudge.Fake()
+    ...                .expects('some_method')
+    ...                .returns("value")
+    ...                .times_called(1))
+    ...
+    >>> test()
+    Traceback (most recent call last):
+    ...
+    AssertionError: fake:my_fake.some_method() was not called
+
+
+Creating partial mocks
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> SomeObject.some_method = mock.Mock(return_value='value')
+    >>> assertEqual("value", SomeObject.some_method())
+
+::
+
+    # Flexmock
+    flexmock(SomeObject).should_receive("some_method").and_return('value')
+    assertEqual("value", mock.some_method())
+
+    # Mox
+    mock = mox.MockObject(SomeObject)
+    mock.some_method().AndReturn("value")
+    mox.Replay(mock)
+    assertEqual("value", mock.some_method())
+    mox.Verify(mock)
+
+    # Mocker
+    mock = mocker.mock(SomeObject)
+    mock.Get()
+    mocker.result("value")
+    mocker.replay()
+    assertEqual("value", mock.some_method())
+    mocker.verify()
+
+::
+
+    >>> # Dingus
+    >>> object = SomeObject
+    >>> object.some_method = dingus.Dingus(return_value="value")
+    >>> assertEqual("value", object.some_method())
+
+::
+
+    >>> # fudge
+    >>> fake = fudge.Fake().is_callable().returns("<fudge-value>")
+    >>> with fudge.patched_context(SomeObject, 'some_method', fake):
+    ...     s = SomeObject()
+    ...     assertEqual("<fudge-value>", s.some_method())
+    ...
+
+
+Ensure calls are made in specific order
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.Mock(spec=SomeObject)
+    >>> my_mock.method1()
+    <Mock name='mock.method1()' id='...'>
+    >>> my_mock.method2()
+    <Mock name='mock.method2()' id='...'>
+    >>> assertEqual(my_mock.mock_calls, [call.method1(), call.method2()])
+
+::
+
+    # Flexmock
+    mock = flexmock(SomeObject)
+    mock.should_receive('method1').once.ordered.and_return('first thing')
+    mock.should_receive('method2').once.ordered.and_return('second thing')
+
+    # Mox
+    mock = mox.MockObject(SomeObject)
+    mock.method1().AndReturn('first thing')
+    mock.method2().AndReturn('second thing')
+    mox.Replay(mock)
+    mox.Verify(mock)
+
+    # Mocker
+    mock = mocker.mock()
+    with mocker.order():
+        mock.method1()
+        mocker.result('first thing')
+        mock.method2()
+        mocker.result('second thing')
+        mocker.replay()
+        mocker.verify()
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus()
+    >>> my_dingus.method1()
+    <Dingus ...>
+    >>> my_dingus.method2()
+    <Dingus ...>
+    >>> assertEqual(['method1', 'method2'], [call.name for call in my_dingus.calls])
+
+::
+
+    >>> # fudge
+    >>> @fudge.test
+    ... def test():
+    ...     my_fake = (fudge.Fake()
+    ...                .remember_order()
+    ...                .expects('method1')
+    ...                .expects('method2'))
+    ...     my_fake.method2()
+    ...     my_fake.method1()
+    ...
+    >>> test()
+    Traceback (most recent call last):
+    ...
+    AssertionError: Call #1 was fake:my_fake.method2(); Expected: #1 fake:my_fake.method1(), #2 fake:my_fake.method2(), end
+
+
+Raising exceptions
+~~~~~~~~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.Mock()
+    >>> my_mock.some_method.side_effect = SomeException("message")
+    >>> assertRaises(SomeException, my_mock.some_method)
+
+::
+
+    # Flexmock
+    mock = flexmock()
+    mock.should_receive("some_method").and_raise(SomeException("message"))
+    assertRaises(SomeException, mock.some_method)
+
+    # Mox
+    mock = mox.MockAnything()
+    mock.some_method().AndRaise(SomeException("message"))
+    mox.Replay(mock)
+    assertRaises(SomeException, mock.some_method)
+    mox.Verify(mock)
+
+    # Mocker
+    mock = mocker.mock()
+    mock.some_method()
+    mocker.throw(SomeException("message"))
+    mocker.replay()
+    assertRaises(SomeException, mock.some_method)
+    mocker.verify()
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus()
+    >>> my_dingus.some_method = dingus.exception_raiser(SomeException)
+    >>> assertRaises(SomeException, my_dingus.some_method)
+
+::
+
+    >>> # fudge
+    >>> my_fake = (fudge.Fake()
+    ...            .is_callable()
+    ...            .raises(SomeException("message")))
+    ...
+    >>> my_fake()
+    Traceback (most recent call last):
+    ...
+    SomeException: message
+
+
+Override new instances of a class
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> with mock.patch('somemodule.Someclass') as MockClass:
+    ...     MockClass.return_value = some_other_object
+    ...     assertEqual(some_other_object, somemodule.Someclass())
+    ...
+
+
+::
+
+    # Flexmock
+    flexmock(some_module.SomeClass, new_instances=some_other_object)
+    assertEqual(some_other_object, some_module.SomeClass())
+
+    # Mox
+    # (you will probably have mox.Mox() available as self.mox in a real test)
+    mox.Mox().StubOutWithMock(some_module, 'SomeClass', use_mock_anything=True)
+    some_module.SomeClass().AndReturn(some_other_object)
+    mox.ReplayAll()
+    assertEqual(some_other_object, some_module.SomeClass())
+
+    # Mocker
+    instance = mocker.mock()
+    klass = mocker.replace(SomeClass, spec=None)
+    klass('expected', 'args')
+    mocker.result(instance)
+
+::
+
+    >>> # Dingus
+    >>> MockClass = dingus.Dingus(return_value=some_other_object)
+    >>> with dingus.patch('somemodule.SomeClass', MockClass):
+    ...     assertEqual(some_other_object, somemodule.SomeClass())
+    ...
+
+::
+
+    >>> # fudge
+    >>> @fudge.patch('somemodule.SomeClass')
+    ... def test(FakeClass):
+    ...     FakeClass.is_callable().returns(some_other_object)
+    ...     assertEqual(some_other_object, somemodule.SomeClass())
+    ...
+    >>> test()
+
+
+Call the same method multiple times
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. note::
+
+    You don't need to do *any* configuration to call `mock.Mock()` methods
+    multiple times. Attributes like `call_count`, `call_args_list` and
+    `method_calls` provide various different ways of making assertions about
+    how the mock was used.
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.Mock()
+    >>> my_mock.some_method()
+    <Mock name='mock.some_method()' id='...'>
+    >>> my_mock.some_method()
+    <Mock name='mock.some_method()' id='...'>
+    >>> assert my_mock.some_method.call_count >= 2
+
+::
+
+    # Flexmock # (verifies that the method gets called at least twice)
+    flexmock(some_object).should_receive('some_method').at_least.twice
+
+    # Mox
+    # (does not support variable number of calls, so you need to create a new entry for each explicit call)
+    mock = mox.MockObject(some_object)
+    mock.some_method(mox.IgnoreArg(), mox.IgnoreArg())
+    mock.some_method(mox.IgnoreArg(), mox.IgnoreArg())
+    mox.Replay(mock)
+    mox.Verify(mock)
+
+    # Mocker
+    # (TODO)
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus()
+    >>> my_dingus.some_method()
+    <Dingus ...>
+    >>> my_dingus.some_method()
+    <Dingus ...>
+    >>> assert len(my_dingus.calls('some_method')) == 2
+
+::
+
+    >>> # fudge
+    >>> @fudge.test
+    ... def test():
+    ...     my_fake = fudge.Fake().expects('some_method').times_called(2)
+    ...     my_fake.some_method()
+    ...
+    >>> test()
+    Traceback (most recent call last):
+    ...
+    AssertionError: fake:my_fake.some_method() was called 1 time(s). Expected 2.
+
+
+Mock chained methods
+~~~~~~~~~~~~~~~~~~~~
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.Mock()
+    >>> method3 = my_mock.method1.return_value.method2.return_value.method3
+    >>> method3.return_value = 'some value'
+    >>> assertEqual('some value', my_mock.method1().method2().method3(1, 2))
+    >>> method3.assert_called_once_with(1, 2)
+
+::
+
+    # Flexmock
+    # (intermediate method calls are automatically assigned to temporary fake objects
+    # and can be called with any arguments)
+    flexmock(some_object).should_receive(
+        'method1.method2.method3'
+    ).with_args(arg1, arg2).and_return('some value')
+    assertEqual('some_value', some_object.method1().method2().method3(arg1, arg2))
+
+::
+
+    # Mox
+    mock = mox.MockObject(some_object)
+    mock2 = mox.MockAnything()
+    mock3 = mox.MockAnything()
+    mock.method1().AndReturn(mock1)
+    mock2.method2().AndReturn(mock2)
+    mock3.method3(arg1, arg2).AndReturn('some_value')
+    self.mox.ReplayAll()
+    assertEqual("some_value", some_object.method1().method2().method3(arg1, arg2))
+    self.mox.VerifyAll()
+
+    # Mocker
+    # (TODO)
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus()
+    >>> method3 = my_dingus.method1.return_value.method2.return_value.method3
+    >>> method3.return_value = 'some value'
+    >>> assertEqual('some value', my_dingus.method1().method2().method3(1, 2))
+    >>> assert method3.calls('()', 1, 2).once()
+
+::
+
+    >>> # fudge
+    >>> @fudge.test
+    ... def test():
+    ...     my_fake = fudge.Fake()
+    ...     (my_fake
+    ...      .expects('method1')
+    ...      .returns_fake()
+    ...      .expects('method2')
+    ...      .returns_fake()
+    ...      .expects('method3')
+    ...      .with_args(1, 2)
+    ...      .returns('some value'))
+    ...     assertEqual('some value', my_fake.method1().method2().method3(1, 2))
+    ...
+    >>> test()
+
+
+Mocking a context manager
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Examples for mock, Dingus and fudge only (so far):
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.MagicMock()
+    >>> with my_mock:
+    ...     pass
+    ...
+    >>> my_mock.__enter__.assert_called_with()
+    >>> my_mock.__exit__.assert_called_with(None, None, None)
+
+::
+
+
+    >>> # Dingus (nothing special here; all dinguses are "magic mocks")
+    >>> my_dingus = dingus.Dingus()
+    >>> with my_dingus:
+    ...     pass
+    ...
+    >>> assert my_dingus.__enter__.calls()
+    >>> assert my_dingus.__exit__.calls('()', None, None, None)
+
+::
+
+    >>> # fudge
+    >>> my_fake = fudge.Fake().provides('__enter__').provides('__exit__')
+    >>> with my_fake:
+    ...     pass
+    ...
+
+
+Mocking the builtin open used as a context manager
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Example for mock only (so far):
+
+.. doctest::
+
+    >>> # mock
+    >>> my_mock = mock.MagicMock()
+    >>> with mock.patch('__builtin__.open', my_mock):
+    ...     manager = my_mock.return_value.__enter__.return_value
+    ...     manager.read.return_value = 'some data'
+    ...     with open('foo') as h:
+    ...         data = h.read()
+    ...
+    >>> data
+    'some data'
+    >>> my_mock.assert_called_once_with('foo')
+
+*or*:
+
+.. doctest::
+
+    >>> # mock
+    >>> with mock.patch('__builtin__.open') as my_mock:
+    ...     my_mock.return_value.__enter__ = lambda s: s
+    ...     my_mock.return_value.__exit__ = mock.Mock()
+    ...     my_mock.return_value.read.return_value = 'some data'
+    ...     with open('foo') as h:
+    ...         data = h.read()
+    ...
+    >>> data
+    'some data'
+    >>> my_mock.assert_called_once_with('foo')
+
+::
+
+    >>> # Dingus
+    >>> my_dingus = dingus.Dingus()
+    >>> with dingus.patch('__builtin__.open', my_dingus):
+    ...     file_ = open.return_value.__enter__.return_value
+    ...     file_.read.return_value = 'some data'
+    ...     with open('foo') as h:
+    ...         data = f.read()
+    ...
+    >>> data
+    'some data'
+    >>> assert my_dingus.calls('()', 'foo').once()
+
+::
+
+    >>> # fudge
+    >>> from contextlib import contextmanager
+    >>> from StringIO import StringIO
+    >>> @contextmanager
+    ... def fake_file(filename):
+    ...     yield StringIO('sekrets')
+    ...
+    >>> with fudge.patch('__builtin__.open') as fake_open:
+    ...     fake_open.is_callable().calls(fake_file)
+    ...     with open('/etc/password') as f:
+    ...         data = f.read()
+    ...
+    fake:__builtin__.open
+    >>> data
+    'sekrets'
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/conf.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+#
+# Mock documentation build configuration file, created by
+# sphinx-quickstart on Mon Nov 17 18:12:00 2008.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# The contents of this file are pickled, so don't put values in the namespace
+# that aren't pickleable (module imports are okay, they're removed automatically).
+#
+# All configuration values have a default value; values that are commented out
+# serve to show the default value.
+
+import sys, os
+sys.path.insert(0, os.path.abspath('..'))
+from mock import __version__
+
+# If your extensions are in another directory, add it here. If the directory
+# is relative to the documentation root, use os.path.abspath to make it
+# absolute, like shown here.
+#sys.path.append(os.path.abspath('some/directory'))
+
+# General configuration
+# ---------------------
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.doctest']
+
+doctest_global_setup = """
+import os
+import sys
+import mock
+from mock import * # yeah, I know :-/
+import unittest2
+import __main__
+
+if os.getcwd() not in sys.path:
+    sys.path.append(os.getcwd())
+
+# keep a reference to __main__
+sys.modules['__main'] = __main__
+
+class ProxyModule(object):
+    def __init__(self):
+        self.__dict__ = globals()
+
+sys.modules['__main__'] = ProxyModule()
+"""
+
+doctest_global_cleanup = """
+sys.modules['__main__'] = sys.modules['__main']
+"""
+
+html_theme = 'nature'
+html_theme_options = {}
+
+# Add any paths that contain templates here, relative to this directory.
+#templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.txt'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General substitutions.
+project = u'Mock'
+copyright = u'2007-2012, Michael Foord & the mock team'
+
+# The default replacements for |version| and |release|, also used in various
+# other places throughout the built documents.
+#
+# The short X.Y version.
+version = __version__[:3]
+# The full version, including alpha/beta/rc tags.
+release = __version__
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+today_fmt = '%B %d, %Y'
+
+# List of documents that shouldn't be included in the build.
+#unused_docs = []
+
+# List of directories, relative to source directories, that shouldn't be searched
+# for source files.
+exclude_trees = []
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+add_module_names = False
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'friendly'
+
+
+# Options for HTML output
+# -----------------------
+
+# The style sheet to use for HTML and HTML Help pages. A file of that name
+# must exist either in Sphinx' static/ path, or in one of the custom paths
+# given in html_static_path.
+#html_style = 'adctheme.css'
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+#html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+html_use_modindex = False
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, the reST sources are included in the HTML build as _sources/<name>.
+#html_copy_source = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = ''
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Mockdoc'
+
+
+# Options for LaTeX output
+# ------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+latex_font_size = '12pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, document class [howto/manual]).
+latex_documents = [
+  ('index', 'Mock.tex', u'Mock Documentation',
+   u'Michael Foord', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+latex_use_modindex = False
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/examples.txt
@@ -0,0 +1,1063 @@
+.. _further-examples:
+
+==================
+ Further Examples
+==================
+
+.. currentmodule:: mock
+
+.. testsetup::
+
+    from datetime import date
+
+    BackendProvider = Mock()
+    sys.modules['mymodule'] = mymodule = Mock(name='mymodule')
+
+    def grob(val):
+        "First frob and then clear val"
+        mymodule.frob(val)
+        val.clear()
+
+    mymodule.frob = lambda val: val
+    mymodule.grob = grob
+    mymodule.date = date
+
+    class TestCase(unittest2.TestCase):
+        def run(self):
+            result = unittest2.TestResult()
+            out = unittest2.TestCase.run(self, result)
+            assert result.wasSuccessful()
+
+    from mock import inPy3k
+
+
+
+For comprehensive examples, see the unit tests included in the full source
+distribution.
+
+Here are some more examples for some slightly more advanced scenarios than in
+the :ref:`getting started <getting-started>` guide.
+
+
+Mocking chained calls
+=====================
+
+Mocking chained calls is actually straightforward with mock once you
+understand the :attr:`~Mock.return_value` attribute. When a mock is called for
+the first time, or you fetch its `return_value` before it has been called, a
+new `Mock` is created.
+
+This means that you can see how the object returned from a call to a mocked
+object has been used by interrogating the `return_value` mock:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> mock().foo(a=2, b=3)
+    <Mock name='mock().foo()' id='...'>
+    >>> mock.return_value.foo.assert_called_with(a=2, b=3)
+
+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...
+
+So, suppose we have some code that looks a little bit like this:
+
+.. doctest::
+
+    >>> class Something(object):
+    ...     def __init__(self):
+    ...         self.backend = BackendProvider()
+    ...     def method(self):
+    ...         response = self.backend.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
+    ...         # more code
+
+Assuming that `BackendProvider` is already well tested, how do we test
+`method()`? Specifically, we want to test that the code section `# more
+code` uses the response object in the correct way.
+
+As this chain of calls is made from an instance attribute we can monkey patch
+the `backend` attribute on a `Something` instance. In this particular case
+we are only interested in the return value from the final call to
+`start_call` 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 `file` as its `spec`.
+
+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
+`start_call` we could do this:
+
+    `mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response`.
+
+We can do that in a slightly nicer way using the :meth:`~Mock.configure_mock`
+method to directly set the return value for us:
+
+.. doctest::
+
+    >>> something = Something()
+    >>> mock_response = Mock(spec=file)
+    >>> mock_backend = Mock()
+    >>> config = {'get_endpoint.return_value.create_call.return_value.start_call.return_value': mock_response}
+    >>> mock_backend.configure_mock(**config)
+
+With these we monkey patch the "mock backend" in place and can make the real
+call:
+
+.. doctest::
+
+    >>> something.backend = mock_backend
+    >>> something.method()
+
+Using :attr:`~Mock.mock_calls` 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 `mock_calls`. We can use :meth:`call.call_list` to create
+this list of calls for us:
+
+.. doctest::
+
+    >>> chained = call.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
+    >>> call_list = chained.call_list()
+    >>> assert mock_backend.mock_calls == call_list
+
+
+Partial mocking
+===============
+
+In some tests I wanted to mock out a call to `datetime.date.today()
+<http://docs.python.org/library/datetime.html#datetime.date.today>`_ to return
+a known date, but I didn't want to prevent the code under test from
+creating new date objects. Unfortunately `datetime.date` is written in C, and
+so I couldn't just monkey-patch out the static `date.today` method.
+
+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).
+
+The :func:`patch decorator <patch>` is used here to
+mock out the `date` class in the module under test. The :attr:`side_effect`
+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 `side_effect`.
+
+.. doctest::
+
+    >>> from datetime import date
+    >>> with patch('mymodule.date') as mock_date:
+    ...     mock_date.today.return_value = date(2010, 10, 8)
+    ...     mock_date.side_effect = lambda *args, **kw: date(*args, **kw)
+    ...
+    ...     assert mymodule.date.today() == date(2010, 10, 8)
+    ...     assert mymodule.date(2009, 6, 8) == date(2009, 6, 8)
+    ...
+
+Note that we don't patch `datetime.date` globally, we patch `date` in the
+module that *uses* it. See :ref:`where to patch <where-to-patch>`.
+
+When `date.today()` is called a known date is returned, but calls to the
+`date(...)` 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.
+
+Calls to the date constructor are recorded in the `mock_date` attributes
+(`call_count` and friends) which may also be useful for your tests.
+
+An alternative way of dealing with mocking dates, or other builtin classes,
+is discussed in `this blog entry
+<http://williamjohnbert.com/2011/07/how-to-unit-testing-in-django-with-mocking-and-patching/>`_.
+
+
+Mocking a Generator Method
+==========================
+
+A Python generator is a function or method that uses the `yield statement
+<http://docs.python.org/reference/simple_stmts.html#the-yield-statement>`_ to
+return a series of values when iterated over [#]_.
+
+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 `__iter__
+<http://docs.python.org/library/stdtypes.html#container.__iter__>`_, so we can
+mock this using a `MagicMock`.
+
+Here's an example class with an "iter" method implemented as a generator:
+
+.. doctest::
+
+    >>> class Foo(object):
+    ...     def iter(self):
+    ...         for i in [1, 2, 3]:
+    ...             yield i
+    ...
+    >>> foo = Foo()
+    >>> list(foo.iter())
+    [1, 2, 3]
+
+
+How would we mock this class, and in particular its "iter" method?
+
+To configure the values returned from the iteration (implicit in the call to
+`list`), we need to configure the object returned by the call to `foo.iter()`.
+
+.. doctest::
+
+    >>> mock_foo = MagicMock()
+    >>> mock_foo.iter.return_value = iter([1, 2, 3])
+    >>> list(mock_foo.iter())
+    [1, 2, 3]
+
+.. [#] There are also generator expressions and more `advanced uses
+    <http://www.dabeaz.com/coroutines/index.html>`_ of generators, but we aren't
+    concerned about them here. A very good introduction to generators and how
+    powerful they are is: `Generator Tricks for Systems Programmers
+    <http://www.dabeaz.com/generators/>`_.
+
+
+Applying the same patch to every test method
+============================================
+
+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 `patch` (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 `test`:
+
+.. doctest::
+
+    >>> @patch('mymodule.SomeClass')
+    ... class MyTest(TestCase):
+    ...
+    ...     def test_one(self, MockSomeClass):
+    ...         self.assertTrue(mymodule.SomeClass is MockSomeClass)
+    ...
+    ...     def test_two(self, MockSomeClass):
+    ...         self.assertTrue(mymodule.SomeClass is MockSomeClass)
+    ...
+    ...     def not_a_test(self):
+    ...         return 'something'
+    ...
+    >>> MyTest('test_one').test_one()
+    >>> MyTest('test_two').test_two()
+    >>> MyTest('test_two').not_a_test()
+    'something'
+
+An alternative way of managing patches is to use the :ref:`start-and-stop`.
+These allow you to move the patching into your `setUp` and `tearDown` methods.
+
+.. doctest::
+
+    >>> class MyTest(TestCase):
+    ...     def setUp(self):
+    ...         self.patcher = patch('mymodule.foo')
+    ...         self.mock_foo = self.patcher.start()
+    ...
+    ...     def test_foo(self):
+    ...         self.assertTrue(mymodule.foo is self.mock_foo)
+    ...
+    ...     def tearDown(self):
+    ...         self.patcher.stop()
+    ...
+    >>> MyTest('test_foo').run()
+
+If you use this technique you must ensure that the patching is "undone" by
+calling `stop`. This can be fiddlier than you might think, because if an
+exception is raised in the setUp then tearDown is not called. `unittest2
+<http://pypi.python.org/pypi/unittest2>`_ cleanup functions make this simpler:
+
+
+.. doctest::
+
+    >>> class MyTest(TestCase):
+    ...     def setUp(self):
+    ...         patcher = patch('mymodule.foo')
+    ...         self.addCleanup(patcher.stop)
+    ...         self.mock_foo = patcher.start()
+    ...
+    ...     def test_foo(self):
+    ...         self.assertTrue(mymodule.foo is self.mock_foo)
+    ...
+    >>> MyTest('test_foo').run()
+
+
+Mocking Unbound Methods
+=======================
+
+Whilst writing tests today I needed to patch an *unbound method* (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 :func:`patch` decorator makes it so simple to
+patch out methods with a mock that having to create a real function becomes a
+nuisance.
+
+If you pass `autospec=True` to patch then it does the patching with a
+*real* 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 `self` passed in as the first argument, which is exactly what I
+wanted:
+
+.. doctest::
+
+    >>> class Foo(object):
+    ...   def foo(self):
+    ...     pass
+    ...
+    >>> with patch.object(Foo, 'foo', autospec=True) as mock_foo:
+    ...   mock_foo.return_value = 'foo'
+    ...   foo = Foo()
+    ...   foo.foo()
+    ...
+    'foo'
+    >>> mock_foo.assert_called_once_with(foo)
+
+If we don't use `autospec=True` then the unbound method is patched out
+with a Mock instance instead, and isn't called with `self`.
+
+
+Checking multiple calls with mock
+=================================
+
+mock has a nice API for making assertions about how your mock objects are used.
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> mock.foo_bar.return_value = None
+    >>> mock.foo_bar('baz', spam='eggs')
+    >>> mock.foo_bar.assert_called_with('baz', spam='eggs')
+
+If your mock is only being called once you can use the
+:meth:`assert_called_once_with` method that also asserts that the
+:attr:`call_count` is one.
+
+.. doctest::
+
+    >>> mock.foo_bar.assert_called_once_with('baz', spam='eggs')
+    >>> mock.foo_bar()
+    >>> mock.foo_bar.assert_called_once_with('baz', spam='eggs')
+    Traceback (most recent call last):
+        ...
+    AssertionError: Expected to be called once. Called 2 times.
+
+Both `assert_called_with` and `assert_called_once_with` make assertions about
+the *most recent* call. If your mock is going to be called several times, and
+you want to make assertions about *all* those calls you can use
+:attr:`~Mock.call_args_list`:
+
+.. doctest::
+
+    >>> mock = Mock(return_value=None)
+    >>> mock(1, 2, 3)
+    >>> mock(4, 5, 6)
+    >>> mock()
+    >>> mock.call_args_list
+    [call(1, 2, 3), call(4, 5, 6), call()]
+
+The :data:`call` helper makes it easy to make assertions about these calls. You
+can build up a list of expected calls and compare it to `call_args_list`. This
+looks remarkably similar to the repr of the `call_args_list`:
+
+.. doctest::
+
+    >>> expected = [call(1, 2, 3), call(4, 5, 6), call()]
+    >>> mock.call_args_list == expected
+    True
+
+
+Coping with mutable arguments
+=============================
+
+Another situation is rare, but can bite you, is when your mock is called with
+mutable arguments. `call_args` and `call_args_list` store *references* 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.
+
+Here's some example code that shows the problem. Imagine the following functions
+defined in 'mymodule'::
+
+    def frob(val):
+        pass
+
+    def grob(val):
+        "First frob and then clear val"
+        frob(val)
+        val.clear()
+
+When we try to test that `grob` calls `frob` with the correct argument look
+what happens:
+
+.. doctest::
+
+    >>> with patch('mymodule.frob') as mock_frob:
+    ...     val = set([6])
+    ...     mymodule.grob(val)
+    ...
+    >>> val
+    set([])
+    >>> mock_frob.assert_called_with(set([6]))
+    Traceback (most recent call last):
+        ...
+    AssertionError: Expected: ((set([6]),), {})
+    Called with: ((set([]),), {})
+
+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.
+
+Here's one solution that uses the :attr:`side_effect`
+functionality. If you provide a `side_effect` function for a mock then
+`side_effect` 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 *another* 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.
+
+.. doctest::
+
+    >>> from copy import deepcopy
+    >>> from mock import Mock, patch, DEFAULT
+    >>> def copy_call_args(mock):
+    ...     new_mock = Mock()
+    ...     def side_effect(*args, **kwargs):
+    ...         args = deepcopy(args)
+    ...         kwargs = deepcopy(kwargs)
+    ...         new_mock(*args, **kwargs)
+    ...         return DEFAULT
+    ...     mock.side_effect = side_effect
+    ...     return new_mock
+    ...
+    >>> with patch('mymodule.frob') as mock_frob:
+    ...     new_mock = copy_call_args(mock_frob)
+    ...     val = set([6])
+    ...     mymodule.grob(val)
+    ...
+    >>> new_mock.assert_called_with(set([6]))
+    >>> new_mock.call_args
+    call(set([6]))
+
+`copy_call_args` is called with the mock that will be called. It returns a new
+mock that we do the assertion on. The `side_effect` function makes a copy of
+the args and calls our `new_mock` with the copy.
+
+.. note::
+
+    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 `side_effect` function.
+
+    .. doctest::
+
+        >>> def side_effect(arg):
+        ...     assert arg == set([6])
+        ...
+        >>> mock = Mock(side_effect=side_effect)
+        >>> mock(set([6]))
+        >>> mock(set())
+        Traceback (most recent call last):
+            ...
+        AssertionError
+
+An alternative approach is to create a subclass of `Mock` or `MagicMock` that
+copies (using `copy.deepcopy
+<http://docs.python.org/library/copy.html#copy.deepcopy>`_) the arguments.
+Here's an example implementation:
+
+.. doctest::
+
+    >>> from copy import deepcopy
+    >>> class CopyingMock(MagicMock):
+    ...     def __call__(self, *args, **kwargs):
+    ...         args = deepcopy(args)
+    ...         kwargs = deepcopy(kwargs)
+    ...         return super(CopyingMock, self).__call__(*args, **kwargs)
+    ...
+    >>> c = CopyingMock(return_value=None)
+    >>> arg = set()
+    >>> c(arg)
+    >>> arg.add(1)
+    >>> c.assert_called_with(set())
+    >>> c.assert_called_with(arg)
+    Traceback (most recent call last):
+        ...
+    AssertionError: Expected call: mock(set([1]))
+    Actual call: mock(set([]))
+    >>> c.foo
+    <CopyingMock name='mock.foo' id='...'>
+
+When you subclass `Mock` or `MagicMock` all dynamically created attributes,
+and the `return_value` will use your subclass automatically. That means all
+children of a `CopyingMock` will also have the type `CopyingMock`.
+
+
+Raising exceptions on attribute access
+======================================
+
+You can use :class:`PropertyMock` to mimic the behaviour of properties. This
+includes raising exceptions when an attribute is accessed.
+
+Here's an example raising a `ValueError` when the 'foo' attribute is accessed:
+
+.. doctest::
+
+    >>> m = MagicMock()
+    >>> p = PropertyMock(side_effect=ValueError)
+    >>> type(m).foo = p
+    >>> m.foo
+    Traceback (most recent call last):
+    ....
+    ValueError
+
+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 `type(mock)` without affecting other mock objects.
+
+
+Multiple calls with different effects
+=====================================
+
+.. note::
+
+    In mock 1.0 the handling of iterable `side_effect` was changed. Any
+    exceptions in the iterable will be raised instead of returned.
+
+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).
+
+One approach is to use a :attr:`side_effect` function that replaces itself. The
+first time it is called the `side_effect` sets a new `side_effect` that will
+be used for the second call. It then raises an exception:
+
+.. doctest::
+
+    >>> def side_effect(*args):
+    ...   def second_call(*args):
+    ...     return 'response'
+    ...   mock.side_effect = second_call
+    ...   raise Exception('boom')
+    ...
+    >>> mock = Mock(side_effect=side_effect)
+    >>> mock('first')
+    Traceback (most recent call last):
+        ...
+    Exception: boom
+    >>> mock('second')
+    'response'
+    >>> mock.assert_called_with('second')
+
+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:
+
+.. doctest::
+
+    >>> returns = [Exception('boom'), 'response']
+    >>> def side_effect(*args):
+    ...   result = returns.pop(0)
+    ...   if isinstance(result, Exception):
+    ...     raise result
+    ...   return result
+    ...
+    >>> mock = Mock(side_effect=side_effect)
+    >>> mock('first')
+    Traceback (most recent call last):
+        ...
+    Exception: boom
+    >>> mock('second')
+    'response'
+    >>> mock.assert_called_with('second')
+
+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.
+
+
+Nesting Patches
+===============
+
+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:
+
+.. doctest::
+
+    >>> class MyTest(TestCase):
+    ...
+    ...     def test_foo(self):
+    ...         with patch('mymodule.Foo') as mock_foo:
+    ...             with patch('mymodule.Bar') as mock_bar:
+    ...                 with patch('mymodule.Spam') as mock_spam:
+    ...                     assert mymodule.Foo is mock_foo
+    ...                     assert mymodule.Bar is mock_bar
+    ...                     assert mymodule.Spam is mock_spam
+    ...
+    >>> original = mymodule.Foo
+    >>> MyTest('test_foo').test_foo()
+    >>> assert mymodule.Foo is original
+
+With unittest2_ `cleanup` functions and the :ref:`start-and-stop` we can
+achieve the same effect without the nested indentation. A simple helper
+method, `create_patch`, puts the patch in place and returns the created mock
+for us:
+
+.. doctest::
+
+    >>> class MyTest(TestCase):
+    ...
+    ...     def create_patch(self, name):
+    ...         patcher = patch(name)
+    ...         thing = patcher.start()
+    ...         self.addCleanup(patcher.stop)
+    ...         return thing
+    ...
+    ...     def test_foo(self):
+    ...         mock_foo = self.create_patch('mymodule.Foo')
+    ...         mock_bar = self.create_patch('mymodule.Bar')
+    ...         mock_spam = self.create_patch('mymodule.Spam')
+    ...
+    ...         assert mymodule.Foo is mock_foo
+    ...         assert mymodule.Bar is mock_bar
+    ...         assert mymodule.Spam is mock_spam
+    ...
+    >>> original = mymodule.Foo
+    >>> MyTest('test_foo').run()
+    >>> assert mymodule.Foo is original
+
+
+Mocking a dictionary with MagicMock
+===================================
+
+You may want to mock a dictionary, or other container object, recording all
+access to it whilst having it still behave like a dictionary.
+
+We can do this with :class:`MagicMock`, which will behave like a dictionary,
+and using :data:`~Mock.side_effect` to delegate dictionary access to a real
+underlying dictionary that is under our control.
+
+When the `__getitem__` and `__setitem__` methods of our `MagicMock` are called
+(normal dictionary access) then `side_effect` is called with the key (and in
+the case of `__setitem__` the value too). We can also control what is returned.
+
+After the `MagicMock` has been used we can use attributes like
+:data:`~Mock.call_args_list` to assert about how the dictionary was used:
+
+.. doctest::
+
+    >>> my_dict = {'a': 1, 'b': 2, 'c': 3}
+    >>> def getitem(name):
+    ...      return my_dict[name]
+    ...
+    >>> def setitem(name, val):
+    ...     my_dict[name] = val
+    ...
+    >>> mock = MagicMock()
+    >>> mock.__getitem__.side_effect = getitem
+    >>> mock.__setitem__.side_effect = setitem
+
+.. note::
+
+    An alternative to using `MagicMock` is to use `Mock` and *only* provide
+    the magic methods you specifically want:
+
+    .. doctest::
+
+        >>> mock = Mock()
+        >>> mock.__setitem__ = Mock(side_effect=getitem)
+        >>> mock.__getitem__ = Mock(side_effect=setitem)
+
+    A *third* option is to use `MagicMock` but passing in `dict` as the `spec`
+    (or `spec_set`) argument so that the `MagicMock` created only has
+    dictionary magic methods available:
+
+    .. doctest::
+
+        >>> mock = MagicMock(spec_set=dict)
+        >>> mock.__getitem__.side_effect = getitem
+        >>> mock.__setitem__.side_effect = setitem
+
+With these side effect functions in place, the `mock` will behave like a normal
+dictionary but recording the access. It even raises a `KeyError` if you try
+to access a key that doesn't exist.
+
+.. doctest::
+
+    >>> mock['a']
+    1
+    >>> mock['c']
+    3
+    >>> mock['d']
+    Traceback (most recent call last):
+        ...
+    KeyError: 'd'
+    >>> mock['b'] = 'fish'
+    >>> mock['d'] = 'eggs'
+    >>> mock['b']
+    'fish'
+    >>> mock['d']
+    'eggs'
+
+After it has been used you can make assertions about the access using the normal
+mock methods and attributes:
+
+.. doctest::
+
+    >>> mock.__getitem__.call_args_list
+    [call('a'), call('c'), call('d'), call('b'), call('d')]
+    >>> mock.__setitem__.call_args_list
+    [call('b', 'fish'), call('d', 'eggs')]
+    >>> my_dict
+    {'a': 1, 'c': 3, 'b': 'fish', 'd': 'eggs'}
+
+
+Mock subclasses and their attributes
+====================================
+
+There are various reasons why you might want to subclass `Mock`. One reason
+might be to add helper methods. Here's a silly example:
+
+.. doctest::
+
+    >>> class MyMock(MagicMock):
+    ...     def has_been_called(self):
+    ...         return self.called
+    ...
+    >>> mymock = MyMock(return_value=None)
+    >>> mymock
+    <MyMock id='...'>
+    >>> mymock.has_been_called()
+    False
+    >>> mymock()
+    >>> mymock.has_been_called()
+    True
+
+The standard behaviour for `Mock` instances is that attributes and the return
+value mocks are of the same type as the mock they are accessed on. This ensures
+that `Mock` attributes are `Mocks` and `MagicMock` attributes are `MagicMocks`
+[#]_. 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.
+
+.. doctest::
+
+    >>> mymock.foo
+    <MyMock name='mock.foo' id='...'>
+    >>> mymock.foo.has_been_called()
+    False
+    >>> mymock.foo()
+    <MyMock name='mock.foo()' id='...'>
+    >>> mymock.foo.has_been_called()
+    True
+
+Sometimes this is inconvenient. For example, `one user
+<https://code.google.com/p/mock/issues/detail?id=105>`_ is subclassing mock to
+created a `Twisted adaptor
+<http://twistedmatrix.com/documents/11.0.0/api/twisted.python.components.html>`_.
+Having this applied to attributes too actually causes errors.
+
+`Mock` (in all its flavours) uses a method called `_get_child_mock` 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 (`**kwargs`) which are then passed
+onto the mock constructor:
+
+.. doctest::
+
+    >>> class Subclass(MagicMock):
+    ...     def _get_child_mock(self, **kwargs):
+    ...         return MagicMock(**kwargs)
+    ...
+    >>> mymock = Subclass()
+    >>> mymock.foo
+    <MagicMock name='mock.foo' id='...'>
+    >>> assert isinstance(mymock, Subclass)
+    >>> assert not isinstance(mymock.foo, Subclass)
+    >>> assert not isinstance(mymock(), Subclass)
+
+.. [#] 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.
+
+
+Mocking imports with patch.dict
+===============================
+
+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.
+
+Generally local imports are to be avoided. They are sometimes done to prevent
+circular dependencies, for which there is *usually* 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).
+
+That aside there is a way to use `mock` to affect the results of an import.
+Importing fetches an *object* from the `sys.modules` dictionary. Note that it
+fetches an *object*, which need not be a module. Importing a module for the
+first time results in a module object being put in `sys.modules`, so usually
+when you import something you get a module back. This need not be the case
+however.
+
+This means you can use :func:`patch.dict` to *temporarily* put a mock in place
+in `sys.modules`. 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 `patcher.stop()` is called) then whatever was there
+previously will be restored safely.
+
+Here's an example that mocks out the 'fooble' module.
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> with patch.dict('sys.modules', {'fooble': mock}):
+    ...    import fooble
+    ...    fooble.blob()
+    ...
+    <Mock name='mock.blob()' id='...'>
+    >>> assert 'fooble' not in sys.modules
+    >>> mock.blob.assert_called_once_with()
+
+As you can see the `import fooble` succeeds, but on exit there is no 'fooble'
+left in `sys.modules`.
+
+This also works for the `from module import name` form:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> with patch.dict('sys.modules', {'fooble': mock}):
+    ...    from fooble import blob
+    ...    blob.blip()
+    ...
+    <Mock name='mock.blob.blip()' id='...'>
+    >>> mock.blob.blip.assert_called_once_with()
+
+With slightly more work you can also mock package imports:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> modules = {'package': mock, 'package.module': mock.module}
+    >>> with patch.dict('sys.modules', modules):
+    ...    from package.module import fooble
+    ...    fooble()
+    ...
+    <Mock name='mock.module.fooble()' id='...'>
+    >>> mock.module.fooble.assert_called_once_with()
+
+
+Tracking order of calls and less verbose call assertions
+========================================================
+
+The :class:`Mock` class allows you to track the *order* of method calls on
+your mock objects through the :attr:`~Mock.method_calls` attribute. This
+doesn't allow you to track the order of calls between separate mock objects,
+however we can use :attr:`~Mock.mock_calls` to achieve the same effect.
+
+Because mocks track calls to child mocks in `mock_calls`, 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 `mock_calls` of the parent:
+
+.. doctest::
+
+    >>> manager = Mock()
+    >>> mock_foo = manager.foo
+    >>> mock_bar = manager.bar
+
+    >>> mock_foo.something()
+    <Mock name='mock.foo.something()' id='...'>
+    >>> mock_bar.other.thing()
+    <Mock name='mock.bar.other.thing()' id='...'>
+
+    >>> manager.mock_calls
+    [call.foo.something(), call.bar.other.thing()]
+
+We can then assert about the calls, including the order, by comparing with
+the `mock_calls` attribute on the manager mock:
+
+.. doctest::
+
+    >>> expected_calls = [call.foo.something(), call.bar.other.thing()]
+    >>> manager.mock_calls == expected_calls
+    True
+
+If `patch` is creating, and putting in place, your mocks then you can attach
+them to a manager mock using the :meth:`~Mock.attach_mock` method. After
+attaching calls will be recorded in `mock_calls` of the manager.
+
+.. doctest::
+
+    >>> manager = MagicMock()
+    >>> with patch('mymodule.Class1') as MockClass1:
+    ...     with patch('mymodule.Class2') as MockClass2:
+    ...         manager.attach_mock(MockClass1, 'MockClass1')
+    ...         manager.attach_mock(MockClass2, 'MockClass2')
+    ...         MockClass1().foo()
+    ...         MockClass2().bar()
+    ...
+    <MagicMock name='mock.MockClass1().foo()' id='...'>
+    <MagicMock name='mock.MockClass2().bar()' id='...'>
+    >>> manager.mock_calls
+    [call.MockClass1(),
+     call.MockClass1().foo(),
+     call.MockClass2(),
+     call.MockClass2().bar()]
+
+If many calls have been made, but you're only interested in a particular
+sequence of them then an alternative is to use the
+:meth:`~Mock.assert_has_calls` method. This takes a list of calls (constructed
+with the :data:`call` object). If that sequence of calls are in
+:attr:`~Mock.mock_calls` then the assert succeeds.
+
+.. doctest::
+
+    >>> m = MagicMock()
+    >>> m().foo().bar().baz()
+    <MagicMock name='mock().foo().bar().baz()' id='...'>
+    >>> m.one().two().three()
+    <MagicMock name='mock.one().two().three()' id='...'>
+    >>> calls = call.one().two().three().call_list()
+    >>> m.assert_has_calls(calls)
+
+Even though the chained call `m.one().two().three()` aren't the only calls that
+have been made to the mock, the assert still succeeds.
+
+Sometimes a mock may have several calls made to it, and you are only interested
+in asserting about *some* of those calls. You may not even care about the
+order. In this case you can pass `any_order=True` to `assert_has_calls`:
+
+.. doctest::
+
+    >>> m = MagicMock()
+    >>> m(1), m.two(2, 3), m.seven(7), m.fifty('50')
+    (...)
+    >>> calls = [call.fifty('50'), call(1), call.seven(7)]
+    >>> m.assert_has_calls(calls, any_order=True)
+
+
+More complex argument matching
+==============================
+
+Using the same basic concept as `ANY` we can implement matchers to do more
+complex assertions on objects used as arguments to mocks.
+
+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 :meth:`~Mock.assert_called_with` 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.
+
+You can see in this example how a 'standard' call to `assert_called_with` isn't
+sufficient:
+
+.. doctest::
+
+    >>> class Foo(object):
+    ...     def __init__(self, a, b):
+    ...         self.a, self.b = a, b
+    ...
+    >>> mock = Mock(return_value=None)
+    >>> mock(Foo(1, 2))
+    >>> mock.assert_called_with(Foo(1, 2))
+    Traceback (most recent call last):
+        ...
+    AssertionError: Expected: call(<__main__.Foo object at 0x...>)
+    Actual call: call(<__main__.Foo object at 0x...>)
+
+A comparison function for our `Foo` class might look something like this:
+
+.. doctest::
+
+    >>> def compare(self, other):
+    ...     if not type(self) == type(other):
+    ...         return False
+    ...     if self.a != other.a:
+    ...         return False
+    ...     if self.b != other.b:
+    ...         return False
+    ...     return True
+    ...
+
+And a matcher object that can use comparison functions like this for its
+equality operation would look something like this:
+
+.. doctest::
+
+    >>> class Matcher(object):
+    ...     def __init__(self, compare, some_obj):
+    ...         self.compare = compare
+    ...         self.some_obj = some_obj
+    ...     def __eq__(self, other):
+    ...         return self.compare(self.some_obj, other)
+    ...
+
+Putting all this together:
+
+.. doctest::
+
+    >>> match_foo = Matcher(compare, Foo(1, 2))
+    >>> mock.assert_called_with(match_foo)
+
+The `Matcher` is instantiated with our compare function and the `Foo` object
+we want to compare against. In `assert_called_with` the `Matcher` 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
+`assert_called_with` passes, and if they don't an `AssertionError` is raised:
+
+.. doctest::
+
+    >>> match_wrong = Matcher(compare, Foo(3, 4))
+    >>> mock.assert_called_with(match_wrong)
+    Traceback (most recent call last):
+        ...
+    AssertionError: Expected: ((<Matcher object at 0x...>,), {})
+    Called with: ((<Foo object at 0x...>,), {})
+
+With a bit of tweaking you could have the comparison function raise the
+`AssertionError` directly and provide a more useful failure message.
+
+As of version 1.5, the Python testing library `PyHamcrest
+<http://pypi.python.org/pypi/PyHamcrest>`_ provides similar functionality,
+that may be useful here, in the form of its equality matcher
+(`hamcrest.library.integration.match_equality
+<http://packages.python.org/PyHamcrest/integration.html#hamcrest.library.integration.match_equality>`_).
+
+
+Less verbose configuration of mock objects
+==========================================
+
+This recipe, for easier configuration of mock objects, is now part of `Mock`.
+See the :meth:`~Mock.configure_mock` method.
+
+
+Matching any argument in assertions
+===================================
+
+This example is now built in to mock. See :data:`ANY`.
+
+
+Mocking Properties
+==================
+
+This example is now built in to mock. See :class:`PropertyMock`.
+
+
+Mocking open
+============
+
+This example is now built in to mock. See :func:`mock_open`.
+
+
+Mocks without some attributes
+=============================
+
+This example is now built in to mock. See :ref:`deleting-attributes`.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/getting-started.txt
@@ -0,0 +1,479 @@
+===========================
+ Getting Started with Mock
+===========================
+
+.. _getting-started:
+
+.. index:: Getting Started
+
+.. testsetup::
+
+    class SomeClass(object):
+        static_method = None
+        class_method = None
+        attribute = None
+
+    sys.modules['package'] = package = Mock(name='package')
+    sys.modules['package.module'] = module = package.module
+    sys.modules['module'] = package.module
+
+
+Using Mock
+==========
+
+Mock Patching Methods
+---------------------
+
+Common uses for :class:`Mock` objects include:
+
+* Patching methods
+* Recording method calls on objects
+
+You might want to replace a method on an object to check that
+it is called with the correct arguments by another part of the system:
+
+.. doctest::
+
+    >>> real = SomeClass()
+    >>> real.method = MagicMock(name='method')
+    >>> real.method(3, 4, 5, key='value')
+    <MagicMock name='method()' id='...'>
+
+Once our mock has been used (`real.method` in this example) it has methods
+and attributes that allow you to make assertions about how it has been used.
+
+.. note::
+
+    In most of these examples the :class:`Mock` and :class:`MagicMock` classes
+    are interchangeable. As the `MagicMock` is the more capable class it makes
+    a sensible one to use by default.
+
+Once the mock has been called its :attr:`~Mock.called` attribute is set to
+`True`. More importantly we can use the :meth:`~Mock.assert_called_with` or
+:meth:`~Mock.assert_called_once_with` method to check that it was called with
+the correct arguments.
+
+This example tests that calling `ProductionClass().method` results in a call to
+the `something` method:
+
+.. doctest::
+
+    >>> from mock import MagicMock
+    >>> class ProductionClass(object):
+    ...     def method(self):
+    ...         self.something(1, 2, 3)
+    ...     def something(self, a, b, c):
+    ...         pass
+    ...
+    >>> real = ProductionClass()
+    >>> real.something = MagicMock()
+    >>> real.method()
+    >>> real.something.assert_called_once_with(1, 2, 3)
+
+
+
+Mock for Method Calls on an Object
+----------------------------------
+
+In the last example we patched a method directly on an object to check that it
+was called correctly. Another common use case is to pass an object into a
+method (or some part of the system under test) and then check that it is used
+in the correct way.
+
+The simple `ProductionClass` below has a `closer` method. If it is called with
+an object then it calls `close` on it.
+
+.. doctest::
+
+    >>> class ProductionClass(object):
+    ...     def closer(self, something):
+    ...         something.close()
+    ...
+
+So to test it we need to pass in an object with a `close` method and check
+that it was called correctly.
+
+.. doctest::
+
+    >>> real = ProductionClass()
+    >>> mock = Mock()
+    >>> real.closer(mock)
+    >>> mock.close.assert_called_with()
+
+We don't have to do any work to provide the 'close' method on our mock.
+Accessing close creates it. So, if 'close' hasn't already been called then
+accessing it in the test will create it, but :meth:`~Mock.assert_called_with`
+will raise a failure exception.
+
+
+Mocking Classes
+---------------
+
+A common use case is to mock out classes instantiated by your code under test.
+When you patch a class, then that class is replaced with a mock. Instances
+are created by *calling the class*. This means you access the "mock instance"
+by looking at the return value of the mocked class.
+
+In the example below we have a function `some_function` that instantiates `Foo`
+and calls a method on it. The call to `patch` replaces the class `Foo` with a
+mock. The `Foo` instance is the result of calling the mock, so it is configured
+by modifying the mock :attr:`~Mock.return_value`.
+
+.. doctest::
+
+    >>> def some_function():
+    ...     instance = module.Foo()
+    ...     return instance.method()
+    ...
+    >>> with patch('module.Foo') as mock:
+    ...     instance = mock.return_value
+    ...     instance.method.return_value = 'the result'
+    ...     result = some_function()
+    ...     assert result == 'the result'
+
+
+Naming your mocks
+-----------------
+
+It can be useful to give your mocks a name. The name is shown in the repr of
+the mock and can be helpful when the mock appears in test failure messages. The
+name is also propagated to attributes or methods of the mock:
+
+.. doctest::
+
+    >>> mock = MagicMock(name='foo')
+    >>> mock
+    <MagicMock name='foo' id='...'>
+    >>> mock.method
+    <MagicMock name='foo.method' id='...'>
+
+
+Tracking all Calls
+------------------
+
+Often you want to track more than a single call to a method. The
+:attr:`~Mock.mock_calls` attribute records all calls
+to child attributes of the mock - and also to their children.
+
+.. doctest::
+
+    >>> mock = MagicMock()
+    >>> mock.method()
+    <MagicMock name='mock.method()' id='...'>
+    >>> mock.attribute.method(10, x=53)
+    <MagicMock name='mock.attribute.method()' id='...'>
+    >>> mock.mock_calls
+    [call.method(), call.attribute.method(10, x=53)]
+
+If you make an assertion about `mock_calls` and any unexpected methods
+have been called, then the assertion will fail. This is useful because as well
+as asserting that the calls you expected have been made, you are also checking
+that they were made in the right order and with no additional calls:
+
+You use the :data:`call` object to construct lists for comparing with
+`mock_calls`:
+
+.. doctest::
+
+    >>> expected = [call.method(), call.attribute.method(10, x=53)]
+    >>> mock.mock_calls == expected
+    True
+
+
+Setting Return Values and Attributes
+------------------------------------
+
+Setting the return values on a mock object is trivially easy:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> mock.return_value = 3
+    >>> mock()
+    3
+
+Of course you can do the same for methods on the mock:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> mock.method.return_value = 3
+    >>> mock.method()
+    3
+
+The return value can also be set in the constructor:
+
+.. doctest::
+
+    >>> mock = Mock(return_value=3)
+    >>> mock()
+    3
+
+If you need an attribute setting on your mock, just do it:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> mock.x = 3
+    >>> mock.x
+    3
+
+Sometimes you want to mock up a more complex situation, like for example
+`mock.connection.cursor().execute("SELECT 1")`. If we wanted this call to
+return a list, then we have to configure the result of the nested call.
+
+We can use :data:`call` to construct the set of calls in a "chained call" like
+this for easy assertion afterwards:
+
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> cursor = mock.connection.cursor.return_value
+    >>> cursor.execute.return_value = ['foo']
+    >>> mock.connection.cursor().execute("SELECT 1")
+    ['foo']
+    >>> expected = call.connection.cursor().execute("SELECT 1").call_list()
+    >>> mock.mock_calls
+    [call.connection.cursor(), call.connection.cursor().execute('SELECT 1')]
+    >>> mock.mock_calls == expected
+    True
+
+It is the call to `.call_list()` that turns our call object into a list of
+calls representing the chained calls.
+
+
+
+Raising exceptions with mocks
+-----------------------------
+
+A useful attribute is :attr:`~Mock.side_effect`. If you set this to an
+exception class or instance then the exception will be raised when the mock
+is called.
+
+.. doctest::
+
+    >>> mock = Mock(side_effect=Exception('Boom!'))
+    >>> mock()
+    Traceback (most recent call last):
+      ...
+    Exception: Boom!
+
+
+Side effect functions and iterables
+-----------------------------------
+
+`side_effect` can also be set to a function or an iterable. The use case for
+`side_effect` as an iterable is where your mock is going to be called several
+times, and you want each call to return a different value. When you set
+`side_effect` to an iterable every call to the mock returns the next value
+from the iterable:
+
+.. doctest::
+
+    >>> mock = MagicMock(side_effect=[4, 5, 6])
+    >>> mock()
+    4
+    >>> mock()
+    5
+    >>> mock()
+    6
+
+
+For more advanced use cases, like dynamically varying the return values
+depending on what the mock is called with, `side_effect` can be a function.
+The function will be called with the same arguments as the mock. Whatever the
+function returns is what the call returns:
+
+.. doctest::
+
+    >>> vals = {(1, 2): 1, (2, 3): 2}
+    >>> def side_effect(*args):
+    ...     return vals[args]
+    ...
+    >>> mock = MagicMock(side_effect=side_effect)
+    >>> mock(1, 2)
+    1
+    >>> mock(2, 3)
+    2
+
+
+Creating a Mock from an Existing Object
+---------------------------------------
+
+One problem with over use of mocking is that it couples your tests to the
+implementation of your mocks rather than your real code. Suppose you have a
+class that implements `some_method`. In a test for another class, you
+provide a mock of this object that *also* provides `some_method`. If later
+you refactor the first class, so that it no longer has `some_method` - then
+your tests will continue to pass even though your code is now broken!
+
+`Mock` allows you to provide an object as a specification for the mock,
+using the `spec` keyword argument. Accessing methods / attributes on the
+mock that don't exist on your specification object will immediately raise an
+attribute error. If you change the implementation of your specification, then
+tests that use that class will start failing immediately without you having to
+instantiate the class in those tests.
+
+.. doctest::
+
+    >>> mock = Mock(spec=SomeClass)
+    >>> mock.old_method()
+    Traceback (most recent call last):
+       ...
+    AttributeError: object has no attribute 'old_method'
+
+If you want a stronger form of specification that prevents the setting
+of arbitrary attributes as well as the getting of them then you can use
+`spec_set` instead of `spec`.
+
+
+
+Patch Decorators
+================
+
+.. note::
+
+   With `patch` it matters that you patch objects in the namespace where they
+   are looked up. This is normally straightforward, but for a quick guide
+   read :ref:`where to patch <where-to-patch>`.
+
+
+A common need in tests is to patch a class attribute or a module attribute,
+for example patching a builtin or patching a class in a module to test that it
+is instantiated. Modules and classes are effectively global, so patching on
+them has to be undone after the test or the patch will persist into other
+tests and cause hard to diagnose problems.
+
+mock provides three convenient decorators for this: `patch`, `patch.object` and
+`patch.dict`. `patch` takes a single string, of the form
+`package.module.Class.attribute` to specify the attribute you are patching. It
+also optionally takes a value that you want the attribute (or class or
+whatever) to be replaced with. 'patch.object' takes an object and the name of
+the attribute you would like patched, plus optionally the value to patch it
+with.
+
+`patch.object`:
+
+.. doctest::
+
+    >>> original = SomeClass.attribute
+    >>> @patch.object(SomeClass, 'attribute', sentinel.attribute)
+    ... def test():
+    ...     assert SomeClass.attribute == sentinel.attribute
+    ...
+    >>> test()
+    >>> assert SomeClass.attribute == original
+
+    >>> @patch('package.module.attribute', sentinel.attribute)
+    ... def test():
+    ...     from package.module import attribute
+    ...     assert attribute is sentinel.attribute
+    ...
+    >>> test()
+
+If you are patching a module (including `__builtin__`) then use `patch`
+instead of `patch.object`:
+
+.. doctest::
+
+    >>> mock = MagicMock(return_value = sentinel.file_handle)
+    >>> with patch('__builtin__.open', mock):
+    ...     handle = open('filename', 'r')
+    ...
+    >>> mock.assert_called_with('filename', 'r')
+    >>> assert handle == sentinel.file_handle, "incorrect file handle returned"
+
+The module name can be 'dotted', in the form `package.module` if needed:
+
+.. doctest::
+
+    >>> @patch('package.module.ClassName.attribute', sentinel.attribute)
+    ... def test():
+    ...     from package.module import ClassName
+    ...     assert ClassName.attribute == sentinel.attribute
+    ...
+    >>> test()
+
+A nice pattern is to actually decorate test methods themselves:
+
+.. doctest::
+
+    >>> class MyTest(unittest2.TestCase):
+    ...     @patch.object(SomeClass, 'attribute', sentinel.attribute)
+    ...     def test_something(self):
+    ...         self.assertEqual(SomeClass.attribute, sentinel.attribute)
+    ...
+    >>> original = SomeClass.attribute
+    >>> MyTest('test_something').test_something()
+    >>> assert SomeClass.attribute == original
+
+If you want to patch with a Mock, you can use `patch` with only one argument
+(or `patch.object` with two arguments). The mock will be created for you and
+passed into the test function / method:
+
+.. doctest::
+
+    >>> class MyTest(unittest2.TestCase):
+    ...     @patch.object(SomeClass, 'static_method')
+    ...     def test_something(self, mock_method):
+    ...         SomeClass.static_method()
+    ...         mock_method.assert_called_with()
+    ...
+    >>> MyTest('test_something').test_something()
+
+You can stack up multiple patch decorators using this pattern:
+
+.. doctest::
+
+    >>> class MyTest(unittest2.TestCase):
+    ...     @patch('package.module.ClassName1')
+    ...     @patch('package.module.ClassName2')
+    ...     def test_something(self, MockClass2, MockClass1):
+    ...         self.assertTrue(package.module.ClassName1 is MockClass1)
+    ...         self.assertTrue(package.module.ClassName2 is MockClass2)
+    ...
+    >>> MyTest('test_something').test_something()
+
+When you nest patch decorators the mocks are passed in to the decorated
+function in the same order they applied (the normal *python* order that
+decorators are applied). This means from the bottom up, so in the example
+above the mock for `test_module.ClassName2` is passed in first.
+
+There is also :func:`patch.dict` for setting values in a dictionary just
+during a scope and restoring the dictionary to its original state when the test
+ends:
+
+.. doctest::
+
+   >>> foo = {'key': 'value'}
+   >>> original = foo.copy()
+   >>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
+   ...     assert foo == {'newkey': 'newvalue'}
+   ...
+   >>> assert foo == original
+
+`patch`, `patch.object` and `patch.dict` can all be used as context managers.
+
+Where you use `patch` to create a mock for you, you can get a reference to the
+mock using the "as" form of the with statement:
+
+.. doctest::
+
+    >>> class ProductionClass(object):
+    ...     def method(self):
+    ...         pass
+    ...
+    >>> with patch.object(ProductionClass, 'method') as mock_method:
+    ...     mock_method.return_value = None
+    ...     real = ProductionClass()
+    ...     real.method(1, 2, 3)
+    ...
+    >>> mock_method.assert_called_with(1, 2, 3)
+
+
+As an alternative `patch`, `patch.object` and `patch.dict` can be used as
+class decorators. When used in this way it is the same as applying the
+decorator indvidually to every method whose name starts with "test".
+
+For some more advanced examples, see the :ref:`further-examples` page.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/helpers.txt
@@ -0,0 +1,583 @@
+=========
+ Helpers
+=========
+
+.. currentmodule:: mock
+
+.. testsetup::
+
+    mock.FILTER_DIR = True
+    from pprint import pprint as pp
+    original_dir = dir
+    def dir(obj):
+        print pp(original_dir(obj))
+
+    import urllib2
+    __main__.urllib2 = urllib2
+
+.. testcleanup::
+
+    dir = original_dir
+    mock.FILTER_DIR = True
+
+
+
+call
+====
+
+.. function:: call(*args, **kwargs)
+
+    `call` is a helper object for making simpler assertions, for comparing
+    with :attr:`~Mock.call_args`, :attr:`~Mock.call_args_list`,
+    :attr:`~Mock.mock_calls` and :attr: `~Mock.method_calls`. `call` can also be
+    used with :meth:`~Mock.assert_has_calls`.
+
+    .. doctest::
+
+        >>> m = MagicMock(return_value=None)
+        >>> m(1, 2, a='foo', b='bar')
+        >>> m()
+        >>> m.call_args_list == [call(1, 2, a='foo', b='bar'), call()]
+        True
+
+.. method:: call.call_list()
+
+    For a call object that represents multiple calls, `call_list`
+    returns a list of all the intermediate calls as well as the
+    final call.
+
+`call_list` is particularly useful for making assertions on "chained calls". A
+chained call is multiple calls on a single line of code. This results in
+multiple entries in :attr:`~Mock.mock_calls` on a mock. Manually constructing
+the sequence of calls can be tedious.
+
+:meth:`~call.call_list` can construct the sequence of calls from the same
+chained call:
+
+.. doctest::
+
+    >>> m = MagicMock()
+    >>> m(1).method(arg='foo').other('bar')(2.0)
+    <MagicMock name='mock().method().other()()' id='...'>
+    >>> kall = call(1).method(arg='foo').other('bar')(2.0)
+    >>> kall.call_list()
+    [call(1),
+     call().method(arg='foo'),
+     call().method().other('bar'),
+     call().method().other()(2.0)]
+    >>> m.mock_calls == kall.call_list()
+    True
+
+.. _calls-as-tuples:
+
+A `call` object is either a tuple of (positional args, keyword args) or
+(name, positional args, keyword args) depending on how it was constructed. When
+you construct them yourself this isn't particularly interesting, but the `call`
+objects that are in the :attr:`Mock.call_args`, :attr:`Mock.call_args_list` and
+:attr:`Mock.mock_calls` attributes can be introspected to get at the individual
+arguments they contain.
+
+The `call` objects in :attr:`Mock.call_args` and :attr:`Mock.call_args_list`
+are two-tuples of (positional args, keyword args) whereas the `call` objects
+in :attr:`Mock.mock_calls`, along with ones you construct yourself, are
+three-tuples of (name, positional args, keyword args).
+
+You can use their "tupleness" to pull out the individual arguments for more
+complex introspection and assertions. The positional arguments are a tuple
+(an empty tuple if there are no positional arguments) and the keyword
+arguments are a dictionary:
+
+.. doctest::
+
+    >>> m = MagicMock(return_value=None)
+    >>> m(1, 2, 3, arg='one', arg2='two')
+    >>> kall = m.call_args
+    >>> args, kwargs = kall
+    >>> args
+    (1, 2, 3)
+    >>> kwargs
+    {'arg2': 'two', 'arg': 'one'}
+    >>> args is kall[0]
+    True
+    >>> kwargs is kall[1]
+    True
+
+    >>> m = MagicMock()
+    >>> m.foo(4, 5, 6, arg='two', arg2='three')
+    <MagicMock name='mock.foo()' id='...'>
+    >>> kall = m.mock_calls[0]
+    >>> name, args, kwargs = kall
+    >>> name
+    'foo'
+    >>> args
+    (4, 5, 6)
+    >>> kwargs
+    {'arg2': 'three', 'arg': 'two'}
+    >>> name is m.mock_calls[0][0]
+    True
+
+
+create_autospec
+===============
+
+.. function:: create_autospec(spec, spec_set=False, instance=False, **kwargs)
+
+    Create a mock object using another object as a spec. Attributes on the
+    mock will use the corresponding attribute on the `spec` object as their
+    spec.
+
+    Functions or methods being mocked will have their arguments checked to
+    ensure that they are called with the correct signature.
+
+    If `spec_set` is `True` then attempting to set attributes that don't exist
+    on the spec object will raise an `AttributeError`.
+
+    If a class is used as a spec then the return value of the mock (the
+    instance of the class) will have the same spec. You can use a class as the
+    spec for an instance object by passing `instance=True`. The returned mock
+    will only be callable if instances of the mock are callable.
+
+    `create_autospec` also takes arbitrary keyword arguments that are passed to
+    the constructor of the created mock.
+
+See :ref:`auto-speccing` for examples of how to use auto-speccing with
+`create_autospec` and the `autospec` argument to :func:`patch`.
+
+
+ANY
+===
+
+.. data:: ANY
+
+Sometimes you may need to make assertions about *some* of the arguments in a
+call to mock, but either not care about some of the arguments or want to pull
+them individually out of :attr:`~Mock.call_args` and make more complex
+assertions on them.
+
+To ignore certain arguments you can pass in objects that compare equal to
+*everything*. Calls to :meth:`~Mock.assert_called_with` and
+:meth:`~Mock.assert_called_once_with` will then succeed no matter what was
+passed in.
+
+.. doctest::
+
+    >>> mock = Mock(return_value=None)
+    >>> mock('foo', bar=object())
+    >>> mock.assert_called_once_with('foo', bar=ANY)
+
+`ANY` can also be used in comparisons with call lists like
+:attr:`~Mock.mock_calls`:
+
+.. doctest::
+
+    >>> m = MagicMock(return_value=None)
+    >>> m(1)
+    >>> m(1, 2)
+    >>> m(object())
+    >>> m.mock_calls == [call(1), call(1, 2), ANY]
+    True
+
+
+
+FILTER_DIR
+==========
+
+.. data:: FILTER_DIR
+
+`FILTER_DIR` is a module level variable that controls the way mock objects
+respond to `dir` (only for Python 2.6 or more recent). The default is `True`,
+which uses the filtering described below, to only show useful members. If you
+dislike this filtering, or need to switch it off for diagnostic purposes, then
+set `mock.FILTER_DIR = False`.
+
+With filtering on, `dir(some_mock)` shows only useful attributes and will
+include any dynamically created attributes that wouldn't normally be shown.
+If the mock was created with a `spec` (or `autospec` of course) then all the
+attributes from the original are shown, even if they haven't been accessed
+yet:
+
+.. doctest::
+
+    >>> dir(Mock())
+    ['assert_any_call',
+     'assert_called_once_with',
+     'assert_called_with',
+     'assert_has_calls',
+     'attach_mock',
+     ...
+    >>> import urllib2
+    >>> dir(Mock(spec=urllib2))
+    ['AbstractBasicAuthHandler',
+     'AbstractDigestAuthHandler',
+     'AbstractHTTPHandler',
+     'BaseHandler',
+     ...
+
+Many of the not-very-useful (private to `Mock` rather than the thing being
+mocked) underscore and double underscore prefixed attributes have been
+filtered from the result of calling `dir` on a `Mock`. If you dislike this
+behaviour you can switch it off by setting the module level switch
+`FILTER_DIR`:
+
+.. doctest::
+
+    >>> import mock
+    >>> mock.FILTER_DIR = False
+    >>> dir(mock.Mock())
+    ['_NonCallableMock__get_return_value',
+     '_NonCallableMock__get_side_effect',
+     '_NonCallableMock__return_value_doc',
+     '_NonCallableMock__set_return_value',
+     '_NonCallableMock__set_side_effect',
+     '__call__',
+     '__class__',
+     ...
+
+Alternatively you can just use `vars(my_mock)` (instance members) and
+`dir(type(my_mock))` (type members) to bypass the filtering irrespective of
+`mock.FILTER_DIR`.
+
+
+mock_open
+=========
+
+.. function:: mock_open(mock=None, read_data=None)
+
+    A helper function to create a mock to replace the use of `open`. It works
+    for `open` called directly or used as a context manager.
+
+    The `mock` argument is the mock object to configure. If `None` (the
+    default) then a `MagicMock` will be created for you, with the API limited
+    to methods or attributes available on standard file handles.
+
+    `read_data` is a string for the `read` method of the file handle to return.
+    This is an empty string by default.
+
+Using `open` as a context manager is a great way to ensure your file handles
+are closed properly and is becoming common::
+
+    with open('/some/path', 'w') as f:
+        f.write('something')
+
+The issue is that even if you mock out the call to `open` it is the
+*returned object* that is used as a context manager (and has `__enter__` and
+`__exit__` called).
+
+Mocking context managers with a :class:`MagicMock` is common enough and fiddly
+enough that a helper function is useful.
+
+.. doctest::
+
+    >>> from mock import mock_open
+    >>> m = mock_open()
+    >>> with patch('__main__.open', m, create=True):
+    ...     with open('foo', 'w') as h:
+    ...         h.write('some stuff')
+    ...
+    >>> m.mock_calls
+    [call('foo', 'w'),
+     call().__enter__(),
+     call().write('some stuff'),
+     call().__exit__(None, None, None)]
+    >>> m.assert_called_once_with('foo', 'w')
+    >>> handle = m()
+    >>> handle.write.assert_called_once_with('some stuff')
+
+And for reading files:
+
+.. doctest::
+
+    >>> with patch('__main__.open', mock_open(read_data='bibble'), create=True) as m:
+    ...     with open('foo') as h:
+    ...         result = h.read()
+    ...
+    >>> m.assert_called_once_with('foo')
+    >>> assert result == 'bibble'
+
+
+.. _auto-speccing:
+
+Autospeccing
+============
+
+Autospeccing is based on the existing `spec` feature of mock. It limits the
+api of mocks to the api of an original object (the spec), but it is recursive
+(implemented lazily) so that attributes of mocks only have the same api as
+the attributes of the spec. In addition mocked functions / methods have the
+same call signature as the original so they raise a `TypeError` if they are
+called incorrectly.
+
+Before I explain how auto-speccing works, here's why it is needed.
+
+`Mock` is a very powerful and flexible object, but it suffers from two flaws
+when used to mock out objects from a system under test. One of these flaws is
+specific to the `Mock` api and the other is a more general problem with using
+mock objects.
+
+First the problem specific to `Mock`. `Mock` has two assert methods that are
+extremely handy: :meth:`~Mock.assert_called_with` and
+:meth:`~Mock.assert_called_once_with`.
+
+.. doctest::
+
+    >>> mock = Mock(name='Thing', return_value=None)
+    >>> mock(1, 2, 3)
+    >>> mock.assert_called_once_with(1, 2, 3)
+    >>> mock(1, 2, 3)
+    >>> mock.assert_called_once_with(1, 2, 3)
+    Traceback (most recent call last):
+     ...
+    AssertionError: Expected to be called once. Called 2 times.
+
+Because mocks auto-create attributes on demand, and allow you to call them
+with arbitrary arguments, if you misspell one of these assert methods then
+your assertion is gone:
+
+.. code-block:: pycon
+
+    >>> mock = Mock(name='Thing', return_value=None)
+    >>> mock(1, 2, 3)
+    >>> mock.assret_called_once_with(4, 5, 6)
+
+Your tests can pass silently and incorrectly because of the typo.
+
+The second issue is more general to mocking. If you refactor some of your
+code, rename members and so on, any tests for code that is still using the
+*old api* but uses mocks instead of the real objects will still pass. This
+means your tests can all pass even though your code is broken.
+
+Note that this is another reason why you need integration tests as well as
+unit tests. Testing everything in isolation is all fine and dandy, but if you
+don't test how your units are "wired together" there is still lots of room
+for bugs that tests might have caught.
+
+`mock` already provides a feature to help with this, called speccing. If you
+use a class or instance as the `spec` for a mock then you can only access
+attributes on the mock that exist on the real class:
+
+.. doctest::
+
+    >>> import urllib2
+    >>> mock = Mock(spec=urllib2.Request)
+    >>> mock.assret_called_with
+    Traceback (most recent call last):
+     ...
+    AttributeError: Mock object has no attribute 'assret_called_with'
+
+The spec only applies to the mock itself, so we still have the same issue
+with any methods on the mock:
+
+.. code-block:: pycon
+
+    >>> mock.has_data()
+    <mock.Mock object at 0x...>
+    >>> mock.has_data.assret_called_with()
+
+Auto-speccing solves this problem. You can either pass `autospec=True` to
+`patch` / `patch.object` or use the `create_autospec` function to create a
+mock with a spec. If you use the `autospec=True` argument to `patch` then the
+object that is being replaced will be used as the spec object. Because the
+speccing is done "lazily" (the spec is created as attributes on the mock are
+accessed) you can use it with very complex or deeply nested objects (like
+modules that import modules that import modules) without a big performance
+hit.
+
+Here's an example of it in use:
+
+.. doctest::
+
+    >>> import urllib2
+    >>> patcher = patch('__main__.urllib2', autospec=True)
+    >>> mock_urllib2 = patcher.start()
+    >>> urllib2 is mock_urllib2
+    True
+    >>> urllib2.Request
+    <MagicMock name='urllib2.Request' spec='Request' id='...'>
+
+You can see that `urllib2.Request` has a spec. `urllib2.Request` takes two
+arguments in the constructor (one of which is `self`). Here's what happens if
+we try to call it incorrectly:
+
+.. doctest::
+
+    >>> req = urllib2.Request()
+    Traceback (most recent call last):
+     ...
+    TypeError: <lambda>() takes at least 2 arguments (1 given)
+
+The spec also applies to instantiated classes (i.e. the return value of
+specced mocks):
+
+.. doctest::
+
+    >>> req = urllib2.Request('foo')
+    >>> req
+    <NonCallableMagicMock name='urllib2.Request()' spec='Request' id='...'>
+
+`Request` objects are not callable, so the return value of instantiating our
+mocked out `urllib2.Request` is a non-callable mock. With the spec in place
+any typos in our asserts will raise the correct error:
+
+.. doctest::
+
+    >>> req.add_header('spam', 'eggs')
+    <MagicMock name='urllib2.Request().add_header()' id='...'>
+    >>> req.add_header.assret_called_with
+    Traceback (most recent call last):
+     ...
+    AttributeError: Mock object has no attribute 'assret_called_with'
+    >>> req.add_header.assert_called_with('spam', 'eggs')
+
+In many cases you will just be able to add `autospec=True` to your existing
+`patch` calls and then be protected against bugs due to typos and api
+changes.
+
+As well as using `autospec` through `patch` there is a
+:func:`create_autospec` for creating autospecced mocks directly:
+
+.. doctest::
+
+    >>> import urllib2
+    >>> mock_urllib2 = create_autospec(urllib2)
+    >>> mock_urllib2.Request('foo', 'bar')
+    <NonCallableMagicMock name='mock.Request()' spec='Request' id='...'>
+
+This isn't without caveats and limitations however, which is why it is not
+the default behaviour. In order to know what attributes are available on the
+spec object, autospec has to introspect (access attributes) the spec. As you
+traverse attributes on the mock a corresponding traversal of the original
+object is happening under the hood. If any of your specced objects have
+properties or descriptors that can trigger code execution then you may not be
+able to use autospec. On the other hand it is much better to design your
+objects so that introspection is safe [#]_.
+
+A more serious problem is that it is common for instance attributes to be
+created in the `__init__` method and not to exist on the class at all.
+`autospec` can't know about any dynamically created attributes and restricts
+the api to visible attributes.
+
+.. doctest::
+
+    >>> class Something(object):
+    ...   def __init__(self):
+    ...     self.a = 33
+    ...
+    >>> with patch('__main__.Something', autospec=True):
+    ...   thing = Something()
+    ...   thing.a
+    ...
+    Traceback (most recent call last):
+      ...
+    AttributeError: Mock object has no attribute 'a'
+
+There are a few different ways of resolving this problem. The easiest, but
+not necessarily the least annoying, way is to simply set the required
+attributes on the mock after creation. Just because `autospec` doesn't allow
+you to fetch attributes that don't exist on the spec it doesn't prevent you
+setting them:
+
+.. doctest::
+
+    >>> with patch('__main__.Something', autospec=True):
+    ...   thing = Something()
+    ...   thing.a = 33
+    ...
+
+There is a more aggressive version of both `spec` and `autospec` that *does*
+prevent you setting non-existent attributes. This is useful if you want to
+ensure your code only *sets* valid attributes too, but obviously it prevents
+this particular scenario:
+
+.. doctest::
+
+    >>> with patch('__main__.Something', autospec=True, spec_set=True):
+    ...   thing = Something()
+    ...   thing.a = 33
+    ...
+    Traceback (most recent call last):
+     ...
+    AttributeError: Mock object has no attribute 'a'
+
+Probably the best way of solving the problem is to add class attributes as
+default values for instance members initialised in `__init__`. Note that if
+you are only setting default attributes in `__init__` then providing them via
+class attributes (shared between instances of course) is faster too. e.g.
+
+.. code-block:: python
+
+    class Something(object):
+        a = 33
+
+This brings up another issue. It is relatively common to provide a default
+value of `None` for members that will later be an object of a different type.
+`None` would be useless as a spec because it wouldn't let you access *any*
+attributes or methods on it. As `None` is *never* going to be useful as a
+spec, and probably indicates a member that will normally of some other type,
+`autospec` doesn't use a spec for members that are set to `None`. These will
+just be ordinary mocks (well - `MagicMocks`):
+
+.. doctest::
+
+    >>> class Something(object):
+    ...     member = None
+    ...
+    >>> mock = create_autospec(Something)
+    >>> mock.member.foo.bar.baz()
+    <MagicMock name='mock.member.foo.bar.baz()' id='...'>
+
+If modifying your production classes to add defaults isn't to your liking
+then there are more options. One of these is simply to use an instance as the
+spec rather than the class. The other is to create a subclass of the
+production class and add the defaults to the subclass without affecting the
+production class. Both of these require you to use an alternative object as
+the spec. Thankfully `patch` supports this - you can simply pass the
+alternative object as the `autospec` argument:
+
+.. doctest::
+
+    >>> class Something(object):
+    ...   def __init__(self):
+    ...     self.a = 33
+    ...
+    >>> class SomethingForTest(Something):
+    ...   a = 33
+    ...
+    >>> p = patch('__main__.Something', autospec=SomethingForTest)
+    >>> mock = p.start()
+    >>> mock.a
+    <NonCallableMagicMock name='Something.a' spec='int' id='...'>
+
+.. note::
+
+    An additional limitation (currently) with `autospec` is that unbound
+    methods on mocked classes *don't* take an "explicit self" as the first
+    argument - so this usage will fail with `autospec`.
+
+    .. doctest::
+
+        >>> class Foo(object):
+        ...   def foo(self):
+        ...     pass
+        ...
+        >>> Foo.foo(Foo())
+        >>> MockFoo = create_autospec(Foo)
+        >>> MockFoo.foo(MockFoo())
+        Traceback (most recent call last):
+          ...
+        TypeError: <lambda>() takes exactly 1 argument (2 given)
+
+    The reason is that its very hard to tell the difference between functions,
+    unbound methods and staticmethods across Python 2 & 3 and the alternative
+    implementations. This restriction may be fixed in future versions.
+
+
+------
+
+.. [#] This only applies to classes or already instantiated objects. Calling
+   a mocked class to create a mock instance *does not* create a real instance.
+   It is only attribute lookups - along with calls to `dir` - that are done. A
+   way round this problem would have been to use `getattr_static
+   <http://docs.python.org/dev/library/inspect.html#inspect.getattr_static>`_,
+   which can fetch attributes without triggering code execution. Descriptors
+   like `classmethod` and `staticmethod` *need* to be fetched correctly though,
+   so that their signatures can be mocked correctly.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/index.txt
@@ -0,0 +1,411 @@
+====================================
+ Mock - Mocking and Testing Library
+====================================
+
+.. currentmodule:: mock
+
+:Author: `Michael Foord
+ <http://www.voidspace.org.uk/python/weblog/index.shtml>`_
+:Version: |release|
+:Date: 2012/10/07
+:Homepage: `Mock Homepage`_
+:Download: `Mock on PyPI`_
+:Documentation: `PDF Documentation
+ <http://www.voidspace.org.uk/downloads/mock-1.0.0.pdf>`_
+:License: `BSD License`_
+:Support: `Mailing list (testing-in-python@lists.idyll.org)
+ <http://lists.idyll.org/listinfo/testing-in-python>`_
+:Issue tracker: `Google code project
+ <http://code.google.com/p/mock/issues/list>`_
+
+.. _Mock Homepage: http://www.voidspace.org.uk/python/mock/
+.. _BSD License: http://www.voidspace.org.uk/python/license.shtml
+
+
+.. currentmodule:: mock
+
+.. module:: mock
+   :synopsis: Mock object and testing library.
+
+.. index:: introduction
+
+mock is a library for testing in Python. It allows you to replace parts of
+your system under test with mock objects and make assertions about how they
+have been used.
+
+mock is now part of the Python standard library, available as `unittest.mock
+<http://docs.python.org/py3k/library/unittest.mock.html#module-unittest.mock>`_
+in Python 3.3 onwards.
+
+mock provides a core :class:`Mock` class removing the need to create a host
+of stubs throughout your test suite. After performing an action, you can make
+assertions about which methods / attributes were used and arguments they were
+called with. You can also specify return values and set needed attributes in
+the normal way.
+
+Additionally, mock provides a :func:`patch` decorator that handles patching
+module and class level attributes within the scope of a test, along with
+:const:`sentinel` for creating unique objects. See the `quick guide`_ for
+some examples of how to use :class:`Mock`, :class:`MagicMock` and
+:func:`patch`.
+
+Mock is very easy to use and is designed for use with
+`unittest <http://pypi.python.org/pypi/unittest2>`_. Mock is based on
+the 'action -> assertion' pattern instead of `'record -> replay'` used by many
+mocking frameworks.
+
+mock is tested on Python versions 2.4-2.7, Python 3 plus the latest versions of
+Jython and PyPy.
+
+
+.. testsetup::
+
+   class ProductionClass(object):
+      def method(self, *args):
+         pass
+
+   module = sys.modules['module'] = ProductionClass
+   ProductionClass.ClassName1 = ProductionClass
+   ProductionClass.ClassName2 = ProductionClass
+
+
+
+API Documentation
+=================
+
+.. toctree::
+   :maxdepth: 2
+
+   mock
+   patch
+   helpers
+   sentinel
+   magicmock
+
+
+User Guide
+==========
+
+.. toctree::
+   :maxdepth: 2
+
+   getting-started
+   examples
+   compare
+   changelog
+
+
+.. index:: installing
+
+Installing
+==========
+
+The current version is |release|. Mock is stable and widely used. If you do
+find any bugs, or have suggestions for improvements / extensions
+then please contact us.
+
+* `mock on PyPI <http://pypi.python.org/pypi/mock>`_
+* `mock documentation as PDF
+  <http://www.voidspace.org.uk/downloads/mock-1.0.0.pdf>`_
+* `Google Code Home & Mercurial Repository <http://code.google.com/p/mock/>`_
+
+.. index:: repository
+.. index:: hg
+
+You can checkout the latest development version from the Google Code Mercurial
+repository with the following command:
+
+    ``hg clone https://mock.googlecode.com/hg/ mock``
+
+
+.. index:: pip
+.. index:: easy_install
+.. index:: setuptools
+
+If you have pip, setuptools or distribute you can install mock with:
+
+    | ``easy_install -U mock``
+    | ``pip install -U mock``
+
+Alternatively you can download the mock distribution from PyPI and after
+unpacking run:
+
+   ``python setup.py install``
+
+
+Quick Guide
+===========
+
+:class:`Mock` and :class:`MagicMock` objects create all attributes and
+methods as you access them and store details of how they have been used. You
+can configure them, to specify return values or limit what attributes are
+available, and then make assertions about how they have been used:
+
+.. doctest::
+
+    >>> from mock import MagicMock
+    >>> thing = ProductionClass()
+    >>> thing.method = MagicMock(return_value=3)
+    >>> thing.method(3, 4, 5, key='value')
+    3
+    >>> thing.method.assert_called_with(3, 4, 5, key='value')
+
+:attr:`side_effect` allows you to perform side effects, including raising an
+exception when a mock is called:
+
+.. doctest::
+
+   >>> mock = Mock(side_effect=KeyError('foo'))
+   >>> mock()
+   Traceback (most recent call last):
+    ...
+   KeyError: 'foo'
+
+   >>> values = {'a': 1, 'b': 2, 'c': 3}
+   >>> def side_effect(arg):
+   ...     return values[arg]
+   ...
+   >>> mock.side_effect = side_effect
+   >>> mock('a'), mock('b'), mock('c')
+   (1, 2, 3)
+   >>> mock.side_effect = [5, 4, 3, 2, 1]
+   >>> mock(), mock(), mock()
+   (5, 4, 3)
+
+Mock has many other ways you can configure it and control its behaviour. For
+example the `spec` argument configures the mock to take its specification
+from another object. Attempting to access attributes or methods on the mock
+that don't exist on the spec will fail with an `AttributeError`.
+
+The :func:`patch` decorator / context manager makes it easy to mock classes or
+objects in a module under test. The object you specify will be replaced with a
+mock (or other object) during the test and restored when the test ends:
+
+.. doctest::
+
+    >>> from mock import patch
+    >>> @patch('module.ClassName2')
+    ... @patch('module.ClassName1')
+    ... def test(MockClass1, MockClass2):
+    ...     module.ClassName1()
+    ...     module.ClassName2()
+
+    ...     assert MockClass1 is module.ClassName1
+    ...     assert MockClass2 is module.ClassName2
+    ...     assert MockClass1.called
+    ...     assert MockClass2.called
+    ...
+    >>> test()
+
+.. note::
+
+   When you nest patch decorators the mocks are passed in to the decorated
+   function in the same order they applied (the normal *python* order that
+   decorators are applied). This means from the bottom up, so in the example
+   above the mock for `module.ClassName1` is passed in first.
+
+   With `patch` it matters that you patch objects in the namespace where they
+   are looked up. This is normally straightforward, but for a quick guide
+   read :ref:`where to patch <where-to-patch>`.
+
+As well as a decorator `patch` can be used as a context manager in a with
+statement:
+
+.. doctest::
+
+    >>> with patch.object(ProductionClass, 'method', return_value=None) as mock_method:
+    ...     thing = ProductionClass()
+    ...     thing.method(1, 2, 3)
+    ...
+    >>> mock_method.assert_called_once_with(1, 2, 3)
+
+
+There is also :func:`patch.dict` for setting values in a dictionary just
+during a scope and restoring the dictionary to its original state when the test
+ends:
+
+.. doctest::
+
+   >>> foo = {'key': 'value'}
+   >>> original = foo.copy()
+   >>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
+   ...     assert foo == {'newkey': 'newvalue'}
+   ...
+   >>> assert foo == original
+
+Mock supports the mocking of Python :ref:`magic methods <magic-methods>`. The
+easiest way of using magic methods is with the :class:`MagicMock` class. It
+allows you to do things like:
+
+.. doctest::
+
+    >>> mock = MagicMock()
+    >>> mock.__str__.return_value = 'foobarbaz'
+    >>> str(mock)
+    'foobarbaz'
+    >>> mock.__str__.assert_called_with()
+
+Mock allows you to assign functions (or other Mock instances) to magic methods
+and they will be called appropriately. The `MagicMock` class is just a Mock
+variant that has all of the magic methods pre-created for you (well, all the
+useful ones anyway).
+
+The following is an example of using magic methods with the ordinary Mock
+class:
+
+.. doctest::
+
+    >>> mock = Mock()
+    >>> mock.__str__ = Mock(return_value='wheeeeee')
+    >>> str(mock)
+    'wheeeeee'
+
+For ensuring that the mock objects in your tests have the same api as the
+objects they are replacing, you can use :ref:`auto-speccing <auto-speccing>`.
+Auto-speccing can be done through the `autospec` argument to patch, or the
+:func:`create_autospec` function. Auto-speccing creates mock objects that
+have the same attributes and methods as the objects they are replacing, and
+any functions and methods (including constructors) have the same call
+signature as the real object.
+
+This ensures that your mocks will fail in the same way as your production
+code if they are used incorrectly:
+
+.. doctest::
+
+   >>> from mock import create_autospec
+   >>> def function(a, b, c):
+   ...     pass
+   ...
+   >>> mock_function = create_autospec(function, return_value='fishy')
+   >>> mock_function(1, 2, 3)
+   'fishy'
+   >>> mock_function.assert_called_once_with(1, 2, 3)
+   >>> mock_function('wrong arguments')
+   Traceback (most recent call last):
+    ...
+   TypeError: <lambda>() takes exactly 3 arguments (1 given)
+
+`create_autospec` can also be used on classes, where it copies the signature of
+the `__init__` method, and on callable objects where it copies the signature of
+the `__call__` method.
+
+
+.. index:: references
+.. index:: articles
+
+References
+==========
+
+Articles, blog entries and other stuff related to testing with Mock:
+
+* `Imposing a No DB Discipline on Django unit tests
+  <https://github.com/carljm/django-testing-slides/blob/master/models/30_no_database.md>`_
+* `mock-django: tools for mocking the Django ORM and models
+  <https://github.com/dcramer/mock-django>`_
+* `PyCon 2011 Video: Testing with mock <https://blip.tv/file/4881513>`_
+* `Mock objects in Python
+  <http://noopenblockers.com/2012/01/06/mock-objects-in-python/>`_
+* `Python: Injecting Mock Objects for Powerful Testing
+  <http://blueprintforge.com/blog/2012/01/08/python-injecting-mock-objects-for-powerful-testing/>`_
+* `Python Mock: How to assert a substring of logger output
+  <http://www.michaelpollmeier.com/python-mock-how-to-assert-a-substring-of-logger-output/>`_
+* `Mocking Django <http://www.mattjmorrison.com/2011/09/mocking-django.html>`_
+* `Mocking dates and other classes that can't be modified
+  <http://williamjohnbert.com/2011/07/how-to-unit-testing-in-django-with-mocking-and-patching/>`_
+* `Mock recipes <http://konryd.blogspot.com/2010/06/mock-recipies.html>`_
+* `Mockity mock mock - some love for the mock module
+  <http://konryd.blogspot.com/2010/05/mockity-mock-mock-some-love-for-mock.html>`_
+* `Coverage and Mock (with django)
+  <http://mattsnider.com/python/mock-and-coverage/>`_
+* `Python Unit Testing with Mock <http://www.insomnihack.com/?p=194>`_
+* `Getting started with Python Mock
+  <http://myadventuresincoding.wordpress.com/2011/02/26/python-python-mock-cheat-sheet/>`_
+* `Smart Parameter Checks with mock
+  <http://tobyho.com/2011/03/24/smart-parameter-checks-in/>`_
+* `Python mock testing techniques and tools
+  <http://agiletesting.blogspot.com/2009/07/python-mock-testing-techniques-and.html>`_
+* `How To Test Django Template Tags
+  <http://techblog.ironfroggy.com/2008/10/how-to-test.html>`_
+* `A presentation on Unit Testing with Mock
+  <http://pypap.blogspot.com/2008/10/newbie-nugget-unit-testing-with-mock.html>`_
+* `Mocking with Django and Google AppEngine
+  <http://michael-a-nelson.blogspot.com/2008/09/mocking-with-django-and-google-app.html>`_
+
+
+.. index:: tests
+.. index:: unittest2
+
+Tests
+=====
+
+Mock uses `unittest2 <http://pypi.python.org/pypi/unittest2>`_ for its own
+test suite. In order to run it, use the `unit2` script that comes with
+`unittest2` module on a checkout of the source repository:
+
+   `unit2 discover`
+
+If you have `setuptools <http://pypi.python.org/pypi/distribute>`_ as well as
+unittest2 you can run:
+
+   ``python setup.py test``
+
+On Python 3.2 you can use ``unittest`` module from the standard library.
+
+   ``python3.2 -m unittest discover``
+
+.. index:: Python 3
+
+On Python 3 the tests for unicode are skipped as they are not relevant. On
+Python 2.4 tests that use the with statements are skipped as the with statement
+is invalid syntax on Python 2.4.
+
+
+.. index:: older versions
+
+Older Versions
+==============
+
+Documentation for older versions of mock:
+
+* `mock 0.8 <http://www.voidspace.org.uk/python/mock/0.8/>`_
+* `mock 0.7 <http://www.voidspace.org.uk/python/mock/0.7/>`_
+* `mock 0.6 <http://www.voidspace.org.uk/python/mock/0.6.0/>`_
+
+Docs from the in-development version of `mock` can be found at
+`mock.readthedocs.org <http://mock.readthedocs.org>`_.
+
+
+Terminology
+===========
+
+Terminology for objects used to replace other ones can be confusing. Terms
+like double, fake, mock, stub, and spy are all used with varying meanings.
+
+In `classic mock terminology
+<http://xunitpatterns.com/Mocks,%20Fakes,%20Stubs%20and%20Dummies.html>`_
+:class:`mock.Mock` is a `spy <http://xunitpatterns.com/Test%20Spy.html>`_ that
+allows for *post-mortem* examination. This is what I call the "action ->
+assertion" [#]_ pattern of testing.
+
+I'm not however a fan of this "statically typed mocking terminology"
+promulgated by `Martin Fowler
+<http://martinfowler.com/articles/mocksArentStubs.html>`_. It confuses usage
+patterns with implementation and prevents you from using natural terminology
+when discussing mocking.
+
+I much prefer duck typing, if an object used in your test suite looks like a
+mock object and quacks like a mock object then it's fine to call it a mock, no
+matter what the implementation looks like.
+
+This terminology is perhaps more useful in less capable languages where
+different usage patterns will *require* different implementations.
+`mock.Mock()` is capable of being used in most of the different roles
+described by Fowler, except (annoyingly / frustratingly / ironically) a Mock
+itself!
+
+How about a simpler definition: a "mock object" is an object used to replace a
+real one in a system under test.
+
+.. [#] This pattern is called "AAA" by some members of the testing community;
+   "Arrange - Act - Assert".
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/magicmock.txt
@@ -0,0 +1,258 @@
+
+.. currentmodule:: mock
+
+
+.. _magic-methods:
+
+Mocking Magic Methods
+=====================
+
+.. currentmodule:: mock
+
+:class:`Mock` supports mocking `magic methods
+<http://www.ironpythoninaction.com/magic-methods.html>`_. This allows mock
+objects to replace containers or other objects that implement Python
+protocols.
+
+Because magic methods are looked up differently from normal methods [#]_, this
+support has been specially implemented. This means that only specific magic
+methods are supported. The supported list includes *almost* all of them. If
+there are any missing that you need please let us know!
+
+You mock magic methods by setting the method you are interested in to a function
+or a mock instance. If you are using a function then it *must* take ``self`` as
+the first argument [#]_.
+
+.. doctest::
+
+   >>> def __str__(self):
+   ...     return 'fooble'
+   ...
+   >>> mock = Mock()
+   >>> mock.__str__ = __str__
+   >>> str(mock)
+   'fooble'
+
+   >>> mock = Mock()
+   >>> mock.__str__ = Mock()
+   >>> mock.__str__.return_value = 'fooble'
+   >>> str(mock)
+   'fooble'
+
+   >>> mock = Mock()
+   >>> mock.__iter__ = Mock(return_value=iter([]))
+   >>> list(mock)
+   []
+
+One use case for this is for mocking objects used as context managers in a
+`with` statement:
+
+.. doctest::
+
+   >>> mock = Mock()
+   >>> mock.__enter__ = Mock(return_value='foo')
+   >>> mock.__exit__ = Mock(return_value=False)
+   >>> with mock as m:
+   ...     assert m == 'foo'
+   ...
+   >>> mock.__enter__.assert_called_with()
+   >>> mock.__exit__.assert_called_with(None, None, None)
+
+Calls to magic methods do not appear in :attr:`~Mock.method_calls`, but they
+are recorded in :attr:`~Mock.mock_calls`.
+
+.. note::
+
+   If you use the `spec` keyword argument to create a mock then attempting to
+   set a magic method that isn't in the spec will raise an `AttributeError`.
+
+The full list of supported magic methods is:
+
+* ``__hash__``, ``__sizeof__``, ``__repr__`` and ``__str__``
+* ``__dir__``, ``__format__`` and ``__subclasses__``
+* ``__floor__``, ``__trunc__`` and ``__ceil__``
+* Comparisons: ``__cmp__``, ``__lt__``, ``__gt__``, ``__le__``, ``__ge__``,
+  ``__eq__`` and ``__ne__``
+* Container methods: ``__getitem__``, ``__setitem__``, ``__delitem__``,
+  ``__contains__``, ``__len__``, ``__iter__``, ``__getslice__``,
+  ``__setslice__``, ``__reversed__`` and ``__missing__``
+* Context manager: ``__enter__`` and ``__exit__``
+* Unary numeric methods: ``__neg__``, ``__pos__`` and ``__invert__``
+* The numeric methods (including right hand and in-place variants):
+  ``__add__``, ``__sub__``, ``__mul__``, ``__div__``,
+  ``__floordiv__``, ``__mod__``, ``__divmod__``, ``__lshift__``,
+  ``__rshift__``, ``__and__``, ``__xor__``, ``__or__``, and ``__pow__``
+* Numeric conversion methods: ``__complex__``, ``__int__``, ``__float__``,
+  ``__index__`` and ``__coerce__``
+* Descriptor methods: ``__get__``, ``__set__`` and ``__delete__``
+* Pickling: ``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``,
+  ``__getnewargs__``, ``__getstate__`` and ``__setstate__``
+
+
+The following methods are supported in Python 2 but don't exist in Python 3:
+
+* ``__unicode__``, ``__long__``, ``__oct__``, ``__hex__`` and ``__nonzero__``
+*  ``__truediv__`` and ``__rtruediv__``
+
+The following methods are supported in Python 3 but don't exist in Python 2:
+
+* ``__bool__`` and ``__next__``
+
+The following methods exist but are *not* supported as they are either in use by
+mock, can't be set dynamically, or can cause problems:
+
+* ``__getattr__``, ``__setattr__``, ``__init__`` and ``__new__``
+* ``__prepare__``, ``__instancecheck__``, ``__subclasscheck__``, ``__del__``
+
+
+
+Magic Mock
+==========
+
+There are two `MagicMock` variants: `MagicMock` and `NonCallableMagicMock`.
+
+
+.. class:: MagicMock(*args, **kw)
+
+   ``MagicMock`` is a subclass of :class:`Mock` with default implementations
+   of most of the magic methods. You can use ``MagicMock`` without having to
+   configure the magic methods yourself.
+
+   The constructor parameters have the same meaning as for :class:`Mock`.
+
+   If you use the `spec` or `spec_set` arguments then *only* magic methods
+   that exist in the spec will be created.
+
+
+.. class:: NonCallableMagicMock(*args, **kw)
+
+    A non-callable version of `MagicMock`.
+
+    The constructor parameters have the same meaning as for
+    :class:`MagicMock`, with the exception of `return_value` and
+    `side_effect` which have no meaning on a non-callable mock.
+
+The magic methods are setup with `MagicMock` objects, so you can configure them
+and use them in the usual way:
+
+.. doctest::
+
+   >>> mock = MagicMock()
+   >>> mock[3] = 'fish'
+   >>> mock.__setitem__.assert_called_with(3, 'fish')
+   >>> mock.__getitem__.return_value = 'result'
+   >>> mock[2]
+   'result'
+
+By default many of the protocol methods are required to return objects of a
+specific type. These methods are preconfigured with a default return value, so
+that they can be used without you having to do anything if you aren't interested
+in the return value. You can still *set* the return value manually if you want
+to change the default.
+
+Methods and their defaults:
+
+* ``__lt__``: NotImplemented
+* ``__gt__``: NotImplemented
+* ``__le__``: NotImplemented
+* ``__ge__``: NotImplemented
+* ``__int__`` : 1
+* ``__contains__`` : False
+* ``__len__`` : 1
+* ``__iter__`` : iter([])
+* ``__exit__`` : False
+* ``__complex__`` : 1j
+* ``__float__`` : 1.0
+* ``__bool__`` : True
+* ``__nonzero__`` : True
+* ``__oct__`` : '1'
+* ``__hex__`` : '0x1'
+* ``__long__`` : long(1)
+* ``__index__`` : 1
+* ``__hash__`` : default hash for the mock
+* ``__str__`` : default str for the mock
+* ``__unicode__`` : default unicode for the mock
+* ``__sizeof__``: default sizeof for the mock
+
+For example:
+
+.. doctest::
+
+   >>> mock = MagicMock()
+   >>> int(mock)
+   1
+   >>> len(mock)
+   0
+   >>> hex(mock)
+   '0x1'
+   >>> list(mock)
+   []
+   >>> object() in mock
+   False
+
+The two equality method, `__eq__` and `__ne__`, are special (changed in
+0.7.2). They do the default equality comparison on identity, using a side
+effect, unless you change their return value to return something else:
+
+.. doctest::
+
+   >>> MagicMock() == 3
+   False
+   >>> MagicMock() != 3
+   True
+   >>> mock = MagicMock()
+   >>> mock.__eq__.return_value = True
+   >>> mock == 3
+   True
+
+In `0.8` the `__iter__` also gained special handling implemented with a
+side effect. The return value of `MagicMock.__iter__` can be any iterable
+object and isn't required to be an iterator:
+
+.. doctest::
+
+   >>> mock = MagicMock()
+   >>> mock.__iter__.return_value = ['a', 'b', 'c']
+   >>> list(mock)
+   ['a', 'b', 'c']
+   >>> list(mock)
+   ['a', 'b', 'c']
+
+If the return value *is* an iterator, then iterating over it once will consume
+it and subsequent iterations will result in an empty list:
+
+.. doctest::
+
+   >>> mock.__iter__.return_value = iter(['a', 'b', 'c'])
+   >>> list(mock)
+   ['a', 'b', 'c']
+   >>> list(mock)
+   []
+
+``MagicMock`` has all of the supported magic methods configured except for some
+of the obscure and obsolete ones. You can still set these up if you want.
+
+Magic methods that are supported but not setup by default in ``MagicMock`` are:
+
+* ``__cmp__``
+* ``__getslice__`` and ``__setslice__``
+* ``__coerce__``
+* ``__subclasses__``
+* ``__dir__``
+* ``__format__``
+* ``__get__``, ``__set__`` and ``__delete__``
+* ``__reversed__`` and ``__missing__``
+* ``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, ``__getnewargs__``,
+  ``__getstate__`` and ``__setstate__``
+* ``__getformat__`` and ``__setformat__``
+
+
+
+------------
+
+.. [#] Magic methods *should* be looked up on the class rather than the
+   instance. Different versions of Python are inconsistent about applying this
+   rule. The supported protocol methods should work with all supported versions
+   of Python.
+.. [#] The function is basically hooked up to the class, but each ``Mock``
+   instance is kept isolated from the others.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/mock.txt
@@ -0,0 +1,842 @@
+The Mock Class
+==============
+
+.. currentmodule:: mock
+
+.. testsetup::
+
+    class SomeClass:
+        pass
+
+
+`Mock` is a flexible mock object intended to replace the use of stubs and
+test doubles throughout your code. Mocks are callable and create attributes as
+new mocks when you access them [#]_. Accessing the same attribute will always
+return the same mock. Mocks record how you use them, allowing you to make
+assertions about what your code has done to them.
+
+:class:`MagicMock` is a subclass of `Mock` with all the magic methods
+pre-created and ready to use. There are also non-callable variants, useful
+when you are mocking out objects that aren't callable:
+:class:`NonCallableMock` and :class:`NonCallableMagicMock`
+
+The :func:`patch` decorators makes it easy to temporarily replace classes
+in a particular module with a `Mock` object. By default `patch` will create
+a `MagicMock` for you. You can specify an alternative class of `Mock` using
+the `new_callable` argument to `patch`.
+
+
+.. index:: side_effect
+.. index:: return_value
+.. index:: wraps
+.. index:: name
+.. index:: spec
+
+.. class:: Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, **kwargs)
+
+    Create a new `Mock` object. `Mock` takes several optional arguments
+    that specify the behaviour of the Mock object:
+
+    * `spec`: This can be either a list of strings or an existing object (a
+      class or instance) that acts as the specification for the mock object. If
+      you pass in an object then a list of strings is formed by calling dir on
+      the object (excluding unsupported magic attributes and methods).
+      Accessing any attribute not in this list will raise an `AttributeError`.
+
+      If `spec` is an object (rather than a list of strings) then
+      :attr:`__class__` returns the class of the spec object. This allows mocks
+      to pass `isinstance` tests.
+
+    * `spec_set`: A stricter variant of `spec`. If used, attempting to *set*
+      or get an attribute on the mock that isn't on the object passed as
+      `spec_set` will raise an `AttributeError`.
+
+    * `side_effect`: A function to be called whenever the Mock is called. See
+      the :attr:`~Mock.side_effect` attribute. Useful for raising exceptions or
+      dynamically changing return values. The function is called with the same
+      arguments as the mock, and unless it returns :data:`DEFAULT`, the return
+      value of this function is used as the return value.
+
+      Alternatively `side_effect` can be an exception class or instance. In
+      this case the exception will be raised when the mock is called.
+
+      If `side_effect` is an iterable then each call to the mock will return
+      the next value from the iterable. If any of the members of the iterable
+      are exceptions they will be raised instead of returned.
+
+      A `side_effect` can be cleared by setting it to `None`.
+
+    * `return_value`: The value returned when the mock is called. By default
+      this is a new Mock (created on first access). See the
+      :attr:`return_value` attribute.
+
+    * `wraps`: Item for the mock object to wrap. If `wraps` is not None then
+      calling the Mock will pass the call through to the wrapped object
+      (returning the real result and ignoring `return_value`). Attribute access
+      on the mock will return a Mock object that wraps the corresponding
+      attribute of the wrapped object (so attempting to access an attribute
+      that doesn't exist will raise an `AttributeError`).
+
+      If the mock has an explicit `return_value` set then calls are not passed
+      to the wrapped object and the `return_value` is returned instead.
+
+    * `name`: If the mock has a name then it will be used in the repr of the
+      mock. This can be useful for debugging. The name is propagated to child
+      mocks.
+
+    Mocks can also be called with arbitrary keyword arguments. These will be
+    used to set attributes on the mock after it is created. See the
+    :meth:`configure_mock` method for details.
+
+
+    .. method:: assert_called_with(*args, **kwargs)
+
+        This method is a convenient way of asserting that calls are made in a
+        particular way:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.method(1, 2, 3, test='wow')
+            <Mock name='mock.method()' id='...'>
+            >>> mock.method.assert_called_with(1, 2, 3, test='wow')
+
+
+    .. method:: assert_called_once_with(*args, **kwargs)
+
+       Assert that the mock was called exactly once and with the specified
+       arguments.
+
+       .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock('foo', bar='baz')
+            >>> mock.assert_called_once_with('foo', bar='baz')
+            >>> mock('foo', bar='baz')
+            >>> mock.assert_called_once_with('foo', bar='baz')
+            Traceback (most recent call last):
+              ...
+            AssertionError: Expected to be called once. Called 2 times.
+
+
+    .. method:: assert_any_call(*args, **kwargs)
+
+        assert the mock has been called with the specified arguments.
+
+        The assert passes if the mock has *ever* been called, unlike
+        :meth:`assert_called_with` and :meth:`assert_called_once_with` that
+        only pass if the call is the most recent one.
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock(1, 2, arg='thing')
+            >>> mock('some', 'thing', 'else')
+            >>> mock.assert_any_call(1, 2, arg='thing')
+
+
+    .. method:: assert_has_calls(calls, any_order=False)
+
+        assert the mock has been called with the specified calls.
+        The `mock_calls` list is checked for the calls.
+
+        If `any_order` is False (the default) then the calls must be
+        sequential. There can be extra calls before or after the
+        specified calls.
+
+        If `any_order` is True then the calls can be in any order, but
+        they must all appear in :attr:`mock_calls`.
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock(1)
+            >>> mock(2)
+            >>> mock(3)
+            >>> mock(4)
+            >>> calls = [call(2), call(3)]
+            >>> mock.assert_has_calls(calls)
+            >>> calls = [call(4), call(2), call(3)]
+            >>> mock.assert_has_calls(calls, any_order=True)
+
+
+    .. method:: reset_mock()
+
+        The reset_mock method resets all the call attributes on a mock object:
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock('hello')
+            >>> mock.called
+            True
+            >>> mock.reset_mock()
+            >>> mock.called
+            False
+
+        This can be useful where you want to make a series of assertions that
+        reuse the same object. Note that `reset_mock` *doesn't* clear the
+        return value, :attr:`side_effect` or any child attributes you have
+        set using normal assignment. Child mocks and the return value mock
+        (if any) are reset as well.
+
+
+    .. method:: mock_add_spec(spec, spec_set=False)
+
+        Add a spec to a mock. `spec` can either be an object or a
+        list of strings. Only attributes on the `spec` can be fetched as
+        attributes from the mock.
+
+        If `spec_set` is `True` then only attributes on the spec can be set.
+
+
+    .. method:: attach_mock(mock, attribute)
+
+        Attach a mock as an attribute of this one, replacing its name and
+        parent. Calls to the attached mock will be recorded in the
+        :attr:`method_calls` and :attr:`mock_calls` attributes of this one.
+
+
+    .. method:: configure_mock(**kwargs)
+
+        Set attributes on the mock through keyword arguments.
+
+        Attributes plus return values and side effects can be set on child
+        mocks using standard dot notation and unpacking a dictionary in the
+        method call:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
+            >>> mock.configure_mock(**attrs)
+            >>> mock.method()
+            3
+            >>> mock.other()
+            Traceback (most recent call last):
+              ...
+            KeyError
+
+        The same thing can be achieved in the constructor call to mocks:
+
+        .. doctest::
+
+            >>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
+            >>> mock = Mock(some_attribute='eggs', **attrs)
+            >>> mock.some_attribute
+            'eggs'
+            >>> mock.method()
+            3
+            >>> mock.other()
+            Traceback (most recent call last):
+              ...
+            KeyError
+
+        `configure_mock` exists to make it easier to do configuration
+        after the mock has been created.
+
+
+    .. method:: __dir__()
+
+        `Mock` objects limit the results of `dir(some_mock)` to useful results.
+        For mocks with a `spec` this includes all the permitted attributes
+        for the mock.
+
+        See :data:`FILTER_DIR` for what this filtering does, and how to
+        switch it off.
+
+
+    .. method:: _get_child_mock(**kw)
+
+        Create the child mocks for attributes and return value.
+        By default child mocks will be the same type as the parent.
+        Subclasses of Mock may want to override this to customize the way
+        child mocks are made.
+
+        For non-callable mocks the callable variant will be used (rather than
+        any custom subclass).
+
+
+    .. attribute:: called
+
+        A boolean representing whether or not the mock object has been called:
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock.called
+            False
+            >>> mock()
+            >>> mock.called
+            True
+
+    .. attribute:: call_count
+
+        An integer telling you how many times the mock object has been called:
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock.call_count
+            0
+            >>> mock()
+            >>> mock()
+            >>> mock.call_count
+            2
+
+
+    .. attribute:: return_value
+
+        Set this to configure the value returned by calling the mock:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.return_value = 'fish'
+            >>> mock()
+            'fish'
+
+        The default return value is a mock object and you can configure it in
+        the normal way:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.return_value.attribute = sentinel.Attribute
+            >>> mock.return_value()
+            <Mock name='mock()()' id='...'>
+            >>> mock.return_value.assert_called_with()
+
+        `return_value` can also be set in the constructor:
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=3)
+            >>> mock.return_value
+            3
+            >>> mock()
+            3
+
+
+    .. attribute:: side_effect
+
+        This can either be a function to be called when the mock is called,
+        or an exception (class or instance) to be raised.
+
+        If you pass in a function it will be called with same arguments as the
+        mock and unless the function returns the :data:`DEFAULT` singleton the
+        call to the mock will then return whatever the function returns. If the
+        function returns :data:`DEFAULT` then the mock will return its normal
+        value (from the :attr:`return_value`.
+
+        An example of a mock that raises an exception (to test exception
+        handling of an API):
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.side_effect = Exception('Boom!')
+            >>> mock()
+            Traceback (most recent call last):
+              ...
+            Exception: Boom!
+
+        Using `side_effect` to return a sequence of values:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.side_effect = [3, 2, 1]
+            >>> mock(), mock(), mock()
+            (3, 2, 1)
+
+        The `side_effect` function is called with the same arguments as the
+        mock (so it is wise for it to take arbitrary args and keyword
+        arguments) and whatever it returns is used as the return value for
+        the call. The exception is if `side_effect` returns :data:`DEFAULT`,
+        in which case the normal :attr:`return_value` is used.
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=3)
+            >>> def side_effect(*args, **kwargs):
+            ...     return DEFAULT
+            ...
+            >>> mock.side_effect = side_effect
+            >>> mock()
+            3
+
+        `side_effect` can be set in the constructor. Here's an example that
+        adds one to the value the mock is called with and returns it:
+
+        .. doctest::
+
+            >>> side_effect = lambda value: value + 1
+            >>> mock = Mock(side_effect=side_effect)
+            >>> mock(3)
+            4
+            >>> mock(-8)
+            -7
+
+        Setting `side_effect` to `None` clears it:
+
+        .. doctest::
+
+            >>> from mock import Mock
+            >>> m = Mock(side_effect=KeyError, return_value=3)
+            >>> m()
+            Traceback (most recent call last):
+             ...
+            KeyError
+            >>> m.side_effect = None
+            >>> m()
+            3
+
+
+    .. attribute:: call_args
+
+        This is either `None` (if the mock hasn't been called), or the
+        arguments that the mock was last called with. This will be in the
+        form of a tuple: the first member is any ordered arguments the mock
+        was called with (or an empty tuple) and the second member is any
+        keyword arguments (or an empty dictionary).
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> print mock.call_args
+            None
+            >>> mock()
+            >>> mock.call_args
+            call()
+            >>> mock.call_args == ()
+            True
+            >>> mock(3, 4)
+            >>> mock.call_args
+            call(3, 4)
+            >>> mock.call_args == ((3, 4),)
+            True
+            >>> mock(3, 4, 5, key='fish', next='w00t!')
+            >>> mock.call_args
+            call(3, 4, 5, key='fish', next='w00t!')
+
+        `call_args`, along with members of the lists :attr:`call_args_list`,
+        :attr:`method_calls` and :attr:`mock_calls` are :data:`call` objects.
+        These are tuples, so they can be unpacked to get at the individual
+        arguments and make more complex assertions. See
+        :ref:`calls as tuples <calls-as-tuples>`.
+
+
+    .. attribute:: call_args_list
+
+        This is a list of all the calls made to the mock object in sequence
+        (so the length of the list is the number of times it has been
+        called). Before any calls have been made it is an empty list. The
+        :data:`call` object can be used for conveniently constructing lists of
+        calls to compare with `call_args_list`.
+
+        .. doctest::
+
+            >>> mock = Mock(return_value=None)
+            >>> mock()
+            >>> mock(3, 4)
+            >>> mock(key='fish', next='w00t!')
+            >>> mock.call_args_list
+            [call(), call(3, 4), call(key='fish', next='w00t!')]
+            >>> expected = [(), ((3, 4),), ({'key': 'fish', 'next': 'w00t!'},)]
+            >>> mock.call_args_list == expected
+            True
+
+        Members of `call_args_list` are :data:`call` objects. These can be
+        unpacked as tuples to get at the individual arguments. See
+        :ref:`calls as tuples <calls-as-tuples>`.
+
+
+    .. attribute:: method_calls
+
+        As well as tracking calls to themselves, mocks also track calls to
+        methods and attributes, and *their* methods and attributes:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.method()
+            <Mock name='mock.method()' id='...'>
+            >>> mock.property.method.attribute()
+            <Mock name='mock.property.method.attribute()' id='...'>
+            >>> mock.method_calls
+            [call.method(), call.property.method.attribute()]
+
+        Members of `method_calls` are :data:`call` objects. These can be
+        unpacked as tuples to get at the individual arguments. See
+        :ref:`calls as tuples <calls-as-tuples>`.
+
+
+    .. attribute:: mock_calls
+
+        `mock_calls` records *all* calls to the mock object, its methods, magic
+        methods *and* return value mocks.
+
+        .. doctest::
+
+            >>> mock = MagicMock()
+            >>> result = mock(1, 2, 3)
+            >>> mock.first(a=3)
+            <MagicMock name='mock.first()' id='...'>
+            >>> mock.second()
+            <MagicMock name='mock.second()' id='...'>
+            >>> int(mock)
+            1
+            >>> result(1)
+            <MagicMock name='mock()()' id='...'>
+            >>> expected = [call(1, 2, 3), call.first(a=3), call.second(),
+            ... call.__int__(), call()(1)]
+            >>> mock.mock_calls == expected
+            True
+
+        Members of `mock_calls` are :data:`call` objects. These can be
+        unpacked as tuples to get at the individual arguments. See
+        :ref:`calls as tuples <calls-as-tuples>`.
+
+
+    .. attribute:: __class__
+
+        Normally the `__class__` attribute of an object will return its type.
+        For a mock object with a `spec` `__class__` returns the spec class
+        instead. This allows mock objects to pass `isinstance` tests for the
+        object they are replacing / masquerading as:
+
+        .. doctest::
+
+            >>> mock = Mock(spec=3)
+            >>> isinstance(mock, int)
+            True
+
+        `__class__` is assignable to, this allows a mock to pass an
+        `isinstance` check without forcing you to use a spec:
+
+        .. doctest::
+
+            >>> mock = Mock()
+            >>> mock.__class__ = dict
+            >>> isinstance(mock, dict)
+            True
+
+.. class:: NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)
+
+    A non-callable version of `Mock`. The constructor parameters have the same
+    meaning of `Mock`, with the exception of `return_value` and `side_effect`
+    which have no meaning on a non-callable mock.
+
+Mock objects that use a class or an instance as a `spec` or `spec_set` are able
+to pass `isintance` tests:
+
+.. doctest::
+
+    >>> mock = Mock(spec=SomeClass)
+    >>> isinstance(mock, SomeClass)
+    True
+    >>> mock = Mock(spec_set=SomeClass())
+    >>> isinstance(mock, SomeClass)
+    True
+
+The `Mock` classes have support for mocking magic methods. See :ref:`magic
+methods <magic-methods>` for the full details.
+
+The mock classes and the :func:`patch` decorators all take arbitrary keyword
+arguments for configuration. For the `patch` decorators the keywords are
+passed to the constructor of the mock being created. The keyword arguments
+are for configuring attributes of the mock:
+
+.. doctest::
+
+        >>> m = MagicMock(attribute=3, other='fish')
+        >>> m.attribute
+        3
+        >>> m.other
+        'fish'
+
+The return value and side effect of child mocks can be set in the same way,
+using dotted notation. As you can't use dotted names directly in a call you
+have to create a dictionary and unpack it using `**`:
+
+.. doctest::
+
+    >>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
+    >>> mock = Mock(some_attribute='eggs', **attrs)
+    >>> mock.some_attribute
+    'eggs'
+    >>> mock.method()
+    3
+    >>> mock.other()
+    Traceback (most recent call last):
+      ...
+    KeyError
+
+
+.. class:: PropertyMock(*args, **kwargs)
+
+   A mock intended to be used as a property, or other descriptor, on a class.
+   `PropertyMock` provides `__get__` and `__set__` methods so you can specify
+   a return value when it is fetched.
+
+   Fetching a `PropertyMock` instance from an object calls the mock, with
+   no args. Setting it calls the mock with the value being set.
+
+   .. doctest::
+
+        >>> class Foo(object):
+        ...     @property
+        ...     def foo(self):
+        ...         return 'something'
+        ...     @foo.setter
+        ...     def foo(self, value):
+        ...         pass
+        ...
+        >>> with patch('__main__.Foo.foo', new_callable=PropertyMock) as mock_foo:
+        ...     mock_foo.return_value = 'mockity-mock'
+        ...     this_foo = Foo()
+        ...     print this_foo.foo
+        ...     this_foo.foo = 6
+        ...
+        mockity-mock
+        >>> mock_foo.mock_calls
+        [call(), call(6)]
+
+Because of the way mock attributes are stored you can't directly attach a
+`PropertyMock` to a mock object. Instead you can attach it to the mock type
+object:
+
+.. doctest::
+
+    >>> m = MagicMock()
+    >>> p = PropertyMock(return_value=3)
+    >>> type(m).foo = p
+    >>> m.foo
+    3
+    >>> p.assert_called_once_with()
+
+
+.. index:: __call__
+.. index:: calling
+
+Calling
+=======
+
+Mock objects are callable. The call will return the value set as the
+:attr:`~Mock.return_value` attribute. The default return value is a new Mock
+object; it is created the first time the return value is accessed (either
+explicitly or by calling the Mock) - but it is stored and the same one
+returned each time.
+
+Calls made to the object will be recorded in the attributes
+like :attr:`~Mock.call_args` and :attr:`~Mock.call_args_list`.
+
+If :attr:`~Mock.side_effect` is set then it will be called after the call has
+been recorded, so if `side_effect` raises an exception the call is still
+recorded.
+
+The simplest way to make a mock raise an exception when called is to make
+:attr:`~Mock.side_effect` an exception class or instance:
+
+.. doctest::
+
+        >>> m = MagicMock(side_effect=IndexError)
+        >>> m(1, 2, 3)
+        Traceback (most recent call last):
+          ...
+        IndexError
+        >>> m.mock_calls
+        [call(1, 2, 3)]
+        >>> m.side_effect = KeyError('Bang!')
+        >>> m('two', 'three', 'four')
+        Traceback (most recent call last):
+          ...
+        KeyError: 'Bang!'
+        >>> m.mock_calls
+        [call(1, 2, 3), call('two', 'three', 'four')]
+
+If `side_effect` is a function then whatever that function returns is what
+calls to the mock return. The `side_effect` function is called with the
+same arguments as the mock. This allows you to vary the return value of the
+call dynamically, based on the input:
+
+.. doctest::
+
+        >>> def side_effect(value):
+        ...     return value + 1
+        ...
+        >>> m = MagicMock(side_effect=side_effect)
+        >>> m(1)
+        2
+        >>> m(2)
+        3
+        >>> m.mock_calls
+        [call(1), call(2)]
+
+If you want the mock to still return the default return value (a new mock), or
+any set return value, then there are two ways of doing this. Either return
+`mock.return_value` from inside `side_effect`, or return :data:`DEFAULT`:
+
+.. doctest::
+
+        >>> m = MagicMock()
+        >>> def side_effect(*args, **kwargs):
+        ...     return m.return_value
+        ...
+        >>> m.side_effect = side_effect
+        >>> m.return_value = 3
+        >>> m()
+        3
+        >>> def side_effect(*args, **kwargs):
+        ...     return DEFAULT
+        ...
+        >>> m.side_effect = side_effect
+        >>> m()
+        3
+
+To remove a `side_effect`, and return to the default behaviour, set the
+`side_effect` to `None`:
+
+.. doctest::
+
+        >>> m = MagicMock(return_value=6)
+        >>> def side_effect(*args, **kwargs):
+        ...     return 3
+        ...
+        >>> m.side_effect = side_effect
+        >>> m()
+        3
+        >>> m.side_effect = None
+        >>> m()
+        6
+
+The `side_effect` can also be any iterable object. Repeated calls to the mock
+will return values from the iterable (until the iterable is exhausted and
+a `StopIteration` is raised):
+
+.. doctest::
+
+        >>> m = MagicMock(side_effect=[1, 2, 3])
+        >>> m()
+        1
+        >>> m()
+        2
+        >>> m()
+        3
+        >>> m()
+        Traceback (most recent call last):
+          ...
+        StopIteration
+
+If any members of the iterable are exceptions they will be raised instead of
+returned:
+
+.. doctest::
+
+        >>> iterable = (33, ValueError, 66)
+        >>> m = MagicMock(side_effect=iterable)
+        >>> m()
+        33
+        >>> m()
+        Traceback (most recent call last):
+         ...
+        ValueError
+        >>> m()
+        66
+
+
+.. _deleting-attributes:
+
+Deleting Attributes
+===================
+
+Mock objects create attributes on demand. This allows them to pretend to be
+objects of any type.
+
+You may want a mock object to return `False` to a `hasattr` call, or raise an
+`AttributeError` when an attribute is fetched. You can do this by providing
+an object as a `spec` for a mock, but that isn't always convenient.
+
+You "block" attributes by deleting them. Once deleted, accessing an attribute
+will raise an `AttributeError`.
+
+.. doctest::
+
+    >>> mock = MagicMock()
+    >>> hasattr(mock, 'm')
+    True
+    >>> del mock.m
+    >>> hasattr(mock, 'm')
+    False
+    >>> del mock.f
+    >>> mock.f
+    Traceback (most recent call last):
+        ...
+    AttributeError: f
+
+
+Attaching Mocks as Attributes
+=============================
+
+When you attach a mock as an attribute of another mock (or as the return
+value) it becomes a "child" of that mock. Calls to the child are recorded in
+the :attr:`~Mock.method_calls` and :attr:`~Mock.mock_calls` attributes of the
+parent. This is useful for configuring child mocks and then attaching them to
+the parent, or for attaching mocks to a parent that records all calls to the
+children and allows you to make assertions about the order of calls between
+mocks:
+
+.. doctest::
+
+    >>> parent = MagicMock()
+    >>> child1 = MagicMock(return_value=None)
+    >>> child2 = MagicMock(return_value=None)
+    >>> parent.child1 = child1
+    >>> parent.child2 = child2
+    >>> child1(1)
+    >>> child2(2)
+    >>> parent.mock_calls
+    [call.child1(1), call.child2(2)]
+
+The exception to this is if the mock has a name. This allows you to prevent
+the "parenting" if for some reason you don't want it to happen.
+
+.. doctest::
+
+    >>> mock = MagicMock()
+    >>> not_a_child = MagicMock(name='not-a-child')
+    >>> mock.attribute = not_a_child
+    >>> mock.attribute()
+    <MagicMock name='not-a-child()' id='...'>
+    >>> mock.mock_calls
+    []
+
+Mocks created for you by :func:`patch` are automatically given names. To
+attach mocks that have names to a parent you use the :meth:`~Mock.attach_mock`
+method:
+
+.. doctest::
+
+    >>> thing1 = object()
+    >>> thing2 = object()
+    >>> parent = MagicMock()
+    >>> with patch('__main__.thing1', return_value=None) as child1:
+    ...     with patch('__main__.thing2', return_value=None) as child2:
+    ...         parent.attach_mock(child1, 'child1')
+    ...         parent.attach_mock(child2, 'child2')
+    ...         child1('one')
+    ...         child2('two')
+    ...
+    >>> parent.mock_calls
+    [call.child1('one'), call.child2('two')]
+
+
+-----
+
+.. [#] The only exceptions are magic methods and attributes (those that have
+       leading and trailing double underscores). Mock doesn't create these but
+       instead of raises an ``AttributeError``. This is because the interpreter
+       will often implicitly request these methods, and gets *very* confused to
+       get a new Mock object when it expects a magic method. If you need magic
+       method support see :ref:`magic methods <magic-methods>`.
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/patch.txt
@@ -0,0 +1,636 @@
+==================
+ Patch Decorators
+==================
+
+
+.. currentmodule:: mock
+
+.. testsetup::
+
+    class SomeClass(object):
+        static_method = None
+        class_method = None
+        attribute = None
+
+    sys.modules['package'] = package = Mock(name='package')
+    sys.modules['package.module'] = package.module
+
+    class TestCase(unittest2.TestCase):
+        def run(self):
+            result = unittest2.TestResult()
+            super(unittest2.TestCase, self).run(result)
+            assert result.wasSuccessful()
+
+.. testcleanup::
+
+    patch.TEST_PREFIX = 'test'
+
+
+The patch decorators are used for patching objects only within the scope of
+the function they decorate. They automatically handle the unpatching for you,
+even if exceptions are raised. All of these functions can also be used in with
+statements or as class decorators.
+
+
+patch
+=====
+
+.. note::
+
+    `patch` is straightforward to use. The key is to do the patching in the
+    right namespace. See the section `where to patch`_.
+
+.. function:: patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
+
+    `patch` acts as a function decorator, class decorator or a context
+    manager. Inside the body of the function or with statement, the `target`
+    is patched with a `new` object. When the function/with statement exits
+    the patch is undone.
+
+    If `new` is omitted, then the target is replaced with a
+    :class:`MagicMock`. If `patch` is used as a decorator and `new` is
+    omitted, the created mock is passed in as an extra argument to the
+    decorated function. If `patch` is used as a context manager the created
+    mock is returned by the context manager.
+
+    `target` should be a string in the form `'package.module.ClassName'`. The
+    `target` is imported and the specified object replaced with the `new`
+    object, so the `target` must be importable from the environment you are
+    calling `patch` from. The target is imported when the decorated function
+    is executed, not at decoration time.
+
+    The `spec` and `spec_set` keyword arguments are passed to the `MagicMock`
+    if patch is creating one for you.
+
+    In addition you can pass `spec=True` or `spec_set=True`, which causes
+    patch to pass in the object being mocked as the spec/spec_set object.
+
+    `new_callable` allows you to specify a different class, or callable object,
+    that will be called to create the `new` object. By default `MagicMock` is
+    used.
+
+    A more powerful form of `spec` is `autospec`. If you set `autospec=True`
+    then the mock with be created with a spec from the object being replaced.
+    All attributes of the mock will also have the spec of the corresponding
+    attribute of the object being replaced. Methods and functions being mocked
+    will have their arguments checked and will raise a `TypeError` if they are
+    called with the wrong signature. For mocks
+    replacing a class, their return value (the 'instance') will have the same
+    spec as the class. See the :func:`create_autospec` function and
+    :ref:`auto-speccing`.
+
+    Instead of `autospec=True` you can pass `autospec=some_object` to use an
+    arbitrary object as the spec instead of the one being replaced.
+
+    By default `patch` will fail to replace attributes that don't exist. If
+    you pass in `create=True`, and the attribute doesn't exist, patch will
+    create the attribute for you when the patched function is called, and
+    delete it again afterwards. This is useful for writing tests against
+    attributes that your production code creates at runtime. It is off by by
+    default because it can be dangerous. With it switched on you can write
+    passing tests against APIs that don't actually exist!
+
+    Patch can be used as a `TestCase` class decorator. It works by
+    decorating each test method in the class. This reduces the boilerplate
+    code when your test methods share a common patchings set. `patch` finds
+    tests by looking for method names that start with `patch.TEST_PREFIX`.
+    By default this is `test`, which matches the way `unittest` finds tests.
+    You can specify an alternative prefix by setting `patch.TEST_PREFIX`.
+
+    Patch can be used as a context manager, with the with statement. Here the
+    patching applies to the indented block after the with statement. If you
+    use "as" then the patched object will be bound to the name after the
+    "as"; very useful if `patch` is creating a mock object for you.
+
+    `patch` takes arbitrary keyword arguments. These will be passed to
+    the `Mock` (or `new_callable`) on construction.
+
+    `patch.dict(...)`, `patch.multiple(...)` and `patch.object(...)` are
+    available for alternate use-cases.
+
+`patch` as function decorator, creating the mock for you and passing it into
+the decorated function:
+
+.. doctest::
+
+    >>> @patch('__main__.SomeClass')
+    ... def function(normal_argument, mock_class):
+    ...     print mock_class is SomeClass
+    ...
+    >>> function(None)
+    True
+
+
+Patching a class replaces the class with a `MagicMock` *instance*. If the
+class is instantiated in the code under test then it will be the
+:attr:`~Mock.return_value` of the mock that will be used.
+
+If the class is instantiated multiple times you could use
+:attr:`~Mock.side_effect` to return a new mock each time. Alternatively you
+can set the `return_value` to be anything you want.
+
+To configure return values on methods of *instances* on the patched class
+you must do this on the `return_value`. For example:
+
+.. doctest::
+
+    >>> class Class(object):
+    ...     def method(self):
+    ...         pass
+    ...
+    >>> with patch('__main__.Class') as MockClass:
+    ...     instance = MockClass.return_value
+    ...     instance.method.return_value = 'foo'
+    ...     assert Class() is instance
+    ...     assert Class().method() == 'foo'
+    ...
+
+If you use `spec` or `spec_set` and `patch` is replacing a *class*, then the
+return value of the created mock will have the same spec.
+
+.. doctest::
+
+    >>> Original = Class
+    >>> patcher = patch('__main__.Class', spec=True)
+    >>> MockClass = patcher.start()
+    >>> instance = MockClass()
+    >>> assert isinstance(instance, Original)
+    >>> patcher.stop()
+
+The `new_callable` argument is useful where you want to use an alternative
+class to the default :class:`MagicMock` for the created mock. For example, if
+you wanted a :class:`NonCallableMock` to be used:
+
+.. doctest::
+
+    >>> thing = object()
+    >>> with patch('__main__.thing', new_callable=NonCallableMock) as mock_thing:
+    ...     assert thing is mock_thing
+    ...     thing()
+    ...
+    Traceback (most recent call last):
+      ...
+    TypeError: 'NonCallableMock' object is not callable
+
+Another use case might be to replace an object with a `StringIO` instance:
+
+.. doctest::
+
+    >>> from StringIO import StringIO
+    >>> def foo():
+    ...     print 'Something'
+    ...
+    >>> @patch('sys.stdout', new_callable=StringIO)
+    ... def test(mock_stdout):
+    ...     foo()
+    ...     assert mock_stdout.getvalue() == 'Something\n'
+    ...
+    >>> test()
+
+When `patch` is creating a mock for you, it is common that the first thing
+you need to do is to configure the mock. Some of that configuration can be done
+in the call to patch. Any arbitrary keywords you pass into the call will be
+used to set attributes on the created mock:
+
+.. doctest::
+
+    >>> patcher = patch('__main__.thing', first='one', second='two')
+    >>> mock_thing = patcher.start()
+    >>> mock_thing.first
+    'one'
+    >>> mock_thing.second
+    'two'
+
+As well as attributes on the created mock attributes, like the
+:attr:`~Mock.return_value` and :attr:`~Mock.side_effect`, of child mocks can
+also be configured. These aren't syntactically valid to pass in directly as
+keyword arguments, but a dictionary with these as keys can still be expanded
+into a `patch` call using `**`:
+
+.. doctest::
+
+    >>> config = {'method.return_value': 3, 'other.side_effect': KeyError}
+    >>> patcher = patch('__main__.thing', **config)
+    >>> mock_thing = patcher.start()
+    >>> mock_thing.method()
+    3
+    >>> mock_thing.other()
+    Traceback (most recent call last):
+      ...
+    KeyError
+
+
+patch.object
+============
+
+.. function:: patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
+
+    patch the named member (`attribute`) on an object (`target`) with a mock
+    object.
+
+    `patch.object` can be used as a decorator, class decorator or a context
+    manager. Arguments `new`, `spec`, `create`, `spec_set`, `autospec` and
+    `new_callable` have the same meaning as for `patch`. Like `patch`,
+    `patch.object` takes arbitrary keyword arguments for configuring the mock
+    object it creates.
+
+    When used as a class decorator `patch.object` honours `patch.TEST_PREFIX`
+    for choosing which methods to wrap.
+
+You can either call `patch.object` with three arguments or two arguments. The
+three argument form takes the object to be patched, the attribute name and the
+object to replace the attribute with.
+
+When calling with the two argument form you omit the replacement object, and a
+mock is created for you and passed in as an extra argument to the decorated
+function:
+
+.. doctest::
+
+    >>> @patch.object(SomeClass, 'class_method')
+    ... def test(mock_method):
+    ...     SomeClass.class_method(3)
+    ...     mock_method.assert_called_with(3)
+    ...
+    >>> test()
+
+`spec`, `create` and the other arguments to `patch.object` have the same
+meaning as they do for `patch`.
+
+
+patch.dict
+==========
+
+.. function:: patch.dict(in_dict, values=(), clear=False, **kwargs)
+
+    Patch a dictionary, or dictionary like object, and restore the dictionary
+    to its original state after the test.
+
+    `in_dict` can be a dictionary or a mapping like container. If it is a
+    mapping then it must at least support getting, setting and deleting items
+    plus iterating over keys.
+
+    `in_dict` can also be a string specifying the name of the dictionary, which
+    will then be fetched by importing it.
+
+    `values` can be a dictionary of values to set in the dictionary. `values`
+    can also be an iterable of `(key, value)` pairs.
+
+    If `clear` is True then the dictionary will be cleared before the new
+    values are set.
+
+    `patch.dict` can also be called with arbitrary keyword arguments to set
+    values in the dictionary.
+
+    `patch.dict` can be used as a context manager, decorator or class
+    decorator. When used as a class decorator `patch.dict` honours
+    `patch.TEST_PREFIX` for choosing which methods to wrap.
+
+`patch.dict` can be used to add members to a dictionary, or simply let a test
+change a dictionary, and ensure the dictionary is restored when the test
+ends.
+
+.. doctest::
+
+    >>> from mock import patch
+    >>> foo = {}
+    >>> with patch.dict(foo, {'newkey': 'newvalue'}):
+    ...     assert foo == {'newkey': 'newvalue'}
+    ...
+    >>> assert foo == {}
+
+    >>> import os
+    >>> with patch.dict('os.environ', {'newkey': 'newvalue'}):
+    ...     print os.environ['newkey']
+    ...
+    newvalue
+    >>> assert 'newkey' not in os.environ
+
+Keywords can be used in the `patch.dict` call to set values in the dictionary:
+
+.. doctest::
+
+    >>> mymodule = MagicMock()
+    >>> mymodule.function.return_value = 'fish'
+    >>> with patch.dict('sys.modules', mymodule=mymodule):
+    ...     import mymodule
+    ...     mymodule.function('some', 'args')
+    ...
+    'fish'
+
+`patch.dict` can be used with dictionary like objects that aren't actually
+dictionaries. At the very minimum they must support item getting, setting,
+deleting and either iteration or membership test. This corresponds to the
+magic methods `__getitem__`, `__setitem__`, `__delitem__` and either
+`__iter__` or `__contains__`.
+
+.. doctest::
+
+    >>> class Container(object):
+    ...     def __init__(self):
+    ...         self.values = {}
+    ...     def __getitem__(self, name):
+    ...         return self.values[name]
+    ...     def __setitem__(self, name, value):
+    ...         self.values[name] = value
+    ...     def __delitem__(self, name):
+    ...         del self.values[name]
+    ...     def __iter__(self):
+    ...         return iter(self.values)
+    ...
+    >>> thing = Container()
+    >>> thing['one'] = 1
+    >>> with patch.dict(thing, one=2, two=3):
+    ...     assert thing['one'] == 2
+    ...     assert thing['two'] == 3
+    ...
+    >>> assert thing['one'] == 1
+    >>> assert list(thing) == ['one']
+
+
+patch.multiple
+==============
+
+.. function:: patch.multiple(target, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
+
+    Perform multiple patches in a single call. It takes the object to be
+    patched (either as an object or a string to fetch the object by importing)
+    and keyword arguments for the patches::
+
+        with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):
+            ...
+
+    Use :data:`DEFAULT` as the value if you want `patch.multiple` to create
+    mocks for you. In this case the created mocks are passed into a decorated
+    function by keyword, and a dictionary is returned when `patch.multiple` is
+    used as a context manager.
+
+    `patch.multiple` can be used as a decorator, class decorator or a context
+    manager. The arguments `spec`, `spec_set`, `create`, `autospec` and
+    `new_callable` have the same meaning as for `patch`. These arguments will
+    be applied to *all* patches done by `patch.multiple`.
+
+    When used as a class decorator `patch.multiple` honours `patch.TEST_PREFIX`
+    for choosing which methods to wrap.
+
+If you want `patch.multiple` to create mocks for you, then you can use
+:data:`DEFAULT` as the value. If you use `patch.multiple` as a decorator
+then the created mocks are passed into the decorated function by keyword.
+
+.. doctest::
+
+    >>> thing = object()
+    >>> other = object()
+
+    >>> @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
+    ... def test_function(thing, other):
+    ...     assert isinstance(thing, MagicMock)
+    ...     assert isinstance(other, MagicMock)
+    ...
+    >>> test_function()
+
+`patch.multiple` can be nested with other `patch` decorators, but put arguments
+passed by keyword *after* any of the standard arguments created by `patch`:
+
+.. doctest::
+
+    >>> @patch('sys.exit')
+    ... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
+    ... def test_function(mock_exit, other, thing):
+    ...     assert 'other' in repr(other)
+    ...     assert 'thing' in repr(thing)
+    ...     assert 'exit' in repr(mock_exit)
+    ...
+    >>> test_function()
+
+If `patch.multiple` is used as a context manager, the value returned by the
+context manger is a dictionary where created mocks are keyed by name:
+
+.. doctest::
+
+    >>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:
+    ...     assert 'other' in repr(values['other'])
+    ...     assert 'thing' in repr(values['thing'])
+    ...     assert values['thing'] is thing
+    ...     assert values['other'] is other
+    ...
+
+
+.. _start-and-stop:
+
+patch methods: start and stop
+=============================
+
+All the patchers have `start` and `stop` methods. These make it simpler to do
+patching in `setUp` methods or where you want to do multiple patches without
+nesting decorators or with statements.
+
+To use them call `patch`, `patch.object` or `patch.dict` as normal and keep a
+reference to the returned `patcher` object. You can then call `start` to put
+the patch in place and `stop` to undo it.
+
+If you are using `patch` to create a mock for you then it will be returned by
+the call to `patcher.start`.
+
+.. doctest::
+
+    >>> patcher = patch('package.module.ClassName')
+    >>> from package import module
+    >>> original = module.ClassName
+    >>> new_mock = patcher.start()
+    >>> assert module.ClassName is not original
+    >>> assert module.ClassName is new_mock
+    >>> patcher.stop()
+    >>> assert module.ClassName is original
+    >>> assert module.ClassName is not new_mock
+
+
+A typical use case for this might be for doing multiple patches in the `setUp`
+method of a `TestCase`:
+
+.. doctest::
+
+    >>> class MyTest(TestCase):
+    ...     def setUp(self):
+    ...         self.patcher1 = patch('package.module.Class1')
+    ...         self.patcher2 = patch('package.module.Class2')
+    ...         self.MockClass1 = self.patcher1.start()
+    ...         self.MockClass2 = self.patcher2.start()
+    ...
+    ...     def tearDown(self):
+    ...         self.patcher1.stop()
+    ...         self.patcher2.stop()
+    ...
+    ...     def test_something(self):
+    ...         assert package.module.Class1 is self.MockClass1
+    ...         assert package.module.Class2 is self.MockClass2
+    ...
+    >>> MyTest('test_something').run()
+
+.. caution::
+
+    If you use this technique you must ensure that the patching is "undone" by
+    calling `stop`. This can be fiddlier than you might think, because if an
+    exception is raised in the setUp then tearDown is not called. `unittest2
+    <http://pypi.python.org/pypi/unittest2>`_ cleanup functions make this
+    easier.
+
+    .. doctest::
+
+        >>> class MyTest(TestCase):
+        ...     def setUp(self):
+        ...         patcher = patch('package.module.Class')
+        ...         self.MockClass = patcher.start()
+        ...         self.addCleanup(patcher.stop)
+        ...
+        ...     def test_something(self):
+        ...         assert package.module.Class is self.MockClass
+        ...
+        >>> MyTest('test_something').run()
+
+    As an added bonus you no longer need to keep a reference to the `patcher`
+    object.
+
+It is also possible to stop all patches which have been started by using
+`patch.stopall`.
+
+.. function:: patch.stopall
+
+    Stop all active patches. Only stops patches started with `start`.
+
+
+TEST_PREFIX
+===========
+
+All of the patchers can be used as class decorators. When used in this way
+they wrap every test method on the class. The patchers recognise methods that
+start with `test` as being test methods. This is the same way that the
+`unittest.TestLoader` finds test methods by default.
+
+It is possible that you want to use a different prefix for your tests. You can
+inform the patchers of the different prefix by setting `patch.TEST_PREFIX`:
+
+.. doctest::
+
+    >>> patch.TEST_PREFIX = 'foo'
+    >>> value = 3
+    >>>
+    >>> @patch('__main__.value', 'not three')
+    ... class Thing(object):
+    ...     def foo_one(self):
+    ...         print value
+    ...     def foo_two(self):
+    ...         print value
+    ...
+    >>>
+    >>> Thing().foo_one()
+    not three
+    >>> Thing().foo_two()
+    not three
+    >>> value
+    3
+
+
+Nesting Patch Decorators
+========================
+
+If you want to perform multiple patches then you can simply stack up the
+decorators.
+
+You can stack up multiple patch decorators using this pattern:
+
+.. doctest::
+
+    >>> @patch.object(SomeClass, 'class_method')
+    ... @patch.object(SomeClass, 'static_method')
+    ... def test(mock1, mock2):
+    ...     assert SomeClass.static_method is mock1
+    ...     assert SomeClass.class_method is mock2
+    ...     SomeClass.static_method('foo')
+    ...     SomeClass.class_method('bar')
+    ...     return mock1, mock2
+    ...
+    >>> mock1, mock2 = test()
+    >>> mock1.assert_called_once_with('foo')
+    >>> mock2.assert_called_once_with('bar')
+
+
+Note that the decorators are applied from the bottom upwards. This is the
+standard way that Python applies decorators. The order of the created mocks
+passed into your test function matches this order.
+
+Like all context-managers patches can be nested using contextlib's nested
+function; *every* patching will appear in the tuple after "as":
+
+.. doctest::
+
+    >>> from contextlib import nested
+    >>> with nested(
+    ...         patch('package.module.ClassName1'),
+    ...         patch('package.module.ClassName2')
+    ...     ) as (MockClass1, MockClass2):
+    ...     assert package.module.ClassName1 is MockClass1
+    ...     assert package.module.ClassName2 is MockClass2
+    ...
+
+
+.. _where-to-patch:
+
+Where to patch
+==============
+
+`patch` works by (temporarily) changing the object that a *name* points to with
+another one. There can be many names pointing to any individual object, so
+for patching to work you must ensure that you patch the name used by the system
+under test.
+
+The basic principle is that you patch where an object is *looked up*, which
+is not necessarily the same place as where it is defined. A couple of
+examples will help to clarify this.
+
+Imagine we have a project that we want to test with the following structure::
+
+    a.py
+        -> Defines SomeClass
+
+    b.py
+        -> from a import SomeClass
+        -> some_function instantiates SomeClass
+
+Now we want to test `some_function` but we want to mock out `SomeClass` using
+`patch`. The problem is that when we import module b, which we will have to
+do then it imports `SomeClass` from module a. If we use `patch` to mock out
+`a.SomeClass` then it will have no effect on our test; module b already has a
+reference to the *real* `SomeClass` and it looks like our patching had no
+effect.
+
+The key is to patch out `SomeClass` where it is used (or where it is looked up
+). In this case `some_function` will actually look up `SomeClass` in module b,
+where we have imported it. The patching should look like:
+
+    `@patch('b.SomeClass')`
+
+However, consider the alternative scenario where instead of `from a import
+SomeClass` module b does `import a` and `some_function` uses `a.SomeClass`. Both
+of these import forms are common. In this case the class we want to patch is
+being looked up on the a module and so we have to patch `a.SomeClass` instead:
+
+    `@patch('a.SomeClass')`
+
+
+Patching Descriptors and Proxy Objects
+======================================
+
+Since version 0.6.0 both patch_ and patch.object_ have been able to correctly
+patch and restore descriptors: class methods, static methods and properties.
+You should patch these on the *class* rather than an instance.
+
+Since version 0.7.0 patch_ and patch.object_ work correctly with some objects
+that proxy attribute access, like the `django setttings object
+<http://www.voidspace.org.uk/python/weblog/arch_d7_2010_12_04.shtml#e1198>`_.
+
+.. note::
+
+    In django `import settings` and `from django.conf import settings`
+    return different objects. If you are using libraries / apps that do both you
+    may have to patch both. Grrr...
new file mode 100644
--- /dev/null
+++ b/python/mock-1.0.0/docs/sentinel.txt
@@ -0,0 +1,58 @@
+==========
+ Sentinel
+==========
+
+
+.. currentmodule:: mock
+
+.. testsetup::
+
+    class ProductionClass(object):
+        def something(self):
+            return self.method()
+
+    class Test(unittest2.TestCase):
+        def testSomething(self):
+            pass
+    self = Test('testSomething')
+
+
+.. data:: sentinel
+
+    The ``sentinel`` object provides a convenient way of providing unique
+    objects for your tests.
+
+    Attributes are created on demand when you access them by name. Accessing
+    the same attribute will always return the same object. The objects
+    returned have a sensible repr so that test failure messages are readable.
+
+
+.. data:: DEFAULT
+
+    The `DEFAULT` object is a pre-created sentinel (actually
+    `sentinel.DEFAULT`). It can be used by :attr:`~Mock.side_effect`
+    functions to indicate that the normal return value should be used.
+
+
+Sentinel Example
+================
+
+Sometimes when testing you need to test that a specific object is passed as an
+argument to another method, or returned. It can be common to create named
+sentinel objects to test this. `sentinel` provides a convenient way of
+creating and testing the identity of objects like this.
+
+In this example we monkey patch `method` to return
+`sentinel.some_object`:
+
+.. doctest::
+
+    >>> real = ProductionClass()
+    >>> real.method = Mock(name="method")
+    >>> real.method.return_value = sentinel.some_object
+    >>> result = real.method()
+    >>> assert result is sentinel.some_object
+    >>> sentinel.some_object
+    sentinel.some_object
+
+
new file mode 100644
index 0000000000000000000000000000000000000000..6356303021b5794bac29edb8ff73cd900b6368dc
GIT binary patch
literal 282659
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
KF2d<w=l=q%Kigpd
new file mode 100644
index 0000000000000000000000000000000000000000..2a961fce4ac230fdfc1efb36afebae3a1327655c
GIT binary patch
literal 56915
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
b3HNn-;tS9@7vfz20&cg9klV#r(uDpGccz|5
new file mode 100644
index 0000000000000000000000000000000000000000..40e4fded532692cace88441947b318afc91f36d9
GIT binary patch
literal 167478
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
new file mode 100644
index 0000000000000000000000000000000000000000..ba82a899840d5582d02f280cd38fdeed04cd2e43
GIT binary patch
literal 70942
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
new file mode 100644
index 0000000000000000000000000000000000000000..4c53f11a5aa77a94f13d9ac3e70ce026b351134c
GIT binary patch
literal 98784
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
G$^QY+JIb2?
new file mode 100644
index 0000000000000000000000000000000000000000..d57214e9895c1a135bd18b2c9e0ba8d1ba0d0ac2
GIT binary patch
literal 75713
zc%1CL2Y^%6*8V+ApG>D0!Kjo0Vd#RRfFdG@G&PDM4w=ark|C2!b`pkBM@0d_-W9u|
z*gN)$z4zXGL+rhNd$0BEoPACbz4z*S?|uK@`xcobd+%rc)>?b*)6b!~je%%mG7$>L
zYa`Ks75Au*EmkDqiFF#hESB35%d7E~MEosQqP^9M$MQR31vS1-qgKtU$jQlRi8d~-
zo#|f`YMd$miWRP!*GqppD;n9!9}fE)!j|2jXw|%KXb_4l^0ufSymIJZG!Ty!&ze`R
zesp|UvdY(K<SP4zVfqKps(Bu}wHmy1R?=4;Pd3C8p@bxgM(P7rQ#@AI5i9pqwE9