Merge lp:~mandel/ubuntu-sso-client/windows_ui_4 into lp:ubuntu-sso-client

[Manuel de la Peña]

Partial fix for lp:732203

Add SSO functionality to the Qt UI allowing to register and sign in users using the Ubuntu SSO client backend.

Partial fix for lp:732203

This branch adds SSO functionality to the Qt UI allowing to register and sign in users using the Ubuntu SSO client backend.

[Roberto Alsina (ralsina)]

+1

review: Approve

[Shane Fagan (shanepatrickfagan)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~mandel/ubuntu-sso-client/windows_ui_4 into lp:ubuntu-sso-client failed. Below is the output from the failed tests.

Running test suite for ubuntu_sso
Xlib: extension "RANDR" missing on display ":99".
ubuntu_sso.tests.test_account
  AccountTestCase
    test_generate_captcha ... [OK]
    test_is_not_validated ... [OK]
    test_is_not_validated_empty_result ... [OK]
    test_is_validated ... [OK]
    test_login_if_http_error ... [OK]
    test_login_if_no_error ... [OK]
    test_register_user_checks_valid_email ... [OK]
    test_register_user_checks_valid_password ... [OK]
    test_register_user_if_status_error ... [OK]
    test_register_user_if_status_error_with_string_message ... [OK]
    test_register_user_if_status_ok ... [OK]
    test_register_user_if_status_unknown ... [OK]
    test_request_password_reset_token_if_http_error ... [OK]
    test_request_password_reset_token_if_status_ok ... [OK]
    test_request_password_reset_token_if_status_unknown ... [OK]
    test_set_new_password_if_http_error ... [OK]
    test_set_new_password_if_status_ok ... [OK]
    test_set_new_password_if_status_unknown ... [OK]
    test_validate_email_if_status_error ... [OK]
    test_validate_email_if_status_error_with_string_message ... [OK]
    test_validate_email_if_status_ok ... [OK]
    test_validate_email_if_status_unknown ... [OK]
  EnvironOverridesTestCase
    test_no_override_service_url ... [OK]
    test_override_service_url ... [OK]
twisted.trial.unittest
  TestCase
    runTest ... [OK]
ubuntu_sso.tests.test_credentials
  BasicTestCase
    runTest ... [OK]
  ClearCredentialsTestCase
    test_clear_credentials ... [OK]
    test_keyring_failure ... [OK]
  CredentialsAuthDeniedTestCase
    test_auth_denial_cb ... [OK]
  CredentialsCallbacksTestCase
    test_callbacks_are_stored ... [OK]
    test_callbacks_default_to_no_op ... [OK]
    test_creation_parameters_are_stored ... [OK]
    test_error_cb ... [OK]
    test_help_text_defaults_to_empty_string ... [OK]
    t...

=== modified file 'data/qt/setup_account.ui'
--- data/qt/setup_account.ui	2011-03-30 14:28:05 +0000
+++ data/qt/setup_account.ui	2011-04-12 15:24:35 +0000
@@ -290,6 +290,12 @@
                </property>
                <item>
                 <widget class="QLabel" name="captcha_view">
+                 <property name="minimumSize">
+                  <size>
+                   <width>0</width>
+                   <height>57</height>
+                  </size>
+                 </property>
                  <property name="frameShape">
                   <enum>QFrame::Box</enum>
                  </property>

=== modified file 'pylintrc'
--- pylintrc	2010-09-22 16:14:28 +0000
+++ pylintrc	2011-04-12 15:24:35 +0000
@@ -20,7 +20,7 @@
 
 # Add <file or directory> to the black list. It should be a base name, not a
 # path. You may set this option multiple times.
-#ignore=<somedir>
+#ignore=qt
 
 # Pickle collected data for later comparisons.
 persistent=no
@@ -50,7 +50,8 @@
 # W0142: Used * or ** magic
 # W0613: Unused argument 'yyy'
 # C0302: Too many lines in module
-disable=R,I,W0142,W0613,C0302
+# W0404: Reimport of module
+disable=R,I,W0142,W0613,C0302,W0404
 
 
 [REPORTS]

=== modified file 'setup.py'
--- setup.py	2011-03-31 13:55:42 +0000
+++ setup.py	2011-04-12 15:24:35 +0000
@@ -49,6 +49,9 @@
 
     description = 'build extra files needed by ubuntu-sso-client'
 
+    def __init__(self):
+        build_extra.build_extra.__init__(self)
+
     def run(self):
         """Do the build."""
         sed = find_executable('sed')
@@ -93,6 +96,9 @@
 
     description = "build PyQt GUIs (.ui) and resources (.qrc)"
 
+    def __init__(self):
+        build_extra.build_extra.__init__(self)
+
     def compile_ui(self, ui_file, py_file=None):
         """Compile the .ui files to python modules."""
         # Search for pyuic4 in python bin dir, then in the $Path.

=== modified file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	2011-03-30 18:50:04 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2011-04-12 15:24:35 +0000
@@ -40,8 +40,9 @@
     SSOLoginClient,
     UbuntuSSORoot)
 
