Cleanup test utilities

10 files changed, 116 insertions, 174 deletions

diff --git a/openid/test/test_association_response.py b/openid/test/test_association_response.py
index 62b3175..3e5dfd0 100644
--- a/openid/test/test_association_response.py
+++ b/openid/test/test_association_response.py
@@ -40,10 +40,6 @@ class BaseAssocTest(unittest.TestCase):
         self.consumer = GenericConsumer(self.store)
         self.endpoint = OpenIDServiceEndpoint()
 
-    def failUnlessProtocolError(self, str_prefix, func, *args, **kwargs):
-        with self.assertRaisesRegexp(ProtocolError, str_prefix):
-            func(*args, **kwargs)
-
 
 def mkExtractAssocMissingTest(keys):
     """Factory function for creating test methods for generating
@@ -124,7 +120,8 @@ class ExtractAssociationSessionTypeMismatch(BaseAssocTest):
                 keys.remove('ns')
             msg = mkAssocResponse(*keys)
             msg.setArg(OPENID_NS, 'session_type', response_session_type)
-            self.failUnlessProtocolError('Session type mismatch', self.consumer._extractAssociation, msg, assoc_session)
+            with self.assertRaisesRegexp(ProtocolError, 'Session type mismatch'):
+                self.consumer._extractAssociation(msg, assoc_session)
 
         return test
 
@@ -285,14 +282,14 @@ class TestInvalidFields(BaseAssocTest):
         # Make sure that the assoc type in the response is not valid
         # for the given session.
         self.assoc_session.allowed_assoc_types = []
-        self.failUnlessProtocolError('Unsupported assoc_type for session',
-                                     self.consumer._extractAssociation, self.assoc_response, self.assoc_session)
+        with self.assertRaisesRegexp(ProtocolError, 'Unsupported assoc_type for session'):
+            self.consumer._extractAssociation(self.assoc_response, self.assoc_session)
 
     def test_badExpiresIn(self):
         # Invalid value for expires_in should cause failure
         self.assoc_response.setArg(OPENID_NS, 'expires_in', 'forever')
-        self.failUnlessProtocolError('Invalid expires_in',
-                                     self.consumer._extractAssociation, self.assoc_response, self.assoc_session)
+        with self.assertRaisesRegexp(ProtocolError, 'Invalid expires_in'):
+            self.consumer._extractAssociation(self.assoc_response, self.assoc_session)
 
 
 # XXX: This is what causes most of the imports in this file. It is
@@ -334,4 +331,5 @@ class TestExtractAssociationDiffieHellman(BaseAssocTest):
     def test_badDHValues(self):
         sess, server_resp = self._setUpDH()
         server_resp.setArg(OPENID_NS, 'enc_mac_key', '\x00\x00\x00')
-        self.failUnlessProtocolError('Malformed response for', self.consumer._extractAssociation, server_resp, sess)
+        with self.assertRaisesRegexp(ProtocolError, 'Malformed response for'):
+            self.consumer._extractAssociation(server_resp, sess)
diff --git a/openid/test/test_auth_request.py b/openid/test/test_auth_request.py
index 3f287ac..cc96987 100644
--- a/openid/test/test_auth_request.py
+++ b/openid/test/test_auth_request.py
@@ -2,7 +2,8 @@ import unittest
 
 from openid import message
 from openid.consumer import consumer
-from openid.test import support
+
+from .utils import OpenIDTestMixin
 
 
 class DummyEndpoint(object):
@@ -25,7 +26,7 @@ class DummyAssoc(object):
     handle = "assoc-handle"
 
 
-class AuthRequestTestMixin(support.OpenIDTestMixin):
+class AuthRequestTestMixin(OpenIDTestMixin):
     """Mixin for AuthRequest tests for OpenID 1 and 2; DON'T add
     unittest.TestCase as a base class here."""
 
@@ -44,21 +45,21 @@ class AuthRequestTestMixin(support.OpenIDTestMixin):
         self.assoc = DummyAssoc()
         self.authreq = consumer.AuthRequest(self.endpoint, self.assoc)
 
-    def failUnlessAnonymous(self, msg):
+    def assertAnonymous(self, msg):
         for key in ['claimed_id', 'identity']:
-            self.failIfOpenIDKeyExists(msg, key)
+            self.assertOpenIDKeyMissing(msg, key)
 
-    def failUnlessHasRequiredFields(self, msg):
+    def assertHasRequiredFields(self, msg):
         self.assertEqual(self.authreq.message.getOpenIDNamespace(), self.preferred_namespace)
         self.assertEqual(msg.getOpenIDNamespace(), self.preferred_namespace)
 
-        self.failUnlessOpenIDValueEquals(msg, 'mode',
+        self.assertOpenIDValueEqual(msg, 'mode',
                                          self.expected_mode)
 
         # Implement these in subclasses because they depend on
         # protocol differences!
-        self.failUnlessHasRealm(msg)
-        self.failUnlessIdentifiersPresent(msg)
+        self.assertHasRealm(msg)
+        self.assertIdentifiersPresent(msg)
 
     # TESTS
 
@@ -67,13 +68,13 @@ class AuthRequestTestMixin(support.OpenIDTestMixin):
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
 
-        self.failIfOpenIDKeyExists(msg, 'assoc_handle')
+        self.assertOpenIDKeyMissing(msg, 'assoc_handle')
 
     def test_checkWithAssocHandle(self):
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
 
-        self.failUnlessOpenIDValueEquals(msg, 'assoc_handle',
+        self.assertOpenIDValueEqual(msg, 'assoc_handle',
                                          self.assoc.handle)
 
     def test_addExtensionArg(self):
@@ -95,28 +96,27 @@ class AuthRequestTestMixin(support.OpenIDTestMixin):
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
 
-        self.failUnlessHasIdentifiers(
-            msg, self.endpoint.local_id, self.endpoint.claimed_id)
+        self.assertIdentifiers(msg, self.endpoint.local_id, self.endpoint.claimed_id)
 
 
 class TestAuthRequestOpenID2(AuthRequestTestMixin, unittest.TestCase):
     preferred_namespace = message.OPENID2_NS
 
-    def failUnlessHasRealm(self, msg):
+    def assertHasRealm(self, msg):
         # check presence of proper realm key and absence of the wrong
         # one.
-        self.failUnlessOpenIDValueEquals(msg, 'realm', self.realm)
-        self.failIfOpenIDKeyExists(msg, 'trust_root')
+        self.assertOpenIDValueEqual(msg, 'realm', self.realm)
+        self.assertOpenIDKeyMissing(msg, 'trust_root')
 
-    def failUnlessIdentifiersPresent(self, msg):
+    def assertIdentifiersPresent(self, msg):
         identity_present = msg.hasKey(message.OPENID_NS, 'identity')
         claimed_present = msg.hasKey(message.OPENID_NS, 'claimed_id')
 
         self.assertEqual(claimed_present, identity_present)
 
-    def failUnlessHasIdentifiers(self, msg, op_specific_id, claimed_id):
-        self.failUnlessOpenIDValueEquals(msg, 'identity', op_specific_id)
-        self.failUnlessOpenIDValueEquals(msg, 'claimed_id', claimed_id)
+    def assertIdentifiers(self, msg, op_specific_id, claimed_id):
+        self.assertOpenIDValueEqual(msg, 'identity', op_specific_id)
+        self.assertOpenIDValueEqual(msg, 'claimed_id', claimed_id)
 
     # TESTS
 
@@ -130,43 +130,42 @@ class TestAuthRequestOpenID2(AuthRequestTestMixin, unittest.TestCase):
         self.authreq.setAnonymous(True)
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
-        self.failUnlessHasRequiredFields(msg)
-        self.failUnlessAnonymous(msg)
+        self.assertHasRequiredFields(msg)
+        self.assertAnonymous(msg)
 
     def test_opAnonymousIgnoresIdentifier(self):
         self.endpoint.is_op_identifier = True
         self.authreq.setAnonymous(True)
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
-        self.failUnlessHasRequiredFields(msg)
-        self.failUnlessAnonymous(msg)
+        self.assertHasRequiredFields(msg)
+        self.assertAnonymous(msg)
 
     def test_opIdentifierSendsIdentifierSelect(self):
         self.endpoint.is_op_identifier = True
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
-        self.failUnlessHasRequiredFields(msg)
-        self.failUnlessHasIdentifiers(
-            msg, message.IDENTIFIER_SELECT, message.IDENTIFIER_SELECT)
+        self.assertHasRequiredFields(msg)
+        self.assertIdentifiers(msg, message.IDENTIFIER_SELECT, message.IDENTIFIER_SELECT)
 
 
 class TestAuthRequestOpenID1(AuthRequestTestMixin, unittest.TestCase):
     preferred_namespace = message.OPENID1_NS
 
-    def failUnlessHasIdentifiers(self, msg, op_specific_id, claimed_id):
+    def assertIdentifiers(self, msg, op_specific_id, claimed_id):
         """Make sure claimed_is is *absent* in request."""
-        self.failUnlessOpenIDValueEquals(msg, 'identity', op_specific_id)
-        self.failIfOpenIDKeyExists(msg, 'claimed_id')
+        self.assertOpenIDValueEqual(msg, 'identity', op_specific_id)
+        self.assertOpenIDKeyMissing(msg, 'claimed_id')
 
-    def failUnlessIdentifiersPresent(self, msg):
-        self.failIfOpenIDKeyExists(msg, 'claimed_id')
+    def assertIdentifiersPresent(self, msg):
+        self.assertOpenIDKeyMissing(msg, 'claimed_id')
         self.assertTrue(msg.hasKey(message.OPENID_NS, 'identity'))
 
-    def failUnlessHasRealm(self, msg):
+    def assertHasRealm(self, msg):
         # check presence of proper realm key and absence of the wrong
         # one.
-        self.failUnlessOpenIDValueEquals(msg, 'trust_root', self.realm)
-        self.failIfOpenIDKeyExists(msg, 'realm')
+        self.assertOpenIDValueEqual(msg, 'trust_root', self.realm)
+        self.assertOpenIDKeyMissing(msg, 'realm')
 
     # TESTS
 
@@ -185,7 +184,7 @@ class TestAuthRequestOpenID1(AuthRequestTestMixin, unittest.TestCase):
         self.endpoint.is_op_identifier = True
         msg = self.authreq.getMessage(self.realm, self.return_to,
                                       self.immediate)
-        self.failUnlessHasRequiredFields(msg)
+        self.assertHasRequiredFields(msg)
         self.assertEqual(msg.getArg(message.OPENID1_NS, 'identity'), message.IDENTIFIER_SELECT)
 
 
diff --git a/openid/test/test_ax.py b/openid/test/test_ax.py
index 83fe5cf..3221169 100644
--- a/openid/test/test_ax.py
+++ b/openid/test/test_ax.py
@@ -84,25 +84,22 @@ class ToTypeURIsTest(unittest.TestCase):
 class ParseAXValuesTest(unittest.TestCase):
     """Testing AXKeyValueMessage.parseExtensionArgs."""
 
-    def failUnlessAXKeyError(self, ax_args):
-        msg = ax.AXKeyValueMessage()
-        self.assertRaises(KeyError, msg.parseExtensionArgs, ax_args)
-
-    def failUnlessAXValues(self, ax_args, expected_args):
+    def assertAXValues(self, ax_args, expected_args):
         """Fail unless parseExtensionArgs(ax_args) == expected_args."""
         msg = ax.AXKeyValueMessage()
         msg.parseExtensionArgs(ax_args)
         self.assertEqual(msg.data, expected_args)
 
     def test_emptyIsValid(self):
-        self.failUnlessAXValues({}, {})
+        self.assertAXValues({}, {})
 
     def test_missingValueForAliasExplodes(self):
-        self.failUnlessAXKeyError({'type.foo': 'urn:foo'})
+        msg = ax.AXKeyValueMessage()
+        self.assertRaises(KeyError, msg.parseExtensionArgs, {'type.foo': 'urn:foo'})
 
     def test_countPresentButNotValue(self):
-        self.failUnlessAXKeyError({'type.foo': 'urn:foo',
-                                   'count.foo': '1'})
+        msg = ax.AXKeyValueMessage()
+        self.assertRaises(KeyError, msg.parseExtensionArgs, {'type.foo': 'urn:foo', 'count.foo': '1'})
 
     def test_invalidCountValue(self):
         msg = ax.FetchRequest()
@@ -154,38 +151,22 @@ class ParseAXValuesTest(unittest.TestCase):
                 self.assertRaises(ax.AXError, msg.parseExtensionArgs, input)
 
     def test_countPresentAndIsZero(self):
-        self.failUnlessAXValues(
-            {'type.foo': 'urn:foo',
-             'count.foo': '0',
-             }, {'urn:foo': []})
+        self.assertAXValues({'type.foo': 'urn:foo', 'count.foo': '0'}, {'urn:foo': []})
 
     def test_singletonEmpty(self):
-        self.failUnlessAXValues(
-            {'type.foo': 'urn:foo',
-             'value.foo': '',
-             }, {'urn:foo': []})
+        self.assertAXValues({'type.foo': 'urn:foo', 'value.foo': ''}, {'urn:foo': []})
 
     def test_doubleAlias(self):
-        self.failUnlessAXKeyError(
-            {'type.foo': 'urn:foo',
-             'value.foo': '',
-             'type.bar': 'urn:foo',
-             'value.bar': '',
-             })
+        msg = ax.AXKeyValueMessage()
+        self.assertRaises(KeyError, msg.parseExtensionArgs,
+                          {'type.foo': 'urn:foo', 'value.foo': '', 'type.bar': 'urn:foo', 'value.bar': ''})
 
     def test_doubleSingleton(self):
-        self.failUnlessAXValues(
-            {'type.foo': 'urn:foo',
-             'value.foo': '',
-             'type.bar': 'urn:bar',
-             'value.bar': '',
-             }, {'urn:foo': [], 'urn:bar': []})
+        self.assertAXValues({'type.foo': 'urn:foo', 'value.foo': '', 'type.bar': 'urn:bar', 'value.bar': ''},
+                            {'urn:foo': [], 'urn:bar': []})
 
     def test_singletonValue(self):
-        self.failUnlessAXValues(
-            {'type.foo': 'urn:foo',
-             'value.foo': 'Westfall',
-             }, {'urn:foo': ['Westfall']})
+        self.assertAXValues({'type.foo': 'urn:foo', 'value.foo': 'Westfall'}, {'urn:foo': ['Westfall']})
 
 
 class FetchRequestTest(unittest.TestCase):
@@ -243,10 +224,7 @@ class FetchRequestTest(unittest.TestCase):
         else:
             self.fail("Didn't find the type definition")
 
-        self.failUnlessExtensionArgs({
-            'type.' + alias: attr.type_uri,
-            'if_available': alias,
-        })
+        self.assertExtensionArgs({'type.' + alias: attr.type_uri, 'if_available': alias})
 
     def test_getExtensionArgs_alias_if_available(self):
         attr = ax.AttrInfo(
@@ -254,10 +232,7 @@ class FetchRequestTest(unittest.TestCase):
             alias='transport',
         )
         self.msg.add(attr)
-        self.failUnlessExtensionArgs({
-            'type.' + attr.alias: attr.type_uri,
-            'if_available': attr.alias,
-        })
+        self.assertExtensionArgs({'type.' + attr.alias: attr.type_uri, 'if_available': attr.alias})
 
     def test_getExtensionArgs_alias_req(self):
         attr = ax.AttrInfo(
@@ -266,12 +241,9 @@ class FetchRequestTest(unittest.TestCase):
             required=True,
         )
         self.msg.add(attr)
-        self.failUnlessExtensionArgs({
-            'type.' + attr.alias: attr.type_uri,
-            'required': attr.alias,
-        })
+        self.assertExtensionArgs({'type.' + attr.alias: attr.type_uri, 'required': attr.alias})
 
-    def failUnlessExtensionArgs(self, expected_args):
+    def assertExtensionArgs(self, expected_args):
         """Make sure that getExtensionArgs has the expected result
 
         This method will fill in the mode.
