move tests out of the package

1 files changed, 556 insertions, 0 deletions

diff --git a/tests/test_predicates.py b/tests/test_predicates.py
new file mode 100644
index 000000000..da0b44708
--- /dev/null
+++ b/tests/test_predicates.py
@@ -0,0 +1,556 @@
+import unittest
+
+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()
+        request.is_xhr = False
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test_text(self):
+        inst = self._makeOne(True)
+        self.assertEqual(inst.text(), 'xhr = True')
+
+    def test_phash(self):
+        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'))
+        request = Dummy()
+        request.method = 'GET'
+        result = inst(None, request)
+        self.assertTrue(result)
+
+    def test___call___false(self):
+        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'))
+        self.assertEqual(inst.text(), 'request_method = GET,HEAD')
+
+    def test_phash(self):
+        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()
+        request.upath_info = text_('/n12')
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test_text(self):
+        inst = self._makeOne('/')
+        self.assertEqual(inst.text(), 'path_info = /')
+
+    def test_phash(self):
+        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}
+        result = inst(None, request)
+        self.assertTrue(result)
+
+    def test___call___true_withval(self):
+        inst = self._makeOne('abc=1')
+        request = Dummy()
+        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='}
+        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'}
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test___call___false(self):
+        inst = self._makeOne('abc')
+        request = Dummy()
+        request.params = {}
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test_text_exists(self):
+        inst = self._makeOne('abc')
+        self.assertEqual(inst.text(), 'request_param abc')
+
+    def test_text_exists_equal_sign(self):
+        inst = self._makeOne('=abc')
+        self.assertEqual(inst.text(), 'request_param =abc')
+
+    def test_text_withval(self):
+        inst = self._makeOne('abc=  1')
+        self.assertEqual(inst.text(), 'request_param abc=1')
+
+    def test_text_multi(self):
+        inst = self._makeOne(('abc=  1', 'def'))
+        self.assertEqual(inst.text(), 'request_param abc=1,def')
+
+    def test_text_multi_equal_sign(self):
+        inst = self._makeOne(('abc=  1', '=def= 2'))
+        self.assertEqual(inst.text(), 'request_param =def=2,abc=1')
+
+    def test_phash_exists(self):
+        inst = self._makeOne('abc')
+        self.assertEqual(inst.phash(), 'request_param abc')
+
+    def test_phash_exists_equal_sign(self):
+        inst = self._makeOne('=abc')
+        self.assertEqual(inst.phash(), 'request_param =abc')
+
+    def test_phash_withval(self):
+        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'}
+        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'}
+        result = inst(None, request)
+        self.assertTrue(result)
+        
+    def test___call___false(self):
+        inst = self._makeOne('abc=1')
+        request = Dummy()
+        request.matchdict = {}
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test___call___matchdict_is_None(self):
+        inst = self._makeOne('abc=1')
+        request = Dummy()
+        request.matchdict = None
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test_text(self):
+        inst = self._makeOne(('def=  1', 'abc =2'))
+        self.assertEqual(inst.text(), 'match_param abc=2,def=1')
+
+    def test_phash(self):
+        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):
+        def func(context, request):
+            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)
+
+    def test_text_func_has___text__(self):
+        pred = predicate()
+        pred.__text__ = 'text'
+        inst = self._makeOne(pred)
+        self.assertEqual(inst.text(), 'text')
+         
+    def test_text_func_repr(self):
+        pred = predicate()
+        inst = self._makeOne(pred)
+        self.assertEqual(inst.text(), 'custom predicate: object predicate')
+
+    def test_phash(self):
+        pred = predicate()
+        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'}
+        request = Dummy()
+        result = inst(info, request)
+        self.assertEqual(result, True)
+        self.assertEqual(info, {'traverse':'abc'})
+
+    def test___call__traverse_matches(self):
+        inst = self._makeOne('/1/:a/: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')}})
+
+    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')}}
+        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'))
+             )
+
+    def test_text(self):
+        inst = self._makeOne('/abc')
+        self.assertEqual(inst.text(), 'traverse matchdict pseudo-predicate')
+
+    def test_phash(self):
+        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):
+        inst = self._makeOne(True, None)
+        self.assertEqual(inst.text(), 'check_csrf = True')
+
+    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
+        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
+        result = inst(None, request)
+        self.assertEqual(result, True)
+
+    def test_it_call_val_False(self):
+        inst = self._makeOne(False, None)
+        request = Dummy()
+        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}
+        result = inst(None, request)
+        self.assertTrue(result)
+
+    def test___call___true_withval(self):
+        inst = self._makeOne('abc:1')
+        request = Dummy()
+        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'}
+        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'}
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test___call___false(self):
+        inst = self._makeOne('abc')
+        request = Dummy()
+        request.headers = {}
+        result = inst(None, request)
+        self.assertFalse(result)
+
+    def test_text_exists(self):
+        inst = self._makeOne('abc')
+        self.assertEqual(inst.text(), 'header abc')
+
+    def test_text_withval(self):
+        inst = self._makeOne('abc:1')
+        self.assertEqual(inst.text(), 'header abc=1')
+
+    def test_text_withregex(self):
+        inst = self._makeOne(r'abc:\d+')
+        self.assertEqual(inst.text(), r'header abc=\d+')
+
+    def test_phash_exists(self):
+        inst = self._makeOne('abc')
+        self.assertEqual(inst.phash(), 'header abc')
+
+    def test_phash_withval(self):
+        inst = self._makeOne('abc:1')
+        self.assertEqual(inst.phash(), "header abc=1")
+
+    def test_phash_withregex(self):
+        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):
+        inst = self._makeOne('/', None)
+        self.assertEqual(inst.text(), "physical_path = ('',)")
+
+    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()
+        root.__name__ = ''
+        root.__parent__ = None
+        context = Dummy()
+        context.__name__ = 'abc'
+        context.__parent__ = root
+        self.assertTrue(inst(context, None))
+
+    def test_it_call_val_list_True(self):
+        inst = self._makeOne(['', 'abc'], None)
+        root = Dummy()
+        root.__name__ = ''
+        root.__parent__ = None
+        context = Dummy()
+        context.__name__ = 'abc'
+        context.__parent__ = root
+        self.assertTrue(inst(context, None))
+
+    def test_it_call_val_str_True(self):
+        inst = self._makeOne('/abc', None)
+        root = Dummy()
+        root.__name__ = ''
+        root.__parent__ = None
+        context = Dummy()
+        context.__name__ = 'abc'
+        context.__parent__ = root
+        self.assertTrue(inst(context, None))
+
+    def test_it_call_False(self):
+        inst = self._makeOne('/', None)
+        root = Dummy()
+        root.__name__ = ''
+        root.__parent__ = None
+        context = Dummy()
+        context.__name__ = 'abc'
+        context.__parent__ = root
+        self.assertFalse(inst(context, None))
+
+    def test_it_call_context_has_no_name(self):
+        inst = self._makeOne('/', None)
+        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']")
+
+    def test_text_noniter(self):
+        inst = self._makeOne('verna', None)
+        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']")
+
+    def test_it_call_no_authentication_policy(self):
+        request = testing.DummyRequest()
+        inst = self._makeOne(('verna', 'fred'), None)
+        context = Dummy()
+        self.assertFalse(inst(context, request))
+
+    def test_it_call_authentication_policy_provides_superset(self):
+        request = testing.DummyRequest()
+        self.config.testing_securitypolicy('fred', groupids=('verna', 'bambi'))
+        inst = self._makeOne(('verna', 'fred'), None)
+        context = Dummy()
+        self.assertTrue(inst(context, request))
+
+    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)
+        context = Dummy()
+        self.assertTrue(inst(context, request))
+
+    def test_it_call_authentication_policy_doesnt_provide_superset(self):
+        request = testing.DummyRequest()
+        self.config.testing_securitypolicy('fred')
+        inst = self._makeOne(('verna', 'fred'), None)
+        context = Dummy()
+        self.assertFalse(inst(context, request))
+
+
+class TestNotted(unittest.TestCase):
+    def _makeOne(self, predicate):
+        from pyramid.predicates import Notted
+        return Notted(predicate)
+
+    def test_it_with_phash_val(self):
+        pred = DummyPredicate('val')
+        inst = self._makeOne(pred)
+        self.assertEqual(inst.text(), '!val')
+        self.assertEqual(inst.phash(), '!val')
+        self.assertEqual(inst(None, None), False)
+
+    def test_it_without_phash_val(self):
+        pred = DummyPredicate('')
+        inst = self._makeOne(pred)
+        self.assertEqual(inst.text(), '')
+        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
+
+    def text(self):
+        return self.result
+
+    phash = text
+
+    def __call__(self, context, request):
+        return True