Merge lp:~fgallina/django-openid-auth/auth-tests-refactor into lp:django-openid-auth

[Fabián Ezequiel Gallina]

Better response factories for auth module tests

Current response factories are tightly bound to particular extensions
and do not allow to easily extend responses to combine one or more
extensions in our tests (e.g. sreg+pape). This commit changes the way
responses are constructed by allowing to compose extensions into a
single response.

[Para Siva (psivaa)]

This looks to be a very neat refactor to me. Individual tests become less verbose and clear. +1

review: Approve

[lp:~fgallina/django-openid-auth/auth-tests-refactor]

120. By Fabián Ezequiel Gallina on 2016-08-17

Provide more flexible server URL and claimed_id setup for auth test responses

[Ricardo Kirkner (ricardokirkner)]

LGTM, nice refactoring.

review: Approve

=== modified file 'django_openid_auth/tests/test_auth.py'
--- django_openid_auth/tests/test_auth.py	2016-08-12 12:03:47 +0000
+++ django_openid_auth/tests/test_auth.py	2016-08-17 14:55:56 +0000
@@ -29,6 +29,7 @@
 from __future__ import unicode_literals
 
 import re
+from urlparse import urljoin
 
 from django.contrib.auth.models import Group, Permission, User
 from django.test import TestCase
@@ -60,45 +61,33 @@
 
 SREG_NS = "http://openid.net/sreg/1.0"
 AX_NS = "http://openid.net/srv/ax/1.0"
