Merge lp:~elachuni/canonical-identity-provider/ssoclient-tests into lp:~elachuni/canonical-identity-provider/ssoclient

[Anthony Lenton]

Added missing tests for all api calls.

Overview
========
This branch adds tests for all api calls that were missing tests in SingleSignOnAPI, and fixes the issues that these tests found.

Details
=======
Tests are written against SSO's mock server, you'll need to have that installed in your PYTHONPATH for the tests to work. Making running the tests easier would be something fo an interesting follow-up branch.

The issues that the tests uncovered were mainly two kinds:
 - Methods that were using POST that should use GET instead.
 - Once the method was switched over to GET, query arguments needed to be manually json-encoded. json_encode_query() was added to make this easier.

To Test
=======
Make SSO's mockserver, piston_mini_client 0.4, httplib2 0.6.0 and wsgi_intercept available on your pythonpath, and then run:

python setup.py test

[David Owen (dsowen)]

When you say that some methods should be GET instead of POST, is that to match what the lazr.restful server expected, or something else?

review: Needs Information

[Anthony Lenton (elachuni)]

Hi David,

> When you say that some methods should be GET instead of POST, is that to match
> what the lazr.restful server expected, or something else?

Yes, it's to match what lazr.restful expects. I'd first notice the test would fail against the mock server, so then I'd manually check each method against production's lazr.restful API. Staging's Piston API will accept either method, but on production using the wrong method fails.

[David Owen (dsowen)]

review: Approve

=== modified file 'ssoclient.py'
--- ssoclient.py	2011-06-17 16:52:13 +0000
+++ ssoclient.py	2011-07-18 21:42:38 +0000
@@ -94,28 +94,28 @@
     @basic_protected
     @returns_json
     def authenticate(self, token_name):
-        args = {'ws.op': 'authenticate',
+        args = self.json_encode_query({'ws.op': 'authenticate',
             'token_name': token_name,
-            }
+            })
         return self._get('authentications', args=args)
 
 
     @basic_protected
     @returns_json
     def list_tokens(self, consumer_key):
-        data = {'ws.op': 'list_tokens',
+        args = self.json_encode_query({'ws.op': 'list_tokens',
             'consumer_key': consumer_key,
-            }
-        return self._post('authentications', data=data)
+            })
+        return self._get('authentications', args=args)
 
     @basic_protected
     @returns_json
     def validate_token(self, consumer_key, token):
-        data = {'ws.op': 'validate_token',
+        data = self.json_encode_query({'ws.op': 'validate_token',
             'consumer_key': consumer_key,
             'token': token,
-            }
-        return self._post('authentications', data=data)
+            })
+        return self._get('authentications', args=data)
 
     @basic_protected
     @returns_json
@@ -129,46 +129,55 @@
     @basic_protected
     @returns_json
     def team_memberships_by_openid(self, openid_identifier, team_names):
-        data = {'ws.op': 'team_memberships',
+        args = self.json_encode_query({'ws.op': 'team_memberships',
             'openid_identifier': openid_identifier,
             'team_names': team_names,
-            }
-        return self._post('authentications', data=data)
+            })
+        return self._get('authentications', args=args)
 
     @basic_protected
     @returns(AccountResponse, none_allowed=True)
     def account_by_email(self, email):
-        data = {'ws.op': 'account_by_email',
+        args = self.json_encode_query({'ws.op': 'account_by_email',
             'email': email,
-            }
-        return self._post('authentications', data=data)
+            })
+        return self._get('authentications', args=args)
 
     @basic_protected
     @returns(AccountResponse, none_allowed=True)
     def account_by_openid(self, openid):
-        data = {'ws.op': 'account_by_openid',
+        args = self.json_encode_query({'ws.op': 'account_by_openid',
             'openid': openid,
-            }
-        return self._post('authentications', data=data)
+            })
+        return self._get('authentications', args=args)
 
     @oauth_protected
     @returns(AccountResponse)
     def me(self):
-        data = {'ws.op': 'me'}
-        return self._post('accounts', data=data)
+        args = self.json_encode_query({'ws.op': 'me'})
+        return self._get('accounts', args=args)
 
     @oauth_protected
     @returns_json
     def my_team_memberships(self, team_names):
-        data = {'ws.op': 'team_memberships',
+        args = self.json_encode_query({'ws.op': 'team_memberships',
             'team_names': team_names,
-            }
-        return self._post('accounts', data=data)
+            })
+        return self._get('accounts', args=args)
 
     @oauth_protected
     @returns_json
     def validate_email(self, email_token):
