Merge lp:~nataliabidart/ubuntu-sso-client/isolate-sso-processor into lp:ubuntu-sso-client

[Natalia Bidart]

* Isolating SSO login processor into a separated module (LP: #637204).

[lp:~nataliabidart/ubuntu-sso-client/isolate-sso-processor]

637. By Natalia Bidart on 2010-10-01

Fixing copyright year.

[John Lenton (chipaca)]

can I sugest firing a DeprecationWarning in the __init__ of SSOLoginProcessor?

review: Approve

[Natalia Bidart (nataliabidart)]

> can I sugest firing a DeprecationWarning in the __init__ of SSOLoginProcessor?

Yes you can! Already done it. Thanks!

[lp:~nataliabidart/ubuntu-sso-client/isolate-sso-processor]

638. By Natalia Bidart on 2010-10-01

Added a DeprecationWarning to SSOLoginProcessor class.

639. By Natalia Bidart on 2010-10-01

Warning must be a DeprecationWarning!

[Manuel de la Peña (mandel)]

+1 from me

review: Approve

=== added file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/account.py	2010-10-01 17:16:44 +0000
@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+
+# Author: Natalia Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Single Sign On account management."""
+
+import os
+import re
+import urllib2
+
+# Unable to import 'lazr.restfulclient.*'
+# pylint: disable=F0401
+from lazr.restfulclient.authorize import BasicHttpAuthorizer
+from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
+from lazr.restfulclient.errors import HTTPError
+from lazr.restfulclient.resource import ServiceRoot
+# pylint: enable=F0401
+from oauth import oauth
+
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging("ubuntu_sso.account")
+SERVICE_URL = "https://login.ubuntu.com/api/1.0"
+
+
+class InvalidEmailError(Exception):
+    """The email is not valid."""
+
+
+class InvalidPasswordError(Exception):
+    """The password is not valid.
+
+    Must provide at least 8 characters, one upper case, one number.
+    """
+
+
+class RegistrationError(Exception):
+    """The registration failed."""
+
+
+class AuthenticationError(Exception):
+    """The authentication failed."""
+
+
+class EmailTokenError(Exception):
+    """The email token is not valid."""
+
+
+class ResetPasswordTokenError(Exception):
+    """The token for password reset could not be generated."""
+
+
+class NewPasswordError(Exception):
+    """The new password could not be set."""
+
+
+class Account(object):
+    """Login and register users using the Ubuntu Single Sign On service."""
+
+    def __init__(self, sso_service_class=None):
+        """Create a new SSO Account manager."""
+        if sso_service_class is None:
+            self.sso_service_class = ServiceRoot
+        else:
+            self.sso_service_class = sso_service_class
+
+        self.service_url = os.environ.get('USSOC_SERVICE_URL', SERVICE_URL)
+
+        logger.info('Created a new SSO access layer for service url %r',
+                     self.service_url)
+
+    def _valid_email(self, email):
+        """Validate the given email."""
+        return email is not None and '@' in email
+
+    def _valid_password(self, password):
+        """Validate the given password."""
+        res = (len(password) > 7 and  # at least 8 characters
+               re.search('[A-Z]', password) and  # one upper case
+               re.search('\d+', password))  # one number
+        return res
+
+    def _format_webservice_errors(self, errdict):
+        """Turn each list of strings in the errdict into a LF separated str."""
+        result = {}
+        for key, val in errdict.iteritems():
+            # workaround until bug #624955 is solved
+            if isinstance(val, basestring):
+                result[key] = val
+            else:
+                result[key] = "\n".join(val)
+        return result
+
+    def generate_captcha(self, filename):
+        """Generate a captcha using the SSO service."""
+        logger.debug('generate_captcha: requesting captcha, filename: %r',
+                     filename)
+        sso_service = self.sso_service_class(None, self.service_url)
+        captcha = sso_service.captchas.new()
+
+        # download captcha and save to 'filename'
+        logger.debug('generate_captcha: server answered: %r', captcha)
+        try:
+            res = urllib2.urlopen(captcha['image_url'])
+            with open(filename, 'wb') as f:
+                f.write(res.read())
+        except:
+            msg = 'generate_captcha crashed while downloading the image.'
+            logger.exception(msg)
+            raise
+
+        return captcha['captcha_id']
+
+    def register_user(self, email, password, captcha_id, captcha_solution):
+        """Register a new user with 'email' and 'password'."""
+        logger.debug('register_user: email: %r password: <hidden>, '
+                     'captcha_id: %r, captcha_solution: %r',
+                     email, captcha_id, captcha_solution)
+        sso_service = self.sso_service_class(None, self.service_url)
+        if not self._valid_email(email):
+            logger.error('register_user: InvalidEmailError for email: %r',
+                         email)
+            raise InvalidEmailError()
+        if not self._valid_password(password):
+            logger.error('register_user: InvalidPasswordError')
+            raise InvalidPasswordError()
+
+        result = sso_service.registrations.register(
+                    email=email, password=password, captcha_id=captcha_id,
+                    captcha_solution=captcha_solution)
+        logger.info('register_user: email: %r result: %r', email, result)
+
+        if result['status'] == 'error':
+            errorsdict = self._format_webservice_errors(result['errors'])
+            raise RegistrationError(errorsdict)
+        elif result['status'] != 'ok':
+            raise RegistrationError('Received unknown status: %s' % result)
+        else:
+            return email
+
+    def login(self, email, password, token_name):
+        """Login a user with 'email' and 'password'."""
+        logger.debug('login: email: %r password: <hidden>, token_name: %r',
+                     email, token_name)
+        basic = BasicHttpAuthorizer(email, password)
+        sso_service = self.sso_service_class(basic, self.service_url)
+        service = sso_service.authentications.authenticate
+
+        try:
+            credentials = service(token_name=token_name)
+        except HTTPError:
+            logger.exception('login failed with:')
+            raise AuthenticationError()
+
+        logger.debug('login: authentication successful! consumer_key: %r, ' \
+                     'token_name: %r', credentials['consumer_key'], token_name)
+        return credentials
+
+    def validate_email(self, email, password, email_token, token_name):
+        """Validate an email token for user with 'email' and 'password'."""
+        logger.debug('validate_email: email: %r password: <hidden>, '
+                     'email_token: %r, token_name: %r.',
+                     email, email_token, token_name)
+        token = self.login(email=email, password=password,
+                           token_name=token_name)
+
+        oauth_token = oauth.OAuthToken(token['token'], token['token_secret'])
+        authorizer = OAuthAuthorizer(token['consumer_key'],
+                                     token['consumer_secret'],
+                                     oauth_token)
+        sso_service = self.sso_service_class(authorizer, self.service_url)
+        result = sso_service.accounts.validate_email(email_token=email_token)
+        logger.info('validate_email: email: %r result: %r', email, result)
+        if 'errors' in result:
+            errorsdict = self._format_webservice_errors(result['errors'])
+            raise EmailTokenError(errorsdict)
+        elif 'email' in result:
+            return token
+        else:
+            raise EmailTokenError('Received invalid reply: %s' % result)
+
+    def request_password_reset_token(self, email):
+        """Request a token to reset the password for the account 'email'."""
+        sso_service = self.sso_service_class(None, self.service_url)
+        service = sso_service.registrations.request_password_reset_token
+        try:
+            result = service(email=email)
+        except HTTPError, e:
+            logger.exception('request_password_reset_token failed with:')
+            raise ResetPasswordTokenError(e.content.split('\n')[0])
+
+        if result['status'] == 'ok':
+            return email
+        else:
+            raise ResetPasswordTokenError('Received invalid reply: %s' %
+                                          result)
+
+    def set_new_password(self, email, token, new_password):
+        """Set a new password for the account 'email' to be 'new_password'.
+
+        The 'token' has to be the one resulting from a call to
+        'request_password_reset_token'.
+
+        """
+        sso_service = self.sso_service_class(None, self.service_url)
+        service = sso_service.registrations.set_new_password
+        try:
+            result = service(email=email, token=token,
+                             new_password=new_password)
+        except HTTPError, e:
+            logger.exception('set_new_password failed with:')
+            raise NewPasswordError(e.content.split('\n')[0])
+
+        if result['status'] == 'ok':
+            return email
+        else:
+            raise NewPasswordError('Received invalid reply: %s' % result)

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-09-30 21:09:44 +0000
+++ ubuntu_sso/main.py	2010-10-01 17:16:44 +0000
@@ -28,24 +28,18 @@
 """
 
 import os
-import re
 import threading
 import traceback
 import urllib2
+import warnings
 
 import dbus.service
 import gobject
 
-# Unable to import 'lazr.restfulclient.*'
-# pylint: disable=F0401
-from lazr.restfulclient.authorize import BasicHttpAuthorizer
-from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
-from lazr.restfulclient.errors import HTTPError
-from lazr.restfulclient.resource import ServiceRoot
-# pylint: enable=F0401
 from oauth import oauth
 
 from ubuntu_sso import DBUS_IFACE_USER_NAME, DBUS_IFACE_CRED_NAME
+from ubuntu_sso.account import Account
 from ubuntu_sso.keyring import Keyring, get_token_name, U1_APP_NAME
 from ubuntu_sso.logger import setup_logging
 
@@ -56,38 +50,6 @@
 
 logger = setup_logging("ubuntu_sso.main")
 PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
-SERVICE_URL = "https://login.ubuntu.com/api/1.0"
-
-
-class InvalidEmailError(Exception):
-    """The email is not valid."""
-
-
-class InvalidPasswordError(Exception):
-    """The password is not valid.
-
-    Must provide at least 8 characters, one upper case, one number.
-    """
-
-
-class RegistrationError(Exception):
-    """The registration failed."""
-
-
-class AuthenticationError(Exception):
-    """The authentication failed."""
-
-
-class EmailTokenError(Exception):
-    """The email token is not valid."""
-
-
-class ResetPasswordTokenError(Exception):
-    """The token for password reset could not be generated."""
-
-
-class NewPasswordError(Exception):
-    """The new password could not be set."""
 
 
 def keyring_store_credentials(app_name, credentials):
@@ -104,164 +66,18 @@
     return creds
 
 
-class SSOLoginProcessor(object):
-    """Login and register users using the Ubuntu Single Sign On service."""
+class SSOLoginProcessor(Account):
+    """Login and register users using the Ubuntu Single Sign On service.
+
+    Alias classname to maintain backwards compatibility. DO NOT USE, use
+    ubuntu_sso.account.Account instead.
+    """
 
     def __init__(self, sso_service_class=None):
-        """Create a new SSO login processor."""
-        if sso_service_class is None:
-            self.sso_service_class = ServiceRoot
-        else:
-            self.sso_service_class = sso_service_class
-
-        self.service_url = os.environ.get('USSOC_SERVICE_URL', SERVICE_URL)
-
-    def _valid_email(self, email):
-        """Validate the given email."""
-        return email is not None and '@' in email
-
-    def _valid_password(self, password):
-        """Validate the given password."""
-        res = (len(password) > 7 and  # at least 8 characters
-               re.search('[A-Z]', password) and  # one upper case
-               re.search('\d+', password))  # one number
-        return res
-
-    def _format_webservice_errors(self, errdict):
-        """Turn each list of strings in the errdict into a LF separated str."""
-        result = {}
-        for k, v in errdict.iteritems():
-            # workaround until bug #624955 is solved
-            if isinstance(v, basestring):
-                result[k] = v
-            else:
-                result[k] = "\n".join(v)
-        return result
-
-    def generate_captcha(self, filename):
-        """Generate a captcha using the SSO service."""
-        logger.debug('generate_captcha: requesting captcha, filename: %r',
-                     filename)
-        sso_service = self.sso_service_class(None, self.service_url)
-        captcha = sso_service.captchas.new()
-
-        # download captcha and save to 'filename'
-        logger.debug('generate_captcha: server answered: %r', captcha)
-        try:
-            res = urllib2.urlopen(captcha['image_url'])
-            with open(filename, 'wb') as f:
-                f.write(res.read())
-        except:
-            msg = 'generate_captcha crashed while downloading the image.'
-            logger.exception(msg)
-            raise
-
-        return captcha['captcha_id']
-
-    def register_user(self, email, password, captcha_id, captcha_solution):
-        """Register a new user with 'email' and 'password'."""
-        logger.debug('register_user: email: %r password: <hidden>, '
-                     'captcha_id: %r, captcha_solution: %r',
-                     email, captcha_id, captcha_solution)
-        sso_service = self.sso_service_class(None, self.service_url)
-        if not self._valid_email(email):
-            logger.error('register_user: InvalidEmailError for email: %r',
-                         email)
-            raise InvalidEmailError()
-        if not self._valid_password(password):
-            logger.error('register_user: InvalidPasswordError')
-            raise InvalidPasswordError()
-
-        result = sso_service.registrations.register(
-                    email=email, password=password, captcha_id=captcha_id,
-                    captcha_solution=captcha_solution)
-        logger.info('register_user: email: %r result: %r', email, result)
-
-        if result['status'] == 'error':
-            errorsdict = self._format_webservice_errors(result['errors'])
-            raise RegistrationError(errorsdict)
-        elif result['status'] != 'ok':
-            raise RegistrationError('Received unknown status: %s' % result)
-        else:
-            return email
-
-    def login(self, email, password, token_name):
-        """Login a user with 'email' and 'password'."""
-        logger.debug('login: email: %r password: <hidden>, token_name: %r',
-                     email, token_name)
-        basic = BasicHttpAuthorizer(email, password)
-        sso_service = self.sso_service_class(basic, self.service_url)
-        service = sso_service.authentications.authenticate
-
-        try:
-            credentials = service(token_name=token_name)
-        except HTTPError:
-            logger.exception('login failed with:')
-            raise AuthenticationError()
-
-        logger.debug('login: authentication successful! consumer_key: %r, ' \
-                     'token_name: %r', credentials['consumer_key'], token_name)
-        return credentials
-
-    def validate_email(self, email, password, email_token, token_name):
-        """Validate an email token for user with 'email' and 'password'."""
-        logger.debug('validate_email: email: %r password: <hidden>, '
-                     'email_token: %r, token_name: %r.',
-                     email, email_token, token_name)
-        token = self.login(email=email, password=password,
-                           token_name=token_name)
-
-        oauth_token = oauth.OAuthToken(token['token'], token['token_secret'])
-        authorizer = OAuthAuthorizer(token['consumer_key'],
-                                     token['consumer_secret'],
-                                     oauth_token)
-        sso_service = self.sso_service_class(authorizer, self.service_url)
-        result = sso_service.accounts.validate_email(email_token=email_token)
-        logger.info('validate_email: email: %r result: %r', email, result)
-        if 'errors' in result:
-            errorsdict = self._format_webservice_errors(result['errors'])
-            raise EmailTokenError(errorsdict)
-        elif 'email' in result:
-            return token
-        else:
-            raise EmailTokenError('Received invalid reply: %s' % result)
-
-    def request_password_reset_token(self, email):
-        """Request a token to reset the password for the account 'email'."""
-        sso_service = self.sso_service_class(None, self.service_url)
-        service = sso_service.registrations.request_password_reset_token
-        try:
-            result = service(email=email)
-        except HTTPError, e:
-            logger.exception('request_password_reset_token failed with:')
-            raise ResetPasswordTokenError(e.content.split('\n')[0])
-
-        if result['status'] == 'ok':
-            return email
-        else:
-            raise ResetPasswordTokenError('Received invalid reply: %s' %
-                                          result)
-
-    def set_new_password(self, email, token, new_password):
-        """Set a new password for the account 'email' to be 'new_password'.
-
-        The 'token' has to be the one resulting from a call to
-        'request_password_reset_token'.
-
-        """
-        sso_service = self.sso_service_class(None, self.service_url)
-        service = sso_service.registrations.set_new_password
-        try:
-            result = service(email=email, token=token,
-                             new_password=new_password)
-        except HTTPError, e:
-            logger.exception('set_new_password failed with:')
-            raise NewPasswordError(e.content.split('\n')[0])
-
-        if result['status'] == 'ok':
-            return email
-        else:
-            raise NewPasswordError('Received invalid reply: %s' % result)
+        """Create a new SSO Account manager."""
+        msg = 'Use ubuntu_sso.account.Account instead.'
+        warnings.warn(msg, DeprecationWarning)
+        super(SSOLoginProcessor, self).__init__(sso_service_class)
 
 
 def except_to_errdict(e):

=== added file 'ubuntu_sso/tests/test_account.py'
--- ubuntu_sso/tests/test_account.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/test_account.py	2010-10-01 17:16:44 +0000
@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the SSO account code."""
+
+import os
+
+# Unable to import 'lazr.restfulclient.*'
+# pylint: disable=F0401
+from lazr.restfulclient.errors import HTTPError
+# pylint: enable=F0401
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso.account import (Account, AuthenticationError, EmailTokenError,
+    InvalidEmailError, InvalidPasswordError, NewPasswordError, SERVICE_URL,
+    RegistrationError, ResetPasswordTokenError)
+from ubuntu_sso.tests import (APP_NAME, CAPTCHA_ID, CAPTCHA_PATH,
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, PASSWORD, RESET_PASSWORD_TOKEN,
+    TOKEN, TOKEN_NAME)
+
+
+# Access to a protected member 'yyy' of a client class
+# pylint: disable=W0212
+
+
+CANT_RESET_PASSWORD_CONTENT = "CanNotResetPassowrdError: " \
+                              "Can't reset password for this account"
+RESET_TOKEN_INVALID_CONTENT = "AuthToken matching query does not exist."
+EMAIL_ALREADY_REGISTERED = '[e-mail]'
+STATUS_UNKNOWN = {'status': 'yadda-yadda'}
+STATUS_ERROR = {'status': 'error', 'errors': {'something': ['Bla', 'Ble']}}
+STATUS_OK = {'status': 'ok'}
+STATUS_EMAIL_UNKNOWN = {'status': 'yadda-yadda'}
+STATUS_EMAIL_ERROR = {'errors': {'email_token': ['Error1', 'Error2']}}
+STATUS_EMAIL_OK = {'email': EMAIL}
+
+
+class FakedCaptchas(object):
+    """Fake the captcha generator."""
+
+    def new(self):
+        """Return a fix captcha)."""
+        return {'image_url': 'file://%s' % CAPTCHA_PATH,
+                'captcha_id': CAPTCHA_ID}
+
+
+class FakedRegistrations(object):
+    """Fake the registrations service."""
+
+    def register(self, email, password, captcha_id, captcha_solution):
+        """Fake registration. Return a fix result."""
+        if email == EMAIL_ALREADY_REGISTERED:
+            return {'status': 'error',
+                    'errors': {'email': 'Email already registered'}}
+        elif captcha_id is None and captcha_solution is None:
+            return STATUS_UNKNOWN
+        elif captcha_id != CAPTCHA_ID or captcha_solution != CAPTCHA_SOLUTION:
+            return STATUS_ERROR
+        else:
+            return STATUS_OK
+
+    def request_password_reset_token(self, email):
+        """Fake password reset token. Return a fix result."""
+        if email is None:
+            return STATUS_UNKNOWN
+        elif email != EMAIL:
+            raise HTTPError(response=None, content=CANT_RESET_PASSWORD_CONTENT)
+        else:
+            return STATUS_OK
+
+    def set_new_password(self, email, token, new_password):
+        """Fake the setting of new password. Return a fix result."""
+        if email is None and token is None and new_password is None:
+            return STATUS_UNKNOWN
+        elif email != EMAIL or token != RESET_PASSWORD_TOKEN:
+            raise HTTPError(response=None, content=RESET_TOKEN_INVALID_CONTENT)
+        else:
+            return STATUS_OK
+
+
+class FakedAuthentications(object):
+    """Fake the authentications service."""
+
+    def authenticate(self, token_name):
+        """Fake authenticate. Return a fix result."""
+        if not token_name.startswith(TOKEN_NAME):
+            raise HTTPError(response=None, content=None)
+        else:
+            return TOKEN
+
+
+class FakedAccounts(object):
+    """Fake the accounts service."""
+
+    def validate_email(self, email_token):
+        """Fake the email validation. Return a fix result."""
+        if email_token is None:
+            return STATUS_EMAIL_UNKNOWN
+        elif email_token == EMAIL_ALREADY_REGISTERED:
+            return {'status': 'error',
+                    'errors': {'email': 'Email already registered'}}
+        elif email_token != EMAIL_TOKEN:
+            return STATUS_EMAIL_ERROR
+        else:
+            return STATUS_EMAIL_OK
+
+
+class FakedSSOServer(object):
+    """Fake an SSO server."""
+
+    def __init__(self, authorizer, service_root):
+        self.captchas = FakedCaptchas()
+        self.registrations = FakedRegistrations()
+        self.authentications = FakedAuthentications()
+        self.accounts = FakedAccounts()
+
+
+class AccountTestCase(TestCase):
+    """Test suite for the SSO login processor."""
+
+    def setUp(self):
+        """Init."""
+        self.processor = Account(sso_service_class=FakedSSOServer)
+        self.register_kwargs = dict(email=EMAIL, password=PASSWORD,
+                                    captcha_id=CAPTCHA_ID,
+                                    captcha_solution=CAPTCHA_SOLUTION)
+        self.login_kwargs = dict(email=EMAIL, password=PASSWORD,
+                                 token_name=TOKEN_NAME)
+
+    def tearDown(self):
+        """Clean up."""
+        self.processor = None
+
+    def test_generate_captcha(self):
+        """Captcha can be generated."""
+        filename = self.mktemp()
+        self.addCleanup(lambda: os.remove(filename))
+        captcha_id = self.processor.generate_captcha(filename)
+        self.assertEqual(CAPTCHA_ID, captcha_id, 'captcha id must be correct.')
+        self.assertTrue(os.path.isfile(filename), '%s must exist.' % filename)
+
+        with open(CAPTCHA_PATH) as f:
+            expected = f.read()
+        with open(filename) as f:
+            actual = f.read()
+        self.assertEqual(expected, actual, 'captcha image must be correct.')
+
+    def test_register_user_checks_valid_email(self):
+        """Email is validated."""
+        self.register_kwargs['email'] = 'notavalidemail'
+        self.assertRaises(InvalidEmailError,
+                          self.processor.register_user, **self.register_kwargs)
+
+    def test_register_user_checks_valid_password(self):
+        """Password is validated."""
+        self.register_kwargs['password'] = ''
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+        # 7 chars, one less than expected
+        self.register_kwargs['password'] = 'tesT3it'
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+        self.register_kwargs['password'] = 'test3it!'  # no upper case
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+        self.register_kwargs['password'] = 'testIt!!'  # no number
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+    # register
+
+    def test_register_user_if_status_ok(self):
+        """A user is succesfuy registered into the SSO server."""
+        result = self.processor.register_user(**self.register_kwargs)
+        self.assertEqual(EMAIL, result, 'registration was successful.')
+
+    def test_register_user_if_status_error(self):
+        """Proper error is raised if register fails."""
+        self.register_kwargs['captcha_id'] = CAPTCHA_ID * 2  # incorrect
+        failure = self.assertRaises(RegistrationError,
+                                    self.processor.register_user,
+                                    **self.register_kwargs)
+        for k, val in failure.args[0].items():
+            self.assertIn(k, STATUS_ERROR['errors'])
+            self.assertEqual(val, "\n".join(STATUS_ERROR['errors'][k]))
+
+    def test_register_user_if_status_error_with_string_message(self):
+        """Proper error is raised if register fails."""
+        self.register_kwargs['email'] = EMAIL_ALREADY_REGISTERED
+        failure = self.assertRaises(RegistrationError,
+                                    self.processor.register_user,
+                                    **self.register_kwargs)
+        for k, val in failure.args[0].items():
+            self.assertIn(k, {'email': 'Email already registered'})
+            self.assertEqual(val, 'Email already registered')
+
+    def test_register_user_if_status_unknown(self):
+        """Proper error is raised if register returns an unknown status."""
+        self.register_kwargs['captcha_id'] = None
+        self.register_kwargs['captcha_solution'] = None
+        failure = self.assertRaises(RegistrationError,
+                                    self.processor.register_user,
+                                    **self.register_kwargs)
+        self.assertIn('Received unknown status: %s' % STATUS_UNKNOWN, failure)
+
+    # login
+
+    def test_login_if_http_error(self):
+        """Proper error is raised if authentication fails."""
+        self.login_kwargs['token_name'] = APP_NAME * 2  # invalid token name
+        self.assertRaises(AuthenticationError,
+                          self.processor.login, **self.login_kwargs)
+
+    def test_login_if_no_error(self):
+        """A user can be succesfully logged in into the SSO service."""
+        result = self.processor.login(**self.login_kwargs)
+        self.assertEqual(TOKEN, result, 'authentication was successful.')
+
+    # validate_email
+
+    def test_validate_email_if_status_ok(self):
+        """A email is succesfuy validated in the SSO server."""
+        self.login_kwargs['email_token'] = EMAIL_TOKEN  # valid email token
+        result = self.processor.validate_email(**self.login_kwargs)
+        self.assertEqual(TOKEN, result, 'email validation was successful.')
+
+    def test_validate_email_if_status_error(self):
+        """Proper error is raised if email validation fails."""
+        self.login_kwargs['email_token'] = EMAIL_TOKEN * 2  # invalid token
+        failure = self.assertRaises(EmailTokenError,
+                                    self.processor.validate_email,
+                                    **self.login_kwargs)
+        for k, val in failure.args[0].items():
+            self.assertIn(k, STATUS_EMAIL_ERROR['errors'])
+            self.assertEqual(val, "\n".join(STATUS_EMAIL_ERROR['errors'][k]))
+
+    def test_validate_email_if_status_error_with_string_message(self):
+        """Proper error is raised if register fails."""
+        self.login_kwargs['email_token'] = EMAIL_ALREADY_REGISTERED
+        failure = self.assertRaises(EmailTokenError,
+                                    self.processor.validate_email,
+                                    **self.login_kwargs)
+        for k, val in failure.args[0].items():
+            self.assertIn(k, {'email': 'Email already registered'})
+            self.assertEqual(val, 'Email already registered')
+
+    def test_validate_email_if_status_unknown(self):
+        """Proper error is raised if email validation returns unknown."""
+        self.login_kwargs['email_token'] = None
+        failure = self.assertRaises(EmailTokenError,
+                                    self.processor.validate_email,
+                                    **self.login_kwargs)
+        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, failure)
+
+    # reset_password
+
+    def test_request_password_reset_token_if_status_ok(self):
+        """A reset password token is succesfuly sent."""
+        result = self.processor.request_password_reset_token(email=EMAIL)
+        self.assertEqual(EMAIL, result,
+                         'password reset token must be successful.')
+
+    def test_request_password_reset_token_if_http_error(self):
+        """Proper error is raised if password token request fails."""
+        exc = self.assertRaises(ResetPasswordTokenError,
+                                self.processor.request_password_reset_token,
+                                email=EMAIL * 2)
+        self.assertIn(CANT_RESET_PASSWORD_CONTENT, exc)
+
+    def test_request_password_reset_token_if_status_unknown(self):
+        """Proper error is raised if password token request returns unknown."""
+        exc = self.assertRaises(ResetPasswordTokenError,
+                                self.processor.request_password_reset_token,
+                                email=None)
+        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
+
+    def test_set_new_password_if_status_ok(self):
+        """A new password is succesfuy set."""
+        result = self.processor.set_new_password(email=EMAIL,
+                                                 token=RESET_PASSWORD_TOKEN,
+                                                 new_password=PASSWORD)
+        self.assertEqual(EMAIL, result,
+                         'new password must be set successfully.')
+
+    def test_set_new_password_if_http_error(self):
+        """Proper error is raised if setting a new password fails."""
+        exc = self.assertRaises(NewPasswordError,
+                                self.processor.set_new_password,
+                                email=EMAIL * 2,
+                                token=RESET_PASSWORD_TOKEN * 2,
+                                new_password=PASSWORD)
+        self.assertIn(RESET_TOKEN_INVALID_CONTENT, exc)
+
+    def test_set_new_password_if_status_unknown(self):
+        """Proper error is raised if setting a new password returns unknown."""
+        exc = self.assertRaises(NewPasswordError,
+                                self.processor.set_new_password,
+                                email=None, token=None, new_password=None)
+        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
+
+
+class EnvironOverridesTestCase(TestCase):
+    """Some URLs can be set from the environment for testing/QA purposes."""
+
+    def test_override_service_url(self):
+        """The service url can be set from the env var USSOC_SERVICE_URL."""
+        fake_url = 'this is not really a URL'
+        old_url = os.environ.get('USSOC_SERVICE_URL')
+        os.environ['USSOC_SERVICE_URL'] = fake_url
+        try:
+            proc = Account(sso_service_class=FakedSSOServer)
+            self.assertEqual(proc.service_url, fake_url)
+        finally:
+            if old_url:
+                os.environ['USSOC_SERVICE_URL'] = old_url
+            else:
+                del os.environ['USSOC_SERVICE_URL']
+
+    def test_no_override_service_url(self):
+        """If the environ is unset, the default service url is used."""
+        proc = Account(sso_service_class=FakedSSOServer)
+        self.assertEqual(proc.service_url, SERVICE_URL)

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-09-30 21:09:44 +0000
+++ ubuntu_sso/tests/test_main.py	2010-10-01 17:16:44 +0000
@@ -26,10 +26,6 @@
 
 import gobject
 
