Merge lp:~gnuoy/ubuntu/utopic/python-logutils/fix-tests into lp:ubuntu/utopic/python-logutils

[Liam Young]

[James Page (james-page)]

review: Needs Fixing

[lp:~gnuoy/ubuntu/utopic/python-logutils/fix-tests]

4. By Liam Young on 2014-07-16

* Fix series in changelog
* Improve changelog description by referencing changed files
* Add dep3 Forwarded field now a pull request has been submitted for these changes

[Liam Young (gnuoy)]

Thanks for the feedback. I've submitted the fixes upstream and updated the branch with your recommendations.

review: Needs Resubmitting

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2014-01-09 14:31:16 +0000
+++ .pc/applied-patches	2014-07-16 11:40:18 +0000
@@ -1,1 +1,3 @@
 no-network-access-during-doc-build.patch
+test-failures-fatal.patch
+fix-dictconf-tests-on-python3.patch

=== added directory '.pc/fix-dictconf-tests-on-python3.patch'
=== added file '.pc/fix-dictconf-tests-on-python3.patch/.timestamp'
=== added directory '.pc/fix-dictconf-tests-on-python3.patch/tests'
=== added file '.pc/fix-dictconf-tests-on-python3.patch/tests/test_dictconfig.py'
--- .pc/fix-dictconf-tests-on-python3.patch/tests/test_dictconfig.py	1970-01-01 00:00:00 +0000
+++ .pc/fix-dictconf-tests-on-python3.patch/tests/test_dictconfig.py	2014-07-16 11:40:18 +0000
@@ -0,0 +1,688 @@
+#
+# Copyright 2009-2013 by Vinay Sajip. See LICENSE.txt for details.
+#
+import logging
+from logutils.adapter import LoggerAdapter
+from logutils.dictconfig import dictConfig, named_handlers_supported
+from logutils.testing import TestHandler, Matcher
+import sys
+import unittest
+
+try:
+    StandardError
+except NameError:
+    StandardError = Exception
+
+class ExceptionFormatter(logging.Formatter):
+    """A special exception formatter."""
+    def formatException(self, ei):
+        return "Got a [%s]" % ei[0].__name__
+
+def formatFunc(format, datefmt=None):
+    return logging.Formatter(format, datefmt)
+
+def testHandler():
+    return TestHandler(Matcher())
+
+def handlerFunc():
+    return logging.StreamHandler()
+
+class CustomHandler(logging.StreamHandler):
+    pass
+
+class ConfigDictTest(unittest.TestCase):
+
+    """Reading logging config from a dictionary."""
+
+    def setUp(self):
+        self.logger = l = logging.getLogger()
+        self.adapter = LoggerAdapter(l, {})
+
+        logger_dict = logging.getLogger().manager.loggerDict
+        logging._acquireLock()
+        try:
+            self.saved_handlers = logging._handlers.copy()
+            self.saved_handler_list = logging._handlerList[:]
+            self.saved_loggers = logger_dict.copy()
+            self.saved_level_names = logging._levelNames.copy()
+        finally:
+            logging._releaseLock()
+
+        self.root_logger = logging.getLogger("")
+        self.original_logging_level = self.root_logger.getEffectiveLevel()
+
+
+    def tearDown(self):
+        self.root_logger.setLevel(self.original_logging_level)
+        logging._acquireLock()
+        try:
+            logging._levelNames.clear()
+            logging._levelNames.update(self.saved_level_names)
+            logging._handlers.clear()
+            logging._handlers.update(self.saved_handlers)
+            logging._handlerList[:] = self.saved_handler_list
+            loggerDict = logging.getLogger().manager.loggerDict
+            loggerDict.clear()
+            loggerDict.update(self.saved_loggers)
+        finally:
+            logging._releaseLock()
+
+    message_num = 0
+
+    def next_message(self):
+        """Generate a message consisting solely of an auto-incrementing
+        integer."""
+        self.message_num += 1
+        return "%d" % self.message_num
+
+    # config0 is a standard configuration.
+    config0 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'root' : {
+            'level' : 'WARNING',
+            'handlers' : ['hand1'],
+        },
+    }
+
+    # config1 adds a little to the standard configuration.
+    config1 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    # config2 has a subtle configuration error that should be reported
+    config2 = {
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                'class' : 'logging.StreamHandler',
+                'formatter' : 'form1',
+                'level' : 'NOTSET',
+                'stream'  : 'ext://sys.stdbout',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    #As config1 but with a misspelt level on a handler
+    config2a = {
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                'class' : 'logging.StreamHandler',
+                'formatter' : 'form1',
+                'level' : 'NTOSET',
+                'stream'  : 'ext://sys.stdout',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+
+    #As config1 but with a misspelt level on a logger
+    config2b = {
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                'class' : 'logging.StreamHandler',
+                'formatter' : 'form1',
+                'level' : 'NOTSET',
+                'stream'  : 'ext://sys.stdout',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WRANING',
+        },
+    } 
+
+    # config3 has a less subtle configuration error
+    config3 = {
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                'class' : 'logging.StreamHandler',
+                'formatter' : 'misspelled_name',
+                'level' : 'NOTSET',
+                'stream'  : 'ext://sys.stdout',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    # config4 specifies a custom formatter class to be loaded
+    config4 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                '()' : __name__ + '.ExceptionFormatter',
+                'format' : '%(levelname)s:%(name)s:%(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'root' : {
+            'level' : 'NOTSET',
+                'handlers' : ['hand1'],
+        },
+    } 
+
+    # As config4 but using an actual callable rather than a string
+    config4a = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                '()' : ExceptionFormatter,
+                'format' : '%(levelname)s:%(name)s:%(message)s',
+            },
+            'form2' : {
+                '()' : __name__ + '.formatFunc',
+                'format' : '%(levelname)s:%(name)s:%(message)s',
+            },
+            'form3' : {
+                '()' : formatFunc,
+                'format' : '%(levelname)s:%(name)s:%(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            },
+            'hand2' : {
+                '()' : handlerFunc,
+            },
+        },
+        'root' : {
+            'level' : 'NOTSET',
+                'handlers' : ['hand1'],
+        },
+    } 
+
+    # config5 specifies a custom handler class to be loaded
+    config5 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    # config6 specifies a custom handler class to be loaded
+    # but has bad arguments
+    config6 = {
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                'class' : __name__ + '.CustomHandler',
+                'formatter' : 'form1',
+                'level' : 'NOTSET',
+                'stream'  : 'ext://sys.stdout',
+                '9' : 'invalid parameter name',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    #config 7 does not define compiler.parser but defines compiler.lexer
+    #so compiler.parser should be disabled after applying it
+    config7 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'loggers' : {
+            'compiler.lexer' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    config8 = {
+        'version': 1,
+        'disable_existing_loggers' : False,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'loggers' : {
+            'compiler' : {
+                'level' : 'DEBUG',
+                'handlers' : ['hand1'],
+            },
+            'compiler.lexer' : {
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+        },
+    } 
+
+    config9 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+            }
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'WARNING',
+                'handlers' : ['hand1'],
+            },
+        },
+        'root' : {
+            'level' : 'NOTSET',
+        },
+    } 
+
+    config9a = {
+        'version': 1,
+        'incremental' : True,
+        'handlers' : {
+            'hand1' : {
+                'level' : 'WARNING',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'INFO',
+            },
+        },
+    } 
+
+    config9b = {
+        'version': 1,
+        'incremental' : True,
+        'handlers' : {
+            'hand1' : {
+                'level' : 'INFO',
+            },
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'INFO',
+            },
+        },
+    } 
+
+    #As config1 but with a filter added
+    config10 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'filters' : {
+            'filt1' : {
+                'name' : 'compiler.parser',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': testHandler,
+                'formatter': 'form1',
+                'filters' : ['filt1'],
+            }
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'filters' : ['filt1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+            'handlers' : ['hand1'],
+        },
+    } 
+
+    # As config10, but declaring a handler in a module using
+    # absolute imports
+    config11 = {
+        'version': 1,
+        'formatters': {
+            'form1' : {
+                'format' : '%(levelname)s ++ %(message)s',
+            },
+        },
+        'filters' : {
+            'filt1' : {
+                'name' : 'compiler.parser',
+            },
+        },
+        'handlers' : {
+            'hand1' : {
+                '()': 'mytest.MyTestHandler',
+                'formatter': 'form1',
+                'filters' : ['filt1'],
+            }
+        },
+        'loggers' : {
+            'compiler.parser' : {
+                'level' : 'DEBUG',
+                'filters' : ['filt1'],
+            },
+        },
+        'root' : {
+            'level' : 'WARNING',
+            'handlers' : ['hand1'],
+        },
+    } 
+
+    def apply_config(self, conf):
+        dictConfig(conf)
+
+    def test_config0_ok(self):
+        # A simple config which overrides the default settings.
+        self.apply_config(self.config0)
+        logger = logging.getLogger()
+        # Won't output anything
+        logger.info(self.next_message())
+        # Outputs a message
+        logger.error(self.next_message())
+        h = logger.handlers[0]
+        self.assertEqual(1, h.count)
+        self.assertTrue(h.matchall([
+                            dict(levelname='ERROR', message='2')
+                        ]))
+
+    def test_config1_ok(self, config=config1):
+        # A config defining a sub-parser as well.
+        self.apply_config(config)
+        logger = logging.getLogger("compiler.parser")
+        # Both will output a message
+        logger.info(self.next_message())
+        logger.error(self.next_message())
+        h = logger.handlers[0]
+        self.assertTrue(h.matchall([
+                            dict(levelname='INFO', message='1'),
+                            dict(levelname='ERROR', message='2'),
+                        ]))
+
+    def test_config2_failure(self):
+        # A simple config which overrides the default settings.
+        self.assertRaises(StandardError, self.apply_config, self.config2)
+
+    def test_config2a_failure(self):
+        # A simple config which overrides the default settings.
+        self.assertRaises(StandardError, self.apply_config, self.config2a)
+
+    def test_config2b_failure(self):
+        # A simple config which overrides the default settings.
+        self.assertRaises(StandardError, self.apply_config, self.config2b)
+
+    def test_config3_failure(self):
+        # A simple config which overrides the default settings.
+        self.assertRaises(StandardError, self.apply_config, self.config3)
+
+    def test_config4_ok(self):
+        # A config specifying a custom formatter class.
+        self.apply_config(self.config4)
+        logger = logging.getLogger()
+        h = logger.handlers[0]
+        try:
+            raise RuntimeError()
+        except RuntimeError:
+            logging.exception("just testing")
+        self.assertEquals(h.formatted[0],
+            "ERROR:root:just testing\nGot a [RuntimeError]")
+
+    def test_config4a_ok(self):
+        # A config specifying a custom formatter class.
+        self.apply_config(self.config4a)
+        logger = logging.getLogger()
+        h = logger.handlers[0]
+        try:
+            raise RuntimeError()
+        except RuntimeError:
+            logging.exception("just testing")
+        self.assertEquals(h.formatted[0],
+            "ERROR:root:just testing\nGot a [RuntimeError]")
+
+    def test_config5_ok(self):
+        self.test_config1_ok(config=self.config5)
+
+    def test_config6_failure(self):
+        self.assertRaises(StandardError, self.apply_config, self.config6)
+
+    def test_config7_ok(self):
+        self.apply_config(self.config1)
+        logger = logging.getLogger("compiler.parser")
+        # Both will output a message
+        logger.info(self.next_message())
+        logger.error(self.next_message())
+        h = logger.handlers[0]
+        self.assertTrue(h.matchall([
+                            dict(levelname='INFO', message='1'),
+                            dict(levelname='ERROR', message='2'),
+                        ]))
+        self.apply_config(self.config7)
+        logger = logging.getLogger("compiler.parser")
+        self.assertTrue(logger.disabled)
+        logger = logging.getLogger("compiler.lexer")
+        # Both will output a message
+        h = logger.handlers[0]
+        logger.info(self.next_message())
+        logger.error(self.next_message())
+        self.assertTrue(h.matchall([
+                            dict(levelname='INFO', message='3'),
+                            dict(levelname='ERROR', message='4'),
+                        ]))
+
+    #Same as test_config_7_ok but don't disable old loggers.
+    def test_config_8_ok(self):
+        self.apply_config(self.config1)
+        logger = logging.getLogger("compiler.parser")
+        # Both will output a message
+        logger.info(self.next_message())
+        logger.error(self.next_message())
+        h = logger.handlers[0]
+        self.assertTrue(h.matchall([
+                            dict(levelname='INFO', message='1'),
+                            dict(levelname='ERROR', message='2'),
+                        ]))
+        self.apply_config(self.config8)
+        logger = logging.getLogger("compiler.parser")
+        self.assertFalse(logger.disabled)
+        toplogger = logging.getLogger("compiler")
+        # Both will output a message
+        logger.info(self.next_message())
+        logger.error(self.next_message())
+        logger = logging.getLogger("compiler.lexer")
+        # Both will output a message
+        logger.info(self.next_message())
+        logger.error(self.next_message())
+        h = toplogger.handlers[0]
+        self.assertTrue(h.matchall([
+                            dict(levelname='INFO', message='3'),
+                            dict(levelname='ERROR', message='4'),
+                            dict(levelname='INFO', message='5'),
+                            dict(levelname='ERROR', message='6'),
+                        ]))
+
+    def test_config_9_ok(self):
+        self.apply_config(self.config9)
+        logger = logging.getLogger("compiler.parser")
+        #Nothing will be output since both handler and logger are set to WARNING
+        logger.info(self.next_message())
+        h = logger.handlers[0]
+        self.assertEqual(0, h.count)
+        self.apply_config(self.config9a)
+        #Nothing will be output since both handler is still set to WARNING
+        logger.info(self.next_message())
+        h = logger.handlers[0]
+        nhs = named_handlers_supported()
+        if nhs:
+            self.assertEqual(0, h.count)
+        else:
+            self.assertEqual(1, h.count)
+        self.apply_config(self.config9b)
+        #Message should now be output
+        logger.info(self.next_message())
+        if nhs:
+            h = logger.handlers[0]
+            self.assertTrue(h.matchall([
+                                dict(levelname='INFO', message='3'),
+                            ]))
+        else:
+            self.assertEqual(2, h.count)
+
+    def test_config_10_ok(self):
+        self.apply_config(self.config10)
+        logger = logging.getLogger("compiler.parser")
+        logger.warning(self.next_message())
+        logger = logging.getLogger('compiler')
+        #Not output, because filtered
+        logger.warning(self.next_message())
+        logger = logging.getLogger('compiler.lexer')
+        #Not output, because filtered
+        logger.warning(self.next_message())
+        logger = logging.getLogger("compiler.parser.codegen")
+        #Output, as not filtered
+        logger.error(self.next_message())
+        h = logging.getLogger().handlers[0]
+        self.assertTrue(h.matchall([
+                            dict(levelname='WARNING', message='1'),
+                            dict(levelname='ERROR', message='4'),
+                        ]))
+ 
+    def test_config_11_ok(self):
+        self.apply_config(self.config11)
+        h = logging.getLogger().handlers[0]
+        self.assertEqual(h.__module__, 'mytest')
+        self.assertEqual(h.__class__.__name__, 'MyTestHandler')
+