diff --git a/openid/test/test_consumer.py b/openid/test/test_consumer.py
index a427dbf..c3df47b 100644
--- a/openid/test/test_consumer.py
+++ b/openid/test/test_consumer.py
@@ -497,7 +497,7 @@ class TestCompleteMissingSig(unittest.TestCase):
 
         self.consumer._verifyDiscoveryResults = _vrfy
         r = self.consumer.complete(self.message, self.endpoint, None)
-        self.failUnlessSuccess(r)
+        self.assertEqual(r.status, SUCCESS)
 
     def test_idResNoIdentity(self):
         self.message.delArg(OPENID_NS, 'identity')
@@ -505,7 +505,7 @@ class TestCompleteMissingSig(unittest.TestCase):
         self.endpoint.claimed_id = None
         self.message.setArg(OPENID_NS, 'signed', 'return_to,response_nonce,assoc_handle,op_endpoint')
         r = self.consumer.complete(self.message, self.endpoint, None)
-        self.failUnlessSuccess(r)
+        self.assertEqual(r.status, SUCCESS)
 
     def test_idResMissingIdentitySig(self):
         self.message.setArg(OPENID_NS, 'signed', 'return_to,response_nonce,assoc_handle,claimed_id')
@@ -527,10 +527,6 @@ class TestCompleteMissingSig(unittest.TestCase):
         r = self.consumer.complete(self.message, self.endpoint, None)
         self.assertEqual(r.status, FAILURE)
 