-# Unable to import 'lazr.restfulclient.*'
-# pylint: disable=F0401
-from lazr.restfulclient.errors import HTTPError
-# pylint: enable=F0401
 from mocker import Mocker, MockerTestCase, ARGS, KWARGS, ANY
 from twisted.internet.defer import Deferred
 from twisted.trial.unittest import TestCase
@@ -39,54 +35,23 @@
 
 from contrib.testing.testcase import MementoHandler
 from ubuntu_sso import gui
-from ubuntu_sso.keyring import get_token_name, U1_APP_NAME
-from ubuntu_sso.main import (
-    AuthenticationError, blocking, EmailTokenError,
-    except_to_errdict, InvalidEmailError, InvalidPasswordError,
+from ubuntu_sso.keyring import U1_APP_NAME
+from ubuntu_sso.main import (blocking, except_to_errdict,
     keyring_get_credentials, keyring_store_credentials, logger,
-    NewPasswordError, PING_URL, SERVICE_URL,
-    RegistrationError, ResetPasswordTokenError,
-    SSOCredentials, SSOLogin, SSOLoginProcessor)
+    PING_URL, SSOCredentials, SSOLogin)
+from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, PASSWORD, TOKEN, TOKEN_NAME,
+    WINDOW_ID)
 
 
 # Access to a protected member 'yyy' of a client class
 # pylint: disable=W0212
 