-
-
-@override_session_serializer
-@override_settings(
-    OPENID_USE_EMAIL_FOR_USERNAME=False,
-    OPENID_LAUNCHPAD_TEAMS_REQUIRED=[],
-    OPENID_LAUNCHPAD_TEAMS_MAPPING_AUTO=False,
-    OPENID_EMAIL_WHITELIST_REGEXP_LIST=[])
-class OpenIDBackendTests(TestCase):
-
-    def setUp(self):
-        super(OpenIDBackendTests, self).setUp()
-        self.backend = OpenIDBackend()
-
-    def make_openid_response(self, sreg_args=None, teams_args=None):
-        endpoint = OpenIDServiceEndpoint()
-        endpoint.claimed_id = 'some-id'
-        endpoint.server_url = 'http://example.com/'
-
-        message = Message(OPENID2_NS)
-        if sreg_args is not None:
-            for key, value in sreg_args.items():
-                message.setArg(SREG_NS, key, value)
-        if teams_args is not None:
-            for key, value in teams_args.items():
-                message.setArg(TEAMS_NS, key, value)
-        response = SuccessResponse(
-            endpoint, message, signed_fields=message.toPostArgs().keys())
-        return response
-
-    def make_response_ax(
-            self, schema="http://axschema.org/",
-            fullname="Some User", nickname="someuser", email="[e-mail]",
-            first=None, last=None, verified=False):
-        endpoint = OpenIDServiceEndpoint()
-        endpoint.claimed_id = 'some-id'
-        endpoint.server_url = 'http://example.com/'
-
-        message = Message(OPENID2_NS)
+SERVER_URL = 'http://example.com'
+
+
+def make_claimed_id(id_):
+    return urljoin(SERVER_URL, id_)
+
+
+class TestMessage(Message):
+    """Convenience class to construct test OpenID messages and responses."""
+
+    def __init__(self, openid_namespace=OPENID2_NS):
+        super(TestMessage, self).__init__(openid_namespace=openid_namespace)
+        endpoint = OpenIDServiceEndpoint()
+        endpoint.claimed_id = make_claimed_id('some-id')
+        endpoint.server_url = SERVER_URL
+        self.endpoint = endpoint
+
+    def set_ax_args(
+            self,
+            email="[e-mail]",
+            first=None,
+            fullname="Some User",
+            last=None,
+            nickname="someuser",
+            schema="http://axschema.org/",
+            verified=False):
+
         attributes = [
             ("nickname", schema + "namePerson/friendly", nickname),
             ("fullname", schema + "namePerson", fullname),
@@ -114,23 +103,49 @@
             attributes.append(
                 ("last", "http://axschema.org/namePerson/last", last))
 
-        message.setArg(AX_NS, "mode", "fetch_response")
+        self.setArg(AX_NS, "mode", "fetch_response")
         for (alias, uri, value) in attributes:
-            message.setArg(AX_NS, "type.%s" % alias, uri)
-            message.setArg(AX_NS, "value.%s" % alias, value)
+            self.setArg(AX_NS, "type.%s" % alias, uri)
+            self.setArg(AX_NS, "value.%s" % alias, value)
+
+    def set_pape_args(self, *auth_policies):
+        self.setArg(pape.ns_uri, 'auth_policies', ' '.join(auth_policies))
+
+    def set_sreg_args(self, **kwargs):
+        for key, value in kwargs.items():
+            self.setArg(SREG_NS, key, value)
+
+    def set_team_args(self, **kwargs):
+        for key, value in kwargs.items():
+            self.setArg(TEAMS_NS, key, value)
+
+    def to_response(self):
         return SuccessResponse(
-            endpoint, message, signed_fields=message.toPostArgs().keys())
-
-    def make_user_openid(self, user=None,
-                         claimed_id='http://example.com/existing_identity',
-                         display_id='http://example.com/existing_identity'):
+            self.endpoint, self, signed_fields=self.toPostArgs().keys())
+
+
+@override_session_serializer
+@override_settings(
+    OPENID_USE_EMAIL_FOR_USERNAME=False,
+    OPENID_LAUNCHPAD_TEAMS_REQUIRED=[],
+    OPENID_LAUNCHPAD_TEAMS_MAPPING_AUTO=False,
+    OPENID_EMAIL_WHITELIST_REGEXP_LIST=[])
+class OpenIDBackendTests(TestCase):
+
+    def setUp(self):
+        super(OpenIDBackendTests, self).setUp()
+        self.backend = OpenIDBackend()
+        self.message = TestMessage()
+
+    def make_user_openid(
+            self, user=None, claimed_id=make_claimed_id('existing_identity')):
         if user is None:
             user = User.objects.create_user(
                 username='someuser', email='[e-mail]',
                 password='12345678')
 
         user_openid, created = UserOpenID.objects.get_or_create(
-            user=user, claimed_id=claimed_id, display_id=display_id)
+            user=user, claimed_id=claimed_id, display_id=claimed_id)
         return user_openid
 
     def _assert_account_verified(self, user, expected):
@@ -170,16 +185,19 @@
                                    expected['last_name']),
             'email': expected['email'],
         }
-        response = self.make_openid_response(sreg_args=data)
+        self.message.set_sreg_args(**data)
 
-        details = self.backend._extract_user_details(response)
+        details = self.backend._extract_user_details(
+            self.message.to_response())
         self.assertEqual(details, expected)
 
     def test_extract_user_details_ax(self):