-# because we are using twisted we have java like names C0103
-# pylint: disable=C0103
+# because we are using twisted we have java like names C0103 and
+# the issues that mocker brings with it like W0104
+# pylint: disable=C0103,W0104
 
 
 class SaveProtocolServerFactory(PBServerFactory):
@@ -141,14 +142,17 @@
     def test_emit_captcha_generation_error(self):
         """Test that the cb was called."""
         app_name = 'app'
-        raised_error = 'error'
+        error_value = 'error'
+        raised_error = self.mocker.mock()
 
         @defer.inlineCallbacks
         def test_emit(client):
             """Actual test."""
-            self.except_to_errdict(raised_error)
-            self.mocker.result(raised_error)
-            client.on_captcha_generation_error_cb(app_name, raised_error)
+            raised_error.value
+            self.mocker.result(error_value)
+            self.except_to_errdict(error_value)
+            self.mocker.result(error_value)
+            client.on_captcha_generation_error_cb(app_name, error_value)
             self.mocker.replay()
             self.login.emit_captcha_generation_error(app_name, raised_error)
             yield client.unregister_to_signals()
@@ -205,14 +209,17 @@
     def test_emit_user_registration_error(self):
         """Test that the cb was called."""
         app_name = 'app'
-        raised_error = 'error'
+        error_value = 'error'
+        raised_error = self.mocker.mock()
 
         @defer.inlineCallbacks
         def test_emit(client):
             """Actual test."""
-            self.except_to_errdict(raised_error)
-            self.mocker.result(raised_error)
-            client.on_user_registration_error_cb(app_name, raised_error)
+            raised_error.value
+            self.mocker.result(error_value)
+            self.except_to_errdict(error_value)
+            self.mocker.result(error_value)
+            client.on_user_registration_error_cb(app_name, error_value)
             self.mocker.replay()
             self.login.emit_user_registration_error(app_name, raised_error)
             yield client.unregister_to_signals()
@@ -275,14 +282,17 @@
     def test_emit_login_error(self):
         """Test that the db was called."""
         app_name = 'app'
-        raised_error = 'error'
+        error_value = 'error'
+        raised_error = self.mocker.mock()
 
         @defer.inlineCallbacks
         def test_emit(client):
             """Actual test."""
-            self.except_to_errdict(raised_error)
-            self.mocker.result(raised_error)
-            client.on_login_error_cb(app_name, raised_error)
+            raised_error.value
+            self.mocker.result(error_value)
+            self.except_to_errdict(error_value)
+            self.mocker.result(error_value)
+            client.on_login_error_cb(app_name, error_value)
             self.mocker.replay()
             self.login.emit_login_error(app_name, raised_error)
             yield client.unregister_to_signals()
@@ -361,14 +371,17 @@
     def test_emit_email_validation_error(self):
         """Test the cb was called."""
         app_name = 'app'
-        raised_error = 'error'
+        error_value = 'error'
+        raised_error = self.mocker.mock()
 
         @defer.inlineCallbacks
         def test_emit(client):
             """Actual test."""
-            self.except_to_errdict(raised_error)
-            self.mocker.result(raised_error)
-            client.on_email_validation_error_cb(app_name, raised_error)
+            raised_error.value
+            self.mocker.result(error_value)
+            self.except_to_errdict(error_value)
+            self.mocker.result(error_value)
+            client.on_email_validation_error_cb(app_name, error_value)
             self.mocker.replay()
             self.login.emit_email_validation_error(app_name, raised_error)
             yield client.unregister_to_signals()
@@ -427,14 +440,17 @@
     def test_emit_password_reset_error(self):
         """Test the cb was called."""
         app_name = 'app'
-        raised_error = 'error'
+        error_value = 'error'
+        raised_error = self.mocker.mock()
 
         @defer.inlineCallbacks
         def test_emit(client):
             """Actual test."""
-            self.except_to_errdict(raised_error)
-            self.mocker.result(raised_error)
-            client.on_password_reset_error_cb(app_name, raised_error)
+            raised_error.value
+            self.mocker.result(error_value)
+            self.except_to_errdict(error_value)
+            self.mocker.result(error_value)
+            client.on_password_reset_error_cb(app_name, error_value)
             self.mocker.replay()
             self.login.emit_password_reset_error(app_name, raised_error)
             yield client.unregister_to_signals()
