Throw in towel on unit test assertion names.

Tres Seaver

2014-12-12 826ba007a16d4a2558239ab690dd1d52c9de6633

Throw in towel on unit test assertion names.

 repoze/who/plugins/tests/test_authtkt.py

@@ -15,9 +15,6 @@
        if self._now_testing is not None:
            self._setNowTesting(self._now_testing)

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

    def _getTargetClass(self):
        from repoze.who.plugins.auth_tkt import AuthTktCookiePlugin
        return AuthTktCookiePlugin
@@ -103,7 +100,7 @@
        self.assertEqual(result['tokens'], [''])
        self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'userid')
        self.assertEqual(result['userdata'], 'userdata')
        self.failUnless('timestamp' in result)
        self.assertTrue('timestamp' in result)
        self.assertEqual(environ['REMOTE_USER_TOKENS'], [''])
        self.assertEqual(environ['REMOTE_USER_DATA'],'userdata')
        self.assertEqual(environ['AUTH_TYPE'],'cookie')
@@ -117,7 +114,7 @@
        self.assertEqual(result['tokens'], [''])
        self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'userid')
        self.assertEqual(result['userdata'], 'userdata')
        self.failUnless('timestamp' in result)
        self.assertTrue('timestamp' in result)
        self.assertEqual(environ['REMOTE_USER_TOKENS'], [''])
        self.assertEqual(environ['REMOTE_USER_DATA'],'userdata')
        self.assertEqual(environ['AUTH_TYPE'],'cookie')
@@ -131,7 +128,7 @@
        self.assertEqual(result['tokens'], [''])
        self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 1)
        self.assertEqual(result['userdata'], 'userid_type:int')
        self.failUnless('timestamp' in result)
        self.assertTrue('timestamp' in result)
        self.assertEqual(environ['REMOTE_USER_TOKENS'], [''])
        self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:int')
        self.assertEqual(environ['AUTH_TYPE'],'cookie')
@@ -145,7 +142,7 @@
        self.assertEqual(result['tokens'], [''])
        self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'userid')
        self.assertEqual(result['userdata'], 'userid_type:unknown')
        self.failUnless('timestamp' in result)
        self.assertTrue('timestamp' in result)
        self.assertEqual(environ['REMOTE_USER_TOKENS'], [''])
        self.assertEqual(environ['REMOTE_USER_DATA'],'userid_type:unknown')
        self.assertEqual(environ['AUTH_TYPE'],'cookie')
@@ -173,7 +170,7 @@
        self.assertEqual(result['tokens'], [''])
        self.assertEqual(result['repoze.who.plugins.auth_tkt.userid'], 'existing')
        self.assertEqual(result['userdata'], 'userdata')
        self.failUnless('timestamp' in result)
        self.assertTrue('timestamp' in result)
        self.assertEqual(environ['REMOTE_USER_TOKENS'], [''])
        self.assertEqual(environ['REMOTE_USER_DATA'],'userdata')
        self.assertEqual(environ['AUTH_TYPE'],'cookie')
