format source using black

1 files changed, 83 insertions, 45 deletions

diff --git a/tests/test_predicates.py b/tests/test_predicates.py
index da0b44708..c072b4229 100644
--- a/tests/test_predicates.py
+++ b/tests/test_predicates.py
@@ -4,18 +4,20 @@ from pyramid import testing
 
 from pyramid.compat import text_
 
+
 class TestXHRPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import XHRPredicate
+
         return XHRPredicate(val, None)
-    
+
     def test___call___true(self):
         inst = self._makeOne(True)
         request = Dummy()
         request.is_xhr = True
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___false(self):
         inst = self._makeOne(True)
         request = Dummy()
@@ -31,60 +33,65 @@ class TestXHRPredicate(unittest.TestCase):
         inst = self._makeOne(True)
         self.assertEqual(inst.phash(), 'xhr = True')
 
+
 class TestRequestMethodPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import RequestMethodPredicate
+
         return RequestMethodPredicate(val, None)
 
     def test_ctor_get_but_no_head(self):
         inst = self._makeOne('GET')
         self.assertEqual(inst.val, ('GET', 'HEAD'))
-    
+
     def test___call___true_single(self):
         inst = self._makeOne('GET')
         request = Dummy()
         request.method = 'GET'
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___true_multi(self):
-        inst = self._makeOne(('GET','HEAD'))
+        inst = self._makeOne(('GET', 'HEAD'))
         request = Dummy()
         request.method = 'GET'
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___false(self):
-        inst = self._makeOne(('GET','HEAD'))
+        inst = self._makeOne(('GET', 'HEAD'))
         request = Dummy()
         request.method = 'POST'
         result = inst(None, request)
         self.assertFalse(result)
 
     def test_text(self):
-        inst = self._makeOne(('HEAD','GET'))
+        inst = self._makeOne(('HEAD', 'GET'))
         self.assertEqual(inst.text(), 'request_method = GET,HEAD')
 
     def test_phash(self):
-        inst = self._makeOne(('HEAD','GET'))
+        inst = self._makeOne(('HEAD', 'GET'))
         self.assertEqual(inst.phash(), 'request_method = GET,HEAD')
 
+
 class TestPathInfoPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import PathInfoPredicate
+
         return PathInfoPredicate(val, None)
 
     def test_ctor_compilefail(self):
         from pyramid.exceptions import ConfigurationError
+
         self.assertRaises(ConfigurationError, self._makeOne, '\\')
-    
+
     def test___call___true(self):
         inst = self._makeOne(r'/\d{2}')
         request = Dummy()
         request.upath_info = text_('/12')
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___false(self):
         inst = self._makeOne(r'/\d{2}')
         request = Dummy()
@@ -100,36 +107,38 @@ class TestPathInfoPredicate(unittest.TestCase):
         inst = self._makeOne('/')
         self.assertEqual(inst.phash(), 'path_info = /')
 
+
 class TestRequestParamPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import RequestParamPredicate
+
         return RequestParamPredicate(val, None)
 
     def test___call___true_exists(self):
         inst = self._makeOne('abc')
         request = Dummy()
-        request.params = {'abc':1}
+        request.params = {'abc': 1}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_withval(self):
         inst = self._makeOne('abc=1')
         request = Dummy()
-        request.params = {'abc':'1'}
+        request.params = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_multi(self):
         inst = self._makeOne(('abc', '=def =2= '))
         request = Dummy()
-        request.params = {'abc':'1', '=def': '2='}
+        request.params = {'abc': '1', '=def': '2='}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___false_multi(self):
         inst = self._makeOne(('abc=3', 'def =2 '))
         request = Dummy()
-        request.params = {'abc':'3', 'def': '1'}
+        request.params = {'abc': '3', 'def': '1'}
         result = inst(None, request)
         self.assertFalse(result)
 
@@ -172,26 +181,27 @@ class TestRequestParamPredicate(unittest.TestCase):
         inst = self._makeOne('abc=   1')
         self.assertEqual(inst.phash(), "request_param abc=1")
 
+
 class TestMatchParamPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import MatchParamPredicate
+
         return MatchParamPredicate(val, None)
 
     def test___call___true_single(self):
         inst = self._makeOne('abc=1')
         request = Dummy()
-        request.matchdict = {'abc':'1'}
+        request.matchdict = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
-
     def test___call___true_multi(self):
         inst = self._makeOne(('abc=1', 'def=2'))
         request = Dummy()
-        request.matchdict = {'abc':'1', 'def':'2'}
+        request.matchdict = {'abc': '1', 'def': '2'}
         result = inst(None, request)
         self.assertTrue(result)
-        
+
     def test___call___false(self):
         inst = self._makeOne('abc=1')
         request = Dummy()
