- Remove "context" argument from ``effective_principals`` and

  ``authenticated_userid`` function APIs in ``repoze.bfg.security``,
  effectively a doing reversion to 0.8 and before behavior.  Both
  functions now again accept only the ``request`` parameter.

4 files changed, 55 insertions, 121 deletions

diff --git a/repoze/bfg/tests/test_authentication.py b/repoze/bfg/tests/test_authentication.py
index b0b1e084a..09782cd3c 100644
--- a/repoze/bfg/tests/test_authentication.py
+++ b/repoze/bfg/tests/test_authentication.py
@@ -19,114 +19,100 @@ class TestRepozeWho1AuthenticationPolicy(unittest.TestCase):
         verifyObject(IAuthenticationPolicy, self._makeOne())
 
     def test_authenticated_userid_None(self):
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne()
-        self.assertEqual(policy.authenticated_userid(context, request), None)
+        self.assertEqual(policy.authenticated_userid(request), None)
         
     def test_authenticated_userid(self):
-        context = DummyContext()
         request = DummyRequest(
             {'repoze.who.identity':{'repoze.who.userid':'fred'}})
         policy = self._makeOne()
-        self.assertEqual(policy.authenticated_userid(context, request), 'fred')
+        self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_authenticated_userid_with_callback_returns_None(self):
-        context = DummyContext()
         request = DummyRequest(
             {'repoze.who.identity':{'repoze.who.userid':'fred'}})
         def callback(identity):
             return None
         policy = self._makeOne(callback=callback)
-        self.assertEqual(policy.authenticated_userid(context, request), None)
+        self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid_with_callback_returns_something(self):
-        context = DummyContext()
         request = DummyRequest(
             {'repoze.who.identity':{'repoze.who.userid':'fred'}})
         def callback(identity):
             return ['agroup']
         policy = self._makeOne(callback=callback)
-        self.assertEqual(policy.authenticated_userid(context, request), 'fred')
+        self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_effective_principals_None(self):
         from repoze.bfg.security import Everyone
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(context, request),
-                         [Everyone])
+        self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_userid_only(self):
         from repoze.bfg.security import Everyone
         from repoze.bfg.security import Authenticated
-        context = DummyContext()
         request = DummyRequest(
             {'repoze.who.identity':{'repoze.who.userid':'fred'}})
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(context, request),
+        self.assertEqual(policy.effective_principals(request),
                          [Everyone, Authenticated, 'fred'])
 
     def test_effective_principals_userid_and_groups(self):
         from repoze.bfg.security import Everyone
         from repoze.bfg.security import Authenticated
-        context = DummyContext()
         request = DummyRequest(
             {'repoze.who.identity':{'repoze.who.userid':'fred',
                                     'groups':['quux', 'biz']}})
         def callback(identity):
             return identity['groups']
         policy = self._makeOne(callback=callback)
-        self.assertEqual(policy.effective_principals(context, request),
+        self.assertEqual(policy.effective_principals(request),
                          [Everyone, Authenticated, 'fred', 'quux', 'biz'])
 
     def test_effective_principals_userid_callback_returns_None(self):
         from repoze.bfg.security import Everyone
-        context = DummyContext()
         request = DummyRequest(
             {'repoze.who.identity':{'repoze.who.userid':'fred',
                                     'groups':['quux', 'biz']}})
         def callback(identity):
             return None
         policy = self._makeOne(callback=callback)
-        self.assertEqual(policy.effective_principals(context, request),
-                         [Everyone])
+        self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_remember_no_plugins(self):
-        context = DummyContext()
         authtkt = DummyWhoPlugin()
         request = DummyRequest({})
         policy = self._makeOne()
-        result = policy.remember(context, request, 'fred')
+        result = policy.remember(request, 'fred')
         self.assertEqual(result, [])
 
     def test_remember(self):
-        context = DummyContext()
         authtkt = DummyWhoPlugin()
         request = DummyRequest(
             {'repoze.who.plugins':{'auth_tkt':authtkt}})
         policy = self._makeOne()
-        result = policy.remember(context, request, 'fred')
+        result = policy.remember(request, 'fred')
         self.assertEqual(result[0], request.environ)
         self.assertEqual(result[1], {'repoze.who.userid':'fred'})
         
     def test_forget_no_plugins(self):
-        context = DummyContext()
         authtkt = DummyWhoPlugin()
         request = DummyRequest({})
         policy = self._makeOne()
-        result = policy.forget(context, request)
+        result = policy.forget(request)
         self.assertEqual(result, [])
 
     def test_forget(self):
-        context = DummyContext()
         authtkt = DummyWhoPlugin()
         request = DummyRequest(
             {'repoze.who.plugins':{'auth_tkt':authtkt},
              'repoze.who.identity':{'repoze.who.userid':'fred'},
              })
         policy = self._makeOne()
-        result = policy.forget(context, request)
+        result = policy.forget(request)
         self.assertEqual(result[0], request.environ)
         self.assertEqual(result[1], request.environ['repoze.who.identity'])
 
@@ -149,48 +135,41 @@ class TestRemoteUserAuthenticationPolicy(unittest.TestCase):
         verifyObject(IAuthenticationPolicy, self._makeOne())
 
     def test_authenticated_userid_None(self):
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne()
-        self.assertEqual(policy.authenticated_userid(context, request), None)
+        self.assertEqual(policy.authenticated_userid(request), None)
         
     def test_authenticated_userid(self):
-        context = DummyContext()
         request = DummyRequest({'REMOTE_USER':'fred'})
         policy = self._makeOne()
-        self.assertEqual(policy.authenticated_userid(context, request), 'fred')
+        self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_effective_principals_None(self):
         from repoze.bfg.security import Everyone
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(context, request),
-                         [Everyone])
+        self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals(self):
         from repoze.bfg.security import Everyone
         from repoze.bfg.security import Authenticated