@@ -457,7 +454,7 @@
        name, value = result.pop(0)

        self.assertEqual('Set-Cookie', name)
        self.failUnless(
        self.assertTrue(
            value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT'))

    def test_remember_max_age(self):
@@ -475,28 +472,28 @@

        name, value = result.pop(0)
        self.assertEqual('Set-Cookie', name)
        self.failUnless(
        self.assertTrue(
            value.startswith('auth_tkt="%s"; Path=/; Max-Age=500' % tkt),
            value)
        self.failUnless(
        self.assertTrue(
            value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT'))

        name, value = result.pop(0)
        self.assertEqual('Set-Cookie', name)
        self.failUnless(
        self.assertTrue(
            value.startswith(
                'auth_tkt="%s"; Path=/; Domain=example.com; Max-Age=500'
                % tkt), value)
        self.failUnless(
        self.assertTrue(
            value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT'))

        name, value = result.pop(0)
        self.assertEqual('Set-Cookie', name)
        self.failUnless(
        self.assertTrue(
            value.startswith(
                'auth_tkt="%s"; Path=/; Domain=.example.com; Max-Age=500' % tkt),
            value)
        self.failUnless(
        self.assertTrue(
            value.endswith('; Expires=Sun, 08 Nov 2009 16:23:42 GMT'))

    def test_forget(self):
@@ -603,27 +600,27 @@
                                           'max_age': u('500')})
        name, value = result.pop(0)
        self.assertEqual('Set-Cookie', name)
        self.failUnless(isinstance(value, str))
        self.failUnless(
        self.assertTrue(isinstance(value, str))
        self.assertTrue(
            value.startswith('auth_tkt="%s"; Path=/; Max-Age=500' % tkt),
            (value, tkt))
        self.failUnless('; Expires=' in value)
        self.assertTrue('; Expires=' in value)
        
        name,value = result.pop(0)
        self.assertEqual('Set-Cookie', name)
        self.failUnless(
        self.assertTrue(
            value.startswith(
            'auth_tkt="%s"; Path=/; Domain=example.com; Max-Age=500'
            % tkt), value)
        self.failUnless('; Expires=' in value)
        self.assertTrue('; Expires=' in value)

        name,value = result.pop(0)
        self.assertEqual('Set-Cookie', name)
        self.failUnless(
        self.assertTrue(
            value.startswith(
            'auth_tkt="%s"; Path=/; Domain=.example.com; Max-Age=500' % tkt),
            value)
        self.failUnless('; Expires=' in value)
        self.assertTrue('; Expires=' in value)


def dummy_userid_checker(userid):

 repoze/who/plugins/tests/test_basicauth.py

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


class TestBasicAuthPlugin(unittest.TestCase):

    def _getTargetClass(self):
@@ -9,9 +10,6 @@
    def _makeOne(self, *arg, **kw):
        plugin = self._getTargetClass()(*arg, **kw)
        return plugin

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

    def _makeEnviron(self, kw=None):
        from wsgiref.util import setup_testing_defaults
@@ -39,7 +37,7 @@
        for item in app_iter:
            items.append(item)
        response = b''.join(items).decode('utf-8')
        self.failUnless(response.startswith('401 Unauthorized'))
        self.assertTrue(response.startswith('401 Unauthorized'))

    def test_identify_noauthinfo(self):
        plugin = self._makeOne('realm')

 repoze/who/plugins/tests/test_htpasswd.py

@@ -16,12 +16,6 @@
        environ['wsgi.version'] = (1,0)
        return environ

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

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

    def test_implements(self):
        from zope.interface.verify import verifyClass
        from repoze.who.interfaces import IAuthenticator
@@ -110,7 +104,7 @@
        result = plugin.authenticate(environ, creds)
        self.assertEqual(result, None)
        self.assertEqual(len(logger.warnings), 1)
        self.failUnless('could not open htpasswd' in logger.warnings[0])
        self.assertTrue('could not open htpasswd' in logger.warnings[0])

    def test_crypt_check(self):
        import sys
@@ -141,8 +135,8 @@

    def test_plain_check(self):
        from repoze.who.plugins.htpasswd import plain_check
        self.failUnless(plain_check('password', 'password'))
        self.failIf(plain_check('notpassword', 'password'))
        self.assertTrue(plain_check('password', 'password'))
        self.assertFalse(plain_check('notpassword', 'password'))

    def test_factory_no_filename_raises(self):
        from repoze.who.plugins.htpasswd import make_plugin

 repoze/who/plugins/tests/test_redirector.py

@@ -1,12 +1,7 @@
import unittest

class _Base(unittest.TestCase):

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


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

    def _getTargetClass(self):
        from repoze.who.plugins.redirector import RedirectorPlugin
@@ -75,7 +70,7 @@
                               [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[0][0], 'forget')
        self.assertEqual(sr.headers[0][1], '1')
        self.assertEqual(sr.headers[1][0], 'Location')
@@ -111,7 +106,7 @@
            [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[1][0], 'Location')
        url = sr.headers[1][1]
        parts = urlparse(url)
@@ -144,7 +139,7 @@
            [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[1][0], 'Location')
        url = sr.headers[1][1]
        parts = urlparse(url)
@@ -169,7 +164,7 @@
            [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[0][0], "forget")
        self.assertEqual(sr.headers[0][1], "1")
        self.assertEqual(sr.headers[1][0], 'Location')
@@ -195,7 +190,7 @@
            [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[1][0], 'Location')
        url = sr.headers[1][1]
        parts = urlparse(url)
@@ -224,7 +219,7 @@
            [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[1][0], 'Location')
        url = sr.headers[1][1]
        parts = urlparse(url)
@@ -253,7 +248,7 @@
            [('forget', '1')])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[1][0], 'Location')
        url = sr.headers[1][1]
        parts = urlparse(url)
@@ -280,13 +275,13 @@
            [])
        sr = DummyStartResponse()
        result = b''.join(app(environ, sr)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(sr.headers[0][0], 'set-cookie')
        self.assertEqual(sr.headers[0][1], 'a')
        self.assertEqual(sr.headers[1][0], 'set-cookie')
        self.assertEqual(sr.headers[1][1], 'b')

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

    def _callFUT(self, *args, **kw):
        from repoze.who.plugins.redirector import make_plugin

 repoze/who/plugins/tests/test_sql.py

@@ -1,11 +1,7 @@
import unittest

class _Base(unittest.TestCase):

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

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

    def _getTargetClass(self):
        from repoze.who.plugins.sql import SQLAuthenticatorPlugin
@@ -70,7 +66,7 @@
        self.assertEqual(dummy_factory.query, None)
        self.assertEqual(dummy_factory.closed, False)

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

    def _getFUT(self):
        from repoze.who.plugins.sql import default_password_compare
@@ -116,7 +112,7 @@
        result = compare('notpassword', stored)
        self.assertEqual(result, False)

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

    def _getTargetClass(self):
        from repoze.who.plugins.sql import SQLMetadataProviderPlugin
@@ -144,9 +140,9 @@
        self.assertEqual(dummy_factory.closed, True)
        self.assertEqual(identity['md'], [ [1,2,3] ])
        self.assertEqual(dummy_factory.query, 'select foo from bar')
        self.failIf('__userid' in identity)
        self.assertFalse('__userid' in identity)

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

    def _getFUT(self):
        from repoze.who.plugins.sql import make_authenticator_plugin
@@ -183,7 +179,7 @@
        self.assertEqual(plugin.conn_factory, DummyConnFactory)
        self.assertEqual(plugin.compare_fn, make_dummy_connfactory)

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

    def _getFUT(self):
        from repoze.who.plugins.sql import make_metadata_plugin

 repoze/who/tests/test__auth_tkt.py

@@ -1,11 +1,7 @@
import unittest

class _Base(unittest.TestCase):

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

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

    def _getTargetClass(self):
        from .._auth_tkt import AuthTicket
@@ -94,7 +90,7 @@
        self.assertEqual(cookie['oatmeal']['secure'], 'true')
 

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

    def _getTargetClass(self):
        from .._auth_tkt import BadTicket
@@ -114,7 +110,7 @@
        self.assertEqual(exc.expected, 'foo')


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

    def _callFUT(self, secret='SEEKRIT', ticket=None, ip='1.2.3.4'):
        from .._auth_tkt import parse_ticket
@@ -126,7 +122,7 @@
        try:
            self._callFUT(ticket=TICKET)
        except BadTicket as e:
            self.failUnless(e.args[0].startswith(
            self.assertTrue(e.args[0].startswith(
                            'Timestamp is not a hex integer:'))
        else:  # pragma: no cover
            self.fail('Did not raise')
@@ -173,7 +169,7 @@
        self.assertEqual(user_data, 'DATA')


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

    # calculate_digest is not very testable, and fully exercised throug callers.

@@ -191,7 +187,7 @@
    def test_maybe_encode_bytes(self):
        from .._auth_tkt import maybe_encode
        foo = b'foo'
        self.failUnless(maybe_encode(foo) is foo)
        self.assertTrue(maybe_encode(foo) is foo)

    def test_maybe_encode_native_string(self):
        from .._auth_tkt import maybe_encode

 repoze/who/tests/test__compat.py

@@ -1,9 +1,7 @@
import unittest

class CompatTests(unittest.TestCase):

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

    def test_REQUEST_METHOD_miss(self):
        # PEP 3333 says CONTENT_TYPE is mandatory
@@ -45,7 +43,7 @@
        from .._compat import SimpleCookie
        environ = {'HTTP_COOKIE': 'qux=spam'}
        cookies = get_cookies(environ)
        self.failUnless(isinstance(cookies, SimpleCookie))
        self.assertTrue(isinstance(cookies, SimpleCookie))
        self.assertEqual(len(cookies), 1)
        self.assertEqual(cookies['qux'].value, 'spam')
        self.assertEqual(environ['paste.cookies'], (cookies, 'qux=spam'))
@@ -57,7 +55,7 @@
                   'paste.cookies': (object(), 'foo=bar'),
                  }
        cookies = get_cookies(environ)
        self.failUnless(isinstance(cookies, SimpleCookie))
        self.assertTrue(isinstance(cookies, SimpleCookie))
        self.assertEqual(len(cookies), 1)
        self.assertEqual(cookies['qux'].value, 'spam')
        self.assertEqual(environ['paste.cookies'], (cookies, 'qux=spam'))
@@ -71,7 +69,7 @@
                   'paste.cookies': (existing, 'qux=spam'),
                  }
        cookies = get_cookies(environ)
        self.failUnless(cookies is existing)
        self.assertTrue(cookies is existing)

    def test_construct_url(self):
        from .._compat import construct_url
@@ -92,13 +90,13 @@
    def test_must_decode_non_string(self):
        from .._compat import must_decode
        foo = object()
        self.failUnless(must_decode(foo) is foo)
        self.assertTrue(must_decode(foo) is foo)

    def test_must_decode_unicode(self):
        from .._compat import must_decode
        from .._compat import u
        foo = u('foo')
        self.failUnless(must_decode(foo) is foo)
        self.assertTrue(must_decode(foo) is foo)

    def test_must_decode_utf8(self):
        from .._compat import must_decode
@@ -113,7 +111,7 @@
    def test_must_encode_non_string(self):
        from .._compat import must_encode
        foo = object()
        self.failUnless(must_encode(foo) is foo)
        self.assertTrue(must_encode(foo) is foo)

    def test_must_encode_unicode(self):
        from .._compat import must_encode
@@ -124,10 +122,10 @@
    def test_must_encode_utf8(self):
        from .._compat import must_encode
        foo = b'b\xc3\xa2tard'
        self.failUnless(must_encode(foo) is foo)
        self.assertTrue(must_encode(foo) is foo)

    def test_must_encode_latin1(self):
        from .._compat import must_encode
        foo = b'b\xe2tard'
        self.failUnless(must_encode(foo) is foo)
        self.assertTrue(must_encode(foo) is foo)


 repoze/who/tests/test_api.py

@@ -1,14 +1,7 @@
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 Test_get_api(_Base):
class Test_get_api(unittest.TestCase):

    def _callFUT(self, environ):
        from repoze.who.api import get_api
@@ -17,15 +10,15 @@
    def test___call___empty_environ(self):
        environ = {}
        api = self._callFUT(environ)
        self.failUnless(api is None)
        self.assertTrue(api is None)

    def test___call___w_api_in_environ(self):
        expected = object()
        environ = {'repoze.who.api': expected}
        api = self._callFUT(environ)
        self.failUnless(api is expected)
        self.assertTrue(api is expected)

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

    def _getTargetClass(self):
        from repoze.who.api import APIFactory
@@ -87,18 +80,18 @@
        environ = {}
        factory = self._makeOne()
        api = factory(environ)
        self.failUnless(isinstance(api, API))
        self.failUnless(environ['repoze.who.api'] is api)
        self.assertTrue(isinstance(api, API))
        self.assertTrue(environ['repoze.who.api'] is api)

    def test___call___w_api_in_environ(self):
        expected = object()
        environ = {'repoze.who.api': expected}
        factory = self._makeOne()
        api = factory(environ)
        self.failUnless(api is expected)
        self.assertTrue(api is expected)


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

    def _callFUT(self, identifiers, authenticators, challengers, mdproviders):
        from repoze.who.api import make_registries
@@ -142,7 +135,7 @@
        self.assertEqual(name_reg['challenger'], dummy_challenger)
        self.assertEqual(name_reg['mdprovider'], dummy_mdprovider)

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

    def _getFUT(self):
        from repoze.who.api import match_classification
@@ -169,7 +162,7 @@
        # any for either
        self.assertEqual(f(IAuthenticator, plugins, 'buz'), [multi1, multi2])

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

    def _getTargetClass(self):
        from repoze.who.api import API
@@ -277,8 +270,8 @@
                            logger=logger)
        identity = api.authenticate()
        self.assertEqual(identity['repoze.who.userid'], 'chrisid')
        self.failUnless(identity['identifier'] is identifier)
        self.failUnless(identity['authenticator'] is authenticator)
        self.assertTrue(identity['identifier'] is identifier)
        self.assertTrue(identity['authenticator'] is authenticator)

        self.assertEqual(len(logger._info), 1)
        self.assertEqual(logger._info[0], 'request classification: browser')
@@ -302,9 +295,9 @@
        self.assertEqual(logger._info[0], 'request classification: match')
        self.assertEqual(logger._info[1], 'no challenge app returned')
        self.assertEqual(len(logger._debug), 2)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'challengers registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'challengers matched for '
                                        'classification "match": ['))

@@ -326,13 +319,13 @@
        self.assertEqual(environ['challenged'], app)
        self.assertEqual(len(logger._info), 2)
        self.assertEqual(logger._info[0], 'request classification: match')
        self.failUnless(logger._info[1].startswith('challenger plugin '))
        self.failUnless(logger._info[1].endswith(
        self.assertTrue(logger._info[1].startswith('challenger plugin '))
        self.assertTrue(logger._info[1].endswith(
                         '"challenge" returned an app'))
        self.assertEqual(len(logger._debug), 2)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'challengers registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'challengers matched for '
                                        'classification "match": ['))

@@ -358,12 +351,12 @@
        self.assertEqual(identifier.forgotten, identity)
        self.assertEqual(len(logger._info), 3)
        self.assertEqual(logger._info[0], 'request classification: match')
        self.failUnless(logger._info[1].startswith('forgetting via headers '))
        self.assertTrue(logger._info[1].startswith('forgetting via headers '))
        self.assertEqual(logger._info[2], 'no challenge app returned')
        self.assertEqual(len(logger._debug), 2)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'challengers registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'challengers matched for '
                                        'classification "match": ['))

@@ -390,14 +383,14 @@
        self.assertEqual(identifier.forgotten, identity)
        self.assertEqual(len(logger._info), 3)
        self.assertEqual(logger._info[0], 'request classification: match')
        self.failUnless(logger._info[1].startswith('forgetting via headers '))
        self.failUnless(logger._info[2].startswith('challenger plugin '))
        self.failUnless(logger._info[2].endswith(
        self.assertTrue(logger._info[1].startswith('forgetting via headers '))
        self.assertTrue(logger._info[2].startswith('challenger plugin '))
        self.assertTrue(logger._info[2].endswith(
                         '"challenge" returned an app'))
        self.assertEqual(len(logger._debug), 2)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'challengers registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'challengers matched for '
                                        'classification "match": ['))

@@ -426,16 +419,16 @@
        self.assertEqual(challenger._challenged_with[3], FORGET_HEADERS)
        self.assertEqual(len(logger._info), 3)
        self.assertEqual(logger._info[0], 'request classification: match')
        self.failUnless(logger._info[1].startswith(
        self.assertTrue(logger._info[1].startswith(
                                        'forgetting via headers from'))
        self.failUnless(logger._info[1].endswith(repr(FORGET_HEADERS)))
        self.failUnless(logger._info[2].startswith('challenger plugin '))
        self.failUnless(logger._info[2].endswith(
        self.assertTrue(logger._info[1].endswith(repr(FORGET_HEADERS)))
        self.assertTrue(logger._info[2].startswith('challenger plugin '))
        self.assertTrue(logger._info[2].endswith(
                         '"challenge" returned an app'))
        self.assertEqual(len(logger._debug), 2)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'challengers registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'challengers matched for '
                                        'classification "match": ['))

@@ -529,9 +522,9 @@
        self.assertEqual(api.remember(), HEADERS)
        self.assertEqual(len(logger._info), 2)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.failUnless(logger._info[1].startswith(
        self.assertTrue(logger._info[1].startswith(
                                        'remembering via headers from'))
        self.failUnless(logger._info[1].endswith(repr(HEADERS)))
        self.assertTrue(logger._info[1].endswith(repr(HEADERS)))
        self.assertEqual(len(logger._debug), 0)

    def test_remember_w_identity_passed_no_identifier(self):
@@ -553,9 +546,9 @@
        self.assertEqual(api.remember(identity), HEADERS)
        self.assertEqual(len(logger._info), 2)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.failUnless(logger._info[1].startswith(
        self.assertTrue(logger._info[1].startswith(
                                        'remembering via headers from'))
        self.failUnless(logger._info[1].endswith(repr(HEADERS)))
        self.assertTrue(logger._info[1].endswith(repr(HEADERS)))
        self.assertEqual(len(logger._debug), 0)

    def test_forget_identifier_plugin_returns_none(self):
@@ -583,9 +576,9 @@
        self.assertEqual(api.forget(), HEADERS)
        self.assertEqual(len(logger._info), 2)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.failUnless(logger._info[1].startswith(
        self.assertTrue(logger._info[1].startswith(
                                        'forgetting via headers from'))
        self.failUnless(logger._info[1].endswith(repr(HEADERS)))
        self.assertTrue(logger._info[1].endswith(repr(HEADERS)))
        self.assertEqual(len(logger._debug), 0)

    def test_forget_w_identity_passed_no_identifier(self):
@@ -607,9 +600,9 @@
        self.assertEqual(api.forget(identity), HEADERS)
        self.assertEqual(len(logger._info), 2)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.failUnless(logger._info[1].startswith(
        self.assertTrue(logger._info[1].startswith(
                                        'forgetting via headers from'))
        self.failUnless(logger._info[1].endswith(repr(HEADERS)))
        self.assertTrue(logger._info[1].endswith(repr(HEADERS)))
        self.assertEqual(len(logger._debug), 0)

    def test_login_w_identifier_name_hit(self):
@@ -711,7 +704,7 @@
                            authenticators=[('authentic', authenticator)],
                            environ=environ)
        api.logout()
        self.failIf('repoze.who.identity' in environ)
        self.assertFalse('repoze.who.identity' in environ)

    def test__identify_success(self):
        environ = self._makeEnviron()
@@ -750,14 +743,14 @@
        self.assertEqual(len(logger._info), 1)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.assertEqual(len(logger._debug), 4)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'identifier plugins registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'identifier plugins matched for '
                                        'classification "browser": ['))
        self.failUnless(logger._debug[2].startswith(
        self.assertTrue(logger._debug[2].startswith(
                                        'no identity returned from <'))
        self.failUnless(logger._debug[2].endswith('> (None)'))
        self.assertTrue(logger._debug[2].endswith('> (None)'))
        self.assertEqual(logger._debug[3], 'identities found: []')

    def test__identify_success_skip_noresults(self):
@@ -884,15 +877,15 @@
        self.assertEqual(len(logger._info), 1)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.assertEqual(len(logger._debug), 5)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'authenticator plugins registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'authenticator plugins matched for '
                                        'classification "browser": ['))
        self.failUnless(logger._debug[2].startswith('no userid returned from'))
        self.failUnless(logger._debug[3].startswith('userid returned from'))
        self.failUnless(logger._debug[3].endswith('"chris"'))
        self.failUnless(logger._debug[4].startswith(
        self.assertTrue(logger._debug[2].startswith('no userid returned from'))
        self.assertTrue(logger._debug[3].startswith('userid returned from'))
        self.assertTrue(logger._debug[3].endswith('"chris"'))
        self.assertTrue(logger._debug[4].startswith(
                                         'identities authenticated: [((1, 0),'))

    def test__authenticate_success_multiresult(self):
@@ -927,16 +920,16 @@
        self.assertEqual(len(logger._info), 1)
        self.assertEqual(logger._info[0], 'request classification: browser')
        self.assertEqual(len(logger._debug), 5)
        self.failUnless(logger._debug[0].startswith(
        self.assertTrue(logger._debug[0].startswith(
                                        'authenticator plugins registered: ['))
        self.failUnless(logger._debug[1].startswith(
        self.assertTrue(logger._debug[1].startswith(
                                        'authenticator plugins matched for '
                                        'classification "browser": ['))
        self.failUnless(logger._debug[2].startswith('userid returned from'))
        self.failUnless(logger._debug[2].endswith('"chris_id1"'))
        self.failUnless(logger._debug[3].startswith('userid returned from'))
        self.failUnless(logger._debug[3].endswith('"chris_id2"'))
        self.failUnless(logger._debug[4].startswith(
        self.assertTrue(logger._debug[2].startswith('userid returned from'))
        self.assertTrue(logger._debug[2].endswith('"chris_id1"'))
        self.assertTrue(logger._debug[3].startswith('userid returned from'))
        self.assertTrue(logger._debug[3].endswith('"chris_id2"'))
        self.assertTrue(logger._debug[4].startswith(
                                         'identities authenticated: [((0, 0),')
                                         )

@@ -1027,7 +1020,7 @@
        self.assertEqual(identity.get('fuz'), None)


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

    def _getTargetClass(self):
        from repoze.who.api import Identity
@@ -1039,12 +1032,12 @@

    def test_str(self):
        identity = self._makeOne(foo=1)
        self.failUnless(str(identity).startswith('<repoze.who identity'))
        self.assertTrue(str(identity).startswith('<repoze.who identity'))
        self.assertEqual(identity['foo'], 1)

    def test_repr(self):
        identity = self._makeOne(foo=1)
        self.failUnless(str(identity).startswith('<repoze.who identity'))
        self.assertTrue(str(identity).startswith('<repoze.who identity'))
        self.assertEqual(identity['foo'], 1)



 repoze/who/tests/test_classifiers.py

@@ -1,14 +1,7 @@
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 TestDefaultRequestClassifier(_Base):
class TestDefaultRequestClassifier(unittest.TestCase):

    def _getFUT(self):
        from repoze.who.classifiers import default_request_classifier
@@ -24,7 +17,7 @@

    def test_conforms_to_IRequestClassifier(self):
        from repoze.who.interfaces import IRequestClassifier
        self.failUnless(IRequestClassifier.providedBy(self._getFUT()))
        self.assertTrue(IRequestClassifier.providedBy(self._getFUT()))

    def test_classify_dav_method(self):
        classifier = self._getFUT()
@@ -71,7 +64,7 @@
        self.assertEqual(result, 'browser')


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

    def _getFUT(self):
        from repoze.who.classifiers import default_challenge_decider
@@ -79,17 +72,17 @@

    def test_conforms_to_IChallengeDecider(self):
        from repoze.who.interfaces import IChallengeDecider
        self.failUnless(IChallengeDecider.providedBy(self._getFUT()))
        self.assertTrue(IChallengeDecider.providedBy(self._getFUT()))

    def test_challenges_on_401(self):
        decider = self._getFUT()
        self.failUnless(decider({}, '401 Unauthorized', []))
        self.assertTrue(decider({}, '401 Unauthorized', []))

    def test_doesnt_challenges_on_non_401(self):
        decider = self._getFUT()
        self.failIf(decider({}, '200 Ok', []))
        self.assertFalse(decider({}, '200 Ok', []))

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

    def _getFUT(self):
        from repoze.who.classifiers import passthrough_challenge_decider
@@ -97,20 +90,20 @@

    def test_conforms_to_IChallengeDecider(self):
        from repoze.who.interfaces import IChallengeDecider
        self.failUnless(IChallengeDecider.providedBy(self._getFUT()))
        self.assertTrue(IChallengeDecider.providedBy(self._getFUT()))

    def test_challenges_on_bare_401(self):
        decider = self._getFUT()
        self.failUnless(decider({}, '401 Unauthorized', []))
        self.assertTrue(decider({}, '401 Unauthorized', []))

    def test_doesnt_challenges_on_non_401(self):
        decider = self._getFUT()
        self.failIf(decider({}, '200 Ok', []))
        self.assertFalse(decider({}, '200 Ok', []))

    def test_doesnt_challenges_on_401_with_WWW_Authenticate(self):
        decider = self._getFUT()
        self.failIf(decider({}, '401 Ok', [('WWW-Authenticate', 'xxx')]))
        self.assertFalse(decider({}, '401 Ok', [('WWW-Authenticate', 'xxx')]))

    def test_doesnt_challenges_on_401_with_text_html(self):
        decider = self._getFUT()
        self.failIf(decider({}, '401 Ok', [('Content-Type', 'text/html')]))
        self.assertFalse(decider({}, '401 Ok', [('Content-Type', 'text/html')]))

 repoze/who/tests/test_config.py

@@ -1,11 +1,7 @@
import unittest

class _Base(unittest.TestCase):

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

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

    def _getTargetClass(self):
        from repoze.who.config import WhoConfig
@@ -60,10 +56,10 @@
        config = self._makeOne()
        config.parse(PLUGINS_ONLY)
        self.assertEqual(len(config.plugins), 2)
        self.failUnless(isinstance(config.plugins['foo'],
        self.assertTrue(isinstance(config.plugins['foo'],
                                   DummyPlugin))
        bar = config.plugins['bar']
        self.failUnless(isinstance(bar, DummyPlugin))
        self.assertTrue(isinstance(bar, DummyPlugin))
        self.assertEqual(bar.credentials, 'qux')

    def test_parse_general_empty(self):
@@ -82,8 +78,8 @@
        PLUGIN_CLASS = self._getDummyPluginClass(IDummy)
        config = self._makeOne()
        config.parse(GENERAL_ONLY)
        self.failUnless(isinstance(config.request_classifier, PLUGIN_CLASS))
        self.failUnless(isinstance(config.challenge_decider, PLUGIN_CLASS))
        self.assertTrue(isinstance(config.request_classifier, PLUGIN_CLASS))
        self.assertTrue(isinstance(config.challenge_decider, PLUGIN_CLASS))
        self.assertEqual(config.remote_user_key, 'ANOTHER_REMOTE_USER')
        self.assertEqual(len(config.plugins), 0)

@@ -95,8 +91,8 @@
        PLUGIN_CLASS = self._getDummyPluginClass(IDummy)
        config = self._makeOne()
        config.parse(GENERAL_WITH_PLUGINS)
        self.failUnless(isinstance(config.request_classifier, PLUGIN_CLASS))
        self.failUnless(isinstance(config.challenge_decider, PLUGIN_CLASS))
        self.assertTrue(isinstance(config.request_classifier, PLUGIN_CLASS))
        self.assertTrue(isinstance(config.challenge_decider, PLUGIN_CLASS))

    def test_parse_identifiers_only(self):
        from repoze.who.interfaces import IIdentifier
@@ -107,11 +103,11 @@
        self.assertEqual(len(identifiers), 2)
        first, second = identifiers
        self.assertEqual(first[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IIdentifier], 'klass1')
        self.assertEqual(second[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_identifiers_with_plugins(self):
        from repoze.who.interfaces import IIdentifier
@@ -122,11 +118,11 @@
        self.assertEqual(len(identifiers), 2)
        first, second = identifiers
        self.assertEqual(first[0], 'foo')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IIdentifier], 'klass1')
        self.assertEqual(second[0], 'bar')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_authenticators_only(self):
        from repoze.who.interfaces import IAuthenticator
@@ -137,11 +133,11 @@
        self.assertEqual(len(authenticators), 2)
        first, second = authenticators
        self.assertEqual(first[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IAuthenticator], 'klass1')
        self.assertEqual(second[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_authenticators_with_plugins(self):
        from repoze.who.interfaces import IAuthenticator
@@ -152,11 +148,11 @@
        self.assertEqual(len(authenticators), 2)
        first, second = authenticators
        self.assertEqual(first[0], 'foo')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IAuthenticator], 'klass1')
        self.assertEqual(second[0], 'bar')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_challengers_only(self):
        from repoze.who.interfaces import IChallenger
@@ -167,11 +163,11 @@
        self.assertEqual(len(challengers), 2)
        first, second = challengers
        self.assertEqual(first[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IChallenger], 'klass1')
        self.assertEqual(second[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_challengers_with_plugins(self):
        from repoze.who.interfaces import IChallenger
@@ -182,11 +178,11 @@
        self.assertEqual(len(challengers), 2)
        first, second = challengers
        self.assertEqual(first[0], 'foo')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IChallenger], 'klass1')
        self.assertEqual(second[0], 'bar')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_mdproviders_only(self):
        from repoze.who.interfaces import IMetadataProvider
@@ -197,11 +193,11 @@
        self.assertEqual(len(mdproviders), 2)
        first, second = mdproviders
        self.assertEqual(first[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IMetadataProvider], 'klass1')
        self.assertEqual(second[0], 'repoze.who.tests.test_config:DummyPlugin')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_mdproviders_with_plugins(self):
        from repoze.who.interfaces import IMetadataProvider
@@ -212,11 +208,11 @@
        self.assertEqual(len(mdproviders), 2)
        first, second = mdproviders
        self.assertEqual(first[0], 'foo')
        self.failUnless(isinstance(first[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(first[1], PLUGIN_CLASS))
        self.assertEqual(len(first[1].classifications), 1)
        self.assertEqual(first[1].classifications[IMetadataProvider], 'klass1')
        self.assertEqual(second[0], 'bar')
        self.failUnless(isinstance(second[1], PLUGIN_CLASS))
        self.assertTrue(isinstance(second[1], PLUGIN_CLASS))

    def test_parse_make_plugin_names(self):
        # see http://bugs.repoze.org/issue92
@@ -224,7 +220,7 @@
        config.parse(MAKE_PLUGIN_ARG_NAMES)
        self.assertEqual(len(config.plugins), 1)
        foo = config.plugins['foo']
        self.failUnless(isinstance(foo, DummyPlugin))
        self.assertTrue(isinstance(foo, DummyPlugin))
        self.assertEqual(foo.iface, 'iface')
        self.assertEqual(foo.name, 'name')
        self.assertEqual(foo.template, '%(template)s')
@@ -352,7 +348,7 @@
template_with_eq = template_with_eq = %%(template_with_eq)s
"""

class TestConfigMiddleware(_Base):
class TestConfigMiddleware(unittest.TestCase):
    _tempdir = None

    def setUp(self):
@@ -391,7 +387,7 @@
        self.assertEqual(len(api_factory.authenticators), 1)
        self.assertEqual(len(api_factory.challengers), 2)
        self.assertEqual(len(api_factory.mdproviders), 0)
        self.failUnless(middleware.logger, middleware.logger)
        self.assertTrue(middleware.logger, middleware.logger)
        self.assertEqual(middleware.logger.getEffectiveLevel(), logging.DEBUG)

    def test_sample_config_no_log_level(self):
@@ -417,7 +413,7 @@
        self.assertEqual(middleware.logger.getEffectiveLevel(), logging.WARN)
        handlers = middleware.logger.handlers
        self.assertEqual(len(handlers), 1)
        self.failUnless(isinstance(handlers[0], logging.StreamHandler))
        self.assertTrue(isinstance(handlers[0], logging.StreamHandler))
        self.assertEqual(handlers[0].stream.name, logfile)
        logging.shutdown()
        handlers[0].stream.close()
@@ -433,10 +429,10 @@
        self.assertEqual(middleware.logger.getEffectiveLevel(), logging.INFO)
        handlers = middleware.logger.handlers
        self.assertEqual(len(handlers), 1)
        self.failUnless(isinstance(handlers[0], NullHandler))
        self.assertTrue(isinstance(handlers[0], NullHandler))
        logging.shutdown()

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

    def _getTargetClass(self):
        from repoze.who.config import NullHandler
@@ -448,13 +444,13 @@
    def test_inheritance(self):
        import logging
        handler = self._makeOne()
        self.failUnless(isinstance(handler, logging.Handler))
        self.assertTrue(isinstance(handler, logging.Handler))

    def test_emit_doesnt_raise_NotImplementedError(self):
        handler = self._makeOne()
        handler.emit(object())

class Test_make_api_factory_with_config(_Base):
class Test_make_api_factory_with_config(unittest.TestCase):
    _tempdir = None

    def setUp(self):
@@ -492,8 +488,8 @@
            self.assertEqual(len(api_factory.challengers), 0)
            self.assertEqual(len(api_factory.mdproviders), 0)
            self.assertEqual(api_factory.remote_user_key, 'REMOTE_USER')
            self.failUnless(api_factory.logger is None)
            self.failUnless(warned)
            self.assertTrue(api_factory.logger is None)
            self.assertTrue(warned)

    def test_bad_config_content(self):
        import warnings
@@ -507,8 +503,8 @@
            self.assertEqual(len(api_factory.challengers), 0)
            self.assertEqual(len(api_factory.mdproviders), 0)
            self.assertEqual(api_factory.remote_user_key, 'REMOTE_USER')
            self.failUnless(api_factory.logger is None)
            self.failUnless(warned)
            self.assertTrue(api_factory.logger is None)
            self.assertTrue(warned)

    def test_sample_config_no_logger(self):
        factory = self._getFactory()
@@ -520,7 +516,7 @@
        self.assertEqual(len(api_factory.challengers), 2)
        self.assertEqual(len(api_factory.mdproviders), 0)
        self.assertEqual(api_factory.remote_user_key, 'REMOTE_USER')
        self.failUnless(api_factory.logger is None)
        self.assertTrue(api_factory.logger is None)

    def test_sample_config_w_remote_user_key(self):
        factory = self._getFactory()
@@ -544,7 +540,7 @@
        self.assertEqual(len(api_factory.authenticators), 1)
        self.assertEqual(len(api_factory.challengers), 2)
        self.assertEqual(len(api_factory.mdproviders), 0)
        self.failUnless(api_factory.logger is logger)
        self.assertTrue(api_factory.logger is logger)

SAMPLE_CONFIG = """\
[plugin:redirector]

 repoze/who/tests/test_middleware.py

@@ -1,11 +1,7 @@
import unittest

class _Base(unittest.TestCase):

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

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

    def _getTargetClass(self):
        from repoze.who.middleware import PluggableAuthenticationMiddleware
@@ -240,7 +236,7 @@
        start_response = DummyStartResponse()
        result = b''.join(mw(environ, start_response)).decode('ascii')
        self.assertEqual(environ['challenged'], challenge_app)
        self.failUnless(result.startswith('401 Unauthorized'))
        self.assertTrue(result.startswith('401 Unauthorized'))

    def test_call_401_challenger_and_identifier_no_authenticator(self):
        from webob.exc import HTTPUnauthorized
@@ -259,7 +255,7 @@

        result = b''.join(mw(environ, start_response)).decode('ascii')
        self.assertEqual(environ['challenged'], challenge_app)
        self.failUnless(result.startswith('401 Unauthorized'))
        self.assertTrue(result.startswith('401 Unauthorized'))
        self.assertEqual(identifier.forgotten, False)
        self.assertEqual(environ.get('REMOTE_USER'), None)

@@ -282,7 +278,7 @@
        start_response = DummyStartResponse()
        result = b''.join(mw(environ, start_response)).decode('ascii')
        self.assertEqual(environ['challenged'], challenge_app)
        self.failUnless(result.startswith('401 Unauthorized'))
        self.assertTrue(result.startswith('401 Unauthorized'))
        # @@ unfuck
##         self.assertEqual(identifier.forgotten, identifier.credentials)
        self.assertEqual(environ['REMOTE_USER'], 'chris')
@@ -391,7 +387,7 @@
                           mdproviders=mdproviders)
        start_response = DummyStartResponse()
        result = b''.join(mw(environ, start_response)).decode('ascii')
        self.failUnless(result.startswith('302 Found'))
        self.assertTrue(result.startswith('302 Found'))
        self.assertEqual(start_response.status, '302 Found')
        headers = start_response.headers
        #self.assertEqual(len(headers), 3, headers)
@@ -402,7 +398,7 @@
        self.assertEqual(headers[3],
                         ('a', '1'))
        self.assertEqual(start_response.exc_info, None)
        self.failIf('repoze.who.application' in environ)
        self.assertFalse('repoze.who.application' in environ)

    def test_call_app_doesnt_call_start_response(self):
        from webob.exc import HTTPUnauthorized
@@ -449,8 +445,8 @@
                           mdproviders=mdproviders)
        start_response = DummyStartResponse()
        result = b''.join(mw(environ, start_response)).decode('ascii')
        self.failUnless(result.startswith('401 Unauthorized'))
        self.failUnless(app._iterable._closed)
        self.assertTrue(result.startswith('401 Unauthorized'))
        self.assertTrue(app._iterable._closed)

    def test_call_w_challenge_but_no_challenger_still_closes_iterable(self):
        environ = self._makeEnviron()
@@ -470,12 +466,12 @@
                           mdproviders=mdproviders)
        start_response = DummyStartResponse()
        self.assertRaises(RuntimeError, mw, environ, start_response)
        self.failUnless(app._iterable._closed)
        self.assertTrue(app._iterable._closed)

    # XXX need more call tests:
    #  - auth_id sorting

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

    def _getTargetClass(self):
        from repoze.who.middleware import StartResponseWrapper
@@ -489,7 +485,7 @@
        wrapper = self._makeOne(None)
        self.assertEqual(wrapper.start_response, None)
        self.assertEqual(wrapper.headers, [])
        self.failUnless(wrapper.buffer)
        self.assertTrue(wrapper.buffer)

    def test_finish_response(self):
        from repoze.who._compat import StringIO
@@ -520,7 +516,7 @@
        self.assertEqual(datases[0], 'written')
        self.assertEqual(closededs[0], True)

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

    def _callFUT(self, iterable):
        from repoze.who.middleware import wrap_generator
@@ -549,11 +545,11 @@
            yield 'b'
        iterable = DummyIterableWithClose(gen())
        newgen = self._callFUT(iterable)
        self.failIf(iterable._closed)
        self.assertFalse(iterable._closed)
        self.assertEqual(list(newgen), ['a', 'b'])
        self.failUnless(iterable._closed)
        self.assertTrue(iterable._closed)

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

    def setUp(self):
        import os

 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,19 +9,19 @@
    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
@@ -41,13 +33,13 @@

        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
@@ -114,7 +106,7 @@
        self.assertEqual(len(_tested), 1)
        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,9 +122,9 @@

        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()
@@ -141,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()
@@ -154,10 +146,10 @@
                     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(object):