-    def failUnlessSuccess(self, response):
-        if response.status != SUCCESS:
-            self.fail("Non-successful response: %s" % (response,))
-
 
 class TestCheckAuthResponse(TestIdRes):
     def setUp(self):
@@ -626,7 +622,8 @@ class TestCheckAuthResponse(TestIdRes):
 
 
 class TestSetupNeeded(TestIdRes):
-    def failUnlessSetupNeeded(self, expected_setup_url, message):
+
+    def assertSetupNeeded(self, expected_setup_url, message):
         with self.assertRaises(SetupNeededError) as catch:
             self.consumer._checkSetupNeeded(message)
         self.assertEqual(catch.exception.user_setup_url, expected_setup_url)
@@ -639,7 +636,7 @@ class TestSetupNeeded(TestIdRes):
             'openid.user_setup_url': setup_url,
         })
         self.assertTrue(message.isOpenID1())
-        self.failUnlessSetupNeeded(setup_url, message)
+        self.assertSetupNeeded(setup_url, message)
 
     def test_setupNeededOpenID1_extra(self):
         """Extra stuff along with setup_url still trigger Setup Needed"""
@@ -650,7 +647,7 @@ class TestSetupNeeded(TestIdRes):
             'openid.identity': 'bogus',
         })
         self.assertTrue(message.isOpenID1())