@@ -214,9 +224,11 @@ class TestMatchParamPredicate(unittest.TestCase):
         inst = self._makeOne(('def=  1', 'abc =2'))
         self.assertEqual(inst.phash(), 'match_param abc=2,def=1')
 
+
 class TestCustomPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import CustomPredicate
+
         return CustomPredicate(val, None)
 
     def test___call___true(self):
@@ -224,15 +236,17 @@ class TestCustomPredicate(unittest.TestCase):
             self.assertEqual(context, None)
             self.assertEqual(request, None)
             return True
+
         inst = self._makeOne(func)
         result = inst(None, None)
         self.assertTrue(result)
-    
+
     def test___call___false(self):
         def func(context, request):
             self.assertEqual(context, None)
             self.assertEqual(request, None)
             return False
+
         inst = self._makeOne(func)
         result = inst(None, None)
         self.assertFalse(result)
@@ -242,7 +256,7 @@ class TestCustomPredicate(unittest.TestCase):
         pred.__text__ = 'text'
         inst = self._makeOne(pred)
         self.assertEqual(inst.text(), 'text')
-         
+
     def test_text_func_repr(self):
         pred = predicate()
         inst = self._makeOne(pred)
@@ -253,39 +267,44 @@ class TestCustomPredicate(unittest.TestCase):
         inst = self._makeOne(pred)
         self.assertEqual(inst.phash(), 'custom:1')
 
+
 class TestTraversePredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import TraversePredicate
+
         return TraversePredicate(val, None)
-    
+
     def test___call__traverse_has_remainder_already(self):
         inst = self._makeOne('/1/:a/:b')
-        info = {'traverse':'abc'}
+        info = {'traverse': 'abc'}
         request = Dummy()
         result = inst(info, request)
         self.assertEqual(result, True)
-        self.assertEqual(info, {'traverse':'abc'})
+        self.assertEqual(info, {'traverse': 'abc'})
 
     def test___call__traverse_matches(self):
         inst = self._makeOne('/1/:a/:b')
-        info = {'match':{'a':'a', 'b':'b'}}
+        info = {'match': {'a': 'a', 'b': 'b'}}
         request = Dummy()
         result = inst(info, request)
         self.assertEqual(result, True)
-        self.assertEqual(info, {'match':
-                                {'a':'a', 'b':'b', 'traverse':('1', 'a', 'b')}})
+        self.assertEqual(
+            info, {'match': {'a': 'a', 'b': 'b', 'traverse': ('1', 'a', 'b')}}
+        )
 
     def test___call__traverse_matches_with_highorder_chars(self):
         inst = self._makeOne(text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8'))
-        info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}}
+        info = {'match': {'x': text_(b'Qu\xc3\xa9bec', 'utf-8')}}
         request = Dummy()
         result = inst(info, request)
         self.assertEqual(result, True)
         self.assertEqual(
             info['match']['traverse'],
-            (text_(b'La Pe\xc3\xb1a', 'utf-8'),
-             text_(b'Qu\xc3\xa9bec', 'utf-8'))
-             )
+            (
+                text_(b'La Pe\xc3\xb1a', 'utf-8'),
+                text_(b'Qu\xc3\xa9bec', 'utf-8'),
+            ),
+        )
 
     def test_text(self):
         inst = self._makeOne('/abc')
@@ -295,9 +314,11 @@ class TestTraversePredicate(unittest.TestCase):
         inst = self._makeOne('/abc')
         self.assertEqual(inst.phash(), '')
 
+
 class Test_CheckCSRFTokenPredicate(unittest.TestCase):
     def _makeOne(self, val, config):
         from pyramid.predicates import CheckCSRFTokenPredicate
+
         return CheckCSRFTokenPredicate(val, config)
 
     def test_text(self):
@@ -307,28 +328,32 @@ class Test_CheckCSRFTokenPredicate(unittest.TestCase):
     def test_phash(self):
         inst = self._makeOne(True, None)
         self.assertEqual(inst.phash(), 'check_csrf = True')
-        
+
     def test_it_call_val_True(self):
         inst = self._makeOne(True, None)
         request = Dummy()
+
         def check_csrf_token(req, val, raises=True):
             self.assertEqual(req, request)
             self.assertEqual(val, 'csrf_token')
             self.assertEqual(raises, False)
             return True
-        inst.check_csrf_token  = check_csrf_token
+
+        inst.check_csrf_token = check_csrf_token
         result = inst(None, request)
         self.assertEqual(result, True)
 
     def test_it_call_val_str(self):
         inst = self._makeOne('abc', None)
         request = Dummy()
+
         def check_csrf_token(req, val, raises=True):
             self.assertEqual(req, request)
             self.assertEqual(val, 'abc')
             self.assertEqual(raises, False)
             return True
