Merge lp:~jml/python-fixtures/normal-names-893539 into lp:~python-fixtures/python-fixtures/trunk

[Jonathan Lange]

This addresses bug 893539 by changing the three fixtures with "Fixture" in their name to not have Fixture in their name.

 EnvironmentVariableFixture => EnvironmentVariable
 LoggerFixture => FakeLogger
 PopenFixture => FakePopen

EnvironmentVariable is the one I really care about.

I did this by renaming the classes and providing exported aliases for the old names. All the docs have been updated for the new names.

=== modified file 'NEWS'
--- NEWS	2011-11-22 09:26:54 +0000
+++ NEWS	2011-11-25 17:48:24 +0000
@@ -8,7 +8,11 @@
 
 CHANGES:
 
-* EnvironmentVariableFixture now upcalls via super().
+* EnvironmentVariableFixture, LoggerFixture, PopenFixture renamed to
+  EnvironmentVariable, FakeLogger and FakePopen respectively. All are still
+  available under their old, deprecated names.  (Jonathan Lange, #893539)
+
+* EnvironmentVariable now upcalls via super().
   (Jonathan Lange, #881120)
 
 0.3.7
 
=== modified file 'README'
--- README	2011-11-22 10:07:24 +0000
+++ README	2011-11-25 17:48:24 +0000
@@ -266,21 +266,30 @@
 includes a number of precanned fixtures. The API docs for fixtures will list
 the complete set of these, should the dcs be out of date or not to hand.
 
-EnvironmentVariableFixture
-++++++++++++++++++++++++++
+EnvironmentVariable
++++++++++++++++++++
 
 Isolate your code from environmental variables, delete them or set them to a
 new value.
 
-  >>> fixture = fixtures.EnvironmentVariableFixture('HOME')
+  >>> fixture = fixtures.EnvironmentVariable('HOME')
 
-LoggerFixture
-+++++++++++++
+FakeLogger
+++++++++++
 
 Isolate your code from an external logging configuration - so that your test
 gets the output from logged messages, but they don't go to e.g. the console.
 
-  >>> fixture = fixtures.LoggerFixture()
+  >>> fixture = fixtures.FakeLogger()
+
+FakePopen
++++++++++
+
+Pretend to run an external command rather than needing it to be present to run
+tests.
+
+  >>> from testtools.compat import BytesIO
+  >>> fixture = fixtures.FakePopen(lambda _:{'stdout': BytesIO('foobar')})
 
 MonkeyPatch
 +++++++++++
@@ -300,15 +309,6 @@
 
   >>> fixture = fixtures.PackagePathEntry('package/name', '/foo/bar')
 
-PopenFixture
-++++++++++++
-
-Pretend to run an external command rather than needing it to be present to run
-tests.
-
-  >>> from testtools.compat import BytesIO
-  >>> fixture = fixtures.PopenFixture(lambda _:{'stdout': BytesIO('foobar')})
-
 PythonPackage
 +++++++++++++
 
 
=== modified file 'lib/fixtures/__init__.py'
--- lib/fixtures/__init__.py	2011-11-22 08:58:38 +0000
+++ lib/fixtures/__init__.py	2011-11-25 17:48:24 +0000
@@ -1,6 +1,6 @@
 #  fixtures: Fixtures with cleanups for testing and convenience.
 #
-# Copyright (c) 2010, Robert Collins <[e-mail]>
+# Copyright (c) 2010, 2011, Robert Collins <[e-mail]>
 # 
 # Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
 # license at the users choice. A copy of both licenses are available in the
@@ -39,7 +39,10 @@
 __version__ = (0, 3, 8, 'beta', 0)
 
 __all__ = [
+    'EnvironmentVariable',
     'EnvironmentVariableFixture',
+    'FakeLogger',
+    'FakePopen',
     'Fixture',
     'FunctionFixture',
     'LoggerFixture',
@@ -56,7 +59,10 @@
 
 from fixtures.fixture import Fixture, FunctionFixture, MethodFixture
 from fixtures._fixtures import (
+    EnvironmentVariable,
     EnvironmentVariableFixture,
+    FakeLogger,
+    FakePopen,
     LoggerFixture,
     MonkeyPatch,
     PackagePathEntry,
@@ -69,7 +75,6 @@
 
 
 def test_suite():
-    import unittest
     import fixtures.tests
     return fixtures.tests.test_suite()
 
 
=== modified file 'lib/fixtures/_fixtures/__init__.py'
--- lib/fixtures/_fixtures/__init__.py	2011-10-26 15:10:31 +0000
+++ lib/fixtures/_fixtures/__init__.py	2011-11-25 17:48:24 +0000
@@ -1,6 +1,6 @@
 #  fixtures: Fixtures with cleanups for testing and convenience.
 #
-# Copyright (c) 2010, Robert Collins <[e-mail]>
+# Copyright (c) 2010, 2011, Robert Collins <[e-mail]>
 # 
 # Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
 # license at the users choice. A copy of both licenses are available in the
@@ -17,7 +17,10 @@
 """Included fixtures."""
 
 __all__ = [
+    'EnvironmentVariable',
     'EnvironmentVariableFixture',
+    'FakeLogger',
+    'FakePopen',
     'LoggerFixture',
     'MonkeyPatch',
     'PackagePathEntry',
@@ -28,10 +31,19 @@
     ]
 
 
-from fixtures._fixtures.environ import EnvironmentVariableFixture
-from fixtures._fixtures.logger import LoggerFixture
+from fixtures._fixtures.environ import (
+    EnvironmentVariable,
+    EnvironmentVariableFixture,
+    )
+from fixtures._fixtures.logger import (
+    FakeLogger,
+    LoggerFixture,
+    )
 from fixtures._fixtures.monkeypatch import MonkeyPatch
-from fixtures._fixtures.popen import PopenFixture
+from fixtures._fixtures.popen import (
+    FakePopen,
+    PopenFixture,
+    )
 from fixtures._fixtures.packagepath import PackagePathEntry
 from fixtures._fixtures.pythonpackage import PythonPackage
 from fixtures._fixtures.pythonpath import PythonPathEntry
 
=== modified file 'lib/fixtures/_fixtures/environ.py'
--- lib/fixtures/_fixtures/environ.py	2011-10-31 16:30:52 +0000
+++ lib/fixtures/_fixtures/environ.py	2011-11-25 17:48:24 +0000
@@ -14,6 +14,7 @@
 # limitations under that license.
 
 __all__ = [
+    'EnvironmentVariable',
     'EnvironmentVariableFixture'
     ]
 
@@ -22,11 +23,11 @@
 from fixtures import Fixture
 
 
-class EnvironmentVariableFixture(Fixture):
+class EnvironmentVariable(Fixture):
     """Isolate a specific environment variable."""
 
     def __init__(self, varname, newvalue=None):
-        """Create an EnvironmentVariableFixture.
+        """Create an EnvironmentVariable fixture.
 
         :param varname: the name of the variable to isolate.
         :param newvalue: A value to set the variable to. If None, the variable
@@ -35,12 +36,12 @@
         During setup the variable will be deleted or assigned the requested
         value, and this will be restored in cleanUp.
         """
-        Fixture.__init__(self)
+        super(EnvironmentVariable, self).__init__()
         self.varname = varname
         self.newvalue = newvalue
 
     def setUp(self):
-        super(EnvironmentVariableFixture, self).setUp()
+        super(EnvironmentVariable, self).setUp()
         varname = self.varname
         orig_value = os.environ.get(varname)
         if orig_value is not None:
@@ -52,3 +53,6 @@
             os.environ[varname] = self.newvalue
         else:
             os.environ.pop(varname, '')
+
+
+EnvironmentVariableFixture = EnvironmentVariable
 
=== modified file 'lib/fixtures/_fixtures/logger.py'
--- lib/fixtures/_fixtures/logger.py	2011-11-22 08:58:59 +0000
+++ lib/fixtures/_fixtures/logger.py	2011-11-25 17:48:24 +0000
@@ -19,15 +19,16 @@
 from fixtures import Fixture
 
 __all__ = [
+    'FakeLogger',
     'LoggerFixture',
     ]
 
 
-class LoggerFixture(Fixture):
+class FakeLogger(Fixture):
     """Replace a logger and capture its output."""
 
     def __init__(self, name="", level=INFO, format=None, nuke_handlers=True):
-        """Create a LoggerFixture.
+        """Create a FakeLogger fixture.
 
         :param name: The name of the logger to replace. Defaults to "".
         :param level: The log level to set, defaults to INFO.
@@ -43,14 +44,14 @@
               logging.info('message')
               self.assertEqual('message', fixture.output)
         """
-        super(LoggerFixture, self).__init__()
+        super(FakeLogger, self).__init__()
         self._name = name
         self._level = level
         self._format = format
         self._nuke_handlers = nuke_handlers
 
     def setUp(self):
-        super(LoggerFixture, self).setUp()
+        super(FakeLogger, self).setUp()
         self._output = StringIO()
         logger = getLogger(self._name) 
         if self._level:
@@ -71,3 +72,6 @@
     @property
     def output(self):
         return self._output.getvalue()
+
+
+LoggerFixture = FakeLogger
 
=== modified file 'lib/fixtures/_fixtures/popen.py'
--- lib/fixtures/_fixtures/popen.py	2010-10-15 02:41:18 +0000
+++ lib/fixtures/_fixtures/popen.py	2011-11-25 17:48:24 +0000
@@ -1,6 +1,6 @@
 #  fixtures: Fixtures with cleanups for testing and convenience.
 #
-# Copyright (c) 2010, Robert Collins <[e-mail]>
+# Copyright (c) 2010, 2011, Robert Collins <[e-mail]>
 # 
 # Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
 # license at the users choice. A copy of both licenses are available in the
@@ -14,6 +14,7 @@
 # limitations under that license.
 
 __all__ = [
+    'FakePopen',
     'PopenFixture'
     ]
 
@@ -50,7 +51,7 @@
         return self.returncode
 
 
-class PopenFixture(Fixture):
+class FakePopen(Fixture):
     """Replace subprocess.Popen.
 
     Primarily useful for testing, this fixture replaces subprocess.Popen with a
@@ -67,10 +68,11 @@
             call, and should return a dict with any desired attributes.
             e.g. return {'stdin': StringIO('foobar')}
         """
+        super(FakePopen, self).__init__()
         self.get_info = get_info
 
     def setUp(self):
-        super(PopenFixture, self).setUp()
+        super(FakePopen, self).setUp()
         self.addCleanup(setattr, subprocess, 'Popen', subprocess.Popen)
         subprocess.Popen = self
         self.procs = []
@@ -83,3 +85,6 @@
         result = FakeProcess(proc_args, proc_info)
         self.procs.append(result)
         return result
+
+
+PopenFixture = FakePopen
 
=== modified file 'lib/fixtures/tests/_fixtures/test_environ.py'
--- lib/fixtures/tests/_fixtures/test_environ.py	2010-10-17 09:45:38 +0000
+++ lib/fixtures/tests/_fixtures/test_environ.py	2011-11-25 17:48:24 +0000
@@ -1,6 +1,6 @@
 #  fixtures: Fixtures with cleanups for testing and convenience.
 #
-# Copyright (c) 2010, Robert Collins <[e-mail]>
+# Copyright (c) 2010, 2011, Robert Collins <[e-mail]>
 # 
 # Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
 # license at the users choice. A copy of both licenses are available in the
@@ -17,59 +17,58 @@
 
 import testtools
 
-import fixtures
-from fixtures import EnvironmentVariableFixture, TestWithFixtures
-
-
-class TestEnvironmentVariableFixture(testtools.TestCase, TestWithFixtures):
+from fixtures import EnvironmentVariable, TestWithFixtures
+
+
+class TestEnvironmentVariable(testtools.TestCase, TestWithFixtures):
 
     def test_setup_ignores_missing(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR')
         os.environ.pop('FIXTURES_TEST_VAR', '')
         self.useFixture(fixture)
         self.assertEqual(None, os.environ.get('FIXTURES_TEST_VAR'))
 
     def test_setup_sets_when_missing(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR', 'bar')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR', 'bar')
         os.environ.pop('FIXTURES_TEST_VAR', '')
         self.useFixture(fixture)
         self.assertEqual('bar', os.environ.get('FIXTURES_TEST_VAR'))
 
     def test_setup_deletes(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR')
         os.environ['FIXTURES_TEST_VAR'] = 'foo'
         self.useFixture(fixture)
         self.assertEqual(None, os.environ.get('FIXTURES_TEST_VAR'))
 
     def test_setup_overrides(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR', 'bar')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR', 'bar')
         os.environ['FIXTURES_TEST_VAR'] = 'foo'
         self.useFixture(fixture)
         self.assertEqual('bar', os.environ.get('FIXTURES_TEST_VAR'))
 
     def test_cleanup_deletes_when_missing(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR')
         os.environ.pop('FIXTURES_TEST_VAR', '')
         with fixture:
             os.environ['FIXTURES_TEST_VAR'] = 'foo'
         self.assertEqual(None, os.environ.get('FIXTURES_TEST_VAR'))
         
     def test_cleanup_deletes_when_set(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR', 'bar')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR', 'bar')
         os.environ.pop('FIXTURES_TEST_VAR', '')
         with fixture:
             os.environ['FIXTURES_TEST_VAR'] = 'foo'
         self.assertEqual(None, os.environ.get('FIXTURES_TEST_VAR'))
 
     def test_cleanup_restores_when_missing(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR')
         os.environ['FIXTURES_TEST_VAR'] = 'bar'
         with fixture:
             os.environ.pop('FIXTURES_TEST_VAR', '')
         self.assertEqual('bar', os.environ.get('FIXTURES_TEST_VAR'))
         
     def test_cleanup_restores_when_set(self):
-        fixture = EnvironmentVariableFixture('FIXTURES_TEST_VAR')
+        fixture = EnvironmentVariable('FIXTURES_TEST_VAR')
         os.environ['FIXTURES_TEST_VAR'] = 'bar'
         with fixture:
             os.environ['FIXTURES_TEST_VAR'] = 'quux'
 
=== modified file 'lib/fixtures/tests/_fixtures/test_logger.py'
--- lib/fixtures/tests/_fixtures/test_logger.py	2011-11-22 08:12:48 +0000
+++ lib/fixtures/tests/_fixtures/test_logger.py	2011-11-25 17:48:24 +0000
@@ -18,13 +18,13 @@
 from testtools import TestCase
 from cStringIO import StringIO
 
-from fixtures import LoggerFixture, TestWithFixtures
-
-
-class LoggerFixtureTest(TestCase, TestWithFixtures):
+from fixtures import FakeLogger, TestWithFixtures
+
+
+class FakeLoggerTest(TestCase, TestWithFixtures):
 
     def setUp(self):
-        super(LoggerFixtureTest, self).setUp()
+        super(FakeLoggerTest, self).setUp()
         self.logger = logging.getLogger()
         self.addCleanup(self.removeHandlers, self.logger)
 
@@ -33,7 +33,7 @@
             logger.removeHandler(handler)
 
     def test_output_property_has_output(self):
-        fixture = self.useFixture(LoggerFixture())
+        fixture = self.useFixture(FakeLogger())
         logging.info("some message")
         self.assertEqual("some message\n", fixture.output)
 
@@ -43,7 +43,7 @@
         logger.addHandler(logging.StreamHandler(stream))
         logger.setLevel(logging.INFO)
         logging.info("one")
-        fixture = LoggerFixture()
+        fixture = FakeLogger()
         with fixture:
             logging.info("two")
         logging.info("three")
@@ -54,7 +54,7 @@
         stream = StringIO()
         self.logger.addHandler(logging.StreamHandler(stream))
         self.logger.setLevel(logging.INFO)
-        fixture = LoggerFixture(nuke_handlers=False)
+        fixture = FakeLogger(nuke_handlers=False)
         with fixture:
             logging.info("message")
         self.assertEqual("message\n", fixture.output)
@@ -62,7 +62,7 @@
 
     def test_logging_level_restored(self):
         self.logger.setLevel(logging.DEBUG)
-        fixture = LoggerFixture(level=logging.WARNING)
+        fixture = FakeLogger(level=logging.WARNING)
         with fixture:
             # The fixture won't capture this, because the DEBUG level
             # is lower than the WARNING one
@@ -72,7 +72,7 @@
         self.assertEqual(logging.DEBUG, self.logger.level)
 
     def test_custom_format(self):
-        fixture = LoggerFixture(format="%(module)s")
+        fixture = FakeLogger(format="%(module)s")
         self.useFixture(fixture)
         logging.info("message")
         self.assertEqual("test_logger\n", fixture.output)
 
=== modified file 'lib/fixtures/tests/_fixtures/test_popen.py'
--- lib/fixtures/tests/_fixtures/test_popen.py	2011-07-26 23:07:48 +0000
+++ lib/fixtures/tests/_fixtures/test_popen.py	2011-11-25 17:48:24 +0000
@@ -1,6 +1,6 @@
 #  fixtures: Fixtures with cleanups for testing and convenience.
 #
-# Copyright (c) 2010, Robert Collins <[e-mail]>
+# Copyright (c) 2010, 2011, Robert Collins <[e-mail]>
 # 
 # Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
 # license at the users choice. A copy of both licenses are available in the
@@ -21,15 +21,14 @@
     BytesIO,
     )
 
-import fixtures
-from fixtures import PopenFixture, TestWithFixtures
+from fixtures import FakePopen, TestWithFixtures
 from fixtures._fixtures.popen import FakeProcess
 
 
-class TestPopenFixture(testtools.TestCase, TestWithFixtures):
+class TestFakePopen(testtools.TestCase, TestWithFixtures):
 
     def test_installs_restores_global(self):
-        fixture = PopenFixture()
+        fixture = FakePopen()
         popen = subprocess.Popen
         fixture.setUp()
         try:
@@ -39,7 +38,7 @@
             self.assertEqual(subprocess.Popen, popen)
 
     def test___call___is_recorded(self):
-        fixture = self.useFixture(PopenFixture())
+        fixture = self.useFixture(FakePopen())
         proc = fixture(['foo', 'bar'], 1, None, 'in', 'out', 'err')
         self.assertEqual(1, len(fixture.procs))
         self.assertEqual(dict(args=['foo', 'bar'], bufsize=1, executable=None,
@@ -48,7 +47,7 @@
     def test_inject_content_stdout(self):
         def get_info(args):
             return {'stdout': 'stdout'}
-        fixture = self.useFixture(PopenFixture(get_info))
+        fixture = self.useFixture(FakePopen(get_info))
         proc = fixture(['foo'])
         self.assertEqual('stdout', proc.stdout)