Merged with master, fixed imports for py3

jurov

2014-12-15 8729b3c625f9914a23dddd9edbef7584e849f40c

 repoze/who/tests/test_restrict.py

@@ -1,14 +1,6 @@
import unittest

class _Base(unittest.TestCase):

    def failUnless(self, predicate, message=''):
        self.assertTrue(predicate, message) # Nannies go home!

    def failIf(self, predicate, message=''):
        self.assertFalse(predicate, message) # Nannies go home!

class AuthenticatedPredicateTests(_Base):
class AuthenticatedPredicateTests(unittest.TestCase):

    def _getFUT(self):
        from repoze.who.restrict import authenticated_predicate
@@ -17,38 +9,37 @@
    def test___call___no_identity_returns_False(self):
        predicate = self._getFUT()
        environ = {}
        self.failIf(predicate(environ))
        self.assertFalse(predicate(environ))

    def test___call___w_REMOTE_AUTH_returns_True(self):
        predicate = self._getFUT()
        environ = {'REMOTE_USER': 'fred'}
        self.failUnless(predicate(environ))
        self.assertTrue(predicate(environ))

    def test___call___w_repoze_who_identity_returns_True(self):
        predicate = self._getFUT()
        environ = {'repoze.who.identity': {'login': 'fred'}}
        self.failUnless(predicate(environ))
        self.assertTrue(predicate(environ))

class MakeAuthenticatedRestrictionTests(_Base):
class MakeAuthenticatedRestrictionTests(unittest.TestCase):

    def _getFUT(self):
        from repoze.who.restrict import make_authenticated_restriction
        return make_authenticated_restriction

    def test_enabled(self):
        from repoze.who.restrict import authenticated_predicate
        fut = self._getFUT()
        app = DummyApp()

        filter = fut(app, {}, enabled=True)

        self.failUnless(filter.app is app)
        self.failUnless(filter.enabled)
        self.assertTrue(filter.app is app)
        self.assertTrue(filter.enabled)
        predicate = filter.predicate
        self.failUnless(predicate({'REMOTE_USER': 'fred'}))
        self.failUnless(predicate({'repoze.who.identity': {'login': 'fred'}}))
        self.assertTrue(predicate({'REMOTE_USER': 'fred'}))
        self.assertTrue(predicate({'repoze.who.identity': {'login': 'fred'}}))

class PredicateRestrictionTests(_Base):
class PredicateRestrictionTests(unittest.TestCase):

    def _getTargetClass(self):
        from repoze.who.restrict import PredicateRestriction
@@ -62,21 +53,18 @@
    def test___call___disabled_predicate_false_calls_app_not_predicate(self):
        _tested = []
        def _factory():
            def _predicate(env):
                _tested.append(env)
                return False
            def _predicate(env):  # pragma: no cover
                assert False
            return _predicate

        _started = []
        def _start_response(status, headers):
            _started.append((status, headers))
            assert False  # pragma: no cover
        environ = {'testing': True}

        restrict = self._makeOne(predicate=_factory, enabled=False)
        restrict(environ, _start_response)

        self.assertEqual(len(_tested), 0)
        self.assertEqual(len(_started), 0)
        self.assertEqual(restrict.app.environ, environ)

    def test___call___enabled_predicate_false_returns_401(self):
@@ -108,19 +96,17 @@
                return True
            return _predicate

        _started = []
        def _start_response(status, headers):
            _started.append((status, headers))
            assert False  # pragma: no cover
        environ = {'testing': True, 'REMOTE_USER': 'fred'}

        restrict = self._makeOne(predicate=_factory)
        restrict(environ, _start_response)

        self.assertEqual(len(_tested), 1)
        self.assertEqual(len(_started), 0)
        self.assertEqual(restrict.app.environ, environ)

class MakePredicateRestrictionTests(_Base):
class MakePredicateRestrictionTests(unittest.TestCase):

    def _getFUT(self):
        from repoze.who.restrict import make_predicate_restriction
@@ -130,15 +116,15 @@
        fut = self._getFUT()
        app = DummyApp()
        def _predicate(env):
            return True
            return True  # pragma: no cover
        def _factory():
            return _predicate

        filter = fut(app, {}, predicate=_factory)

        self.failUnless(filter.app is app)
        self.failUnless(filter.predicate is _predicate)
        self.failUnless(filter.enabled)
        self.assertTrue(filter.app is app)
        self.assertTrue(filter.predicate is _predicate)
        self.assertTrue(filter.enabled)

    def test_disabled_non_string_predicate_w_args(self):
        fut = self._getFUT()
@@ -147,10 +133,10 @@
        filter = fut(app, {}, predicate=DummyPredicate, enabled=False,
                     foo='Foo')

        self.failUnless(filter.app is app)
        self.failUnless(isinstance(filter.predicate, DummyPredicate))
        self.assertTrue(filter.app is app)
        self.assertTrue(isinstance(filter.predicate, DummyPredicate))
        self.assertEqual(filter.predicate.foo, 'Foo')
        self.failIf(filter.enabled)
        self.assertFalse(filter.enabled)

    def test_enabled_string_predicate_w_args(self):
        fut = self._getFUT()
@@ -160,20 +146,18 @@
                     predicate='repoze.who.tests.test_restrict:DummyPredicate',
                     enabled=True, foo='Foo')

        self.failUnless(filter.app is app)
        self.failUnless(isinstance(filter.predicate, DummyPredicate))
        self.assertTrue(filter.app is app)
        self.assertTrue(isinstance(filter.predicate, DummyPredicate))
        self.assertEqual(filter.predicate.foo, 'Foo')
        self.failUnless(filter.enabled)
        self.assertTrue(filter.enabled)


class DummyApp:
class DummyApp(object):
    environ = None
    def __call__(self, environ, start_response):
        self.environ = environ
        return []

class DummyPredicate:
class DummyPredicate(object):
    def __init__(self, **kw):
        self.__dict__.update(kw)
    def __call__(self, env):
        return True