@@ -491,14 +507,17 @@
     def test_emit_password_change_error(self):
         """Test the cb was called."""
         app_name = 'app'
-        raised_error = 'error'
+        error_value = 'error'
+        raised_error = self.mocker.mock()
 
         @defer.inlineCallbacks
         def test_emit(client):
             """Actual test."""
-            self.except_to_errdict(raised_error)
-            self.mocker.result(raised_error)
-            client.on_password_change_error(app_name, raised_error)
+            raised_error.value
+            self.mocker.result(error_value)
+            self.except_to_errdict(error_value)
+            self.mocker.result(error_value)
+            client.on_password_change_error(app_name, error_value)
             self.mocker.replay()
             self.login.emit_password_change_error(app_name, raised_error)
             yield client.unregister_to_signals()

=== modified file 'ubuntu_sso/main/windows.py'
--- ubuntu_sso/main/windows.py	2011-03-30 19:27:48 +0000
+++ ubuntu_sso/main/windows.py	2011-04-12 15:24:35 +0000
@@ -15,7 +15,6 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Main implementation on windows."""
-
 from functools import wraps
 from twisted.internet import defer, reactor
 from twisted.internet.threads import deferToThread
@@ -61,7 +60,7 @@
 from ubuntu_sso.main import (CredentialsManagementRoot, SSOLoginRoot,
                              SSOCredentialsRoot, except_to_errdict)
 
-logger = setup_logging("ubuntu_sso.main")
+logger = setup_logging("ubuntu_sso.main.windows")
 NAMED_PIPE_URL = '\\\\.\\pipe\\ubuntu_sso\\%s'
 
 
@@ -74,9 +73,11 @@
 
 def blocking(f, app_name, result_cb, error_cb):
     """Run f in a thread; return or throw an exception thru the callbacks."""
-    d = deferToThread(f, app_name)
-    d.addCallbacks(result_cb, error_cb, callbackArgs=(app_name,),
-                   errbackArgs=(app_name,))
+    d = deferToThread(f)
+    # the calls in twisted will be called with the args in a diff order,
+    # in order to follow the linux api, we swap them around with a lambda
+    d.addCallback(lambda result, app: result_cb(app, result), app_name)
+    d.addErrback(lambda err, app: error_cb(app, err), app_name)
 
 
 class RemoteMeta(type):
@@ -164,7 +165,7 @@
         logger.debug('SSOLogin: emitting CaptchaGenerationError with '
                      'app_name "%s" and error %r', app_name, raised_error)
         self.emit_signal('on_captcha_generation_error', app_name,
-                         except_to_errdict(raised_error))
+                         except_to_errdict(raised_error.value))
 
     def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
@@ -184,7 +185,7 @@
         logger.debug('SSOLogin: emitting UserRegistrationError with '
                      'app_name "%s" and error %r', app_name, raised_error)
         self.emit_signal('on_user_registration_error', app_name,
-                         except_to_errdict(raised_error))
+                         except_to_errdict(raised_error.value))
 
     def register_user(self, app_name, email, password, displayname,
                       captcha_id, captcha_solution):
@@ -206,7 +207,7 @@
         logger.debug('SSOLogin: emitting LoginError with '
                      'app_name "%s" and error %r', app_name, raised_error)
         self.emit_signal('on_login_error', app_name,
-                         except_to_errdict(raised_error))
+                         except_to_errdict(raised_error.value))
 
     def emit_user_not_validated(self, app_name, result):
         """Signal thrown when the user is not validated."""
@@ -232,7 +233,7 @@
         logger.debug('SSOLogin: emitting EmailValidationError with '
                      'app_name "%s" and error %r', app_name, raised_error)
         self.emit_signal('on_email_validation_error', app_name,
-                         except_to_errdict(raised_error))
+                         except_to_errdict(raised_error.value))
 
     def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
@@ -252,7 +253,7 @@
         logger.debug('SSOLogin: emitting PasswordResetError with '
                      'app_name "%s" and error %r', app_name, raised_error)
         self.emit_signal('on_password_reset_error', app_name,
-                         except_to_errdict(raised_error))
+                         except_to_errdict(raised_error.value))
 
     def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
@@ -272,7 +273,7 @@
         logger.debug('SSOLogin: emitting PasswordChangeError with '
                      'app_name "%s" and error %r', app_name, raised_error)
         self.emit_signal('on_password_change_error', app_name,
-                         except_to_errdict(raised_error))
+                         except_to_errdict(raised_error.value))
 
     def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
@@ -918,9 +919,12 @@
     @defer.inlineCallbacks
     def _request_remote_objects(self, root):
         """Get the status remote object."""
-        self.sso_login = yield root.callRemote('get_sso_login')
-        self.sso_cred = yield root.callRemote('get_sso_credentials')
-        self.cred_management = yield root.callRemote('get_cred_manager')
+        sso_login = yield root.callRemote('get_sso_login')
+        self.sso_login = SSOLoginClient(sso_login)
+        sso_cred = yield root.callRemote('get_sso_credentials')
+        self.sso_cred = SSOCredentialsClient(sso_cred)
+        cred_management = yield root.callRemote('get_cred_manager')
+        self.cred_management = CredentialsManagementClient(cred_management)
         defer.returnValue(self)
 
     def connect(self):

=== modified file 'ubuntu_sso/qt/controllers.py'
--- ubuntu_sso/qt/controllers.py	2011-04-05 13:37:33 +0000
+++ ubuntu_sso/qt/controllers.py	2011-04-12 15:24:35 +0000
@@ -16,13 +16,21 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Controllers with the logic of the UI."""
 
