diff options
Diffstat (limited to 'python/mock-1.0.0/docs/changelog.txt')
| -rw-r--r-- | python/mock-1.0.0/docs/changelog.txt | 725 |
1 files changed, 725 insertions, 0 deletions
diff --git a/python/mock-1.0.0/docs/changelog.txt b/python/mock-1.0.0/docs/changelog.txt new file mode 100644 index 0000000000..a605be3d97 --- /dev/null +++ b/python/mock-1.0.0/docs/changelog.txt @@ -0,0 +1,725 @@ +.. currentmodule:: mock + + +CHANGELOG +========= + +2012/10/07 Version 1.0.0 +------------------------ + +No changes since 1.0.0 beta 1. This version has feature parity with +`unittest.mock +<http://docs.python.org/py3k/library/unittest.mock.html#module-unittest.mock>`_ +in Python 3.3. + +Full list of changes since 0.8: + +* `mocksignature`, along with the `mocksignature` argument to `patch`, removed +* Support for deleting attributes (accessing deleted attributes will raise an + `AttributeError`) +* Added the `mock_open` helper function for mocking the builtin `open` +* `__class__` is assignable, so a mock can pass an `isinstance` check without + requiring a spec +* Addition of `PropertyMock`, for mocking properties +* `MagicMocks` made unorderable by default (in Python 3). The comparison + methods (other than equality and inequality) now return `NotImplemented` +* Propagate traceback info to support subclassing of `_patch` by other + libraries +* `create_autospec` works with attributes present in results of `dir` that + can't be fetched from the object's class. Contributed by Konstantine Rybnikov +* Any exceptions in an iterable `side_effect` will be raised instead of + returned +* In Python 3, `create_autospec` now supports keyword only arguments +* Added `patch.stopall` method to stop all active patches created by `start` +* BUGFIX: calling `MagicMock.reset_mock` wouldn't reset magic method mocks +* BUGFIX: calling `reset_mock` on a `MagicMock` created with autospec could + raise an exception +* BUGFIX: passing multiple spec arguments to patchers (`spec` , `spec_set` and + `autospec`) had unpredictable results, now it is an error +* BUGFIX: using `spec=True` *and* `create=True` as arguments to patchers could + result in using `DEFAULT` as the spec. Now it is an error instead +* BUGFIX: using `spec` or `autospec` arguments to patchers, along with + `spec_set=True` did not work correctly +* BUGFIX: using an object that evaluates to False as a spec could be ignored +* BUGFIX: a list as the `spec` argument to a patcher would always result in a + non-callable mock. Now if `__call__` is in the spec the mock is callable + + +2012/07/13 Version 1.0.0 beta 1 +-------------------------------- + +* Added `patch.stopall` method to stop all active patches created by `start` +* BUGFIX: calling `MagicMock.reset_mock` wouldn't reset magic method mocks +* BUGFIX: calling `reset_mock` on a `MagicMock` created with autospec could + raise an exception + + +2012/05/04 Version 1.0.0 alpha 2 +-------------------------------- + +* `PropertyMock` attributes are now standard `MagicMocks` +* `create_autospec` works with attributes present in results of `dir` that + can't be fetched from the object's class. Contributed by Konstantine Rybnikov +* Any exceptions in an iterable `side_effect` will be raised instead of + returned +* In Python 3, `create_autospec` now supports keyword only arguments + + +2012/03/25 Version 1.0.0 alpha 1 +-------------------------------- + +The standard library version! + +* `mocksignature`, along with the `mocksignature` argument to `patch`, removed +* Support for deleting attributes (accessing deleted attributes will raise an + `AttributeError`) +* Added the `mock_open` helper function for mocking the builtin `open` +* `__class__` is assignable, so a mock can pass an `isinstance` check without + requiring a spec +* Addition of `PropertyMock`, for mocking properties +* `MagicMocks` made unorderable by default (in Python 3). The comparison + methods (other than equality and inequality) now return `NotImplemented` +* Propagate traceback info to support subclassing of `_patch` by other + libraries +* BUGFIX: passing multiple spec arguments to patchers (`spec` , `spec_set` and + `autospec`) had unpredictable results, now it is an error +* BUGFIX: using `spec=True` *and* `create=True` as arguments to patchers could + result in using `DEFAULT` as the spec. Now it is an error instead +* BUGFIX: using `spec` or `autospec` arguments to patchers, along with + `spec_set=True` did not work correctly +* BUGFIX: using an object that evaluates to False as a spec could be ignored +* BUGFIX: a list as the `spec` argument to a patcher would always result in a + non-callable mock. Now if `__call__` is in the spec the mock is callable + + +2012/02/13 Version 0.8.0 +------------------------ + +The only changes since 0.8rc2 are: + +* Improved repr of :data:`sentinel` objects +* :data:`ANY` can be used for comparisons against :data:`call` objects +* The return value of `MagicMock.__iter__` method can be set to + any iterable and isn't required to be an iterator + +Full List of changes since 0.7: + +mock 0.8.0 is the last version that will support Python 2.4. + +* Addition of :attr:`~Mock.mock_calls` list for *all* calls (including magic + methods and chained calls) +* :func:`patch` and :func:`patch.object` now create a :class:`MagicMock` + instead of a :class:`Mock` by default +* The patchers (`patch`, `patch.object` and `patch.dict`), plus `Mock` and + `MagicMock`, take arbitrary keyword arguments for configuration +* New mock method :meth:`~Mock.configure_mock` for setting attributes and + return values / side effects on the mock and its attributes +* New mock assert methods :meth:`~Mock.assert_any_call` and + :meth:`~Mock.assert_has_calls` +* Implemented :ref:`auto-speccing` (recursive, lazy speccing of mocks with + mocked signatures for functions/methods), as the `autospec` argument to + `patch` +* Added the :func:`create_autospec` function for manually creating + 'auto-specced' mocks +* :func:`patch.multiple` for doing multiple patches in a single call, using + keyword arguments +* Setting :attr:`~Mock.side_effect` to an iterable will cause calls to the mock + to return the next value from the iterable +* New `new_callable` argument to `patch` and `patch.object` allowing you to + pass in a class or callable object (instead of `MagicMock`) that will be + called to replace the object being patched +* Addition of :class:`NonCallableMock` and :class:`NonCallableMagicMock`, mocks + without a `__call__` method +* Addition of :meth:`~Mock.mock_add_spec` method for adding (or changing) a + spec on an existing mock +* Protocol methods on :class:`MagicMock` are magic mocks, and are created + lazily on first lookup. This means the result of calling a protocol method is + a `MagicMock` instead of a `Mock` as it was previously +* Addition of :meth:`~Mock.attach_mock` method +* Added :data:`ANY` for ignoring arguments in :meth:`~Mock.assert_called_with` + calls +* Addition of :data:`call` helper object +* Improved repr for mocks +* Improved repr for :attr:`Mock.call_args` and entries in + :attr:`Mock.call_args_list`, :attr:`Mock.method_calls` and + :attr:`Mock.mock_calls` +* Improved repr for :data:`sentinel` objects +* `patch` lookup is done at use time not at decoration time +* In Python 2.6 or more recent, `dir` on a mock will report all the dynamically + created attributes (or the full list of attributes if there is a spec) as + well as all the mock methods and attributes. +* Module level :data:`FILTER_DIR` added to control whether `dir(mock)` filters + private attributes. `True` by default. +* `patch.TEST_PREFIX` for controlling how patchers recognise test methods when + used to decorate a class +* Support for using Java exceptions as a :attr:`~Mock.side_effect` on Jython +* `Mock` call lists (`call_args_list`, `method_calls` & `mock_calls`) are now + custom list objects that allow membership tests for "sub lists" and have + a nicer representation if you `str` or `print` them +* Mocks attached as attributes or return values to other mocks have calls + recorded in `method_calls` and `mock_calls` of the parent (unless a name is + already set on the child) +* Improved failure messages for `assert_called_with` and + `assert_called_once_with` +* The return value of the :class:`MagicMock` `__iter__` method can be set to + any iterable and isn't required to be an iterator +* Added the Mock API (`assert_called_with` etc) to functions created by + :func:`mocksignature` +* Tuples as well as lists can be used to specify allowed methods for `spec` & + `spec_set` arguments +* Calling `stop` on an unstarted patcher fails with a more meaningful error + message +* Renamed the internal classes `Sentinel` and `SentinelObject` to prevent abuse +* BUGFIX: an error creating a patch, with nested patch decorators, won't leave + patches in place +* BUGFIX: `__truediv__` and `__rtruediv__` not available as magic methods on + mocks in Python 3 +* BUGFIX: `assert_called_with` / `assert_called_once_with` can be used with + `self` as a keyword argument +* BUGFIX: when patching a class with an explicit spec / spec_set (not a + boolean) it applies "spec inheritance" to the return value of the created + mock (the "instance") +* BUGFIX: remove the `__unittest` marker causing traceback truncation +* Removal of deprecated `patch_object` +* Private attributes `_name`, `_methods`, '_children', `_wraps` and `_parent` + (etc) renamed to reduce likelihood of clash with user attributes. +* Added license file to the distribution + + +2012/01/10 Version 0.8.0 release candidate 2 +-------------------------------------------- + +* Removed the `configure` keyword argument to `create_autospec` and allow + arbitrary keyword arguments (for the `Mock` constructor) instead +* Fixed `ANY` equality with some types in `assert_called_with` calls +* Switched to a standard Sphinx theme (compatible with + `readthedocs.org <http://mock.readthedocs.org>`_) + + +2011/12/29 Version 0.8.0 release candidate 1 +-------------------------------------------- + +* `create_autospec` on the return value of a mocked class will use `__call__` + for the signature rather than `__init__` +* Performance improvement instantiating `Mock` and `MagicMock` +* Mocks used as magic methods have the same type as their parent instead of + being hardcoded to `MagicMock` + +Special thanks to Julian Berman for his help with diagnosing and improving +performance in this release. + + +2011/10/09 Version 0.8.0 beta 4 +------------------------------- + +* `patch` lookup is done at use time not at decoration time +* When attaching a Mock to another Mock as a magic method, calls are recorded + in mock_calls +* Addition of `attach_mock` method +* Renamed the internal classes `Sentinel` and `SentinelObject` to prevent abuse +* BUGFIX: various issues around circular references with mocks (setting a mock + return value to be itself etc) + + +2011/08/15 Version 0.8.0 beta 3 +------------------------------- + +* Mocks attached as attributes or return values to other mocks have calls + recorded in `method_calls` and `mock_calls` of the parent (unless a name is + already set on the child) +* Addition of `mock_add_spec` method for adding (or changing) a spec on an + existing mock +* Improved repr for `Mock.call_args` and entries in `Mock.call_args_list`, + `Mock.method_calls` and `Mock.mock_calls` +* Improved repr for mocks +* BUGFIX: minor fixes in the way `mock_calls` is worked out, + especially for "intermediate" mocks in a call chain + + +2011/08/05 Version 0.8.0 beta 2 +------------------------------- + +* Setting `side_effect` to an iterable will cause calls to the mock to return + the next value from the iterable +* Added `assert_any_call` method +* Moved `assert_has_calls` from call lists onto mocks +* BUGFIX: `call_args` and all members of `call_args_list` are two tuples of + `(args, kwargs)` again instead of three tuples of `(name, args, kwargs)` + + +2011/07/25 Version 0.8.0 beta 1 +------------------------------- + +* `patch.TEST_PREFIX` for controlling how patchers recognise test methods when + used to decorate a class +* `Mock` call lists (`call_args_list`, `method_calls` & `mock_calls`) are now + custom list objects that allow membership tests for "sub lists" and have + an `assert_has_calls` method for unordered call checks +* `callargs` changed to *always* be a three-tuple of `(name, args, kwargs)` +* Addition of `mock_calls` list for *all* calls (including magic methods and + chained calls) +* Extension of `call` object to support chained calls and `callargs` for better + comparisons with or without names. `call` object has a `call_list` method for + chained calls +* Added the public `instance` argument to `create_autospec` +* Support for using Java exceptions as a `side_effect` on Jython +* Improved failure messages for `assert_called_with` and + `assert_called_once_with` +* Tuples as well as lists can be used to specify allowed methods for `spec` & + `spec_set` arguments +* BUGFIX: Fixed bug in `patch.multiple` for argument passing when creating + mocks +* Added license file to the distribution + + +2011/07/16 Version 0.8.0 alpha 2 +-------------------------------- + +* `patch.multiple` for doing multiple patches in a single call, using keyword + arguments +* New `new_callable` argument to `patch` and `patch.object` allowing you to + pass in a class or callable object (instead of `MagicMock`) that will be + called to replace the object being patched +* Addition of `NonCallableMock` and `NonCallableMagicMock`, mocks without a + `__call__` method +* Mocks created by `patch` have a `MagicMock` as the `return_value` where a + class is being patched +* `create_autospec` can create non-callable mocks for non-callable objects. + `return_value` mocks of classes will be non-callable unless the class has + a `__call__` method +* `autospec` creates a `MagicMock` without a spec for properties and slot + descriptors, because we don't know the type of object they return +* Removed the "inherit" argument from `create_autospec` +* Calling `stop` on an unstarted patcher fails with a more meaningful error + message +* BUGFIX: an error creating a patch, with nested patch decorators, won't leave + patches in place +* BUGFIX: `__truediv__` and `__rtruediv__` not available as magic methods on + mocks in Python 3 +* BUGFIX: `assert_called_with` / `assert_called_once_with` can be used with + `self` as a keyword argument +* BUGFIX: autospec for functions / methods with an argument named self that + isn't the first argument no longer broken +* BUGFIX: when patching a class with an explicit spec / spec_set (not a + boolean) it applies "spec inheritance" to the return value of the created + mock (the "instance") +* BUGFIX: remove the `__unittest` marker causing traceback truncation + + +2011/06/14 Version 0.8.0 alpha 1 +-------------------------------- + +mock 0.8.0 is the last version that will support Python 2.4. + +* The patchers (`patch`, `patch.object` and `patch.dict`), plus `Mock` and + `MagicMock`, take arbitrary keyword arguments for configuration +* New mock method `configure_mock` for setting attributes and return values / + side effects on the mock and its attributes +* In Python 2.6 or more recent, `dir` on a mock will report all the dynamically + created attributes (or the full list of attributes if there is a spec) as + well as all the mock methods and attributes. +* Module level `FILTER_DIR` added to control whether `dir(mock)` filters + private attributes. `True` by default. Note that `vars(Mock())` can still be + used to get all instance attributes and `dir(type(Mock())` will still return + all the other attributes (irrespective of `FILTER_DIR`) +* `patch` and `patch.object` now create a `MagicMock` instead of a `Mock` by + default +* Added `ANY` for ignoring arguments in `assert_called_with` calls +* Addition of `call` helper object +* Protocol methods on `MagicMock` are magic mocks, and are created lazily on + first lookup. This means the result of calling a protocol method is a + MagicMock instead of a Mock as it was previously +* Added the Mock API (`assert_called_with` etc) to functions created by + `mocksignature` +* Private attributes `_name`, `_methods`, '_children', `_wraps` and `_parent` + (etc) renamed to reduce likelihood of clash with user attributes. +* Implemented auto-speccing (recursive, lazy speccing of mocks with mocked + signatures for functions/methods) + + Limitations: + + - Doesn't mock magic methods or attributes (it creates MagicMocks, so the + magic methods are *there*, they just don't have the signature mocked nor + are attributes followed) + - Doesn't mock function / method attributes + - Uses object traversal on the objects being mocked to determine types - so + properties etc may be triggered + - The return value of mocked classes (the 'instance') has the same call + signature as the class __init__ (as they share the same spec) + + You create auto-specced mocks by passing `autospec=True` to `patch`. + + Note that attributes that are None are special cased and mocked without a + spec (so any attribute / method can be used). This is because None is + typically used as a default value for attributes that may be of some other + type, and as we don't know what type that may be we allow all access. + + Note that the `autospec` option to `patch` obsoletes the `mocksignature` + option. + +* Added the `create_autospec` function for manually creating 'auto-specced' + mocks +* Removal of deprecated `patch_object` + + +2011/05/30 Version 0.7.2 +------------------------ + +* BUGFIX: instances of list subclasses can now be used as mock specs +* BUGFIX: MagicMock equality / inequality protocol methods changed to use the + default equality / inequality. This is done through a `side_effect` on + the mocks used for `__eq__` / `__ne__` + + +2011/05/06 Version 0.7.1 +------------------------ + +Package fixes contributed by Michael Fladischer. No code changes. + +* Include template in package +* Use isolated binaries for the tox tests +* Unset executable bit on docs +* Fix DOS line endings in getting-started.txt + + +2011/03/05 Version 0.7.0 +------------------------ + +No API changes since 0.7.0 rc1. Many documentation changes including a stylish +new `Sphinx theme <https://github.com/coordt/ADCtheme/>`_. + +The full set of changes since 0.6.0 are: + +* Python 3 compatibility +* Ability to mock magic methods with `Mock` and addition of `MagicMock` + with pre-created magic methods +* Addition of `mocksignature` and `mocksignature` argument to `patch` and + `patch.object` +* Addition of `patch.dict` for changing dictionaries during a test +* Ability to use `patch`, `patch.object` and `patch.dict` as class decorators +* Renamed ``patch_object`` to `patch.object` (``patch_object`` is + deprecated) +* Addition of soft comparisons: `call_args`, `call_args_list` and `method_calls` + now return tuple-like objects which compare equal even when empty args + or kwargs are skipped +* patchers (`patch`, `patch.object` and `patch.dict`) have start and stop + methods +* Addition of `assert_called_once_with` method +* Mocks can now be named (`name` argument to constructor) and the name is used + in the repr +* repr of a mock with a spec includes the class name of the spec +* `assert_called_with` works with `python -OO` +* New `spec_set` keyword argument to `Mock` and `patch`. If used, + attempting to *set* an attribute on a mock not on the spec will raise an + `AttributeError` +* Mocks created with a spec can now pass `isinstance` tests (`__class__` + returns the type of the spec) +* Added docstrings to all objects +* Improved failure message for `Mock.assert_called_with` when the mock + has not been called at all +* Decorated functions / methods have their docstring and `__module__` + preserved on Python 2.4. +* BUGFIX: `mock.patch` now works correctly with certain types of objects that + proxy attribute access, like the django settings object +* BUGFIX: mocks are now copyable (thanks to Ned Batchelder for reporting and + diagnosing this) +* BUGFIX: `spec=True` works with old style classes +* BUGFIX: ``help(mock)`` works now (on the module). Can no longer use ``__bases__`` + as a valid sentinel name (thanks to Stephen Emslie for reporting and + diagnosing this) +* BUGFIX: ``side_effect`` now works with ``BaseException`` exceptions like + ``KeyboardInterrupt`` +* BUGFIX: `reset_mock` caused infinite recursion when a mock is set as its own + return value +* BUGFIX: patching the same object twice now restores the patches correctly +* with statement tests now skipped on Python 2.4 +* Tests require unittest2 (or unittest2-py3k) to run +* Tested with `tox <http://pypi.python.org/pypi/tox>`_ on Python 2.4 - 3.2, + jython and pypy (excluding 3.0) +* Added 'build_sphinx' command to setup.py (requires setuptools or distribute) + Thanks to Florian Bauer +* Switched from subversion to mercurial for source code control +* `Konrad Delong <http://konryd.blogspot.com/>`_ added as co-maintainer + + +2011/02/16 Version 0.7.0 RC 1 +----------------------------- + +Changes since beta 4: + +* Tested with jython, pypy and Python 3.2 and 3.1 +* Decorated functions / methods have their docstring and `__module__` + preserved on Python 2.4 +* BUGFIX: `mock.patch` now works correctly with certain types of objects that + proxy attribute access, like the django settings object +* BUGFIX: `reset_mock` caused infinite recursion when a mock is set as its own + return value + + +2010/11/12 Version 0.7.0 beta 4 +------------------------------- + +* patchers (`patch`, `patch.object` and `patch.dict`) have start and stop + methods +* Addition of `assert_called_once_with` method +* repr of a mock with a spec includes the class name of the spec +* `assert_called_with` works with `python -OO` +* New `spec_set` keyword argument to `Mock` and `patch`. If used, + attempting to *set* an attribute on a mock not on the spec will raise an + `AttributeError` +* Attributes and return value of a `MagicMock` are `MagicMock` objects +* Attempting to set an unsupported magic method now raises an `AttributeError` +* `patch.dict` works as a class decorator +* Switched from subversion to mercurial for source code control +* BUGFIX: mocks are now copyable (thanks to Ned Batchelder for reporting and + diagnosing this) +* BUGFIX: `spec=True` works with old style classes +* BUGFIX: `mocksignature=True` can now patch instance methods via + `patch.object` + + +2010/09/18 Version 0.7.0 beta 3 +------------------------------- + +* Using spec with :class:`MagicMock` only pre-creates magic methods in the spec +* Setting a magic method on a mock with a ``spec`` can only be done if the + spec has that method +* Mocks can now be named (`name` argument to constructor) and the name is used + in the repr +* `mocksignature` can now be used with classes (signature based on `__init__`) + and callable objects (signature based on `__call__`) +* Mocks created with a spec can now pass `isinstance` tests (`__class__` + returns the type of the spec) +* Default numeric value for MagicMock is 1 rather than zero (because the + MagicMock bool defaults to True and 0 is False) +* Improved failure message for :meth:`~Mock.assert_called_with` when the mock + has not been called at all +* Adding the following to the set of supported magic methods: + + - ``__getformat__`` and ``__setformat__`` + - pickle methods + - ``__trunc__``, ``__ceil__`` and ``__floor__`` + - ``__sizeof__`` + +* Added 'build_sphinx' command to setup.py (requires setuptools or distribute) + Thanks to Florian Bauer +* with statement tests now skipped on Python 2.4 +* Tests require unittest2 to run on Python 2.7 +* Improved several docstrings and documentation + + +2010/06/23 Version 0.7.0 beta 2 +------------------------------- + +* :func:`patch.dict` works as a context manager as well as a decorator +* ``patch.dict`` takes a string to specify dictionary as well as a dictionary + object. If a string is supplied the name specified is imported +* BUGFIX: ``patch.dict`` restores dictionary even when an exception is raised + + +2010/06/22 Version 0.7.0 beta 1 +------------------------------- + +* Addition of :func:`mocksignature` +* Ability to mock magic methods +* Ability to use ``patch`` and ``patch.object`` as class decorators +* Renamed ``patch_object`` to :func:`patch.object` (``patch_object`` is + deprecated) +* Addition of :class:`MagicMock` class with all magic methods pre-created for you +* Python 3 compatibility (tested with 3.2 but should work with 3.0 & 3.1 as + well) +* Addition of :func:`patch.dict` for changing dictionaries during a test +* Addition of ``mocksignature`` argument to ``patch`` and ``patch.object`` +* ``help(mock)`` works now (on the module). Can no longer use ``__bases__`` + as a valid sentinel name (thanks to Stephen Emslie for reporting and + diagnosing this) +* Addition of soft comparisons: `call_args`, `call_args_list` and `method_calls` + now return tuple-like objects which compare equal even when empty args + or kwargs are skipped +* Added docstrings. +* BUGFIX: ``side_effect`` now works with ``BaseException`` exceptions like + ``KeyboardInterrupt`` +* BUGFIX: patching the same object twice now restores the patches correctly +* The tests now require `unittest2 <http://pypi.python.org/pypi/unittest2>`_ + to run +* `Konrad Delong <http://konryd.blogspot.com/>`_ added as co-maintainer + + +2009/08/22 Version 0.6.0 +------------------------ + +* New test layout compatible with test discovery +* Descriptors (static methods / class methods etc) can now be patched and + restored correctly +* Mocks can raise exceptions when called by setting ``side_effect`` to an + exception class or instance +* Mocks that wrap objects will not pass on calls to the underlying object if + an explicit return_value is set + + +2009/04/17 Version 0.5.0 +------------------------ + +* Made DEFAULT part of the public api. +* Documentation built with Sphinx. +* ``side_effect`` is now called with the same arguments as the mock is called with and + if returns a non-DEFAULT value that is automatically set as the ``mock.return_value``. +* ``wraps`` keyword argument used for wrapping objects (and passing calls through to the wrapped object). +* ``Mock.reset`` renamed to ``Mock.reset_mock``, as reset is a common API name. +* ``patch`` / ``patch_object`` are now context managers and can be used with ``with``. +* A new 'create' keyword argument to patch and patch_object that allows them to patch + (and unpatch) attributes that don't exist. (Potentially unsafe to use - it can allow + you to have tests that pass when they are testing an API that doesn't exist - use at + your own risk!) +* The methods keyword argument to Mock has been removed and merged with spec. The spec + argument can now be a list of methods or an object to take the spec from. +* Nested patches may now be applied in a different order (created mocks passed + in the opposite order). This is actually a bugfix. +* patch and patch_object now take a spec keyword argument. If spec is + passed in as 'True' then the Mock created will take the object it is replacing + as its spec object. If the object being replaced is a class, then the return + value for the mock will also use the class as a spec. +* A Mock created without a spec will not attempt to mock any magic methods / attributes + (they will raise an ``AttributeError`` instead). + + +2008/10/12 Version 0.4.0 +------------------------ + +* Default return value is now a new mock rather than None +* return_value added as a keyword argument to the constructor +* New method 'assert_called_with' +* Added 'side_effect' attribute / keyword argument called when mock is called +* patch decorator split into two decorators: + + - ``patch_object`` which takes an object and an attribute name to patch + (plus optionally a value to patch with which defaults to a mock object) + - ``patch`` which takes a string specifying a target to patch; in the form + 'package.module.Class.attribute'. (plus optionally a value to + patch with which defaults to a mock object) + +* Can now patch objects with ``None`` +* Change to patch for nose compatibility with error reporting in wrapped functions +* Reset no longer clears children / return value etc - it just resets + call count and call args. It also calls reset on all children (and + the return value if it is a mock). + +Thanks to Konrad Delong, Kevin Dangoor and others for patches and suggestions. + + +2007/12/03 Version 0.3.1 +------------------------- + +``patch`` maintains the name of decorated functions for compatibility with nose +test autodiscovery. + +Tests decorated with ``patch`` that use the two argument form (implicit mock +creation) will receive the mock(s) passed in as extra arguments. + +Thanks to Kevin Dangoor for these changes. + + +2007/11/30 Version 0.3.0 +------------------------- + +Removed ``patch_module``. ``patch`` can now take a string as the first +argument for patching modules. + +The third argument to ``patch`` is optional - a mock will be created by +default if it is not passed in. + + +2007/11/21 Version 0.2.1 +------------------------- + +Bug fix, allows reuse of functions decorated with ``patch`` and ``patch_module``. + + +2007/11/20 Version 0.2.0 +------------------------- + +Added ``spec`` keyword argument for creating ``Mock`` objects from a +specification object. + +Added ``patch`` and ``patch_module`` monkey patching decorators. + +Added ``sentinel`` for convenient access to unique objects. + +Distribution includes unit tests. + + +2007/11/19 Version 0.1.0 +------------------------- + +Initial release. + + +TODO and Limitations +==================== + +Contributions, bug reports and comments welcomed! + +Feature requests and bug reports are handled on the issue tracker: + + * `mock issue tracker <http://code.google.com/p/mock/issues/list>`_ + +`wraps` is not integrated with magic methods. + +`patch` could auto-do the patching in the constructor and unpatch in the +destructor. This would be useful in itself, but violates TOOWTDI and would be +unsafe for IronPython & PyPy (non-deterministic calling of destructors). +Destructors aren't called in CPython where there are cycles, but a weak +reference with a callback can be used to get round this. + +`Mock` has several attributes. This makes it unsuitable for mocking objects +that use these attribute names. A way round this would be to provide methods +that *hide* these attributes when needed. In 0.8 many, but not all, of these +attributes are renamed to gain a `_mock` prefix, making it less likely that +they will clash. Any outstanding attributes that haven't been modified with +the prefix should be changed. + +If a patch is started using `patch.start` and then not stopped correctly then +the unpatching is not done. Using weak references it would be possible to +detect and fix this when the patch object itself is garbage collected. This +would be tricky to get right though. + +When a `Mock` is created by `patch`, arbitrary keywords can be used to set +attributes. If `patch` is created with a `spec`, and is replacing a class, then +a `return_value` mock is created. The keyword arguments are not applied to the +child mock, but could be. + +When mocking a class with `patch`, passing in `spec=True` or `autospec=True`, +the mock class has an instance created from the same spec. Should this be the +default behaviour for mocks anyway (mock return values inheriting the spec +from their parent), or should it be controlled by an additional keyword +argument (`inherit`) to the Mock constructor? `create_autospec` does this, so +an additional keyword argument to Mock is probably unnecessary. + +The `mocksignature` argument to `patch` with a non `Mock` passed into +`new_callable` will *probably* cause an error. Should it just be invalid? + +Note that `NonCallableMock` and `NonCallableMagicMock` still have the unused +(and unusable) attributes: `return_value`, `side_effect`, `call_count`, +`call_args` and `call_args_list`. These could be removed or raise errors on +getting / setting. They also have the `assert_called_with` and +`assert_called_once_with` methods. Removing these would be pointless as +fetching them would create a mock (attribute) that could be called without +error. + +Some outstanding technical debt. The way autospeccing mocks function +signatures was copied and modified from `mocksignature`. This could all be +refactored into one set of functions instead of two. The way we tell if +patchers are started and if a patcher is being used for a `patch.multiple` +call are both horrible. There are now a host of helper functions that should +be rationalised. (Probably time to split mock into a package instead of a +module.) + +Passing arbitrary keyword arguments to `create_autospec`, or `patch` with +`autospec`, when mocking a *function* works fine. However, the arbitrary +attributes are set on the created mock - but `create_autospec` returns a +real function (which doesn't have those attributes). However, what is the use +case for using autospec to create functions with attributes that don't exist +on the original? + +`mocksignature`, plus the `call_args_list` and `method_calls` attributes of +`Mock` could all be deprecated. |