-        context = DummyContext()
         request = DummyRequest({'REMOTE_USER':'fred'})
         policy = self._makeOne()
-        self.assertEqual(policy.effective_principals(context, request),
+        self.assertEqual(policy.effective_principals(request),
                          [Everyone, Authenticated, 'fred'])
 
     def test_remember(self):
-        context = DummyContext()
         authtkt = DummyWhoPlugin()
         request = DummyRequest({'REMOTE_USER':'fred'})
         policy = self._makeOne()
-        result = policy.remember(context, request, 'fred')
+        result = policy.remember(request, 'fred')
         self.assertEqual(result, [])
         
     def test_forget(self):
-        context = DummyContext()
         authtkt = DummyWhoPlugin()
         request = DummyRequest({'REMOTE_USER':'fred'})
         policy = self._makeOne()
-        result = policy.forget(context, request)
+        result = policy.forget(request)
         self.assertEqual(result, [])
 
 class TestAutkTktAuthenticationPolicy(unittest.TestCase):
@@ -214,68 +193,58 @@ class TestAutkTktAuthenticationPolicy(unittest.TestCase):
         verifyObject(IAuthenticationPolicy, self._makeOne(None, None))
 
     def test_authenticated_userid_no_cookie_identity(self):
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne(None, None)
-        self.assertEqual(policy.authenticated_userid(context, request), None)
+        self.assertEqual(policy.authenticated_userid(request), None)
         
     def test_authenticated_userid_callback_returns_None(self):
-        context = DummyContext()
         request = DummyRequest({})
         def callback(userid):
             return None
         policy = self._makeOne(callback, {'userid':'fred'})
-        self.assertEqual(policy.authenticated_userid(context, request), None)
+        self.assertEqual(policy.authenticated_userid(request), None)
 
     def test_authenticated_userid(self):
-        context = DummyContext()
         request = DummyRequest({})
         def callback(userid):
             return True
         policy = self._makeOne(callback, {'userid':'fred'})
-        self.assertEqual(policy.authenticated_userid(context, request), 'fred')
+        self.assertEqual(policy.authenticated_userid(request), 'fred')
 
     def test_effective_principals_no_cookie_identity(self):
         from repoze.bfg.security import Everyone
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne(None, None)
-        self.assertEqual(policy.effective_principals(context, request),
-                         [Everyone])
+        self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals_callback_returns_None(self):
         from repoze.bfg.security import Everyone
-        context = DummyContext()
         request = DummyRequest({})
         def callback(userid):
             return None
         policy = self._makeOne(callback, {'userid':'fred'})
-        self.assertEqual(policy.effective_principals(context, request),
-                         [Everyone])
+        self.assertEqual(policy.effective_principals(request), [Everyone])
 
     def test_effective_principals(self):
         from repoze.bfg.security import Everyone
         from repoze.bfg.security import Authenticated
-        context = DummyContext()
         request = DummyRequest({})
         def callback(userid):
             return ['group.foo']
         policy = self._makeOne(callback, {'userid':'fred'})
-        self.assertEqual(policy.effective_principals(context, request),
+        self.assertEqual(policy.effective_principals(request),
                              [Everyone, Authenticated, 'fred', 'group.foo'])
 
     def test_remember(self):
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne(None, None)
-        result = policy.remember(context, request, 'fred')
+        result = policy.remember(request, 'fred')
         self.assertEqual(result, [])
         
     def test_forget(self):
-        context = DummyContext()
         request = DummyRequest({})
         policy = self._makeOne(None, None)
-        result = policy.forget(context, request)
+        result = policy.forget(request)
         self.assertEqual(result, [])
 
 class TestAuthTktCookieHelper(unittest.TestCase):
diff --git a/repoze/bfg/tests/test_secpols.py b/repoze/bfg/tests/test_secpols.py
index 2b0449e89..8f60a0d94 100644
--- a/repoze/bfg/tests/test_secpols.py
+++ b/repoze/bfg/tests/test_secpols.py
@@ -13,19 +13,6 @@ class TestAPIFunctionsSecpolBBB(unittest.TestCase):
         except KeyError:
             pass
 
-    def _testWithWarnings(self, f, *args, **kw):
-        messages = []
-        def showwarning(message, category, filename, lineno, file=None):
-            messages.append(message)
-        try:
-            import warnings
-            _old_showwarning = warnings.showwarning
-            warnings.showwarning = showwarning
-            result = f(*args, **kw)
-            return result, messages
-        finally:
-            warnings.showwarning = _old_showwarning
-
     def _registerSecurityPolicy(self, secpol):
         import zope.component
         from repoze.bfg.secpols import registerBBBAuthn
@@ -49,43 +36,28 @@ class TestAPIFunctionsSecpolBBB(unittest.TestCase):
         self._registerSecurityPolicy(secpol)
         from repoze.bfg.security import authenticated_userid
         request = DummyRequest({})
-        result, warnings = self._testWithWarnings(authenticated_userid,
-                                                  request)
+        result = authenticated_userid(request)
         self.assertEqual(result, 'fred')
-        self.assertEqual(len(warnings), 1)
         
     def test_authenticated_userid_not_registered(self):
         from repoze.bfg.security import authenticated_userid
         request = DummyRequest({})
-        result, warnings = self._testWithWarnings(authenticated_userid,
-                                                  request)
+        result = authenticated_userid(request)
         self.assertEqual(result, None)
-        self.assertEqual(len(warnings), 1)
-
-    def test_authenticated_userid_too_many_args(self):
-        from repoze.bfg.security import authenticated_userid
-        self.assertRaises(TypeError, authenticated_userid, None, None, None)
 
     def test_effective_principals_registered(self):
         secpol = DummySecurityPolicy(False)
         self._registerSecurityPolicy(secpol)
         from repoze.bfg.security import effective_principals
         request = DummyRequest({})
-        result, warnings = self._testWithWarnings(effective_principals, request)
+        result = effective_principals(request)
         self.assertEqual(result, ['fred', 'bob'])
-        self.assertEqual(len(warnings), 1)
         
     def test_effective_principals_not_registered(self):
         from repoze.bfg.security import effective_principals
         request = DummyRequest({})
-        result, warnings = self._testWithWarnings(effective_principals, request)
+        result  = effective_principals(request)
         self.assertEqual(result, [])
-        self.assertEqual(len(warnings), 1)
-
-    def test_effective_principals_too_many_args(self):
-        from repoze.bfg.security import effective_principals
-        self.assertRaises(TypeError, effective_principals, None, None, None)
-
 
     def test_principals_allowed_by_permission_not_registered(self):
         from repoze.bfg.security import principals_allowed_by_permission
@@ -665,25 +637,25 @@ class TestSecurityPolicyToAuthenticationPolicyAdapter(unittest.TestCase):
     def test_authenticated_userid(self):
         secpol = DummySecurityPolicy(None)
         adapter = self._makeOne(secpol)
-        result = adapter.authenticated_userid(None, None)
+        result = adapter.authenticated_userid(None)
         self.assertEqual(result, 'fred')
         
     def test_effective_principals(self):
         secpol = DummySecurityPolicy(None)
         adapter = self._makeOne(secpol)
-        result = adapter.effective_principals(None, None)
+        result = adapter.effective_principals(None)
         self.assertEqual(result, ['fred', 'bob'])
 
     def test_remember(self):
         secpol = DummySecurityPolicy(None)
         adapter = self._makeOne(secpol)
-        result = adapter.remember(None, None, None)
+        result = adapter.remember(None, None)
         self.assertEqual(result, [])
 
     def test_forget(self):
         secpol = DummySecurityPolicy(None)
         adapter = self._makeOne(secpol)
-        result = adapter.forget(None, None)
+        result = adapter.forget(None)
         self.assertEqual(result, [])
 
 class TestSecurityPolicyToAuthorizationPolicyAdapter(unittest.TestCase):
diff --git a/repoze/bfg/tests/test_security.py b/repoze/bfg/tests/test_security.py
index 3f18d3a4a..bb1a54e04 100644
--- a/repoze/bfg/tests/test_security.py
+++ b/repoze/bfg/tests/test_security.py
@@ -230,21 +230,19 @@ class TestAuthenticatedUserId(unittest.TestCase):
     def tearDown(self):
         cleanUp()
 
-    def _callFUT(self, *arg):
+    def _callFUT(self, request):
         from repoze.bfg.security import authenticated_userid
-        return authenticated_userid(*arg)
+        return authenticated_userid(request)
 
     def test_no_authentication_policy(self):
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request)
+        result = self._callFUT(request)
         self.assertEqual(result, None)
 
     def test_with_authentication_policy(self):
         _registerAuthenticationPolicy('yo')
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request)
+        result = self._callFUT(request)
         self.assertEqual(result, 'yo')
 
 class TestEffectivePrincipals(unittest.TestCase):