-        self.failUnlessSetupNeeded(setup_url, message)
+        self.assertSetupNeeded(setup_url, message)
 
     def test_noSetupNeededOpenID1(self):
         """When the user_setup_url is missing on an OpenID 1 message,
@@ -1599,7 +1596,7 @@ class IDPDrivenTest(unittest.TestCase):
         self.consumer._checkReturnTo = lambda unused1, unused2: True
         response = self.consumer._doIdRes(message, self.endpoint, None)
 
-        self.failUnlessSuccess(response)
+        self.assertEqual(response.status, SUCCESS)
         self.assertEqual(response.identity_url, "=directed_identifier")
 
         # assert that discovery attempt happens and returns good
@@ -1621,10 +1618,6 @@ class IDPDrivenTest(unittest.TestCase):
         self.consumer._checkReturnTo = lambda unused1, unused2: True
         self.assertRaises(DiscoveryFailure, self.consumer._doIdRes, message, self.endpoint, None)
 
-    def failUnlessSuccess(self, response):
-        if response.status != SUCCESS:
-            self.fail("Non-successful response: %s" % (response,))
-
 
 class TestDiscoveryVerification(unittest.TestCase):
     services = []
@@ -1893,14 +1886,11 @@ class TestDiscoverAndVerify(unittest.TestCase):
         self.consumer._discover = dummyDiscover
         self.to_match = OpenIDServiceEndpoint()
 
-    def failUnlessDiscoveryFailure(self):
-        self.assertRaises(DiscoveryFailure, self.consumer._discoverAndVerify, 'http://claimed-id.com/', [self.to_match])
-
     def test_noServices(self):
         """Discovery returning no results results in a
         DiscoveryFailure exception"""
         self.discovery_result = (None, [])
-        self.failUnlessDiscoveryFailure()
+        self.assertRaises(DiscoveryFailure, self.consumer._discoverAndVerify, 'http://claimed-id.com/', [self.to_match])
 
     def test_noMatches(self):
         """If no discovered endpoint matches the values from the