+import os
+import tempfile
+
+from PyQt4.QtGui import QMessageBox
 from PyQt4.QtCore import QUrl
+from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.main.windows import UbuntuSSOClient
 from ubuntu_sso.utils.ui import (
     CAPTCHA_SOLUTION_ENTRY,
     EMAIL1_ENTRY,
     EMAIL2_ENTRY,
+    EMAIL_MISMATCH,
+    EMAIL_INVALID,
     EXISTING_ACCOUNT_CHOICE_BUTTON,
     FORGOTTEN_PASSWORD_BUTTON,
     JOIN_HEADER_LABEL,
@@ -30,9 +38,12 @@
     PASSWORD1_ENTRY,
     PASSWORD2_ENTRY,
     PASSWORD_HELP,
+    PASSWORD_MISMATCH,
+    PASSWORD_TOO_WEAK,
     SET_UP_ACCOUNT_CHOICE_BUTTON,
     SET_UP_ACCOUNT_BUTTON,
     SIGN_IN_BUTTON,
+    SUCCESS,
     SURNAME_ENTRY,
     TC_BUTTON,
     VERIFY_EMAIL_TITLE,
@@ -45,6 +56,36 @@
 logger = setup_logging('ubuntu_sso.controllers')
 
 
+class BackendController(object):
+    """Represent a controller that talks with the sso backend."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.root = None
+        self.backends = []
+
+    def __del__(self):
+        """Clean the resources."""
+        logger.info('Unregistering %s backends', len(self.backends))
+        for backend in self.backends:
+            backend.unregister_to_signals()
+        if self.root is not None:
+            logger.info('Disconnecting from root.')
+            self.root.disconnect()
+
+    @inlineCallbacks
+    def get_backend(self):
+        """Return the backend used by the controller."""
+        # get the back end from the root
+        if self.root is None:
+            self.root = UbuntuSSOClient()
+            self.root = yield self.root.connect()
+        backend = self.root.sso_login
+        yield backend.register_to_signals()
+        self.backends.append(backend)
+        returnValue(backend)
+
+
 class ChooseSignInController(object):
     """Controlled to the ChooseSignIn view/widget."""
 
@@ -87,12 +128,17 @@
         view.wizard().next()
 
 
-class CurrentUserController(object):
+class CurrentUserController(BackendController):
     """Controller used in the view that is used to allow the signin."""
 
-    def __init__(self, title=''):
+    def __init__(self, backend=None, title='', app_name='', message_box=None):
         """Create a new instance."""
+        super(CurrentUserController, self).__init__()
+        if message_box is None:
+            message_box = QMessageBox
+        self.message_box = message_box
         self._title = title
+        self._app_name = app_name
 
     def _set_translated_strings(self, view):
         """Set the translated strings."""
@@ -102,21 +148,56 @@
         view.forgot_password_label.setText(FORGOTTEN_PASSWORD_BUTTON)
         view.sign_in_button.setText(SIGN_IN_BUTTON)
 
+    def _connect_buttons(self, view, backend):
+        """Connect the buttons to perform actions."""
+        view.sign_in_button.clicked.connect(lambda: self.login(view, backend))
+        # lets add call backs to be execute for the calls we are interested
+        backend.on_login_error_cb = lambda app, error:\
+                                        self.on_login_error(view, app, error)
+        backend.on_logged_in_cb = lambda app, result:\
+                                        self.on_logged_in(view, app, result)
+
+    def login(self, view, backend):
+        """Perform the login using the backend."""
+        logger.debug('Trying to log in using %s', backend)
+        # grab the data from the view and call the backend
+        d = backend.login(self._app_name, view.email, view.password)
+        d.addErrback(lambda e: self.on_login_error(view, self._app_name, e))
+
+    def on_login_error(self, view, app_name, error):
+        """There was an error when login in."""
+        # let the user know
+        logger.error('Got error when login %s, error: %s', app_name, error)
+        self.message_box.critical(view, app_name, error)
+
+    def on_logged_in(self, view, app_name, result):
+        """We managed to log in."""
+        logger.info('Logged in for %s', app_name)
+        self.message_box.information(view, app_name, SUCCESS)
+        view.wizard.close()
+
     # use an ugly name just so have a simlar api as found in PyQt
     #pylint: disable=C0103
+    @inlineCallbacks
     def setupUi(self, view):
         """Setup the view."""
+        backend = yield self.get_backend()
         view.setTitle(self._title)
         self._set_translated_strings(view)
+        self._connect_buttons(view, backend)
     #pylint: enable=C0103
 
 
-class SetUpAccountController(object):
+class SetUpAccountController(BackendController):
     """Conroller for the setup account view."""
 
     def __init__(self, tos_id=0, validation_id=1, app_name='',
-                 help_message=''):
+                 help_message='', message_box=None):
         """Create a new instance."""
+        super(SetUpAccountController, self).__init__()
+        if message_box is None:
+            message_box = QMessageBox
+        self.message_box = message_box
         self._tos_id = tos_id
         self._validation_id = validation_id
         self._app_name = app_name
@@ -157,31 +238,90 @@
         view.password_edit.textChanged.connect(
                                    view.confirm_password_edit.textChanged.emit)
 
-    def _connect_ui_elements(self, view):
+    def _connect_ui_elements(self, view, backend):
         """Set the connection of signals."""
         view.terms_and_conditions_button.clicked.connect(
                                                lambda: self.set_next_tos(view))
         view.set_up_button.clicked.connect(lambda: self.set_next_validation(
-                                                                         view))
+                                                                view, backend))
         view.password_edit.textChanged.connect(
                               lambda x: self.update_password_strength(x, view))
         view.terms_and_conditions_check_box.stateChanged.connect(
                                                  view.set_up_button.setEnabled)
+        view.captcha_refresh_label.linkActivated.connect(lambda url:\
+                                          self._refresh_captcha(view, backend))
+        # set the callbacks for the captcha generation
+        backend.on_captcha_generated_cb = lambda app, result:\
+                                self.on_captcha_generated(view, app, result)
+        backend.on_captcha_generation_error_cb = lambda app, error:\
+                            self.on_captcha_generation_error(view, app, error)
+        backend.on_user_registration_error_cb = lambda app, error:\
+                            self.on_user_registration_error(view, app, error)
+        return backend
+
+    def _refresh_captcha(self, view, backend):
+        """Refresh the captcha image shown in the ui."""
+        # lets clean behind us, do we have the old file arround?
+        old_file = None
+        if view.captcha_file and os.path.exists(view.captcha_file):
+            old_file = view.captcha_file
+        fd = tempfile.TemporaryFile(mode='r')
+        file_name = fd.name
+        view.captcha_file = file_name
+        d = backend.generate_captcha(self._app_name, file_name)
+        if old_file:
+            d.addCallback(lambda x: os.unlink(old_file))
+        d.addErrback(lambda e: self.on_captcha_generation_error(view,
+                                                                self._app_name,
+                                                                e))
 
     def _set_titles(self, view):
         """Set the diff titles of the view."""
         view.setTitle(JOIN_HEADER_LABEL % {'app_name': self._app_name})
         view.setSubTitle(self._help_message)
 
+    def on_captcha_generated(self, view, app_name, result):
+        """A new image was generated."""
+        view.captcha_image = result
+
+    def on_captcha_generation_error(self, view, app_name, error):
+        """An error ocurred."""
+        self.message_box.critical(view, app_name, str(error))
+
+    def on_user_registration_error(self, view, app_name, error):
+        """Let the user know we could not register."""
+        # error are returned as a dict with the data we want to show.
+        self.message_box.critical(view, error['errtype'], error['email'])
+
     def set_next_tos(self, view):
         """Set the tos page as the next one."""
         view.next = self._tos_id
         view.wizard().next()
 
-    def set_next_validation(self, view):
+    def validate_form(self, view):
+        """Validate the info of the form and return an error."""
+        if not self.is_correct_email(view.email):
+            self.message_box.critical(view, self._app_name, EMAIL_INVALID)
+        if view.email_edit.text() != view.confirm_email_edit.text():
+            self.message_box.critical(view, self._app_name, EMAIL_MISMATCH)
+            return False
+        if not is_min_required_password(str(view.password_edit.text())):
+            self.message_box.critical(view, self._app_name, PASSWORD_TOO_WEAK)
+            return False
+        if view.password_edit.text() != view.confirm_password_edit.text():
+            self.message_box.critical(view, self._app_name, PASSWORD_MISMATCH)
+            return False
+        return True
+
+    def set_next_validation(self, view, backend):
         """Set the validation as the next page."""
-        view.next = self._validation_id
-        view.wizard().next()
+        # validate the current info of the form, try to perform the action
+        # to register the user, and then move foward
+        if self.validate_form(view):
+            backend.register_user(self._app_name, view.email, view.password,
+                                  view.captcha_id, view.captcha_solution)
+            view.next = self._validation_id
+            view.wizard().next()
 
     def update_password_strength(self, password, view):
         """Callback used to update the password strenght UI code."""
@@ -203,12 +343,16 @@
         return view.password_edit.text() == password
 
     #pylint: disable=C0103
+    @inlineCallbacks
     def setupUi(self, view):
         """Setup the view."""
+        # request the backend to be used with the ui
+        backend = yield self.get_backend()
+        self._connect_ui_elements(view, backend)
+        self._refresh_captcha(view, backend)
         self._set_titles(view)
         self._set_translated_strings(view)
         self._set_line_edits_validations(view)
-        self._connect_ui_elements(view)
     #pylint: enable=C0103
 
 

=== modified file 'ubuntu_sso/qt/gui.py'
--- ubuntu_sso/qt/gui.py	2011-04-05 13:37:33 +0000
+++ ubuntu_sso/qt/gui.py	2011-04-12 15:24:35 +0000
@@ -16,7 +16,6 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Qt implementation of the UI."""
 
-from PyQt4 import Qt
 from PyQt4.QtGui import (
     QApplication,
     QColor,
@@ -27,8 +26,7 @@
     QPushButton,
     QStyle,
     QWizard,
-    QWizardPage,
-    QGraphicsScene)
+    QWizardPage)
 
 from ubuntu_sso.logger import setup_logging
 # pylint: disable=F0401,E0611
