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