1import unittest 2 3class AuthenticatedPredicateTests(unittest.TestCase): 4 5 def _getFUT(self): 6 from repoze.who.restrict import authenticated_predicate 7 return authenticated_predicate() 8 9 def test___call___no_identity_returns_False(self): 10 predicate = self._getFUT() 11 environ = {} 12 self.assertFalse(predicate(environ)) 13 14 def test___call___w_REMOTE_AUTH_returns_True(self): 15 predicate = self._getFUT() 16 environ = {'REMOTE_USER': 'fred'} 17 self.assertTrue(predicate(environ)) 18 19 def test___call___w_repoze_who_identity_returns_True(self): 20 predicate = self._getFUT() 21 environ = {'repoze.who.identity': {'login': 'fred'}} 22 self.assertTrue(predicate(environ)) 23 24class MakeAuthenticatedRestrictionTests(unittest.TestCase): 25 26 def _getFUT(self): 27 from repoze.who.restrict import make_authenticated_restriction 28 return make_authenticated_restriction 29 30 def test_enabled(self): 31 fut = self._getFUT() 32 app = DummyApp() 33 34 filter = fut(app, {}, enabled=True) 35 36 self.assertTrue(filter.app is app) 37 self.assertTrue(filter.enabled) 38 predicate = filter.predicate 39 self.assertTrue(predicate({'REMOTE_USER': 'fred'})) 40 self.assertTrue(predicate({'repoze.who.identity': {'login': 'fred'}})) 41 42class PredicateRestrictionTests(unittest.TestCase): 43 44 def _getTargetClass(self): 45 from repoze.who.restrict import PredicateRestriction 46 return PredicateRestriction 47 48 def _makeOne(self, app=None, **kw): 49 if app is None: 50 app = DummyApp() 51 return self._getTargetClass()(app, **kw) 52 53 def test___call___disabled_predicate_false_calls_app_not_predicate(self): 54 _tested = [] 55 def _factory(): 56 def _predicate(env): # pragma: no cover 57 assert False 58 return _predicate 59 60 def _start_response(status, headers): 61 assert False # pragma: no cover 62 environ = {'testing': True} 63 64 restrict = self._makeOne(predicate=_factory, enabled=False) 65 restrict(environ, _start_response) 66 67 self.assertEqual(len(_tested), 0) 68 self.assertEqual(restrict.app.environ, environ) 69 70 def test___call___enabled_predicate_false_returns_401(self): 71 _tested = [] 72 def _factory(): 73 def _predicate(env): 74 _tested.append(env) 75 return False 76 return _predicate 77 78 _started = [] 79 def _start_response(status, headers): 80 _started.append((status, headers)) 81 environ = {'testing': True} 82 83 restrict = self._makeOne(predicate=_factory) 84 restrict(environ, _start_response) 85 86 self.assertEqual(len(_tested), 1) 87 self.assertEqual(len(_started), 1, _started) 88 self.assertEqual(_started[0][0], '401 Unauthorized') 89 self.assertEqual(restrict.app.environ, None) 90 91 def test___call___enabled_predicate_true_calls_app(self): 92 _tested = [] 93 def _factory(): 94 def _predicate(env): 95 _tested.append(env) 96 return True 97 return _predicate 98 99 def _start_response(status, headers): 100 assert False # pragma: no cover 101 environ = {'testing': True, 'REMOTE_USER': 'fred'} 102 103 restrict = self._makeOne(predicate=_factory) 104 restrict(environ, _start_response) 105 106 self.assertEqual(len(_tested), 1) 107 self.assertEqual(restrict.app.environ, environ) 108 109class MakePredicateRestrictionTests(unittest.TestCase): 110 111 def _getFUT(self): 112 from repoze.who.restrict import make_predicate_restriction 113 return make_predicate_restriction 114 115 def test_non_string_predicate_no_args(self): 116 fut = self._getFUT() 117 app = DummyApp() 118 def _predicate(env): 119 return True # pragma: no cover 120 def _factory(): 121 return _predicate 122 123 filter = fut(app, {}, predicate=_factory) 124 125 self.assertTrue(filter.app is app) 126 self.assertTrue(filter.predicate is _predicate) 127 self.assertTrue(filter.enabled) 128 129 def test_disabled_non_string_predicate_w_args(self): 130 fut = self._getFUT() 131 app = DummyApp() 132 133 filter = fut(app, {}, predicate=DummyPredicate, enabled=False, 134 foo='Foo') 135 136 self.assertTrue(filter.app is app) 137 self.assertTrue(isinstance(filter.predicate, DummyPredicate)) 138 self.assertEqual(filter.predicate.foo, 'Foo') 139 self.assertFalse(filter.enabled) 140 141 def test_enabled_string_predicate_w_args(self): 142 fut = self._getFUT() 143 app = DummyApp() 144 145 filter = fut(app, {}, 146 predicate='repoze.who.tests.test_restrict:DummyPredicate', 147 enabled=True, foo='Foo') 148 149 self.assertTrue(filter.app is app) 150 self.assertTrue(isinstance(filter.predicate, DummyPredicate)) 151 self.assertEqual(filter.predicate.foo, 'Foo') 152 self.assertTrue(filter.enabled) 153 154 155class DummyApp(object): 156 environ = None 157 def __call__(self, environ, start_response): 158 self.environ = environ 159 return [] 160 161class DummyPredicate(object): 162 def __init__(self, **kw): 163 self.__dict__.update(kw) 164