@@ -1911,7 +1901,7 @@ class TestDiscoverAndVerify(unittest.TestCase):
         def raiseProtocolError(unused1, unused2):
             raise ProtocolError('unit test')
         self.consumer._verifyDiscoverySingle = raiseProtocolError
-        self.failUnlessDiscoveryFailure()
+        self.assertRaises(DiscoveryFailure, self.consumer._discoverAndVerify, 'http://claimed-id.com/', [self.to_match])
 
     def test_matches(self):
         """If an endpoint matches, we return it
diff --git a/openid/test/test_discover.py b/openid/test/test_discover.py
index 458ed63..9708cee 100644
--- a/openid/test/test_discover.py
+++ b/openid/test/test_discover.py
@@ -708,7 +708,7 @@ class TestEndpointSupportsType(unittest.TestCase):
     def setUp(self):
         self.endpoint = discover.OpenIDServiceEndpoint()
 
-    def failUnlessSupportsOnly(self, *types):
+    def assertSupportsOnly(self, *types):
         for t in [
             'foo',
             discover.OPENID_1_1_TYPE,
@@ -722,39 +722,34 @@ class TestEndpointSupportsType(unittest.TestCase):
                 self.assertFalse(self.endpoint.supportsType(t), "Shouldn't support %r" % (t,))
 
     def test_supportsNothing(self):
-        self.failUnlessSupportsOnly()
+        self.assertSupportsOnly()
 
     def test_openid2(self):
         self.endpoint.type_uris = [discover.OPENID_2_0_TYPE]
-        self.failUnlessSupportsOnly(discover.OPENID_2_0_TYPE)
+        self.assertSupportsOnly(discover.OPENID_2_0_TYPE)
 
     def test_openid2provider(self):
         self.endpoint.type_uris = [discover.OPENID_IDP_2_0_TYPE]
-        self.failUnlessSupportsOnly(discover.OPENID_IDP_2_0_TYPE,
-                                    discover.OPENID_2_0_TYPE)
+        self.assertSupportsOnly(discover.OPENID_IDP_2_0_TYPE, discover.OPENID_2_0_TYPE)
 
     def test_openid1_0(self):
         self.endpoint.type_uris = [discover.OPENID_1_0_TYPE]
-        self.failUnlessSupportsOnly(discover.OPENID_1_0_TYPE)
+        self.assertSupportsOnly(discover.OPENID_1_0_TYPE)
 
     def test_openid1_1(self):
         self.endpoint.type_uris = [discover.OPENID_1_1_TYPE]
-        self.failUnlessSupportsOnly(discover.OPENID_1_1_TYPE)
+        self.assertSupportsOnly(discover.OPENID_1_1_TYPE)
 
     def test_multiple(self):
         self.endpoint.type_uris = [discover.OPENID_1_1_TYPE,
                                    discover.OPENID_2_0_TYPE]
-        self.failUnlessSupportsOnly(discover.OPENID_1_1_TYPE,
-                                    discover.OPENID_2_0_TYPE)
+        self.assertSupportsOnly(discover.OPENID_1_1_TYPE, discover.OPENID_2_0_TYPE)
 
     def test_multipleWithProvider(self):
         self.endpoint.type_uris = [discover.OPENID_1_1_TYPE,
                                    discover.OPENID_2_0_TYPE,
                                    discover.OPENID_IDP_2_0_TYPE]
-        self.failUnlessSupportsOnly(discover.OPENID_1_1_TYPE,
-                                    discover.OPENID_2_0_TYPE,
-                                    discover.OPENID_IDP_2_0_TYPE,
-                                    )
+        self.assertSupportsOnly(discover.OPENID_1_1_TYPE, discover.OPENID_2_0_TYPE, discover.OPENID_IDP_2_0_TYPE)
 
 
 class TestEndpointDisplayIdentifier(unittest.TestCase):
diff --git a/openid/test/test_fetchers.py b/openid/test/test_fetchers.py
index b1c066d..16f615a 100644
--- a/openid/test/test_fetchers.py
+++ b/openid/test/test_fetchers.py
@@ -13,7 +13,7 @@ from openid import fetchers
 # XXX: make these separate test cases
 
 
-def failUnlessResponseExpected(expected, actual):
+def assertResponse(expected, actual):
     assert expected.final_url == actual.final_url, (
         "%r != %r" % (expected.final_url, actual.final_url))
     assert expected.status == actual.status
@@ -63,7 +63,7 @@ def test_fetcher(fetcher, exc, server):
             print fetcher, fetch_url
             raise
         else:
-            failUnlessResponseExpected(expected, actual)
+            assertResponse(expected, actual)
 
     for err_url in [geturl('/closed'),
                     'http://invalid.janrain.com/',
@@ -302,21 +302,21 @@ class TestUrllib2Fetcher(unittest.TestCase):
         self.add_response('http://example.cz/success/', 200, {'Content-Type': 'text/plain'}, 'BODY')
         response = self.fetcher.fetch('http://example.cz/success/')
         expected = fetchers.HTTPResponse('http://example.cz/success/', 200, {'Content-Type': 'text/plain'}, 'BODY')
-        failUnlessResponseExpected(expected, response)
+        assertResponse(expected, response)
 
     def test_redirect(self):
         # Test redirect response - a final response comes from another URL.
         self.add_response('http://example.cz/success/', 200, {'Content-Type': 'text/plain'}, 'BODY')
         response = self.fetcher.fetch('http://example.cz/redirect/')
         expected = fetchers.HTTPResponse('http://example.cz/success/', 200, {'Content-Type': 'text/plain'}, 'BODY')
-        failUnlessResponseExpected(expected, response)
+        assertResponse(expected, response)
 
     def test_error(self):
         # Test error responses - returned as obtained
         self.add_response('http://example.cz/error/', 500, {'Content-Type': 'text/plain'}, 'BODY')
         response = self.fetcher.fetch('http://example.cz/error/')
         expected = fetchers.HTTPResponse('http://example.cz/error/', 500, {'Content-Type': 'text/plain'}, 'BODY')
-        failUnlessResponseExpected(expected, response)
+        assertResponse(expected, response)
 
     def test_invalid_url(self):
         with self.assertRaisesRegexp(self.invalid_url_error, 'Bad URL scheme:'):
@@ -328,7 +328,7 @@ class TestUrllib2Fetcher(unittest.TestCase):
                                                        {'Content-Type': 'text/plain'}, StringIO('BODY'))
         response = self.fetcher.fetch('http://example.cz/error/')
         expected = fetchers.HTTPResponse('http://example.cz/error/', 500, {'Content-Type': 'text/plain'}, 'BODY')
-        failUnlessResponseExpected(expected, response)
+        assertResponse(expected, response)
 
 
 class TestSilencedUrllib2Fetcher(TestUrllib2Fetcher):
diff --git a/openid/test/test_rpverify.py b/openid/test/test_rpverify.py
index 04b693e..cbcb6df 100644
--- a/openid/test/test_rpverify.py
+++ b/openid/test/test_rpverify.py
@@ -17,7 +17,7 @@ class TestBuildDiscoveryURL(unittest.TestCase):
     return_to URL
     """
 