@@ -50,7 +48,7 @@
 
 # colors used to define the password stenght
 WEAK_COLOR = QColor(220, 20, 60)
-MEDIUN_COLOR = QColor(255, 215, 0)
+MEDIUM_COLOR = QColor(255, 215, 0)
 STRONG_COLOR = QColor(50, 205, 50)
 
 
@@ -224,13 +222,11 @@
         # palettes that will be used to set the colors of the password strenght
         original_palette = self.ui.strenght_frame.palette()
         self._original_color = original_palette.background().color()
+        self.next = -1
+        self.captcha_id = None
+        self.captcha_file = None
         self.controller = controller
         self.controller.setupUi(self)
-        self.next = -1
-        # create the scene to be used to show the captcha
-        self.image = None
-        self.image_file = None
-        self.scene = QGraphicsScene(self.ui.captcha_view)
 
     def set_strenght_level(self, level, password):
         """Set the strenght level colors."""
@@ -348,6 +344,11 @@
         return self.ui.confirm_password_edit
 
     @property
+    def captcha_refresh_label(self):
+        """Return the refresh label."""
+        return self.ui.refresh_label
+
+    @property
     def captcha_solution(self):
         """Return the provided captcha solution."""
         return str(self.ui.captcha_solution_edit.text())
@@ -359,15 +360,14 @@
 
     def get_captcha_image(self):
         """Return the path to the captcha image."""