@@ -254,21 +252,19 @@ class TestEffectivePrincipals(unittest.TestCase):
     def tearDown(self):
         cleanUp()
 
-    def _callFUT(self, *arg):
+    def _callFUT(self, request):
         from repoze.bfg.security import effective_principals
-        return effective_principals(*arg)
+        return effective_principals(request)
 
     def test_no_authentication_policy(self):
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request)
+        result = self._callFUT(request)
         self.assertEqual(result, [])
 
     def test_with_authentication_policy(self):
         _registerAuthenticationPolicy('yo')
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request)
+        result = self._callFUT(request)
         self.assertEqual(result, 'yo')
 
 class TestPrincipalsAllowedByPermission(unittest.TestCase):
@@ -308,14 +304,13 @@ class TestRemember(unittest.TestCase):
     def test_no_authentication_policy(self):
         context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request, 'me')
+        result = self._callFUT(request, 'me')
         self.assertEqual(result, [])
 
     def test_with_authentication_policy(self):
         _registerAuthenticationPolicy('yo')
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request, 'me')
+        result = self._callFUT(request, 'me')
         self.assertEqual(result, 'yo')
 
 class TestForget(unittest.TestCase):
@@ -330,16 +325,14 @@ class TestForget(unittest.TestCase):
         return forget(*arg)
 
     def test_no_authentication_policy(self):
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request)
+        result = self._callFUT(request)
         self.assertEqual(result, [])
 
     def test_with_authentication_policy(self):
         _registerAuthenticationPolicy('yo')