-        args = {'ws.op': 'validate_email',
+        args = self.json_encode_query({'ws.op': 'validate_email',
             'email_token': email_token,
-            }
+            })
         return self._get('accounts', args=args)
+
+    def json_encode_query(self, data):
+        result = {}
+        for key, value in data.items():
+            if key == 'ws.op':
+                result[key] = value
+            else:
+                result[key] = json.dumps(value)
+        return result
 
=== modified file 'tests/test_ssoclient.py'
--- tests/test_ssoclient.py	2011-05-24 22:24:03 +0000
+++ tests/test_ssoclient.py	2011-07-18 21:42:38 +0000
@@ -1,19 +1,28 @@
 #!/usr/bin/python
 
 import unittest
-from mockssoservice.mockserver import MockSSOServer, new_token
+
+from mockssoservice import mockserver
 from wsgi_intercept import add_wsgi_intercept, remove_wsgi_intercept
 from wsgi_intercept.httplib2_intercept import install, uninstall
-
+from piston_mini_client.auth import BasicAuthorizer, OAuthAuthorizer
+from piston_mini_client.failhandlers import APIError
 from ssoclient import SingleSignOnAPI
 
 class SSOTestCase(unittest.TestCase):
     def mock_sso(self, *args):
-        return MockSSOServer('login.ubuntu.com', 443, '/api/1.0',
+        return mockserver.MockSSOServer('login.ubuntu.com', 443, '/api/1.0',
                              scheme='https')
 
     def setUp(self):
         install()
+        self.service_root = 'https://login.ubuntu.com/api/1.0'
+        self.basic_server_auth = BasicAuthorizer(username='MyUsername',
+            password='password')
+        self.basic_user_auth = BasicAuthorizer(username='[e-mail]',
+            password='OMGTh1sIs5trong')
+        self.oauth_auth=OAuthAuthorizer('tokenkey', 'tokensecret',
+            'consumerkey', 'consumersecret')
         add_wsgi_intercept('login.ubuntu.com', 443, self.mock_sso)
         super(SSOTestCase, self).setUp()
 
@@ -25,7 +34,7 @@
 
 class CaptchaTestCase(SSOTestCase):
     def test_new_captcha(self):
-        api = SingleSignOnAPI(service_root='https://login.ubuntu.com/api/1.0')
+        api = SingleSignOnAPI(self.service_root)
 
         captcha = api.new_captcha()
 
@@ -35,7 +44,7 @@
 
 class RegisterTestCase(SSOTestCase):
     def test_register_weak_password(self):
-        api = SingleSignOnAPI(service_root='https://login.ubuntu.com/api/1.0')
+        api = SingleSignOnAPI(self.service_root)
         kwargs = {'email': '[e-mail]',
             'captcha_id': 'someid',
             'captcha_solution': 'omg lol',
@@ -53,7 +62,7 @@
             self.assertEqual(['password'], r['errors'].keys())
 
     def test_invalid_email(self):
-        api = SingleSignOnAPI(service_root='https://login.ubuntu.com/api/1.0')
+        api = SingleSignOnAPI(self.service_root)
         r = api.register(password='H1l4riuos',
             captcha_id='someid',
             captcha_solution='omg lol',
@@ -62,5 +71,174 @@
         self.assertEqual(['email'], r['errors'].keys())
 
 
+class RequestPasswordResetTokenTestCase(SSOTestCase):
+    def test_request_password_reset_token(self):
+        api = SingleSignOnAPI(self.service_root)
+        result = api.request_password_reset_token('[e-mail]')
+        expected = {'status': 'ok', 'message': 'Password reset token sent.'}
+        self.assertEqual(expected, result)
+
+
+class SetNewPasswordTestCase(SSOTestCase):
+    def test_set_new_password_invalid_password(self):
+        api = SingleSignOnAPI(self.service_root)
+        invalid_passwords = [
+            'Shor7',
+            'onlylowercase',
+            'etc...',
+        ]
+        expected = {
+            'status': 'error',
+            'errors': [
+                'Password must be at least 8 characters long, and must '
+                'contain at least one number and an upper case letter.'
+            ],
+        }
+        for passwd in invalid_passwords:
+            result = api.set_new_password('[e-mail]', passwd, 'token')
+            self.assertEqual(expected, result)
+
+    def test_set_new_password_success(self):
+        api = SingleSignOnAPI(self.service_root)
+        result = api.set_new_password('[e-mail]', 'Q1w2E3r4', 'token')
+        expected = {'message': 'Password changed', 'status': 'ok'}
+        self.assertEqual(expected, result)
+
+
+class AuthenticateTestCase(SSOTestCase):
+    def test_authenticate_failure(self):
+        # Attempt to authenticate an APIUser fails using the mock server
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+        self.assertRaises(APIError, api.authenticate, token_name='foobar')
+
+    def test_authenticate_success(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_user_auth)
+        result = api.authenticate(token_name='foobar')
+        expected = set(['consumer_secret', 'token', 'consumer_key', 'name',
+            'token_secret'])
+        self.assertEqual(expected, set(result.keys()))
+
+
+class ListTokensTestCase(SSOTestCase):
+    def test_list_tokens_auth_failure(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_user_auth)
+        self.assertRaises(APIError, api.list_tokens, 'openid-123')
+
+    def test_list_tokens_no_tokens(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+        self.assertEqual([], api.list_tokens('openid-123'))
+
+    def test_list_tokens_some_tokens(self):
+        mockserver.tokens.clear()
+        mockserver.new_token('foobar')
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+        self.assertEqual(1, len(api.list_tokens('name12_oid')))
+
+
+class ValidateTokenTestCase(SSOTestCase):
+    def test_validate_token_auth_faliure(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_user_auth)
+        self.assertRaises(APIError, api.validate_token, 'openid-123', 'token')
+
+    def test_validate_token_success(self):
+        mockserver.tokens.clear()
+        token = '0123456789abcdef'
+        mockserver.new_token('token-name', token=token)
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+        expected = set(['consumer_secret', 'token', 'consumer_key', 'name',
+            'token_secret'])
+
+        result = api.validate_token(consumer_key='name12_oid', token=token)
+
+        self.assertEqual(expected, set(result.keys()))
+
+
+class InvalidateTokenTestCase(SSOTestCase):
+    def test_invalidate_token_auth_faliure(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_user_auth)
+        self.assertRaises(APIError, api.invalidate_token, 'someoid', 'token')
+
+    def test_invalidate_token_success(self):
+        mockserver.tokens.clear()
+        token = '0123456789abcdef'
+        mockserver.new_token('token-name', token=token)
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+        result = api.invalidate_token(consumer_key='name12_oid', token=token)
+        self.assertEqual(None, result)
+
+
+class TeamMembershipsByOpenid(SSOTestCase):
+    def test_team_memberships_by_openid_auth_failure(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_user_auth)
+        self.assertRaises(APIError, api.invalidate_token, 'someoid', 'token')
+
+    def test_team_memberships_by_openid_success(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+        result = api.team_memberships_by_openid('someoid',
+            ["ubuntu-team", "myteam", "someotherteam"])
+
+        self.assertEqual(["ubuntu-team", "myteam"], result)
+
+
+class AccountByEmailTestCase(SSOTestCase):
+    def test_account_by_email_invalid_email(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+
+        result = api.account_by_email(email='[e-mail]')
+        self.assertEqual(None, result)
+
+    def test_account_by_email_verified(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+
+        result = api.account_by_email(email='[e-mail]')
+        self.assertEqual('username', result.username)
+        self.assertEqual('Blu Bli', result.displayname)
+        self.assertEqual('[e-mail]', result.preferred_email)
+        self.assertEqual([], result.verified_emails)
+        self.assertEqual([], result.unverified_emails)
+
+class AccountByOpenIDTestCase(SSOTestCase):
+    def test_account_by_openid_invalid_identifier(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+
+        result = api.account_by_openid(openid='oid_1234')
+        self.assertEqual(None, result)
+
+    def test_account_by_openid_success(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.basic_server_auth)
+
+        result = api.account_by_openid(openid='openid_identifier')
+        self.assertEqual('username', result.username)
+        self.assertEqual('Blu Bli', result.displayname)
+        self.assertEqual('openid_identifier', result.openid_identifier)
+
+
+class MeTestCase(SSOTestCase):
+    def test_me(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.oauth_auth)
+        result = api.me()
+        self.assertEqual('Blu Bli', result.displayname)
+
+
+class MyTeamMembershipsTestcase(SSOTestCase):
+    def test_my_team_memberships(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.oauth_auth)
+        result = api.my_team_memberships(['foobar'])
+        self.assertEqual([], result)
+
+
+class ValidateEmailTestCase(SSOTestCase):
+    def test_validate_email_fail(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.oauth_auth)
+        result = api.validate_email('abcdefghijkl1234567890')
+        expected = {'errors': {'email_token': ['Bad email token!']}}
+        self.assertEqual(expected, result)
+
+    def test_validate_email_success(self):
+        api = SingleSignOnAPI(self.service_root, auth=self.oauth_auth)
+        result = api.validate_email('jJRkmngbHjmnJDEK')
+        self.assertEqual({'email': '[e-mail]'}, result)
+
+
 if __name__ == "__main__":
     unittest.main()