-        return self.image_file
+        return self.captcha_id
 
-    def set_captcha_image(self, file_path):
+    def set_captcha_image(self, data):
         """Set the new image of the captcha."""
-        if self.image:
-            self.scene.removeItem(self.image)
-        self.image_file = file_path
-        pix = QPixmap(self.image_file)
-        self.image = self.scene.addPixmap(pix)
+        self.captcha_id = data
+        # lets set the QPixmap for the label
+        pic = QPixmap(self.captcha_file)
+        self.ui.captcha_view.setPixmap(pic)
 
     captcha_image = property(get_captcha_image, set_captcha_image)
 
@@ -416,7 +416,8 @@
         self.email_verification = EmailVerificationPage(
                                                 Ui_EmailVerificationPage(),
                                                 EmailVerificationController())
-        self.current_user_controller = CurrentUserController(title='Sign in')
+        self.current_user_controller = CurrentUserController(title='Sign in',
+                                                            app_name=app_name)
         self.current_user = CurrentUserSignInPage(Ui_CurrentUserSignInPage(),
                                                   self.current_user_controller,
                                                   parent=self)
@@ -445,15 +446,3 @@
 
 class UbuntuSSOClientGUI(object):
     """Ubuntu single sign-on GUI."""
-
-if __name__ == '__main__':
-    # pylint: disable=C0103
-    # show the ui
-    import sys
-
-    app = Qt.QApplication(sys.argv)
-
-    wizard = UbuntuSSOWizard()
-    wizard.show()
-    # Now we can start it.
-    app.exec_()