-    def failUnlessDiscoURL(self, realm, expected_discovery_url):
+    def assertDiscoveryURL(self, realm, expected_discovery_url):
         """Build a discovery URL out of the realm and a return_to and
         make sure that it matches the expected discovery URL
         """
@@ -28,20 +28,17 @@ class TestBuildDiscoveryURL(unittest.TestCase):
     def test_trivial(self):
         """There is no wildcard and the realm is the same as the return_to URL
         """
-        self.failUnlessDiscoURL('http://example.com/foo',
-                                'http://example.com/foo')
+        self.assertDiscoveryURL('http://example.com/foo', 'http://example.com/foo')
 
     def test_wildcard(self):
         """There is a wildcard
         """
-        self.failUnlessDiscoURL('http://*.example.com/foo',
-                                'http://www.example.com/foo')
+        self.assertDiscoveryURL('http://*.example.com/foo', 'http://www.example.com/foo')
 
     def test_wildcard_port(self):
         """There is a wildcard
         """
-        self.failUnlessDiscoURL('http://*.example.com:8001/foo',
-                                'http://www.example.com:8001/foo')
+        self.assertDiscoveryURL('http://*.example.com:8001/foo', 'http://www.example.com:8001/foo')
 
 
 class TestExtractReturnToURLs(unittest.TestCase):
@@ -61,29 +58,24 @@ class TestExtractReturnToURLs(unittest.TestCase):
         result.normalized_uri = uri
         return result
 