=== added directory '.pc/test-failures-fatal.patch'
=== added file '.pc/test-failures-fatal.patch/.timestamp'
=== added file '.pc/test-failures-fatal.patch/setup.py'
--- .pc/test-failures-fatal.patch/setup.py	1970-01-01 00:00:00 +0000
+++ .pc/test-failures-fatal.patch/setup.py	2014-07-16 11:40:18 +0000
@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+
+import distutils.core
+import logutils
+from os.path import join, dirname, abspath
+import re
+
+
+def description():
+    f = open(join(dirname(__file__), 'README.txt'))
+    readme = f.read()
+    f.close()
+    regexp = r'^logutils\s*[\d.]*\s*\n=======+\s*\n(.*)Requirements '
+    reqts, = re.findall(regexp, readme, re.DOTALL)
+    regexp = r'Availability & Documentation\s*\n-----+\s*\n(.*)'
+    avail, = re.findall(regexp, readme, re.DOTALL)
+    return reqts + avail
+
+class TestCommand(distutils.core.Command):
+    user_options = []
+
+    def run(self):
+        import sys
+        import unittest
+        
+        sys.path.append(join(dirname(__file__), 'tests'))
+        import logutil_tests
+        loader = unittest.TestLoader()
+        runner = unittest.TextTestRunner()
+        runner.run(loader.loadTestsFromModule(logutil_tests))
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+distutils.core.setup(
+    name='logutils',
+    version=logutils.__version__,
+    author='Vinay Sajip',
+    author_email='[e-mail]',
+    url='http://code.google.com/p/logutils/',
+    description='Logging utilities',
+    long_description = description(),
+    license='Copyright (C) 2010-2013 by Vinay Sajip. All Rights Reserved. See LICENSE.txt for license.',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Console',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: BSD License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 3",
+        'Topic :: Software Development',
+    ],
+    packages=['logutils'],
+    cmdclass={
+        'test': TestCommand,
+    },
+    
+)