=== added file 'ubuntu_sso/qt/tests/show_gui.py'
--- ubuntu_sso/qt/tests/show_gui.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/tests/show_gui.py	2011-04-12 15:24:35 +0000
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Author: Manuel de la Pena <[e-mail]>
+#
+# Copyright 2011 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/>.
+"""Script that shows the qt gui."""
+
+
+if __name__ == '__main__':
+    # pylint: disable=C0103,E1101,F0401
+    # show the ui
+    import sys
+    from PyQt4 import Qt
+    app = Qt.QApplication(sys.argv)
+    from qtreactor import qt4reactor
+    qt4reactor.install()
+    from twisted.internet import reactor
+    from ubuntu_sso.qt.gui import UbuntuSSOWizard
+
+    wizard = UbuntuSSOWizard(app_name='test')
+    wizard.show()
+    reactor.run()

=== renamed file 'ubuntu_sso/qt/tests/test_controllers.py' => 'ubuntu_sso/qt/tests/test_windows.py'
--- ubuntu_sso/qt/tests/test_controllers.py	2011-04-05 13:45:31 +0000
+++ ubuntu_sso/qt/tests/test_windows.py	2011-04-12 15:24:35 +0000
@@ -28,6 +28,7 @@
     CAPTCHA_SOLUTION_ENTRY,
     EMAIL1_ENTRY,
     EMAIL2_ENTRY,
+    EMAIL_MISMATCH,
     EXISTING_ACCOUNT_CHOICE_BUTTON,
     FORGOTTEN_PASSWORD_BUTTON,
     JOIN_HEADER_LABEL,
@@ -35,6 +36,8 @@
     PASSWORD1_ENTRY,
     PASSWORD2_ENTRY,
     PASSWORD_HELP,
+    PASSWORD_TOO_WEAK,
+    PASSWORD_MISMATCH,
     SET_UP_ACCOUNT_CHOICE_BUTTON,
     SET_UP_ACCOUNT_BUTTON,
     SIGN_IN_BUTTON,
@@ -95,17 +98,28 @@
         """Setup tests."""
         super(CurrentUserControllerTestCase, self).setUp()
         self.view = self.mocker.mock()
-        self.controller = CurrentUserController(title='the title')
+        self.backend = self.mocker.mock()
+        self.connect = self.mocker.mock()
+        self.signal = self.mocker.replace('PyQt4.QtCore.SIGNAL')
+        self.controller = CurrentUserController(title='the title',
+                                                backend=self.backend)
 
-    def test_setup_ui(self):
+    def test_translated_strings(self):
         """test that the ui is correctly set up."""
-        self.view.setTitle(self.controller._title)
         self.view.email_edit.setPlaceholderText(EMAIL1_ENTRY)
         self.view.password_edit.setPlaceholderText(PASSWORD1_ENTRY)
         self.view.forgot_password_label.setText(FORGOTTEN_PASSWORD_BUTTON)
         self.view.sign_in_button.setText(SIGN_IN_BUTTON)
         self.mocker.replay()
-        self.controller.setupUi(self.view)
+        self.controller._set_translated_strings(self.view)
+
+    def test_connect_ui(self):
+        """test that the ui is correctly set up."""
+        self.view.sign_in_button.clicked.connect(MATCH(callable))
+        self.backend.on_login_error_cb = MATCH(callable)
+        self.backend.on_logged_in_cb = MATCH(callable)
+        self.mocker.replay()
+        self.controller._connect_buttons(self.view, self.backend)
 
 
 class SetUpAccountControllerTestCase(MockerTestCase):
@@ -119,8 +133,10 @@
                                  'ubuntu_sso.utils.ui.get_password_strength')
         self.app_name = 'test'
         self.help = 'help'
