Merge lp:~diegosarmentero/ubuntu-sso-client/qt-refactor into lp:ubuntu-sso-client

[Diego Sarmentero]

- Refactor the pages and controller in sso (LP: #929686).

Now the Qt UI can be started in linux.

[lp:~diegosarmentero/ubuntu-sso-client/qt-refactor]

852. By Diego Sarmentero on 2012-02-09

String moved to utils.ui

853. By Diego Sarmentero on 2012-02-10

merge

[Natalia Bidart (nataliabidart)]

Looks great!

review: Approve

[Roberto Alsina (ralsina)]

I like it.

review: Approve

=== modified file 'data/qt/choose_sign_in.ui'
--- data/qt/choose_sign_in.ui	2012-02-02 13:40:36 +0000
+++ data/qt/choose_sign_in.ui	2012-02-10 11:32:20 +0000
@@ -65,7 +65,7 @@
       </font>
      </property>
      <property name="text">
-      <string>Congratulations, Ubuntu One is installed!</string>
+      <string>Congratulations, app_name is installed!</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>

=== modified file 'ubuntu_sso/qt/__init__.py'
--- ubuntu_sso/qt/__init__.py	2012-02-03 15:11:19 +0000
+++ ubuntu_sso/qt/__init__.py	2012-02-10 11:32:20 +0000
@@ -17,10 +17,13 @@
 """The Qt graphical interface for the Ubuntu Single Sign On Client."""
 
 import gettext
+import collections
 
 
 _ = gettext.gettext
 
+ERROR_ALL = '__all__'
+ERROR_MESSAGE = 'message'
 LOCAL_FOLDERS_TITLE = _("Syncing your computer with the cloud")
 LOCAL_FOLDERS_SPACE_HEADER = _("Space (%s)")
 LOCAL_FOLDERS_OFFER_LABEL = _("The folders you have selected to sync "
@@ -28,3 +31,29 @@
     "some extra space")
 LOCAL_FOLDERS_CALCULATING = _("Calculating")
 NEXT = _("Next")
+
+
+# Based on the gtk implementation
+def build_general_error_message(errordict):
+    """Build a user-friendly error message from the errordict."""
+    result = ''
+    if isinstance(errordict, collections.Mapping):
+        msg1 = errordict.get(ERROR_ALL)
+        msg2 = errordict.get(ERROR_MESSAGE)
+        if msg2 is None:
+            # See the errordict in LP: 828417
+            msg2 = errordict.get('error_message')
+        if msg1 is not None and msg2 is not None:
+            result = '\n'.join((msg1, msg2))
+        elif msg1 is not None:
+            result = msg1
+        elif msg2 is not None:
+            result = msg2
+        else:
+            if 'errtype' in errordict:
+                del errordict['errtype']
+            result = '\n'.join(
+                [('%s: %s' % (k, v)) for k, v in errordict.iteritems()])
+    else:
+        result = repr(errordict)
+    return result

=== modified file 'ubuntu_sso/qt/common.py'
--- ubuntu_sso/qt/common.py	2011-09-01 11:04:23 +0000
+++ ubuntu_sso/qt/common.py	2012-02-10 11:32:20 +0000
@@ -18,20 +18,18 @@
 """Common functionality used by the UI modules."""
 
 import re
-import gettext
-
-gettext.textdomain('ubuntu-sso-client')
-_ = gettext.gettext
+from ubuntu_sso.utils.ui import (
+    PASSWORD_DIGIT,
+    PASSWORD_LENGTH,
+    PASSWORD_MATCH,
+    PASSWORD_MUST_CONTAIN,
+    PASSWORD_UPPER,
+)
 
 # all the text + styles that are used in the gui
 BAD = u'<img src=":/password_hint_warning.png" /><font> %s </font>'
 GOOD = u'<img src=":/password_hint_ok.png" /><font> %s </font>'
 NORMAL = u'<font> %s </font>'
-PASSWORD_DIGIT = _("At least one number")
-PASSWORD_LENGTH = _("At least 8 characters")
-PASSWORD_MATCH = _("Passwords don't match")
-PASSWORD_MUST_CONTAIN = _("Your password must contain")
-PASSWORD_UPPER = _("At least one uppercase letter")
 
 
 def password_assistance(line_edit, assistance, icon_type=BAD):

=== removed file 'ubuntu_sso/qt/controllers.py'
--- ubuntu_sso/qt/controllers.py	2012-02-06 16:21:12 +0000
+++ ubuntu_sso/qt/controllers.py	1970-01-01 00:00:00 +0000
@@ -1,977 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 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/>.
-"""Controllers with the logic of the UI."""
-
-import collections
-import os
-import StringIO
-import tempfile
-
-# pylint: disable=F0401
-try:
-    from PIL import Image
-except ImportError:
-    import Image
-# pylint: enable=F0401
-
-from PyQt4.QtGui import QMessageBox, QWizard, QPixmap
-from twisted.internet import defer
-
-from ubuntu_sso import main, NO_OP
-from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.utils.ui import (
-    CAPTCHA_LOAD_ERROR,
-    CAPTCHA_REQUIRED_ERROR,
-    CAPTCHA_SOLUTION_ENTRY,
-    EMAIL1_ENTRY,
-    EMAIL2_ENTRY,
-    EMAIL_LABEL,
-    EMAIL_INVALID,
-    EMAIL_MISMATCH,
-    ERROR,
-    EXISTING_ACCOUNT_CHOICE_BUTTON,
-    FORGOTTEN_PASSWORD_BUTTON,
-    is_min_required_password,
-    is_correct_email,
-    JOIN_HEADER_LABEL,
-    LOGIN_PASSWORD_LABEL,
-    NAME_ENTRY,
-    NAME_INVALID,
-    PASSWORD1_ENTRY,
-    PASSWORD2_ENTRY,
-    PASSWORD_HELP,
-    PASSWORD_MISMATCH,
-    PASSWORD_TOO_WEAK,
-    REQUEST_PASSWORD_TOKEN_LABEL,
-    RESET_PASSWORD,
-    REQUEST_PASSWORD_TOKEN_WRONG_EMAIL,
-    REQUEST_PASSWORD_TOKEN_TECH_ERROR,
-    SET_UP_ACCOUNT_CHOICE_BUTTON,
-    SIGN_IN_BUTTON,
-    TRY_AGAIN_BUTTON,
-    VERIFY_EMAIL_TITLE,
-    VERIFY_EMAIL_CONTENT,
-)
-
-
-ERROR_ALL = '__all__'
-ERROR_EMAIL = 'email'
-ERROR_EMAIL_TOKEN = 'email_token'
-ERROR_MESSAGE = 'message'
-ERROR_PASSWORD = 'password'
-logger = setup_logging('ubuntu_sso.controllers')
-
-
-# Based on the gtk implementation
-def _build_general_error_message(errordict):
-    """Build a user-friendly error message from the errordict."""
-    result = ''
-    if isinstance(errordict, collections.Mapping):
-        msg1 = errordict.get(ERROR_ALL)
-        msg2 = errordict.get(ERROR_MESSAGE)
-        if msg2 is None:
-            # See the errordict in LP: 828417
-            msg2 = errordict.get('error_message')
-        if msg1 is not None and msg2 is not None:
-            result = '\n'.join((msg1, msg2))
-        elif msg1 is not None:
-            result = msg1
-        elif msg2 is not None:
-            result = msg2
-        else:
-            if 'errtype' in errordict:
-                del errordict['errtype']
-            result = '\n'.join(
-                [('%s: %s' % (k, v)) for k, v in errordict.iteritems()])
-    else:
-        result = repr(errordict)
-    return result
-
-
-class BackendController(object):
-    """Represent a controller that talks with the sso self.backend."""
-
-    def __init__(self, title='', subtitle=''):
-        """Create a new instance."""
-        self.view = None
-        self.backend = None
-        self._title = title
-        self._subtitle = subtitle
-
-    @defer.inlineCallbacks
-    def get_backend(self):
-        """Return the backend used by the controller."""
-        if self.backend is None:
-            client = yield main.get_sso_client()
-            self.backend = client.sso_login
-        defer.returnValue(self.backend)
-
-    #pylint: disable=C0103
-    def pageInitialized(self):
-        """Call to prepare the page just before it is shown."""
-    #pylint: enable=C0103
-
-
-class ChooseSignInController(BackendController):
-    """Controlled to the ChooseSignIn view/widget."""
-
-    def __init__(self, title='', subtitle=''):
-        """Create a new instance to manage the view."""
-        super(ChooseSignInController, self).__init__(title, subtitle)
-        self.view = None
-
-    # use an ugly name just so have a simlar api as found in PyQt
-    # pylint: disable=C0103
-    def setupUi(self, view):
-        """Perform the required actions to set up the ui."""
-        self.view = view
-        self._set_up_translated_strings()
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-        self._connect_buttons()
-    # pylint: enable=C0103
-
-    def _set_up_translated_strings(self):
-        """Set the correct strings for the UI."""
-        logger.debug('ChooseSignInController._set_up_translated_strings')
-        self.view.ui.existing_account_button.setText(
-                                        EXISTING_ACCOUNT_CHOICE_BUTTON)
-        self.view.ui.setup_account_button.setText(
-                                        SET_UP_ACCOUNT_CHOICE_BUTTON)
-
-    def _connect_buttons(self):
-        """Connect the buttons to the actions to perform."""
-        logger.debug('ChooseSignInController._connect_buttons')
-        self.view.ui.existing_account_button.clicked.connect(
-                                                    self._set_next_existing)
-        self.view.ui.setup_account_button.clicked.connect(self._set_next_new)
-
-    def _set_next_existing(self):
-        """Set the next id and fire signal."""
-        logger.debug('ChooseSignInController._set_next_existing')
-        self.view.next = self.view.wizard().current_user_page_id
-        self.view.wizard().next()
-
-    def _set_next_new(self):
-        """Set the next id and fire signal."""
-        logger.debug('ChooseSignInController._set_next_new')
-        self.view.next = self.view.wizard().setup_account_page_id
-        self.view.wizard().next()
-
-
-class CurrentUserController(BackendController):
-    """Controller used in the view that is used to allow the signin."""
-
-    def __init__(self, backend=None, title='', subtitle='', message_box=None):
-        """Create a new instance."""
-        super(CurrentUserController, self).__init__(title, subtitle)
-        if message_box is None:
-            message_box = QMessageBox
-        self.message_box = message_box
-
-    def _set_translated_strings(self):
-        """Set the translated strings."""
-        logger.debug('CurrentUserController._set_translated_strings')
-        self.view.ui.email_label.setText(EMAIL_LABEL)
-        self.view.ui.password_label.setText(LOGIN_PASSWORD_LABEL)
-        self.view.ui.forgot_password_label.setText(FORGOTTEN_PASSWORD_BUTTON)
-        self.view.ui.sign_in_button.setText(SIGN_IN_BUTTON)
-
-    def _connect_ui(self):
-        """Connect the buttons to perform actions."""
-        logger.debug('CurrentUserController._connect_buttons')
-        self.view.ui.sign_in_button.clicked.connect(self.login)
-        # lets add call backs to be execute for the calls we are interested
-        self.backend.on_login_error_cb = lambda app, error:\
-                                                    self.on_login_error(error)
-        self.backend.on_logged_in_cb = self.on_logged_in
-        self.view.ui.forgot_password_label.linkActivated.connect(
-                                                    self.on_forgotten_password)
-        self.view.ui.email_edit.textChanged.connect(self._validate)
-        self.view.ui.password_edit.textChanged.connect(self._validate)
-
-    def _validate(self):
-        """Perform input validation."""
-        valid = True
-        if not is_correct_email(unicode(self.view.ui.email_edit.text())) or \
-            not unicode(self.view.ui.password_edit.text()):
-            valid = False
-        self.view.ui.sign_in_button.setEnabled(valid)
-        self.view.ui.sign_in_button.setProperty("DisabledState",
-            not self.view.ui.sign_in_button.isEnabled())
-        self.view.ui.sign_in_button.style().unpolish(
-            self.view.ui.sign_in_button)
-        self.view.ui.sign_in_button.style().polish(
-            self.view.ui.sign_in_button)
-
-    def login(self):
-        """Perform the login using the self.backend."""
-        logger.debug('CurrentUserController.login')
-        # grab the data from the view and call the backend
-        email = unicode(self.view.ui.email_edit.text())
-        password = unicode(self.view.ui.password_edit.text())
-        d = self.backend.login(self.view.wizard().app_name, email, password)
-        d.addErrback(self.on_login_error)
-
-    def on_login_error(self, error):
-        """There was an error when login in."""
-        # let the user know
-        logger.error('Got error when login %s, error: %s',
-                     self.view.wizard().app_name, error)
-        if isinstance(error, collections.Mapping) and \
-        error.get('errtype', None) == 'UserNotValidated':
-            self.view.setField('email_address', self.view.ui.email_edit.text())
-            self.view.setField('password', self.view.ui.password_edit.text())
-            app_name = self.view.wizard().app_name
-            self.view.wizard().registrationIncomplete.emit(
-                app_name, error['message'])
-        else:
-            self.message_box.critical(_build_general_error_message(error),
-                self.view)
-
-    def on_logged_in(self, app_name, result):
-        """We managed to log in."""
-        logger.info('Logged in for %s', app_name)
-        email = unicode(self.view.ui.email_edit.text())
-        self.view.wizard().loginSuccess.emit(app_name, email)
-        logger.debug('Wizard.loginSuccess emitted.')
-
-    def on_forgotten_password(self):
-        """Show the user the forgotten password page."""
-        logger.info('Forgotten password')
-        email = unicode(self.view.ui.email_edit.text())
-        self.view.wizard().forgotten.ui.email_line_edit.setText(email)
-        self.view.next = self.view.wizard().forgotten_password_page_id
-        self.view.wizard().next()
-
-    # use an ugly name just so have a simlar api as found in PyQt
-    #pylint: disable=C0103
-    @defer.inlineCallbacks
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.backend = yield self.get_backend()
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-        self._set_translated_strings()
-        self._connect_ui()
-    #pylint: enable=C0103
-
-
-class SetUpAccountController(BackendController):
-    """Controller for the setup account view."""
-
-    def __init__(self, message_box=None, title='', subtitle=''):
-        """Create a new instance."""
-        super(SetUpAccountController, self).__init__(title, subtitle)
-        if message_box is None:
-            message_box = QMessageBox
-        self.message_box = message_box
-
-    def _set_translated_strings(self):
-        """Set the different gettext translated strings."""
-        logger.debug('SetUpAccountController._set_translated_strings')
-        # set the translated string
-        self.view.ui.name_label.setText(NAME_ENTRY)
-        self.view.ui.email_label.setText(EMAIL1_ENTRY)
-        self.view.ui.confirm_email_label.setText(EMAIL2_ENTRY)
-        self.view.ui.password_label.setText(PASSWORD1_ENTRY)
-        self.view.ui.confirm_password_label.setText(PASSWORD2_ENTRY)
-        self.view.ui.password_info_label.setText(PASSWORD_HELP)
-        self.view.ui.captcha_solution_edit.setPlaceholderText(
-                                                      CAPTCHA_SOLUTION_ENTRY)
-
-    def _set_line_edits_validations(self):
-        """Set the validations to be performed on the edits."""
-        logger.debug('SetUpAccountController._set_line_edits_validations')
-        self.view.set_line_edit_validation_rule(self.view.ui.email_edit,
-                                                is_correct_email)
-        # set the validation rule for the email confirmation
-        self.view.set_line_edit_validation_rule(
-                                            self.view.ui.confirm_email_edit,
-                                            self.is_correct_email_confirmation)
-        # connect the changed text of the password to trigger a changed text
-        # in the confirm so that the validation is redone
-        self.view.ui.email_edit.textChanged.connect(
-                            self.view.ui.confirm_email_edit.textChanged.emit)
-        self.view.set_line_edit_validation_rule(self.view.ui.password_edit,
-                                                is_min_required_password)
-        self.view.set_line_edit_validation_rule(
-                                        self.view.ui.confirm_password_edit,
-                                        self.is_correct_password_confirmation)
-        # same as the above case, lets connect a signal to a signal
-        self.view.ui.password_edit.textChanged.connect(
-                        self.view.ui.confirm_password_edit.textChanged.emit)
-
-    def _connect_ui_elements(self):
-        """Set the connection of signals."""
-        logger.debug('SetUpAccountController._connect_ui_elements')
-        self.view.ui.refresh_label.linkActivated.connect(lambda url: \
-                                          self._refresh_captcha())
-        # set the callbacks for the captcha generation
-        self.backend.on_captcha_generated_cb = self.on_captcha_generated
-        self.backend.on_captcha_generation_error_cb = lambda app, error: \
-                            self.on_captcha_generation_error(error)
-        self.backend.on_user_registered_cb = self.on_user_registered
-        self.backend.on_user_registration_error_cb = \
-                                            self.on_user_registration_error
-        # We need to check if we enable the button on many signals
-        self.view.ui.name_edit.textEdited.connect(self._enable_setup_button)
-        self.view.ui.email_edit.textEdited.connect(self._enable_setup_button)
-        self.view.ui.confirm_email_edit.textEdited.connect(
-            self._enable_setup_button)
-        self.view.ui.password_edit.textEdited.connect(
-            self._enable_setup_button)
-        self.view.ui.confirm_password_edit.textEdited.connect(
-            self._enable_setup_button)
-        self.view.ui.captcha_solution_edit.textEdited.connect(
-            self._enable_setup_button)
-        self.view.terms_checkbox.stateChanged.connect(
-            self._enable_setup_button)
-
-    def _enable_setup_button(self):
-        """Only enable the setup button if the form is valid."""
-        name = unicode(self.view.ui.name_edit.text()).strip()
-        email = unicode(self.view.ui.email_edit.text())
-        confirm_email = unicode(self.view.ui.confirm_email_edit.text())
-        password = unicode(self.view.ui.password_edit.text())
-        confirm_password = unicode(self.view.ui.confirm_password_edit.text())
-        captcha_solution = unicode(self.view.ui.captcha_solution_edit.text())
-
-        # Check for len(name) > 0 to ensure that a bool is assigned to enabled
-        enabled = self.view.terms_checkbox.isChecked() and \
-          len(captcha_solution) > 0 and \
-          is_min_required_password(password) and \
-          password == confirm_password and is_correct_email(email) and \
-          email == confirm_email and len(name) > 0
-
-        self.view.set_up_button.setEnabled(enabled)
-        self.view.set_up_button.setProperty("DisabledState", not enabled)
-        self.view.set_up_button.style().unpolish(self.view.set_up_button)
-        self.view.set_up_button.style().polish(self.view.set_up_button)
-
-    def _refresh_captcha(self):
-        """Refresh the captcha image shown in the ui."""
-        logger.debug('SetUpAccountController._refresh_captcha')
-        # lets clean behind us, do we have the old file arround?
-        old_file = None
-        if self.view.captcha_file and os.path.exists(self.view.captcha_file):
-            old_file = self.view.captcha_file
-        fd = tempfile.TemporaryFile(mode='r')
-        file_name = fd.name
-        self.view.captcha_file = file_name
-        d = self.backend.generate_captcha(self.view.wizard().app_name,
-                                          file_name)
-        if old_file:
-            d.addCallback(lambda x: os.unlink(old_file))
-        d.addErrback(self.on_captcha_generation_error)
-        self.view.on_captcha_refreshing()
-
-    def _set_titles(self):
-        """Set the diff titles of the view."""
-        logger.debug('SetUpAccountController._set_titles')
-        self.view.header.set_title(
-            JOIN_HEADER_LABEL % {'app_name': self.view.wizard().app_name})
-        self.view.header.set_subtitle(self.view.wizard().help_text)
-
-    def _register_fields(self):
-        """Register the diff fields of the Ui."""
-        self.view.registerField('email_address', self.view.ui.email_edit)
-        self.view.registerField('password', self.view.ui.password_edit)
-
-    def on_captcha_generated(self, app_name, result):
-        """A new image was generated."""
-        logger.debug('SetUpAccountController.on_captcha_generated for %r '
-                     '(captcha id %r, filename %r).',
-                     app_name, result, self.view.captcha_file)
-        self.view.captcha_id = result
-        # HACK: First, let me apologize before hand, you can mention my mother
-        # if needed I would do the same (mandel)
-        # In an ideal world we could use the Qt plug-in for the images so that
-        # we could load jpgs etc.. but this won't work when the app has been
-        # brozen win py2exe using bundle_files=1
-        # The main issue is that Qt will complain about the thread not being
-        # the correct one when performing a moveToThread operation which is
-        # done either by a setParent or something within the qtreactor, PIL
-        # in this case does solve the issue. Sorry :(
-        pil_image = Image.open(self.view.captcha_file)
-        string_io = StringIO.StringIO()
-        pil_image.save(string_io, format='png')
-        pixmap_image = QPixmap()
-        pixmap_image.loadFromData(string_io.getvalue())
-        self.view.captcha_image = pixmap_image
-        self.view.on_captcha_refresh_complete()
-
-    def on_captcha_generation_error(self, error):
-        """An error ocurred."""
-        logger.debug('SetUpAccountController.on_captcha_generation_error')
-        self.message_box.critical(CAPTCHA_LOAD_ERROR, self.view)
-        self.view.on_captcha_refresh_complete()
-
-    def on_user_registration_error(self, app_name, error):
-        """Let the user know we could not register."""
-        logger.debug('SetUpAccountController.on_user_registration_error')
-        # errors are returned as a dict with the data we want to show.
-        self._refresh_captcha()
-        msg = error.pop(ERROR_EMAIL, None)
-        if msg:
-            self.view.set_error_message(self.view.ui.email_assistance, msg)
-        self.message_box.critical(_build_general_error_message(error),
-            self.view)
-
-    def on_user_registered(self, app_name, result):
-        """Execute when the user did register."""
-        logger.debug('SetUpAccountController.on_user_registered')
-        self.view.next = self.view.wizard().email_verification_page_id
-        self.view.wizard().next()
-
-    def validate_form(self):
-        """Validate the info of the form and return an error."""
-        logger.debug('SetUpAccountController.validate_form')
-        name = unicode(self.view.ui.name_edit.text()).strip()
-        email = unicode(self.view.ui.email_edit.text())
-        confirm_email = unicode(self.view.ui.confirm_email_edit.text())
-        password = unicode(self.view.ui.password_edit.text())
-        confirm_password = unicode(self.view.ui.confirm_password_edit.text())
-        captcha_solution = unicode(self.view.ui.captcha_solution_edit.text())
-        condition = True
-        messages = []
-        if not name:
-            condition = False
-            self.view.set_error_message(self.view.ui.name_assistance,
-                NAME_INVALID)
-        if not is_correct_email(email):
-            condition = False
-            self.view.set_error_message(self.view.ui.email_assistance,
-                EMAIL_INVALID)
-        if email != confirm_email:
-            condition = False
-            self.view.set_error_message(self.view.ui.confirm_email_assistance,
-                EMAIL_MISMATCH)
-        if not is_min_required_password(password):
-            messages.append(PASSWORD_TOO_WEAK)
-        if password != confirm_password:
-            messages.append(PASSWORD_MISMATCH)
-        if not captcha_solution:
-            messages.append(CAPTCHA_REQUIRED_ERROR)
-        if len(messages) > 0:
-            condition = False
-            self.message_box.critical('\n'.join(messages), self.view)
-        return condition
-
-    def set_next_validation(self):
-        """Set the validation as the next page."""
-        logger.debug('SetUpAccountController.set_next_validation')
-        email = unicode(self.view.ui.email_edit.text())
-        password = unicode(self.view.ui.password_edit.text())
-        name = unicode(self.view.ui.name_edit.text())
-        captcha_id = self.view.captcha_id
-        captcha_solution = unicode(self.view.ui.captcha_solution_edit.text())
-        # validate the current info of the form, try to perform the action
-        # to register the user, and then move foward
-        if self.validate_form():
-            self.backend.register_user(self.view.wizard().app_name, email,
-                                       password, name, captcha_id,
-                                       captcha_solution)
-        # Update validation page's title, which contains the email
-        p_id = self.view.wizard().email_verification_page_id
-        self.view.wizard().page(p_id).controller.set_titles()
-
-    def is_correct_email(self, email_address):
-        """Return if the email is correct."""
-        logger.debug('SetUpAccountController.is_correct_email')
-        return '@' in email_address
-
-    def is_correct_email_confirmation(self, email_address):
-        """Return that the email is the same."""
-        logger.debug('SetUpAccountController.is_correct_email_confirmation')
-        return unicode(self.view.ui.email_edit.text()) == email_address
-
-    def is_correct_password_confirmation(self, password):
-        """Return that the passwords are correct."""
-        logger.debug('SetUpAccountController.is_correct_password_confirmation')
-        return unicode(self.view.ui.password_edit.text()) == password
-
-    #pylint: disable=C0103
-    @defer.inlineCallbacks
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        # request the backend to be used with the ui
-        self.backend = yield self.get_backend()
-        self._connect_ui_elements()
-        self._refresh_captcha()
-        self._set_titles()
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-        self._set_translated_strings()
-        self._set_line_edits_validations()
-        self._register_fields()
-    #pylint: enable=C0103
-
-
-class EmailVerificationController(BackendController):
-    """Controller used for the verification page."""
-
-    def __init__(self, message_box=None, title='', subtitle=''):
-        """Create a new instance."""
-        super(EmailVerificationController, self).__init__(title, subtitle)
-        if message_box is None:
-            message_box = QMessageBox
-        self.message_box = message_box
-
-    def _set_translated_strings(self):
-        """Set the trnaslated strings."""
-        logger.debug('EmailVerificationController._set_translated_strings')
-
-    def _connect_ui_elements(self):
-        """Set the connection of signals."""
-        logger.debug('EmailVerificationController._connect_ui_elements')
-        self.view.ui.verification_code_edit.textChanged.connect(
-            self.validate_form)
-        self.view.next_button.clicked.connect(self.validate_email)
-        self.backend.on_email_validated_cb = lambda app, result: \
-                            self.on_email_validated(app)
-        self.backend.on_email_validation_error_cb = \
-                                                self.on_email_validation_error
-
-    def validate_form(self):
-        """Check the state of the form."""
-        code = self.view.verification_code.strip()
-        enabled = len(code) > 0
-        self.view.next_button.setEnabled(enabled)
-        self.view.next_button.setProperty('DisabledState',
-            not self.view.next_button.isEnabled())
-        self.view.next_button.style().unpolish(
-            self.view.next_button)
-        self.view.next_button.style().polish(
-            self.view.next_button)
-
-    def _set_titles(self):
-        """Set the different titles."""
-        logger.debug('EmailVerificationController._set_titles')
-        self.view.header.set_title(VERIFY_EMAIL_TITLE)
-        self.view.header.set_subtitle(VERIFY_EMAIL_CONTENT % {
-            "app_name": self.view.wizard().app_name,
-            "email": self.view.wizard().field("email_address").toString(),
-        })
-
-    def set_titles(self):
-        """This class needs to have a public set_titles.
-
-        Since the subtitle contains data that is only known after SetupAccount
-        and _set_titles is only called on initialization.
-        """
-        self._set_titles()
-
-    #pylint: disable=C0103
-    @defer.inlineCallbacks
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.backend = yield self.get_backend()
-        self._set_titles()
-        self._set_translated_strings()
-        self._connect_ui_elements()
-    #pylint: enable=C0103
-
-    def validate_email(self):
-        """Call the next action."""
-        logger.debug('EmailVerificationController.validate_email')
-        email = unicode(self.view.wizard().field('email_address').toString())
-        password = unicode(self.view.wizard().field('password').toString())
-        code = unicode(self.view.ui.verification_code_edit.text())
-        self.backend.validate_email(self.view.wizard().app_name, email,
-                                    password, code)
-
-    def on_email_validated(self, app_name):
-        """Signal thrown after the email is validated."""
-        logger.info('EmailVerificationController.on_email_validated')
-        email = self.view.wizard().field('email_address').toString()
-        self.view.wizard().registrationSuccess.emit(app_name, email)
-
-    def on_email_validation_error(self, app_name, error):
-        """Signal thrown when there's a problem validating the email."""
-        msg = error.pop(ERROR_EMAIL_TOKEN, '')
-        msg += _build_general_error_message(error)
-        self.message_box.critical(msg, self.view)
-
-    #pylint: disable=C0103
-    def pageInitialized(self):
-        """Called to prepare the page just before it is shown."""
-        self.view.next_button.setDefault(True)
-        self.view.next_button.setEnabled(False)
-        self.view.next_button.setProperty('DisabledState',
-            not self.view.next_button.isEnabled())
-        self.view.next_button.style().unpolish(
-            self.view.next_button)
-        self.view.next_button.style().polish(
-            self.view.next_button)
-    #pylint: enable=C0103
-
-
-class ErrorController(BackendController):
-    """Controller used for the error page."""
-
-    def __init__(self, title='', subtitle=''):
-        """Create a new instance."""
-        super(ErrorController, self).__init__(title, subtitle)
-        self.view = None
-
-    #pylint: disable=C0103
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.view.next = -1
-        self.view.ui.error_message_label.setText(ERROR)
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-    #pylint: enable=C0103
-
-
-class ForgottenPasswordController(BackendController):
-    """Controller used to deal with the forgotten pwd page."""
-
-    def __init__(self, message_box=None, title='', subtitle=''):
-        """Create a new instance."""
-        super(ForgottenPasswordController, self).__init__()
-        if message_box is None:
-            message_box = QMessageBox
-        self.message_box = message_box
-        super(ForgottenPasswordController, self).__init__(title, subtitle)
-
-    #pylint: disable=C0103
-    def pageInitialized(self):
-        """Set the initial state of ForgottenPassword page."""
-        self.view.send_button.setDefault(True)
-        enabled = not self.view.ui.email_line_edit.text().isEmpty()
-        self.view.send_button.setEnabled(enabled)
-        # The style from this property come from the Wizard
-        self.view.send_button.setProperty("DisabledState",
-            not self.view.send_button.isEnabled())
-        self.view.send_button.style().unpolish(
-            self.view.send_button)
-        self.view.send_button.style().polish(
-            self.view.send_button)
-    #pylint: enable=C0103
-
-    def _register_fields(self):
-        """Register the fields of the wizard page."""
-        self.view.registerField('email_address',
-                                self.view.email_address_line_edit)
-
-    def _set_translated_strings(self):
-        """Set the translated strings in the view."""
-        self.view.forgotted_password_intro_label.setText(
-                                    REQUEST_PASSWORD_TOKEN_LABEL % {'app_name':
-                                    self.view.wizard().app_name})
-        self.view.email_address_label.setText(EMAIL_LABEL)
-        self.view.send_button.setText(RESET_PASSWORD)
-        self.view.try_again_button.setText(TRY_AGAIN_BUTTON)
-
-    def _set_enhanced_line_edit(self):
-        """Set the extra logic to the line edits."""
-        self.view.set_line_edit_validation_rule(
-                                           self.view.email_address_line_edit,
-                                           is_correct_email)
-
-    def _connect_ui(self):
-        """Connect the diff signals from the Ui."""
-        self.view.email_address_line_edit.textChanged.connect(self._validate)
-        self.view.send_button.clicked.connect(
-                            lambda: self.backend.request_password_reset_token(
-                                                self.view.wizard().app_name,
-                                                self.view.email_address))
-        self.view.try_again_button.clicked.connect(self.on_try_again)
-        # set the backend callbacks to be used
-        self.backend.on_password_reset_token_sent_cb = lambda app, result:\
-                                    self.on_password_reset_token_sent()
-        self.backend.on_password_reset_error_cb = self.on_password_reset_error
-
-    def _validate(self):
-        """Validate that we have an email."""
-        email = unicode(self.view.email_address_line_edit.text())
-        self.view.send_button.setEnabled(is_correct_email(email))
-        self.view.send_button.setProperty("DisabledState",
-            not self.view.send_button.isEnabled())
-        self.view.send_button.style().unpolish(
-            self.view.send_button)
-        self.view.send_button.style().polish(
-            self.view.send_button)
-
-    def on_try_again(self):
-        """Set back the widget to the initial state."""
-        self.view.try_again_widget.setVisible(False)
-        self.view.email_widget.setVisible(True)
-
-    def on_password_reset_token_sent(self):
-        """Action taken when we managed to get the password reset done."""
-        # ignore the result and move to the reset page
-        self.view.next = self.view.wizard().reset_password_page_id
-        self.view.wizard().next()
-
-    def on_password_reset_error(self, app_name, error):
-        """Action taken when there was an error requesting the reset."""
-        # set the error message
-        msg = REQUEST_PASSWORD_TOKEN_TECH_ERROR
-        if error['errtype'] == 'ResetPasswordTokenError':
-            # the account provided is wrong, lets tell the user to try
-            # again
-            msg = REQUEST_PASSWORD_TOKEN_WRONG_EMAIL
-        else:
-            # ouch, I dont know what went wrong, tell the user to try later
-            self.view.email_widget.setVisible(False)
-            self.view.forgotted_password_intro_label.setVisible(False)
-            self.view.try_again_widget.setVisible(True)
-        self.message_box.critical(msg, self.view)
-
-    #pylint: disable=C0103
-    @defer.inlineCallbacks
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.backend = yield self.get_backend()
-        # hide the error label
-        self.view.try_again_widget.setVisible(False)
-        self._set_translated_strings()
-        self._connect_ui()
-        self._set_enhanced_line_edit()
-        self._register_fields()
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-    #pylint: enable=C0103
-
-
-class ResetPasswordController(BackendController):
-    """Controller used to deal with reseintg the password."""
-
-    def __init__(self, title='', subtitle='', message_box=None):
-        """Create a new instance."""
-        if message_box is None:
-            message_box = QMessageBox
-        self.message_box = message_box
-        super(ResetPasswordController, self).__init__(title, subtitle)
-
-    #pylint: disable=C0103
-    def pageInitialized(self):
-        """Set the initial state of ForgottenPassword page."""
-        self.view.ui.reset_password_button.setDefault(True)
-        self.view.ui.reset_password_button.setEnabled(False)
-        # The style from this property come from the Wizard
-        self.view.ui.reset_password_button.setProperty("DisabledState",
-            not self.view.ui.reset_password_button.isEnabled())
-        self.view.ui.reset_password_button.style().unpolish(
-            self.view.ui.reset_password_button)
-        self.view.ui.reset_password_button.style().polish(
-            self.view.ui.reset_password_button)
-    #pylint: enable=C0103
-
-    def _set_translated_strings(self):
-        """Translate the diff strings used in the app."""
-        self.view.ui.reset_password_button.setText(RESET_PASSWORD)
-        self.view.setSubTitle(PASSWORD_HELP)
-
-    def _connect_ui(self):
-        """Connect the different ui signals."""
-        self.view.ui.reset_password_button.clicked.connect(
-                                                    self.set_new_password)
-        self.backend.on_password_changed_cb = self.on_password_changed
-        self.backend.on_password_change_error_cb = \
-                                                self.on_password_change_error
-        self.view.ui.reset_code_line_edit.textChanged.connect(self._validate)
-        self.view.ui.password_line_edit.textChanged.connect(self._validate)
-        self.view.ui.confirm_password_line_edit.textChanged.connect(
-            self._validate)
-
-    def _validate(self):
-        """Enable the submit button if data is valid."""
-        enabled = True
-        code = unicode(self.view.ui.reset_code_line_edit.text())
-        password = unicode(self.view.ui.password_line_edit.text())
-        confirm_password = unicode(
-            self.view.ui.confirm_password_line_edit.text())
-        if not is_min_required_password(password):
-            enabled = False
-        elif not self.is_correct_password_confirmation(confirm_password):
-            enabled = False
-        elif not code:
-            enabled = False
-        self.view.ui.reset_password_button.setEnabled(enabled)
-        self.view.ui.reset_password_button.setProperty("DisabledState",
-            not self.view.ui.reset_password_button.isEnabled())
-        self.view.ui.reset_password_button.style().unpolish(
-            self.view.ui.reset_password_button)
-        self.view.ui.reset_password_button.style().polish(
-            self.view.ui.reset_password_button)
-
-    def _add_line_edits_validations(self):
-        """Add the validations to be use by the line edits."""
-        self.view.set_line_edit_validation_rule(
-                                           self.view.ui.password_line_edit,
-                                           is_min_required_password)
-        self.view.set_line_edit_validation_rule(
-                                    self.view.ui.confirm_password_line_edit,
-                                    self.is_correct_password_confirmation)
-        # same as the above case, lets connect a signal to a signal
-        self.view.ui.password_line_edit.textChanged.connect(
-                     self.view.ui.confirm_password_line_edit.textChanged.emit)
-
-    def on_password_changed(self, app_name, result):
-        """Let user know that the password was changed."""
-        email = unicode(self.view.wizard().forgotten.ui.email_line_edit.text())
-        self.view.wizard().current_user.ui.email_edit.setText(email)
-        self.view.wizard().overlay.hide()
-        current_user_id = self.view.wizard().current_user_page_id
-        visited_pages = self.view.wizard().visitedPages()
-        for index in reversed(visited_pages):
-            if index == current_user_id:
-                break
-            self.view.wizard().back()
-
-    def on_password_change_error(self, app_name, error):
-        """Let the user know that there was an error."""
-        logger.error('Got error changing password for %s, error: %s',
-                     self.view.wizard().app_name, error)
-        self.message_box.critical(_build_general_error_message(error),
-            self.view)
-
-    def set_new_password(self):
-        """Request a new password to be set."""
-        app_name = self.view.wizard().app_name
-        email = unicode(self.view.wizard().forgotten.ui.email_line_edit.text())
-        code = unicode(self.view.ui.reset_code_line_edit.text())
-        password = unicode(self.view.ui.password_line_edit.text())
-        logger.info('Setting new password for %r and email %r with code %r',
-                    app_name, email, code)
-        self.backend.set_new_password(app_name, email, code, password)
-
-    def is_correct_password_confirmation(self, password):
-        """Return if the password is correct."""
-        return unicode(self.view.ui.password_line_edit.text()) == password
-
-    #pylint: disable=C0103
-    @defer.inlineCallbacks
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.backend = yield self.get_backend()
-        self._set_translated_strings()
-        self._connect_ui()
-        self._add_line_edits_validations()
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-    #pylint: enable=C0103
-
-
-class SuccessController(BackendController):
-    """Controller used for the success page."""
-
-    def __init__(self, title='', subtitle=''):
-        """Create a new instance."""
-        super(SuccessController, self).__init__(title, subtitle)
-        self.view = None
-
-    #pylint: disable=C0103
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.view.next = -1
-        self.view.header.set_title(self._title)
-        self.view.header.set_subtitle(self._subtitle)
-    #pylint: enable=C0103
-
-
-class UbuntuSSOWizardController(object):
-    """Controller used for the overall wizard."""
-
-    def __init__(self, login_success_callback=NO_OP,
-                 registration_success_callback=NO_OP,
-                 user_cancellation_callback=NO_OP):
-        """Create a new instance."""
-        self.view = None
-        self.login_success_callback = login_success_callback
-        self.registration_success_callback = registration_success_callback
-        self.user_cancellation_callback = user_cancellation_callback
-
-    def on_user_cancelation(self):
-        """Process the cancel action."""
-        logger.debug('UbuntuSSOWizardController.on_user_cancelation')
-        self.user_cancellation_callback(self.view.app_name)
-        self.view.close()
-
-    @defer.inlineCallbacks
-    def on_login_success(self, app_name, email):
-        """Process the success of a login."""
-        logger.debug('UbuntuSSOWizardController.on_login_success')
-        result = yield self.login_success_callback(
-            unicode(app_name), unicode(email))
-        logger.debug('Result from callback is %s', result)
-        if result == 0:
-            logger.info('Success in calling the given success_callback')
-            self.show_success_message()
-        else:
-            logger.info('Error in calling the given success_callback')
-            self.show_error_message()
-
-    @defer.inlineCallbacks
-    def on_registration_success(self, app_name, email):
-        """Process the success of a registration."""
-        logger.debug('UbuntuSSOWizardController.on_registration_success')
-        result = yield self.registration_success_callback(unicode(app_name),
-                                                          unicode(email))
-        logger.debug('Result from callback is %s', result)
-        if result == 0:
-            logger.info('Success in calling the given registration_callback')
-            self.show_success_message()
-        else:
-            logger.info('Success in calling the given registration_callback')
-            self.show_error_message()
-
-    def show_success_message(self):
-        """Show the success message in the view."""
-        logger.info('Showing success message.')
-        # get the id of the success page, set it as the next id of the
-        # current page and let the wizard move to the next step
-        self.view.currentPage().next = self.view.success_page_id
-        self.view.next()
-        # show the finish button but with a close message
-        buttons_layout = []
-        buttons_layout.append(QWizard.Stretch)
-        buttons_layout.append(QWizard.FinishButton)
-        self.view.setButtonLayout(buttons_layout)
-
-    def show_error_message(self):
-        """Show the error page in the view."""
-        logger.info('Showing error message.')
-        # similar to the success page but using the error id
-        self.view.currentPage().next = self.view.error_page_id
-        self.view.next()
-        # show the finish button but with a close message
-        buttons_layout = []
-        buttons_layout.append(QWizard.Stretch)
-        buttons_layout.append(QWizard.FinishButton)
-        self.view.setButtonLayout(buttons_layout)
-
-    #pylint: disable=C0103
-    def setupUi(self, view):
-        """Setup the view."""
-        self.view = view
-        self.view.setWizardStyle(QWizard.ModernStyle)
-        self.view.button(QWizard.CancelButton).clicked.connect(
-                                                    self.on_user_cancelation)
-        self.view.loginSuccess.connect(self.on_login_success)
-        self.view.registrationSuccess.connect(self.on_registration_success)
-    #pylint: enable=C0103

=== modified file 'ubuntu_sso/qt/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-02 13:40:36 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-10 11:32:20 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-
+#
 # Copyright 2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -19,16 +19,58 @@
 import gettext
 
 from PyQt4 import QtGui
+from twisted.internet import defer
 
+from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt.gui import SSOWizardPage
+from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils.ui import (
+    EMAIL_LABEL,
+    FORGOTTEN_PASSWORD_BUTTON,
+    is_correct_email,
+    LOGIN_PASSWORD_LABEL,
+    SIGN_IN_BUTTON,
+)
 
 
 _ = gettext.gettext
+logger = setup_logging('ubuntu_sso.current_user_sign_in_page')
 
 
 class CurrentUserSignInPage(SSOWizardPage):
     """Wizard Page that lets a current user Sign into Ubuntu One."""
 
+    def __init__(self, ui, *args, **kwargs):
+        super(CurrentUserSignInPage, self).__init__(ui, *args, **kwargs)
+
+        self._signals = {
+            'LoggedIn':
+             self._filter_by_app_name(self.on_logged_in),
+            'LoginError':
+             self._filter_by_app_name(self.on_login_error),
+             'UserNotValidated':
+             self._filter_by_app_name(self.on_user_not_validated),
+         }
+        self.setup_page()
+
+    # pylint: disable=W0212
+    def on_user_not_validated(self, *args):
+        """Show the validate email page."""
+        self.next = self.wizard()._pages[self.wizard().email_verification]
+        email = unicode(self.ui.email_edit.text())
+        self.wizard().page(self.next).set_titles(email)
+        self.wizard().next()
+    # pylint: enable=W0212
+
+    @defer.inlineCallbacks
+    def setup_page(self):
+        """Setup the widget components."""
+        self.backend = yield self.get_backend()
+        self._set_translated_strings()
+        # lets add call backs to be execute for the calls we are interested
+        self._setup_signals()
+        self._connect_ui()
+
     # Invalid names of Qt-inherited methods
     # pylint: disable=C0103
 
@@ -59,3 +101,64 @@
     def cleanupPage(self):
         """Reset the state of the wizard if Verification code was visited."""
         self.wizard()._next_id = None
+
+    def _set_translated_strings(self):
+        """Set the translated strings."""
+        logger.debug('CurrentUserSignInPage._set_translated_strings')
+        self.ui.email_label.setText(EMAIL_LABEL)
+        self.ui.password_label.setText(LOGIN_PASSWORD_LABEL)
+        self.ui.forgot_password_label.setText(FORGOTTEN_PASSWORD_BUTTON)
+        self.ui.sign_in_button.setText(SIGN_IN_BUTTON)
+
+    def _connect_ui(self):
+        """Connect the buttons to perform actions."""
+        logger.debug('CurrentUserSignInPage._connect_buttons')
+        self.ui.forgot_password_label.linkActivated.connect(
+                                                    self.on_forgotten_password)
+        self.ui.email_edit.textChanged.connect(self._validate)
+        self.ui.password_edit.textChanged.connect(self._validate)
+        self.ui.sign_in_button.clicked.connect(self.login)
+
+    def _validate(self):
+        """Perform input validation."""
+        valid = True
+        correct_mail = is_correct_email(unicode(self.ui.email_edit.text()))
+        password = unicode(self.ui.password_edit.text())
+        if not correct_mail or not password:
+            valid = False
+        self.ui.sign_in_button.setEnabled(valid)
+        self.ui.sign_in_button.setProperty("DisabledState",
+            not self.ui.sign_in_button.isEnabled())
+        self.ui.sign_in_button.style().unpolish(self.ui.sign_in_button)
+        self.ui.sign_in_button.style().polish(self.ui.sign_in_button)
+
+    def login(self):
+        """Perform the login using the self.backend."""
+        logger.debug('CurrentUserSignInPage.login')
+        # grab the data from the view and call the backend
+        email = unicode(self.ui.email_edit.text())
+        password = unicode(self.ui.password_edit.text())
+        self.backend.login(self.app_name, email, password)
+
+    def on_login_error(self, app_name, error):
+        """There was an error when login in."""
+        # let the user know
+        logger.error('Got error when login %s, error: %s',
+            self.app_name, error)
+        self.message_box.critical(self, self.app_name,
+            build_general_error_message(error))
+
+    # pylint: disable=W0212
+    def on_logged_in(self, app_name, result):
+        """We managed to log in."""
+        logger.info('Logged in for %s', app_name)
+        self.next = self.wizard()._pages[self.wizard().success]
+        self.wizard().next()
+        logger.debug('Wizard.loginSuccess emitted.')
+
+    def on_forgotten_password(self):
+        """Show the user the forgotten password page."""
+        logger.info('Forgotten password')
+        self.next = self.wizard()._pages[self.wizard().forgotten]
+        self.wizard().next()
+    # pylint: enable=W0212

=== added file 'ubuntu_sso/qt/email_verification_page.py'
--- ubuntu_sso/qt/email_verification_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/email_verification_page.py	2012-02-10 11:32:20 +0000
@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 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/>.
+
+"""Email Verification page UI."""
+
+from twisted.internet import defer
+
+from ubuntu_sso.qt import build_general_error_message
+from ubuntu_sso.qt.gui import SSOWizardPage
+from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils.ui import (
+    VERIFY_EMAIL_TITLE,
+    VERIFY_EMAIL_CONTENT,
+)
+from ubuntu_sso.utils.ui import ERROR_EMAIL_TOKEN
+
+
+logger = setup_logging('ubuntu_sso.email_verification_page')
+
+
+class EmailVerificationPage(SSOWizardPage):
+    """Widget used to input the email verification code."""
+
+    def __init__(self, ui, *args, **kwargs):
+        super(EmailVerificationPage, self).__init__(ui, *args, **kwargs)
+        self.email = ''
+        self._signals = {
+            'EmailValidated':
+             self._filter_by_app_name(self.on_email_validated),
+            'EmailValidationError':
+             self._filter_by_app_name(self.on_email_validation_error),
+        }
+        self.setup_page()
+
+    @defer.inlineCallbacks
+    def setup_page(self):
+        """Setup the ui components."""
+        self.backend = yield self.get_backend()
+        self._setup_signals()
+        self._connect_ui_elements()
+
+    @property
+    def verification_code(self):
+        """Return the content of the verification code edit."""
+        return str(self.ui.verification_code_edit.text())
+
+    @property
+    def next_button(self):
+        """Return the button that move to the next stage."""
+        return self.ui.next_button
+
+    def _connect_ui_elements(self):
+        """Set the connection of signals."""
+        logger.debug('EmailVerificationController._connect_ui_elements')
+        self.ui.verification_code_edit.textChanged.connect(
+            self.validate_form)
+        self.next_button.clicked.connect(self.validate_email)
+
+    def validate_form(self):
+        """Check the state of the form."""
+        code = self.verification_code.strip()
+        enabled = len(code) > 0
+        self.next_button.setEnabled(enabled)
+        self.next_button.setProperty('DisabledState',
+            not self.next_button.isEnabled())
+        self.next_button.style().unpolish(
+            self.next_button)
+        self.next_button.style().polish(
+            self.next_button)
+
+    def _set_titles(self):
+        """Set the different titles."""
+        logger.debug('EmailVerificationController._set_titles')
+        self.header.set_title(VERIFY_EMAIL_TITLE)
+        self.header.set_subtitle(VERIFY_EMAIL_CONTENT % {
+            "app_name": self.app_name,
+            "email": self.email,
+        })
+
+    def set_titles(self, email):
+        """This class needs to have a public set_titles.
+
+        Since the subtitle contains data that is only known after SetupAccount
+        and _set_titles is only called on initialization.
+        """
+        self.email = email
+        self._set_titles()
+
+    def validate_email(self):
+        """Call the next action."""
+        logger.debug('EmailVerificationController.validate_email')
+        email = unicode(self.wizard().field('email_address').toString())
+        password = unicode(self.wizard().field('password').toString())
+        code = unicode(self.ui.verification_code_edit.text())
+        self.backend.validate_email(self.app_name, email,
+                                    password, code)
+
+    def on_email_validated(self, app_name, *args, **kwargs):
+        """Signal thrown after the email is validated."""
+        logger.info('EmailVerificationController.on_email_validated')
+        email = self.wizard().field('email_address').toString()
+        self.wizard().registrationSuccess.emit(app_name, email)
+
+    def on_email_validation_error(self, app_name, error):
+        """Signal thrown when there's a problem validating the email."""
+        msg = error.pop(ERROR_EMAIL_TOKEN, '')
+        msg += build_general_error_message(error)
+        self.message_box.critical(self, self.app_name, msg)
+
+    #pylint: disable=C0103
+    def initializePage(self):
+        """Called to prepare the page just before it is shown."""
+        self.next_button.setDefault(True)
+        self.next_button.setEnabled(False)
+        self.next_button.setProperty('DisabledState',
+            not self.next_button.isEnabled())
+        self.next_button.style().unpolish(self.next_button)
+        self.next_button.style().polish(self.next_button)
+    #pylint: enable=C0103

=== added file 'ubuntu_sso/qt/error_page.py'
--- ubuntu_sso/qt/error_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/error_page.py	2012-02-10 11:32:20 +0000
@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 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/>.
+
+"""Email Verification page UI."""
+
+from ubuntu_sso.qt.gui import SSOWizardPage
+from ubuntu_sso.utils.ui import ERROR
+
+
+class ErrorPage(SSOWizardPage):
+    """Widget used to show the diff errors."""
+
+    def __init__(self, ui, *args, **kwargs):
+        super(ErrorPage, self).__init__(ui, *args, **kwargs)
+        self.next = -1
+        self.ui.error_message_label.setText(ERROR)

=== added file 'ubuntu_sso/qt/forgotten_password_page.py'
--- ubuntu_sso/qt/forgotten_password_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/forgotten_password_page.py	2012-02-10 11:32:20 +0000
@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 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/>.
+
+"""Forgotten Password page UI."""
+
+from twisted.internet import defer
+
+from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
+from ubuntu_sso.utils.ui import (
+    EMAIL_LABEL,
+    is_correct_email,
+    RESET_PASSWORD,
+    REQUEST_PASSWORD_TOKEN_LABEL,
+    REQUEST_PASSWORD_TOKEN_WRONG_EMAIL,
+    REQUEST_PASSWORD_TOKEN_TECH_ERROR,
+    TRY_AGAIN_BUTTON,
+)
+
+
+class ForgottenPasswordPage(SSOWizardEnhancedEditPage):
+    """Widget used to deal with users that forgot the password."""
+
+    def __init__(self, ui, *args, **kwargs):
+        super(ForgottenPasswordPage, self).__init__(ui, *args, **kwargs)
+        self._signals = {
+            'PasswordResetTokenSent':
+             self._filter_by_app_name(self.on_password_reset_token_sent),
+            'PasswordResetError':
+             self._filter_by_app_name(self.on_password_reset_error),
+        }
+        self.setup_page()
+
+    @defer.inlineCallbacks
+    def setup_page(self):
+        """Setup the widget components."""
+        self.backend = yield self.get_backend()
+        self._setup_signals()
+        # hide the error label
+        self.try_again_widget.setVisible(False)
+        self._set_translated_strings()
+        self._connect_ui()
+        self._set_enhanced_line_edit()
+        self._register_fields()
+
+    @property
+    def email_widget(self):
+        """Return the widget used to show the email information."""
+        return self.ui.email_widget
+
+    @property
+    def forgotted_password_intro_label(self):
+        """Return the intro label that lets the user know the issue."""
+        return self.ui.forgotted_password_intro_label
+
+    @property
+    def error_label(self):
+        """Return the label used to show error."""
+        return self.ui.error_label
+
+    @property
+    def email_address_label(self):
+        """Return the lable used to state the use of the line edit."""
+        return self.ui.email_address_label
+
+    @property
+    def email_address(self):
+        """Return the email address provided by the user."""
+        return str(self.ui.email_line_edit.text())
+
+    @property
+    def email_address_line_edit(self):
+        """Return the line edit with the content."""
+        return self.ui.email_line_edit
+
+    @property
+    def send_button(self):
+        """Return the button used to request the new password."""
+        return self.ui.send_button
+
+    @property
+    def try_again_widget(self):
+        """Return the widget used to display the try again button."""
+        return self.ui.try_again_widget
+
+    @property
+    def try_again_button(self):
+        """Return the button used to try again the reset password."""
+        return self.ui.try_again_button
+
+    #pylint: disable=C0103
+    def initializePage(self):
+        """Set the initial state of ForgottenPassword page."""
+        self.send_button.setDefault(True)
+        enabled = not self.ui.email_line_edit.text().isEmpty()
+        self.send_button.setEnabled(enabled)
+        # The style from this property come from the Wizard
+        self.send_button.setProperty("DisabledState",
+            not self.send_button.isEnabled())
+        self.send_button.style().unpolish(self.send_button)
+        self.send_button.style().polish(self.send_button)
+    #pylint: enable=C0103
+
+    def _register_fields(self):
+        """Register the fields of the wizard page."""
+        self.registerField('email_address',
+                                self.email_address_line_edit)
+
+    def _set_translated_strings(self):
+        """Set the translated strings in the view."""
+        self.forgotted_password_intro_label.setText(
+                                    REQUEST_PASSWORD_TOKEN_LABEL % {'app_name':
+                                    self.app_name})
+        self.email_address_label.setText(EMAIL_LABEL)
+        self.send_button.setText(RESET_PASSWORD)
+        self.try_again_button.setText(TRY_AGAIN_BUTTON)
+
+    def _set_enhanced_line_edit(self):
+        """Set the extra logic to the line edits."""
+        self.set_line_edit_validation_rule(
+                                           self.email_address_line_edit,
+                                           is_correct_email)
+
+    def _connect_ui(self):
+        """Connect the diff signals from the Ui."""
+        self.email_address_line_edit.textChanged.connect(self._validate)
+        self.send_button.clicked.connect(
+                            lambda: self.backend.request_password_reset_token(
+                                                self.app_name,
+                                                self.email_address))
+        self.try_again_button.clicked.connect(self.on_try_again)
+
+    def _validate(self):
+        """Validate that we have an email."""
+        email = unicode(self.email_address_line_edit.text())
+        self.send_button.setEnabled(is_correct_email(email))
+        self.send_button.setProperty("DisabledState",
+            not self.send_button.isEnabled())
+        self.send_button.style().unpolish(self.send_button)
+        self.send_button.style().polish(self.send_button)
+
+    def on_try_again(self):
+        """Set back the widget to the initial state."""
+        self.try_again_widget.setVisible(False)
+        self.email_widget.setVisible(True)
+
+    # pylint: disable=W0212
+    def on_password_reset_token_sent(self):
+        """Action taken when we managed to get the password reset done."""
+        # ignore the result and move to the reset page
+        self.next = self.wizard()._pages[self.wizard().reset_password]
+        self.wizard().next()
+    # pylint: enable=W0212
+
+    def on_password_reset_error(self, app_name, error):
+        """Action taken when there was an error requesting the reset."""
+        # set the error message
+        msg = REQUEST_PASSWORD_TOKEN_TECH_ERROR
+        if error['errtype'] == 'ResetPasswordTokenError':
+            # the account provided is wrong, lets tell the user to try
+            # again
+            msg = REQUEST_PASSWORD_TOKEN_WRONG_EMAIL
+        else:
+            # ouch, I dont know what went wrong, tell the user to try later
+            self.email_widget.setVisible(False)
+            self.forgotted_password_intro_label.setVisible(False)
+            self.try_again_widget.setVisible(True)
+        self.message_box.critical(self, self.app_name, msg)

=== modified file 'ubuntu_sso/qt/gui.py'
--- ubuntu_sso/qt/gui.py	2012-02-02 18:09:21 +0000
+++ ubuntu_sso/qt/gui.py	2012-02-10 11:32:20 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2011 Canonical Ltd.
+# Copyright 2011-2012 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
@@ -16,55 +16,31 @@
 """Qt implementation of the UI."""
 
 import gettext
+from functools import wraps
 
 # pylint: disable=F0401,E0611
 
-from PyQt4.QtCore import pyqtSignal, Qt, SIGNAL
+from PyQt4.QtCore import Qt
 from PyQt4.QtGui import (
     QApplication,
     QWidget,
     QCursor,
     QHBoxLayout,
     QVBoxLayout,
-    QPixmap,
+    QMessageBox,
     QStyle,
-    QWizard,
     QWizardPage,
     QLabel,
 )
+from twisted.internet import defer
 
+from ubuntu_sso import main
+from ubuntu_sso.qt.loadingoverlay import LoadingOverlay
 from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.qt import common
-from ubuntu_sso.qt.controllers import (
-    ChooseSignInController,
-    CurrentUserController,
-    EmailVerificationController,
-    ErrorController,
-    ForgottenPasswordController,
-    ResetPasswordController,
-    SetUpAccountController,
-    SuccessController,
-    UbuntuSSOWizardController,
-)
-from ubuntu_sso.qt.ui.choose_sign_in_ui import Ui_ChooseSignInPage
-from ubuntu_sso.qt.ui.current_user_sign_in_ui import Ui_CurrentUserSignInPage
-from ubuntu_sso.qt.ui.email_verification_ui import Ui_EmailVerificationPage
-from ubuntu_sso.qt.ui.error_message_ui import Ui_ErrorPage
-from ubuntu_sso.qt.ui.setup_account_ui import Ui_SetUpAccountPage
-from ubuntu_sso.qt.ui.success_message_ui import Ui_SuccessPage
-from ubuntu_sso.qt.ui.forgotten_password_ui import Ui_ForgottenPasswordPage
-from ubuntu_sso.qt.ui.reset_password_ui import Ui_ResetPasswordPage
-from ubuntu_sso.utils.ui import (
-    PASSWORD1_ENTRY,
-    PASSWORD2_ENTRY,
-    RESET_CODE_ENTRY,
-)
+
 
 _ = gettext.gettext
 logger = setup_logging('ubuntu_sso.gui')
-RESET_TITLE = _("Reset password")
-RESET_SUBTITLE = _("A password reset code has been sent to your e-mail."
-                   "Please enter the code below along with your new password.")
 
 
 class Header(QWidget):
@@ -105,43 +81,79 @@
 class SSOWizardPage(QWizardPage):
     """Root class for all wizard pages."""
 
-    def __init__(self, ui, controller, parent=None):
+    def __init__(self, ui, app_name=None, title='', subtitle='', parent=None):
         """Create a new instance."""
         super(SSOWizardPage, self).__init__(parent)
         self.ui = ui
         self.ui.setupUi(self)
+        self.overlay = LoadingOverlay(self)
+        self.overlay.hide()
+        self.app_name = app_name
         self.header = Header()
+        self.header.set_title(title)
+        self.header.set_subtitle(subtitle)
         self.layout().insertWidget(0, self.header)
-        self.controller = controller
-        if self.controller:
-            self.controller.setupUi(self)
+        self.message_box = QMessageBox
         self.next = -1
+        self._signals = {}
+        self._signals_receivers = {}
+        self.backend = None
+
+    @defer.inlineCallbacks
+    def get_backend(self):
+        """Return the backend used by the controller."""
+        if self.backend is None:
+            client = yield main.get_sso_client()
+            self.backend = client.sso_login
+        defer.returnValue(self.backend)
 
     # pylint: disable=C0103
     def nextId(self):
         """Provide the next id."""
         return self.next
-    # pylint: enable=C0103
-
-    # pylint: disable=C0103
-    def initializePage(self):
-        """Called to prepare the page just before it is shown."""
-        if self.controller:
-            self.controller.pageInitialized()
-    # pylint: enable=C0103
-
-    # pylint: disable=C0103
+
+    def resizeEvent(self, event):
+        """Resize the overlay to fit all the widget."""
+        QWizardPage.resizeEvent(self, event)
+        self.overlay.resize(event.size())
+
     def setTitle(self, title=''):
         """Set the Wizard Page Title."""
         self.header.set_title(title)
-    # pylint: enable=C0103
 
-    # pylint: disable=C0103
     def setSubTitle(self, subtitle=''):
         """Set the Wizard Page Subtitle."""
         self.header.set_subtitle(subtitle)
     # pylint: enable=C0103
 
+    def _filter_by_app_name(self, f):
+        """Excecute the decorated function only for 'self.app_name'."""
+
+        @wraps(f)
+        def inner(app_name, *args, **kwargs):
+            """Execute 'f' only if 'app_name' matches 'self.app_name'."""
+            result = None
+            if app_name == self.app_name:
+                result = f(app_name, *args, **kwargs)
+            else:
+                logger.info('%s: ignoring call since received app_name '\
+                            '"%s" (expected "%s")',
+                            f.__name__, app_name, self.app_name)
+            return result
+
+        return inner
+
+    def _setup_signals(self):
+        """Bind signals to callbacks to be able to test the pages."""
+        for signal, method in self._signals.iteritems():
+            actual = self._signals_receivers.get(signal)
+            if actual is not None:
+                msg = 'Signal %r is already connected with %r.'
+                logger.warning(msg, signal, actual)
+
+            match = self.backend.connect_to_signal(signal, method)
+            self._signals_receivers[signal] = match
+
 
 class EnhancedLineEdit(object):
     """Represents and enhanced lineedit.
@@ -186,10 +198,11 @@
 class SSOWizardEnhancedEditPage(SSOWizardPage):
     """Page that contains enhanced line edits."""
 
-    def __init__(self, ui, controller, parent=None):
+    def __init__(self, ui, app_name=None, parent=None):
         """Create a new instance."""
         self._enhanced_edits = {}
-        super(SSOWizardEnhancedEditPage, self).__init__(ui, controller, parent)
+        super(SSOWizardEnhancedEditPage, self).__init__(ui,
+            app_name=app_name, parent=parent)
 
     def set_line_edit_validation_rule(self, edit, cb):
         """Set a new enhanced edit so that we can show an icon."""
@@ -199,322 +212,3 @@
             # create a new enhanced edit
             enhanced_edit = EnhancedLineEdit(edit, cb)
             self._enhanced_edits[edit] = enhanced_edit
-
-
-class ChooseSignInPage(SSOWizardPage):
-    """Widget that allows the user to choose how to sign in."""
-
-
-class CurrentUserSignInPage(SSOWizardPage):
-    """Widget that allows to get the data of user to sign in."""
-
-
-class EmailVerificationPage(SSOWizardPage):
-    """Widget used to input the email verification code."""
-
-    @property
-    def verification_code(self):
-        """Return the content of the verification code edit."""
-        return str(self.ui.verification_code_edit.text())
-
-    @property
-    def next_button(self):
-        """Return the button that move to the next stage."""
-        return self.ui.next_button
-
-
-class ErrorPage(SSOWizardPage):
-    """Widget used to show the diff errors."""
-
-
-class ForgottenPasswordPage(SSOWizardEnhancedEditPage):
-    """Widget used to deal with users that forgot the password."""
-
-    @property
-    def email_widget(self):
-        """Return the widget used to show the email information."""
-        return self.ui.email_widget
-
-    @property
-    def forgotted_password_intro_label(self):
-        """Return the intro label that lets the user know the issue."""
-        return self.ui.forgotted_password_intro_label
-
-    @property
-    def error_label(self):
-        """Return the label used to show error."""
-        return self.ui.error_label
-
-    @property
-    def email_address_label(self):
-        """Return the lable used to state the use of the line edit."""
-        return self.ui.email_address_label
-
-    @property
-    def email_address(self):
-        """Return the email address provided by the user."""
-        return str(self.ui.email_line_edit.text())
-
-    @property
-    def email_address_line_edit(self):
-        """Return the line edit with the content."""
-        return self.ui.email_line_edit
-
-    @property
-    def send_button(self):
-        """Return the button used to request the new password."""
-        return self.ui.send_button
-
-    @property
-    def try_again_widget(self):
-        """Return the widget used to display the try again button."""
-        return self.ui.try_again_widget
-
-    @property
-    def try_again_button(self):
-        """Return the button used to try again the reset password."""
-        return self.ui.try_again_button
-
-
-class ResetPasswordPage(SSOWizardEnhancedEditPage):
-    """Widget used to allow the user change his password."""
-
-    def __init__(self, ui, controller, parent=None):
-        """Create a new instance."""
-        super(ResetPasswordPage, self).__init__(ui, controller, parent)
-        self.ui.password_line_edit.textEdited.connect(
-            lambda: common.password_assistance(self.ui.password_line_edit,
-                                                 self.ui.password_assistance,
-                                                 common.NORMAL))
-        self.ui.confirm_password_line_edit.textEdited.connect(
-            lambda: common.password_check_match(self.ui.password_line_edit,
-                                      self.ui.confirm_password_line_edit,
-                                      self.ui.password_assistance))
-
-    def focus_changed(self, old, now):
-        """Check who has the focus to activate password popups if necessary."""
-        if now == self.ui.password_line_edit:
-            self.ui.password_assistance.setVisible(True)
-            common.password_default_assistance(self.ui.password_assistance)
-        elif now == self.ui.confirm_password_line_edit:
-            common.password_check_match(self.ui.password_line_edit,
-                                      self.ui.confirm_password_line_edit,
-                                      self.ui.password_assistance)
-
-    # Invalid name "initializePage"
-    # pylint: disable=C0103
-
-    def initializePage(self):
-        super(ResetPasswordPage, self).initializePage()
-        common.password_default_assistance(self.ui.password_assistance)
-        self.ui.password_assistance.setVisible(False)
-        self.setTitle(RESET_TITLE)
-        self.setSubTitle(RESET_SUBTITLE)
-        self.ui.password_label.setText(PASSWORD1_ENTRY)
-        self.ui.confirm_password_label.setText(PASSWORD2_ENTRY)
-        self.ui.reset_code.setText(RESET_CODE_ENTRY)
-
-    def showEvent(self, event):
-        """Connect focusChanged signal from the application."""
-        super(ResetPasswordPage, self).showEvent(event)
-        self.connect(QApplication.instance(),
-            SIGNAL("focusChanged(QWidget*, QWidget*)"),
-            self.focus_changed)
-
-    def hideEvent(self, event):
-        """Disconnect the focusChanged signal when the page change."""
-        super(ResetPasswordPage, self).hideEvent(event)
-        try:
-            self.disconnect(QApplication.instance(),
-                SIGNAL("focusChanged(QWidget*, QWidget*)"),
-                self.focus_changed)
-        except TypeError:
-            pass
-
-    # pylint: enable=C0103
-
-
-class SetupAccountPage(SSOWizardEnhancedEditPage):
-    """Widget used to create a new account."""
-
-    def __init__(self, ui, controller, parent=None):
-        """Create a new widget to be used."""
-        super(SetupAccountPage, self).__init__(ui, controller, parent)
-        # palettes that will be used to set the colors of the password strengh
-        self.captcha_id = None
-        self.captcha_file = None
-        self.ui.captcha_view.setPixmap(QPixmap())
-
-    def get_captcha_image(self):
-        """Return the path to the captcha image."""
-        return self.ui.captcha_view.pixmap()
-
-    def set_captcha_image(self, pixmap_image):
-        """Set the new image of the captcha."""
-        # lets set the QPixmap for the label
-        self.ui.captcha_view.setPixmap(pixmap_image)
-
-    captcha_image = property(get_captcha_image, set_captcha_image)
-
-
-class SuccessPage(SSOWizardPage):
-    """Page used to display success message."""
-
-
-class UbuntuSSOWizard(QWizard):
-    """Wizard used to create or use sso."""
-
-    # definition of the signals raised by the widget
-    recoverableError = pyqtSignal('QString', 'QString')
-    loginSuccess = pyqtSignal('QString', 'QString')
-    registrationSuccess = pyqtSignal('QString', 'QString')
-
-    def __init__(self, controller, app_name, **kwargs):
-        """Create a new wizard."""
-        parent = kwargs.get('parent')
-        super(UbuntuSSOWizard, self).__init__(parent)
-
-        # store common useful data provided by the app
-        self.app_name = app_name
-        self.ping_url = kwargs.get('ping_url', '')
-        self.tc_url = kwargs.get('tc_url', '')
-        self.help_text = kwargs.get('help_text', '')
-        self.login_only = kwargs.get('login_only', False)
-        self.close_callback = kwargs.get('close_callback', lambda: None)
-
-        # set the diff pages of the QWizard
-        self.sign_in_controller = ChooseSignInController(title='Sign In')
-        self.sign_in_page = ChooseSignInPage(Ui_ChooseSignInPage(),
-                                             self.sign_in_controller,
-                                             parent=self)
-        self.setup_controller = SetUpAccountController()
-        self.setup_account = SetupAccountPage(Ui_SetUpAccountPage(),
-                                              self.setup_controller,
-                                              parent=self)
-        self.email_verification = EmailVerificationPage(
-                                                Ui_EmailVerificationPage(),
-                                                EmailVerificationController())
-        self.current_user_controller = CurrentUserController(title='Sign in')
-        self.current_user = CurrentUserSignInPage(Ui_CurrentUserSignInPage(),
-                                                  self.current_user_controller,
-                                                  parent=self)
-        self.success_controller = SuccessController()
-        self.success = SuccessPage(Ui_SuccessPage(), self.success_controller,
-                                   parent=self)
-        self.error_controller = ErrorController()
-        self.error = ErrorPage(Ui_ErrorPage(), self.error_controller)
-        self.forgotte_pwd_controller = ForgottenPasswordController()
-        self.forgotten = ForgottenPasswordPage(Ui_ForgottenPasswordPage(),
-                                               self.forgotte_pwd_controller,
-                                               parent=self)
-        self.reset_password_controller = ResetPasswordController()
-        self.reset_password = ResetPasswordPage(Ui_ResetPasswordPage(),
-                                                self.reset_password_controller,
-                                                parent=self)
-        # store the ids of the pages so that it is easier to access them later
-        self._pages = {}
-        for page in [self.sign_in_page, self.setup_account,
-                     self.email_verification, self.current_user, self.success,
-                     self.error, self.forgotten, self.reset_password]:
-            self._pages[page] = self.addPage(page)
-
-        # set the buttons layout to only have cancel and back since the next
-        # buttons are the ones used in the diff pages.
-        buttons_layout = []
-        buttons_layout.append(QWizard.Stretch)
-        buttons_layout.append(QWizard.BackButton)
-        buttons_layout.append(QWizard.CancelButton)
-        self.setButtonLayout(buttons_layout)
-        self.setWindowTitle(self.app_name)
-        self.controller = controller
-        self.controller.setupUi(self)
-
-    @property
-    def sign_in_page_id(self):
-        """Return the id of the page used for choosing sign in type."""
-        return self._pages[self.sign_in_page]
-
-    @property
-    def setup_account_page_id(self):
-        """Return the id of the page used for sign in."""
-        return self._pages[self.setup_account]
-
-    @property
-    def email_verification_page_id(self):
-        """Return the id of the verification page."""
-        return self._pages[self.email_verification]
-
-    @property
-    def current_user_page_id(self):
-        """Return the id used to signin by a current user."""
-        return self._pages[self.current_user]
-
-    @property
-    def success_page_id(self):
-        """Return the id of the success page."""
-        return self._pages[self.success]
-
-    @property
-    def forgotten_password_page_id(self):
-        """Return the id of the forgotten password page."""
-        return self._pages[self.forgotten]
-
-    @property
-    def reset_password_page_id(self):
-        """Return the id of the reset password page."""
-        return self._pages[self.reset_password]
-
-    @property
-    def error_page_id(self):
-        """Return the id of the error page."""
-        return self._pages[self.error]
-
-
-class UbuntuSSOClientGUI(object):
-    """Ubuntu single sign-on GUI."""
-
-    def __init__(self, app_name, **kwargs):
-        """Create a new instance."""
-        super(UbuntuSSOClientGUI, self).__init__()
-        logger.debug('UbuntuSSOClientGUI: app_name %r, kwargs %r.',
-                     app_name, kwargs)
-        self.app_name = app_name
-        # create the controller and the ui, then set the cb and call the show
-        # method so that we can work
-        self.controller = UbuntuSSOWizardController(app_name)
-        self.view = UbuntuSSOWizard(self.controller, app_name=app_name,
-                                    **kwargs)
-        self.view.show()
-
-    def get_login_success_callback(self):
-        """Return the log in success cb."""
-        return self.controller.login_success_callback
-
-    def set_login_success_callback(self, cb):
-        """Set log in success cb."""
-        self.controller.login_success_callback = cb
-
-    login_success_callback = property(get_login_success_callback,
-                                      set_login_success_callback)
-
-    def get_registration_success_callback(self):
-        """Return the registration success cb."""
-        return self.controller.registration_success_callback
-
-    def set_registration_success_callback(self, cb):
-        """Set registration success cb."""
-        self.controller.registration_success_callback = cb
-
-    registration_success_callback = property(get_registration_success_callback,
-                                             set_registration_success_callback)
-
-    def get_user_cancellation_callback(self):
-        """Return the user cancellation callback."""
-        return self.controller.user_cancellation_callback
-
-    def set_user_cancellation_callback(self, cb):
-        """Set the user cancellation callback."""
-        self.controller.user_cancellation_callback = cb
-
-    user_cancellation_callback = property(get_user_cancellation_callback,
-                                          set_user_cancellation_callback)

=== modified file 'ubuntu_sso/qt/main.py'
--- ubuntu_sso/qt/main.py	2012-02-01 19:19:32 +0000
+++ ubuntu_sso/qt/main.py	2012-02-10 11:32:20 +0000
@@ -20,7 +20,7 @@
 import sys
 
 from PyQt4 import QtGui
-from ubuntu_sso.qt.gui import UbuntuSSOClientGUI
+from ubuntu_sso.qt.ubuntu_sso_wizard import UbuntuSSOClientGUI
 
 
 def parse_args():
@@ -32,6 +32,8 @@
         help='a link to be used as the ping url (to notify about new tokens)')
     parser.add_argument('--tc_url', default='',
         help='a link to be used as Terms & Conditions url')
+    parser.add_argument('--policy_url', default='',
+        help='a link to be used as Privacy Policy url')
     parser.add_argument('--help_text', default='',
         help='extra text that will be shown below the headers')
     parser.add_argument('--login_only', action='store_true', default=False,

=== added file 'ubuntu_sso/qt/reset_password_page.py'
--- ubuntu_sso/qt/reset_password_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/reset_password_page.py	2012-02-10 11:32:20 +0000
@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 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/>.
+
+"""Reset Password page UI."""
+
+from PyQt4.QtCore import SIGNAL
+from PyQt4.QtGui import QApplication
+from twisted.internet import defer
+
+from ubuntu_sso.qt import build_general_error_message
+from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
+from ubuntu_sso.qt import common
+from ubuntu_sso.utils.ui import (
+    is_min_required_password,
+    PASSWORD1_ENTRY,
+    PASSWORD2_ENTRY,
+    PASSWORD_HELP,
+    RESET_CODE_ENTRY,
+    RESET_PASSWORD,
+    RESET_TITLE,
+    RESET_SUBTITLE,
+)
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging('ubuntu_sso.reset_password_page')
+
+
+class ResetPasswordPage(SSOWizardEnhancedEditPage):
+    """Widget used to allow the user change his password."""
+
+    def __init__(self, ui, app_name=None, parent=None):
+        """Create a new instance."""
+        super(ResetPasswordPage, self).__init__(ui, app_name, parent)
+        self.ui.password_line_edit.textEdited.connect(
+            lambda: common.password_assistance(self.ui.password_line_edit,
+                                                 self.ui.password_assistance,
+                                                 common.NORMAL))
+        self.ui.confirm_password_line_edit.textEdited.connect(
+            lambda: common.password_check_match(self.ui.password_line_edit,
+                                      self.ui.confirm_password_line_edit,
+                                      self.ui.password_assistance))
+        self._signals = {
+            'PasswordChanged':
+             self._filter_by_app_name(self.on_password_changed),
+            'PasswordChangeError':
+             self._filter_by_app_name(self.on_password_change_error),
+        }
+        self.setup_page()
+
+    @defer.inlineCallbacks
+    def setup_page(self):
+        """Setup the widget components."""
+        self.backend = yield self.get_backend()
+        self._setup_signals()
+        self._set_translated_strings()
+        self._connect_ui()
+        self._add_line_edits_validations()
+
+    def focus_changed(self, old, now):
+        """Check who has the focus to activate password popups if necessary."""
+        if now == self.ui.password_line_edit:
+            self.ui.password_assistance.setVisible(True)
+            common.password_default_assistance(self.ui.password_assistance)
+        elif now == self.ui.confirm_password_line_edit:
+            common.password_check_match(self.ui.password_line_edit,
+                                      self.ui.confirm_password_line_edit,
+                                      self.ui.password_assistance)
+
+    # Invalid name "initializePage"
+    # pylint: disable=C0103
+
+    def initializePage(self):
+        """Extends QWizardPage initializePage method."""
+        super(ResetPasswordPage, self).initializePage()
+        common.password_default_assistance(self.ui.password_assistance)
+        self.ui.password_assistance.setVisible(False)
+        self.setTitle(RESET_TITLE)
+        self.setSubTitle(RESET_SUBTITLE)
+        self.ui.password_label.setText(PASSWORD1_ENTRY)
+        self.ui.confirm_password_label.setText(PASSWORD2_ENTRY)
+        self.ui.reset_code.setText(RESET_CODE_ENTRY)
+
+        self.ui.reset_password_button.setDefault(True)
+        self.ui.reset_password_button.setEnabled(False)
+        # The style from this property come from the Wizard
+        self.ui.reset_password_button.setProperty("DisabledState",
+            not self.ui.reset_password_button.isEnabled())
+        self.ui.reset_password_button.style().unpolish(
+            self.ui.reset_password_button)
+        self.ui.reset_password_button.style().polish(
+            self.ui.reset_password_button)
+
+    def showEvent(self, event):
+        """Connect focusChanged signal from the application."""
+        super(ResetPasswordPage, self).showEvent(event)
+        self.connect(QApplication.instance(),
+            SIGNAL("focusChanged(QWidget*, QWidget*)"),
+            self.focus_changed)
+
+    def hideEvent(self, event):
+        """Disconnect the focusChanged signal when the page change."""
+        super(ResetPasswordPage, self).hideEvent(event)
+        try:
+            self.disconnect(QApplication.instance(),
+                SIGNAL("focusChanged(QWidget*, QWidget*)"),
+                self.focus_changed)
+        except TypeError:
+            pass
+
+    # pylint: enable=C0103
+
+    def _set_translated_strings(self):
+        """Translate the diff strings used in the app."""
+        self.ui.reset_password_button.setText(RESET_PASSWORD)
+        self.setSubTitle(PASSWORD_HELP)
+
+    def _connect_ui(self):
+        """Connect the different ui signals."""
+        self.ui.reset_password_button.clicked.connect(
+                                                    self.set_new_password)
+        self.ui.reset_code_line_edit.textChanged.connect(self._validate)
+        self.ui.password_line_edit.textChanged.connect(self._validate)
+        self.ui.confirm_password_line_edit.textChanged.connect(
+            self._validate)
+
+    def _validate(self):
+        """Enable the submit button if data is valid."""
+        enabled = True
+        code = unicode(self.ui.reset_code_line_edit.text())
+        password = unicode(self.ui.password_line_edit.text())
+        confirm_password = unicode(
+            self.ui.confirm_password_line_edit.text())
+        if not is_min_required_password(password):
+            enabled = False
+        elif not self.is_correct_password_confirmation(confirm_password):
+            enabled = False
+        elif not code:
+            enabled = False
+        self.ui.reset_password_button.setEnabled(enabled)
+        self.ui.reset_password_button.setProperty("DisabledState",
+            not self.ui.reset_password_button.isEnabled())
+        self.ui.reset_password_button.style().unpolish(
+            self.ui.reset_password_button)
+        self.ui.reset_password_button.style().polish(
+            self.ui.reset_password_button)
+
+    def _add_line_edits_validations(self):
+        """Add the validations to be use by the line edits."""
+        self.set_line_edit_validation_rule(
+                                           self.ui.password_line_edit,
+                                           is_min_required_password)
+        self.set_line_edit_validation_rule(
+                                    self.ui.confirm_password_line_edit,
+                                    self.is_correct_password_confirmation)
+        # same as the above case, lets connect a signal to a signal
+        self.ui.password_line_edit.textChanged.connect(
+                     self.ui.confirm_password_line_edit.textChanged.emit)
+
+    def on_password_changed(self, app_name, result):
+        """Let user know that the password was changed."""
+        email = unicode(self.wizard().forgotten.ui.email_line_edit.text())
+        self.wizard().current_user.ui.email_edit.setText(email)
+        self.overlay.hide()
+        current_user_id = self.wizard().current_user_page_id
+        visited_pages = self.wizard().visitedPages()
+        for index in reversed(visited_pages):
+            if index == current_user_id:
+                break
+            self.wizard().back()
+
+    def on_password_change_error(self, app_name, error):
+        """Let the user know that there was an error."""
+        logger.error('Got error changing password for %s, error: %s',
+                     self.app_name, error)
+        self.message_box.critical(self, self.app_name,
+            build_general_error_message(error))
+
+    def set_new_password(self):
+        """Request a new password to be set."""
+        email = unicode(self.wizard().forgotten.ui.email_line_edit.text())
+        code = unicode(self.ui.reset_code_line_edit.text())
+        password = unicode(self.ui.password_line_edit.text())
+        logger.info('Setting new password for %r and email %r with code %r',
+                    self.app_name, email, code)
+        self.backend.set_new_password(self.app_name, email, code, password)
+
+    def is_correct_password_confirmation(self, password):
+        """Return if the password is correct."""
+        return unicode(self.ui.password_line_edit.text()) == password

=== modified file 'ubuntu_sso/qt/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-02-02 15:57:02 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-02-10 11:32:20 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-
+#
 # Copyright 2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -16,59 +16,138 @@
 
 """Customized Setup Account page for SSO."""
 
-import gettext
-import re
+import StringIO
+import tempfile
+import os
+
+# pylint: disable=F0401
+try:
+    from PIL import Image
+except ImportError:
+    import Image
+# pylint: enable=F0401
 
 from PyQt4 import QtGui, QtCore
+from twisted.internet import defer
 
+from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt import common
-from ubuntu_sso.qt import gui as sso_gui
+from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
 from ubuntu_sso.qt import enhanced_check_box
 from ubuntu_sso.utils.ui import SET_UP_ACCOUNT_BUTTON
-
-
-_ = gettext.gettext
+from ubuntu_sso.utils.ui import (
+    AGREE_TO_TERMS,
+    AGREE_TO_TERMS_AND_POLICY,
+    CAPTCHA_LOAD_ERROR,
+    CAPTCHA_REQUIRED_ERROR,
+    CAPTCHA_SOLUTION_ENTRY,
+    EMAIL,
+    EMAIL1_ENTRY,
+    EMAIL2_ENTRY,
+    EMAIL_INVALID,
+    EMAIL_MATCH,
+    EMAIL_MISMATCH,
+    EMPTY_NAME,
+    INVALID_EMAIL,
+    is_min_required_password,
+    is_correct_email,
+    JOIN_HEADER_LABEL,
+    NAME,
+    NAME_ENTRY,
+    NAME_INVALID,
+    PASSWORD,
+    PASSWORD1_ENTRY,
+    PASSWORD2_ENTRY,
+    PASSWORD_HELP,
+    PASSWORD_MISMATCH,
+    PASSWORD_TOO_WEAK,
+    PRIVACY_POLICY_TEXT,
+    RETYPE_EMAIL,
+    RETYPE_PASSWORD,
+    TERMS_TEXT,
+    TITLE,
+)
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging('ubuntu_sso.setup_account_page')
 
 # pylint: disable=C0103
 ERROR = u'<font color="#df2d1f"><b> %s </b></font>'
 TITLE_STYLE = "<span style=\"font-size:24px\">%s</span>"
 
-EMAIL = _("Email")
-EMPTY_NAME = _("Please enter your name")
-INVALID_EMAIL = _("Please enter a valid email address")
-EMAIL_MATCH = _("The email addresses do not match")
-NAME = _("Name")
-PASSWORD = _("Create a password")
-RETYPE_EMAIL = _("Retype email")
-RETYPE_PASSWORD = _("Retype password")
-SUBTITLE = _("You only need to set up your account "
-             "once to get access to Ubuntu One across your devices.")
-TERMS = _("By signing up to Ubuntu One you agree to our "
-          "{terms_and_conditions} and {privacy_policy}")
-TERMS_LINK = _("<a href='https://one.ubuntu.com/terms/'>"
-               "<span style='color:#df2d1f;'>Terms of Service</span></a>")
-PRIVACY_POLICY_LINK = _("<a href='https://one.ubuntu.com/privacy/'>"
-                        "<span style='color:#df2d1f;'>Privacy Policy"
+ERROR_EMAIL = 'email'
+TERMS_LINK = ("<a href='{toc_link}'>"
+              "<span style='color:#df2d1f;'>{terms_text}</span></a>")
+PRIVACY_POLICY_LINK = ("<a href='{policy_link}'>"
+                        "<span style='color:#df2d1f;'>{privacy_policy_text}"
                         "</span></a></font>")
-TITLE = _("Sign Up to Ubuntu One")
-
-
-class SetupAccountPage(sso_gui.SetupAccountPage):
+
+
+class SetupAccountPage(SSOWizardEnhancedEditPage):
     """Customized Setup Account page for SSO."""
 
-    def __init__(self, *args, **kwargs):
-        super(SetupAccountPage, self).__init__(*args, **kwargs)
+    def __init__(self, ui, subtitle, toc_link, policy_link, *args, **kwargs):
+        super(SetupAccountPage, self).__init__(ui, *args, **kwargs)
+        self._subtitle = subtitle
+        self._toc_link = toc_link
+        self._policy_link = policy_link
+        self.captcha_id = None
+        self.captcha_file = None
+        self._show_checkbox = True
+        self.ui.captcha_view.setPixmap(QtGui.QPixmap())
         self.ui.password_edit.textEdited.connect(
             lambda: common.password_assistance(self.ui.password_edit,
                                                  self.ui.password_assistance,
                                                  common.NORMAL))
-        terms = TERMS.format(terms_and_conditions=TERMS_LINK,
-                         privacy_policy=PRIVACY_POLICY_LINK)
+        terms_links = TERMS_LINK.format(toc_link=self._toc_link,
+            terms_text=TERMS_TEXT)
+        privacy_policy_link = PRIVACY_POLICY_LINK.format(
+            policy_link=self._policy_link,
+            privacy_policy_text=PRIVACY_POLICY_TEXT)
+        if self._toc_link and self._policy_link:
+            terms = AGREE_TO_TERMS_AND_POLICY
+        elif self._toc_link:
+            terms = AGREE_TO_TERMS
+        elif self._policy_link:
+            terms = AGREE_TO_TERMS
+            terms_links = privacy_policy_link
+        else:
+            terms = ''
+            self._show_checkbox = False
+        terms = terms.format(app_name=self.app_name,
+                         terms_and_conditions=terms_links,
+                         privacy_policy=privacy_policy_link)
         self.terms_checkbox = enhanced_check_box.EnhancedCheckBox(terms)
         self.ui.hlayout_check.addWidget(self.terms_checkbox)
+        self.terms_checkbox.setVisible(self._show_checkbox)
 
         self.set_up_button = None
         self.captcha_received = False
+        self._signals = {
+            'CaptchaGenerated':
+             self._filter_by_app_name(self.on_captcha_generated),
+            'CaptchaGenerationError':
+             self._filter_by_app_name(self.on_captcha_generation_error),
+             'UserRegistered':
+             self._filter_by_app_name(self.on_user_registered),
+            'UserRegistrationError':
+             self._filter_by_app_name(self.on_user_registration_error),
+        }
+        self.setup_page()
+
+    @defer.inlineCallbacks
+    def setup_page(self):
+        """Setup the widget components."""
+        # request the backend to be used with the ui
+        self.backend = yield self.get_backend()
+        # set the callbacks for the captcha generation
+        self._setup_signals()
+        self._connect_ui_elements()
+        self._refresh_captcha()
+        self._set_translated_strings()
+        self._set_line_edits_validations()
+        self._register_fields()
 
     # Invalid name "initializePage"
     # pylint: disable=C0103
@@ -77,9 +156,9 @@
         """Setup UI details."""
         # We need to override some texts from SSO
         # to match our spec
-        title_page = TITLE_STYLE % TITLE
+        title_page = TITLE_STYLE % TITLE.format(app_name=self.app_name)
         self.setTitle(title_page)
-        self.setSubTitle(SUBTITLE)
+        self.setSubTitle(self._subtitle)
         # Set Setup Account button
         self.wizard().setOption(QtGui.QWizard.HaveCustomButton3, True)
         try:
@@ -88,8 +167,8 @@
             pass
         self.setButtonText(QtGui.QWizard.CustomButton3, SET_UP_ACCOUNT_BUTTON)
         self.set_up_button = self.wizard().button(QtGui.QWizard.CustomButton3)
-        self.set_up_button.clicked.connect(self.wizard().overlay.show)
-        self.set_up_button.clicked.connect(self.controller.set_next_validation)
+        self.set_up_button.clicked.connect(self.overlay.show)
+        self.set_up_button.clicked.connect(self.set_next_validation)
         self.set_up_button.setEnabled(False)
 
         self.ui.name_label.setText(NAME)
@@ -112,6 +191,224 @@
         self.ui.confirm_email_assistance.setVisible(False)
         self.ui.password_assistance.setVisible(False)
         self.ui.refresh_label.setVisible(True)
+    #pylint: enable=C0103
+
+    def _set_translated_strings(self):
+        """Set the different gettext translated strings."""
+        logger.debug('SetUpAccountPage._set_translated_strings')
+        # set the translated string
+        self.ui.name_label.setText(NAME_ENTRY)
+        self.ui.email_label.setText(EMAIL1_ENTRY)
+        self.ui.confirm_email_label.setText(EMAIL2_ENTRY)
+        self.ui.password_label.setText(PASSWORD1_ENTRY)
+        self.ui.confirm_password_label.setText(PASSWORD2_ENTRY)
+        self.ui.password_info_label.setText(PASSWORD_HELP)
+        self.ui.captcha_solution_edit.setPlaceholderText(
+                                                      CAPTCHA_SOLUTION_ENTRY)
+
+    def _set_line_edits_validations(self):
+        """Set the validations to be performed on the edits."""
+        logger.debug('SetUpAccountPage._set_line_edits_validations')
+        self.set_line_edit_validation_rule(self.ui.email_edit,
+                                                is_correct_email)
+        # set the validation rule for the email confirmation
+        self.set_line_edit_validation_rule(
+                                        self.ui.confirm_email_edit,
+                                        self.is_correct_email_confirmation)
+        # connect the changed text of the password to trigger a changed text
+        # in the confirm so that the validation is redone
+        self.ui.email_edit.textChanged.connect(
+                            self.ui.confirm_email_edit.textChanged.emit)
+        self.set_line_edit_validation_rule(self.ui.password_edit,
+                                                is_min_required_password)
+        self.set_line_edit_validation_rule(
+                                        self.ui.confirm_password_edit,
+                                        self.is_correct_password_confirmation)
+        # same as the above case, lets connect a signal to a signal
+        self.ui.password_edit.textChanged.connect(
+            self.ui.confirm_password_edit.textChanged.emit)
+
+    def _connect_ui_elements(self):
+        """Set the connection of signals."""
+        logger.debug('SetUpAccountPage._connect_ui_elements')
+        self.ui.refresh_label.linkActivated.connect(lambda url: \
+                                          self._refresh_captcha())
+        # We need to check if we enable the button on many signals
+        self.ui.name_edit.textEdited.connect(self._enable_setup_button)
+        self.ui.email_edit.textEdited.connect(self._enable_setup_button)
+        self.ui.confirm_email_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.ui.password_edit.textEdited.connect(self._enable_setup_button)
+        self.ui.confirm_password_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.ui.captcha_solution_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.terms_checkbox.stateChanged.connect(self._enable_setup_button)
+
+    def _enable_setup_button(self):
+        """Only enable the setup button if the form is valid."""
+        name = unicode(self.ui.name_edit.text()).strip()
+        email = unicode(self.ui.email_edit.text())
+        confirm_email = unicode(self.ui.confirm_email_edit.text())
+        password = unicode(self.ui.password_edit.text())
+        confirm_password = unicode(self.ui.confirm_password_edit.text())
+        captcha_solution = unicode(self.ui.captcha_solution_edit.text())
+
+        # Check for len(name) > 0 to ensure that a bool is assigned to enabled
+        if not self._show_checkbox:
+            checkbox_terms = True
+        else:
+            checkbox_terms = self.terms_checkbox.isChecked()
+        enabled = checkbox_terms and \
+          len(captcha_solution) > 0 and \
+          is_min_required_password(password) and \
+          password == confirm_password and is_correct_email(email) and \
+          email == confirm_email and len(name) > 0
+
+        self.set_up_button.setEnabled(enabled)
+        self.set_up_button.setProperty("DisabledState", not enabled)
+        self.set_up_button.style().unpolish(self.set_up_button)
+        self.set_up_button.style().polish(self.set_up_button)
+
+    def _refresh_captcha(self):
+        """Refresh the captcha image shown in the ui."""
+        logger.debug('SetUpAccountPage._refresh_captcha')
+        # lets clean behind us, do we have the old file arround?
+        if self.captcha_file and os.path.exists(self.captcha_file):
+            os.unlink(self.captcha_file)
+        fd = tempfile.TemporaryFile(mode='r')
+        file_name = fd.name
+        self.captcha_file = file_name
+        self.backend.generate_captcha(self.app_name, file_name)
+        self.on_captcha_refreshing()
+
+    def _set_titles(self):
+        """Set the diff titles of the view."""
+        logger.debug('SetUpAccountPage._set_titles')
+        self.header.set_title(
+            JOIN_HEADER_LABEL % {'app_name': self.app_name})
+        self.header.set_subtitle(self.wizard().help_text)
+
+    def _register_fields(self):
+        """Register the diff fields of the Ui."""
+        self.registerField('email_address', self.ui.email_edit)
+        self.registerField('password', self.ui.password_edit)
+
+    def on_captcha_generated(self, app_name, result):
+        """A new image was generated."""
+        logger.debug('SetUpAccountPage.on_captcha_generated for %r '
+                     '(captcha id %r, filename %r).',
+                     app_name, result, self.captcha_file)
+        self.captcha_id = result
+        # HACK: First, let me apologize before hand, you can mention my mother
+        # if needed I would do the same (mandel)
+        # In an ideal world we could use the Qt plug-in for the images so that
+        # we could load jpgs etc.. but this won't work when the app has been
+        # brozen win py2exe using bundle_files=1
+        # The main issue is that Qt will complain about the thread not being
+        # the correct one when performing a moveToThread operation which is
+        # done either by a setParent or something within the qtreactor, PIL
+        # in this case does solve the issue. Sorry :(
+        pil_image = Image.open(self.captcha_file)
+        string_io = StringIO.StringIO()
+        pil_image.save(string_io, format='png')
+        pixmap_image = QtGui.QPixmap()
+        pixmap_image.loadFromData(string_io.getvalue())
+        self.captcha_image = pixmap_image
+        self.on_captcha_refresh_complete()
+
+    def on_captcha_generation_error(self, error, *args, **kwargs):
+        """An error ocurred."""
+        logger.debug('SetUpAccountPage.on_captcha_generation_error')
+        self.message_box.critical(self, self.app_name, CAPTCHA_LOAD_ERROR)
+        self.on_captcha_refresh_complete()
+
+    def on_user_registration_error(self, app_name, error):
+        """Let the user know we could not register."""
+        logger.debug('SetUpAccountPage.on_user_registration_error')
+        # errors are returned as a dict with the data we want to show.
+        msg = error.pop(ERROR_EMAIL, '')
+        if msg:
+            self.set_error_message(self.ui.email_assistance, msg)
+        error_msg = build_general_error_message(error)
+        if error_msg:
+            self.message_box.critical(self, self.app_name, error_msg)
+        self._refresh_captcha()
+
+    def on_user_registered(self, app_name, result):
+        """Execute when the user did register."""
+        logger.debug('SetUpAccountPage.on_user_registered')
+        self.next = self.wizard().email_verification_page_id
+        self.wizard().next()
+
+    def validate_form(self):
+        """Validate the info of the form and return an error."""
+        logger.debug('SetUpAccountPage.validate_form')
+        name = unicode(self.ui.name_edit.text()).strip()
+        email = unicode(self.ui.email_edit.text())
+        confirm_email = unicode(self.ui.confirm_email_edit.text())
+        password = unicode(self.ui.password_edit.text())
+        confirm_password = unicode(self.ui.confirm_password_edit.text())
+        captcha_solution = unicode(self.ui.captcha_solution_edit.text())
+        condition = True
+        messages = []
+        if not name:
+            condition = False
+            self.set_error_message(self.ui.name_assistance,
+                NAME_INVALID)
+        if not is_correct_email(email):
+            condition = False
+            self.set_error_message(self.ui.email_assistance,
+                EMAIL_INVALID)
+        if email != confirm_email:
+            condition = False
+            self.set_error_message(self.ui.confirm_email_assistance,
+                EMAIL_MISMATCH)
+        if not is_min_required_password(password):
+            messages.append(PASSWORD_TOO_WEAK)
+        if password != confirm_password:
+            messages.append(PASSWORD_MISMATCH)
+        if not captcha_solution:
+            messages.append(CAPTCHA_REQUIRED_ERROR)
+        if len(messages) > 0:
+            condition = False
+            self.message_box.critical(self, self.app_name, '\n'.join(messages))
+        return condition
+
+    # pylint: disable=W0212
+    def set_next_validation(self):
+        """Set the validation as the next page."""
+        logger.debug('SetUpAccountPage.set_next_validation')
+        email = unicode(self.ui.email_edit.text())
+        password = unicode(self.ui.password_edit.text())
+        name = unicode(self.ui.name_edit.text())
+        captcha_id = self.captcha_id
+        captcha_solution = unicode(self.ui.captcha_solution_edit.text())
+        # validate the current info of the form, try to perform the action
+        # to register the user, and then move foward
+        if self.validate_form():
+            self.backend.register_user(self.app_name, email,
+                                       password, name, captcha_id,
+                                       captcha_solution)
+        # Update validation page's title, which contains the email
+        self.next = self.wizard()._pages[self.wizard().email_verification]
+        self.wizard().page(self.next).set_titles(email)
+    # pylint: enable=W0212
+
+    def is_correct_email(self, email_address):
+        """Return if the email is correct."""
+        logger.debug('SetUpAccountPage.is_correct_email')
+        return '@' in email_address
+
+    def is_correct_email_confirmation(self, email_address):
+        """Return that the email is the same."""
+        logger.debug('SetUpAccountPage.is_correct_email_confirmation')
+        return unicode(self.ui.email_edit.text()) == email_address
+
+    def is_correct_password_confirmation(self, password):
+        """Return that the passwords are correct."""
+        logger.debug('SetUpAccountPage.is_correct_password_confirmation')
+        return unicode(self.ui.password_edit.text()) == password
 
     def focus_changed(self, old, now):
         """Check who has the focus to activate password popups if necessary."""
@@ -167,6 +464,7 @@
         label.setText(ERROR % msg)
         label.setVisible(True)
 
+    #pylint: disable=C0103
     def showEvent(self, event):
         """Set set_up_button as default button when the page is shown."""
         # This method should stays here because if we move it to initializePage
@@ -183,7 +481,7 @@
             self.focus_changed)
         super(SetupAccountPage, self).showEvent(event)
         if not self.captcha_received:
-            self.wizard().overlay.show()
+            self.overlay.show()
 
     def hideEvent(self, event):
         """Disconnect the focusChanged signal when the page change."""
@@ -196,31 +494,26 @@
         except TypeError:
             pass
         super(SetupAccountPage, self).hideEvent(event)
+    #pylint: enable=C0103
 
     def on_captcha_refreshing(self):
         """Show overlay when captcha is refreshing."""
         if self.isVisible():
-            self.wizard().overlay.show()
+            self.overlay.show()
         self.captcha_received = False
 
     def on_captcha_refresh_complete(self):
         """Hide overlay when captcha finished refreshing."""
-        self.wizard().overlay.hide()
+        self.overlay.hide()
         self.captcha_received = True
 
-
-def is_min_required_password(password):
-    """Return if the password meets the minimum requirements."""
-    if (len(password) < 8 or
-        re.search('[A-Z]', password) is None or
-        re.search('\d+', password) is None):
-        return False
-    return True
-
-
-# pylint: disable=W0511
-# FIXME: this should do the same check as SSO's server side
-def is_correct_email(email_address):
-    """Return if the email is correct."""
-    return '@' in email_address
-# pylint: enable=W0511
+    def get_captcha_image(self):
+        """Return the path to the captcha image."""
+        return self.ui.captcha_view.pixmap()
+
+    def set_captcha_image(self, pixmap_image):
+        """Set the new image of the captcha."""
+        # lets set the QPixmap for the label
+        self.ui.captcha_view.setPixmap(pixmap_image)
+
+    captcha_image = property(get_captcha_image, set_captcha_image)

=== modified file 'ubuntu_sso/qt/sign_in_page.py'
--- ubuntu_sso/qt/sign_in_page.py	2012-02-02 18:54:38 +0000
+++ ubuntu_sso/qt/sign_in_page.py	2012-02-10 11:32:20 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-
+#
 # Copyright 2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -21,17 +21,55 @@
 from PyQt4 import QtGui
 
 from ubuntu_sso.qt.gui import SSOWizardPage
+from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils.ui import (
+    CONGRATULATIONS,
+    EXISTING_ACCOUNT_CHOICE_BUTTON,
+    SET_UP_ACCOUNT_CHOICE_BUTTON,
+)
 
 
 _ = gettext.gettext
+logger = setup_logging('ubuntu_sso.sing_in_page')
 
 
 class SignInPage(SSOWizardPage):
     """Wizard Page that lets the user Sign into Ubuntu One."""
 
-    def __init__(self, image_pixmap, *args, **kwargs):
-        super(SignInPage, self).__init__(*args, **kwargs)
+    def __init__(self, ui, image_pixmap, *args, **kwargs):
+        super(SignInPage, self).__init__(ui, *args, **kwargs)
         self.ui.image_label.setPixmap(image_pixmap)
+        self._set_up_translated_strings()
+        self._connect_buttons()
+
+    def _set_up_translated_strings(self):
+        """Set the correct strings for the UI."""
+        logger.debug('SingInPage._set_up_translated_strings')
+        congratulations = CONGRATULATIONS.format(app_name=self.app_name)
+        self.ui.message_label.setText(congratulations)
+        self.ui.existing_account_button.setText(
+                                        EXISTING_ACCOUNT_CHOICE_BUTTON)
+        self.ui.setup_account_button.setText(
+                                        SET_UP_ACCOUNT_CHOICE_BUTTON)
+
+    def _connect_buttons(self):
+        """Connect the buttons to the actions to perform."""
+        logger.debug('SingInPage._connect_buttons')
+        self.ui.existing_account_button.clicked.connect(
+                                                    self._set_next_existing)
+        self.ui.setup_account_button.clicked.connect(self._set_next_new)
+
+    def _set_next_existing(self):
+        """Set the next id and fire signal."""
+        logger.debug('SignInPage._set_next_existing')
+        self.next = self.wizard().current_user_page_id
+        self.wizard().next()
+
+    def _set_next_new(self):
+        """Set the next id and fire signal."""
+        logger.debug('SignInPage._set_next_new')
+        self.next = self.wizard().setup_account_page_id
+        self.wizard().next()
 
     # Invalid names of Qt-inherited methods
     # pylint: disable=C0103

=== added file 'ubuntu_sso/qt/success_page.py'
--- ubuntu_sso/qt/success_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/success_page.py	2012-02-10 11:32:20 +0000
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 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/>.
+
+"""Success page UI."""
+
+from ubuntu_sso.qt.gui import SSOWizardPage
+
+
+class SuccessPage(SSOWizardPage):
+    """Page used to display success message."""
+
+    def __init__(self, ui, *args, **kwargs):
+        super(SuccessPage, self).__init__(ui, *args, **kwargs)
+        self.next = -1

=== modified file 'ubuntu_sso/qt/tests/__init__.py'
--- ubuntu_sso/qt/tests/__init__.py	2012-02-03 15:11:19 +0000
+++ ubuntu_sso/qt/tests/__init__.py	2012-02-10 11:32:20 +0000
@@ -28,7 +28,8 @@
     """Fake an object, record every call."""
 
     next_result = None
-    exposed_methods = []
+    exposed_methods = ['connect_to_signal',
+        'generate_captcha']
 
     def __init__(self, *args, **kwargs):
         self._args = args
@@ -249,16 +250,47 @@
     """Replace wizard() function on wizard pages."""
 
     customButtonClicked = QtCore.QObject()
+    sign_in_page_id = 1
+    setup_account_id = 2
+    current_user_id = 3
+    email_verification_id = 4
+    success_id = 5
+    error_id = 6
+    forgotten_id = 7
+    reset_password_id = 8
 
     def __init__(self):
         self.overlay = FakeOverlay()
         self.called = []
         self.buttons = {}
+        self.buttons_text = {}
         self._next_id = -1
+        self.sign_in_page = object()
+        self.setup_account = object()
+        self.current_user = object()
+        self.email_verification = object()
+        self.success = object()
+        self.error = object()
+        self.forgotten = object()
+        self.reset_password = object()
+        self._pages = {
+            self.sign_in_page: self.sign_in_page_id,
+            self.setup_account: self.setup_account_id,
+            self.current_user: self.current_user_id,
+            self.email_verification: self.email_verification_id,
+            self.success: self.success_id,
+            self.error: self.error_id,
+            self.forgotten: self.forgotten_id,
+            self.reset_password: self.reset_password_id,
+        }
 
     # Invalid name "setButtonLayout", "setOption"
     # pylint: disable=C0103
 
+    def setButtonText(self, key, value):
+        """Fake setButtonText."""
+        self.buttons_text[key] = value
+
     def setButtonLayout(self, *args, **kwargs):
         """Fake the functionality of setButtonLayout on QWizard class."""
         self.called.append(('setButtonLayout', (args, kwargs)))
@@ -273,6 +305,18 @@
         """Fake the functionality of button on QWizard class."""
         return self.buttons.setdefault(button_id, QtGui.QPushButton())
 
+    def next(self):
+        """Fake next."""
+        self.called.append('next')
+
+    def page(self, p_id):
+        """Fake page method."""
+        return self
+
+    def set_titles(self, title):
+        """Fake set_titles."""
+        self.called.append(('set_titles', title))
+
 
 class FakeWizardButtonStyle(FakeWizard):
 

=== removed file 'ubuntu_sso/qt/tests/test_controllers.py'
--- ubuntu_sso/qt/tests/test_controllers.py	2012-02-06 16:18:24 +0000
+++ ubuntu_sso/qt/tests/test_controllers.py	1970-01-01 00:00:00 +0000
@@ -1,2113 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Authors: Manuel de la Pena <[e-mail]>
-#          Natalia B. Bidart <[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/>.
-
-"""Test the ui controllers."""
-
-import collections
-
-from twisted.internet import defer
-
-# pylint: disable=F0401,E0611
-
-from PyQt4.QtCore import QString, SIGNAL
-from PyQt4.QtGui import QCheckBox, QLabel, QLineEdit, QWizard
-
-try:
-    from PIL import Image
-except ImportError:
-    import Image
-# pylint: enable=F0401,E0611
-
-from ubuntu_sso.qt.controllers import (
-    BackendController,
-    ChooseSignInController,
-    CurrentUserController,
-    EmailVerificationController,
-    ErrorController,
-    ForgottenPasswordController,
-    ResetPasswordController,
-    SetUpAccountController,
-    SuccessController,
-    UbuntuSSOWizardController,
-)
-from ubuntu_sso.qt.tests import BaseTestCase, FakePageUiStyle
-from ubuntu_sso.utils.ui import (
-    CAPTCHA_REQUIRED_ERROR,
-    CAPTCHA_SOLUTION_ENTRY,
-    EMAIL1_ENTRY,
-    EMAIL2_ENTRY,
-    EMAIL_INVALID,
-    EMAIL_MISMATCH,
-    ERROR,
-    EMAIL_LABEL,
-    EXISTING_ACCOUNT_CHOICE_BUTTON,
-    FORGOTTEN_PASSWORD_BUTTON,
-    JOIN_HEADER_LABEL,
-    LOGIN_PASSWORD_LABEL,
-    NAME_ENTRY,
-    NAME_INVALID,
-    PASSWORD1_ENTRY,
-    PASSWORD2_ENTRY,
-    PASSWORD_HELP,
-    PASSWORD_TOO_WEAK,
-    PASSWORD_MISMATCH,
-    RESET_PASSWORD,
-    REQUEST_PASSWORD_TOKEN_LABEL,
-    SET_UP_ACCOUNT_CHOICE_BUTTON,
-    SIGN_IN_BUTTON,
-    SUCCESS,
-    REQUEST_PASSWORD_TOKEN_WRONG_EMAIL,
-    REQUEST_PASSWORD_TOKEN_TECH_ERROR,
-    TRY_AGAIN_BUTTON,
-    VERIFY_EMAIL_CONTENT,
-    VERIFY_EMAIL_TITLE,
-)
-
-#ignore the comon mocker issues with lint
-# pylint: disable=W0212,W0104,W0106,E1103
-
-
-class FakeButton(FakePageUiStyle):
-
-    """Fake Button."""
-
-    def __init__(self):
-        """Initialize object."""
-        super(FakeButton, self).__init__()
-        self.function = None
-        self.clicked = self
-
-    def connect(self, function):
-        """Receive the function that should be connected to this button."""
-        self.function = function
-
-
-class FakeField(object):
-
-    """Fake Field for text input."""
-
-    def __init__(self, text):
-        self.text = text
-
-    # pylint: disable=C0103
-    def toString(self):
-        """Fake toString method for input fields."""
-        return self.text
-    # pylint: enable=C0103
-
-
-class FakeWizard(object):
-
-    """Fake Wizard."""
-
-    current_user_page_id = 1
-    setup_account_page_id = 2
-    forgotten_password_page_id = 3
-    reset_password_page_id = 4
-
-    def __init__(self, view):
-        """Initialize object."""
-        self.properties = {}
-        self.app_name = 'app_name'
-        self.help_text = 'help'
-        self.view = view
-        self.next_id = 0
-        # pylint: disable=C0103
-        self.loginSuccess = self
-        self.registrationSuccess = self
-        # pylint: enable=C0103
-        self.forgotten = self
-        self.ui = self
-        self.email_line_edit = QLineEdit()
-
-    # pylint: disable=C0103
-    def registerField(self, key, text):
-        """Fake registerField from wizard."""
-        self.properties['field_%s' % key] = FakeField(text)
-    # pylint: enable=C0103
-
-    def field(self, key):
-        """Fake field from wizard"""
-        return self.properties['field_%s' % key]
-
-    def next(self):
-        """Fake next method to move to to next page in the wizard."""
-        self.view.properties['wizard_next'] = True
-
-    def emit(self, name, email):
-        """Fake emit."""
-        self.properties['emit'] = (name, email)
-
-
-class FakeGenericView(object):
-
-    """Fake Generic page."""
-
-    def __init__(self):
-        """Initialize object."""
-        self.properties = {}
-        self.ui = self
-        self.header = self
-        self.properties['currentId'] = -1
-        self.next = 0
-        self.fake_wizard = FakeWizard(self)
-
-    def set_title(self, title):
-        """Fake set_title for the page."""
-        self.properties['title'] = title
-
-    def set_subtitle(self, subtitle):
-        """Fake set_subtitle for the page"""
-        self.properties['subtitle'] = subtitle
-
-    # pylint: disable=C0103
-    def setTitle(self, title):
-        """Fake setTitle."""
-        self.set_title(title)
-
-    def setSubTitle(self, subtitle):
-        """Fake setTitle."""
-        self.set_subtitle(subtitle)
-    # pylint: enable=C0103
-
-    def wizard(self):
-        """Fake wizard is returned."""
-        return self.fake_wizard
-
-
-class FakeChooseSignInView(FakeGenericView):
-
-    """Fake ChooseSignIn page."""
-
-    def __init__(self):
-        """Initialize object."""
-        super(FakeChooseSignInView, self).__init__()
-        self.existing_account_button = FakeButton()
-        self.setup_account_button = FakeButton()
-
-
-class FakeCurrentUserView(FakeGenericView):
-
-    """Fake Current User view."""
-
-    def __init__(self):
-        super(FakeCurrentUserView, self).__init__()
-        self.email_label = QLabel()
-        self.password_label = QLabel()
-        self.forgot_password_label = QLabel()
-        self.sign_in_button = FakeButton()
-        self.email_edit = QLineEdit()
-        self.password_edit = QLineEdit()
-        self.on_logged_in_cb = None
-        self.on_login_error_cb = None
-
-    def fake_backend(self):
-        """Fake get_backend."""
-        return self
-
-    def login(self, appname, email, password):
-        """Fake backend login."""
-        self.properties['backend_login'] = (appname, email, password)
-        return self
-
-    # pylint: disable=C0103
-    def addErrback(self, function):
-        """Fake defer addErrback."""
-        self.properties['login-addErrback'] = function
-    # pylint: enable=C0103
-
-
-class FakeLineEdit(object):
-
-    """A fake QLineEdit."""
-
-    def __init__(self, *args):
-        """Initialize."""
-        self._text = u""
-
-    def text(self):
-        """Save text."""
-        return self._text
-
-    # setText is inherited
-    # pylint: disable=C0103
-    def setText(self, text):
-        """Return saved text."""
-        self._text = text
-
-
-class FakePage(object):
-
-    """A fake wizard page."""
-
-    app_name = "APP"
-
-    def wizard(self):
-        """Fake wizard."""
-        return self
-
-
-class FakeCurrentUserPage(FakePageUiStyle):
-
-    """Fake CurrentuserPage."""
-
-    def __init__(self, *args):
-        """Initialize."""
-        super(FakeCurrentUserPage, self).__init__(*args)
-        self.ui.email_edit = FakeLineEdit()
-        self.ui.password_edit = FakeLineEdit()
-        self.sign_in_button = self
-
-
-class FakeSetupAccountPageView(FakeGenericView):
-
-    """Fake SetupAccount view."""
-
-    def __init__(self):
-        super(FakeSetupAccountPageView, self).__init__()
-        self.ui = self
-        # Labels
-        self.name_label = QLabel()
-        self.email_label = QLabel()
-        self.confirm_email_label = QLabel()
-        self.password_label = QLabel()
-        self.confirm_password_label = QLabel()
-        self.password_info_label = QLabel()
-        self.refresh_label = QLabel()
-        self.name_assistance = QLabel()
-        self.email_assistance = QLabel()
-        self.confirm_email_assistance = QLabel()
-        # Line Edits
-        self.captcha_solution_edit = QLineEdit()
-        self.name_edit = QLineEdit()
-        self.email_edit = QLineEdit()
-        self.confirm_email_edit = QLineEdit()
-        self.password_edit = QLineEdit()
-        self.confirm_password_edit = QLineEdit()
-        self.captcha_solution_edit = QLineEdit()
-        # Check Box
-        self.terms_checkbox = QCheckBox()
-        # Setup Button
-        self.set_up_button = FakeButton()
-        # Backend
-        self.on_captcha_generated_cb = None
-        self.on_captcha_generation_error_cb = None
-        self.on_user_registered_cb = None
-        self.on_user_registration_error_cb = None
-
-    def fake_backend(self):
-        """Fake get_backend."""
-        return self
-
-    def set_line_edit_validation_rule(self, edit, function):
-        """Fake set_line_edit_validation_rule from view."""
-        elements = self.properties.get('validation_rule', None)
-        if elements is None:
-            elements = []
-        elements.append((edit, function))
-        self.properties['validation_rule'] = elements
-
-    # pylint: disable=C0103
-    def registerField(self, key, edit):
-        """Fake registerField from page."""
-        self.properties[key] = edit
-    # pylint: enable=C0103
-
-    def set_error_message(self, label, message):
-        """Fake set_error_message."""
-        label.setText(message)
-
-
-class FakeMessageBox(object):
-
-    """A fake message box."""
-
-    args = None
-    critical_args = None
-
-    def __init__(self, *args, **kwargs):
-        self.args = (args, kwargs)
-
-    def critical(self, *args, **kwargs):
-        """Fake critical popup."""
-        self.critical_args = (args, kwargs)
-
-
-class FakeSetupAccountUi(object):
-    """Fake ui variable for FakeView."""
-
-    email_assistance = None
-
-
-class FakeView(object):
-
-    """A fake view."""
-
-    app_name = "TestApp"
-    ui = FakeSetupAccountUi()
-
-    def wizard(self):
-        """Use itself as a fake wizard, too."""
-        return self
-
-    def set_error_message(self, label, msg):
-        """Simulate to add the message to the label as SetupAccount do."""
-
-
-class FakeSetupAccountView(FakeView):
-
-    """A Fake view."""
-
-    captcha_file = None
-    captcha_image = None
-    captcha_refresh_executed = False
-    captcha_refreshing_value = False
-
-    def on_captcha_refresh_complete(self):
-        """Fake the call to refresh finished."""
-        self.captcha_refresh_executed = True
-
-    def on_captcha_refreshing(self):
-        """Fake the call to refreshing."""
-        self.captcha_refreshing_value = True
-
-    def fake_open(self, filename):
-        """Fake open for Image."""
-        return self
-
-    # pylint: disable=W0622
-    def save(self, io, format):
-        """Fake save for Image."""
-    # pylint: enable=W0622
-
-
-class FakeControllerForCaptcha(object):
-
-    """Fake controller to test refresh_captcha method."""
-
-    def __init__(self):
-        """Initialize FakeControllerForCaptcha."""
-        self.callback_error = False
-
-    def generate_captcha(self, *args):
-        """Fake generate deferred for captcha."""
-        return self
-
-    # pylint: disable=C0103
-    def addErrback(self, call):
-        """Fake addErrback."""
-        self.callback_error = call is not None
-    # pylint: enable=C0103
-
-
-class FakeEmailVerificationView(FakePageUiStyle):
-    """Fake EmailVerification Page."""
-
-    def __init__(self, *args):
-        """Initialize."""
-        super(FakeEmailVerificationView, self).__init__(*args)
-        self.verification_code = ''
-        self.next_button = self
-
-
-class EmailVerificationView(FakeGenericView):
-
-    """Fake Email Verification view."""
-
-    def __init__(self):
-        super(EmailVerificationView, self).__init__()
-        self.ui = self
-        # Line Edits
-        self.verification_code_edit = QLineEdit()
-        self.verification_code = ''
-        # Setup Button
-        self.next_button = FakeButton()
-        # Backend
-        self.on_email_validated_cb = None
-        self.on_email_validation_error_cb = None
-
-    def fake_backend(self):
-        """Fake get_backend."""
-        return self
-
-    def validate_email(self, *args, **kwargs):
-        """Fake validate_email method from backend"""
-        self.properties['validate_email'] = (args, kwargs)
-
-
-class ErrorPageView(FakeGenericView):
-
-    """Fake Error Page view."""
-
-    def __init__(self):
-        super(ErrorPageView, self).__init__()
-        self.ui = self
-        self.error_message_label = QLabel()
-
-
-class SuccessPageView(FakeGenericView):
-
-    """Fake Success Page view."""
-
-    def __init__(self):
-        super(SuccessPageView, self).__init__()
-        self.ui = self
-        self.success_message_body = QLabel()
-
-
-class UbuntuSSOView(object):
-
-    """Fake view for UbuntuSSO."""
-
-    success_page_id = 5
-    error_page_id = 6
-
-    def __init__(self):
-        self.properties = {}
-        self.ui = self
-        self.app_name = 'app_name'
-        self.success_message_label = QLabel()
-        self.result = 0
-        # pylint: disable=C0103
-        self.loginSuccess = FakeButton()
-        self.registrationSuccess = FakeButton()
-        # pylint: enable=C0103
-        self.page = FakeGenericView()
-
-    def button(self, *args):
-        """Fake button."""
-        self.properties['button_method'] = args
-        self.properties['button'] = FakeButton()
-        return self.properties['button']
-
-    def callback(self, *args, **kwargs):
-        """Fake callback."""
-        self.properties['callback'] = (args, kwargs)
-        return self.result
-
-    def close(self):
-        """Fake close."""
-        self.properties['close'] = True
-
-    # pylint: disable=C0103
-    def setButtonLayout(self, layout):
-        """Fake setButtonLayout."""
-        self.properties['buttons_layout'] = layout
-
-    def currentPage(self):
-        """Fake currentPage."""
-        return self.page
-
-    def setWizardStyle(self, style):
-        """Fake setWizardStyle."""
-        self.properties['wizard_style'] = style
-    # pylint: enable=C0103
-
-    def next(self):
-        """Fake next method to move to to next page in the wizard."""
-        self.properties['wizard_next'] = True
-
-
-class FakeLineEditForForgottenPage(object):
-
-    """Fake Line Edit"""
-
-    def __init__(self):
-        """Initilize object."""
-        self.email_text = QString()
-
-    def text(self):
-        """Fake text for QLineEdit."""
-        return self.email_text
-
-    # setText is inherited
-    # pylint: disable=C0103
-    def setText(self, text):
-        """Fake setText for QLineEdit."""
-        self.email_text = QString(text)
-    # pylint: enable=C0103
-
-
-class FakeForgottenPasswordPage(FakePageUiStyle):
-    """Fake the page."""
-
-    def __init__(self):
-        super(FakeForgottenPasswordPage, self).__init__()
-        self.email_address_line_edit = self
-        self.send_button = self
-        self.email_widget = FakePageUiStyle()
-        self.forgotted_password_intro_label = FakePageUiStyle()
-        self.try_again_widget = FakePageUiStyle()
-        self.email_line_edit = FakeLineEditForForgottenPage()
-
-    def fake_backend(self):
-        """Fake get_backend."""
-        return self
-
-
-class FakeForgottenPasswordPageView(FakeGenericView):
-    """Fake the page."""
-
-    def __init__(self):
-        super(FakeForgottenPasswordPageView, self).__init__()
-        self.email_address_line_edit = QLineEdit()
-        self.send_button = FakeButton()
-        self.try_again_button = FakeButton()
-        self.email_widget = FakePageUiStyle()
-        self.forgotted_password_intro_label = QLabel()
-        self.email_address_label = QLabel()
-        self.try_again_widget = FakePageUiStyle()
-        self.email_line_edit = QLineEdit()
-        # Backend
-        self.on_password_reset_error_cb = None
-        self.on_password_reset_token_sent_cb = None
-
-    def fake_backend(self):
-        """Fake get_backend."""
-        return self
-
-    # pylint: disable=C0103
-    def registerField(self, key, item):
-        """Fake registerField from wizard."""
-        self.properties['field_%s' % key] = item
-    # pylint: enable=C0103
-
-    def field(self, key):
-        """Fake field from wizard"""
-        return self.properties['field_%s' % key]
-
-    def set_line_edit_validation_rule(self, edit, function):
-        """Fake set_line_edit_validation_rule from view."""
-        elements = self.properties.get('validation_rule', None)
-        if elements is None:
-            elements = []
-        elements.append((edit, function))
-        self.properties['validation_rule'] = elements
-
-
-class ResetPasswordPageView(FakeGenericView):
-    """Fake the page."""
-
-    def __init__(self):
-        super(ResetPasswordPageView, self).__init__()
-        self.reset_password_button = FakeButton()
-        self.reset_code_line_edit = QLineEdit()
-        self.password_line_edit = QLineEdit()
-        self.confirm_password_line_edit = QLineEdit()
-        # Backend
-        self.on_password_changed_cb = None
-        self.on_password_change_error_cb = None
-
-    def fake_backend(self):
-        """Fake get_backend."""
-        return self
-
-    # pylint: disable=C0103
-    def registerField(self, key, item):
-        """Fake registerField from wizard."""
-        self.properties['field_%s' % key] = item
-    # pylint: enable=C0103
-
-    def field(self, key):
-        """Fake field from wizard"""
-        return self.properties['field_%s' % key]
-
-    def set_line_edit_validation_rule(self, edit, function):
-        """Fake set_line_edit_validation_rule from view."""
-        elements = self.properties.get('validation_rule', None)
-        if elements is None:
-            elements = []
-        elements.append((edit, function))
-        self.properties['validation_rule'] = elements
-
-    def set_new_password(self, *args, **kwargs):
-        """Fake set_new_password from backend."""
-        self.properties['backend_new_password'] = (args, kwargs)
-
-
-class FakeResetPasswordPage(FakePageUiStyle):
-
-    """Fake ResetPasswordPage."""
-
-    def __init__(self, *args):
-        """Initialize."""
-        super(FakeResetPasswordPage, self).__init__()
-        self.ui.reset_code_line_edit = FakeLineEdit()
-        self.ui.password_line_edit = FakeLineEdit()
-        self.ui.confirm_password_line_edit = FakeLineEdit()
-        self.reset_password_button = self
-        self._enabled = 9  # Intentionally wrong.
-
-
-class FakeWizardForResetPassword(object):
-
-    """Fake Wizard for ResetPasswordController."""
-
-    def __init__(self):
-        self.current_user = self
-        self.ui = self
-        self.email_edit = self
-        self.email_line_edit = self
-        self.forgotten = self
-        self.overlay = self
-        self.count_back = 0
-        self.hide_value = False
-        self.text_value = '[e-mail]'
-        self.current_user_page_id = 4
-
-    def wizard(self):
-        """Fake wizard function for view."""
-        return self
-
-    def back(self):
-        """Fake back for wizard."""
-        self.count_back += 1
-
-    def hide(self):
-        """Fake hide for overlay."""
-        self.hide_value = True
-
-    def text(self):
-        """Fake text for QLineEdit."""
-        return self.text_value
-
-    # pylint: disable=C0103
-    def setText(self, text):
-        """Fake setText for QLineEdit."""
-        self.text_value = text
-
-    def visitedPages(self):
-        """Return an int list of fake visited pages."""
-        return [1, 4, 6, 8]
-    # pylint: enable=C0103
-
-
-class BackendControllerTestCase(BaseTestCase):
-    """The test case for the BackendController."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(BackendControllerTestCase, self).setUp()
-        self.backend = BackendController()
-
-    @defer.inlineCallbacks
-    def test_get_backend(self):
-        """The backend is properly retrieved."""
-        result = yield self.backend.get_backend()
-        self.assertTrue(self.sso_login_backend is result)
-
-
-class ChooseSignInControllerTestCase(BaseTestCase):
-    """Test the choose sign in controller."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set tests."""
-        yield super(ChooseSignInControllerTestCase, self).setUp()
-        self.title = 'title'
-        self.subtitle = 'subtitle'
-        self.controller = ChooseSignInController(self.title, self.subtitle)
-        self.view = FakeChooseSignInView()
-        self.controller.view = self.view
-
-    def test_setup_ui(self):
-        """Test the set up of the ui."""
-        self.controller.setupUi(self.view)
-        self.assertEqual(self.view.properties['title'], self.title)
-        self.assertEqual(self.view.properties['subtitle'], self.subtitle)
-        self.assertEqual(self.view.existing_account_button.text(),
-            EXISTING_ACCOUNT_CHOICE_BUTTON)
-        self.assertEqual(self.view.setup_account_button.text(),
-            SET_UP_ACCOUNT_CHOICE_BUTTON)
-        self.assertIsInstance(self.view.existing_account_button.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.setup_account_button.function,
-            collections.Callable)
-
-    def test_set_up_translated_strings(self):
-        """Ensure that the translations are used."""
-        self.controller._set_up_translated_strings()
-        self.assertEqual(self.view.existing_account_button.text(),
-            EXISTING_ACCOUNT_CHOICE_BUTTON)
-        self.assertEqual(self.view.setup_account_button.text(),
-            SET_UP_ACCOUNT_CHOICE_BUTTON)
-
-    def test_connect_buttons(self):
-        """Ensure that all the buttons are correcly connected."""
-        self.controller._connect_buttons()
-        self.assertIsInstance(self.view.existing_account_button.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.setup_account_button.function,
-            collections.Callable)
-
-    def test_set_next_existing(self):
-        """Test the execution of the callback."""
-        self.controller._set_next_existing()
-        self.assertEqual(self.view.next,
-            self.view.fake_wizard.current_user_page_id)
-
-    def test_set_next_new(self):
-        """Test the execution of the callback."""
-        self.controller._set_next_new()
-        self.assertEqual(self.view.next,
-            self.view.fake_wizard.setup_account_page_id)
-
-
-class CurrentUserControllerTestCase(BaseTestCase):
-    """Test the current user controller."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup tests."""
-        yield super(CurrentUserControllerTestCase, self).setUp()
-        self.controller = CurrentUserController(title='the title',
-            subtitle='the subtitle')
-        self.view = FakeCurrentUserView()
-        self.controller.view = self.view
-        self.patch(self.controller, "get_backend", self.view.fake_backend)
-        self.controller.setupUi(self.view)
-
-    def test_translated_strings(self):
-        """test that the ui is correctly set up."""
-        self.controller._set_translated_strings()
-        self.assertEqual(self.view.email_label.text(), EMAIL_LABEL)
-        self.assertEqual(self.view.password_label.text(), LOGIN_PASSWORD_LABEL)
-        self.assertEqual(self.view.forgot_password_label.text(),
-            FORGOTTEN_PASSWORD_BUTTON)
-        self.assertEqual(self.view.sign_in_button.text(), SIGN_IN_BUTTON)
-
-    def test_connect_ui(self):
-        """test that the ui is correctly set up."""
-        self.controller._connect_ui()
-        self.assertIsInstance(self.view.sign_in_button.function,
-            collections.Callable)
-        # Check if receivers is 2 because _connect_ui was called on setUp
-        self.assertEqual(self.view.forgot_password_label.receivers(
-            SIGNAL('linkActivated(QString)')), 2)
-        self.assertEqual(self.view.email_edit.receivers(
-            SIGNAL('textChanged(QString)')), 2)
-        self.assertEqual(self.view.password_edit.receivers(
-            SIGNAL('textChanged(QString)')), 2)
-        self.assertFalse(self.view.on_login_error_cb is None)
-        self.assertFalse(self.view.on_logged_in_cb is None)
-
-    def test_title_subtitle(self):
-        """Ensure we are storing the title and subtitle correctly."""
-        self.assertEqual(self.view.properties['title'], 'the title')
-        self.assertEqual(self.view.properties['subtitle'], 'the subtitle')
-
-    def test_on_logged_in(self):
-        """Test on_logged_in method."""
-        self.view.email_edit.setText('[e-mail]')
-        self.controller.on_logged_in('app-name', {})
-        self.assertEqual(self.view.fake_wizard.properties['emit'],
-            ('app-name', '[e-mail]'))
-
-    def test_login(self):
-        """Test login method."""
-        email = '[e-mail]'
-        password = 'password'
-        self.view.email_edit.setText(email)
-        self.view.password_edit.setText(password)
-        self.controller.login()
-        self.assertEqual(self.view.properties['backend_login'],
-            (self.view.fake_wizard.app_name, email, password))
-        self.assertIsInstance(self.view.properties['login-addErrback'],
-            collections.Callable)
-
-    def test_on_forgotten_password(self):
-        """Test on_forgotten_password flow."""
-        email = '[e-mail]'
-        self.view.email_edit.setText(email)
-        self.controller.on_forgotten_password()
-        self.assertEqual(self.view.next,
-            self.view.fake_wizard.forgotten_password_page_id)
-        self.assertTrue(self.view.properties['wizard_next'])
-
-    def test_setup_ui(self):
-        """Test the set up of the ui."""
-        self.controller._title = 'title_setup'
-        self.controller._subtitle = 'subtitle_setup'
-        self.controller.setupUi(self.view)
-        self.assertEqual(self.view.properties['title'], 'title_setup')
-        self.assertEqual(self.view.properties['subtitle'], 'subtitle_setup')
-        self.assertIsInstance(self.view.sign_in_button.function,
-            collections.Callable)
-        # Check if receivers is 2 because _connect_ui was called on setUp
-        self.assertEqual(self.view.forgot_password_label.receivers(
-            SIGNAL('linkActivated(QString)')), 2)
-        self.assertEqual(self.view.email_edit.receivers(
-            SIGNAL('textChanged(QString)')), 2)
-        self.assertEqual(self.view.password_edit.receivers(
-            SIGNAL('textChanged(QString)')), 2)
-        self.assertFalse(self.view.on_login_error_cb is None)
-        self.assertFalse(self.view.on_logged_in_cb is None)
-        self.assertEqual(self.view.email_label.text(), EMAIL_LABEL)
-        self.assertEqual(self.view.password_label.text(), LOGIN_PASSWORD_LABEL)
-        self.assertEqual(self.view.forgot_password_label.text(),
-            FORGOTTEN_PASSWORD_BUTTON)
-        self.assertEqual(self.view.sign_in_button.text(), SIGN_IN_BUTTON)
-
-
-class CurrentUserControllerErrorTestCase(BaseTestCase):
-
-    """Tests for CurrentUserController's error handler."""
-
-    on_error_method_name = "on_login_error"
-    controller_class = CurrentUserController
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup test."""
-        yield super(CurrentUserControllerErrorTestCase, self).setUp()
-        self.message_box = FakeMessageBox()
-        self.controller = self.controller_class(
-            message_box=self.message_box)
-        self.controller.view = FakePage()
-        self.on_error_method = getattr(
-            self.controller, self.on_error_method_name)
-
-    def test_error_message_key(self):
-        """Test that on_login_error reacts to errors with "error_message"."""
-        self.on_error_method({"error_message": "WORRY!"})
-        self.assertEqual(self.message_box.critical_args, (('WORRY!',
-            self.controller.view), {}))
-
-    def test_message_key(self):
-        """Test that on_login_error reacts to errors with "message"."""
-        self.on_error_method({"message": "WORRY!"})
-        self.assertEqual(self.message_box.critical_args, (('WORRY!',
-            self.controller.view), {}))
-
-    def test_broken_error(self):
-        """Test that on_login_error reacts to broken errors."""
-        self.on_error_method({"boo!": "WORRY!"})
-        result = '\n'.join(
-                [('%s: %s' % (k, v)) for k, v in \
-                {"boo!": "WORRY!"}.iteritems()])
-        self.assertEqual(self.message_box.critical_args,
-            ((result, self.controller.view), {}))
-
-    def test_all_and_message(self):
-        """Test that on_login_error reacts to broken errors."""
-        self.on_error_method(
-            {"message": "WORRY!", "__all__": "MORE!"})
-        self.assertEqual(self.message_box.critical_args,
-            (('MORE!\nWORRY!', self.controller.view), {}))
-
-    def test_all_and_error_message(self):
-        """Test that on_login_error reacts to broken errors."""
-        self.on_error_method(
-            {"error_message": "WORRY!", "__all__": "MORE!"})
-        self.assertEqual(self.message_box.critical_args,
-            (('MORE!\nWORRY!', self.controller.view), {}))
-
-    def test_only_all(self):
-        """Test that on_login_error reacts to broken errors."""
-        self.on_error_method(
-            {"__all__": "MORE!"})
-        self.assertEqual(self.message_box.critical_args,
-            (('MORE!', self.controller.view), {}))
-
-
-class EmailVerificationControllerErrorTestCase(
-    CurrentUserControllerErrorTestCase):
-
-    """Tests for EmailVerificationController's error handler."""
-
-    on_error_method_name = "on_email_validation_error"
-    controller_class = EmailVerificationController
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup test."""
-        yield super(EmailVerificationControllerErrorTestCase, self).setUp()
-        # This error handler takes one extra argument.
-        self.on_error_method = lambda error: getattr(
-            self.controller, self.on_error_method_name)('APP', error)
-
-
-class SetUpAccountControllerErrorTestCase(
-    EmailVerificationControllerErrorTestCase):
-
-    """Tests for SetUpAccountController's error handler."""
-
-    on_error_method_name = "on_user_registration_error"
-    controller_class = SetUpAccountController
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup test."""
-        yield super(SetUpAccountControllerErrorTestCase, self).setUp()
-        self.patch(self.controller, "_refresh_captcha", lambda *args: None)
-
-
-class ResetPasswordControllerErrorTestCase(
-    EmailVerificationControllerErrorTestCase):
-
-    """Tests for ResetPasswordController's error handler."""
-
-    on_error_method_name = "on_password_change_error"
-    controller_class = ResetPasswordController
-
-
-class CurrentUserControllerValidationTest(BaseTestCase):
-
-    """Tests for CurrentUserController, but without Mocker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup test."""
-        yield super(CurrentUserControllerValidationTest, self).setUp()
-        self.message_box = FakeMessageBox()
-        self.controller = CurrentUserController(
-            message_box=self.message_box)
-        self.controller.view = FakeCurrentUserPage()
-
-    def test_valid(self):
-        """Enable the button with a valid email/password."""
-        self.controller.view.email_edit.setText("a@b")
-        self.controller.view.password_edit.setText("pass")
-        self.controller._validate()
-        self.assertTrue(self.controller.view.sign_in_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.sign_in_button.enabled())
-
-    def test_invalid_email(self):
-        """The submit button should be disabled with an invalid email."""
-        self.controller.view.email_edit.setText("ab")
-        self.controller.view.password_edit.setText("pass")
-        self.controller._validate()
-        self.assertFalse(self.controller.view.sign_in_button.enabled())
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.sign_in_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-
-    def test_invalid_password(self):
-        """The submit button should be disabled with an invalid password."""
-        self.controller.view.email_edit.setText("a@b")
-        self.controller.view.password_edit.setText("")
-        self.controller._validate()
-        self.assertFalse(self.controller.view.sign_in_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.sign_in_button.enabled())
-
-    def test_invalid_both(self):
-        """The submit button should be disabled with invalid data."""
-        self.controller.view.email_edit.setText("ab")
-        self.controller.view.password_edit.setText("")
-        self.controller._validate()
-        self.assertFalse(self.controller.view.sign_in_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.sign_in_button.enabled())
-
-
-class SetUpAccountControllerTestCase(BaseTestCase):
-    """test the controller used to setup a new account."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the different tests."""
-        yield super(SetUpAccountControllerTestCase, self).setUp()
-        self.view = FakeSetupAccountPageView()
-        self.message_box = FakeMessageBox()
-        self.controller = SetUpAccountController(message_box=self.message_box)
-        self.patch(self.controller, "get_backend", self.view.fake_backend)
-        self.controller.view = self.view
-        self.controller.backend = self.view
-
-    def test_set_translated_strings(self):
-        """Ensure all the strings are set."""
-        self.controller._set_translated_strings()
-        self.assertEqual(self.view.name_label.text(), NAME_ENTRY)
-        self.assertEqual(self.view.email_label.text(), EMAIL1_ENTRY)
-        self.assertEqual(self.view.confirm_email_label.text(), EMAIL2_ENTRY)
-        self.assertEqual(self.view.password_label.text(), PASSWORD1_ENTRY)
-        self.assertEqual(self.view.confirm_password_label.text(),
-            PASSWORD2_ENTRY)
-        self.assertEqual(self.view.password_info_label.text(), PASSWORD_HELP)
-        self.assertEqual(self.view.captcha_solution_edit.placeholderText(),
-            CAPTCHA_SOLUTION_ENTRY)
-
-    def test_set_titles(self):
-        """Test how the different titles are set."""
-        self.controller._set_titles()
-        self.assertEqual(self.view.properties['title'],
-            JOIN_HEADER_LABEL % {'app_name': self.view.fake_wizard.app_name})
-        self.assertEqual(self.view.properties['subtitle'],
-            self.view.fake_wizard.help_text)
-
-    def test_connect_ui_elements(self):
-        """Test that the ui elements are correctly connect."""
-        self.controller._connect_ui_elements()
-        self.assertEqual(self.view.name_edit.receivers(
-            SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.view.email_edit.receivers(
-            SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.view.confirm_email_edit.receivers(
-            SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.view.password_edit.receivers(
-            SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.view.confirm_password_edit.receivers(
-            SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.view.captcha_solution_edit.receivers(
-            SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.view.refresh_label.receivers(
-            SIGNAL('linkActivated(QString)')), 1)
-        self.assertEqual(self.view.terms_checkbox.receivers(
-            SIGNAL('stateChanged(int)')), 1)
-        # set the callbacks for the captcha generation
-        self.assertIsInstance(self.view.on_captcha_generated_cb,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_captcha_generation_error_cb,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_user_registration_error_cb,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_user_registered_cb,
-            collections.Callable)
-
-    def test_set_line_edits_validations(self):
-        """Test _set_line_validations from controller."""
-        self.controller._set_line_edits_validations()
-        elements = self.view.properties['validation_rule']
-        self.assertFalse(elements is None)
-        for e in elements:
-            self.assertTrue(type(e[0]) is QLineEdit)
-            self.assertIsInstance(e[1], collections.Callable)
-
-    def all_valid(self):
-        """Set all the widgets to a valid state."""
-        self.view.name_edit.setText('Name')
-        self.view.email_edit.setText('[e-mail]')
-        self.view.confirm_email_edit.setText('[e-mail]')
-        self.view.password_edit.setText('T3st3rqw')
-        self.view.confirm_password_edit.setText('T3st3rqw')
-        self.view.captcha_solution_edit.setText('captcha solution')
-        self.view.terms_checkbox.setChecked(True)
-
-    def all_invalid(self):
-        """Set all the widgets to an invalid state."""
-        self.view.name_edit.setText('')
-        self.view.email_edit.setText('')
-        self.view.confirm_email_edit.setText('email')
-        self.view.password_edit.setText('')
-        self.view.confirm_password_edit.setText('t')
-        self.view.captcha_solution_edit.setText('')
-        self.view.terms_checkbox.setChecked(False)
-
-    def test_enable_setup_button_only_checkbox_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.terms_checkbox.setChecked(True)
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_name_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.name_edit.setText('Name')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_email_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.email_edit.setText('[e-mail]')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_confirm_email_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.confirm_email_edit.setText('[e-mail]')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_email_and_confirm_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.email_edit.setText('[e-mail]')
-        self.view.confirm_email_edit.setText('[e-mail]')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_password_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.password_edit.setText('T3st3rqw')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_password_confirm_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.confirm_password_edit.setText('T3st3rqw')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_password_and_confirm_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.password_edit.setText('T3st3rqw')
-        self.view.confirm_password_edit.setText('T3st3rqw')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_captcha_ok(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.view.captcha_solution_edit.setText('captcha solution')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_only_all_ok(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.controller._enable_setup_button()
-
-        self.assertTrue(self.view.set_up_button.enabled())
-        self.assertFalse(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_all_wrong(self):
-        """Test enable button only name valid."""
-        self.all_invalid()
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_name_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.name_edit.setText('')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_email_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.email_edit.setText('')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_confirm_email_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.confirm_email_edit.setText('')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_password_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.password_edit.setText('')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_confirm_password_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.confirm_password_edit.setText('')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_captcha_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.captcha_solution_edit.setText('')
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_enable_setup_button_checkbox_wrong(self):
-        """Test enable button only name valid."""
-        self.all_valid()
-        self.view.terms_checkbox.setChecked(False)
-        self.controller._enable_setup_button()
-
-        self.assertFalse(self.view.set_up_button.enabled())
-        self.assertTrue(self.view.set_up_button.property('DisabledState'))
-        self.assertTrue(self.view.set_up_button.properties['polish'])
-        self.assertTrue(self.view.set_up_button.properties['unpolish'])
-
-    def test_register_fields(self):
-        """Test _register_fields."""
-        self.controller._register_fields()
-        self.assertTrue('email_address' in self.view.properties)
-        self.assertTrue('password' in self.view.properties)
-        self.assertTrue(type(self.view.properties['email_address']) is \
-            QLineEdit)
-        self.assertTrue(type(self.view.properties['password']) is \
-            QLineEdit)
-
-    def test_validate_form_all_ok(self):
-        """Test the result of validate_form."""
-        self.all_valid()
-        self.assertTrue(self.controller.validate_form())
-        self.assertNotEqual(self.view.name_assistance.text(), NAME_INVALID)
-        self.assertNotEqual(self.view.email_assistance.text(), EMAIL_INVALID)
-        self.assertNotEqual(self.view.confirm_email_assistance.text(),
-            EMAIL_MISMATCH)
-        messages = '\n'.join([PASSWORD_TOO_WEAK, PASSWORD_MISMATCH,
-            CAPTCHA_REQUIRED_ERROR])
-        self.assertNotEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_all_wrong(self):
-        """Test the result of validate_form."""
-        self.all_invalid()
-        self.assertFalse(self.controller.validate_form())
-        self.assertEqual(self.view.name_assistance.text(), NAME_INVALID)
-        self.assertEqual(self.view.email_assistance.text(), EMAIL_INVALID)
-        self.assertEqual(self.view.confirm_email_assistance.text(),
-            EMAIL_MISMATCH)
-        messages = '\n'.join([PASSWORD_TOO_WEAK, PASSWORD_MISMATCH,
-            CAPTCHA_REQUIRED_ERROR])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_name_ok(self):
-        """Test the result of validate_form."""
-        self.all_invalid()
-        self.view.name_edit.setText('Name')
-        self.assertFalse(self.controller.validate_form())
-        self.assertEqual(self.view.email_assistance.text(), EMAIL_INVALID)
-        self.assertEqual(self.view.confirm_email_assistance.text(),
-            EMAIL_MISMATCH)
-        messages = '\n'.join([PASSWORD_TOO_WEAK, PASSWORD_MISMATCH,
-            CAPTCHA_REQUIRED_ERROR])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_email_ok(self):
-        """Test the result of validate_form."""
-        self.all_invalid()
-        self.view.email_edit.setText('[e-mail]')
-        self.assertFalse(self.controller.validate_form())
-        self.assertEqual(self.view.name_assistance.text(), NAME_INVALID)
-        self.assertEqual(self.view.confirm_email_assistance.text(),
-            EMAIL_MISMATCH)
-        messages = '\n'.join([PASSWORD_TOO_WEAK, PASSWORD_MISMATCH,
-            CAPTCHA_REQUIRED_ERROR])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_confirm_email_ok(self):
-        """Test the result of validate_form."""
-        self.all_invalid()
-        self.view.email_edit.setText('[e-mail]')
-        self.view.confirm_email_edit.setText('[e-mail]')
-        self.assertFalse(self.controller.validate_form())
-        self.assertEqual(self.view.name_assistance.text(), NAME_INVALID)
-        messages = '\n'.join([PASSWORD_TOO_WEAK, PASSWORD_MISMATCH,
-            CAPTCHA_REQUIRED_ERROR])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_password_weak(self):
-        """Test the result of validate_form."""
-        self.all_valid()
-        self.view.password_edit.setText('Test')
-        self.view.confirm_password_edit.setText('Test')
-        self.assertFalse(self.controller.validate_form())
-        messages = '\n'.join([PASSWORD_TOO_WEAK])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_password_mismatch(self):
-        """Test the result of validate_form."""
-        self.all_valid()
-        self.view.password_edit.setText('T3st3rqw')
-        self.view.confirm_password_edit.setText('test')
-        self.assertFalse(self.controller.validate_form())
-        messages = '\n'.join([PASSWORD_MISMATCH])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_validate_form_captcha_required(self):
-        """Test the result of validate_form."""
-        self.all_valid()
-        self.view.captcha_solution_edit.setText('')
-        self.assertFalse(self.controller.validate_form())
-        messages = '\n'.join([CAPTCHA_REQUIRED_ERROR])
-        self.assertEqual(self.message_box.critical_args,
-            ((messages, self.view), {}))
-
-    def test_is_correct_email(self):
-        """Test if the email is correct."""
-        self.assertTrue(self.controller.is_correct_email('email@'))
-        self.assertFalse(self.controller.is_correct_email('email'))
-
-    def test_is_correct_email_confirmation(self):
-        """Test if the email confirmation is correct."""
-        self.view.email_edit.setText('[e-mail]')
-        self.controller.is_correct_email_confirmation('[e-mail]')
-
-    def test_is_correct_password_confirmation(self):
-        """Test is_correct_password_confirmation method."""
-        self.view.password_edit.setText('T3st3rqw')
-        self.controller.is_correct_password_confirmation('T3st3rqw')
-
-
-class SetupAccountControllerCaptchaTest(BaseTestCase):
-    """Tests for SetupAccountController, but without Mocker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the different tests."""
-        yield super(SetupAccountControllerCaptchaTest, self).setUp()
-        self.message_box = FakeMessageBox()
-        self.controller = SetUpAccountController(message_box=self.message_box)
-        self.patch(self.controller, 'view', FakeSetupAccountView())
-        self.fake_backend = FakeControllerForCaptcha()
-        self.patch(self.controller, 'backend', self.fake_backend)
-
-    def test_refresh_captcha(self):
-        """Test the Refresh Captcha function."""
-        self.assertFalse(self.controller.view.captcha_refreshing_value)
-        self.controller._refresh_captcha()
-        self.assertTrue(self.controller.view.captcha_refreshing_value)
-        self.assertTrue(self.fake_backend.callback_error)
-
-
-class SetupAccountControllerValidationTest(BaseTestCase):
-    """Tests for SetupAccountController, but without Mocker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the different tests."""
-        yield super(SetupAccountControllerValidationTest, self).setUp()
-        self.message_box = FakeMessageBox()
-        self.controller = SetUpAccountController(message_box=self.message_box)
-        self.patch(self.controller, '_refresh_captcha', self._set_called)
-        self.patch(self.controller, 'view', FakeSetupAccountView())
-
-    def test_on_user_registration_refresh_captcha(self):
-        """If there is a user reg. error, captcha should refresh."""
-        self.controller.on_user_registration_error('TestApp', {})
-        self.assertEqual(self._called, ((), {}))
-
-    def test_on_user_registration_all_only(self):
-        """Pass only a __all__ error key."""
-        self.controller.on_user_registration_error('TestApp',
-            {'__all__': "Error in All"})
-        self.assertEqual(self.message_box.critical_args, ((
-            "Error in All", self.controller.view), {}))
-
-    def test_on_user_registration_all_fields(self):
-        """Pass all known error keys, plus unknown one."""
-        self.controller.on_user_registration_error('TestApp',
-            {'__all__': "Error in All",
-             'email': "Error in email",
-             'pasword': "Error in password",
-             'unknownfield': "Error in unknown",
-            })
-        self.assertEqual(self.message_box.critical_args, ((
-            "Error in All", self.controller.view), {}))
-
-    def test_registration_errors_without_message_or_all(self):
-        """Pass only a email error key."""
-        errdict = {'errtype': "RegistrationError",
-                   'email': "Error in email"}
-        self.controller.on_user_registration_error('TestApp', errdict)
-
-        expected = (('', self.controller.view), {})
-        self.assertEqual(self.message_box.critical_args, expected)
-
-    def test_on_captcha_generated(self):
-        """Test if the method that shows the overlay is executed."""
-        self.patch(Image, "open", self.controller.view.fake_open)
-        self.assertFalse(self.controller.view.captcha_refresh_executed)
-        self.controller.on_captcha_generated('app_name', 'captcha_id')
-        self.assertTrue(self.controller.view.captcha_refresh_executed)
-
-    def test_on_captcha_generation_error(self):
-        """Test if the method that hides the overlay is executed."""
-        self.assertFalse(self.controller.view.captcha_refresh_executed)
-        self.controller.on_captcha_generation_error({})
-        self.assertTrue(self.controller.view.captcha_refresh_executed)
-
-
-class EmailVerificationControllerTestCase(BaseTestCase):
-    """Test the controller."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set tests."""
-        yield super(EmailVerificationControllerTestCase, self).setUp()
-        self.view = EmailVerificationView()
-        self.backend = self.view
-        self.controller = EmailVerificationController(
-            message_box=FakeMessageBox())
-        self.controller.view = self.view
-        self.controller.backend = self.backend
-        self.patch(self.controller, "get_backend", self.view.fake_backend)
-        self.email = '[e-mail]'
-        self.password = 'T3st3rqw'
-        self.view.fake_wizard.registerField('email_address', self.email)
-        self.view.fake_wizard.registerField('password', self.password)
-
-    def test_connect_ui_elements(self):
-        """Set the ui connections."""
-        self.controller._connect_ui_elements()
-        self.assertEqual(self.view.verification_code_edit.receivers(
-            SIGNAL('textChanged(QString)')), 1)
-        self.assertIsInstance(self.view.next_button.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_email_validated_cb,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_email_validation_error_cb,
-            collections.Callable)
-
-    def test_set_titles(self):
-        """Test that the titles are set."""
-        self.controller.set_titles()
-        self.assertEqual(self.view.properties['title'], VERIFY_EMAIL_TITLE)
-        self.assertEqual(self.view.properties['subtitle'],
-            VERIFY_EMAIL_CONTENT % {
-            "app_name": self.view.fake_wizard.app_name,
-            "email": self.email,
-            })
-
-    def test_validate_email(self):
-        """Test the callback."""
-        code = 'qwe123'
-        self.view.verification_code_edit.setText(code)
-        self.controller.validate_email()
-        self.assertEqual(self.view.properties['validate_email'],
-            ((self.view.fake_wizard.app_name, self.email, self.password,
-            code), {}))
-
-    def test_validate_form(self):
-        """Test validate_form."""
-        self.view.verification_code = 'qwe123'
-        self.controller.validate_form()
-        self.assertTrue(self.view.next_button.enabled())
-        self.assertFalse(self.view.next_button.property('DisabledState'))
-        self.assertTrue(self.view.next_button.properties['polish'])
-        self.assertTrue(self.view.next_button.properties['unpolish'])
-
-        self.view.verification_code = ''
-        self.controller.validate_form()
-        self.assertFalse(self.view.next_button.enabled())
-        self.assertTrue(self.view.next_button.property('DisabledState'))
-        self.assertTrue(self.view.next_button.properties['polish'])
-        self.assertTrue(self.view.next_button.properties['unpolish'])
-
-    def test_page_initialized(self):
-        """test pageInitialized to check the initial state of the page."""
-        self.controller.pageInitialized()
-        self.assertTrue(self.view.next_button.properties['default'])
-        self.assertFalse(self.view.next_button.enabled())
-        self.assertTrue(self.view.next_button.property('DisabledState'))
-        self.assertTrue(self.view.next_button.properties['polish'])
-        self.assertTrue(self.view.next_button.properties['unpolish'])
-
-    def test_on_email_validation_error(self):
-        """Test on_email_validation_error."""
-        error = dict(error='email error')
-        self.controller.on_email_validation_error('app', error)
-        result = '\n'.join(
-                [('%s: %s' % (k, v)) for k, v in error.iteritems()])
-        self.assertEqual(self.controller.message_box.critical_args,
-            ((result, self.view), {}))
-
-    def test_on_email_validated(self):
-        """Test on_email_validated."""
-        self.controller.on_email_validated('app_name')
-        self.assertEqual(self.view.fake_wizard.properties['emit'],
-            ('app_name', self.email))
-
-
-class EmailVerificationControllerValidationTestCase(BaseTestCase):
-    """Tests for EmailVerificationController, but without Mocker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the different tests."""
-        yield super(EmailVerificationControllerValidationTestCase,
-            self).setUp()
-        self.message_box = FakeMessageBox()
-        self.controller = EmailVerificationController(
-            message_box=self.message_box)
-        self.patch(self.controller, 'view', FakeEmailVerificationView())
-
-    def test_on_email_validation_error(self):
-        """Test that on_email_validation_error callback works as expected."""
-        # Error type is removed from the final message
-        error = dict(errtype='BadTokenError')
-        app_name = 'app_name'
-        self.controller.on_email_validation_error(app_name, error)
-        self.assertEqual(self.message_box.critical_args,
-            (('', self.controller.view), {}))
-
-    def test_validate_form_wrong(self):
-        """Check the state of the next button."""
-        self.controller.view.verification_code = ''
-        self.controller.validate_form()
-        self.assertFalse(self.controller.view.next_button.isEnabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.next_button.enabled())
-
-    def test_validate_form_ok(self):
-        """Check the state of the next button."""
-        self.controller.view.verification_code = 'as322fdw'
-        self.controller.validate_form()
-        self.assertTrue(self.controller.view.next_button.isEnabled)
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.next_button.enabled())
-
-
-class ErrorControllerTestCase(BaseTestCase):
-    """Test the success page controller."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(ErrorControllerTestCase, self).setUp()
-        self.view = ErrorPageView()
-        self.backend = self.view
-        self.controller = ErrorController()
-        self.controller.view = self.view
-        self.controller.backend = self.backend
-
-    def test_set_ui(self):
-        """Test the process that sets the ui."""
-        self.controller._title = ERROR
-        self.controller._subtitle = ERROR
-        self.controller.setupUi(self.view)
-        self.assertEqual(self.view.error_message_label.text(), ERROR)
-        self.assertEqual(self.view.properties['title'], ERROR)
-        self.assertEqual(self.view.properties['subtitle'], ERROR)
-        self.assertEqual(self.view.next, -1)
-
-
-class SuccessControllerTestCase(BaseTestCase):
-    """Test the success page controller."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(SuccessControllerTestCase, self).setUp()
-        self.view = SuccessPageView()
-        self.backend = self.view
-        self.controller = SuccessController()
-        self.controller.view = self.view
-        self.controller.backend = self.backend
-
-    def test_set_ui(self):
-        """Test the process that sets the ui."""
-        self.controller._title = SUCCESS
-        self.controller._subtitle = SUCCESS
-        self.controller.setupUi(self.view)
-        self.assertEqual(self.view.properties['title'], SUCCESS)
-        self.assertEqual(self.view.properties['subtitle'], SUCCESS)
-        self.assertEqual(self.view.next, -1)
-
-
-class UbuntuSSOWizardControllerTestCase(BaseTestCase):
-    """Test the wizard controller."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set tests."""
-        yield super(UbuntuSSOWizardControllerTestCase, self).setUp()
-        self.view = UbuntuSSOView()
-        self.backend = self.view
-        self.callback = self.view.callback
-        self.controller = UbuntuSSOWizardController()
-        self.controller.view = self.view
-        self.controller.backend = self.backend
-
-    def test_on_user_cancelation(self):
-        """Test that the callback is indeed called."""
-        self.controller.user_cancellation_callback = self.callback
-        self.controller.on_user_cancelation()
-        self.assertTrue(self.view.properties.get('close', False))
-        self.assertEqual(self.view.properties['callback'],
-            ((self.view.app_name, ), {}))
-
-    def test_on_login_success(self):
-        """Test that the callback is indeed called."""
-        app_name = 'app'
-        email = 'email'
-        self.controller.login_success_callback = self.callback
-        self.controller.login_success_callback(app_name, email)
-        self.assertEqual(self.view.properties['callback'],
-            ((app_name, email), {}))
-
-    def test_on_registration_success(self):
-        """Test that the callback is indeed called."""
-        app_name = 'app'
-        email = 'email'
-        self.controller.registration_success_callback = self.callback
-        self.controller.registration_success_callback(app_name, email)
-        self.assertEqual(self.view.properties['callback'],
-            ((app_name, email), {}))
-
-    def test_show_success_message(self):
-        """Test that the correct page will be shown."""
-        self.controller.show_success_message()
-        # the buttons layout we expect to have
-        layout = []
-        layout.append(QWizard.Stretch)
-        layout.append(QWizard.FinishButton)
-
-        self.assertEqual(self.view.page.next, self.view.success_page_id)
-        self.assertTrue(self.view.properties['wizard_next'])
-        self.assertEqual(self.view.properties['buttons_layout'], layout)
-
-    def test_show_error_message(self):
-        """Test that the correct page will be shown."""
-        self.controller.show_error_message()
-        # the buttons layout we expect to have
-        layout = []
-        layout.append(QWizard.Stretch)
-        layout.append(QWizard.FinishButton)
-
-        self.assertEqual(self.view.page.next, self.view.error_page_id)
-        self.assertTrue(self.view.properties['wizard_next'])
-        self.assertEqual(self.view.properties['buttons_layout'], layout)
-
-    def test_setup_ui(self):
-        """Test that the ui is connect."""
-        self.controller.setupUi(self.view)
-        self.assertEqual(self.view.properties['wizard_style'],
-            QWizard.ModernStyle)
-        self.assertIsInstance(self.view.properties['button'].function,
-            collections.Callable)
-        self.assertIsInstance(self.view.loginSuccess.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.registrationSuccess.function,
-            collections.Callable)
-
-
-class ForgottenPasswordControllerValidationTest(BaseTestCase):
-
-    """Tests for ForgottenPasswordController, but without Mocker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set the different tests."""
-        yield super(ForgottenPasswordControllerValidationTest, self).setUp()
-        self.message_box = FakeMessageBox()
-        self.controller = ForgottenPasswordController(
-            message_box=self.message_box)
-        self.view = FakeForgottenPasswordPage()
-        self.controller.view = self.view
-        self.patch(self.controller, "get_backend", self.view.fake_backend)
-
-    def test_page_initialized(self):
-        """Test the initial state of the page when it is loaded."""
-        self.controller.pageInitialized()
-        self.assertFalse(self.controller.view.send_button.enabled())
-        self.assertTrue(self.controller.view.send_button.properties['default'])
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.send_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-
-    def test_page_initialized_with_text(self):
-        """Test the initial state of the page when it is loaded."""
-        self.controller.view.email_line_edit.setText('[e-mail]')
-        self.controller.pageInitialized()
-        self.assertTrue(self.controller.view.send_button.enabled())
-        self.assertTrue(
-            self.controller.view.send_button.properties['default'])
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.send_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-
-    def test_valid(self):
-        """The submit button should be enabled with a valid email."""
-        self.controller.view.email_address_line_edit.setText("a@b")
-        self.assertNotEqual(unicode(
-            self.controller.view.email_address_line_edit.text()), u"")
-        self.controller._validate()
-        self.assertTrue(self.controller.view.send_button.enabled())
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.send_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-
-    def test_invalid(self):
-        """The submit button should be disabled with an invalid email."""
-        self.controller.view.email_address_line_edit.setText("ab")
-        self.assertNotEqual(
-            unicode(self.controller.view.email_address_line_edit.text()), u"")
-        self.controller._validate()
-        self.assertFalse(self.controller.view.send_button.enabled())
-        self.assertTrue("DisabledState" in self.controller.view.properties)
-        self.assertEqual(self.controller.view.properties["DisabledState"],
-            not self.controller.view.send_button.enabled())
-        self.assertTrue(self.controller.view.properties.get('unpolish', False))
-        self.assertTrue(self.controller.view.properties.get('polish', False))
-
-    def test_empty(self):
-        """The submit button should be disabled without email."""
-        self.assertEqual(
-            unicode(self.controller.view.email_address_line_edit.text()), u"")
-        self.assertFalse(self.controller.view.send_button.enabled())
-
-    def test_on_password_reset_error_token_error(self):
-        """Test that the on_password_reset_error callback works as expected."""
-        error = dict(errtype='ResetPasswordTokenError')
-        app_name = 'app_name'
-        self.controller.on_password_reset_error(app_name, error)
-        msg = REQUEST_PASSWORD_TOKEN_WRONG_EMAIL
-        self.assertEqual(self.controller.message_box.critical_args,
-            ((msg, self.controller.view), {}))
-
-    def test_on_password_reset_error_general_error(self):
-        """Test that the on_password_reset_error callback works as expected."""
-        error = dict(errtype='RandomError')
-        app_name = 'app_name'
-        msg = REQUEST_PASSWORD_TOKEN_TECH_ERROR
-        self.controller.on_password_reset_error(app_name, error)
-        self.assertFalse(self.controller.view.email_widget.isVisible())
-        self.assertFalse(
-            self.controller.view.forgotted_password_intro_label.isVisible())
-        self.assertTrue(self.controller.view.try_again_widget.isVisible())
-        self.assertEqual(self.controller.message_box.critical_args,
-            ((msg, self.controller.view), {}))
-
-
-class ForgottenPasswordControllerTestCase(BaseTestCase):
-    """Test the controller of the fogotten password page."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup the tests."""
-        yield super(ForgottenPasswordControllerTestCase, self).setUp()
-        self.view = FakeForgottenPasswordPageView()
-        self.backend = self.view
-        self.controller = ForgottenPasswordController(
-            message_box=FakeMessageBox())
-        self.controller.view = self.view
-        self.controller.backend = self.backend
-
-    def test_register_fields(self):
-        """Ensure that all the diff fields are registered."""
-        self.controller._register_fields()
-        self.assertEqual(self.view.field('email_address'),
-            self.view.email_address_line_edit)
-
-    def test_set_translated_strings(self):
-        """Ensure that the correct strings are translated."""
-        self.controller._set_translated_strings()
-        self.assertEqual(self.view.forgotted_password_intro_label.text(),
-            REQUEST_PASSWORD_TOKEN_LABEL % {'app_name':
-                                            self.view.fake_wizard.app_name})
-        self.assertEqual(self.view.email_address_label.text(),
-            EMAIL_LABEL)
-        self.assertEqual(self.view.send_button.text(),
-            RESET_PASSWORD)
-        self.assertEqual(self.view.try_again_button.text(),
-            TRY_AGAIN_BUTTON)
-
-    def test_set_enhanced_line_edit(self):
-        """Test that the correct line enhancements have been added."""
-        self.controller._set_enhanced_line_edit()
-        elements = self.view.properties['validation_rule']
-        self.assertFalse(elements is None)
-        for e in elements:
-            self.assertTrue(e[0] is self.view.email_address_line_edit)
-            self.assertIsInstance(e[1], collections.Callable)
-
-    def test_connect_ui(self):
-        """Test that the correct ui signals are connected."""
-        self.controller._connect_ui()
-        self.assertEqual(self.view.email_address_line_edit.receivers(
-            SIGNAL('textChanged(QString)')), 1)
-        self.assertIsInstance(self.view.send_button.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.try_again_button.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_password_reset_token_sent_cb,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_password_reset_error_cb,
-            collections.Callable)
-
-    def test_on_try_again(self):
-        """Test that the on_try_again callback does work as expected."""
-        self.controller.on_try_again()
-        self.assertFalse(self.view.try_again_widget.isVisible())
-        self.assertTrue(self.view.email_widget.isVisible())
-
-    def test_on_password_reset_token_sent(self):
-        """Test that the on_password_token_sent callback works as expected."""
-        self.controller.on_password_reset_token_sent()
-        self.assertTrue(self.view.properties['wizard_next'])
-        self.assertEqual(self.view.next,
-            self.view.fake_wizard.reset_password_page_id)
-
-
-class ResetPasswordControllerTestCase(BaseTestCase):
-    """Ensure that the reset password works as expected."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup the tests."""
-        yield super(ResetPasswordControllerTestCase, self).setUp()
-        self.view = ResetPasswordPageView()
-        self.backend = self.view
-        self.controller = ResetPasswordController()
-        self.controller.view = self.view
-        self.controller.backend = self.backend
-
-    def test_set_translated_strings(self):
-        """Ensure that the correct strings are set."""
-        self.controller._set_translated_strings()
-        self.assertEqual(self.view.reset_password_button.text(),
-            RESET_PASSWORD)
-        self.assertEqual(self.view.properties['subtitle'],
-            PASSWORD_HELP)
-
-    def test_connect_ui(self):
-        """Ensure that the diffent signals from the ui are connected."""
-        self.controller._connect_ui()
-        self.assertIsInstance(self.view.reset_password_button.function,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_password_changed_cb,
-            collections.Callable)
-        self.assertIsInstance(self.view.on_password_change_error_cb,
-            collections.Callable)
-        self.assertEqual(self.view.reset_code_line_edit.receivers(
-            SIGNAL('textChanged(QString)')), 1)
-        self.assertEqual(self.view.password_line_edit.receivers(
-            SIGNAL('textChanged(QString)')), 1)
-        self.assertEqual(self.view.confirm_password_line_edit.receivers(
-            SIGNAL('textChanged(QString)')), 1)
-
-    def test_add_line_edits_validations(self):
-        """Ensure that the line validation have been added."""
-        self.controller._add_line_edits_validations()
-        self.assertEqual(self.view.password_line_edit.receivers(
-            SIGNAL('textChanged(QString)')), 1)
-        elements = self.view.properties['validation_rule']
-        self.assertFalse(elements is None)
-        for e in elements:
-            self.assertTrue(type(e[0]) is QLineEdit)
-            self.assertIsInstance(e[1], collections.Callable)
-
-    def test_set_new_password(self):
-        """Test that the correct action is performed."""
-        email = '[e-mail]'
-        code = 'qwe123'
-        password = 'T3st3rqw'
-        self.view.wizard().forgotten.ui.email_line_edit.setText(email)
-        self.view.reset_code_line_edit.setText(code)
-        self.view.password_line_edit.setText(password)
-        self.controller.set_new_password()
-        self.assertEqual(self.view.properties['backend_new_password'],
-            ((self.view.fake_wizard.app_name, email, code, password), {}))
-
-    def test_is_correct_password_confirmation_true(self):
-        """Test that the correct password confirmation is used."""
-        password = 'password'
-        self.view.password_line_edit.setText(password)
-        self.assertTrue(self.controller.is_correct_password_confirmation(
-                                                                    password))
-
-    def test_is_correct_password_confirmation_false(self):
-        """Test that the correct password confirmation is used."""
-        password = 'password'
-        self.view.password_line_edit.setText(password + password)
-        self.assertFalse(self.controller.is_correct_password_confirmation(
-                                                                    password))
-
-
-class ResetPasswordControllerValidationTest(BaseTestCase):
-
-    """Tests for ResetPasswordController, but without Mocker."""