Hello community, here is the log from the commit of package python-fixtures for openSUSE:Factory checked in at 2016-06-23 13:36:04 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-fixtures (Old) and /work/SRC/openSUSE:Factory/.python-fixtures.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-fixtures" Changes: -------- --- /work/SRC/openSUSE:Factory/python-fixtures/python-fixtures.changes 2015-09-30 05:50:29.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.python-fixtures.new/python-fixtures.changes 2016-06-23 13:36:05.000000000 +0200 @@ -1,0 +2,26 @@ +Mon Jun 20 08:04:02 UTC 2016 - [email protected] + +- update to 3.0.0: + * Release 3.0.0 + * Fixup the MonkeyPatch patch + * Tweak the new tests for consistency + * Update the semantics on _fixtures.MonkeyPatch + * Avoid old versions of pbr - we require modern releases + * Correct MockPatchMultiple example + * Ignore .tox + * MonkeyPatch staticmethod + * Drop support for Python 3.2. It's history + * Fix print in README + * Add CompoundFixture + * Tweak hacking docs + * Fix "propagate" spelling everywhere + * Missed one: propogate -> propagate + * Spelling and lint fixes + * Release 1.4 + * Trivial pep8 fix to logger.py + * FakeLogger: Mis-formatted log messages will raise Exception + * Use mock in preference to unittest.mock + * Add a .travis.yml + * Note how to push on releases + +------------------------------------------------------------------- Old: ---- fixtures-1.3.1.tar.gz New: ---- fixtures-3.0.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-fixtures.spec ++++++ --- /var/tmp/diff_new_pack.ik6NBE/_old 2016-06-23 13:36:06.000000000 +0200 +++ /var/tmp/diff_new_pack.ik6NBE/_new 2016-06-23 13:36:06.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package python-fixtures # -# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,13 +17,13 @@ Name: python-fixtures -Version: 1.3.1 +Version: 3.0.0 Release: 0 Summary: Fixtures, reusable state for writing clean tests and more License: Apache-2.0 or BSD-3-Clause Group: Development/Languages/Python Url: https://launchpad.net/python-fixtures -Source: http://pypi.python.org/packages/source/f/fixtures/fixtures-%{version}.tar.gz +Source: https://pypi.io/packages/source/f/fixtures/fixtures-%{version}.tar.gz BuildRequires: python-devel BuildRequires: python-mock BuildRequires: python-pbr >= 0.11 ++++++ fixtures-1.3.1.tar.gz -> fixtures-3.0.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/.travis.yml new/fixtures-3.0.0/.travis.yml --- old/fixtures-1.3.1/.travis.yml 1970-01-01 01:00:00.000000000 +0100 +++ new/fixtures-3.0.0/.travis.yml 2016-04-07 02:32:14.000000000 +0200 @@ -0,0 +1,23 @@ +sudo: false +language: python + +python: + - "2.6" + - "2.7" + - "3.3" + - "3.4" + - "3.5" + - "pypy" + - pypy3 + - "nightly" + +install: + - pip install -U pip + - pip install -U wheel setuptools pbr + - pip install -U .[docs,test] + - pip list + - python --version + +script: + - make check + - rst2html.py README README.html diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/AUTHORS new/fixtures-3.0.0/AUTHORS --- old/fixtures-1.3.1/AUTHORS 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/AUTHORS 2016-05-20 01:03:07.000000000 +0200 @@ -1,3 +1,5 @@ +Andrew Laski <[email protected]> +Brant Knudson <[email protected]> Clark Boylan <[email protected]> Dan Kenigsberg <[email protected]> Francesco Banconi <[email protected]> @@ -6,6 +8,7 @@ Gavin Panella <[email protected]> Gavin Panella <[email protected]> James Westby <[email protected]> +John L. Villalovos <[email protected]> Jonathan Lange <[email protected]> Jonathan Lange <[email protected]> Joshua Harlow <[email protected]> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/ChangeLog new/fixtures-3.0.0/ChangeLog --- old/fixtures-1.3.1/ChangeLog 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/ChangeLog 2016-05-20 01:03:07.000000000 +0200 @@ -1,6 +1,40 @@ CHANGES ======= +3.0.0 +----- + +* Release 3.0.0 +* Fixup the MonkeyPatch patch +* Tweak the new tests for consistency +* Update the semantics on _fixtures.MonkeyPatch +* Avoid old versions of pbr - we require modern releases +* Correct MockPatchMultiple example +* Ignore .tox + +2.0.0 +----- + +* Fixup NEWS, release 2.0 +* MonkeyPatch staticmethod +* Drop support for Python 3.2. It's history +* Fix print in README +* Add CompoundFixture +* Tweak hacking docs +* Fix "propagate" spelling everywhere +* Missed one: propogate -> propagate +* Spelling and lint fixes + +1.4 +--- + +* Release 1.4 +* Trivial pep8 fix to logger.py +* FakeLogger: Mis-formatted log messages will raise Exception +* Use mock in preference to unittest.mock +* Add a .travis.yml +* Note how to push on releases + 1.3.1 ----- @@ -59,30 +93,30 @@ ------ * Release 0.3.15 -* * ``FakeProcess`` wait() now supports arguments added in Python 3. (Steve Kowalik) -* * ``FakeProcess`` wait() now supports arguments added in Python 3. (Steve Kowalik) -* * ``FakeProcess`` now supports kill(). (Steve Kowalik) -* * ``FakePopen`` now supports being called under a context manager (IE: with). (Steve Kowalik) -* * ``MonkeyPatch`` now preserves ``staticmethod`` functions. (Dan Kenigsberg) +* * ``FakeProcess`` wait() now supports arguments added in Python 3. (Steve Kowalik) +* * ``FakeProcess`` wait() now supports arguments added in Python 3. (Steve Kowalik) * * ``FakeProcess`` now supports kill(). (Steve Kowalik) -* * ``FakePopen`` now works under a context manager itself. (Steve Kowalik, #1358085) +* * ``FakePopen`` now supports being called under a context manager (IE: with). (Steve Kowalik) +* * ``MonkeyPatch`` now preserves ``staticmethod`` functions. (Dan Kenigsberg) +* * ``FakeProcess`` now supports kill(). (Steve Kowalik) +* * ``FakePopen`` now works under a context manager itself. (Steve Kowalik, #1358085) * MonkeyPatch staticmethod 0.3.14 ------ * Release 0.3.14 -* * ``FakePopen`` can now override the returncode attribute. (Robert Collins) +* * ``FakePopen`` can now override the returncode attribute. (Robert Collins) * More releasing docs 0.3.13 ------ * Release 0.3.13 -* * Documentation hopefully covers ``TestWithFixtures`` a little better. (Robert Collins, #1102688) +* * Documentation hopefully covers ``TestWithFixtures`` a little better. (Robert Collins, #1102688) * Ignore an egg-info directory if it exists -* * ``setup.py`` now lists the ``testtools`` dependency which was missing. (Robert Collins, #1103823) -* * ``FakePopen`` now accepts all the parameters available in Python 2.7. (Robert Collins) +* * ``setup.py`` now lists the ``testtools`` dependency which was missing. (Robert Collins, #1103823) +* * ``FakePopen`` now accepts all the parameters available in Python 2.7. (Robert Collins) 0.3.12 ------ @@ -95,12 +129,12 @@ ------ * Release 0.3.11 -* * pydoc is recommended as a source of info about fixtures. (Robert Collins, #812845) -* * The docs for fixtures have been updated to cover the full API. (Robert Collins, #1071649) -* * ``DetailStream`` was ambiguous about whether it handled bytes or characters, which matters a lot for Python3. It now is deprecated with ByteStream and StringStream replacing it. (Robert Collins) +* * pydoc is recommended as a source of info about fixtures. (Robert Collins, #812845) +* * The docs for fixtures have been updated to cover the full API. (Robert Collins, #1071649) +* * ``DetailStream`` was ambiguous about whether it handled bytes or characters, which matters a lot for Python3. It now is deprecated with ByteStream and StringStream replacing it. (Robert Collins) * Update docs -* * ``DetailStream`` was ambiguous about whether it handled bytes or characters, which matters a lot for Python3. It now is deprecated with ByteStream and StringStream replacing it. (Robert Collins) -* * ``FakeLogger`` has been split out into a ``LogHandler`` fixture that can inject arbitrary handlers, giving more flexability. (Jonathan Lange) +* * ``DetailStream`` was ambiguous about whether it handled bytes or characters, which matters a lot for Python3. It now is deprecated with ByteStream and StringStream replacing it. (Robert Collins) +* * ``FakeLogger`` has been split out into a ``LogHandler`` fixture that can inject arbitrary handlers, giving more flexability. (Jonathan Lange) * Drop the MementoHandler stuff * Rest of the tests for LogHandler * Give up on MementoHandler, just test LogHandler instead @@ -109,12 +143,12 @@ * Extract the handler managing bit of FakeLogger into its own fixture * Add MementoHandler * Release 0.3.10 -* * New ``DetailStream`` fixture to add file-like object content to testtools details. This allows for easy capture of sys.stdout and sys.stderr for example. (Clark Boylan) +* * New ``DetailStream`` fixture to add file-like object content to testtools details. This allows for easy capture of sys.stdout and sys.stderr for example. (Clark Boylan) * Document DetailStream -* * New ``DetailStream`` fixture to add file-like object content to testtools details. This allows for easy capture of sys.stdout and sys.stderr for example. (Clark Boylan) -* * Factor out new ``CallMany`` class to isolate the cleanup logic. (Robert Collins) +* * New ``DetailStream`` fixture to add file-like object content to testtools details. This allows for easy capture of sys.stdout and sys.stderr for example. (Clark Boylan) +* * Factor out new ``CallMany`` class to isolate the cleanup logic. (Robert Collins) * Add 'join' method to TempDir -* Revert filetree patch, r54. Now in lp:treeshape +* Revert filetree patch, r54. Now in lp:treeshape * Rename to 'join' * Update NEWS * Add an 'abspath' helper @@ -146,7 +180,7 @@ * Initial creation of FileTree * Add a matcher, because I can't bear to write that code again * Clean up pyflakes -* Export TempHomeDir. Otherwise it's imported here for no reason +* Export TempHomeDir. Otherwise it's imported here for no reason 0.3.9 ----- @@ -195,7 +229,7 @@ * Bump version to 0.3.7 beta * Typo * Extend TempDir to allow controlling the root directory -* * On Python 2.7 and above the _fixtures tests are no longer run twice. (Robert Collins) +* * On Python 2.7 and above the _fixtures tests are no longer run twice. (Robert Collins) * Note in NEWS the new testtools version dependency as well * NEWS & README * Pretty sure this is a py3 thing @@ -204,7 +238,7 @@ * Release 0.3.6 * Another small API break - sorry. Fixture.getDetails no longer returns the internal details dict (self._details). Access that directly if needed. It now looks for details in used fixtures and returns those as well as details added directly. (RobertCollins, #780806) * New fixture ``PackagePathEntry`` which patches the path of an existing package, allowing importing part of it from aonther directory. (Robert Collins) -* * Details from child fixtures for both Fixture and TestWithFixtures no longer quash same-named details if testtools 0.9.11 is available (for the gather_details helper). (Gavin Panella, #796253) +* * Details from child fixtures for both Fixture and TestWithFixtures no longer quash same-named details if testtools 0.9.11 is available (for the gather_details helper). (Gavin Panella, #796253) * Test failure on some setups in test_cleanUp_raise_first_false_callscleanups_returns_exceptions. (Gavin Panella, #796249) * Gather details from fixtures that fail to setUp() in TestWithFixtures * Use testtools.helpers.try_import instead of try:except: @@ -212,7 +246,7 @@ * Reminder to self to skip test if gather_details is not available * Test against types.TracebackType instead of the type of the current traceback in sys.exc_info() * Gather details from fixtures that fail to setUp() -* * New fixture ``PythonPathEntry`` which patches sys.path. (Robert Collins, #737503) +* * New fixture ``PythonPathEntry`` which patches sys.path. (Robert Collins, #737503) * Better docs for cleanUp and exceptions * Document sharing dependencies somewhat * Release 0.3.5 @@ -228,7 +262,7 @@ * Ship new packages * Release 0.3.1 * Add a communicate method to FakeProcess -* * Experimental PopenFixture providing a test double for testing code that runs external processes. (Robert Collins) +* * Experimental PopenFixture providing a test double for testing code that runs external processes. (Robert Collins) * Fixup cleanUp protocol for good * Stop silently swallowing exceptions during cleanUp * Cause cleanup failures to cause test failures diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/HACKING new/fixtures-3.0.0/HACKING --- old/fixtures-1.3.1/HACKING 2015-06-22 01:52:32.000000000 +0200 +++ new/fixtures-3.0.0/HACKING 2016-03-23 23:55:38.000000000 +0100 @@ -38,7 +38,11 @@ 1. Add a version to NEWS. -1. commit, tag. +1. commit, tag:: + + git commit -am "Release X.Y.Z" + git tag -m "Release X.Y.Z" X.Y.Z + git push --tags origin master:master 1. Upload to pypi, signed. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/NEWS new/fixtures-3.0.0/NEWS --- old/fixtures-1.3.1/NEWS 2015-06-30 04:21:13.000000000 +0200 +++ new/fixtures-3.0.0/NEWS 2016-05-20 01:01:08.000000000 +0200 @@ -6,6 +6,40 @@ NEXT ~~~~ +3.0.0 +~~~~~ + +* Monkeypatching of callables has been thoroughly overhauled: there were deep + flaws in usability because staticmethod and classmethods are actually + descriptors. (Andrew Laski, Robert Collins) + +2.0 +~~~ + +* Monkeypatching of staticmethod's now works correctly on Python 2 and 3. + This is an API break as previously they were bound as instancemethods's + and thus any working patches need to have their first parameter (self) + dropped. (Andrew Laski) + +* New class ``CompoundFixture`` added, allowing fixtures to be combined. + (Jonathan Lange) + +* Support for Python 3.2 dropped (as pip and setuptools have). + (Robert Collins) + +1.4 +~~~ + +* ``fixtures`` now has CI testing via Travis, no more manual work. + (Robert Collins) + +* ``mock`` is used in preference to ``unittest.mock`` now, as the rolling + backport has significant bugfixes over older but still supported CPython + stdlib versions. (Robert Collins) + +* ``fixtures.FakeLogger`` now detects incorrectly formatted log messages. + (John Villalovos, #1503049) + 1.3.1 ~~~~~ @@ -22,7 +56,7 @@ * Fixture.setUp should no longer be overridden in subclasses. Instead override _setUp. This permits the Fixture base class to detect failures during _setUp and trigger any registered cleanups, attach any details - to the failure exception and propogate that to callers. Overriding of + to the failure exception and propagate that to callers. Overriding of setUp is still supported: this adds a new interface for simpler implementation of the contract of a fixture. (Robert Collins, #1456361, #1456353) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/PKG-INFO new/fixtures-3.0.0/PKG-INFO --- old/fixtures-1.3.1/PKG-INFO 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/PKG-INFO 2016-05-20 01:03:07.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: fixtures -Version: 1.3.1 +Version: 3.0.0 Summary: Fixtures, reusable state for writing clean tests and more. Home-page: https://launchpad.net/python-fixtures Author: Robert Collins @@ -33,7 +33,7 @@ Dependencies ============ - * Python 2.6+ + * Python 2.6+, or 3.3+ This is the base language fixtures is written in and for. * pbr @@ -64,7 +64,7 @@ Standard Python unittest.py provides no obvious method for making and reusing state needed in a test case other than by adding a method on the test class. - This scales poorly - complex helper functions propogating up a test class + This scales poorly - complex helper functions propagating up a test class hierarchy is a regular pattern when this is done. Mocking while a great tool doesn't itself prevent this (and helpers to mock complex things can accumulate in the same way if placed on the test class). @@ -154,6 +154,14 @@ >>> server = MyServer() >>> fixture = fixtures.MethodFixture(server, server.start, server.stop) + You can also combine existing fixtures using ``CompoundFixture``:: + + >>> noddy_with_log = fixtures.CompoundFixture([NoddyFixture(), + ... WithLog()]) + >>> with noddy_with_log as x: + ... print (x.fixtures[0].frobnozzle) + 42 + The Fixture API =============== @@ -238,7 +246,7 @@ class implementation of ``setUp`` acts to reduce the chance of leaking external resources if an error is raised from ``_setUp``. Specifically, ``setUp`` contains a try:/except: block which catches all exceptions, captures - any registered detail objects, and calls ``self.cleanUp`` before propogating + any registered detail objects, and calls ``self.cleanUp`` before propagating the error. As long as you take care to register any cleanups before calling the code that may fail, this will cause them to be cleaned up. The captured detail objects are provided to the args of the raised exception. @@ -393,7 +401,7 @@ Adapts ``mock.patch.multiple`` to be used as a Fixture. - >>> fixture = fixtures.MockPatch('subprocess.Popen', returncode=3) + >>> fixture = fixtures.MockPatchMultiple('subprocess.Popen', returncode=3) MonkeyPatch +++++++++++ @@ -404,6 +412,9 @@ ... pass >>> fixture = fixtures.MonkeyPatch('__builtin__.open', fake_open) + Note that there are some complexities when patching methods - please see the + API documentation for details. + NestedTempfile ++++++++++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/README new/fixtures-3.0.0/README --- old/fixtures-1.3.1/README 2015-06-30 02:56:38.000000000 +0200 +++ new/fixtures-3.0.0/README 2016-05-19 12:27:44.000000000 +0200 @@ -25,7 +25,7 @@ Dependencies ============ -* Python 2.6+ +* Python 2.6+, or 3.3+ This is the base language fixtures is written in and for. * pbr @@ -56,7 +56,7 @@ Standard Python unittest.py provides no obvious method for making and reusing state needed in a test case other than by adding a method on the test class. -This scales poorly - complex helper functions propogating up a test class +This scales poorly - complex helper functions propagating up a test class hierarchy is a regular pattern when this is done. Mocking while a great tool doesn't itself prevent this (and helpers to mock complex things can accumulate in the same way if placed on the test class). @@ -146,6 +146,14 @@ >>> server = MyServer() >>> fixture = fixtures.MethodFixture(server, server.start, server.stop) +You can also combine existing fixtures using ``CompoundFixture``:: + + >>> noddy_with_log = fixtures.CompoundFixture([NoddyFixture(), + ... WithLog()]) + >>> with noddy_with_log as x: + ... print (x.fixtures[0].frobnozzle) + 42 + The Fixture API =============== @@ -230,7 +238,7 @@ class implementation of ``setUp`` acts to reduce the chance of leaking external resources if an error is raised from ``_setUp``. Specifically, ``setUp`` contains a try:/except: block which catches all exceptions, captures -any registered detail objects, and calls ``self.cleanUp`` before propogating +any registered detail objects, and calls ``self.cleanUp`` before propagating the error. As long as you take care to register any cleanups before calling the code that may fail, this will cause them to be cleaned up. The captured detail objects are provided to the args of the raised exception. @@ -385,7 +393,7 @@ Adapts ``mock.patch.multiple`` to be used as a Fixture. - >>> fixture = fixtures.MockPatch('subprocess.Popen', returncode=3) + >>> fixture = fixtures.MockPatchMultiple('subprocess.Popen', returncode=3) MonkeyPatch +++++++++++ @@ -396,6 +404,9 @@ ... pass >>> fixture = fixtures.MonkeyPatch('__builtin__.open', fake_open) +Note that there are some complexities when patching methods - please see the +API documentation for details. + NestedTempfile ++++++++++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/__init__.py new/fixtures-3.0.0/fixtures/__init__.py --- old/fixtures-1.3.1/fixtures/__init__.py 2015-06-22 08:56:00.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/__init__.py 2016-03-23 23:55:38.000000000 +0100 @@ -44,6 +44,7 @@ __all__ = [ 'ByteStream', + 'CompoundFixture', 'DetailStream', 'EnvironmentVariable', 'EnvironmentVariableFixture', @@ -78,6 +79,7 @@ from fixtures.fixture import ( + CompoundFixture, Fixture, FunctionFixture, MethodFixture, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/_fixtures/logger.py new/fixtures-3.0.0/fixtures/_fixtures/logger.py --- old/fixtures-1.3.1/fixtures/_fixtures/logger.py 2015-06-22 08:56:00.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/_fixtures/logger.py 2016-03-23 23:55:38.000000000 +0100 @@ -14,7 +14,9 @@ # limitations under that license. from logging import StreamHandler, getLogger, INFO, Formatter +import sys +import six from testtools.compat import _u from fixtures import Fixture @@ -61,6 +63,12 @@ self.addCleanup(logger.removeHandler, self.handler) +class StreamHandlerRaiseException(StreamHandler): + """Handler class that will raise an exception on formatting errors.""" + def handleError(self, record): + six.reraise(*sys.exc_info()) + + class FakeLogger(Fixture): """Replace a logger and capture its output.""" @@ -98,7 +106,7 @@ name = _u("pythonlogging:'%s'") % self._name output = self.useFixture(StringStream(name)).stream self._output = output - handler = StreamHandler(output) + handler = StreamHandlerRaiseException(output) if self._format: formatter = (self._formatter or Formatter) handler.setFormatter(formatter(self._format, self._datefmt)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/_fixtures/mockpatch.py new/fixtures-3.0.0/fixtures/_fixtures/mockpatch.py --- old/fixtures-1.3.1/fixtures/_fixtures/mockpatch.py 2015-06-22 08:56:00.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/_fixtures/mockpatch.py 2016-03-23 23:55:38.000000000 +0100 @@ -19,9 +19,9 @@ import fixtures -mock = extras.try_imports(['unittest.mock', 'mock'], None) +mock = extras.try_imports(['mock', 'unittest.mock'], None) mock_default = extras.try_imports( - ['unittest.mock.DEFAULT', 'mock.DEFAULT'], None) + ['mock.DEFAULT', 'unittest.mock.DEFAULT'], None) class _Base(fixtures.Fixture): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/_fixtures/monkeypatch.py new/fixtures-3.0.0/fixtures/_fixtures/monkeypatch.py --- old/fixtures-1.3.1/fixtures/_fixtures/monkeypatch.py 2015-06-22 08:56:00.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/_fixtures/monkeypatch.py 2016-05-20 00:14:52.000000000 +0200 @@ -17,12 +17,81 @@ 'MonkeyPatch' ] +import functools import sys import types from fixtures import Fixture +_class_types = (type, ) +if getattr(types, 'ClassType', None): + # Python 2 has multiple types of classes. + _class_types = _class_types + (types.ClassType,) + + +def _coerce_values(obj, name, new_value, sentinel): + """Return an adapted (new_value, old_value) for patching obj.name. + + setattr transforms a function into an instancemethod when set on a class. + This checks if the attribute to be replaced is a callable descriptor - + staticmethod, classmethod, or types.FunctionType - and wraps new_value if + necessary. + + This also checks getattr(obj, name) and wraps it if necessary + since the staticmethod wrapper isn't preserved. + + :param obj: The object with an attribute being patched. + :param name: The name of the attribute being patched. + :param new_value: The new value to be assigned. + :param sentinel: If no old_value existed, the sentinel is returned to + indicate that. + """ + old_value = getattr(obj, name, sentinel) + if not isinstance(obj, _class_types): + # We may be dealing with an instance of a class. In that case the + # attribute may be the result of a descriptor lookup (or a __getattr__ + # override etc). Its incomplete, but generally good enough to just + # look and see if name is in the instance dict. + try: + obj.__dict__[name] + except (AttributeError, KeyError): + return (new_value, sentinel) + else: + return (new_value, old_value) + + # getattr() returns a function, this access pattern will return a + # staticmethod/classmethod if the name method is defined that way + old_attribute = obj.__dict__.get(name) + if old_attribute is not None: + old_value = old_attribute + + # If new_value is not callable, no special handling is needed. + # (well, technically the same descriptor issue can happen with + # user supplied descriptors, but that is arguably a feature - someone can + # deliberately install a different descriptor. + if not callable(new_value): + return (new_value, old_value) + + if isinstance(old_value, staticmethod): + new_value = staticmethod(new_value) + elif isinstance(old_value, classmethod): + new_value = classmethod(new_value) + elif isinstance(old_value, types.FunctionType): + if hasattr(new_value, '__get__'): + # new_value is a descriptor, and that would result in it being + # rebound if we assign it to a class - we want to preserve the + # bound state rather than having it bound to the new object + # it has been patched onto. + captured_method = new_value + @functools.wraps(old_value) + def avoid_get(*args, **kwargs): + return captured_method(*args, **kwargs) + new_value = avoid_get + + return (new_value, old_value) + + class MonkeyPatch(Fixture): """Replace or delete an attribute.""" @@ -37,6 +106,26 @@ During setup the name will be deleted or assigned the requested value, and this will be restored in cleanUp. + + When patching methods, the call signature of name should be a subset + of the parameters which can be used to call new_value. + + For instance. + + >>> class T: + ... def method(self, arg1): + ... pass + >>> class N: + ... @staticmethod + ... def newmethod(arg1): + ... pass + + Patching N.newmethod on top of T.method and then calling T().method(1) + will not work because they do not have compatible call signatures - + self will be passed to newmethod because the callable (N.newmethod) + is placed onto T as a regular function. This allows capturing all the + supplied parameters while still consulting local state in your + new_value. """ Fixture.__init__(self) self.name = name @@ -55,20 +144,16 @@ for component in components[1:]: current = getattr(current, component) sentinel = object() - old_value = getattr(current, attribute, sentinel) + new_value, old_value = _coerce_values(current, attribute, + self.new_value, sentinel) if self.new_value is self.delete: if old_value is not sentinel: delattr(current, attribute) else: - setattr(current, attribute, self.new_value) + setattr(current, attribute, new_value) if old_value is sentinel: self.addCleanup(self._safe_delete, current, attribute) else: - # Python 2's setattr transforms function into instancemethod - if (sys.version_info[0] == 2 and - isinstance(current, (type, types.ClassType)) and - isinstance(old_value, types.FunctionType)): - old_value = staticmethod(old_value) self.addCleanup(setattr, current, attribute, old_value) def _safe_delete(self, obj, attribute): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/callmany.py new/fixtures-3.0.0/fixtures/callmany.py --- old/fixtures-1.3.1/fixtures/callmany.py 2014-09-25 04:31:06.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/callmany.py 2016-03-23 23:55:38.000000000 +0100 @@ -67,7 +67,8 @@ re-raised after all the functions have run. If multiple exceptions are raised, they are all wrapped into a MultipleExceptions object, and that is raised. - Thus, to cach a specific exception from a function run by __call__, + + Thus, to catch a specific exception from a function run by __call__, you need to catch both the exception and MultipleExceptions, and then check within a MultipleExceptions instance for an occurance of the type you wish to catch. @@ -96,5 +97,4 @@ def __exit__(self, exc_type, exc_val, exc_tb): self() - return False # propogate exceptions from the with body. - + return False # Propagate exceptions from the with body. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/fixture.py new/fixtures-3.0.0/fixtures/fixture.py --- old/fixtures-1.3.1/fixtures/fixture.py 2015-06-30 03:01:38.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/fixture.py 2016-05-19 01:47:32.000000000 +0200 @@ -14,6 +14,7 @@ # limitations under that license. __all__ = [ + 'CompoundFixture', 'Fixture', 'FunctionFixture', 'MethodFixture', @@ -27,7 +28,6 @@ import six from testtools.compat import ( advance_iterator, - reraise, ) from testtools.helpers import try_import @@ -115,7 +115,7 @@ if a single exception is raised, it is reraised after all the cleanUps have run. If multiple exceptions are raised, they are all wrapped into a MultipleExceptions object, and that is reraised. - Thus, to cach a specific exception from cleanUp, you need to catch + Thus, to catch a specific exception from cleanUp, you need to catch both the exception and MultipleExceptions, and then check within a MultipleExceptions instance for the type you're catching. :return: A list of the exc_info() for each exception that occured if @@ -157,7 +157,7 @@ self._cleanups() finally: self._remove_state() - return False # propogate exceptions from the with body. + return False # propagate exceptions from the with body. def getDetails(self): """Get the current details registered with the fixture. @@ -206,7 +206,7 @@ errors = [err] + self.cleanUp(raise_first=False) try: raise SetupError(details) - except SetupError as e: + except SetupError: errors.append(sys.exc_info()) if issubclass(err[0], Exception): raise MultipleExceptions(*errors) @@ -381,12 +381,12 @@ if setup is None: setup = getattr(obj, 'setUp', None) if setup is None: - setup = lambda:None + setup = lambda: None self._setup = setup if cleanup is None: cleanup = getattr(obj, 'tearDown', None) if cleanup is None: - cleanup = lambda:None + cleanup = lambda: None self._cleanup = cleanup if reset is None: reset = getattr(obj, 'reset', None) @@ -404,3 +404,22 @@ super(MethodFixture, self).reset() else: self._reset() + + +class CompoundFixture(Fixture): + """A fixture that combines many fixtures. + + :ivar fixtures: The list of fixtures that make up this one. (read only). + """ + + def __init__(self, fixtures): + """Construct a fixture made of many fixtures. + + :param fixtures: An iterable of fixtures. + """ + super(CompoundFixture, self).__init__() + self.fixtures = list(fixtures) + + def _setUp(self): + for fixture in self.fixtures: + self.useFixture(fixture) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/tests/_fixtures/test_logger.py new/fixtures-3.0.0/fixtures/tests/_fixtures/test_logger.py --- old/fixtures-1.3.1/fixtures/tests/_fixtures/test_logger.py 2015-06-22 01:52:32.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/tests/_fixtures/test_logger.py 2016-03-23 23:55:38.000000000 +0100 @@ -17,6 +17,7 @@ import sys import time +import testtools from testtools import TestCase from testtools.compat import StringIO @@ -140,6 +141,11 @@ except: pass + def test_exceptionraised(self): + with FakeLogger(): + with testtools.ExpectedException(TypeError): + logging.info("Some message", "wrongarg") + class LogHandlerTest(TestCase, TestWithFixtures): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/tests/_fixtures/test_mockpatch.py new/fixtures-3.0.0/fixtures/tests/_fixtures/test_mockpatch.py --- old/fixtures-1.3.1/fixtures/tests/_fixtures/test_mockpatch.py 2015-06-22 02:24:03.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/tests/_fixtures/test_mockpatch.py 2016-03-23 23:55:38.000000000 +0100 @@ -14,7 +14,7 @@ import extras -mock = extras.try_imports(['unittest.mock', 'mock'], None) +import mock # Yes, we only test the rolling backport import testtools from fixtures import ( diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/tests/_fixtures/test_monkeypatch.py new/fixtures-3.0.0/fixtures/tests/_fixtures/test_monkeypatch.py --- old/fixtures-1.3.1/fixtures/tests/_fixtures/test_monkeypatch.py 2014-09-25 04:31:06.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/tests/_fixtures/test_monkeypatch.py 2016-05-20 00:15:24.000000000 +0200 @@ -13,16 +13,52 @@ # license you chose for the specific language governing permissions and # limitations under that license. +import functools + import testtools +from testtools.matchers import Is from fixtures import MonkeyPatch, TestWithFixtures reference = 23 class C(object): + def foo(self, arg): + return arg + @staticmethod + def foo_static(): pass + @classmethod + def foo_cls(cls): pass + +class D(object): + def bar(self): pass + def bar_two_args(self, arg): + return (self, arg) + @classmethod + def bar_cls(cls): + return cls + @classmethod + def bar_cls_args(cls, *args): + return (cls,) + args @staticmethod - def foo(): pass -def bar(): pass + def bar_static(): + pass + @staticmethod + def bar_static_args(*args): + return args + def bar_self_referential(self, *args, **kwargs): + self.bar() + +INST_C = C() + +def fake(*args): + return args +def fake2(arg): pass +def fake_no_args(): pass +def fake_no_args2(): pass +@staticmethod +def fake_static(): pass + class TestMonkeyPatch(testtools.TestCase, TestWithFixtures): @@ -72,12 +108,318 @@ fixture.cleanUp() self.assertFalse('new_attr' in globals()) - def test_patch_staticmethod(self): - oldfoo = C.foo + def _check_restored_static_or_class_method(self, oldmethod, oldmethod_inst, + klass, methodname): + restored_method = getattr(klass, methodname) + restored_method_inst = getattr(klass(), methodname) + self.assertEqual(oldmethod, restored_method) + self.assertEqual(oldmethod, restored_method_inst) + self.assertEqual(oldmethod_inst, restored_method) + self.assertEqual(oldmethod_inst, restored_method_inst) + restored_method() + restored_method_inst() + + def test_patch_staticmethod_with_staticmethod(self): + oldmethod = C.foo_static + oldmethod_inst = C().foo_static + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_static', + D.bar_static) + with fixture: + C.foo_static() + C().foo_static() + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_static') + + def test_patch_staticmethod_with_classmethod(self): + oldmethod = C.foo_static + oldmethod_inst = C().foo_static + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_static', + D.bar_cls) + with fixture: + C.foo_static() + C().foo_static() + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_static') + + def test_patch_staticmethod_with_function(self): + oldmethod = C.foo_static + oldmethod_inst = C().foo_static + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_static', + fake_no_args) + with fixture: + C.foo_static() + C().foo_static() + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_static') + + def test_patch_staticmethod_with_boundmethod(self): + oldmethod = C.foo_static + oldmethod_inst = C().foo_static + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_static', + D().bar) + with fixture: + C.foo_static() + C().foo_static() + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_static') + + def test_patch_classmethod_with_staticmethod(self): + oldmethod = C.foo_cls + oldmethod_inst = C().foo_cls + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', + D.bar_static_args) + with fixture: + (cls,) = C.foo_cls() + self.expectThat(cls, Is(C)) + (cls,) = C().foo_cls() + self.expectThat(cls, Is(C)) + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_cls') + + def test_patch_classmethod_with_classmethod(self): + oldmethod = C.foo_cls + oldmethod_inst = C().foo_cls + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', + D.bar_cls_args) + with fixture: + cls, target_class = C.foo_cls() + self.expectThat(cls, Is(D)) + self.expectThat(target_class, Is(C)) + cls, target_class = C().foo_cls() + self.expectThat(cls, Is(D)) + self.expectThat(target_class, Is(C)) + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_cls') + + def test_patch_classmethod_with_function(self): + oldmethod = C.foo_cls + oldmethod_inst = C().foo_cls + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', + fake) + with fixture: + (cls,) = C.foo_cls() + self.expectThat(cls, Is(C)) + (cls, arg) = C().foo_cls(1) + self.expectThat(cls, Is(C)) + self.assertEqual(1, arg) + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_cls') + + def test_patch_classmethod_with_boundmethod(self): + oldmethod = C.foo_cls + oldmethod_inst = C().foo_cls + d = D() + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', + d.bar_two_args) + with fixture: + slf, cls = C.foo_cls() + self.expectThat(slf, Is(d)) + self.expectThat(cls, Is(C)) + slf, cls = C().foo_cls() + self.expectThat(slf, Is(d)) + self.expectThat(cls, Is(C)) + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_cls') + + def test_patch_function_with_staticmethod(self): + oldmethod = fake_no_args + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.fake_no_args', + D.bar_static) + with fixture: + fake_no_args() + self.assertEqual(oldmethod, fake_no_args) + + def test_patch_function_with_classmethod(self): + oldmethod = fake_no_args + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.fake_no_args', + D.bar_cls) + with fixture: + fake_no_args() + self.assertEqual(oldmethod, fake_no_args) + + def test_patch_function_with_function(self): + oldmethod = fake_no_args + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.fake_no_args', + fake_no_args2) + with fixture: + fake_no_args() + self.assertEqual(oldmethod, fake_no_args) + + def test_patch_function_with_partial(self): + oldmethod = fake_no_args + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.fake_no_args', + functools.partial(fake, 1)) + with fixture: + (ret,) = fake_no_args() + self.assertEqual(1, ret) + self.assertEqual(oldmethod, fake_no_args) + + def test_patch_function_with_boundmethod(self): + oldmethod = fake_no_args + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.fake_no_args', + D().bar) + with fixture: + fake_no_args() + self.assertEqual(oldmethod, fake_no_args) + + def test_patch_boundmethod_with_staticmethod(self): + oldmethod = INST_C.foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.INST_C.foo', + D.bar_static) + with fixture: + INST_C.foo() + self.assertEqual(oldmethod, INST_C.foo) + + def test_patch_boundmethod_with_classmethod(self): + oldmethod = INST_C.foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.INST_C.foo', + D.bar_cls) + with fixture: + INST_C.foo() + self.assertEqual(oldmethod, INST_C.foo) + + def test_patch_boundmethod_with_function(self): + oldmethod = INST_C.foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.INST_C.foo', + fake_no_args) + with fixture: + INST_C.foo() + self.assertEqual(oldmethod, INST_C.foo) + + def test_patch_boundmethod_with_boundmethod(self): + oldmethod = INST_C.foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.INST_C.foo', + D().bar) + with fixture: + INST_C.foo() + self.assertEqual(oldmethod, INST_C.foo) + sentinel = object() + self.assertEqual(sentinel, INST_C.__dict__.get('foo', sentinel)) + + def test_patch_unboundmethod_with_staticmethod(self): + oldmethod = C.foo fixture = MonkeyPatch( 'fixtures.tests._fixtures.test_monkeypatch.C.foo', - bar) + D.bar_static_args) with fixture: - pass - self.assertEqual(oldfoo, C.foo) + target_self, arg = INST_C.foo(1) + self.expectThat(target_self, Is(INST_C)) + self.assertEqual(1, arg) + self.assertEqual(oldmethod, C.foo) + def test_patch_unboundmethod_with_classmethod(self): + oldmethod = C.foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo', + D.bar_cls_args) + with fixture: + c = C() + cls, target_self, arg = c.foo(1) + self.expectThat(cls, Is(D)) + self.expectThat(target_self, Is(c)) + self.assertEqual(1, arg) + self.assertEqual(oldmethod, C.foo) + + def test_patch_unboundmethod_with_function(self): + oldmethod = C.foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo', + fake) + with fixture: + c = C() + target_self, arg = c.foo(1) + self.expectThat(target_self, Is(c)) + self.assertTrue(1, arg) + self.assertEqual(oldmethod, C.foo) + + def test_patch_unboundmethod_with_boundmethod(self): + oldmethod = C.foo + d = D() + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo', + d.bar_two_args) + with fixture: + c = C() + slf, target_self = c.foo() + self.expectThat(slf, Is(d)) + self.expectThat(target_self, Is(c)) + self.assertEqual(oldmethod, C.foo) + + def test_double_patch_instancemethod(self): + oldmethod = C.foo + oldmethod_inst = C().foo + fixture1 = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo', + fake) + fixture2 = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo', + fake2) + with fixture1: + with fixture2: + C().foo() + self.assertEqual(oldmethod, C.foo) + # The method address changes with each instantiation of C, and method + # equivalence just tests that. Compare the code objects instead. + self.assertEqual(oldmethod_inst.__code__, C().foo.__code__) + + def test_double_patch_staticmethod(self): + oldmethod = C.foo_static + oldmethod_inst = C().foo_static + fixture1 = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_static', + fake_no_args) + fixture2 = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_static', + fake_static) + with fixture1: + with fixture2: + C.foo_static() + C().foo_static() + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_static') + + def test_double_patch_classmethod(self): + oldmethod = C.foo_cls + oldmethod_inst = C().foo_cls + fixture1 = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', + fake) + fixture2 = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', + fake2) + with fixture1: + with fixture2: + C.foo_cls() + C().foo_cls() + self._check_restored_static_or_class_method(oldmethod, oldmethod_inst, + C, 'foo_cls') + + def test_patch_c_foo_with_instance_d_bar_self_referential(self): + oldmethod = C.foo + oldmethod_inst = C().foo + fixture = MonkeyPatch( + 'fixtures.tests._fixtures.test_monkeypatch.C.foo', + D().bar_self_referential) + with fixture: + C().foo() + self.assertEqual(oldmethod, C.foo) + # The method address changes with each instantiation of C, and method + # equivalence just tests that. Compare the code objects instead. + self.assertEqual(oldmethod_inst.__code__, C().foo.__code__) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/tests/test_callmany.py new/fixtures-3.0.0/fixtures/tests/test_callmany.py --- old/fixtures-1.3.1/fixtures/tests/test_callmany.py 2014-09-25 04:31:06.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/tests/test_callmany.py 2016-03-23 23:55:38.000000000 +0100 @@ -45,7 +45,7 @@ self.assertEqual(('woo',), value.args) self.assertIsInstance(tb, types.TracebackType) - def test_exit_propogates_exceptions(self): + def test_exit_propagates_exceptions(self): call = CallMany() call.__enter__() self.assertEqual(False, call.__exit__(None, None, None)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures/tests/test_fixture.py new/fixtures-3.0.0/fixtures/tests/test_fixture.py --- old/fixtures-1.3.1/fixtures/tests/test_fixture.py 2015-06-30 02:51:08.000000000 +0200 +++ new/fixtures-3.0.0/fixtures/tests/test_fixture.py 2016-03-23 23:55:38.000000000 +0100 @@ -84,7 +84,7 @@ self.assertEqual(('woo',), value.args) self.assertIsInstance(tb, types.TracebackType) - def test_exit_propogates_exceptions(self): + def test_exit_propagates_exceptions(self): fixture = fixtures.Fixture() fixture.__enter__() self.assertEqual(False, fixture.__exit__(None, None, None)) @@ -259,7 +259,7 @@ def test_setup_failures_with_base_exception(self): # when _setUp fails with a BaseException (or subclass thereof) that - # exception is propogated as is, but we still call cleanups etc. + # exception is propagated as is, but we still call cleanups etc. class MyBase(BaseException):pass log = [] class Subclass(fixtures.Fixture): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures.egg-info/PKG-INFO new/fixtures-3.0.0/fixtures.egg-info/PKG-INFO --- old/fixtures-1.3.1/fixtures.egg-info/PKG-INFO 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/fixtures.egg-info/PKG-INFO 2016-05-20 01:03:06.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: fixtures -Version: 1.3.1 +Version: 3.0.0 Summary: Fixtures, reusable state for writing clean tests and more. Home-page: https://launchpad.net/python-fixtures Author: Robert Collins @@ -33,7 +33,7 @@ Dependencies ============ - * Python 2.6+ + * Python 2.6+, or 3.3+ This is the base language fixtures is written in and for. * pbr @@ -64,7 +64,7 @@ Standard Python unittest.py provides no obvious method for making and reusing state needed in a test case other than by adding a method on the test class. - This scales poorly - complex helper functions propogating up a test class + This scales poorly - complex helper functions propagating up a test class hierarchy is a regular pattern when this is done. Mocking while a great tool doesn't itself prevent this (and helpers to mock complex things can accumulate in the same way if placed on the test class). @@ -154,6 +154,14 @@ >>> server = MyServer() >>> fixture = fixtures.MethodFixture(server, server.start, server.stop) + You can also combine existing fixtures using ``CompoundFixture``:: + + >>> noddy_with_log = fixtures.CompoundFixture([NoddyFixture(), + ... WithLog()]) + >>> with noddy_with_log as x: + ... print (x.fixtures[0].frobnozzle) + 42 + The Fixture API =============== @@ -238,7 +246,7 @@ class implementation of ``setUp`` acts to reduce the chance of leaking external resources if an error is raised from ``_setUp``. Specifically, ``setUp`` contains a try:/except: block which catches all exceptions, captures - any registered detail objects, and calls ``self.cleanUp`` before propogating + any registered detail objects, and calls ``self.cleanUp`` before propagating the error. As long as you take care to register any cleanups before calling the code that may fail, this will cause them to be cleaned up. The captured detail objects are provided to the args of the raised exception. @@ -393,7 +401,7 @@ Adapts ``mock.patch.multiple`` to be used as a Fixture. - >>> fixture = fixtures.MockPatch('subprocess.Popen', returncode=3) + >>> fixture = fixtures.MockPatchMultiple('subprocess.Popen', returncode=3) MonkeyPatch +++++++++++ @@ -404,6 +412,9 @@ ... pass >>> fixture = fixtures.MonkeyPatch('__builtin__.open', fake_open) + Note that there are some complexities when patching methods - please see the + API documentation for details. + NestedTempfile ++++++++++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures.egg-info/SOURCES.txt new/fixtures-3.0.0/fixtures.egg-info/SOURCES.txt --- old/fixtures-1.3.1/fixtures.egg-info/SOURCES.txt 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/fixtures.egg-info/SOURCES.txt 2016-05-20 01:03:07.000000000 +0200 @@ -1,4 +1,5 @@ .testr.conf +.travis.yml AUTHORS Apache-2.0 BSD @@ -13,7 +14,6 @@ requirements.txt setup.cfg setup.py -test-requirements.txt tox.ini fixtures/__init__.py fixtures/callmany.py diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures.egg-info/pbr.json new/fixtures-3.0.0/fixtures.egg-info/pbr.json --- old/fixtures-1.3.1/fixtures.egg-info/pbr.json 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/fixtures.egg-info/pbr.json 2016-05-20 01:03:06.000000000 +0200 @@ -1 +1 @@ -{"is_release": true, "git_version": "09afde5"} \ No newline at end of file +{"is_release": true, "git_version": "c2c28a1"} \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/fixtures.egg-info/requires.txt new/fixtures-3.0.0/fixtures.egg-info/requires.txt --- old/fixtures-1.3.1/fixtures.egg-info/requires.txt 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/fixtures.egg-info/requires.txt 2016-05-20 01:03:06.000000000 +0200 @@ -1,3 +1,9 @@ pbr>=0.11 six testtools>=0.9.22 + +[docs] +docutils + +[test] +mock diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/setup.cfg new/fixtures-3.0.0/setup.cfg --- old/fixtures-1.3.1/setup.cfg 2015-06-30 04:22:04.000000000 +0200 +++ new/fixtures-3.0.0/setup.cfg 2016-05-20 01:03:07.000000000 +0200 @@ -24,6 +24,12 @@ [bdist_wheel] universal = 1 +[extras] +test = + mock +docs = + docutils + [egg_info] tag_build = tag_date = 0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/setup.py new/fixtures-3.0.0/setup.py --- old/fixtures-1.3.1/setup.py 2014-09-25 04:43:13.000000000 +0200 +++ new/fixtures-3.0.0/setup.py 2016-05-18 05:46:25.000000000 +0200 @@ -3,5 +3,5 @@ import setuptools setuptools.setup( - setup_requires=['pbr'], + setup_requires=['pbr>0.11'], pbr=True) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/test-requirements.txt new/fixtures-3.0.0/test-requirements.txt --- old/fixtures-1.3.1/test-requirements.txt 2015-06-22 02:24:03.000000000 +0200 +++ new/fixtures-3.0.0/test-requirements.txt 1970-01-01 01:00:00.000000000 +0100 @@ -1 +0,0 @@ -mock;python_version<'3.3' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/fixtures-1.3.1/tox.ini new/fixtures-3.0.0/tox.ini --- old/fixtures-1.3.1/tox.ini 2015-06-22 01:52:32.000000000 +0200 +++ new/fixtures-3.0.0/tox.ini 2016-03-23 23:55:38.000000000 +0100 @@ -1,5 +1,5 @@ [tox] -envlist = py27 +envlist = py26,py27,py32,py33,py34,py35,pypy,pypy3 minversion = 1.6 skipsdist = True @@ -8,5 +8,5 @@ install_command = pip install -U {opts} {packages} setenv = VIRTUAL_ENV={envdir} whitelist_externals = make -deps = -r{toxinidir}/requirements.txt +deps = .[docs,test] commands = make check