-
-APP_NAME = 'The Coolest App Ever'
-CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
-                                            'files', 'captcha.png'))
-CAPTCHA_ID = 'test'
-CAPTCHA_SOLUTION = 'william Byrd'
-CANT_RESET_PASSWORD_CONTENT = "CanNotResetPassowrdError: " \
-                              "Can't reset password for this account"
-RESET_TOKEN_INVALID_CONTENT = "AuthToken matching query does not exist."
-EMAIL = '[e-mail]'
-EMAIL_ALREADY_REGISTERED = '[e-mail]'
-EMAIL_TOKEN = 'B2Pgtf'
-HELP = 'help text'
-PASSWORD = 'be4tiFul'
-RESET_PASSWORD_TOKEN = '8G5Wtq'
-TOKEN = {u'consumer_key': u'xQ7xDAz',
-         u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
-         u'token_name': u'test',
-         u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
-         u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
-TOKEN_NAME = get_token_name(APP_NAME)
-STATUS_UNKNOWN = {'status': 'yadda-yadda'}
-STATUS_ERROR = {'status': 'error', 'errors': {'something': ['Bla', 'Ble']}}
-STATUS_OK = {'status': 'ok'}
-STATUS_EMAIL_UNKNOWN = {'status': 'yadda-yadda'}
-STATUS_EMAIL_ERROR = {'errors': {'email_token': ['Error1', 'Error2']}}
-STATUS_EMAIL_OK = {'email': EMAIL}
-TC_URL = 'tcurl'
-WINDOW_ID = 5
-
 NO_OP = lambda *args, **kwargs: None
-LOGIN_OR_REGISTER_ARGS = (APP_NAME, TC_URL, HELP, WINDOW_ID)
+LOGIN_OR_REGISTER_ARGS = (APP_NAME, TC_URL, HELP_TEXT, WINDOW_ID)
 LOGIN_OR_REGISTER_GUI_ARGS = LOGIN_OR_REGISTER_ARGS + (False,)
-LOGIN_ONLY_ARGS = (APP_NAME, HELP, WINDOW_ID)
-LOGIN_ONLY_GUI_ARGS = (APP_NAME, None, HELP, WINDOW_ID, True)
+LOGIN_ONLY_ARGS = (APP_NAME, HELP_TEXT, WINDOW_ID)
+LOGIN_ONLY_GUI_ARGS = (APP_NAME, None, HELP_TEXT, WINDOW_ID, True)
 
 
 class FakedResponse(object):
@@ -97,273 +62,6 @@
             setattr(self, k, val)
 
 
-class FakedCaptchas(object):
-    """Fake the captcha generator."""
-
-    def new(self):
-        """Return a fix captcha)."""
-        return {'image_url': 'file://%s' % CAPTCHA_PATH,
-                'captcha_id': CAPTCHA_ID}
-
-
-class FakedRegistrations(object):
-    """Fake the registrations service."""
-
-    def register(self, email, password, captcha_id, captcha_solution):
-        """Fake registration. Return a fix result."""
-        if email == EMAIL_ALREADY_REGISTERED:
-            return {'status': 'error',
-                    'errors': {'email': 'Email already registered'}}
-        elif captcha_id is None and captcha_solution is None:
-            return STATUS_UNKNOWN
-        elif captcha_id != CAPTCHA_ID or captcha_solution != CAPTCHA_SOLUTION:
-            return STATUS_ERROR
-        else:
-            return STATUS_OK
-
-    def request_password_reset_token(self, email):
-        """Fake password reset token. Return a fix result."""
-        if email is None:
-            return STATUS_UNKNOWN
-        elif email != EMAIL:
-            raise HTTPError(response=None, content=CANT_RESET_PASSWORD_CONTENT)
-        else:
-            return STATUS_OK
-
-    def set_new_password(self, email, token, new_password):
-        """Fake the setting of new password. Return a fix result."""
-        if email is None and token is None and new_password is None:
-            return STATUS_UNKNOWN
-        elif email != EMAIL or token != RESET_PASSWORD_TOKEN:
-            raise HTTPError(response=None, content=RESET_TOKEN_INVALID_CONTENT)
-        else:
-            return STATUS_OK
-
-
-class FakedAuthentications(object):
-    """Fake the authentications service."""
-
-    def authenticate(self, token_name):
-        """Fake authenticate. Return a fix result."""
-        if not token_name.startswith(TOKEN_NAME):
-            raise HTTPError(response=None, content=None)
-        else:
-            return TOKEN
-
-
-class FakedAccounts(object):
-    """Fake the accounts service."""
-
-    def validate_email(self, email_token):
-        """Fake the email validation. Return a fix result."""
-        if email_token is None:
-            return STATUS_EMAIL_UNKNOWN
-        elif email_token == EMAIL_ALREADY_REGISTERED:
-            return {'status': 'error',
-                    'errors': {'email': 'Email already registered'}}
-        elif email_token != EMAIL_TOKEN:
-            return STATUS_EMAIL_ERROR
-        else:
-            return STATUS_EMAIL_OK
-
-
-class FakedSSOServer(object):
-    """Fake an SSO server."""
-
-    def __init__(self, authorizer, service_root):
-        self.captchas = FakedCaptchas()
-        self.registrations = FakedRegistrations()
-        self.authentications = FakedAuthentications()
-        self.accounts = FakedAccounts()
-
-
-class SSOLoginProcessorTestCase(TestCase, MockerTestCase):
-    """Test suite for the SSO login processor."""
-
-    def setUp(self):
-        """Init."""
-        self.processor = SSOLoginProcessor(sso_service_class=FakedSSOServer)
-        self.register_kwargs = dict(email=EMAIL, password=PASSWORD,
-                                    captcha_id=CAPTCHA_ID,
-                                    captcha_solution=CAPTCHA_SOLUTION)
-        self.login_kwargs = dict(email=EMAIL, password=PASSWORD,
-                                 token_name=TOKEN_NAME)
-
-    def tearDown(self):
-        """Clean up."""
-        self.processor = None
-
-    def test_generate_captcha(self):
-        """Captcha can be generated."""
-        filename = self.mktemp()
-        self.addCleanup(lambda: os.remove(filename))
-        captcha_id = self.processor.generate_captcha(filename)
-        self.assertEqual(CAPTCHA_ID, captcha_id, 'captcha id must be correct.')
-        self.assertTrue(os.path.isfile(filename), '%s must exist.' % filename)
-
-        with open(CAPTCHA_PATH) as f:
-            expected = f.read()
-        with open(filename) as f:
-            actual = f.read()
-        self.assertEqual(expected, actual, 'captcha image must be correct.')
-
-    def test_register_user_checks_valid_email(self):
-        """Email is validated."""
-        self.register_kwargs['email'] = 'notavalidemail'
-        self.assertRaises(InvalidEmailError,
-                          self.processor.register_user, **self.register_kwargs)
-
-    def test_register_user_checks_valid_password(self):
-        """Password is validated."""
-        self.register_kwargs['password'] = ''
-        self.assertRaises(InvalidPasswordError,
-                          self.processor.register_user, **self.register_kwargs)
-
-        # 7 chars, one less than expected
-        self.register_kwargs['password'] = 'tesT3it'
-        self.assertRaises(InvalidPasswordError,
-                          self.processor.register_user, **self.register_kwargs)
-
-        self.register_kwargs['password'] = 'test3it!'  # no upper case
-        self.assertRaises(InvalidPasswordError,
-                          self.processor.register_user, **self.register_kwargs)
-
-        self.register_kwargs['password'] = 'testIt!!'  # no number
-        self.assertRaises(InvalidPasswordError,
-                          self.processor.register_user, **self.register_kwargs)
-
-    # register
-
-    def test_register_user_if_status_ok(self):
-        """A user is succesfuy registered into the SSO server."""
-        result = self.processor.register_user(**self.register_kwargs)
-        self.assertEqual(EMAIL, result, 'registration was successful.')
-
-    def test_register_user_if_status_error(self):
-        """Proper error is raised if register fails."""
-        self.register_kwargs['captcha_id'] = CAPTCHA_ID * 2  # incorrect
-        failure = self.assertRaises(RegistrationError,
-                                    self.processor.register_user,
-                                    **self.register_kwargs)
-        for k, val in failure.args[0].items():
-            self.assertIn(k, STATUS_ERROR['errors'])
-            self.assertEqual(val, "\n".join(STATUS_ERROR['errors'][k]))
-
-    def test_register_user_if_status_error_with_string_message(self):
-        """Proper error is raised if register fails."""
-        self.register_kwargs['email'] = EMAIL_ALREADY_REGISTERED
-        failure = self.assertRaises(RegistrationError,
-                                    self.processor.register_user,
-                                    **self.register_kwargs)
-        for k, val in failure.args[0].items():
-            self.assertIn(k, {'email': 'Email already registered'})
-            self.assertEqual(val, 'Email already registered')
-
-    def test_register_user_if_status_unknown(self):
-        """Proper error is raised if register returns an unknown status."""
-        self.register_kwargs['captcha_id'] = None
-        self.register_kwargs['captcha_solution'] = None
-        failure = self.assertRaises(RegistrationError,
-                                    self.processor.register_user,
-                                    **self.register_kwargs)
-        self.assertIn('Received unknown status: %s' % STATUS_UNKNOWN, failure)
-
-    # login
-
-    def test_login_if_http_error(self):
-        """Proper error is raised if authentication fails."""
-        self.login_kwargs['token_name'] = APP_NAME * 2  # invalid token name
-        self.assertRaises(AuthenticationError,
-                          self.processor.login, **self.login_kwargs)
-
-    def test_login_if_no_error(self):
-        """A user can be succesfully logged in into the SSO service."""
-        result = self.processor.login(**self.login_kwargs)
-        self.assertEqual(TOKEN, result, 'authentication was successful.')
-
-    # validate_email
-
-    def test_validate_email_if_status_ok(self):
-        """A email is succesfuy validated in the SSO server."""
-        self.login_kwargs['email_token'] = EMAIL_TOKEN  # valid email token
-        result = self.processor.validate_email(**self.login_kwargs)
-        self.assertEqual(TOKEN, result, 'email validation was successful.')
-
-    def test_validate_email_if_status_error(self):
-        """Proper error is raised if email validation fails."""
-        self.login_kwargs['email_token'] = EMAIL_TOKEN * 2  # invalid token
-        failure = self.assertRaises(EmailTokenError,
-                                    self.processor.validate_email,
-                                    **self.login_kwargs)
-        for k, val in failure.args[0].items():
-            self.assertIn(k, STATUS_EMAIL_ERROR['errors'])
-            self.assertEqual(val, "\n".join(STATUS_EMAIL_ERROR['errors'][k]))
-
-    def test_validate_email_if_status_error_with_string_message(self):
-        """Proper error is raised if register fails."""
-        self.login_kwargs['email_token'] = EMAIL_ALREADY_REGISTERED
-        failure = self.assertRaises(EmailTokenError,
-                                    self.processor.validate_email,
-                                    **self.login_kwargs)
-        for k, val in failure.args[0].items():
-            self.assertIn(k, {'email': 'Email already registered'})
-            self.assertEqual(val, 'Email already registered')
-
-    def test_validate_email_if_status_unknown(self):
-        """Proper error is raised if email validation returns unknown."""
-        self.login_kwargs['email_token'] = None
-        failure = self.assertRaises(EmailTokenError,
-                                    self.processor.validate_email,
-                                    **self.login_kwargs)
-        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, failure)
-
-    # reset_password
-
-    def test_request_password_reset_token_if_status_ok(self):
-        """A reset password token is succesfuly sent."""
-        result = self.processor.request_password_reset_token(email=EMAIL)
-        self.assertEqual(EMAIL, result,
-                         'password reset token must be successful.')
-
-    def test_request_password_reset_token_if_http_error(self):
-        """Proper error is raised if password token request fails."""
-        exc = self.assertRaises(ResetPasswordTokenError,
-                                self.processor.request_password_reset_token,
-                                email=EMAIL * 2)
-        self.assertIn(CANT_RESET_PASSWORD_CONTENT, exc)
-
-    def test_request_password_reset_token_if_status_unknown(self):
-        """Proper error is raised if password token request returns unknown."""
-        exc = self.assertRaises(ResetPasswordTokenError,
-                                self.processor.request_password_reset_token,
-                                email=None)
-        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
-
-    def test_set_new_password_if_status_ok(self):
-        """A new password is succesfuy set."""
-        result = self.processor.set_new_password(email=EMAIL,
-                                                 token=RESET_PASSWORD_TOKEN,
-                                                 new_password=PASSWORD)
-        self.assertEqual(EMAIL, result,
-                         'new password must be set successfully.')
-
-    def test_set_new_password_if_http_error(self):
-        """Proper error is raised if setting a new password fails."""
-        exc = self.assertRaises(NewPasswordError,
-                                self.processor.set_new_password,
-                                email=EMAIL * 2,
-                                token=RESET_PASSWORD_TOKEN * 2,
-                                new_password=PASSWORD)
-        self.assertIn(RESET_TOKEN_INVALID_CONTENT, exc)
-
-    def test_set_new_password_if_status_unknown(self):
-        """Proper error is raised if setting a new password returns unknown."""
-        exc = self.assertRaises(NewPasswordError,
-                                self.processor.set_new_password,
-                                email=None, token=None, new_password=None)
-        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
-
-
 class BlockingSampleException(Exception):
     """The exception that will be thrown by the fake blocking."""
 
@@ -1391,22 +1089,3 @@
         """If the environ is unset, the default ping url is used."""
         creds = SSOCredentials(None)
         self.assertEqual(creds.ping_url, PING_URL)
-
-    def test_override_service_url(self):
-        """The service url can be set from the env var USSOC_SERVICE_URL."""
-        fake_url = 'this is not really a URL'
-        old_url = os.environ.get('USSOC_SERVICE_URL')
-        os.environ['USSOC_SERVICE_URL'] = fake_url
-        try:
-            proc = SSOLoginProcessor(sso_service_class=FakedSSOServer)
-            self.assertEqual(proc.service_url, fake_url)
-        finally:
-            if old_url:
-                os.environ['USSOC_SERVICE_URL'] = old_url
-            else:
-                del os.environ['USSOC_SERVICE_URL']
-
-    def test_no_override_service_url(self):
-        """If the environ is unset, the default service url is used."""
-        proc = SSOLoginProcessor(sso_service_class=FakedSSOServer)
-        self.assertEqual(proc.service_url, SERVICE_URL)