Merge lp:~nataliabidart/ubuntu-sso-client/use-login-only into lp:ubuntu-sso-client

[Natalia Bidart]

- Move the 'choose sign in page' to client code (U1 control panel
  in this case) (LP: #933576).
- Make use of the 'login_only' parameter that is being passed to the
  UbuntuSSOWizard (LP: #939558).

[lp:~nataliabidart/ubuntu-sso-client/use-login-only]

890. By Natalia Bidart on 2012-02-23

- Also remove choose_sign_in.ui file (no longer needed in this project).

891. By Natalia Bidart on 2012-02-24

Merged trunk in.

892. By Natalia Bidart on 2012-02-24

- Fixed window tests run.

893. By Natalia Bidart on 2012-02-24

Movind the line_edit connects to _connect_ui method.

894. By Natalia Bidart on 2012-02-24

Merged dependency branch in.

895. By Natalia Bidart on 2012-02-24

Making test pass.

896. By Natalia Bidart on 2012-02-24

Merged trunk in.

897. By Natalia Bidart on 2012-02-24

Fixing another test.

898. By Natalia Bidart on 2012-02-24

Lint fixes.

[Roberto Alsina (ralsina)]

+1

review: Approve

[lp:~nataliabidart/ubuntu-sso-client/use-login-only]

899. By Natalia Bidart on 2012-02-24

Fixed pep8 issues.

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== removed file 'data/qt/choose_sign_in.ui'
--- data/qt/choose_sign_in.ui	2012-02-22 16:58:08 +0000
+++ data/qt/choose_sign_in.ui	1970-01-01 00:00:00 +0000
@@ -1,163 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>ChooseSignInPage</class>
- <widget class="QWizardPage" name="ChooseSignInPage">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>432</width>
-    <height>387</height>
-   </rect>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout_2">
-   <property name="leftMargin">
-    <number>0</number>
-   </property>
-   <property name="topMargin">
-    <number>0</number>
-   </property>
-   <property name="rightMargin">
-    <number>0</number>
-   </property>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_2">
-     <item>
-      <widget class="QLabel" name="image_label">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="minimumSize">
-        <size>
-         <width>400</width>
-         <height>150</height>
-        </size>
-       </property>
-       <property name="text">
-        <string/>
-       </property>
-       <property name="textFormat">
-        <enum>Qt::PlainText</enum>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignCenter</set>
-       </property>
-       <property name="wordWrap">
-        <bool>true</bool>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <widget class="QLabel" name="message_label">
-     <property name="font">
-      <font>
-       <pointsize>11</pointsize>
-       <weight>50</weight>
-       <bold>false</bold>
-      </font>
-     </property>
-     <property name="text">
-      <string notr="true">Congratulations, app_name is installed!</string>
-     </property>
-     <property name="alignment">
-      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <spacer name="verticalSpacer_3">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeType">
-      <enum>QSizePolicy::Fixed</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>30</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout">
-     <item>
-      <spacer name="horizontalSpacer_2">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>20</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <layout class="QVBoxLayout" name="verticalLayout">
-       <item>
-        <widget class="QPushButton" name="existing_account_button">
-         <property name="text">
-          <string notr="true"/>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QPushButton" name="setup_account_button">
-         <property name="text">
-          <string notr="true"/>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QPushButton" name="cancel_button">
-         <property name="text">
-          <string notr="true"/>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeType">
-        <enum>QSizePolicy::Expanding</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>20</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <spacer name="verticalSpacer_2">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>50</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>

=== modified file 'run-tests.bat'
--- run-tests.bat	2012-01-31 19:02:36 +0000
+++ run-tests.bat	2012-02-24 17:28:19 +0000
@@ -99,7 +99,7 @@
 "%PYTHONEXEPATH%\python.exe" setup.py build
 ECHO Running tests
 :: execute the tests with a number of ignored linux only modules
-"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1trial" -i "test_linux.py, test_txsecrets.py" -p "ubuntu_sso\gtk" --reactor=qt4 --gui %PARAMS% ubuntu_sso 
+"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1trial" -i "test_linux.py, test_txsecrets.py, test_qt.py, test_glib.py" -p "ubuntu_sso\gtk" --reactor=qt4 --gui %PARAMS% ubuntu_sso 
 :: Clean the build from the setupt.py
 ECHO Cleaning the generated code
 "%PYTHONEXEPATH%\python.exe" setup.py clean

=== modified file 'ubuntu_sso/qt/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-18 15:02:49 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-24 17:28:19 +0000
@@ -19,12 +19,12 @@
 from functools import partial
 
 from PyQt4 import QtGui, QtCore
-from twisted.internet import defer
 
 from ubuntu_sso import NO_OP
+from ubuntu_sso.logger import setup_logging
 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.qt.sso_wizard_page import SSOWizardPage
+from ubuntu_sso.qt.ui.current_user_sign_in_ui import Ui_CurrentUserSignInPage
 from ubuntu_sso.utils.ui import (
     CANCEL_BUTTON,
     EMAIL_LABEL,
@@ -45,15 +45,15 @@
 class CurrentUserSignInPage(SSOWizardPage):
     """Wizard Page that lets a current user Sign into Ubuntu Single Sign On."""
 
+    ui_class = Ui_CurrentUserSignInPage
     userLoggedIn = QtCore.pyqtSignal('QString', 'QString')
     passwordForgotten = QtCore.pyqtSignal()
     userNotValidated = QtCore.pyqtSignal('QString', 'QString')
 
-    def __init__(self, ui, ping_url, *args, **kwargs):
-        super(CurrentUserSignInPage, self).__init__(ui, *args, **kwargs)
-        self.ping_url = ping_url
-
-        self._signals = {
+    @property
+    def _signals(self):
+        """The signals to connect to the backend."""
+        result = {
             'LoggedIn':
              self._filter_by_app_name(self.on_logged_in),
             'LoginError':
@@ -61,7 +61,7 @@
              'UserNotValidated':
              self._filter_by_app_name(self.on_user_not_validated),
          }
-        self.setup_page()
+        return result
 
     def on_user_not_validated(self, *args):
         """Show the validate email page."""
@@ -69,15 +69,6 @@
         password = unicode(self.ui.password_edit.text())
         self.userNotValidated.emit(email, password)
 
-    @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
 

=== modified file 'ubuntu_sso/qt/email_verification_page.py'
--- ubuntu_sso/qt/email_verification_page.py	2012-02-22 16:58:08 +0000
+++ ubuntu_sso/qt/email_verification_page.py	2012-02-24 17:28:19 +0000
@@ -19,19 +19,19 @@
 from functools import partial
 
 from PyQt4 import QtCore
-from twisted.internet import defer
 
 from ubuntu_sso import NO_OP
+from ubuntu_sso.logger import setup_logging
 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.qt.sso_wizard_page import SSOWizardPage
+from ubuntu_sso.qt.ui.email_verification_ui import Ui_EmailVerificationPage
 from ubuntu_sso.utils.ui import (
+    ERROR_EMAIL_TOKEN,
     NEXT,
     VERIFICATION_CODE,
     VERIFY_EMAIL_TITLE,
     VERIFY_EMAIL_CONTENT,
 )
-from ubuntu_sso.utils.ui import ERROR_EMAIL_TOKEN
 
 
 logger = setup_logging('ubuntu_sso.email_verification_page')
@@ -40,27 +40,24 @@
 class EmailVerificationPage(SSOWizardPage):
     """Widget used to input the email verification code."""
 
+    ui_class = Ui_EmailVerificationPage
     registrationSuccess = QtCore.pyqtSignal('QString', 'QString')
 
-    def __init__(self, ui, ping_url, *args, **kwargs):
-        super(EmailVerificationPage, self).__init__(ui, *args, **kwargs)
-        self.ping_url = ping_url
+    def __init__(self, *args, **kwargs):
         self.email = ''
         self.password = ''
-        self._signals = {
+        super(EmailVerificationPage, self).__init__(*args, **kwargs)
+
+    @property
+    def _signals(self):
+        """The signals to connect to the backend."""
+        result = {
             '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()
+        return result
 
     @property
     def verification_code(self):
@@ -72,9 +69,9 @@
         """Return the button that move to the next stage."""
         return self.ui.next_button
 
-    def _connect_ui_elements(self):
+    def _connect_ui(self):
         """Set the connection of signals."""
-        logger.debug('EmailVerificationController._connect_ui_elements')
+        logger.debug('EmailVerificationController._connect_ui')
         self.ui.verification_code_edit.textChanged.connect(
             self.validate_form)
         self.next_button.clicked.connect(self.validate_email)
@@ -89,7 +86,7 @@
         self.next_button.style().unpolish(self.next_button)
         self.next_button.style().polish(self.next_button)
 
-    def _set_titles(self):
+    def _set_translated_strings(self):
         """Set the different titles."""
         logger.debug('EmailVerificationController._set_titles')
         self.header.set_title(VERIFY_EMAIL_TITLE)
@@ -104,9 +101,9 @@
         """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.
+        and _set_translated_strings is only called on initialization.
         """
-        self._set_titles()
+        self._set_translated_strings()
 
     def validate_email(self):
         """Call the next action."""

=== modified file 'ubuntu_sso/qt/error_page.py'
--- ubuntu_sso/qt/error_page.py	2012-02-07 18:59:36 +0000
+++ ubuntu_sso/qt/error_page.py	2012-02-24 17:28:19 +0000
@@ -16,14 +16,21 @@
 
 """Email Verification page UI."""
 
-from ubuntu_sso.qt.gui import SSOWizardPage
+from ubuntu_sso.qt.sso_wizard_page import SSOWizardPage
+from ubuntu_sso.qt.ui.error_message_ui import Ui_ErrorPage
 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)
+    ui_class = Ui_ErrorPage
+    next = None
+
+    def _set_translated_strings(self):
+        """Set the translated strings."""
+        self.ui.error_message_label.setText(ERROR)
+
+    def _connect_ui(self):
+        """Connect the buttons to perform actions."""
         self.next = -1
-        self.ui.error_message_label.setText(ERROR)

=== modified file 'ubuntu_sso/qt/forgotten_password_page.py'
--- ubuntu_sso/qt/forgotten_password_page.py	2012-02-16 14:13:36 +0000
+++ ubuntu_sso/qt/forgotten_password_page.py	2012-02-24 17:28:19 +0000
@@ -19,10 +19,10 @@
 from functools import partial
 
 from PyQt4 import QtCore
-from twisted.internet import defer
 
 from ubuntu_sso import NO_OP
-from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
+from ubuntu_sso.qt.sso_wizard_page import SSOWizardEnhancedEditPage
+from ubuntu_sso.qt.ui.forgotten_password_ui import Ui_ForgottenPasswordPage
 from ubuntu_sso.utils.ui import (
     EMAIL_LABEL,
     is_correct_email,
@@ -37,29 +37,19 @@
 class ForgottenPasswordPage(SSOWizardEnhancedEditPage):
     """Widget used to deal with users that forgot the password."""
 
+    ui_class = Ui_ForgottenPasswordPage
     passwordResetTokenSent = QtCore.pyqtSignal()
 
-    def __init__(self, ui, *args, **kwargs):
-        super(ForgottenPasswordPage, self).__init__(ui, *args, **kwargs)
-        self._signals = {
+    @property
+    def _signals(self):
+        """The signals to connect to the backend."""
+        result = {
             '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()
+        return result
 
     @property
     def email_widget(self):
@@ -144,8 +134,13 @@
         self.email_address_line_edit.textChanged.connect(self._validate)
 
         self.send_button.clicked.connect(self.request_new_password)
+
+        self.try_again_widget.setVisible(False)
         self.try_again_button.clicked.connect(self.on_try_again)
 
+        self._set_enhanced_line_edit()
+        self._register_fields()
+
     def request_new_password(self):
         """Send the request password operation."""
         args = (self.app_name, self.email_address)
@@ -171,13 +166,11 @@
         self.try_again_widget.setVisible(False)
         self.email_widget.setVisible(True)
 
-    # pylint: disable=W0212
     def on_password_reset_token_sent(self, app_name, result):
         """Action taken when we managed to get the password reset done."""
         # ignore the result and move to the reset page
         self.overlay.hide()
         self.passwordResetTokenSent.emit()
-    # pylint: enable=W0212
 
     def on_password_reset_error(self, app_name, error):
         """Action taken when there was an error requesting the reset."""

=== modified file 'ubuntu_sso/qt/loadingoverlay.py'
--- ubuntu_sso/qt/loadingoverlay.py	2012-02-22 16:58:08 +0000
+++ ubuntu_sso/qt/loadingoverlay.py	2012-02-24 17:28:19 +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
@@ -45,7 +45,7 @@
 
         self.ui.label.setText(LOADING_OVERLAY)
 
-    # Invalid name "paintEvent"
+    # Invalid name "paintEvent", "eventFilter", "showEvent", "timerEvent"
     # pylint: disable=C0103
 
     def paintEvent(self, event):
@@ -60,9 +60,6 @@
         painter.end()
         QtGui.QFrame.paintEvent(self, event)
 
-    # Invalid name "eventFilter"
-    # pylint: disable=C0103
-
     def eventFilter(self, obj, event):
         """Filter events from Frame content to draw the dot animation."""
         if getattr(self, 'ui', None) is not None and \
@@ -99,9 +96,6 @@
             painter.end()
         return False
 
-    # Invalid name "showEvent"
-    # pylint: disable=C0103
-
     def showEvent(self, event):
         """Start the dot animation."""
         self.ui.frm_box.installEventFilter(self)
@@ -112,9 +106,6 @@
         if not self.timer:
             self.timer = self.startTimer(200)
 
-    # Invalid name "timerEvent"
-    # pylint: disable=C0103
-
     def timerEvent(self, event):
         """Execute a loop to update the dot animation."""
         if self.counter in (0, 4):
@@ -124,3 +115,5 @@
         else:
             self.counter -= 1
         self.update()
+
+    # pylint: enable=C0103

=== modified file 'ubuntu_sso/qt/network_detection_page.py'
--- ubuntu_sso/qt/network_detection_page.py	2012-02-22 16:58:08 +0000
+++ ubuntu_sso/qt/network_detection_page.py	2012-02-24 17:28:19 +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,6 +21,7 @@
 
 from ubuntu_sso import networkstate
 
+from ubuntu_sso.qt.sso_wizard_page import SSOWizardPage
 from ubuntu_sso.qt.ui import network_detection_ui
 from ubuntu_sso.utils.ui import (
     CLOSE_AND_SETUP_LATER,
@@ -30,21 +31,21 @@
 )
 
 
-class NetworkDetectionPage(QtGui.QWizardPage):
+class NetworkDetectionPage(SSOWizardPage):
 
     """Widget to show if we don't detect a network connection."""
 
-    def __init__(self, app_name, banner_pixmap=None, parent=None):
-        super(NetworkDetectionPage, self).__init__(parent)
-        self.app_name = app_name
-        self.setTitle(NETWORK_DETECTION_TITLE)
-        self.ui = network_detection_ui.Ui_Form()
-        self.ui.setupUi(self)
+    ui_class = network_detection_ui.Ui_Form
+
+    def __init__(self, *args, **kwargs):
+        super(NetworkDetectionPage, self).__init__(*args, **kwargs)
+        banner_pixmap = kwargs.pop('banner_pixmap', None)
         if banner_pixmap is not None:
             self.ui.image_label.setPixmap(banner_pixmap)
         self.btn_try_again = None
 
     # pylint: disable=C0103
+
     def initializePage(self):
         """Set UI details."""
         self.wizard()._next_id = None
@@ -70,6 +71,7 @@
         self.btn_try_again.style().unpolish(self.btn_try_again)
         self.btn_try_again.style().polish(self.btn_try_again)
         self.wizard().customButtonClicked.connect(self.try_again)
+
     # pylint: enable=C0103
 
     @defer.inlineCallbacks
@@ -81,3 +83,10 @@
                 self.wizard()._next_id = self.wizard().SIGN_IN_PAGE_ID
                 self.wizard().next()
                 self.wizard()._next_id = None
+
+    def _set_translated_strings(self):
+        """Implement in each child."""
+        self.setTitle(NETWORK_DETECTION_TITLE)
+
+    def _connect_ui(self):
+        """Implement in each child."""

=== modified file 'ubuntu_sso/qt/reset_password_page.py'
--- ubuntu_sso/qt/reset_password_page.py	2012-02-16 14:13:36 +0000
+++ ubuntu_sso/qt/reset_password_page.py	2012-02-24 17:28:19 +0000
@@ -18,15 +18,14 @@
 
 from functools import partial
 
-from PyQt4.QtCore import SIGNAL
-from PyQt4.QtCore import pyqtSignal
+from PyQt4.QtCore import SIGNAL, pyqtSignal
 from PyQt4.QtGui import QApplication
-from twisted.internet import defer
 
 from ubuntu_sso import NO_OP
-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.logger import setup_logging
+from ubuntu_sso.qt import build_general_error_message, common
+from ubuntu_sso.qt.sso_wizard_page import SSOWizardEnhancedEditPage
+from ubuntu_sso.qt.ui.reset_password_ui import Ui_ResetPasswordPage
 from ubuntu_sso.utils.ui import (
     is_min_required_password,
     PASSWORD1_ENTRY,
@@ -37,7 +36,6 @@
     RESET_TITLE,
     RESET_SUBTITLE,
 )
-from ubuntu_sso.logger import setup_logging
 
 
 logger = setup_logging('ubuntu_sso.reset_password_page')
@@ -46,35 +44,19 @@
 class ResetPasswordPage(SSOWizardEnhancedEditPage):
     """Widget used to allow the user change his password."""
 
+    ui_class = Ui_ResetPasswordPage
     passwordChanged = pyqtSignal('QString')
 
-    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 = {
+    @property
+    def _signals(self):
+        """The signals to connect to the backend."""
+        result = {
             '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()
+        return result
 
     def focus_changed(self, old, now):
         """Check who has the focus to activate password popups if necessary."""
@@ -136,6 +118,15 @@
 
     def _connect_ui(self):
         """Connect the different ui signals."""
+        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.ui.reset_password_button.clicked.connect(
                                                     self.set_new_password)
         self.ui.reset_code_line_edit.textChanged.connect(self._validate)
@@ -143,6 +134,8 @@
         self.ui.confirm_password_line_edit.textChanged.connect(
             self._validate)
 
+        self._add_line_edits_validations()
+
     def _validate(self):
         """Enable the submit button if data is valid."""
         enabled = True

=== modified file 'ubuntu_sso/qt/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-02-24 14:58:30 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-02-24 17:28:19 +0000
@@ -29,13 +29,16 @@
 # pylint: enable=F0401
 
 from PyQt4 import QtGui, QtCore
-from twisted.internet import defer
 
 from ubuntu_sso import NO_OP
-from ubuntu_sso.qt import build_general_error_message
-from ubuntu_sso.qt import common
-from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
-from ubuntu_sso.qt import enhanced_check_box
+from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.qt import (
+    build_general_error_message,
+    common,
+    enhanced_check_box,
+)
+from ubuntu_sso.qt.sso_wizard_page import SSOWizardEnhancedEditPage
+from ubuntu_sso.qt.ui.setup_account_ui import Ui_SetUpAccountPage
 from ubuntu_sso.utils.ui import (
     AGREE_TO_PRIVACY_POLICY,
     AGREE_TO_TERMS,
@@ -71,12 +74,10 @@
     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>"
 
@@ -92,47 +93,21 @@
 class SetupAccountPage(SSOWizardEnhancedEditPage):
     """Customized Setup Account page for SSO."""
 
+    ui_class = Ui_SetUpAccountPage
     userRegistered = QtCore.pyqtSignal('QString', 'QString')
 
-    def __init__(self, ui, subtitle, toc_link, policy_link, *args, **kwargs):
-        super(SetupAccountPage, self).__init__(ui, *args, **kwargs)
-        self._subtitle = subtitle
+    def __init__(self, *args, **kwargs):
+        self.captcha_file = None
         self.captcha_id = None
-        self.captcha_file = None
-        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))
-
-        if toc_link:
-            terms_links = TERMS_LINK.format(toc_link=toc_link,
-                                            terms_text=TERMS_TEXT)
-        if policy_link:
-            privacy_policy_link = PRIVACY_POLICY_LINK.format(
-                                    policy_link=policy_link,
-                                    privacy_policy_text=PRIVACY_POLICY_TEXT)
-
-        terms = ''
-        if toc_link and policy_link:
-            terms = AGREE_TO_TERMS_AND_PRIVACY_POLICY.format(
-                        app_name=self.app_name,
-                        terms_and_conditions=terms_links,
-                        privacy_policy=privacy_policy_link)
-        elif toc_link:
-            terms = AGREE_TO_TERMS.format(app_name=self.app_name,
-                        terms_and_conditions=terms_links)
-        elif policy_link:
-            terms = AGREE_TO_PRIVACY_POLICY.format(app_name=self.app_name,
-                        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(bool(toc_link or policy_link))
-
+        self.captcha_received = False
         self.set_up_button = None
-        self.captcha_received = False
-        self._signals = {
+        self.terms_checkbox = None
+        super(SetupAccountPage, self).__init__(*args, **kwargs)
+
+    @property
+    def _signals(self):
+        """The signals to connect to the backend."""
+        result = {
             'CaptchaGenerated':
              self._filter_by_app_name(self.on_captcha_generated),
             'CaptchaGenerationError':
@@ -142,31 +117,16 @@
             '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()
+        return result
 
     # Invalid name "initializePage"
     # pylint: disable=C0103
 
     def initializePage(self):
         """Setup UI details."""
-        # We need to override some texts from SSO
-        # to match our spec
         title_page = TITLE_STYLE % TITLE.format(app_name=self.app_name)
         self.setTitle(title_page)
-        self.setSubTitle(self._subtitle)
+        self.setSubTitle(self.help_text)
         # Set Setup Account button
         self.wizard().setOption(QtGui.QWizard.HaveCustomButton3, True)
         try:
@@ -199,7 +159,8 @@
         self.ui.confirm_email_assistance.setVisible(False)
         self.ui.password_assistance.setVisible(False)
         self.ui.refresh_label.setVisible(True)
-    #pylint: enable=C0103
+
+    # pylint: enable=C0103
 
     def _set_translated_strings(self):
         """Set the strings."""
@@ -218,6 +179,33 @@
         self.ui.refresh_label.setText(CAPTCHA_RELOAD_MESSAGE %
                                       {'reload_link': link})
 
+        if self.tc_url:
+            terms_links = TERMS_LINK.format(toc_link=self.tc_url,
+                                            terms_text=TERMS_TEXT)
+        if self.policy_url:
+            privacy_policy_link = PRIVACY_POLICY_LINK.format(
+                                    policy_link=self.policy_url,
+                                    privacy_policy_text=PRIVACY_POLICY_TEXT)
+
+        terms = ''
+        if self.tc_url and self.policy_url:
+            terms = AGREE_TO_TERMS_AND_PRIVACY_POLICY.format(
+                        app_name=self.app_name,
+                        terms_and_conditions=terms_links,
+                        privacy_policy=privacy_policy_link)
+        elif self.tc_url:
+            terms = AGREE_TO_TERMS.format(app_name=self.app_name,
+                        terms_and_conditions=terms_links)
+        elif self.policy_url:
+            terms = AGREE_TO_PRIVACY_POLICY.format(app_name=self.app_name,
+                        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(bool(self.tc_url or self.policy_url))
+
+        self._register_fields()
+
     def _set_line_edits_validations(self):
         """Set the validations to be performed on the edits."""
         logger.debug('SetUpAccountPage._set_line_edits_validations')
@@ -240,9 +228,17 @@
         self.ui.password_edit.textChanged.connect(
             self.ui.confirm_password_edit.textChanged.emit)
 
-    def _connect_ui_elements(self):
+    def _connect_ui(self):
         """Set the connection of signals."""
-        logger.debug('SetUpAccountPage._connect_ui_elements')
+        logger.debug('SetUpAccountPage._connect_ui')
+        self._set_line_edits_validations()
+
+        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))
+
         self.ui.refresh_label.linkActivated.connect(lambda url: \
                                           self._refresh_captcha())
         # We need to check if we enable the button on many signals
@@ -257,6 +253,8 @@
             self._enable_setup_button)
         self.terms_checkbox.stateChanged.connect(self._enable_setup_button)
 
+        self._refresh_captcha()
+
     def _enable_setup_button(self):
         """Only enable the setup button if the form is valid."""
         name = unicode(self.ui.name_edit.text()).strip()
@@ -393,7 +391,6 @@
             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')
@@ -413,7 +410,6 @@
             f(*args, reply_handler=NO_OP, error_handler=error_handler)
             # Update validation page's title, which contains the email
             self.userRegistered.emit(email, password)
-    # pylint: enable=W0212
 
     def is_correct_email(self, email_address):
         """Return if the email is correct."""
@@ -484,7 +480,8 @@
         label.setText(ERROR % msg)
         label.setVisible(True)
 
-    #pylint: disable=C0103
+    # 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
@@ -514,7 +511,8 @@
         except TypeError:
             pass
         super(SetupAccountPage, self).hideEvent(event)
-    #pylint: enable=C0103
+
+    # pylint: enable=C0103
 
     def on_captcha_refreshing(self):
         """Show overlay when captcha is refreshing."""

=== removed file 'ubuntu_sso/qt/sign_in_page.py'
--- ubuntu_sso/qt/sign_in_page.py	2012-02-17 18:43:17 +0000
+++ ubuntu_sso/qt/sign_in_page.py	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-# -*- 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/>.
-
-"""Page to allow the user to sign in."""
-
-from PyQt4 import QtGui, QtCore
-
-from ubuntu_sso.qt.gui import SSOWizardPage
-from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.utils.ui import (
-    CLOSE_AND_SETUP_LATER,
-    EXISTING_ACCOUNT_CHOICE_BUTTON,
-    SET_UP_ACCOUNT_CHOICE_BUTTON,
-)
-
-
-logger = setup_logging('ubuntu_sso.sing_in_page')
-
-
-class SignInPage(SSOWizardPage):
-    """Wizard Page that lets the user Sign into Ubuntu Single Sign On."""
-
-    existingAccountSelected = QtCore.pyqtSignal()
-    newAccountSelected = QtCore.pyqtSignal()
-    singInCanceled = QtCore.pyqtSignal()
-
-    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')
-        self.ui.message_label.setText('')
-        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.existingAccountSelected.emit()
-
-    def _set_next_new(self):
-        """Set the next id and fire signal."""
-        logger.debug('SignInPage._set_next_new')
-        self.newAccountSelected.emit()
-
-    # Invalid names of Qt-inherited methods
-    # pylint: disable=C0103
-
-    def initializePage(self):
-        """Setup UI details."""
-        self.ui.cancel_button.setText(CLOSE_AND_SETUP_LATER)
-        self.ui.cancel_button.clicked.connect(self.singInCanceled.emit)
-        # Layout without custom button 1,
-        # without finish button
-        # without cancel
-        self.wizard().setButtonLayout([
-            QtGui.QWizard.Stretch,
-            QtGui.QWizard.NextButton])
-
-    def showEvent(self, event):
-        """Set existing_account_button as default when the page is shown."""
-        super(SignInPage, self).showEvent(event)
-        self.ui.existing_account_button.setDefault(True)
-        self.ui.existing_account_button.style().unpolish(
-            self.ui.existing_account_button)
-        self.ui.existing_account_button.style().polish(
-            self.ui.existing_account_button)
-
-    def nextId(self):
-        """Provide the next id."""
-        return self.next

=== renamed file 'ubuntu_sso/qt/gui.py' => 'ubuntu_sso/qt/sso_wizard_page.py'
--- ubuntu_sso/qt/gui.py	2012-02-23 20:16:46 +0000
+++ ubuntu_sso/qt/sso_wizard_page.py	2012-02-24 17:28:19 +0000
@@ -35,13 +35,13 @@
 from twisted.internet import defer
 
 from ubuntu_sso import main
+from ubuntu_sso.logger import setup_logging
 from ubuntu_sso.qt import PREFERED_UI_SIZE
 from ubuntu_sso.qt.loadingoverlay import LoadingOverlay
-from ubuntu_sso.logger import setup_logging
 from ubuntu_sso.utils.ui import GENERIC_BACKEND_ERROR
 
 
-logger = setup_logging('ubuntu_sso.gui')
+logger = setup_logging('ubuntu_sso.sso_wizard_page')
 
 
 class Header(QFrame):
@@ -92,32 +92,53 @@
 class SSOWizardPage(QWizardPage):
     """Root class for all wizard pages."""
 
-    def __init__(self, ui, app_name=None, title='', subtitle='', parent=None):
+    ui_class = None
+    _signals = {}  # override in children
+
+    def __init__(self, app_name, **kwargs):
         """Create a new instance."""
-        super(SSOWizardPage, self).__init__(parent)
-        self.ui = ui
-        self.ui.setupUi(self)
+        parent = kwargs.pop('parent', None)
+        super(SSOWizardPage, self).__init__(parent=parent)
+
+        self.ui = None
+        if self.ui_class is not None:
+            # self.ui_class is not callable, pylint: disable=E1102
+            self.ui = self.ui_class()
+            self.ui.setupUi(self)
+
         self.overlay = LoadingOverlay(self)
         self.overlay.hide()
+
+        # 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.policy_url = kwargs.get('policy_url', '')
+        self.help_text = kwargs.get('help_text', '')
+
         self.header = Header()
-        self.header.set_title(title)
-        self.header.set_subtitle(subtitle)
+        self.header.set_title(title='')
+        self.header.set_subtitle(subtitle='')
         self.layout().insertWidget(0, self.header)
+
         self.message_box = QMessageBox
-        self._signals = {}
         self._signals_receivers = {}
         self.backend = None
 
+        self.setup_page()
+
     @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)
+    def setup_page(self):
+        """Setup the widget components."""
+        client = yield main.get_sso_client()
+        self.backend = client.sso_login
+
+        self._setup_signals()
+        self._set_translated_strings()
+        self._connect_ui()
 
     # pylint: disable=C0103
+
     def resizeEvent(self, event):
         """Resize the overlay to fit all the widget."""
         QWizardPage.resizeEvent(self, event)
@@ -130,6 +151,7 @@
     def setSubTitle(self, subtitle=''):
         """Set the Wizard Page Subtitle."""
         self.header.set_subtitle(subtitle)
+
     # pylint: enable=C0103
 
     def _filter_by_app_name(self, f):
@@ -160,6 +182,14 @@
             match = self.backend.connect_to_signal(signal, method)
             self._signals_receivers[signal] = match
 
+    def _set_translated_strings(self):
+        """Implement in each child."""
+        raise NotImplementedError()
+
+    def _connect_ui(self):
+        """Implement in each child."""
+        raise NotImplementedError()
+
     def _handle_error(self, remote_call, handler, error):
         """Handle any error when calling the remote backend."""
         logger.error('Remote call %r failed with: %r', remote_call, error)
@@ -210,11 +240,14 @@
 class SSOWizardEnhancedEditPage(SSOWizardPage):
     """Page that contains enhanced line edits."""
 
-    def __init__(self, ui, app_name=None, parent=None):
+    # Method '_connect_ui', '_set_translated_strings' is abstract in class
+    # 'SSOWizardPage' but is not overridden
+    # pylint: disable=W0223
+
+    def __init__(self, *args, **kwargs):
         """Create a new instance."""
         self._enhanced_edits = {}
-        super(SSOWizardEnhancedEditPage, self).__init__(ui,
-            app_name=app_name, parent=parent)
+        super(SSOWizardEnhancedEditPage, self).__init__(*args, **kwargs)
 
     def set_line_edit_validation_rule(self, edit, cb):
         """Set a new enhanced edit so that we can show an icon."""

=== modified file 'ubuntu_sso/qt/success_page.py'
--- ubuntu_sso/qt/success_page.py	2012-02-13 18:08:13 +0000
+++ ubuntu_sso/qt/success_page.py	2012-02-24 17:28:19 +0000
@@ -16,15 +16,24 @@
 
 """Success page UI."""
 
-from ubuntu_sso.qt.gui import SSOWizardPage
+from PyQt4 import QtGui
+
+from ubuntu_sso.qt.sso_wizard_page import SSOWizardPage
+from ubuntu_sso.qt.ui.success_message_ui import Ui_SuccessPage
 from ubuntu_sso.utils.ui import SUCCESS
 
 
 class SuccessPage(SSOWizardPage):
     """Page used to display success message."""
 
-    def __init__(self, ui, image_pixmap, *args, **kwargs):
-        super(SuccessPage, self).__init__(ui, *args, **kwargs)
-        self.ui.image_label.setPixmap(image_pixmap)
+    ui_class = Ui_SuccessPage
+
+    def _set_translated_strings(self):
+        """Set proper strings to widgets."""
+        # we may want to customize the image_label in some future
+        self.ui.image_label.setPixmap(QtGui.QPixmap())
         message = SUCCESS % {'app_name': self.app_name}
         self.ui.success_message_body.setText(message)
+
+    def _connect_ui(self):
+        """Nothing to connect."""

=== modified file 'ubuntu_sso/qt/tests/__init__.py'
--- ubuntu_sso/qt/tests/__init__.py	2012-02-15 17:33:40 +0000
+++ ubuntu_sso/qt/tests/__init__.py	2012-02-24 17:28:19 +0000
@@ -19,20 +19,30 @@
 from PyQt4 import QtGui, QtCore
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
-from ubuntu_sso.qt import loadingoverlay
 
-from ubuntu_sso import (
-    main,
-    NO_OP,
+from ubuntu_sso import main, NO_OP
+from ubuntu_sso.qt import sso_wizard_page
+from ubuntu_sso.tests import (
+    APP_NAME,
+    HELP_TEXT,
+    PING_URL,
+    POLICY_URL,
+    TC_URL,
+    WINDOW_ID,
 )
 
+KWARGS = dict(app_name=APP_NAME, help_text=HELP_TEXT, ping_url=PING_URL,
+              policy_url=POLICY_URL, tc_url=TC_URL, window_id=WINDOW_ID)
+
+# is ok to access private method/attrs in tests
+# pylint: disable=W0212
+
 
 class FakedObject(object):
     """Fake an object, record every call."""
 
     next_result = None
-    exposed_methods = ['connect_to_signal',
-        'generate_captcha', 'request_password_reset_token']
+    exposed_methods = []
 
     def __init__(self, *args, **kwargs):
         self._args = args
@@ -52,10 +62,26 @@
         return inner
 
 
+class FakedSSOLoginBackend(FakedObject):
+    """A faked sso_login backend."""
+
+    exposed_methods = [
+        'connect_to_signal',
+        'generate_captcha',
+        'login',
+        'login_and_ping',
+        'register_user',
+        'request_password_reset_token',
+        'set_new_password',
+        'validate_email',
+        'validate_email_and_ping',
+    ]
+
+
 class FakedBackend(object):
     """A faked backend."""
 
-    sso_login = FakedObject()
+    sso_login = FakedSSOLoginBackend()
 
 
 class FakePageUiStyle(object):
@@ -203,7 +229,7 @@
         self.overlay = FakeOverlay()
         self.local_folders_page = FakeWizardPage()
         self.folders_page = FakeWizardPage()
-        self.app_name = 'app_name'
+        self.app_name = APP_NAME
 
     def show(self):
         """Fake method."""
@@ -250,6 +276,7 @@
 
 
 class FakeWizard(object):
+
     """Replace wizard() function on wizard pages."""
 
     customButtonClicked = QtCore.QObject()
@@ -374,6 +401,12 @@
 class BaseTestCase(TestCase):
     """The base test case."""
 
+    kwargs = None
+    ui_class = None
+    ui_signals = ()
+    ui_backend_signals = ()
+    ui_wizard_class = FakeWizard
+
     @defer.inlineCallbacks
     def setUp(self):
         yield super(BaseTestCase, self).setUp()
@@ -383,11 +416,31 @@
         self.patch(main, 'get_sso_client',
                    lambda *a: defer.succeed(backend))
 
+        self.patch(sso_wizard_page, 'LoadingOverlay', FakeOverlay)
+
+        self.app_name = APP_NAME
+        self.ping_url = PING_URL
+        self.signals_results = []
+
+        # self.ui_class is not callable
+        # pylint: disable=E1102, C0103, W0212
+        self.ui = None
+        self.wizard = None
+        if self.ui_class is not None:
+            kwargs = dict(KWARGS) if self.kwargs is None else self.kwargs
+            self.ui = self.ui_class(**kwargs)
+
+            for signal in self.ui_signals:
+                self.patch(self.ui_class, signal, FakeSignal())
+
+            if self.ui_wizard_class is not None:
+                self.wizard = self.ui_wizard_class()
+                self.patch(self.ui, 'wizard', lambda: self.wizard)
+
     def _set_called(self, *args, **kwargs):
         """Store 'args' and 'kwargs' for test assertions."""
         self._called = (args, kwargs)
 
-    # pylint: disable=E1101, W0212
     def assert_backend_called(self, method, *args, **kwargs):
         """Check that 'method(*args, **kwargs)' was called in the backend."""
         self.assertIn(method, self.ui.backend._called)
@@ -402,34 +455,6 @@
         self.assertEqual(error_handler.func, self.ui._handle_error)
 
         self.assertEqual(call[1], kwargs)
-    # pylint: enable=E1101, W0212
-
-
-class BaseTestCaseUI(TestCase):
-    """Base Test Case."""
-
-    class_ui = None
-    kwargs = {}
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(BaseTestCaseUI, self).setUp()
-        # self.class_ui is not callable
-        # pylint: disable=E1102, C0103, W0212
-        self.ui = None
-        self._called = False
-        if self.class_ui is not None:
-            self.ui = self.class_ui(**self.kwargs)
-
-        if hasattr(self.ui, 'backend'):
-            # clean backend calls
-            self.ui.backend._called.clear()
-
-        self.patch(loadingoverlay, 'LoadingOverlay', FakeOverlay)
-
-    def _set_called(self, *args, **kwargs):
-        """Store 'args' and 'kwargs' for test assertions."""
-        self._called = (args, kwargs)
 
     def get_pixmap_data(self, pixmap):
         """Get the raw data of a QPixmap."""
@@ -446,3 +471,30 @@
         d1 = self.get_pixmap_data(pixmap1)
         d2 = self.get_pixmap_data(pixmap2)
         self.assertEqual(d1, d2)
+
+    # pylint: enable=C0103
+
+    @defer.inlineCallbacks
+    def test_setup_page(self):
+        """Test the backend signal connection."""
+        if self.ui is None or getattr(self.ui, 'setup_page', None) is None:
+            return
+
+        called = []
+        self.patch(self.ui, '_setup_signals',
+                   lambda *a: called.append('_setup_signals'))
+        self.patch(self.ui, '_connect_ui',
+                   lambda *a: called.append('_connect_ui'))
+        self.patch(self.ui, '_set_translated_strings',
+                   lambda *a: called.append('_set_translated_strings'))
+
+        yield self.ui.setup_page()
+
+        self.assertEqual(self.ui.backend, self.sso_login_backend)
+
+        for signal in self.ui_backend_signals:
+            self.assertIn(signal, self.ui._signals)
+            self.assertTrue(callable(self.ui._signals[signal]))
+
+        expected = ['_setup_signals', '_set_translated_strings', '_connect_ui']
+        self.assertEqual(expected, called)

=== modified file 'ubuntu_sso/qt/tests/test_current_user_sign_in_page.py'
--- ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-02-16 18:40:41 +0000
+++ ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-02-24 17:28:19 +0000
@@ -17,78 +17,22 @@
 """Tests for the Setup Account page Qt UI."""
 
 from PyQt4 import QtGui, QtCore
-from twisted.internet import defer
 
-from ubuntu_sso.qt import gui
 from ubuntu_sso.qt import current_user_sign_in_page
 from ubuntu_sso.qt.tests import (
     BaseTestCase,
-    FakedBackend,
-    FakedObject,
-    FakeOverlay,
     FakePageUiStyle,
-    FakeSignal,
-    FakeWizard,
     FakeWizardButtonStyle,
 )
-from ubuntu_sso.qt.ui import current_user_sign_in_ui
 
 
 # pylint: disable=W0212
 class CurrentUserSignInTestCase(BaseTestCase):
     """Test the SetupAccountPage code."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(CurrentUserSignInTestCase, self).setUp()
-        self.patch(gui, "LoadingOverlay", FakeOverlay)
-        self.patch(gui.main, "get_sso_client", FakedBackend)
-        self.signals_results = []
-        self.patch(current_user_sign_in_page.CurrentUserSignInPage,
-            "userLoggedIn", FakeSignal())
-        self.patch(current_user_sign_in_page.CurrentUserSignInPage,
-            "passwordForgotten", FakeSignal())
-        self.patch(current_user_sign_in_page.CurrentUserSignInPage,
-            "userNotValidated", FakeSignal())
-        self.app_name = 'my_app'
-        self.ui = current_user_sign_in_page.CurrentUserSignInPage(
-            current_user_sign_in_ui.Ui_CurrentUserSignInPage(),
-            '',
-            app_name=self.app_name,
-            parent=None)
-        self.wizard = FakeWizard()
-        self.patch(self.ui, 'wizard', lambda: self.wizard)
-
-    def test_init(self):
-        """Test the construction of the object."""
-        self.assertIn('LoggedIn', self.ui._signals)
-        self.assertIn('LoginError', self.ui._signals)
-        self.assertIn('UserNotValidated', self.ui._signals)
-        self.assertTrue(callable(self.ui._signals['LoggedIn']))
-        self.assertTrue(callable(self.ui._signals['LoginError']))
-        self.assertTrue(callable(self.ui._signals['UserNotValidated']))
-        self.assertEqual(self.ui.backend, FakedBackend.sso_login)
-
-    # pylint: disable=E1101
-    def test_setup_page(self):
-        """Test that the backend is received and the methods are called."""
-        exposed_methods = [
-            '_set_translated_strings',
-            '_setup_signals',
-            '_connect_ui']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "_set_translated_strings",
-            faked_object._set_translated_strings)
-        self.patch(self.ui, "_setup_signals",
-            faked_object._setup_signals)
-        self.patch(self.ui, "_connect_ui",
-            faked_object._connect_ui)
-        self.ui.setup_page()
-        self.assertIn('_set_translated_strings', faked_object._called)
-        self.assertIn('_setup_signals', faked_object._called)
-        self.assertIn('_connect_ui', faked_object._called)
-    # pylint: enable=E1101
+    ui_class = current_user_sign_in_page.CurrentUserSignInPage
+    ui_signals = ('userLoggedIn', 'passwordForgotten', 'userNotValidated')
+    ui_backend_signals = ('LoggedIn', 'LoginError', 'UserNotValidated')
 
     def test_on_user_not_validated(self):
         """Test the navigation flow on user not validated."""
@@ -176,12 +120,6 @@
 
     def test_login_with_ping(self):
         """Test the login method."""
-        ping = 'http://ping.me'
-        self.ui.ping_url = ping
-        exposed_methods = ['login', 'login_and_ping']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "backend", faked_object)
         email = 'valid@email'
         password = '123456'
         self.ui.ui.email_edit.setText(email)
@@ -189,15 +127,11 @@
         self.ui.login()
         self.assertEqual(self.ui.overlay.show_counter, 1)
         self.assert_backend_called('login_and_ping',
-            self.app_name, email, password, ping)
+            self.app_name, email, password, self.ping_url)
 
     def test_login_without_ping(self):
         """Test the login method."""
         self.ui.ping_url = ''
-        exposed_methods = ['login']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "backend", faked_object)
         email = 'valid@email'
         password = '123456'
         self.ui.ui.email_edit.setText(email)

=== modified file 'ubuntu_sso/qt/tests/test_email_verification.py'
--- ubuntu_sso/qt/tests/test_email_verification.py	2012-02-23 20:16:46 +0000
+++ ubuntu_sso/qt/tests/test_email_verification.py	2012-02-24 17:28:19 +0000
@@ -17,62 +17,23 @@
 """Tests for the Setup Account page Qt UI."""
 
 from PyQt4 import QtGui, QtCore
-from twisted.internet import defer
 
-from ubuntu_sso.qt import gui
 from ubuntu_sso.qt import email_verification_page
 from ubuntu_sso.qt.tests import (
     BaseTestCase,
-    FakedBackend,
-    FakedObject,
     FakePageUiStyle,
-    FakeSignal,
-    FakeWizard,
 )
-from ubuntu_sso.qt.ui import email_verification_ui
-
-
+
+# is ok to access private method/attrs in tests
 # pylint: disable=W0212
+
+
 class EmailVerificationTestCase(BaseTestCase):
     """Test the SetupAccountPage code."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(EmailVerificationTestCase, self).setUp()
-        self.signals_results = []
-        self.patch(gui.main, "get_sso_client", FakedBackend)
-        self.patch(email_verification_page.EmailVerificationPage,
-            "registrationSuccess", FakeSignal())
-        self.ui = email_verification_page.EmailVerificationPage(
-            email_verification_ui.Ui_EmailVerificationPage(), '',
-            parent=None)
-        self.wizard = FakeWizard()
-        self.patch(self.ui, 'wizard', lambda: self.wizard)
-
-    def test_init(self):
-        """Test the construction of the object."""
-        self.assertIn('EmailValidated', self.ui._signals)
-        self.assertIn('EmailValidationError', self.ui._signals)
-        self.assertTrue(callable(self.ui._signals['EmailValidated']))
-        self.assertTrue(callable(self.ui._signals['EmailValidationError']))
-        self.assertEqual(self.ui.backend, FakedBackend.sso_login)
-
-    # pylint: disable=E1101
-    def test_setup_page(self):
-        """Test that the backend is received and the methods are called."""
-        exposed_methods = [
-            '_setup_signals',
-            '_connect_ui_elements']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "_setup_signals",
-            faked_object._setup_signals)
-        self.patch(self.ui, "_connect_ui_elements",
-            faked_object._connect_ui_elements)
-        self.ui.setup_page()
-        self.assertIn('_setup_signals', faked_object._called)
-        self.assertIn('_connect_ui_elements', faked_object._called)
-    # pylint: enable=E1101
+    ui_class = email_verification_page.EmailVerificationPage
+    ui_signals = ('registrationSuccess',)
+    ui_backend_signals = ('EmailValidated', 'EmailValidationError')
 
     def test_verification_code(self):
         """Test the verification value returned."""
@@ -87,9 +48,9 @@
         self.assertEqual(value, self.ui.ui.next_button)
         self.assertTrue(isinstance(value, QtGui.QPushButton))
 
-    def test_connect_ui_elements(self):
+    def test_connect_ui(self):
         """Test the connect ui method."""
-        self.ui._connect_ui_elements()
+        self.ui._connect_ui()
         # We expect 2 values because _connect_ui is called in the init too.
         self.assertEqual(self.ui.ui.verification_code_edit.receivers(
             QtCore.SIGNAL("textChanged(const QString&)")), 2)
@@ -170,40 +131,29 @@
 
     def test_validate_email_with_ping(self):
         """Test the login method."""
-        ping = 'http://ping.me'
-        app_name = 'app_name'
         email = '[e-mail]'
         password = 'password'
         code = 'code'
-        self.ui.ping_url = ping
-        self.ui.app_name = app_name
         self.ui.email = email
         self.ui.password = password
         self.ui.ui.verification_code_edit.setText(code)
-        exposed_methods = ['validate_email', 'validate_email_and_ping']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "backend", faked_object)
+
         self.ui.validate_email()
+
         self.assert_backend_called('validate_email_and_ping',
-            app_name, email, password, code, ping)
+            self.app_name, email, password, code, self.ping_url)
 
     def test_validate_email_without_ping(self):
         """Test the login method."""
-        ping = ''
-        app_name = 'app_name'
+        self.ui.ping_url = ''
         email = '[e-mail]'
         password = 'password'
         code = 'code'
-        self.ui.ping_url = ping
-        self.ui.app_name = app_name
         self.ui.email = email
         self.ui.password = password
         self.ui.ui.verification_code_edit.setText(code)
-        exposed_methods = ['validate_email', 'validate_email_and_ping']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "backend", faked_object)
+
         self.ui.validate_email()
+
         self.assert_backend_called('validate_email',
-            app_name, email, password, code)
+            self.app_name, email, password, code)

=== modified file 'ubuntu_sso/qt/tests/test_enchanced_line_edit.py'
--- ubuntu_sso/qt/tests/test_enchanced_line_edit.py	2012-01-26 15:34:16 +0000
+++ ubuntu_sso/qt/tests/test_enchanced_line_edit.py	2012-02-24 17:28:19 +0000
@@ -18,13 +18,10 @@
 
 import collections
 
+from PyQt4 import QtGui, QtCore
 from twisted.trial.unittest import TestCase
 
-# pylint: disable=E1101
-
-from PyQt4 import QtGui, QtCore
-
-from ubuntu_sso.qt.gui import EnhancedLineEdit
+from ubuntu_sso.qt.sso_wizard_page import EnhancedLineEdit
 
 
 class EnhancedLineEditTestCase(TestCase):

=== added file 'ubuntu_sso/qt/tests/test_error_page.py'
--- ubuntu_sso/qt/tests/test_error_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/tests/test_error_page.py	2012-02-24 17:28:19 +0000
@@ -0,0 +1,26 @@
+# -*- 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/>.
+
+"""Test the error page."""
+
+from ubuntu_sso.qt.error_page import ErrorPage
+from ubuntu_sso.qt.tests import BaseTestCase
+
+
+class ErrorPageTestCase(BaseTestCase):
+    """Test that the correct widgets are used."""
+
+    ui_class = ErrorPage

=== modified file 'ubuntu_sso/qt/tests/test_forgotten_password.py'
--- ubuntu_sso/qt/tests/test_forgotten_password.py	2012-02-18 15:12:09 +0000
+++ ubuntu_sso/qt/tests/test_forgotten_password.py	2012-02-24 17:28:19 +0000
@@ -17,48 +17,23 @@
 """Tests for the Setup Account page Qt UI."""
 
 from PyQt4 import QtGui, QtCore
-from twisted.internet import defer
 
-from ubuntu_sso.qt import gui
 from ubuntu_sso.qt import forgotten_password_page
 from ubuntu_sso.qt.tests import (
     BaseTestCase,
-    FakedBackend,
-    FakedObject,
-    FakeOverlay,
     FakePageUiStyle,
-    FakeSignal,
-    FakeWizard,
 )
-from ubuntu_sso.qt.ui import forgotten_password_ui
-
-
+
+# is ok to access private method/attrs in tests
 # pylint: disable=W0212, E1101
+
+
 class ForgottenPasswordTestCase(BaseTestCase):
     """Test the SetupAccountPage code."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(ForgottenPasswordTestCase, self).setUp()
-        self.signals_results = []
-        self.patch(gui, "LoadingOverlay", FakeOverlay)
-        self.patch(gui.main, "get_sso_client", FakedBackend)
-        self.patch(forgotten_password_page.ForgottenPasswordPage,
-            "passwordResetTokenSent", FakeSignal())
-        self.app_name = 'my_app'
-        self.ui = forgotten_password_page.ForgottenPasswordPage(
-            forgotten_password_ui.Ui_ForgottenPasswordPage(),
-            app_name=self.app_name, parent=None)
-        self.wizard = FakeWizard()
-        self.patch(self.ui, 'wizard', lambda: self.wizard)
-
-    def test_init(self):
-        """Test the construction of the object."""
-        self.assertIn('PasswordResetTokenSent', self.ui._signals)
-        self.assertIn('PasswordResetError', self.ui._signals)
-        self.assertTrue(callable(self.ui._signals['PasswordResetTokenSent']))
-        self.assertTrue(callable(self.ui._signals['PasswordResetError']))
-        self.assertEqual(self.ui.backend, FakedBackend.sso_login)
+    ui_class = forgotten_password_page.ForgottenPasswordPage
+    ui_siganls = ('passwordResetTokenSent',)
+    ui_backend_siganls = ('PasswordResetTokenSent', 'PasswordResetError')
 
     def test_request_new_password(self):
         """Test the request_new_password function."""
@@ -71,33 +46,6 @@
         self.assert_backend_called('request_password_reset_token',
             app_name, email)
 
-    def test_setup_page(self):
-        """Test that the backend is received and the methods are called."""
-        exposed_methods = [
-            '_setup_signals',
-            '_set_translated_strings',
-            '_connect_ui',
-            '_set_enhanced_line_edit',
-            '_register_fields']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "_setup_signals",
-            faked_object._setup_signals)
-        self.patch(self.ui, "_set_translated_strings",
-            faked_object._set_translated_strings)
-        self.patch(self.ui, "_connect_ui",
-            faked_object._connect_ui)
-        self.patch(self.ui, "_set_enhanced_line_edit",
-            faked_object._set_enhanced_line_edit)
-        self.patch(self.ui, "_register_fields",
-            faked_object._register_fields)
-        self.ui.setup_page()
-        self.assertIn('_setup_signals', faked_object._called)
-        self.assertIn('_set_translated_strings', faked_object._called)
-        self.assertIn('_connect_ui', faked_object._called)
-        self.assertIn('_set_enhanced_line_edit', faked_object._called)
-        self.assertIn('_register_fields', faked_object._called)
-
     def test_email_widget(self):
         """Test the email_widget property."""
         value = self.ui.email_widget

=== modified file 'ubuntu_sso/qt/tests/test_loadingoverlay.py'
--- ubuntu_sso/qt/tests/test_loadingoverlay.py	2012-02-03 14:51:41 +0000
+++ ubuntu_sso/qt/tests/test_loadingoverlay.py	2012-02-24 17:28:19 +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,21 +16,21 @@
 
 """Tests for the Loading Overlay."""
 
-from ubuntu_sso.qt import loadingoverlay as gui
+from ubuntu_sso.qt.loadingoverlay import LoadingOverlay
 from ubuntu_sso.qt.tests import BaseTestCase
 
 
 class LoadingOverlayTestCase(BaseTestCase):
     """Test the qt control panel."""
 
-    innerclass_ui = gui.loadingoverlay_ui
-    innerclass_name = "Ui_Form"
-    class_ui = gui.LoadingOverlay
+    kwargs = {}
+    ui_class = LoadingOverlay
+    ui_wizard_class = None
 
-    # pylint: disable=E1101
-    def assert_status_correct(self):
+    def test_status_correct(self):
         """Test if the necessary variables for the animation exists"""
         self.ui.show()
+        self.addCleanup(self.ui.hide)
+
         self.assertTrue(self.ui.counter is not None)
         self.assertTrue(self.ui.orientation is not None)
-    # pylint: enable=E1101

=== modified file 'ubuntu_sso/qt/tests/test_network_detection.py'
--- ubuntu_sso/qt/tests/test_network_detection.py	2012-02-22 16:58:08 +0000
+++ ubuntu_sso/qt/tests/test_network_detection.py	2012-02-24 17:28:19 +0000
@@ -16,39 +16,28 @@
 
 """The test suite for Network Detection UI."""
 
-from twisted.internet import defer
-
 from PyQt4 import QtGui
 
-from ubuntu_sso.tests import APP_NAME
 from ubuntu_sso.qt import network_detection_page
 from ubuntu_sso.qt.tests import (
     BaseTestCase,
     FakeWizardButtonStyle,
 )
 
+# is ok to access private method/attrs in tests
+# pylint: disable=W0212, E1101
+
 
 class NetworkDetectionTestCase(BaseTestCase):
 
     """Test the CurrentUserController."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this test instance."""
-        yield super(NetworkDetectionTestCase, self).setUp()
-        self.wizard = FakeWizardButtonStyle()
-        self.network_detection = network_detection_page.NetworkDetectionPage(
-                                                            app_name=APP_NAME)
-        self.patch(self.network_detection, 'wizard', self._get_wizard)
-
-    def _get_wizard(self):
-        """Fake wizard method for wizard page."""
-        return self.wizard
-
-    # pylint: disable=W0212
+    ui_class = network_detection_page.NetworkDetectionPage
+    ui_wizard_class = FakeWizardButtonStyle
+
     def test_initialize_page(self):
         """Check Network detection initialize page."""
-        self.network_detection.initializePage()
+        self.ui.initializePage()
         self.assertEqual(self.wizard._next_id, None)
         self.assertTrue(('setButtonLayout', ([
             QtGui.QWizard.Stretch,
@@ -58,18 +47,16 @@
 
     def test_initialize_page_button_property(self):
         """Test the Try Again button properties."""
-        self.patch(self.network_detection,
-            "wizard", FakeWizardButtonStyle)
-        self.network_detection.initializePage()
-        self.assertTrue(self.network_detection.btn_try_again.isDefault())
-        self.assertIn('polish', self.network_detection.btn_try_again.data)
-        self.assertIn('unpolish', self.network_detection.btn_try_again.data)
-        self.assertEqual(
-            self.network_detection.btn_try_again.data['polish'],
-            self.network_detection.btn_try_again)
-        self.assertEqual(
-            self.network_detection.btn_try_again.data['unpolish'],
-            self.network_detection.btn_try_again)
+        self.ui.initializePage()
+        self.assertTrue(self.ui.btn_try_again.isDefault())
+        self.assertIn('polish', self.ui.btn_try_again.data)
+        self.assertIn('unpolish', self.ui.btn_try_again.data)
+        self.assertEqual(
+            self.ui.btn_try_again.data['polish'],
+            self.ui.btn_try_again)
+        self.assertEqual(
+            self.ui.btn_try_again.data['unpolish'],
+            self.ui.btn_try_again)
 
     def test_try_again_with_connection(self):
         """Check try again method with connection."""
@@ -78,7 +65,7 @@
         self.wizard._next_id = -1
         if 'next' in self.wizard.data:
             self.wizard.data.pop('next')
-        self.network_detection.try_again()
+        self.ui.try_again()
         self.assertEqual(self.wizard._next_id, None)
         self.assertTrue(self.wizard.data.get('next', False))
 
@@ -89,7 +76,6 @@
         self.wizard._next_id = -1
         if 'next' in self.wizard.data:
             self.wizard.data.pop('next')
-        self.network_detection.try_again()
+        self.ui.try_again()
         self.assertEqual(self.wizard._next_id, -1)
         self.assertFalse(self.wizard.data.get('next', False))
-    # pylint: enable=W0212

=== modified file 'ubuntu_sso/qt/tests/test_reset_password.py'
--- ubuntu_sso/qt/tests/test_reset_password.py	2012-02-15 17:33:40 +0000
+++ ubuntu_sso/qt/tests/test_reset_password.py	2012-02-24 17:28:19 +0000
@@ -18,40 +18,19 @@
 # pylint: disable=F0401,E0611,E1101
 
 from PyQt4 import QtGui, QtCore
-from twisted.internet import defer
 
 from ubuntu_sso.utils.ui import (
     PASSWORD1_ENTRY,
     PASSWORD2_ENTRY,
-    RESET_CODE_ENTRY)
-from ubuntu_sso.qt import gui
+    RESET_CODE_ENTRY,
+)
 from ubuntu_sso.qt import common
 from ubuntu_sso.qt.reset_password_page import (
     ResetPasswordPage,
     RESET_SUBTITLE,
     RESET_TITLE,
 )
-from ubuntu_sso.qt.ui.reset_password_ui import Ui_ResetPasswordPage
-from ubuntu_sso.qt.tests import (
-    BaseTestCase,
-    FakedBackend,
-    FakedObject,
-    FakeWizard,
-)
-
-
-class FakePasswordAssistance(object):
-    """Fake password_assistance_* calls."""
-
-    _called = False
-
-    def call(self, *args, **kwargs):
-        """Check if the method was called."""
-        FakePasswordAssistance._called = True
-
-    def clenaup(self):
-        """Clean up the variable."""
-        FakePasswordAssistance._called = False
+from ubuntu_sso.qt.tests import BaseTestCase
 
 
 # We need this Fake until a future refactor.
@@ -78,19 +57,11 @@
 class ResetPasswordTestCase(BaseTestCase):
     """Test the ResetPasswordPage code."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(ResetPasswordTestCase, self).setUp()
-        self.patch(gui.main, "get_sso_client", FakedBackend)
-        self.app_name = 'my_app'
-        self.ui = ResetPasswordPage(Ui_ResetPasswordPage(),
-                                                app_name=self.app_name,
-                                                parent=None)
-        self.wizard = FakeWizard()
-        self.patch(self.ui, 'wizard', lambda: self.wizard)
-        self.fake = FakePasswordAssistance()
+    ui_class = ResetPasswordPage
+    ui_signals = ('passwordChanged',)
+    ui_backend_siganls = ('PasswordChanged', 'PasswordChangeError')
 
-    def test_init(self):
+    def test_password_line(self):
         """Check the initial state of ResetPassword."""
         self.assertEqual(self.ui.ui.password_line_edit.receivers(
             QtCore.SIGNAL('textEdited(QString)')), 1)
@@ -131,25 +102,27 @@
 
     def test_focus_changed_1(self):
         """Check functions execution when focus_changed() is executed."""
-        self.patch(common, 'password_default_assistance', self.fake.call)
-        self.addCleanup(self.fake.clenaup)
+        self.patch(common, 'password_default_assistance', self._set_called)
+
         self.ui.show()
         self.addCleanup(self.ui.hide)
-        self.assertFalse(FakePasswordAssistance._called)
+
+        self.assertFalse(self._called)
         self.ui.focus_changed(None, self.ui.ui.password_line_edit)
         self.assertTrue(self.ui.ui.password_assistance.isVisible())
-        self.assertTrue(FakePasswordAssistance._called)
+        self.assertTrue(self._called)
 
     def test_focus_changed_2(self):
         """Check functions execution when focus_changed() is executed."""
-        self.patch(common, 'password_check_match', self.fake.call)
-        self.addCleanup(self.fake.clenaup)
+        self.patch(common, 'password_check_match', self._set_called)
+
         self.ui.show()
         self.addCleanup(self.ui.hide)
-        self.assertFalse(FakePasswordAssistance._called)
+
+        self.assertFalse(self._called)
         self.ui.focus_changed(None, self.ui.ui.confirm_password_line_edit)
         self.assertTrue(self.ui.ui.password_assistance.isVisible())
-        self.assertTrue(FakePasswordAssistance._called)
+        self.assertTrue(self._called)
 
     # pylint: enable=W0212
 
@@ -161,12 +134,10 @@
         forgotten = FakeForgottenPage()
         forgotten.setText(email)
         self.patch(self.wizard, "forgotten", forgotten)
-        exposed_methods = ['set_new_password']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "backend", faked_object)
         self.ui.ui.reset_code_line_edit.setText(code)
         self.ui.ui.password_line_edit.setText(password)
+
         self.ui.set_new_password()
+
         self.assert_backend_called('set_new_password',
             self.app_name, email, code, password)

=== modified file 'ubuntu_sso/qt/tests/test_setup_account.py'
--- ubuntu_sso/qt/tests/test_setup_account.py	2012-02-18 15:12:09 +0000
+++ ubuntu_sso/qt/tests/test_setup_account.py	2012-02-24 17:28:19 +0000
@@ -18,45 +18,22 @@
 
 from PyQt4 import QtGui, QtCore
 
-from twisted.internet import defer
-
-from ubuntu_sso.qt import gui
-from ubuntu_sso.qt import common
-from ubuntu_sso.qt import setup_account_page
+from ubuntu_sso.qt import common, setup_account_page
 from ubuntu_sso.qt.tests import (
     BaseTestCase,
-    FakedBackend,
-    FakedObject,
-    FakeOverlay,
-    FakeSignal,
-    FakeWizard,
+    HELP_TEXT,
 )
-from ubuntu_sso.qt.ui import setup_account_ui
 
 
 class SetupAccountTestCase(BaseTestCase):
     """Test the SetupAccountPage code."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(SetupAccountTestCase, self).setUp()
-        self.patch(gui.main, "get_sso_client", FakedBackend)
-        self.signals_results = []
-        self.patch(setup_account_page.SetupAccountPage,
-            "userRegistered", FakeSignal())
-        self.app_name = 'my_app'
-        self.ui = setup_account_page.SetupAccountPage(
-            setup_account_ui.Ui_SetUpAccountPage(),
-            'subtitle',
-            'toc_link',
-            'policy_link',
-            app_name=self.app_name,
-            parent=None)
-        self.wizard = FakeWizard()
-        self.patch(self.ui, 'wizard', lambda: self.wizard)
-        self.patch(self.ui, "set_up_button", QtGui.QPushButton())
+    ui_class = setup_account_page.SetupAccountPage
+    ui_signals = ('userRegistered',)
+    ui_backend_signals = ('CaptchaGenerated', 'CaptchaGenerationError',
+                          'UserRegistered', 'UserRegistrationError')
 
-    def test_init(self):
+    def test_password_receiver(self):
         """Check the initial state of SetupAccount."""
         self.assertEqual(self.ui.ui.password_edit.receivers(
             QtCore.SIGNAL('textEdited(QString)')), 2)
@@ -79,6 +56,8 @@
 
     def test_enable_setup_button_with_visible_check(self):
         """Test _enable_setup_button method with terms check visible."""
+        self.patch(self.ui, "set_up_button", QtGui.QPushButton())
+
         self.ui.ui.name_edit.setText('name')
         email = '[e-mail]'
         self.ui.ui.email_edit.setText(email)
@@ -97,6 +76,8 @@
 
     def test_enable_setup_button_without_visible_check(self):
         """Test _enable_setup_button method with terms check not visible."""
+        self.patch(self.ui, "set_up_button", QtGui.QPushButton())
+
         self.ui.ui.name_edit.setText('name')
         email = '[e-mail]'
         self.ui.ui.email_edit.setText(email)
@@ -170,10 +151,6 @@
 
     def test_on_user_registered(self):
         """Test on_user_registered method."""
-        exposed_methods = ['register_user']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "backend", faked_object)
         self.patch(self.ui, "validate_form", lambda: True)
 
         email = 'email@example'
@@ -190,8 +167,11 @@
         def slot(email, password):
             """Fake slot."""
             self.signals_results.append((email, password))
+
         self.ui.userRegistered.connect(slot)
+
         self.ui.set_next_validation()
+
         self.assertIn((email, password), self.signals_results)
         self.assert_backend_called('register_user',
             self.app_name, email, password, name, captcha_id,
@@ -217,29 +197,6 @@
         self.assert_backend_called('generate_captcha',
             self.app_name, self.ui.captcha_file)
 
-
-class SetupAccountFakeWizardTestCase(BaseTestCase):
-    """Test the SetupAccountPage code."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this test instance."""
-        # Faking each SSO object instead of doing it lower
-        # so we don't rely on any SSO behaviour
-        yield super(SetupAccountFakeWizardTestCase, self).setUp()
-        self.patch(gui, "LoadingOverlay", FakeOverlay)
-        self.app_name = 'my_app'
-        self._subtitle = 'subtitle'
-        self.ui = setup_account_page.SetupAccountPage(
-            setup_account_ui.Ui_SetUpAccountPage(),
-            self._subtitle,
-            'toc_link',
-            'policy_link',
-            app_name=self.app_name,
-            parent=None)
-        self.wizard = FakeWizard()
-        self.patch(self.ui, 'wizard', lambda: self.wizard)
-
     def test_initialize_page(self):
         """Widgets are properly initialized."""
         self.ui.initializePage()
@@ -251,7 +208,11 @@
         title_expected = (setup_account_page.TITLE_STYLE %
             setup_account_page.TITLE.format(app_name=self.app_name))
         self.assertEqual(title, title_expected)
-        self.assertEqual(self.ui.header.subtitle_label.text(), self._subtitle)
+
+        elided_text = unicode(self.ui.header.subtitle_label.text())
+        elided_text = elided_text[:len(elided_text) - 1]
+        self.assertTrue(HELP_TEXT.startswith(elided_text))
+        self.assertEqual(self.ui.header.subtitle_label.toolTip(), HELP_TEXT)
 
         # set up account button
         expected = [QtGui.QWizard.BackButton, QtGui.QWizard.Stretch,

=== removed file 'ubuntu_sso/qt/tests/test_sign_in_page.py'
--- ubuntu_sso/qt/tests/test_sign_in_page.py	2012-02-15 17:33:40 +0000
+++ ubuntu_sso/qt/tests/test_sign_in_page.py	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-# -*- 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/>.
-
-"""The test suite for Sign In UI."""
-
-from PyQt4 import QtGui
-from twisted.internet import defer
-
-from ubuntu_sso.qt import sign_in_page as gui
-from ubuntu_sso.qt.ui.choose_sign_in_ui import Ui_ChooseSignInPage
-from ubuntu_sso.qt.tests import BaseTestCase, FakeMainWindow, FakeSignal
-
-
-class SignInPageTestCase(BaseTestCase):
-    """Test the SignInPage code."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Initialize this test instance."""
-        yield super(SignInPageTestCase, self).setUp()
-        self.signals_results = []
-        self.patch(gui.SignInPage, "existingAccountSelected", FakeSignal())
-        self.patch(gui.SignInPage, "newAccountSelected", FakeSignal())
-        self.patch(gui.SignInPage, "singInCanceled", FakeSignal())
-        self.ui = gui.SignInPage(Ui_ChooseSignInPage(), QtGui.QPixmap())
-
-    def test_show_event(self):
-        """Check the page is initialized correctly."""
-        wizard = FakeMainWindow()
-        self.patch(self.ui, 'wizard', lambda *args: wizard)
-        self.ui.initializePage()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
-        self.assertTrue(self.ui.ui.existing_account_button.isDefault())
-
-    # pylint: disable=W0212
-    def test_set_next_existing(self):
-        """Test _set_next_existing method."""
-
-        def slot():
-            """Fake slot."""
-            self.signals_results.append(1)
-        self.ui.existingAccountSelected.connect(slot)
-        self.ui._set_next_existing()
-        self.assertIn(1, self.signals_results)
-
-    def test_set_next_new(self):
-        """Test _set_next_existing method."""
-
-        def slot():
-            """Fake slot."""
-            self.signals_results.append(1)
-        self.ui.newAccountSelected.connect(slot)
-        self.ui._set_next_new()
-        self.assertIn(1, self.signals_results)
-    # pylint: enable=W0212

=== renamed file 'ubuntu_sso/qt/tests/test_qt_views.py' => 'ubuntu_sso/qt/tests/test_sso_wizard_page.py'
--- ubuntu_sso/qt/tests/test_qt_views.py	2012-02-24 13:57:19 +0000
+++ ubuntu_sso/qt/tests/test_sso_wizard_page.py	2012-02-24 17:28:19 +0000
@@ -13,107 +13,23 @@
 #
 # 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 interaction of the view with the auto generated code."""
-
-from unittest import TestCase
-from mocker import MATCH, Mocker
-
-from PyQt4 import QtGui
-
-from ubuntu_sso.qt.error_page import ErrorPage
-from ubuntu_sso.qt.sign_in_page import SignInPage
-from ubuntu_sso.qt.success_page import SuccessPage
+
+"""Test the SSOWizardPage and related."""
+
+from twisted.internet import defer
 
 from ubuntu_sso.qt import PREFERED_UI_SIZE
-from ubuntu_sso.qt.gui import Header
-from ubuntu_sso.qt.ui.choose_sign_in_ui import Ui_ChooseSignInPage
-from ubuntu_sso.qt.ui.error_message_ui import Ui_ErrorPage
-from ubuntu_sso.qt.ui.success_message_ui import Ui_SuccessPage
-
-
-class FakeController(object):
-    """A fake controller for the tests."""
-
-    # pylint: disable=C0103
-    def setupUi(self, view):
-        """Fake the setup."""
-    # pylint: enable=C0103
-
-
-class ChooseSignInPageTestCase(TestCase):
-    """Test the ChooseSignInPage."""
-
-    def setUp(self):
-        """Set up the tests."""
-        super(ChooseSignInPageTestCase, self).setUp()
-        self.ui = Ui_ChooseSignInPage()
-        self.controller = FakeController()
-        self.widget = SignInPage(self.ui, QtGui.QPixmap())
-
-    def tearDown(self):
-        self.widget.close()
-
-    def test_constructor(self):
-        """Test the constructor of the class."""
-        # used a mocked ui for this
-        mocker = Mocker()
-        ui = mocker.mock()
-        ui.setupUi(MATCH(lambda x: isinstance(x, SignInPage)))
-        mocker.replay()
-        self.widget = SignInPage(self.ui, QtGui.QPixmap())
-
-    def test_next_id(self):
-        """Test the nextId method."""
-        next_id = 1
-        self.widget.next = next_id
-        self.assertEqual(next_id, self.widget.nextId())
-
-
-class SuccessPageTestCase(TestCase):
-    """Test that the correct widgets are used."""
-
-    def setUp(self):
-        """Setup tests."""
-        super(SuccessPageTestCase, self).setUp()
-        self.ui = Ui_SuccessPage()
-        self.widget = SuccessPage(self.ui, QtGui.QPixmap())
-
-    def test_constructor(self):
-        """Test that the constructor works as expected."""
-        mocker = Mocker()
-        ui = mocker.mock()
-        ui.setupUi(MATCH(lambda x: isinstance(x, SuccessPage)))
-        mocker.replay()
-        self.widget = SuccessPage(self.ui, QtGui.QPixmap())
-
-
-class ErrorPageTestCase(TestCase):
-    """Test that the correct widgets are used."""
-
-    def setUp(self):
-        """Setup tests."""
-        super(ErrorPageTestCase, self).setUp()
-        self.ui = Ui_ErrorPage()
-        self.controller = FakeController()
-        self.widget = ErrorPage(self.ui, self.controller)
-
-    def test_constructor(self):
-        """Test that the constructor works as expected."""
-        mocker = Mocker()
-        ui = mocker.mock()
-        controller = mocker.mock()
-        ui.setupUi(MATCH(lambda x: isinstance(x, ErrorPage)))
-        controller.setupUi(MATCH(lambda x: isinstance(x, ErrorPage)))
-        mocker.replay()
-        self.widget = ErrorPage(self.ui, self.controller)
-
-
-class HeaderTest(TestCase):
+from ubuntu_sso.qt.sso_wizard_page import Header
+from ubuntu_sso.qt.tests import BaseTestCase
+
+
+class HeaderTest(BaseTestCase):
+
     """Tests for injected Header in each Wizard Page."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        """Setup test."""
-        super(HeaderTest, self).setUp()
+        yield super(HeaderTest, self).setUp()
         self.header = Header()
 
     def test_label_state(self):

=== added file 'ubuntu_sso/qt/tests/test_success_page.py'
--- ubuntu_sso/qt/tests/test_success_page.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/tests/test_success_page.py	2012-02-24 17:28:19 +0000
@@ -0,0 +1,26 @@
+# -*- 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/>.
+
+"""Test the success page."""
+
+from ubuntu_sso.qt.success_page import SuccessPage
+from ubuntu_sso.qt.tests import BaseTestCase
+
+
+class SuccessPageTestCase(BaseTestCase):
+    """Test that the correct widgets are used."""
+
+    ui_class = SuccessPage

=== modified file 'ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-02-24 14:58:30 +0000
+++ ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-02-24 17:28:19 +0000
@@ -20,21 +20,24 @@
 from twisted.internet import defer
 
 from ubuntu_sso.qt import PREFERED_UI_SIZE, ubuntu_sso_wizard
-from ubuntu_sso.qt.tests import (
-    BaseTestCase,
-    FakedObject,
-)
-
-
-class ReturnCodeTestCase(BaseTestCase):
-    """Test the return codes."""
+from ubuntu_sso.qt.tests import BaseTestCase
+
+
+# is ok to access private method/attrs in tests
+# pylint: disable=W0212
+
+
+class UbuntuSSOClientGUITestCase(BaseTestCase):
+
+    """Test the UbuntuSSOClientGUI class."""
+
+    ui_class = ubuntu_sso_wizard.UbuntuSSOClientGUI
+    ui_wizard_class = None
 
     @defer.inlineCallbacks
     def setUp(self):
-        yield super(ReturnCodeTestCase, self).setUp()
+        yield super(UbuntuSSOClientGUITestCase, self).setUp()
         self.patch(ubuntu_sso_wizard.sys, 'exit', self._set_called)
-        self.app_name = 'app_name'
-        self.ui = ubuntu_sso_wizard.UbuntuSSOClientGUI(self.app_name)
 
     def test_closing_main_window(self):
         """When closing the main window, USER_CANCELLATION is returned."""
@@ -42,44 +45,36 @@
         self.assertEqual(self._called,
             ((ubuntu_sso_wizard.USER_CANCELLATION,), {}))
 
-    # pylint: disable=W0212
     def test_close_main_window_reaching_success_page(self):
         """Closing the window in success page, USER_SUCCESS is returned."""
-        email = '[e-mail]'
-        self.ui.wizard._move_to_success_page(self.app_name, email)
+        self.ui.wizard._move_to_success_page()
         self.ui.close()
         self.assertEqual(self._called,
             ((ubuntu_sso_wizard.USER_SUCCESS,), {}))
-    # pylint: enable=W0212
 
-    def test_closing_wizard(self):
+    def test_closing_wizard_no_parent(self):
         """When closing the wizard, USER_CANCELLATION is returned."""
         self.ui.wizard.setParent(None)
         self.ui.wizard.close()
         self.assertEqual(self._called,
             ((ubuntu_sso_wizard.USER_CANCELLATION,), {}))
 
-    # pylint: disable=W0212
-    def test_close_wizard_reaching_success_page(self):
+    def test_close_wizard_no_parent_reaching_success_page(self):
         """Closing the wizard in success page, USER_SUCCESS is returned."""
         self.ui.wizard.setParent(None)
-        email = '[e-mail]'
-        self.ui.wizard._move_to_success_page(self.app_name, email)
+        self.ui.wizard._move_to_success_page()
         self.ui.wizard.close()
         self.assertEqual(self._called,
             ((ubuntu_sso_wizard.USER_SUCCESS,), {}))
-    # pylint: enable=W0212
 
 
 class UbuntuSSOWizardTestCase(BaseTestCase):
 
-    """Test Case for UbuntuSSOWizard"""
+    """Test case for UbuntuSSOWizard class."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(UbuntuSSOWizardTestCase, self).setUp()
-        self.app_name = 'app_name'
-        self.ui = ubuntu_sso_wizard.UbuntuSSOWizard(self.app_name)
+    ui_class = ubuntu_sso_wizard.UbuntuSSOWizard
+    ui_signals = ('recoverableError', 'loginSuccess', 'registrationSuccess')
+    ui_wizard_class = None
 
     def test_window_size(self):
         """check the window size."""
@@ -89,32 +84,13 @@
         self.assertEqual(size.height(), PREFERED_UI_SIZE['height'])
         self.assertEqual(size.width(), PREFERED_UI_SIZE['width'])
 
-    # pylint: disable=W0212
     def test_move_to_success_page_state(self):
         """Test _move_to_success_page method."""
         self.patch(self.ui, 'setButtonLayout', self._set_called)
-        self.ui._move_to_success_page(self.app_name)
+        self.ui._move_to_success_page()
         self.assertEqual(self.ui._next_id, -1)
         self.assertEqual(self.ui._next_id, -1)
         self.assertEqual(self._called,
             (([QtGui.QWizard.Stretch, QtGui.QWizard.FinishButton],), {}))
         self.assertTrue(self.ui.button(QtGui.QWizard.FinishButton).isEnabled())
-        self.assertEqual(self.ui._done, ubuntu_sso_wizard.USER_SUCCESS)
-    # pylint: enable=W0212
-
-    # pylint: disable=W0212, E1101
-    def test_sing_in_canceled_connection(self):
-        """Test if sign in canceled signal calls close and not reject."""
-        exposed_methods = [
-            'close',
-            'reject']
-        self.patch(FakedObject, "exposed_methods", exposed_methods)
-        faked_object = FakedObject()
-        self.patch(self.ui, "closeEvent", faked_object.close)
-        self.patch(self.ui, "reject", faked_object.reject)
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
-        self.ui.sign_in_page.ui.cancel_button.clicked.emit(True)
-        self.assertIn('close', faked_object._called)
-        self.assertNotIn('reject', faked_object._called)
-    # pylint: enable=W0212, E1101
+        self.assertEqual(self.ui.exit_code, ubuntu_sso_wizard.USER_SUCCESS)

=== modified file 'ubuntu_sso/qt/ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/ubuntu_sso_wizard.py	2012-02-24 14:58:30 +0000
+++ ubuntu_sso/qt/ubuntu_sso_wizard.py	2012-02-24 17:28:19 +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,14 +21,11 @@
 from PyQt4.QtCore import pyqtSignal
 from PyQt4.QtGui import (
     QFrame,
-    QPixmap,
     QVBoxLayout,
     QWizard,
 )
-from twisted.internet import defer
 
 from ubuntu_sso import (
-    NO_OP,
     USER_CANCELLATION,
     USER_SUCCESS,
 )
@@ -40,17 +37,7 @@
 from ubuntu_sso.qt.forgotten_password_page import ForgottenPasswordPage
 from ubuntu_sso.qt.reset_password_page import ResetPasswordPage
 from ubuntu_sso.qt.setup_account_page import SetupAccountPage
-from ubuntu_sso.qt.sign_in_page import SignInPage
 from ubuntu_sso.qt.success_page import SuccessPage
-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
-
 
 logger = setup_logging('ubuntu_sso.gui')
 
@@ -65,83 +52,61 @@
 
     def __init__(self, app_name, **kwargs):
         """Create a new wizard."""
-        parent = kwargs.get('parent')
-        super(UbuntuSSOWizard, self).__init__(parent)
+        logger.debug('UbuntuSSOWizard: app_name %r, kwargs %r.',
+                     app_name, kwargs)
+        parent = kwargs.pop('parent', None)
+        super(UbuntuSSOWizard, self).__init__(parent=parent)
         self._next_id = -1
         self.setOption(QWizard.HaveFinishButtonOnEarlyPages, True)
-        self._done = USER_CANCELLATION
+        self.setOption(QWizard.NoBackButtonOnStartPage, True)
+        self.exit_code = USER_CANCELLATION
 
-        # 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.policy_url = kwargs.get('policy_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)
-        self.login_success_callback = NO_OP
-        self.registration_success_callback = NO_OP
-        self.user_cancellation_callback = NO_OP
+        self.login_only = kwargs.pop('login_only', False)
+        self.close_callback = kwargs.pop('close_callback', lambda: None)
+
+        # store the ids of the pages so that it is easier to access them later
+        self._pages = {}
+
+        # prepare kwargs to be suitable for the pages
+        kwargs['app_name'] = self.app_name
+        kwargs['parent'] = self
 
         # set the diff pages of the QWizard
-        self.sign_in_page = SignInPage(Ui_ChooseSignInPage(),
-                                       QPixmap(),
-                                       app_name=self.app_name,
-                                       parent=self)
-        self.sign_in_page.singInCanceled.connect(self.close)
-        self.sign_in_page.existingAccountSelected.connect(
-            self._move_to_login_page)
-        self.sign_in_page.newAccountSelected.connect(
-            self._move_to_setup_account_page)
-
-        self.setup_account = SetupAccountPage(Ui_SetUpAccountPage(),
-                                              self.help_text,
-                                              self.tc_url,
-                                              self.policy_url,
-                                              app_name=self.app_name,
-                                              parent=self)
-        self.setup_account.userRegistered.connect(
-            self._move_to_email_verification_page)
-
-        self.current_user = CurrentUserSignInPage(Ui_CurrentUserSignInPage(),
-                                                  self.ping_url,
-                                                  app_name=self.app_name,
-                                                  parent=self)
+        if not self.login_only:
+            self.setup_account = SetupAccountPage(**kwargs)
+            self.setup_account.userRegistered.connect(
+                self._move_to_email_verification_page)
+            self.addPage(self.setup_account)
+
+        self.current_user = CurrentUserSignInPage(**kwargs)
         self.current_user.userNotValidated.connect(
             self._move_to_email_verification_page)
         self.current_user.userLoggedIn.connect(self._move_to_success_page)
         self.current_user.passwordForgotten.connect(
             self._move_to_forgotten_page)
+        self.addPage(self.current_user)
 
-        self.email_verification = EmailVerificationPage(
-                                                Ui_EmailVerificationPage(),
-                                                self.ping_url,
-                                                app_name=self.app_name)
+        self.email_verification = EmailVerificationPage(**kwargs)
         self.email_verification.registrationSuccess.connect(
             self._move_to_success_page)
-
-        self.success = SuccessPage(Ui_SuccessPage(), QPixmap(),
-                                   app_name=self.app_name, parent=self)
-        self.error = ErrorPage(Ui_ErrorPage(),
-                               app_name=self.app_name)
-        self.forgotten = ForgottenPasswordPage(Ui_ForgottenPasswordPage(),
-                                               app_name=self.app_name,
-                                               parent=self)
+        self.addPage(self.email_verification)
+
+        self.success = SuccessPage(**kwargs)
+        self.addPage(self.success)
+
+        self.error = ErrorPage(**kwargs)
+        self.addPage(self.error)
+
+        self.forgotten = ForgottenPasswordPage(**kwargs)
         self.forgotten.passwordResetTokenSent.connect(
             self._move_to_reset_password_page)
+        self.addPage(self.forgotten)
 
-        self.reset_password = ResetPasswordPage(Ui_ResetPasswordPage(),
-                                                app_name=self.app_name,
-                                                parent=self)
-        self.reset_password.passwordChanged.connect(
-            self._go_back_to_current_page)
-        # store the ids of the pages so that it is easier to access them later
-        pages = [self.sign_in_page, self.setup_account,
-                     self.email_verification, self.current_user, self.success,
-                     self.error, self.forgotten, self.reset_password]
-        self._pages = {}
-        for page in pages:
-            self._pages[page] = self.addPage(page)
+        self.reset_password = ResetPasswordPage(**kwargs)
+        back = lambda *a: self._go_back_to_current_page(self.current_user)
+        self.reset_password.passwordChanged.connect(back)
+        self.addPage(self.reset_password)
 
         # set the buttons layout to only have cancel and back since the next
         # buttons are the ones used in the diff pages.
@@ -152,24 +117,29 @@
         self.setButtonLayout(buttons_layout)
         self.setWindowTitle(self.app_name)
         self.setWizardStyle(QWizard.ModernStyle)
-        self.button(QWizard.CancelButton).clicked.connect(
-                                                    self.on_user_cancelation)
+        self.button(QWizard.CancelButton).clicked.connect(self.close)
         self.setMinimumSize(PREFERED_UI_SIZE['width'],
             PREFERED_UI_SIZE['height'])
 
     # pylint: disable=C0103
+
     def nextId(self):
         """Return the id of the next page."""
         return self._next_id
+
+    def addPage(self, page):
+        """Add 'page' to this wizard."""
+        page_id = super(UbuntuSSOWizard, self).addPage(page)
+        self._pages[page] = page_id
+
     # pylint: enable=C0103
 
-    def _go_back_to_current_page(self, email):
-        """Move back until it reaches the current user sign in page. """
-        self.current_user.ui.email_edit.setText(email)
-        current_user_id = self.current_user_page_id
+    def _go_back_to_page(self, page):
+        """Move back until it reaches the 'page'."""
+        page_id = self._pages[page]
         visited_pages = self.visitedPages()
         for index in reversed(visited_pages):
-            if index == current_user_id:
+            if index == page_id:
                 break
             self.back()
 
@@ -179,12 +149,9 @@
         self.next()
         self._next_id = -1
 
-    def _move_to_email_verification_page(self, email, password):
+    def _move_to_email_verification_page(self):
         """Move to the email verification page wizard."""
         self._next_id = self.email_verification_page_id
-        self.email_verification.email = unicode(email)
-        self.email_verification.password = unicode(password)
-        self.email_verification.set_titles(email)
         self.next()
         self._next_id = -1
 
@@ -200,7 +167,7 @@
         self.next()
         self._next_id = -1
 
-    def _move_to_success_page(self, app_name='', email=''):
+    def _move_to_success_page(self):
         """Move to the success page wizard."""
         self._next_id = self.success_page_id
         self.next()
@@ -209,7 +176,7 @@
             QWizard.FinishButton])
         self.button(QWizard.FinishButton).setEnabled(True)
         self.button(QWizard.FinishButton).setFocus()
-        self._done = USER_SUCCESS
+        self.exit_code = USER_SUCCESS
         self._next_id = -1
 
     def _move_to_forgotten_page(self):
@@ -219,11 +186,6 @@
         self._next_id = -1
 
     @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]
@@ -258,76 +220,18 @@
         """Return the id of the error page."""
         return self._pages[self.error]
 
-    def on_user_cancelation(self):
-        """Process the cancel action."""
-        logger.debug('UbuntuSSOWizard.on_user_cancelation')
-        self.user_cancellation_callback(self.app_name)
-        self.close()
-
-    @defer.inlineCallbacks
-    def on_login_success(self, app_name, email):
-        """Process the success of a login."""
-        logger.debug('UbuntuSSOWizard.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('UbuntuSSOWizard.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.currentPage().next = self.success_page_id
-        self.next()
-        # show the finish button but with a close message
-        buttons_layout = []
-        buttons_layout.append(QWizard.Stretch)
-        buttons_layout.append(QWizard.FinishButton)
-        self.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.currentPage().next = self.error_page_id
-        self.next()
-        # show the finish button but with a close message
-        buttons_layout = []
-        buttons_layout.append(QWizard.Stretch)
-        buttons_layout.append(QWizard.FinishButton)
-        self.setButtonLayout(buttons_layout)
-
-    # pylint: disable=C0103, W0212
+    # pylint: disable=C0103
+
     def closeEvent(self, event):
         """Catch close event and send the proper return code."""
         if self.parent() is not None:
             self.parent().close()
         else:
-            sys.exit(self._done)
-    # pylint: enable=C0103, W0212
-
-
-# pylint: disable=W0201
+            sys.exit(self.exit_code)
+
+    # pylint: enable=C0103
+
+
 class UbuntuSSOClientGUI(QFrame):
     """Ubuntu single sign-on GUI."""
 
@@ -345,41 +249,10 @@
         self.wizard = UbuntuSSOWizard(app_name=app_name, **kwargs)
         vbox.addWidget(self.wizard)
 
-    def get_login_success_callback(self):
-        """Return the log in success cb."""
-        return self.view.login_success_callback
-
-    def set_login_success_callback(self, cb):
-        """Set log in success cb."""
-        self.view.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.view.registration_success_callback
-
-    def set_registration_success_callback(self, cb):
-        """Set registration success cb."""
-        self.view.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.view.user_cancellation_callback
-
-    def set_user_cancellation_callback(self, cb):
-        """Set the user cancellation callback."""
-        self.view.user_cancellation_callback = cb
-
-    user_cancellation_callback = property(get_user_cancellation_callback,
-                                          set_user_cancellation_callback)
-
-    # pylint: disable=C0103, W0212
+    # pylint: disable=C0103
+
     def closeEvent(self, event):
         """Catch close event and send the proper return code."""
-        sys.exit(self.wizard._done)
-    # pylint: enable=C0103, W0212
+        sys.exit(self.wizard.exit_code)
+
+    # pylint: enable=C0103