+        self.message_box = self.mocker.mock()
         self.controller = SetUpAccountController(app_name=self.app_name,
-                                                 help_message=self.help)
+                                                 help_message=self.help,
+                                                 message_box=self.message_box)
 
     def test_set_translated_strings(self):
         """Ensure all the strings are set."""
@@ -148,15 +164,21 @@
 
     def test_connect_ui_elements(self):
         """Test that the ui elements are correctly connect."""
+        backend = self.mocker.mock()
         self.view.terms_and_conditions_button.clicked.connect(MATCH(callable))
         self.view.set_up_button.clicked.connect(MATCH(callable))
         self.view.password_edit.textChanged.connect(MATCH(callable))
         self.view.set_up_button.setEnabled
-        self.mocker.result(lambda:None)
+        self.mocker.result(lambda: None)
         self.view.terms_and_conditions_check_box.stateChanged.connect(
                                                              MATCH(callable))
+        self.view.captcha_refresh_label.linkActivated.connect(MATCH(callable))
+        # set the callbacks for the captcha generatio
+        backend.on_captcha_generated_cb = MATCH(callable)
+        backend.on_captcha_generation_error_cb = MATCH(callable)
+        backend.on_user_registration_error_cb = MATCH(callable)
         self.mocker.replay()
-        self.controller._connect_ui_elements(self.view)
+        self.controller._connect_ui_elements(self.view, backend)
 
     def test_is_correct_password_confirmation_false(self):
         """Test when the password is not correct."""
@@ -219,10 +241,86 @@
 
     def test_set_next_validation(self):
         """Test the callback."""
+        email = '[e-mail]'
+        password = 'Qwerty9923'
+        captcha_id = 'captcha_id'
+        captcha_solution = 'captcha_solution'
+        self.view.email
+        self.mocker.result(email)
+        self.view.email_edit.text()
+        self.mocker.result(email)
+        self.view.confirm_email_edit.text()
+        self.mocker.result(email)
+        self.view.password_edit.text()
+        self.mocker.result(password)
+        self.view.password_edit.text()
+        self.mocker.result(password)
+        self.view.confirm_password_edit.text()
+        self.mocker.result(password)
+        self.view.email
+        self.mocker.result(email)
+        self.view.password
+        self.mocker.result(password)
+        self.view.captcha_id
+        self.mocker.result(captcha_id)
+        self.view.captcha_solution
+        self.mocker.result(captcha_solution)
+        backend = self.mocker.mock()
+        backend.register_user(self.app_name, email, password, captcha_id,
+                              captcha_solution)
         self.view.next = self.controller._validation_id
         self.view.wizard().next()
         self.mocker.replay()
-        self.controller.set_next_validation(self.view)
+        self.controller.set_next_validation(self.view, backend)
+
+    def test_set_next_validation_wrong_email(self):
+        """Test the callback when there is a wrong email."""
+        email = '[e-mail]'
+        self.view.email
+        self.mocker.result(email)
+        self.view.email_edit.text()
+        self.mocker.result('email')
+        self.view.confirm_email_edit.text()
+        self.mocker.result('email2')
+        self.message_box.critical(self.view, self.app_name, EMAIL_MISMATCH)
+        self.mocker.replay()
+        self.assertFalse(self.controller.validate_form(self.view))
+
+    def test_set_next_validation_not_min_password(self):
+        """Test the callback with a weak password."""
+        weak_password = 'weak'
+        email = '[e-mail]'
+        self.view.email
+        self.mocker.result(email)
+        self.view.email_edit.text()
+        self.mocker.result(email)
+        self.view.confirm_email_edit.text()
+        self.mocker.result(email)
+        self.view.password_edit.text()
+        self.mocker.result(weak_password)
+        self.message_box.critical(self.view, self.app_name, PASSWORD_TOO_WEAK)
+        self.mocker.replay()
+        self.assertFalse(self.controller.validate_form(self.view))
+
+    def test_set_next_validation_wrong_password(self):
+        """Test the callback where the password is wrong."""
+        password = 'Qwerty9923'
+        email = '[e-mail]'
+        self.view.email
+        self.mocker.result(email)
+        self.view.email_edit.text()
+        self.mocker.result(email)
+        self.view.confirm_email_edit.text()
+        self.mocker.result(email)
+        self.view.password_edit.text()
+        self.mocker.result(password)
+        self.view.password_edit.text()
+        self.mocker.result(password)
+        self.view.confirm_password_edit.text()
+        self.mocker.result('other_password')
+        self.message_box.critical(self.view, self.app_name, PASSWORD_MISMATCH)
+        self.mocker.replay()
+        self.assertFalse(self.controller.validate_form(self.view))
 
     def test_update_password_strength(self):
         """Test the callback."""