-        context = DummyContext()
         request = DummyRequest({})
-        result = self._callFUT(context, request)
+        result = self._callFUT(request)
         self.assertEqual(result, 'yo')
 
 class DummyContext:
@@ -354,16 +347,16 @@ class DummyAuthenticationPolicy:
     def __init__(self, result):
         self.result = result
 
-    def effective_principals(self, context, request):
+    def effective_principals(self, request):
         return self.result
 
-    def authenticated_userid(self, context, request):
+    def authenticated_userid(self, request):
         return self.result
 
-    def remember(self, context, request, principal, **kw):
+    def remember(self, request, principal, **kw):
         return self.result
 
-    def forget(self, context, request):
+    def forget(self, request):
         return self.result
 
 class DummyAuthorizationPolicy:
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
index 5024c41ba..ff0846881 100644
--- a/repoze/bfg/tests/test_testing.py
+++ b/repoze/bfg/tests/test_testing.py
@@ -222,19 +222,19 @@ class TestDummySecurityPolicy(unittest.TestCase):
 
     def test_authenticated_userid(self):
         policy = self._makeOne('user')
-        self.assertEqual(policy.authenticated_userid(None, None), 'user')
+        self.assertEqual(policy.authenticated_userid(None), 'user')
         
     def test_effective_principals_userid(self):
         policy = self._makeOne('user', ('group1',))
         from repoze.bfg.security import Everyone
         from repoze.bfg.security import Authenticated
-        self.assertEqual(policy.effective_principals(None, None),
+        self.assertEqual(policy.effective_principals(None),
                          [Everyone, Authenticated, 'user', 'group1'])
 
     def test_effective_principals_nouserid(self):
         policy = self._makeOne()
         from repoze.bfg.security import Everyone
-        self.assertEqual(policy.effective_principals(None, None), [Everyone])
+        self.assertEqual(policy.effective_principals(None), [Everyone])
 
     def test_permits(self):
         policy = self._makeOne()
@@ -249,11 +249,11 @@ class TestDummySecurityPolicy(unittest.TestCase):
 
     def test_forget(self):
         policy = self._makeOne()
-        self.assertEqual(policy.forget(None, None), [])
+        self.assertEqual(policy.forget(None), [])
         
     def test_remember(self):
         policy = self._makeOne()
-        self.assertEqual(policy.remember(None, None, None), [])
+        self.assertEqual(policy.remember(None, None), [])