-    def failUnlessFileHasReturnURLs(self, filename, expected_return_urls):
-        self.failUnlessXRDSHasReturnURLs(file(filename).read(),
-                                         expected_return_urls)
-
-    def failUnlessXRDSHasReturnURLs(self, data, expected_return_urls):
+    def assertReturnURLs(self, data, expected_return_urls):
         self.data = data
-        actual_return_urls = list(trustroot.getAllowedReturnURLs(
-            self.disco_url))
+        actual_return_urls = trustroot.getAllowedReturnURLs(self.disco_url)
 
         self.assertEqual(actual_return_urls, expected_return_urls)
 
-    def failUnlessDiscoveryFailure(self, text):
+    def assertDiscoveryFailure(self, text):
         self.data = text
         self.assertRaises(DiscoveryFailure, trustroot.getAllowedReturnURLs, self.disco_url)
 
     def test_empty(self):
-        self.failUnlessDiscoveryFailure('')
+        self.assertDiscoveryFailure('')
 
     def test_badXML(self):
-        self.failUnlessDiscoveryFailure('>')
+        self.assertDiscoveryFailure('>')
 
     def test_noEntries(self):
-        self.failUnlessXRDSHasReturnURLs('''\
+        self.assertReturnURLs('''\
 <?xml version="1.0" encoding="UTF-8"?>
 <xrds:XRDS xmlns:xrds="xri://$xrds"
            xmlns="xri://$xrd*($v*2.0)"
@@ -94,7 +86,7 @@ class TestExtractReturnToURLs(unittest.TestCase):
 ''', [])
 
     def test_noReturnToEntries(self):
-        self.failUnlessXRDSHasReturnURLs('''\
+        self.assertReturnURLs('''\
 <?xml version="1.0" encoding="UTF-8"?>
 <xrds:XRDS xmlns:xrds="xri://$xrds"
            xmlns="xri://$xrd*($v*2.0)"
@@ -109,7 +101,7 @@ class TestExtractReturnToURLs(unittest.TestCase):
 ''', [])
 
     def test_oneEntry(self):
-        self.failUnlessXRDSHasReturnURLs('''\
+        self.assertReturnURLs('''\
 <?xml version="1.0" encoding="UTF-8"?>
 <xrds:XRDS xmlns:xrds="xri://$xrds"
            xmlns="xri://$xrd*($v*2.0)"
@@ -124,7 +116,7 @@ class TestExtractReturnToURLs(unittest.TestCase):
 ''', ['http://rp.example.com/return'])
 
     def test_twoEntries(self):
-        self.failUnlessXRDSHasReturnURLs('''\
+        self.assertReturnURLs('''\
 <?xml version="1.0" encoding="UTF-8"?>
 <xrds:XRDS xmlns:xrds="xri://$xrds"
            xmlns="xri://$xrd*($v*2.0)"
@@ -143,7 +135,7 @@ class TestExtractReturnToURLs(unittest.TestCase):
 ''', ['http://rp.example.com/return', 'http://other.rp.example.com/return'])
 
     def test_twoEntries_withOther(self):
-        self.failUnlessXRDSHasReturnURLs('''\
+        self.assertReturnURLs('''\
 <?xml version="1.0" encoding="UTF-8"?>
 <xrds:XRDS xmlns:xrds="xri://$xrds"
            xmlns="xri://$xrd*($v*2.0)"
diff --git a/openid/test/test_server.py b/openid/test/test_server.py
index c61878b..ba19206 100644
--- a/openid/test/test_server.py
+++ b/openid/test/test_server.py
@@ -1452,7 +1452,7 @@ class TestAssociate(unittest.TestCase):
         self.assertEqual(reply.getArg(OPENID_NS, 'reference'), reference)
         self.assertEqual(reply.getArg(OPENID_NS, 'contact'), contact)
 
-    def failUnlessExpiresInMatches(self, msg, expected_expires_in):
+    def assertExpiresIn(self, msg, expected_expires_in):
         expires_in_str = msg.getArg(OPENID_NS, 'expires_in', no_default)
         expires_in = int(expires_in_str)
 
@@ -1475,8 +1475,7 @@ class TestAssociate(unittest.TestCase):
         self.assertEqual(rfg("assoc_type"), "HMAC-SHA1")
         self.assertEqual(rfg("assoc_handle"), self.assoc.handle)
 
-        self.failUnlessExpiresInMatches(
-            response.fields, self.signatory.SECRET_LIFETIME)
+        self.assertExpiresIn(response.fields, self.signatory.SECRET_LIFETIME)
 
         self.assertEqual(rfg("mac_key"), oidutil.toBase64(self.assoc.secret))
         self.assertFalse(rfg("session_type"))
@@ -1506,8 +1505,7 @@ class TestAssociate(unittest.TestCase):
         self.assertEqual(rfg("assoc_type"), "HMAC-SHA1")
         self.assertEqual(rfg("assoc_handle"), self.assoc.handle)
 
-        self.failUnlessExpiresInMatches(
-            response.fields, self.signatory.SECRET_LIFETIME)
+        self.assertExpiresIn(response.fields, self.signatory.SECRET_LIFETIME)
 
         self.assertEqual(rfg("mac_key"), oidutil.toBase64(self.assoc.secret))
 
@@ -1524,8 +1522,7 @@ class TestAssociate(unittest.TestCase):
         self.assertEqual(rfg("assoc_type"), "HMAC-SHA1")
         self.assertEqual(rfg("assoc_handle"), self.assoc.handle)
 
-        self.failUnlessExpiresInMatches(
-            response.fields, self.signatory.SECRET_LIFETIME)
+        self.assertExpiresIn(response.fields, self.signatory.SECRET_LIFETIME)
 
         self.assertEqual(rfg("mac_key"), oidutil.toBase64(self.assoc.secret))
         self.assertFalse(rfg("session_type"))
diff --git a/openid/test/test_verifydisco.py b/openid/test/test_verifydisco.py
index ec69a62..12318f3 100644
--- a/openid/test/test_verifydisco.py
+++ b/openid/test/test_verifydisco.py
@@ -4,7 +4,6 @@ from testfixtures import LogCapture, StringComparison
 
 from openid import message
 from openid.consumer import consumer, discover
-from openid.test.support import OpenIDTestMixin
 from openid.test.test_consumer import TestIdRes
 
 
@@ -17,10 +16,7 @@ def const(result):
     return constResult
 
 
-class DiscoveryVerificationTest(OpenIDTestMixin, TestIdRes):
-    def failUnlessProtocolError(self, prefix, callable, *args, **kwargs):
-        with self.assertRaisesRegexp(consumer.ProtocolError, prefix):
-            callable(*args, **kwargs)
+class DiscoveryVerificationTest(TestIdRes):
 
     def test_openID1NoLocalID(self):
         endpoint = discover.OpenIDServiceEndpoint()
@@ -28,8 +24,8 @@ class DiscoveryVerificationTest(OpenIDTestMixin, TestIdRes):
 
         msg = message.Message.fromOpenIDArgs({})
         with LogCapture() as logbook:
-            self.failUnlessProtocolError('Missing required field openid.identity',
-                                         self.consumer._verifyDiscoveryResults, msg, endpoint)
+            with self.assertRaisesRegexp(consumer.ProtocolError, 'Missing required field openid.identity'):
+                self.consumer._verifyDiscoveryResults(msg, endpoint)
         self.assertEqual(logbook.records, [])
 
     def test_openID1NoEndpoint(self):
@@ -49,8 +45,8 @@ class DiscoveryVerificationTest(OpenIDTestMixin, TestIdRes):
                                               'op_endpoint': 'Phone Home',
                                               'identity': 'Jose Lius Borges'})
         with LogCapture() as logbook:
-            self.failUnlessProtocolError('openid.identity is present without',
-                                         self.consumer._verifyDiscoveryResults, msg)
+            with self.assertRaisesRegexp(consumer.ProtocolError, 'openid.identity is present without'):
+                self.consumer._verifyDiscoveryResults(msg)
         self.assertEqual(logbook.records, [])
 
     def test_openID2NoLocalIDClaimed(self):
@@ -58,8 +54,8 @@ class DiscoveryVerificationTest(OpenIDTestMixin, TestIdRes):
                                               'op_endpoint': 'Phone Home',
                                               'claimed_id': 'Manuel Noriega'})
         with LogCapture() as logbook:
