atlas-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From venkat...@apache.org
Subject [03/10] incubator-atlas git commit: ATLAS-19 remove unnecessary docs dir
Date Wed, 17 Jun 2015 00:33:21 GMT
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/examples.txt
----------------------------------------------------------------------
diff --git a/src/test/mock/docs/examples.txt b/src/test/mock/docs/examples.txt
deleted file mode 100644
index ecb994b..0000000
--- a/src/test/mock/docs/examples.txt
+++ /dev/null
@@ -1,1063 +0,0 @@
-.. _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`.

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/getting-started.txt
----------------------------------------------------------------------
diff --git a/src/test/mock/docs/getting-started.txt b/src/test/mock/docs/getting-started.txt
deleted file mode 100644
index 1b5d289..0000000
--- a/src/test/mock/docs/getting-started.txt
+++ /dev/null
@@ -1,479 +0,0 @@
-===========================
- 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.

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/helpers.txt
----------------------------------------------------------------------
diff --git a/src/test/mock/docs/helpers.txt b/src/test/mock/docs/helpers.txt
deleted file mode 100644
index 571b71d..0000000
--- a/src/test/mock/docs/helpers.txt
+++ /dev/null
@@ -1,583 +0,0 @@
-=========
- 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.

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/index.txt
----------------------------------------------------------------------
diff --git a/src/test/mock/docs/index.txt b/src/test/mock/docs/index.txt
deleted file mode 100644
index fe89925..0000000
--- a/src/test/mock/docs/index.txt
+++ /dev/null
@@ -1,411 +0,0 @@
-====================================
- 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.1.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.1.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".



Mime
View raw message