Source Code for Module repoze.who.tests.test_restrict

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