ATLAS-19 remove unnecessary docs dir
Project: http://git-wip-us.apache.org/repos/asf/incubator-atlas/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-atlas/commit/ed9b669f Tree: http://git-wip-us.apache.org/repos/asf/incubator-atlas/tree/ed9b669f Diff: http://git-wip-us.apache.org/repos/asf/incubator-atlas/diff/ed9b669f Branch: refs/heads/master Commit: ed9b669f967132230ab3a58502d822014e89b79f Parents: aefca9a Author: Jon Maron <[email protected]> Authored: Tue Jun 16 12:41:29 2015 -0400 Committer: Jon Maron <[email protected]> Committed: Tue Jun 16 12:41:29 2015 -0400 ---------------------------------------------------------------------- src/test/mock/docs/__init__.py | 1 - src/test/mock/docs/changelog.txt | 737 ------------------- src/test/mock/docs/compare.txt | 628 ---------------- src/test/mock/docs/conf.py | 209 ------ src/test/mock/docs/examples.txt | 1063 --------------------------- src/test/mock/docs/getting-started.txt | 479 ------------ src/test/mock/docs/helpers.txt | 583 --------------- src/test/mock/docs/index.txt | 411 ----------- src/test/mock/docs/magicmock.txt | 258 ------- src/test/mock/docs/mock.txt | 842 --------------------- src/test/mock/docs/patch.txt | 636 ---------------- src/test/mock/docs/sentinel.txt | 58 -- 12 files changed, 5905 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/__init__.py ---------------------------------------------------------------------- diff --git a/src/test/mock/docs/__init__.py b/src/test/mock/docs/__init__.py deleted file mode 100644 index fea728a..0000000 --- a/src/test/mock/docs/__init__.py +++ /dev/null @@ -1 +0,0 @@ -__author__ = 'jmaron' http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/changelog.txt ---------------------------------------------------------------------- diff --git a/src/test/mock/docs/changelog.txt b/src/test/mock/docs/changelog.txt deleted file mode 100644 index 823341a..0000000 --- a/src/test/mock/docs/changelog.txt +++ /dev/null @@ -1,737 +0,0 @@ -.. currentmodule:: mock - - -CHANGELOG -========= - -2012/11/05 Version 1.0.1 ------------------------- - -* Functions decorated with `patch` variants have a `__wrapped__` attribute - pointing to the original function. This brings compatibility with the - default behaviour in Python 3.3 (due to a new feature in `functools.wraps`). - -Note that due to changes in `tox`, `mock` is no longer tested with Python 2.4. -The compatibility code has not been removed so it probably still works, but -tests are no longer run. - - -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. http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/compare.txt ---------------------------------------------------------------------- diff --git a/src/test/mock/docs/compare.txt b/src/test/mock/docs/compare.txt deleted file mode 100644 index 4155530..0000000 --- a/src/test/mock/docs/compare.txt +++ /dev/null @@ -1,628 +0,0 @@ -========================= - 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 http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/ed9b669f/src/test/mock/docs/conf.py ---------------------------------------------------------------------- diff --git a/src/test/mock/docs/conf.py b/src/test/mock/docs/conf.py deleted file mode 100644 index 62f0491..0000000 --- a/src/test/mock/docs/conf.py +++ /dev/null @@ -1,209 +0,0 @@ -# -*- 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
