1 files changed, 27 insertions, 6 deletions

diff --git a/tests/test_exceptions.py b/tests/test_exceptions.py
index 9cb0f58d1..399940c05 100644
--- a/tests/test_exceptions.py
+++ b/tests/test_exceptions.py
@@ -1,29 +1,37 @@
 import unittest
 
+
 class TestBWCompat(unittest.TestCase):
     def test_bwcompat_notfound(self):
         from pyramid.exceptions import NotFound as one
         from pyramid.httpexceptions import HTTPNotFound as two
+
         self.assertTrue(one is two)
 
     def test_bwcompat_forbidden(self):
         from pyramid.exceptions import Forbidden as one
         from pyramid.httpexceptions import HTTPForbidden as two
+
         self.assertTrue(one is two)
 
+
 class TestBadCSRFToken(unittest.TestCase):
     def test_response_equivalence(self):
         from pyramid.exceptions import BadCSRFToken
         from pyramid.httpexceptions import HTTPBadRequest
+
         self.assertTrue(isinstance(BadCSRFToken(), HTTPBadRequest))
 
+
 class TestNotFound(unittest.TestCase):
     def _makeOne(self, message):
         from pyramid.exceptions import NotFound
+
         return NotFound(message)
 
     def test_it(self):
         from pyramid.interfaces import IExceptionResponse
+
         e = self._makeOne('notfound')
         self.assertTrue(IExceptionResponse.providedBy(e))
         self.assertEqual(e.status, '404 Not Found')
@@ -32,15 +40,19 @@ class TestNotFound(unittest.TestCase):
     def test_response_equivalence(self):
         from pyramid.exceptions import NotFound
         from pyramid.httpexceptions import HTTPNotFound
+
         self.assertTrue(NotFound is HTTPNotFound)
 
+
 class TestForbidden(unittest.TestCase):
     def _makeOne(self, message):
         from pyramid.exceptions import Forbidden
+
         return Forbidden(message)
 
     def test_it(self):
         from pyramid.interfaces import IExceptionResponse
+
         e = self._makeOne('forbidden')
         self.assertTrue(IExceptionResponse.providedBy(e))
         self.assertEqual(e.status, '403 Forbidden')
@@ -49,18 +61,22 @@ class TestForbidden(unittest.TestCase):
     def test_response_equivalence(self):
         from pyramid.exceptions import Forbidden
         from pyramid.httpexceptions import HTTPForbidden
+
         self.assertTrue(Forbidden is HTTPForbidden)
 
+
 class TestConfigurationConflictError(unittest.TestCase):
     def _makeOne(self, conflicts):
         from pyramid.exceptions import ConfigurationConflictError
+
         return ConfigurationConflictError(conflicts)
 
     def test_str(self):
-        conflicts = {'a':('1', '2', '3'), 'b':('4', '5', '6')}
+        conflicts = {'a': ('1', '2', '3'), 'b': ('4', '5', '6')}
         exc = self._makeOne(conflicts)
-        self.assertEqual(str(exc),
-"""\
+        self.assertEqual(
+            str(exc),
+            """\
 Conflicting configuration actions
   For: a
     1
@@ -69,24 +85,29 @@ Conflicting configuration actions
   For: b
     4
     5
-    6""")
+    6""",
+        )
+
 
 class TestConfigurationExecutionError(unittest.TestCase):
     def _makeOne(self, etype, evalue, info):
         from pyramid.exceptions import ConfigurationExecutionError
+
         return ConfigurationExecutionError(etype, evalue, info)
 
     def test_str(self):
         exc = self._makeOne('etype', 'evalue', 'info')
         self.assertEqual(str(exc), 'etype: evalue\n  in:\n  info')
-        
+
+
 class TestCyclicDependencyError(unittest.TestCase):
     def _makeOne(self, cycles):
         from pyramid.exceptions import CyclicDependencyError
+
         return CyclicDependencyError(cycles)
 
     def test___str__(self):
-        exc = self._makeOne({'a':['c', 'd'], 'c':['a']})
+        exc = self._makeOne({'a': ['c', 'd'], 'c': ['a']})
         result = str(exc)
         self.assertTrue("'a' sorts before ['c', 'd']" in result)
         self.assertTrue("'c' sorts before ['a']" in result)