-        response = self.make_response_ax(
-            fullname="Some User", nickname="someuser", email="[e-mail]")
-
-        data = self.backend._extract_user_details(response)
+        self.message.set_ax_args(
+            email="[e-mail]",
+            fullname="Some User",
+            nickname="someuser",
+        )
+        data = self.backend._extract_user_details(self.message.to_response())
 
         self.assertEqual(data, {"nickname": "someuser",
                                 "first_name": "Some",
@@ -190,10 +208,9 @@
     def test_extract_user_details_ax_split_name(self):
         # Include fullname too to show that the split data takes
         # precedence.
-        response = self.make_response_ax(
+        self.message.set_ax_args(
             fullname="Bad Data", first="Some", last="User")
-
-        data = self.backend._extract_user_details(response)
+        data = self.backend._extract_user_details(self.message.to_response())
 
         self.assertEqual(data, {"nickname": "someuser",
                                 "first_name": "Some",
@@ -202,11 +219,10 @@
                                 "account_verified": False})
 
     def test_extract_user_details_ax_broken_myopenid(self):
-        response = self.make_response_ax(
+        self.message.set_ax_args(
             schema="http://schema.openid.net/", fullname="Some User",
             nickname="someuser", email="[e-mail]")
-
-        data = self.backend._extract_user_details(response)
+        data = self.backend._extract_user_details(self.message.to_response())
 
         self.assertEqual(data, {"nickname": "someuser",
                                 "first_name": "Some",
@@ -215,7 +231,7 @@
                                 "account_verified": False})
 
     def test_update_user_details_long_names(self):
-        response = self.make_response_ax()
+        self.message.set_ax_args()
         user = User.objects.create_user(
             'someuser', '[e-mail]', password=None)
         user_openid, created = UserOpenID.objects.get_or_create(
@@ -227,7 +243,8 @@
             last_name=u"User56789012345678901234567890123",
             email=u"[e-mail]", account_verified=False)
 
-        self.backend.update_user_details(user, data, response)
+        self.backend.update_user_details(
+            user, data, self.message.to_response())
 
         self.assertEqual("Some56789012345678901234567890",  user.first_name)
         self.assertEqual("User56789012345678901234567890",  user.last_name)
@@ -247,12 +264,13 @@
             self.assert_account_not_verified(user)
 
         # get a response including verification status
-        response = self.make_response_ax()
+        self.message.set_ax_args()
         data = dict(first_name=u"Some56789012345678901234567890123",
                     last_name=u"User56789012345678901234567890123",
                     email=u"[e-mail]",
                     account_verified=verified)
-        self.backend.update_user_details(user, data, response)
+        self.backend.update_user_details(
+            user, data, self.message.to_response())
 
         # refresh object from the database
         user = User.objects.get(pk=user.pk)
@@ -283,17 +301,17 @@
             initially_verified=False, verified=False)
 
     def test_extract_user_details_name_with_trailing_space(self):
-        response = self.make_response_ax(fullname="SomeUser ")
+        self.message.set_ax_args(fullname="SomeUser ")
 
-        data = self.backend._extract_user_details(response)
+        data = self.backend._extract_user_details(self.message.to_response())
 
         self.assertEqual("", data['first_name'])
         self.assertEqual("SomeUser", data['last_name'])
 
     def test_extract_user_details_name_with_thin_space(self):
-        response = self.make_response_ax(fullname=u"Some\u2009User")
+        self.message.set_ax_args(fullname=u"Some\u2009User")
 
-        data = self.backend._extract_user_details(response)
+        data = self.backend._extract_user_details(self.message.to_response())
 
         self.assertEqual("Some", data['first_name'])
         self.assertEqual("User", data['last_name'])
@@ -330,10 +348,10 @@
     def test_authenticate_when_not_member_of_teams_required(self):
         Group.objects.create(name='team')
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser')
+        self.message.set_team_args(is_member='foo')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNone(user)
 
@@ -343,10 +361,10 @@
     def test_authenticate_when_no_group_mapping_to_required_team(self):
         assert Group.objects.filter(name='team').count() == 0
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser')
+        self.message.set_team_args(is_member='foo')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNone(user)
 
@@ -356,19 +374,19 @@
     def test_authenticate_when_member_of_teams_required(self):
         Group.objects.create(name='team')
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser'),
-            teams_args=dict(is_member='foo,team'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser')
+        self.message.set_team_args(is_member='foo,team')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
     @override_settings(OPENID_LAUNCHPAD_TEAMS_REQUIRED=[])
     def test_authenticate_when_no_teams_required(self):
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser'),
-            teams_args=dict(is_member='team'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser')
+        self.message.set_team_args(is_member='team')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
@@ -378,10 +396,10 @@
     def test_authenticate_when_member_of_at_least_one_team(self):
         Group.objects.create(name='team1')
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser'),
-            teams_args=dict(is_member='foo,team1'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser')
+        self.message.set_team_args(is_member='foo,team1')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
@@ -393,17 +411,17 @@
             self):
         assert Group.objects.filter(name='team').count() == 0
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(
+            nickname='someuser', email='[e-mail]')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(
+            nickname='someuser', email='[e-mail]')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
@@ -414,10 +432,9 @@
     def test_authenticate_whitelisted_email_multiple_patterns(self):
         assert Group.objects.filter(name='team').count() == 0
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser', email='[e-mail]')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
@@ -428,10 +445,10 @@
     def test_authenticate_whitelisted_email_not_match(self):
         assert Group.objects.filter(name='team').count() == 0
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='someuser', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='someuser', email='[e-mail]')
+        self.message.set_team_args(is_member='foo')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNone(user)
 
@@ -459,24 +476,21 @@
 
     @override_settings(OPENID_CREATE_USERS=False)
     def test_auth_no_create_users(self):
-        response = self.make_openid_response(
-            sreg_args=dict(email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args()
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNone(user)
         self.assert_no_users_created()
 
     @override_settings(OPENID_CREATE_USERS=False)
     def test_auth_no_create_users_existing_user(self):
-        response = self.make_openid_response(
-            sreg_args=dict(email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
+        self.message.set_sreg_args()
         existing_openid = self.make_user_openid(
-            claimed_id=response.identity_url)
+            claimed_id=self.message.endpoint.claimed_id)
         expected_user_count = User.objects.count()
-
-        user = self.backend.authenticate(openid_response=response)
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
         self.assertEqual(user, existing_openid.user)
@@ -485,12 +499,12 @@
     @override_settings(
         OPENID_UPDATE_DETAILS_FROM_SREG=True,
         OPENID_VALID_VERIFICATION_SCHEMES={
-            'http://example.com/': {'token_via_email'}})
+            SERVER_URL: {'token_via_email'}})
     def test_auth_update_details_from_sreg(self):
         first_name = 'a' * 31
         last_name = 'b' * 31
         email = '[e-mail]'
-        response = self.make_response_ax(
+        self.message.set_ax_args(
             fullname=first_name + ' ' + last_name,
             nickname='newnickname',
             email=email,
@@ -499,13 +513,14 @@
             verified=True,
         )
         existing_openid = self.make_user_openid(
-            claimed_id=response.identity_url)
+            claimed_id=self.message.endpoint.claimed_id)
         original_username = existing_openid.user.username
         expected_user_count = User.objects.count()
 
         self.assert_account_not_verified(existing_openid.user)
 
-        user = self.backend.authenticate(openid_response=response)
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertEqual(user, existing_openid.user)
         self.assertEqual(
@@ -520,7 +535,7 @@
     @override_settings(
         OPENID_UPDATE_DETAILS_FROM_SREG=True,
         OPENID_VALID_VERIFICATION_SCHEMES={
-            'http://example.com/': {'token_via_email'}})
+            SERVER_URL: {'token_via_email'}})
     def test_auth_update_details_from_sreg_unverifies_account(self):
         first_name = 'a' * 31
         last_name = 'b' * 31
@@ -533,17 +548,17 @@
             last=last_name,
             verified=True,
         )
-        verified_response = self.make_response_ax(**kwargs)
+        self.message.set_ax_args(**kwargs)
         verified_user = self.backend.authenticate(
-            openid_response=verified_response)
+            openid_response=self.message.to_response())
 
         self.assert_account_verified(verified_user)
         expected_user_count = User.objects.count()
 
         kwargs['verified'] = False
-        unverified_response = self.make_response_ax(**kwargs)
+        self.message.set_ax_args(**kwargs)
         unverified_user = self.backend.authenticate(
-            openid_response=unverified_response)
+            openid_response=self.message.to_response())
 
         self.assertEqual(verified_user, unverified_user)
         self.assert_account_not_verified(unverified_user)
@@ -551,70 +566,60 @@
 
     @override_settings(OPENID_PHYSICAL_MULTIFACTOR_REQUIRED=True)
     def test_physical_multifactor_required_not_given(self):
-        response = self.make_openid_response()
+        response = self.message.to_response()
 
         with self.assertRaises(MissingPhysicalMultiFactor):
             self.backend.authenticate(openid_response=response)
 
         self.assertTrue(
-            UserOpenID.objects.filter(claimed_id='some-id').exists(),
+            UserOpenID.objects.filter(
+                claimed_id=self.message.endpoint.claimed_id).exists(),
             'User must be created anyways.')
 
     @override_settings(OPENID_PHYSICAL_MULTIFACTOR_REQUIRED=True)
     def test_physical_multifactor_required_invalid_auth_policy(self):
-        response = self.make_openid_response()
-        message = response.message
-        message.setArg(
-            pape.ns_uri, 'auth_policies',
-            pape.AUTH_MULTI_FACTOR + ' ' + pape.AUTH_PHISHING_RESISTANT)
-        response = SuccessResponse(
-            response.endpoint, message,
-            signed_fields=message.toPostArgs().keys())
+        self.message.set_pape_args(
+            pape.AUTH_MULTI_FACTOR, pape.AUTH_PHISHING_RESISTANT)
 
         with self.assertRaises(MissingPhysicalMultiFactor):
-            self.backend.authenticate(openid_response=response)
+            self.backend.authenticate(
+                openid_response=self.message.to_response())
 
         self.assertTrue(
-            UserOpenID.objects.filter(claimed_id='some-id').exists(),
+            UserOpenID.objects.filter(
+                claimed_id=self.message.endpoint.claimed_id).exists(),
             'User must be created anyways.')
 
     @override_settings(OPENID_PHYSICAL_MULTIFACTOR_REQUIRED=True)
     def test_physical_multifactor_required_valid_auth_policy(self):
-        response = self.make_openid_response()
-        message = response.message
-        message.setArg(
-            pape.ns_uri, 'auth_policies',
-            pape.AUTH_MULTI_FACTOR_PHYSICAL)
-        response = SuccessResponse(
-            response.endpoint, message,
-            signed_fields=message.toPostArgs().keys())
-
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_pape_args(
+            pape.AUTH_MULTI_FACTOR, pape.AUTH_MULTI_FACTOR_PHYSICAL,
+            pape.AUTH_PHISHING_RESISTANT)
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
 
     @override_settings(OPENID_STRICT_USERNAMES=True)
     def test_auth_strict_usernames(self):
         username = 'nickname'
-        response = self.make_openid_response(
-            sreg_args=dict(nickname=username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname=username)
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user, 'User must be created')
         self.assertEqual(user.username, username)
 
     @override_settings(OPENID_STRICT_USERNAMES=True)
     def test_auth_strict_usernames_no_nickname(self):
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
+        self.message.set_sreg_args(nickname='')
 
         msg = re.escape(
             "An attribute required for logging in was not returned (nickname)")
 
         with self.assertRaisesRegexp(RequiredAttributeNotReturned, msg):
-            self.backend.authenticate(openid_response=response)
+            self.backend.authenticate(
+                openid_response=self.message.to_response())
 
         self.assert_no_users_created()
 
@@ -624,14 +629,12 @@
     def test_auth_strict_usernames_conflict(self):
         existing_openid = self.make_user_openid()
         expected_user_count = User.objects.count()
-
-        response = self.make_openid_response(
-            sreg_args=dict(
-                nickname=existing_openid.user.username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
+        self.message.set_sreg_args(
+            nickname=existing_openid.user.username)
 
         with self.assertRaises(DuplicateUsernameViolation):
-            self.backend.authenticate(openid_response=response)
+            self.backend.authenticate(
+                openid_response=self.message.to_response())
 
         self.assert_no_users_created(expected_count=expected_user_count)
 
@@ -641,19 +644,16 @@
         OPENID_UPDATE_DETAILS_FROM_SREG=True)
     def test_auth_follow_renames(self):
         new_username = 'new'
-        original_response = self.make_openid_response(
-            sreg_args=dict(nickname='username', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        rename_response = self.make_openid_response(
-            sreg_args=dict(nickname=new_username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=original_response)
+        self.message.set_sreg_args(nickname='username')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
         expected_user_count = User.objects.count()
 
         self.assertIsNotNone(user, 'User must be created')
 
+        self.message.set_sreg_args(nickname=new_username)
         renamed_user = self.backend.authenticate(
-            openid_response=rename_response)
+            openid_response=self.message.to_response())
 
         self.assertEqual(user.pk, renamed_user.pk)
         self.assertEqual(renamed_user.username, new_username)
@@ -664,22 +664,20 @@
         OPENID_STRICT_USERNAMES=True,
         OPENID_UPDATE_DETAILS_FROM_SREG=True)
     def test_auth_follow_renames_strict_usernames_no_nickname(self):
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='nickame', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='nickame')
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
         expected_user_count = User.objects.count()
 
         self.assertIsNotNone(user, 'User must be created')
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
+        self.message.set_sreg_args(nickname='')
 
         # XXX: Check possibilities to normalize this error into a
         # `RequiredAttributeNotReturned`.
         with self.assertRaises(MissingUsernameViolation):
-            self.backend.authenticate(openid_response=response)
+            self.backend.authenticate(
+                openid_response=self.message.to_response())
 
         self.assert_no_users_created(expected_count=expected_user_count)
 
@@ -690,20 +688,19 @@
     def test_auth_follow_renames_strict_usernames_rename_conflict(self):
         existing_openid = self.make_user_openid()
         original_username = 'nickame'
-        good_response = self.make_openid_response(
-            sreg_args=dict(nickname=original_username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        conflict_response = self.make_openid_response(
-            sreg_args=dict(
-                nickname=existing_openid.user.username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=good_response)
+        self.message.set_sreg_args(nickname=original_username)
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
         expected_user_count = User.objects.count()
 
         self.assertIsNotNone(user, 'First request should succeed')
 
+        self.message.set_sreg_args(
+                nickname=existing_openid.user.username)
+
         with self.assertRaises(DuplicateUsernameViolation):
-            self.backend.authenticate(openid_response=conflict_response)
+            self.backend.authenticate(
+                openid_response=self.message.to_response())
 
         db_user = User.objects.get(pk=user.pk)
         self.assertEqual(db_user.username, original_username)
@@ -726,13 +723,12 @@
             duplicate_username_handler, sender=User, weak=False,
             dispatch_uid='testing')
 
-        response = self.make_openid_response(
-            sreg_args=dict(
-                nickname=existing_openid.user.username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
+        self.message.set_sreg_args(
+                nickname=existing_openid.user.username)
 
         with self.assertRaises(DuplicateUsernameViolation):
-            self.backend.authenticate(openid_response=response)
+            self.backend.authenticate(
+                openid_response=self.message.to_response())
 
         self.assertIn('username', signal_kwargs)
         self.assertEqual(
@@ -756,11 +752,10 @@
             duplicate_username_handler, sender=User, weak=False,
             dispatch_uid='testing')
 
-        response = self.make_openid_response(
-            sreg_args=dict(
-                nickname=existing_openid.user.username, email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        user = self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(
+                nickname=existing_openid.user.username)
+        user = self.backend.authenticate(
+            openid_response=self.message.to_response())
 
         self.assertIsNotNone(user)
         self.assertNotEqual(user, existing_openid.user)
@@ -778,7 +773,5 @@
             duplicate_username_handler, sender=User, weak=False,
             dispatch_uid='testing')
 
-        response = self.make_openid_response(
-            sreg_args=dict(nickname='nickname', email='[e-mail]'),
-            teams_args=dict(is_member='foo'))
-        self.backend.authenticate(openid_response=response)
+        self.message.set_sreg_args(nickname='nickname')
+        self.backend.authenticate(openid_response=self.message.to_response())