=== modified file 'debian/changelog'
--- debian/changelog	2014-01-09 14:31:16 +0000
+++ debian/changelog	2014-07-16 11:40:18 +0000
@@ -1,3 +1,10 @@
+python-logutils (0.3.3-1ubuntu1) utopic; urgency=medium
+
+  * d/p/test-failures-fatal.patch: Make unit test failures fatal to build 
+  * d/p/fix-dictconf-tests-on-python3.patch: Fix tests failing with python3.
+
+ -- Liam Young <[e-mail]>  Fri, 04 Jul 2014 13:44:06 +0100
+
 python-logutils (0.3.3-1) unstable; urgency=medium
 
   * Initial release. (Closes: #734687)

=== added file 'debian/patches/fix-dictconf-tests-on-python3.patch'
--- debian/patches/fix-dictconf-tests-on-python3.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix-dictconf-tests-on-python3.patch	2014-07-16 11:40:18 +0000
@@ -0,0 +1,45 @@
+Description: Make refernces to _levelNames python2 specific as it does not exist in the python3 version of the module.
+Author: Liam Young <[e-mail]>
+Bug-Ubuntu: https://launchpad.net/bugs/1319909
+Forwarded: https://bitbucket.org/vinay.sajip/logutils/pull-request/1/fix-python3-tests-and-make-test-failures/diff
+Last-Update: 2014-07-04
+
+Index: python-logutils/tests/test_dictconfig.py
+===================================================================
+--- python-logutils.orig/tests/test_dictconfig.py
++++ python-logutils/tests/test_dictconfig.py
+@@ -27,6 +27,12 @@ def testHandler():
+ def handlerFunc():
+     return logging.StreamHandler()
+ 
++def is_python2():
++    if sys.version_info >= (2, 0) and sys.version_info < (3, 0):
++        return True
++    else:
++        return False
++
+ class CustomHandler(logging.StreamHandler):
+     pass
+ 
+@@ -44,7 +50,8 @@ class ConfigDictTest(unittest.TestCase):
+             self.saved_handlers = logging._handlers.copy()
+             self.saved_handler_list = logging._handlerList[:]
+             self.saved_loggers = logger_dict.copy()
+-            self.saved_level_names = logging._levelNames.copy()
++            if is_python2():
++                self.saved_level_names = logging._levelNames.copy()
+         finally:
+             logging._releaseLock()
+ 
+@@ -56,8 +63,9 @@ class ConfigDictTest(unittest.TestCase):
+         self.root_logger.setLevel(self.original_logging_level)
+         logging._acquireLock()
+         try:
+-            logging._levelNames.clear()
+-            logging._levelNames.update(self.saved_level_names)
++            if is_python2():
++                logging._levelNames.clear()
++                logging._levelNames.update(self.saved_level_names)
+             logging._handlers.clear()
+             logging._handlers.update(self.saved_handlers)
+             logging._handlerList[:] = self.saved_handler_list

=== modified file 'debian/patches/series'
--- debian/patches/series	2014-01-09 14:31:16 +0000
+++ debian/patches/series	2014-07-16 11:40:18 +0000
@@ -1,1 +1,3 @@
 no-network-access-during-doc-build.patch
+test-failures-fatal.patch
+fix-dictconf-tests-on-python3.patch

=== added file 'debian/patches/test-failures-fatal.patch'
--- debian/patches/test-failures-fatal.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/test-failures-fatal.patch	2014-07-16 11:40:18 +0000
@@ -0,0 +1,21 @@
+Description: Test failures should be fatal to the build process
+Author: Liam Young <[e-mail]>
+Bug-Ubuntu: https://launchpad.net/bugs/1319909
+Forwarded: https://bitbucket.org/vinay.sajip/logutils/pull-request/1/fix-python3-tests-and-make-test-failures/diff
+Last-Update: 2014-07-04
+
+Index: python-logutils/setup.py
+===================================================================
+--- python-logutils.orig/setup.py
++++ python-logutils/setup.py
+@@ -27,7 +27,9 @@ class TestCommand(distutils.core.Command
+         import logutil_tests
+         loader = unittest.TestLoader()
+         runner = unittest.TextTestRunner()
+-        runner.run(loader.loadTestsFromModule(logutil_tests))
++        test_results = runner.run(loader.loadTestsFromModule(logutil_tests))
++        if not test_results.wasSuccessful():
++            sys.exit(1)
+ 
+     def initialize_options(self):
+         pass

=== modified file 'setup.py'
--- setup.py	2014-01-09 14:31:16 +0000
+++ setup.py	2014-07-16 11:40:18 +0000
@@ -27,7 +27,9 @@
         import logutil_tests
         loader = unittest.TestLoader()
         runner = unittest.TextTestRunner()
-        runner.run(loader.loadTestsFromModule(logutil_tests))
+        test_results = runner.run(loader.loadTestsFromModule(logutil_tests))
+        if not test_results.wasSuccessful():
+            sys.exit(1)
 
     def initialize_options(self):
         pass

=== modified file 'tests/test_dictconfig.py'
--- tests/test_dictconfig.py	2014-01-09 14:31:16 +0000
+++ tests/test_dictconfig.py	2014-07-16 11:40:18 +0000
@@ -27,6 +27,12 @@
 def handlerFunc():
     return logging.StreamHandler()
 
+def is_python2():
+    if sys.version_info >= (2, 0) and sys.version_info < (3, 0):
+        return True
+    else:
+        return False
+
 class CustomHandler(logging.StreamHandler):
     pass
 
@@ -44,7 +50,8 @@
             self.saved_handlers = logging._handlers.copy()
             self.saved_handler_list = logging._handlerList[:]
             self.saved_loggers = logger_dict.copy()
-            self.saved_level_names = logging._levelNames.copy()
+            if is_python2():
+                self.saved_level_names = logging._levelNames.copy()
         finally:
             logging._releaseLock()
 
@@ -56,8 +63,9 @@
         self.root_logger.setLevel(self.original_logging_level)
         logging._acquireLock()
         try:
-            logging._levelNames.clear()
-            logging._levelNames.update(self.saved_level_names)
+            if is_python2():
+                logging._levelNames.clear()
+                logging._levelNames.update(self.saved_level_names)
             logging._handlers.clear()
             logging._handlers.update(self.saved_handlers)
             logging._handlerList[:] = self.saved_handler_list