-        inst.check_csrf_token  = check_csrf_token
+
+        inst.check_csrf_token = check_csrf_token
         result = inst(None, request)
         self.assertEqual(result, True)
 
@@ -338,36 +363,38 @@ class Test_CheckCSRFTokenPredicate(unittest.TestCase):
         result = inst(None, request)
         self.assertEqual(result, True)
 
+
 class TestHeaderPredicate(unittest.TestCase):
     def _makeOne(self, val):
         from pyramid.predicates import HeaderPredicate
+
         return HeaderPredicate(val, None)
 
     def test___call___true_exists(self):
         inst = self._makeOne('abc')
         request = Dummy()
-        request.headers = {'abc':1}
+        request.headers = {'abc': 1}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_withval(self):
         inst = self._makeOne('abc:1')
         request = Dummy()
-        request.headers = {'abc':'1'}
+        request.headers = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___true_withregex(self):
         inst = self._makeOne(r'abc:\d+')
         request = Dummy()
-        request.headers = {'abc':'1'}
+        request.headers = {'abc': '1'}
         result = inst(None, request)
         self.assertTrue(result)
 
     def test___call___false_withregex(self):
         inst = self._makeOne(r'abc:\d+')
         request = Dummy()
-        request.headers = {'abc':'a'}
+        request.headers = {'abc': 'a'}
         result = inst(None, request)
         self.assertFalse(result)
 
@@ -402,9 +429,11 @@ class TestHeaderPredicate(unittest.TestCase):
         inst = self._makeOne(r'abc:\d+')
         self.assertEqual(inst.phash(), r'header abc=\d+')
 
+
 class Test_PhysicalPathPredicate(unittest.TestCase):
     def _makeOne(self, val, config):
         from pyramid.predicates import PhysicalPathPredicate
+
         return PhysicalPathPredicate(val, config)
 
     def test_text(self):
@@ -414,7 +443,7 @@ class Test_PhysicalPathPredicate(unittest.TestCase):
     def test_phash(self):
         inst = self._makeOne('/', None)
         self.assertEqual(inst.phash(), "physical_path = ('',)")
-        
+
     def test_it_call_val_tuple_True(self):
         inst = self._makeOne(('', 'abc'), None)
         root = Dummy()
@@ -460,31 +489,34 @@ class Test_PhysicalPathPredicate(unittest.TestCase):
         context = Dummy()
         self.assertFalse(inst(context, None))
 
+
 class Test_EffectivePrincipalsPredicate(unittest.TestCase):
     def setUp(self):
         self.config = testing.setUp()
 
     def tearDown(self):
         testing.tearDown()
-        
+
     def _makeOne(self, val, config):
         from pyramid.predicates import EffectivePrincipalsPredicate
+
         return EffectivePrincipalsPredicate(val, config)
 
     def test_text(self):
         inst = self._makeOne(('verna', 'fred'), None)
-        self.assertEqual(inst.text(),
-                         "effective_principals = ['fred', 'verna']")
+        self.assertEqual(
+            inst.text(), "effective_principals = ['fred', 'verna']"
+        )
 
     def test_text_noniter(self):
         inst = self._makeOne('verna', None)
-        self.assertEqual(inst.text(),
-                         "effective_principals = ['verna']")
+        self.assertEqual(inst.text(), "effective_principals = ['verna']")
 
     def test_phash(self):
         inst = self._makeOne(('verna', 'fred'), None)
-        self.assertEqual(inst.phash(),
-                         "effective_principals = ['fred', 'verna']")
+        self.assertEqual(
+            inst.phash(), "effective_principals = ['fred', 'verna']"
+        )
 
     def test_it_call_no_authentication_policy(self):
         request = testing.DummyRequest()
@@ -501,6 +533,7 @@ class Test_EffectivePrincipalsPredicate(unittest.TestCase):
 
     def test_it_call_authentication_policy_provides_superset_implicit(self):
         from pyramid.security import Authenticated
+
         request = testing.DummyRequest()
         self.config.testing_securitypolicy('fred', groupids=('verna', 'bambi'))
         inst = self._makeOne(Authenticated, None)
@@ -518,6 +551,7 @@ class Test_EffectivePrincipalsPredicate(unittest.TestCase):
 class TestNotted(unittest.TestCase):
     def _makeOne(self, predicate):
         from pyramid.predicates import Notted
+
         return Notted(predicate)
 
     def test_it_with_phash_val(self):
@@ -534,15 +568,19 @@ class TestNotted(unittest.TestCase):
         self.assertEqual(inst.phash(), '')
         self.assertEqual(inst(None, None), True)
 
+
 class predicate(object):
     def __repr__(self):
         return 'predicate'
+
     def __hash__(self):
         return 1
 
+
 class Dummy(object):
     pass
 
+
 class DummyPredicate(object):
     def __init__(self, result):
         self.result = result