Merge lp:~nataliabidart/django-oauth-backend/use-own-models into lp:django-oauth-backend

[Natalia Bidart]

- Return local models instead of those from the oauth library.
- Adapt some signatures to those expected from Piston.

This branch ensures the loopup method from the data store will return "local" models. It also includes some cleaner methods to provide the hacks from:

http://bazaar.launchpad.net/~canonical-isd-hackers/canonical-identity-provider/trunk/view/head:/src/identityprovider/store.py

[Matias Bordese (matiasb)]

Looks good.

review: Approve

=== modified file 'oauth_backend/models.py'
--- oauth_backend/models.py	2014-01-23 14:20:45 +0000
+++ oauth_backend/models.py	2014-01-27 18:41:15 +0000
@@ -45,10 +45,38 @@
                    for x in range(length))
 
 
+class Consumer(models.Model):
+    """An OAuth consumer (client)."""
+
+    user = models.OneToOneField(User, related_name='oauth_consumer')
+
+    secret = models.CharField(
+        max_length=255, blank=True,
+        default=partial(generate_random_string, CONSUMER_SECRET_LENGTH)
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        db_table = 'oauth_consumer'
+
+    def __unicode__(self):
+        return self.key
+
+    @property
+    def key(self):
+        return self.user.username
+
+    def oauth_consumer(self):
+        """Return OAuthConsumer based on information contained in this model"""
+        return OAuthConsumer(self.key, self.secret)
+
+
 class Token(models.Model):
     """An OAuth access token."""
 
-    consumer = models.ForeignKey('Consumer')
+    consumer = models.ForeignKey(Consumer)
 
     token = models.CharField(
         max_length=TOKEN_LENGTH,
@@ -64,6 +92,27 @@
     created_at = models.DateTimeField(default=datetime.utcnow)
     updated_at = models.DateTimeField(default=datetime.utcnow)
 
+    class Meta:
+        db_table = 'oauth_token'
+
+    def __unicode__(self):
+        return self.token
+
+    # This class will be used from Piston oauth handlers, which assume the
+    # Token instance have key, secret and user attributes.
+
+    @property
+    def key(self):
+        return self.token
+
+    @property
+    def secret(self):
+        return self.token_secret
+
+    @property
+    def user(self):
+        return self.consumer.user
+
     def oauth_token(self):
         """Return OAuthToken with information contained in this model"""
         return OAuthToken(self.token, self.token_secret)
@@ -79,42 +128,6 @@
             'updated': str(self.updated_at),
         }
 
-    def __unicode__(self):
-        return self.token
-
-    class Meta:
-        db_table = 'oauth_token'
-
-
-class Consumer(models.Model):
-    """An OAuth consumer (client)."""
-
-    user = models.OneToOneField(User, related_name='oauth_consumer')
-
-    @property
-    def key(self):
-        return self.user.username
-
-    secret = models.CharField(
-        max_length=255,
-        blank=True,
-        null=False,
-        default=partial(generate_random_string, CONSUMER_SECRET_LENGTH)
-    )
-
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    def __unicode__(self):
-        return self.key
-
-    def oauth_consumer(self):
-        """Return OAuthConsumer based on information contained in this model"""
-        return OAuthConsumer(self.key, self.secret)
-
-    class Meta:
-        db_table = 'oauth_consumer'
-
 
 class Nonce(models.Model):
     token = models.ForeignKey(Token)
@@ -142,36 +155,37 @@
 
     DEFAULT_NONCE_TIMEOUT = 3600  # one hour
 
+    def __init__(self, oauth_request=None):
+        """To serve as a Piston datastore we'll need provide this signature.
+
+        We later won't use the oauth_request, so we can ignore it here.
+        """
+        super(DataStore, self).__init__()
+
     def lookup_token(self, token_type, token_field):
-        """
-        :param token_type: type of token to lookup
-        :param token_field: token to look up
-
-        :note: token_type should always be 'access' as only such tokens are
-               stored in database
-
-        :returns: OAuthToken object
+        """Return the Token object for the given token_field value.
+
+        The value for token_type should always be 'access' as only such tokens
+        are stored in database.
+
         """
         assert token_type == 'access'
 
         try:
             token = Token.objects.get(token=token_field)
-            return OAuthToken(token.token, token.token_secret)
         except Token.DoesNotExist:
-            return None
+            token = None
+
+        return token
 
     def lookup_consumer(self, consumer_key):
-        """
-        :param consumer_key: consumer key to lookup
-
-        :returns: OAuthConsumer object
-        """
+        """Return the Consumer object for the given consumer_key value."""
         try:
-            consumer = Consumer.objects.get(
-                user__username=consumer_key)
-            return consumer.oauth_consumer()
+            consumer = Consumer.objects.get(user__username=consumer_key)
         except Consumer.DoesNotExist:
-            return None
+            consumer = None
+
+        return consumer
 
     @property
     def _nonce_timeout_seconds(self):

=== modified file 'oauth_backend/tests.py'
--- oauth_backend/tests.py	2014-01-23 14:58:32 +0000
+++ oauth_backend/tests.py	2014-01-27 18:41:15 +0000
@@ -6,8 +6,9 @@
 from django.contrib.auth.models import User
 from django.core.cache import cache
 from django.test import TestCase
+from oauth.oauth import OAuthDataStore
 
-from .models import Consumer, DataStore, Nonce, Token, OAuthToken
+from .models import Consumer, DataStore, Nonce, Token
 
 
 class BaseTestCase(TestCase):
@@ -129,20 +130,29 @@
             consumer=self.consumer, token_key='token', token_secret='secret')
         self.addCleanup(cache.clear)
 
+    def test_data_store_creation_piston_compatible(self):
+        store = DataStore(oauth_request=object())
+        self.assertIsInstance(store, OAuthDataStore)
+
     def test_lookup_token_wrong_type(self):
-        self.assertRaises(AssertionError, self.ds.lookup_token, 'value',
-                          'token')
+        self.assertRaises(
+            AssertionError, self.ds.lookup_token, 'value', 'token')
 
     def test_lookup_token_exists(self):
-        # create a token
+        token = self.ds.lookup_token('access', 'token')
+        self.assertEqual(token.token, 'token')
+        self.assertEqual(token.token_secret, 'secret')
+
+    def test_lookup_token_has_expected_attributes(self):
         token = self.ds.lookup_token('access', 'token')
         self.assertEqual(token.key, 'token')
         self.assertEqual(token.secret, 'secret')
+        self.assertEqual(token.user, self.consumer.user)
 
     def test_lookup_token_not_exists(self):
         self.token.delete()
         token = self.ds.lookup_token('access', 'token')
-        self.assertEqual(token, None)
+        self.assertIsNone(token)
 
     def test_lookup_consumer_exists(self):
         consumer_key = self.consumer.key
@@ -151,9 +161,8 @@
         self.assertEqual(result.secret, self.consumer.secret)
 
     def test_lookup_consumer_not_exists(self):
-        consumer_key = 'foo'
-        consumer = self.ds.lookup_consumer(consumer_key)
-        self.assertEqual(consumer, None)
+        consumer = self.ds.lookup_consumer('foo')
+        self.assertIsNone(consumer,)
 
     def test_lookup_nonce_does_not_exist(self):
         nonce = self.ds.lookup_nonce(self.consumer, self.token, 'nonce')