Add more tests for the other login modes.

django_openid_auth/forms.py

@@ -6,17 +6,17 @@ from openid.yadis import xri
 
 
 class OpenIDLoginForm(forms.Form):
-    openid_url = forms.CharField(
+    openid_identifier = forms.CharField(
         max_length=255,
         widget=forms.TextInput(attrs={'class': 'required openid'}))
 
-    def clean_openid_url(self):
-        if 'openid_url' in self.cleaned_data:
-            openid_url = self.cleaned_data['openid_url']
-            if xri.identifierScheme(openid_url) == 'XRI' and getattr(
+    def clean_openid_identifier(self):
+        if 'openid_identifier' in self.cleaned_data:
+            openid_identifier = self.cleaned_data['openid_identifier']
+            if xri.identifierScheme(openid_identifier) == 'XRI' and getattr(
                 settings, 'OPENID_DISALLOW_INAMES', False
                 ):
                 raise forms.ValidationError(_('i-names are not supported'))
-            return self.cleaned_data['openid_url']
+            return self.cleaned_data['openid_identifier']
 
 

django_openid_auth/templates/openid/login.html

@@ -17,8 +17,8 @@ input.openid {
 <h1>Sign in with your OpenID</h1>
 {% if form.errors %}
 <p class="errors">{% trans "Please correct errors below:" %}<br />
-	{% if form.openid_url.errors %} 
-		<span class="error">{{ form.openid_url.errors|join:", " }}</span>
+	{% if form.openid_identifier.errors %} 
+		<span class="error">{{ form.openid_identifier.errors|join:", " }}</span>
 	{% endif %}
 	{% if form.next.errors %} 
 		<span class="error">{{ form.next.errors|join:", " }}</span>
@@ -28,8 +28,9 @@ input.openid {
 <form name="fopenid" action="{{ action }}" method="post">
 	<fieldset>
 		<legend>{% trans "Sign In Using Your OpenID" %}</legend>
-        <div class="form-row"><label for="id_openid_ul">{% trans "OpenId URL :" %}</label><br />{{ form.openid_url }}</div>     
-        <div class="submit-row "><input name="bsignin" type="submit" value="{% trans "Sign in with OPENID" %}"></div>
+        <div class="form-row"><label for="id_openid_identifier">{%
+        trans "OpenID:" %}</label><br />{{ form.openid_identifier }}</div>
+        <div class="submit-row "><input name="bsignin" type="submit" value="{% trans "Sign in" %}"></div>
 
  {% if next %}
 	<input type="hidden" name="next" value="{{ next }}" />

django_openid_auth/tests/test_views.py

@@ -6,6 +6,7 @@ import unittest
 from django.conf import settings
 from django.contrib.auth.models import User
 from django.test import TestCase
+from openid.extensions.sreg import SRegRequest, SRegResponse
 from openid.fetchers import (
     HTTPFetcher, HTTPFetchingError, HTTPResponse, setDefaultFetcher)
 from openid.oidutil import importElementTree
@@ -23,6 +24,7 @@ class StubOpenIDProvider(HTTPFetcher):
     def __init__(self, base_url):
         self.store = MemoryStore()
         self.identity_url = base_url + 'identity'
+        self.localid_url = base_url + 'localid'
         self.endpoint_url = base_url + 'endpoint'
         self.server = Server(self.store, self.endpoint_url)
         self.last_request = None
@@ -44,7 +46,7 @@ class StubOpenIDProvider(HTTPFetcher):
     </Service>
   </XRD>
 </xrds:XRDS>
-""" % (self.endpoint_url, self.identity_url))
+""" % (self.endpoint_url, self.localid_url))
         elif url.startswith(self.endpoint_url):
             # Gather query parameters
             query = {}
@@ -119,6 +121,38 @@ class RelyingPartyTests(TestCase):
         return self.client.get('/openid/complete',
             dict(cgi.parse_qsl(redirect_to.split('?', 1)[1])))
 
+    def test_login(self):
+        user = User.objects.create_user('someuser', 'someone@example.com')
+        useropenid = UserOpenID(
+            user=user,
+            claimed_id='http://example.com/identity',
+            display_id='http://example.com/identity')
+        useropenid.save()
+
+        # The login form is displayed:
+        response = self.client.get('/openid/login')
+        self.assertTemplateUsed(response, 'openid/login.html')
+
+        # Posting in an identity URL begins the authentication request:
+        response = self.client.post('/openid/login',
+            {'openid_identifier': 'http://example.com/identity',
+             'next': '/getuser'})
+        self.assertContains(response, 'OpenID transaction in progress')
+
+        openid_request = self.provider.parseFormPost(response.content)
+        self.assertEquals(openid_request.mode, 'checkid_setup')
+        self.assertTrue(openid_request.return_to.startswith(
+                'http://testserver/openid/complete'))
+
+        # Complete the request.  The user is redirected to the next URL.
+        openid_response = openid_request.answer(True)
+        response = self.complete(openid_response)
+        self.assertRedirects(response, 'http://testserver/getuser')
+
+        # And they are now logged in:
+        response = self.client.get('/getuser')
+        self.assertEquals(response.content, 'someuser')
+
     def test_login_sso(self):
         settings.OPENID_SSO_SERVER_URL = 'http://example.com/identity'
         user = User.objects.create_user('someuser', 'someone@example.com')
@@ -128,6 +162,8 @@ class RelyingPartyTests(TestCase):
             display_id='http://example.com/identity')
         useropenid.save()
 
+        # Requesting the login form immediately begins an
+        # authentication request.
         response = self.client.get('/openid/login', {'next': '/getuser'})
         self.assertEquals(response.status_code, 200)
         self.assertContains(response, 'OpenID transaction in progress')
@@ -146,6 +182,78 @@ class RelyingPartyTests(TestCase):
         response = self.client.get('/getuser')
         self.assertEquals(response.content, 'someuser')
 
+    def test_login_create_users(self):
+        settings.OPENID_CREATE_USERS = True
+        # Create a user with the same name as we'll pass back via sreg.
+        User.objects.create_user('someuser', 'someone@example.com')
+
+        # Posting in an identity URL begins the authentication request:
+        response = self.client.post('/openid/login',
+            {'openid_identifier': 'http://example.com/identity',
+             'next': '/getuser'})
+        self.assertContains(response, 'OpenID transaction in progress')
+
+        # Complete the request, passing back some simple registration
+        # data.  The user is redirected to the next URL.
+        openid_request = self.provider.parseFormPost(response.content)
+        sreg_request = SRegRequest.fromOpenIDRequest(openid_request)
+        openid_response = openid_request.answer(True)
+        sreg_response = SRegResponse.extractResponse(
+            sreg_request, {'nickname': 'someuser', 'fullname': 'Some User',
+                           'email': 'foo@example.com'})
+        openid_response.addExtension(sreg_response)
+        response = self.complete(openid_response)
+        self.assertRedirects(response, 'http://testserver/getuser')
+
+        # And they are now logged in as a new user (they haven't taken
+        # over the existing "someuser" user).
+        response = self.client.get('/getuser')
+        self.assertEquals(response.content, 'someuser2')
+
+        # Check the details of the new user.
+        user = User.objects.get(username='someuser2')
+        self.assertEquals(user.first_name, 'Some')
+        self.assertEquals(user.last_name, 'User')
+        self.assertEquals(user.email, 'foo@example.com')
+
+    def test_login_update_details(self):
+        settings.OPENID_UPDATE_DETAILS_FROM_SREG = True
+        user = User.objects.create_user('testuser', 'someone@example.com')
+        useropenid = UserOpenID(
+            user=user,
+            claimed_id='http://example.com/identity',
+            display_id='http://example.com/identity')
+        useropenid.save()
+
+        # Posting in an identity URL begins the authentication request:
+        response = self.client.post('/openid/login',
+            {'openid_identifier': 'http://example.com/identity',
+             'next': '/getuser'})
+        self.assertContains(response, 'OpenID transaction in progress')
+
+        # Complete the request, passing back some simple registration
+        # data.  The user is redirected to the next URL.
+        openid_request = self.provider.parseFormPost(response.content)
+        sreg_request = SRegRequest.fromOpenIDRequest(openid_request)
+        openid_response = openid_request.answer(True)
+        sreg_response = SRegResponse.extractResponse(
+            sreg_request, {'nickname': 'someuser', 'fullname': 'Some User',
+                           'email': 'foo@example.com'})
+        openid_response.addExtension(sreg_response)
+        response = self.complete(openid_response)
+        self.assertRedirects(response, 'http://testserver/getuser')
+
+        # And they are now logged in as testuser (the passed in
+        # nickname has not caused the username to change).
+        response = self.client.get('/getuser')
+        self.assertEquals(response.content, 'testuser')
+
+        # The user's full name and email have been updated.
+        user = User.objects.get(username='testuser')
+        self.assertEquals(user.first_name, 'Some')
+        self.assertEquals(user.last_name, 'User')
+        self.assertEquals(user.email, 'foo@example.com')
+
 
 def suite():
     return unittest.TestLoader().loadTestsFromName(__name__)

django_openid_auth/views.py

@@ -87,7 +87,7 @@ def login_begin(request, template_name='openid/login.html',
         if request.POST:
             login_form = OpenIDLoginForm(data=request.POST)
             if login_form.is_valid():
-                openid_url = login_form.cleaned_data['openid_url']
+                openid_url = login_form.cleaned_data['openid_identifier']
         else:
             login_form = OpenIDLoginForm()