-            self.failUnlessProtocolError('openid.claimed_id is present without',
-                                         self.consumer._verifyDiscoveryResults, msg)
+            with self.assertRaisesRegexp(consumer.ProtocolError, 'openid.claimed_id is present without'):
+                self.consumer._verifyDiscoveryResults(msg)
         self.assertEqual(logbook.records, [])
 
     def test_openID2NoIdentifiers(self):
diff --git a/openid/test/support.py b/openid/test/utils.py
index 16f54c7..09ae1a9 100644
--- a/openid/test/support.py
+++ b/openid/test/utils.py
@@ -1,8 +1,12 @@
+"""Test utilities."""
 from openid import message
 
 
 class OpenIDTestMixin(object):
-    def failUnlessOpenIDValueEquals(self, msg, key, expected, ns=None):
+    """Mixin providing custom asserts."""
+
+    def assertOpenIDValueEqual(self, msg, key, expected, ns=None):
+        """Check OpenID message contains key with expected value."""
         if ns is None:
             ns = message.OPENID_NS
 
@@ -11,10 +15,9 @@ class OpenIDTestMixin(object):
         error_message = error_format % (key, expected, actual)
         self.assertEqual(actual, expected, error_message)
 
-    def failIfOpenIDKeyExists(self, msg, key, ns=None):
+    def assertOpenIDKeyMissing(self, msg, key, ns=None):
         if ns is None:
             ns = message.OPENID_NS
 
-        actual = msg.getArg(ns, key)
-        error_message = 'openid.%s unexpectedly present: %s' % (key, actual)
-        self.assertIsNone(actual, error_message)
+        error_message = 'openid.%s unexpectedly present' % key
+        self.assertFalse(msg.hasKey(ns, key), error_message)