view | history | commit | commitdiff
Michael Merickel
2018-10-15 81576ee51564c49d5ff3c1c07f214f22a8438231
commit | author | age
4f0b02 1 import unittest
CM 2
c7337b 3 from pyramid import testing
CM 4
4f0b02 5 from pyramid.compat import text_
CM 6
7 class TestXHRPredicate(unittest.TestCase):
8     def _makeOne(self, val):
c7974f 9         from pyramid.predicates import XHRPredicate
9c8ec5 10         return XHRPredicate(val, None)
4f0b02 11     
CM 12     def test___call___true(self):
13         inst = self._makeOne(True)
14         request = Dummy()
15         request.is_xhr = True
16         result = inst(None, request)
17         self.assertTrue(result)
18         
19     def test___call___false(self):
20         inst = self._makeOne(True)
21         request = Dummy()
22         request.is_xhr = False
23         result = inst(None, request)
24         self.assertFalse(result)
25
4d2602 26     def test_text(self):
4f0b02 27         inst = self._makeOne(True)
4d2602 28         self.assertEqual(inst.text(), 'xhr = True')
4f0b02 29
4d2602 30     def test_phash(self):
4f0b02 31         inst = self._makeOne(True)
4d2602 32         self.assertEqual(inst.phash(), 'xhr = True')
4f0b02 33
CM 34 class TestRequestMethodPredicate(unittest.TestCase):
35     def _makeOne(self, val):
c7974f 36         from pyramid.predicates import RequestMethodPredicate
9c8ec5 37         return RequestMethodPredicate(val, None)
d98612 38
CM 39     def test_ctor_get_but_no_head(self):
40         inst = self._makeOne('GET')
41         self.assertEqual(inst.val, ('GET', 'HEAD'))
4f0b02 42     
CM 43     def test___call___true_single(self):
44         inst = self._makeOne('GET')
45         request = Dummy()
46         request.method = 'GET'
47         result = inst(None, request)
48         self.assertTrue(result)
49         
50     def test___call___true_multi(self):
51         inst = self._makeOne(('GET','HEAD'))
52         request = Dummy()
53         request.method = 'GET'
54         result = inst(None, request)
55         self.assertTrue(result)
56
57     def test___call___false(self):
58         inst = self._makeOne(('GET','HEAD'))
59         request = Dummy()
60         request.method = 'POST'
61         result = inst(None, request)
62         self.assertFalse(result)
63
4d2602 64     def test_text(self):
4f0b02 65         inst = self._makeOne(('HEAD','GET'))
4d2602 66         self.assertEqual(inst.text(), 'request_method = GET,HEAD')
4f0b02 67
4d2602 68     def test_phash(self):
4f0b02 69         inst = self._makeOne(('HEAD','GET'))
4d2602 70         self.assertEqual(inst.phash(), 'request_method = GET,HEAD')
4f0b02 71
CM 72 class TestPathInfoPredicate(unittest.TestCase):
73     def _makeOne(self, val):
c7974f 74         from pyramid.predicates import PathInfoPredicate
9c8ec5 75         return PathInfoPredicate(val, None)
4f0b02 76
CM 77     def test_ctor_compilefail(self):
78         from pyramid.exceptions import ConfigurationError
79         self.assertRaises(ConfigurationError, self._makeOne, '\\')
80     
81     def test___call___true(self):
82         inst = self._makeOne(r'/\d{2}')
83         request = Dummy()
84         request.upath_info = text_('/12')
85         result = inst(None, request)
86         self.assertTrue(result)
87         
88     def test___call___false(self):
89         inst = self._makeOne(r'/\d{2}')
90         request = Dummy()
91         request.upath_info = text_('/n12')
92         result = inst(None, request)
93         self.assertFalse(result)
94
4d2602 95     def test_text(self):
4f0b02 96         inst = self._makeOne('/')
4d2602 97         self.assertEqual(inst.text(), 'path_info = /')
4f0b02 98
4d2602 99     def test_phash(self):
4f0b02 100         inst = self._makeOne('/')
4d2602 101         self.assertEqual(inst.phash(), 'path_info = /')
4f0b02 102
CM 103 class TestRequestParamPredicate(unittest.TestCase):
104     def _makeOne(self, val):
c7974f 105         from pyramid.predicates import RequestParamPredicate
9c8ec5 106         return RequestParamPredicate(val, None)
4f0b02 107
CM 108     def test___call___true_exists(self):
109         inst = self._makeOne('abc')
110         request = Dummy()
111         request.params = {'abc':1}
112         result = inst(None, request)
113         self.assertTrue(result)
114
115     def test___call___true_withval(self):
116         inst = self._makeOne('abc=1')
117         request = Dummy()
118         request.params = {'abc':'1'}
119         result = inst(None, request)
120         self.assertTrue(result)
121
3fb934 122     def test___call___true_multi(self):
53c7f7 123         inst = self._makeOne(('abc', '=def =2= '))
3fb934 124         request = Dummy()
53c7f7 125         request.params = {'abc':'1', '=def': '2='}
3fb934 126         result = inst(None, request)
MM 127         self.assertTrue(result)
128
129     def test___call___false_multi(self):
130         inst = self._makeOne(('abc=3', 'def =2 '))
131         request = Dummy()
132         request.params = {'abc':'3', 'def': '1'}
133         result = inst(None, request)
134         self.assertFalse(result)
135
4f0b02 136     def test___call___false(self):
CM 137         inst = self._makeOne('abc')
138         request = Dummy()
139         request.params = {}
140         result = inst(None, request)
141         self.assertFalse(result)
142
4d2602 143     def test_text_exists(self):
4f0b02 144         inst = self._makeOne('abc')
4d2602 145         self.assertEqual(inst.text(), 'request_param abc')
4f0b02 146
00f80c 147     def test_text_exists_equal_sign(self):
TI 148         inst = self._makeOne('=abc')
149         self.assertEqual(inst.text(), 'request_param =abc')
150
4d2602 151     def test_text_withval(self):
4f0b02 152         inst = self._makeOne('abc=  1')
5507b8 153         self.assertEqual(inst.text(), 'request_param abc=1')
4f0b02 154
3fb934 155     def test_text_multi(self):
MM 156         inst = self._makeOne(('abc=  1', 'def'))
5507b8 157         self.assertEqual(inst.text(), 'request_param abc=1,def')
3fb934 158
00f80c 159     def test_text_multi_equal_sign(self):
afa8a7 160         inst = self._makeOne(('abc=  1', '=def= 2'))
TI 161         self.assertEqual(inst.text(), 'request_param =def=2,abc=1')
00f80c 162
4d2602 163     def test_phash_exists(self):
4f0b02 164         inst = self._makeOne('abc')
4d2602 165         self.assertEqual(inst.phash(), 'request_param abc')
4f0b02 166
00f80c 167     def test_phash_exists_equal_sign(self):
TI 168         inst = self._makeOne('=abc')
169         self.assertEqual(inst.phash(), 'request_param =abc')
170
4d2602 171     def test_phash_withval(self):
4f0b02 172         inst = self._makeOne('abc=   1')
5507b8 173         self.assertEqual(inst.phash(), "request_param abc=1")
4f0b02 174
4d2602 175 class TestMatchParamPredicate(unittest.TestCase):
CM 176     def _makeOne(self, val):
c7974f 177         from pyramid.predicates import MatchParamPredicate
9c8ec5 178         return MatchParamPredicate(val, None)
4d2602 179
CM 180     def test___call___true_single(self):
181         inst = self._makeOne('abc=1')
182         request = Dummy()
183         request.matchdict = {'abc':'1'}
184         result = inst(None, request)
185         self.assertTrue(result)
186
187
188     def test___call___true_multi(self):
189         inst = self._makeOne(('abc=1', 'def=2'))
190         request = Dummy()
191         request.matchdict = {'abc':'1', 'def':'2'}
192         result = inst(None, request)
193         self.assertTrue(result)
194         
195     def test___call___false(self):
196         inst = self._makeOne('abc=1')
197         request = Dummy()
198         request.matchdict = {}
199         result = inst(None, request)
200         self.assertFalse(result)
201
267dbd 202     def test___call___matchdict_is_None(self):
CM 203         inst = self._makeOne('abc=1')
204         request = Dummy()
205         request.matchdict = None
206         result = inst(None, request)
207         self.assertFalse(result)
208
4d2602 209     def test_text(self):
CM 210         inst = self._makeOne(('def=  1', 'abc =2'))
211         self.assertEqual(inst.text(), 'match_param abc=2,def=1')
212
213     def test_phash(self):
214         inst = self._makeOne(('def=  1', 'abc =2'))
215         self.assertEqual(inst.phash(), 'match_param abc=2,def=1')
216
217 class TestCustomPredicate(unittest.TestCase):
218     def _makeOne(self, val):
c7974f 219         from pyramid.predicates import CustomPredicate
9c8ec5 220         return CustomPredicate(val, None)
4d2602 221
CM 222     def test___call___true(self):
223         def func(context, request):
224             self.assertEqual(context, None)
225             self.assertEqual(request, None)
226             return True
227         inst = self._makeOne(func)
228         result = inst(None, None)
229         self.assertTrue(result)
230     
231     def test___call___false(self):
232         def func(context, request):
233             self.assertEqual(context, None)
234             self.assertEqual(request, None)
235             return False
236         inst = self._makeOne(func)
237         result = inst(None, None)
238         self.assertFalse(result)
239
240     def test_text_func_has___text__(self):
241         pred = predicate()
242         pred.__text__ = 'text'
243         inst = self._makeOne(pred)
244         self.assertEqual(inst.text(), 'text')
245          
246     def test_text_func_repr(self):
247         pred = predicate()
248         inst = self._makeOne(pred)
859e94 249         self.assertEqual(inst.text(), 'custom predicate: object predicate')
4d2602 250
CM 251     def test_phash(self):
252         pred = predicate()
253         inst = self._makeOne(pred)
9c8ec5 254         self.assertEqual(inst.phash(), 'custom:1')
4d2602 255
CM 256 class TestTraversePredicate(unittest.TestCase):
257     def _makeOne(self, val):
c7974f 258         from pyramid.predicates import TraversePredicate
9c8ec5 259         return TraversePredicate(val, None)
4d2602 260     
CM 261     def test___call__traverse_has_remainder_already(self):
262         inst = self._makeOne('/1/:a/:b')
263         info = {'traverse':'abc'}
264         request = Dummy()
265         result = inst(info, request)
266         self.assertEqual(result, True)
267         self.assertEqual(info, {'traverse':'abc'})
268
269     def test___call__traverse_matches(self):
270         inst = self._makeOne('/1/:a/:b')
271         info = {'match':{'a':'a', 'b':'b'}}
272         request = Dummy()
273         result = inst(info, request)
274         self.assertEqual(result, True)
275         self.assertEqual(info, {'match':
276                                 {'a':'a', 'b':'b', 'traverse':('1', 'a', 'b')}})
277
278     def test___call__traverse_matches_with_highorder_chars(self):
279         inst = self._makeOne(text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8'))
280         info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}}
281         request = Dummy()
282         result = inst(info, request)
283         self.assertEqual(result, True)
284         self.assertEqual(
285             info['match']['traverse'],
286             (text_(b'La Pe\xc3\xb1a', 'utf-8'),
287              text_(b'Qu\xc3\xa9bec', 'utf-8'))
288              )
289
290     def test_text(self):
291         inst = self._makeOne('/abc')
292         self.assertEqual(inst.text(), 'traverse matchdict pseudo-predicate')
293
294     def test_phash(self):
295         inst = self._makeOne('/abc')
296         self.assertEqual(inst.phash(), '')
297
643a83 298 class Test_CheckCSRFTokenPredicate(unittest.TestCase):
CM 299     def _makeOne(self, val, config):
c7974f 300         from pyramid.predicates import CheckCSRFTokenPredicate
643a83 301         return CheckCSRFTokenPredicate(val, config)
CM 302
303     def test_text(self):
304         inst = self._makeOne(True, None)
305         self.assertEqual(inst.text(), 'check_csrf = True')
306
307     def test_phash(self):
308         inst = self._makeOne(True, None)
309         self.assertEqual(inst.phash(), 'check_csrf = True')
310         
311     def test_it_call_val_True(self):
312         inst = self._makeOne(True, None)
313         request = Dummy()
314         def check_csrf_token(req, val, raises=True):
315             self.assertEqual(req, request)
316             self.assertEqual(val, 'csrf_token')
317             self.assertEqual(raises, False)
318             return True
319         inst.check_csrf_token  = check_csrf_token
320         result = inst(None, request)
321         self.assertEqual(result, True)
322
323     def test_it_call_val_str(self):
324         inst = self._makeOne('abc', None)
325         request = Dummy()
326         def check_csrf_token(req, val, raises=True):
327             self.assertEqual(req, request)
328             self.assertEqual(val, 'abc')
329             self.assertEqual(raises, False)
330             return True
331         inst.check_csrf_token  = check_csrf_token
332         result = inst(None, request)
333         self.assertEqual(result, True)
334
335     def test_it_call_val_False(self):
336         inst = self._makeOne(False, None)
337         request = Dummy()
338         result = inst(None, request)
339         self.assertEqual(result, True)
340
b1d2a3 341 class TestHeaderPredicate(unittest.TestCase):
MM 342     def _makeOne(self, val):
c7974f 343         from pyramid.predicates import HeaderPredicate
b1d2a3 344         return HeaderPredicate(val, None)
MM 345
346     def test___call___true_exists(self):
347         inst = self._makeOne('abc')
348         request = Dummy()
349         request.headers = {'abc':1}
350         result = inst(None, request)
351         self.assertTrue(result)
352
353     def test___call___true_withval(self):
354         inst = self._makeOne('abc:1')
355         request = Dummy()
356         request.headers = {'abc':'1'}
357         result = inst(None, request)
358         self.assertTrue(result)
359
360     def test___call___true_withregex(self):
361         inst = self._makeOne(r'abc:\d+')
362         request = Dummy()
363         request.headers = {'abc':'1'}
364         result = inst(None, request)
365         self.assertTrue(result)
366
367     def test___call___false_withregex(self):
368         inst = self._makeOne(r'abc:\d+')
369         request = Dummy()
370         request.headers = {'abc':'a'}
371         result = inst(None, request)
372         self.assertFalse(result)
373
374     def test___call___false(self):
375         inst = self._makeOne('abc')
376         request = Dummy()
377         request.headers = {}
378         result = inst(None, request)
379         self.assertFalse(result)
380
381     def test_text_exists(self):
382         inst = self._makeOne('abc')
383         self.assertEqual(inst.text(), 'header abc')
384
385     def test_text_withval(self):
386         inst = self._makeOne('abc:1')
387         self.assertEqual(inst.text(), 'header abc=1')
388
389     def test_text_withregex(self):
390         inst = self._makeOne(r'abc:\d+')
391         self.assertEqual(inst.text(), r'header abc=\d+')
392
393     def test_phash_exists(self):
394         inst = self._makeOne('abc')
395         self.assertEqual(inst.phash(), 'header abc')
396
397     def test_phash_withval(self):
398         inst = self._makeOne('abc:1')
399         self.assertEqual(inst.phash(), "header abc=1")
400
401     def test_phash_withregex(self):
402         inst = self._makeOne(r'abc:\d+')
403         self.assertEqual(inst.phash(), r'header abc=\d+')
404
c25a8f 405 class Test_PhysicalPathPredicate(unittest.TestCase):
CM 406     def _makeOne(self, val, config):
c7974f 407         from pyramid.predicates import PhysicalPathPredicate
c25a8f 408         return PhysicalPathPredicate(val, config)
CM 409
410     def test_text(self):
411         inst = self._makeOne('/', None)
412         self.assertEqual(inst.text(), "physical_path = ('',)")
413
414     def test_phash(self):
415         inst = self._makeOne('/', None)
416         self.assertEqual(inst.phash(), "physical_path = ('',)")
417         
418     def test_it_call_val_tuple_True(self):
419         inst = self._makeOne(('', 'abc'), None)
420         root = Dummy()
421         root.__name__ = ''
422         root.__parent__ = None
423         context = Dummy()
424         context.__name__ = 'abc'
425         context.__parent__ = root
426         self.assertTrue(inst(context, None))
427
428     def test_it_call_val_list_True(self):
429         inst = self._makeOne(['', 'abc'], None)
430         root = Dummy()
431         root.__name__ = ''
432         root.__parent__ = None
433         context = Dummy()
434         context.__name__ = 'abc'
435         context.__parent__ = root
436         self.assertTrue(inst(context, None))
437
438     def test_it_call_val_str_True(self):
439         inst = self._makeOne('/abc', None)
440         root = Dummy()
441         root.__name__ = ''
442         root.__parent__ = None
443         context = Dummy()
444         context.__name__ = 'abc'
445         context.__parent__ = root
446         self.assertTrue(inst(context, None))
447
448     def test_it_call_False(self):
449         inst = self._makeOne('/', None)
450         root = Dummy()
451         root.__name__ = ''
452         root.__parent__ = None
453         context = Dummy()
454         context.__name__ = 'abc'
455         context.__parent__ = root
456         self.assertFalse(inst(context, None))
457
267dbd 458     def test_it_call_context_has_no_name(self):
CM 459         inst = self._makeOne('/', None)
460         context = Dummy()
461         self.assertFalse(inst(context, None))
462
c7337b 463 class Test_EffectivePrincipalsPredicate(unittest.TestCase):
CM 464     def setUp(self):
465         self.config = testing.setUp()
466
467     def tearDown(self):
468         testing.tearDown()
469         
470     def _makeOne(self, val, config):
c7974f 471         from pyramid.predicates import EffectivePrincipalsPredicate
c7337b 472         return EffectivePrincipalsPredicate(val, config)
CM 473
474     def test_text(self):
475         inst = self._makeOne(('verna', 'fred'), None)
476         self.assertEqual(inst.text(),
477                          "effective_principals = ['fred', 'verna']")
478
479     def test_text_noniter(self):
480         inst = self._makeOne('verna', None)
481         self.assertEqual(inst.text(),
482                          "effective_principals = ['verna']")
483
484     def test_phash(self):
485         inst = self._makeOne(('verna', 'fred'), None)
486         self.assertEqual(inst.phash(),
487                          "effective_principals = ['fred', 'verna']")
488
489     def test_it_call_no_authentication_policy(self):
490         request = testing.DummyRequest()
491         inst = self._makeOne(('verna', 'fred'), None)
492         context = Dummy()
493         self.assertFalse(inst(context, request))
494
495     def test_it_call_authentication_policy_provides_superset(self):
496         request = testing.DummyRequest()
497         self.config.testing_securitypolicy('fred', groupids=('verna', 'bambi'))
498         inst = self._makeOne(('verna', 'fred'), None)
499         context = Dummy()
500         self.assertTrue(inst(context, request))
501
502     def test_it_call_authentication_policy_provides_superset_implicit(self):
503         from pyramid.security import Authenticated
504         request = testing.DummyRequest()
505         self.config.testing_securitypolicy('fred', groupids=('verna', 'bambi'))
506         inst = self._makeOne(Authenticated, None)
507         context = Dummy()
508         self.assertTrue(inst(context, request))
509
510     def test_it_call_authentication_policy_doesnt_provide_superset(self):
511         request = testing.DummyRequest()
512         self.config.testing_securitypolicy('fred')
513         inst = self._makeOne(('verna', 'fred'), None)
514         context = Dummy()
515         self.assertFalse(inst(context, request))
516
52fde9 517
MM 518 class TestNotted(unittest.TestCase):
519     def _makeOne(self, predicate):
520         from pyramid.predicates import Notted
521         return Notted(predicate)
522
523     def test_it_with_phash_val(self):
524         pred = DummyPredicate('val')
525         inst = self._makeOne(pred)
526         self.assertEqual(inst.text(), '!val')
527         self.assertEqual(inst.phash(), '!val')
528         self.assertEqual(inst(None, None), False)
529
530     def test_it_without_phash_val(self):
531         pred = DummyPredicate('')
532         inst = self._makeOne(pred)
533         self.assertEqual(inst.text(), '')
534         self.assertEqual(inst.phash(), '')
535         self.assertEqual(inst(None, None), True)
536
4d2602 537 class predicate(object):
CM 538     def __repr__(self):
539         return 'predicate'
540     def __hash__(self):
541         return 1
52fde9 542
4f0b02 543 class Dummy(object):
52fde9 544     pass
MM 545
546 class DummyPredicate(object):
547     def __init__(self, result):
548         self.result = result
549
550     def text(self):
551         return self.result
552
553     phash = text
554
555     def __call__(self, context, request):
556         return True