Merge lp:~nataliabidart/ubuntu-sso-client/reusable-headers into lp:ubuntu-sso-client

[Natalia Bidart]

- The tooltip should not be shown for titles and subtitles when no cut off was
  needed (LP: #949741).
- Making the WizardHeader a reusable class.
- Added some minor logging to build_general_error_msg.
- Improved code for the 'sign in' button validation.

[lp:~nataliabidart/ubuntu-sso-client/reusable-headers]

914. By Natalia Bidart on 2012-03-13

Fixed tests.

915. By Natalia Bidart on 2012-03-13

Fixed lint issues.

916. By Natalia Bidart on 2012-03-13

Pep8 fixes.

[Diego Sarmentero (diegosarmentero)]

Text conflict in ubuntu_sso/qt/tests/test_email_verification.py
1 conflicts encountered.

review: Needs Fixing

[lp:~nataliabidart/ubuntu-sso-client/reusable-headers]

917. By Natalia Bidart on 2012-03-14

Merged trunk in.

918. By Natalia Bidart on 2012-03-14

- Added some minor logging to build_general_error_msg.

919. By Natalia Bidart on 2012-03-14

- Do not hide the error when a new captcha is requested, since that will
  immediatly hide a potential error shown from a just-failed registration
  attempt.

920. By Natalia Bidart on 2012-03-14

Revert error hiding and fiule bug for it.

921. By Natalia Bidart on 2012-03-14

- Improved code for 'sign in' button validation.

[Roberto Alsina (ralsina)]

+1

review: Approve

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== modified file 'data/qt/stylesheet.qss'
--- data/qt/stylesheet.qss	2012-03-05 20:30:57 +0000
+++ data/qt/stylesheet.qss	2012-03-14 13:30:25 +0000
@@ -95,17 +95,11 @@
     font-size: 20px;
 }
 
-QLabel#title_label {
-    font-size: 20px;
-}
-
-QFrame#header {
+WizardHeader {
     padding-top: 1px;
     padding-bottom: 1px;
 }
 
 QLabel#form_errors {
-    font: bold 14px;
-    color: #df2d1f;
     padding-bottom: 1px;
 }

=== modified file 'run-tests'
--- run-tests	2012-02-17 16:57:34 +0000
+++ run-tests	2012-03-14 13:30:25 +0000
@@ -57,7 +57,7 @@
 
 echo "*** Running QT test suite for ""$MODULE"" ***"
 ./setup.py build
-USE_QT_MAINLOOP=True $XVFB_CMDLINE u1trial --reactor=qt4 --gui -p "$GTK_TESTS_PATH" -i "test_windows.py" "$MODULE"
+$XVFB_CMDLINE u1trial --reactor=qt4 --gui -p "$GTK_TESTS_PATH" -i "test_windows.py" "$MODULE"
 rm -rf _trial_temp
 rm -rf build
 

=== modified file 'ubuntu_sso/qt/__init__.py'
--- ubuntu_sso/qt/__init__.py	2012-03-12 14:03:08 +0000
+++ ubuntu_sso/qt/__init__.py	2012-03-14 13:30:25 +0000
@@ -18,20 +18,26 @@
 
 import collections
 
+from PyQt4 import QtGui, QtCore
+
+from ubuntu_sso.logger import setup_gui_logging
+
+logger = setup_gui_logging('ubuntu_sso.qt')
 
 LINK_STYLE = (u'<a href="{link_url}">'
               '<span style="color:#df2d1f;">{link_text}</span></a>')
 ERROR_ALL = '__all__'
-ERROR_STYLE = u'<font color="#df2d1f"><b>%s</b></font>'
+ERROR_STYLE = u'<font color="#df2d1f" style="font-size:small"><b>%s</b></font>'
 ERROR_MESSAGE = 'message'
 PREFERED_UI_SIZE = {'width': 550, 'height': 525}
-TITLE_STYLE = u'<span style="font-size:24px">%s</span>'
+TITLE_STYLE = u'<span style="font-size:xx-large">%s</span>'
 WINDOW_TITLE = 'Ubuntu Single Sign On'
 
 
 # Based on the gtk implementation
 def build_general_error_message(errordict):
     """Build a user-friendly error message from the errordict."""
+    logger.debug('build_general_error_message: errordict is: %r.', errordict)
     result = ''
     if isinstance(errordict, collections.Mapping):
         msg1 = errordict.get(ERROR_ALL)
@@ -52,4 +58,22 @@
                 [('%s: %s' % (k, v)) for k, v in errordict.iteritems()])
     else:
         result = repr(errordict)
+
+    logger.info('build_general_error_message: returning %r.', result)
     return result
+
+
+def maybe_elide_text(label, text, width, markup=None):
+    """Set 'text' to be the 'label's text.
+
+    If 'text' is longer than 'width', set the label's tooltip to be the full
+    text, and the text itself to be the elided version of 'text'.
+
+    """
+    fm = QtGui.QFontMetrics(label.font())
+    elided_text = fm.elidedText(text, QtCore.Qt.ElideRight, width)
+    if elided_text != text:
+        label.setToolTip(text)
+    if markup is not None:
+        elided_text = markup % elided_text
+    label.setText(elided_text)

=== modified file 'ubuntu_sso/qt/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-03-12 14:53:00 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-03-14 13:30:25 +0000
@@ -119,12 +119,10 @@
 
     def _validate(self):
         """Perform input validation."""
-        valid = True
         correct_mail = is_correct_email(unicode(self.ui.email_edit.text()))
-        password = unicode(self.ui.password_edit.text())
-        if not correct_mail or not password:
-            valid = False
-        self.ui.sign_in_button.setEnabled(valid)
+        correct_password = len(unicode(self.ui.password_edit.text())) > 0
+        enabled = correct_mail and correct_password
+        self.ui.sign_in_button.setEnabled(enabled)
 
     def login(self):
         """Perform the login using the self.backend."""
@@ -149,7 +147,7 @@
         # let the user know
         logger.error('Got error when login %s, error: %s',
             self.app_name, error)
-        self.show_error(self.app_name, build_general_error_message(error))
+        self.show_error(build_general_error_message(error))
 
     def on_logged_in(self, app_name, result):
         """We managed to log in."""

=== modified file 'ubuntu_sso/qt/email_verification_page.py'
--- ubuntu_sso/qt/email_verification_page.py	2012-03-09 17:27:30 +0000
+++ ubuntu_sso/qt/email_verification_page.py	2012-03-14 13:30:25 +0000
@@ -134,7 +134,7 @@
         self.hide_overlay()
         msg = error.pop(ERROR_EMAIL_TOKEN, '')
         msg += build_general_error_message(error)
-        self.show_error(self.app_name, msg)
+        self.show_error(msg)
 
     # pylint: disable=C0103
 

=== modified file 'ubuntu_sso/qt/forgotten_password_page.py'
--- ubuntu_sso/qt/forgotten_password_page.py	2012-03-09 17:27:30 +0000
+++ ubuntu_sso/qt/forgotten_password_page.py	2012-03-14 13:30:25 +0000
@@ -127,4 +127,4 @@
         # set the error message
         self.hide_overlay()
         msg = REQUEST_PASSWORD_TOKEN_WRONG_EMAIL
-        self.show_error(self.app_name, msg)
+        self.show_error(msg)

=== modified file 'ubuntu_sso/qt/reset_password_page.py'
--- ubuntu_sso/qt/reset_password_page.py	2012-03-09 17:27:30 +0000
+++ ubuntu_sso/qt/reset_password_page.py	2012-03-14 13:30:25 +0000
@@ -169,7 +169,7 @@
         """Let the user know that there was an error."""
         logger.error('Got error changing password for %s, error: %s',
                      self.app_name, error)
-        self.show_error(self.app_name, build_general_error_message(error))
+        self.show_error(build_general_error_message(error))
 
     def set_new_password(self):
         """Request a new password to be set."""

=== modified file 'ubuntu_sso/qt/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-03-13 20:33:06 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-03-14 13:30:25 +0000
@@ -322,10 +322,10 @@
         self.captcha_image = pixmap_image
         self.on_captcha_refresh_complete()
 
-    def on_captcha_generation_error(self, error, *args, **kwargs):
+    @log_call(logger.error)
+    def on_captcha_generation_error(self, app_name, error):
         """An error ocurred."""
-        logger.error('Got error on captcha generation: %s', error)
-        self.show_error(self.app_name, CAPTCHA_LOAD_ERROR)
+        self.show_error(CAPTCHA_LOAD_ERROR)
         self.on_captcha_refresh_complete()
 
     @log_call(logger.error)
@@ -337,7 +337,7 @@
             self.set_error_message(self.ui.email_assistance, msg)
         error_msg = build_general_error_message(error)
         if error_msg:
-            self.show_error(self.app_name, error_msg)
+            self.show_error(error_msg)
         self._refresh_captcha()
 
     @log_call(logger.info)
@@ -378,7 +378,7 @@
             messages.append(CAPTCHA_REQUIRED_ERROR)
         if len(messages) > 0:
             condition = False
-            self.show_error(self.app_name, '\n'.join(messages))
+            self.show_error('\n'.join(messages))
         return condition
 
     def set_next_validation(self):

=== modified file 'ubuntu_sso/qt/sso_wizard_page.py'
--- ubuntu_sso/qt/sso_wizard_page.py	2012-03-12 14:53:00 +0000
+++ ubuntu_sso/qt/sso_wizard_page.py	2012-03-14 13:30:25 +0000
@@ -23,31 +23,38 @@
     QApplication,
     QCursor,
     QFrame,
-    QFontMetrics,
     QHBoxLayout,
+    QLabel,
+    QStyle,
     QVBoxLayout,
-    QStyle,
     QWizardPage,
-    QLabel,
 )
 from twisted.internet import defer
 
 from ubuntu_sso import main
 from ubuntu_sso.logger import setup_gui_logging, log_call
-from ubuntu_sso.qt import PREFERED_UI_SIZE, TITLE_STYLE
+from ubuntu_sso.qt import (
+    ERROR_STYLE,
+    maybe_elide_text,
+    PREFERED_UI_SIZE,
+    TITLE_STYLE,
+)
 from ubuntu_sso.utils.ui import GENERIC_BACKEND_ERROR
 
 
 logger = setup_gui_logging('ubuntu_sso.sso_wizard_page')
 
 
-class Header(QFrame):
-    """Header Class for Title and Subtitle in all wizard pages."""
+class WizardHeader(QFrame):
+    """WizardHeader Class for Title and Subtitle in all wizard pages."""
 
-    def __init__(self):
+    def __init__(self, max_width, parent=None):
         """Create a new instance."""
-        super(Header, self).__init__()
-        self.setObjectName('header')
+        super(WizardHeader, self).__init__(parent=parent)
+        self.max_width = max_width
+        self.max_title_width = self.max_width * 0.95
+        self.max_subtitle_width = self.max_width * 1.8
+
         vbox = QVBoxLayout(self)
         vbox.setContentsMargins(0, 0, 0, 0)
         self.title_label = QLabel()
@@ -64,11 +71,8 @@
     def set_title(self, title):
         """Set the Title of the page or hide it otherwise"""
         if title:
-            fm = QFontMetrics(self.subtitle_label.font())
-            width = PREFERED_UI_SIZE['width'] * 0.95
-            elided_text = fm.elidedText(title, Qt.ElideRight, width)
-            self.title_label.setToolTip(title)
-            self.title_label.setText(elided_text)
+            maybe_elide_text(self.title_label, title, self.max_title_width,
+                             markup=TITLE_STYLE)
             self.title_label.setVisible(True)
         else:
             self.title_label.setVisible(False)
@@ -76,28 +80,23 @@
     def set_subtitle(self, subtitle):
         """Set the Subtitle of the page or hide it otherwise"""
         if subtitle:
-            fm = QFontMetrics(self.subtitle_label.font())
-            width = PREFERED_UI_SIZE['width'] * 1.8
-            elided_text = fm.elidedText(subtitle, Qt.ElideRight, width)
-            self.subtitle_label.setText(elided_text)
-            self.subtitle_label.setToolTip(subtitle)
+            maybe_elide_text(self.subtitle_label, subtitle,
+                             self.max_subtitle_width)
             self.subtitle_label.setVisible(True)
         else:
             self.subtitle_label.setVisible(False)
 
 
-class SSOWizardPage(QWizardPage):
-    """Root class for all wizard pages."""
+class BaseWizardPage(QWizardPage):
+    """Base class for all wizard pages."""
 
     ui_class = None
-    _signals = {}  # override in children
+    max_width = 0
     processingStarted = pyqtSignal()
     processingFinished = pyqtSignal()
 
-    def __init__(self, app_name, **kwargs):
-        """Create a new instance."""
-        parent = kwargs.pop('parent', None)
-        super(SSOWizardPage, self).__init__(parent=parent)
+    def __init__(self, parent=None):
+        super(BaseWizardPage, self).__init__(parent=parent)
 
         self.ui = None
         if self.ui_class is not None:
@@ -105,55 +104,108 @@
             self.ui = self.ui_class()
             self.ui.setupUi(self)
 
-        # 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', '')
+        if self.layout() is None:
+            self.setLayout(QVBoxLayout(self))
 
         # Set the error area
-        self.form_errors_label = QLabel(' ')
+        self.form_errors_label = QLabel()
         self.form_errors_label.setObjectName('form_errors')
         self.form_errors_label.setAlignment(Qt.AlignBottom)
         self.layout().insertWidget(0, self.form_errors_label)
+
         # Set the header
-        self.header = Header()
+        self.header = WizardHeader(max_width=self.max_width)
         self.header.set_title(title='')
         self.header.set_subtitle(subtitle='')
         self.layout().insertWidget(0, self.header)
-        self._signals_receivers = {}
-        self.backend = None
 
         self.layout().setAlignment(Qt.AlignLeft)
 
-        self.setup_page()
+        self._is_processing = False
+
+    def _get_is_processing(self):
+        """Is this widget processing any request?"""
+        return self._is_processing
+
+    def _set_is_processing(self, new_value):
+        """Set this widget to be processing a request."""
+        self._is_processing = new_value
+        self.setEnabled(not new_value)
+        if not self._is_processing:
+            self.processingFinished.emit()
+        else:
+            self.processingStarted.emit()
+
+    is_processing = property(fget=_get_is_processing, fset=_set_is_processing)
+
+    # pylint: disable=C0103
+
+    def cleanupPage(self):
+        """Hide the errors."""
+        self.hide_error()
+
+    def setTitle(self, title=''):
+        """Set the Wizard Page Title."""
+        self.header.set_title(title)
+
+    def setSubTitle(self, subtitle=''):
+        """Set the Wizard Page Subtitle."""
+        self.header.set_subtitle(subtitle)
+
+    def title(self):
+        """Return the header's title."""
+        return self.header.title_label.text()
+
+    def subTitle(self):
+        """Return the header's subtitle."""
+        return self.header.subtitle_label.text()
+
+    # pylint: enable=C0103
 
     @log_call(logger.error)
-    def show_error(self, app_name, message):
+    def show_error(self, message):
         """Show an error message inside the page."""
-        self.hide_overlay()
-        fm = QFontMetrics(self.form_errors_label.font())
-        width = PREFERED_UI_SIZE['width'] * 0.95
-        elided_text = fm.elidedText(message, Qt.ElideRight, width)
-        self.form_errors_label.setText(elided_text)
-        self.form_errors_label.setToolTip(message)
+        self.is_processing = False
+        maybe_elide_text(self.form_errors_label, message,
+                         self.max_width * 0.95, markup=ERROR_STYLE)
 
     def hide_error(self):
         """Hide the label errors in the current page."""
-        # We actually want the label with one chat, because if it is an
+        # We actually want the label with one empty char, because if it is an
         # empty string, the height of the label is 0
         self.form_errors_label.setText(' ')
 
+
+class SSOWizardPage(BaseWizardPage):
+    """Root class for all SSO specific wizard pages."""
+
+    _signals = {}  # override in children
+    max_width = PREFERED_UI_SIZE['width']
+
+    def __init__(self, app_name, **kwargs):
+        """Create a new instance."""
+        parent = kwargs.pop('parent', None)
+        super(SSOWizardPage, self).__init__(parent=parent)
+
+        # store common useful data provided by the app
+        self.app_name = app_name
+        self.ping_url = kwargs.get('ping_url', '')
+        self.tc_url = kwargs.get('tc_url', '')
+        self.policy_url = kwargs.get('policy_url', '')
+        self.help_text = kwargs.get('help_text', '')
+
+        self._signals_receivers = {}
+        self.backend = None
+
+        self.setup_page()
+
     def hide_overlay(self):
         """Emit the signal to notify the upper container that ends loading."""
-        self.setEnabled(True)
-        self.processingFinished.emit()
+        self.is_processing = False
 
     def show_overlay(self):
         """Emit the signal to notify the upper container that is loading."""
-        self.setEnabled(False)
-        self.processingStarted.emit()
+        self.is_processing = True
 
     @defer.inlineCallbacks
     def setup_page(self):
@@ -165,30 +217,6 @@
         self._set_translated_strings()
         self._connect_ui()
 
-    # pylint: disable=C0103
-
-    def cleanupPage(self):
-        """Hide the errors."""
-        self.hide_error()
-
-    def setTitle(self, title=''):
-        """Set the Wizard Page Title."""
-        self.header.set_title(TITLE_STYLE % title)
-
-    def setSubTitle(self, subtitle=''):
-        """Set the Wizard Page Subtitle."""
-        self.header.set_subtitle(subtitle)
-
-    def title(self):
-        """Return the header's title."""
-        return self.header.title_label.text()
-
-    def subTitle(self):
-        """Return the header's subtitle."""
-        return self.header.subtitle_label.text()
-
-    # pylint: enable=C0103
-
     def _filter_by_app_name(self, f):
         """Excecute the decorated function only for 'self.app_name'."""
 
@@ -219,11 +247,9 @@
 
     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."""

=== modified file 'ubuntu_sso/qt/tests/__init__.py'
--- ubuntu_sso/qt/tests/__init__.py	2012-03-05 21:18:15 +0000
+++ ubuntu_sso/qt/tests/__init__.py	2012-03-14 13:30:25 +0000
@@ -21,7 +21,7 @@
 from twisted.trial.unittest import TestCase
 
 from ubuntu_sso import main, NO_OP
-from ubuntu_sso.qt import TITLE_STYLE
+from ubuntu_sso.qt import ERROR_STYLE, maybe_elide_text, TITLE_STYLE
 from ubuntu_sso.tests import (
     APP_NAME,
     HELP_TEXT,
@@ -38,6 +38,15 @@
 # pylint: disable=W0212
 
 
+def build_string_for_pixels(label, width):
+    """Return a random string that will be as big as with in pixels."""
+    char = 'a'
+    fm = QtGui.QFontMetrics(label.font())
+    pixel_width = fm.width(char)
+    chars = int(width / pixel_width)
+    return char * chars
+
+
 class FakedObject(object):
     """Fake an object, record every call."""
 
@@ -439,6 +448,9 @@
                 self.wizard = self.ui_wizard_class()
                 self.patch(self.ui, 'wizard', lambda: self.wizard)
 
+            self.ui.show()
+            self.addCleanup(self.ui.hide)
+
     def _set_called(self, *args, **kwargs):
         """Store 'args' and 'kwargs' for test assertions."""
         self._called = (args, kwargs)
@@ -467,6 +479,38 @@
 
         self.assertEqual(self.signal_results, [signal_args])
 
+    def assert_title_correct(self, title_label, expected, max_width):
+        """Check that the label's text is equal to 'expected'."""
+        label = QtGui.QLabel()
+        maybe_elide_text(label, expected, max_width)
+
+        self.assertEqual(TITLE_STYLE % unicode(label.text()),
+                         unicode(title_label.text()))
+        self.assertEqual(unicode(label.toolTip()),
+                         unicode(title_label.toolTip()))
+        self.assertTrue(title_label.isVisible())
+
+    def assert_subtitle_correct(self, subtitle_label, expected, max_width):
+        """Check that the subtitle is equal to 'expected'."""
+        label = QtGui.QLabel()
+        maybe_elide_text(label, expected, max_width)
+
+        self.assertEqual(unicode(label.text()), unicode(subtitle_label.text()))
+        self.assertEqual(unicode(label.toolTip()),
+                         unicode(subtitle_label.toolTip()))
+        self.assertTrue(subtitle_label.isVisible())
+
+    def assert_error_correct(self, error_label, expected, max_width):
+        """Check that the error 'error_label' displays 'expected' as text."""
+        label = QtGui.QLabel()
+        maybe_elide_text(label, expected, max_width)
+
+        self.assertEqual(ERROR_STYLE % unicode(label.text()),
+                         unicode(error_label.text()))
+        self.assertEqual(unicode(label.toolTip()),
+                         unicode(error_label.toolTip()))
+        self.assertTrue(error_label.isVisible())
+
     def get_pixmap_data(self, pixmap):
         """Get the raw data of a QPixmap."""
         byte_array = QtCore.QByteArray()
@@ -550,14 +594,18 @@
         self.assertEqual(self._overlay_hide_counter, 1)
         self.assertTrue(self.ui.isEnabled())
 
+    # pylint: disable=W0221
+
     def assert_title_correct(self, expected):
         """Check that the title is equal to 'expected'."""
-        self.assertEqual(TITLE_STYLE % expected, unicode(self.ui.title()))
+        check = super(PageBaseTestCase, self).assert_title_correct
+        check(self.ui.header.title_label, expected,
+              self.ui.header.max_title_width)
 
     def assert_subtitle_correct(self, expected):
         """Check that the subtitle is equal to 'expected'."""
-        elided_text = unicode(self.ui.subTitle())
-        elided_text = elided_text[:len(elided_text) - 1]
+        check = super(PageBaseTestCase, self).assert_subtitle_correct
+        check(self.ui.header.subtitle_label, expected,
+              self.ui.header.max_subtitle_width)
 
-        self.assertTrue(expected.startswith(elided_text))
-        self.assertEqual(self.ui.header.subtitle_label.toolTip(), expected)
+    # pylint: enable=W0221

=== modified file 'ubuntu_sso/qt/tests/test_common.py'
--- ubuntu_sso/qt/tests/test_common.py	2011-10-28 10:41:18 +0000
+++ ubuntu_sso/qt/tests/test_common.py	2012-03-14 13:30:25 +0000
@@ -20,7 +20,9 @@
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 
-from ubuntu_sso.qt.common import (check_as_invalid,
+from ubuntu_sso.qt import maybe_elide_text
+from ubuntu_sso.qt.common import (
+    check_as_invalid,
     check_as_valid,
     password_assistance,
     password_check_match,
@@ -30,7 +32,9 @@
     PASSWORD_DIGIT,
     PASSWORD_LENGTH,
     PASSWORD_MATCH,
-    PASSWORD_UPPER)
+    PASSWORD_UPPER,
+)
+from ubuntu_sso.qt.tests import build_string_for_pixels
 
 
 class PasswordTestCase(TestCase):
@@ -234,3 +238,46 @@
         line_edit = QtGui.QLineEdit()
         check_as_invalid(line_edit)
         self.assertTrue(line_edit.property("formError").toBool())
+
+
+class ElidedTextTestCase(TestCase):
+    """The test case for the maybe_elide_text function."""
+
+    max_width = 100
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(ElidedTextTestCase, self).setUp()
+        self.ui = QtGui.QLabel()
+
+    def test_text_not_elided_if_too_short(self):
+        """If text is shorter than max_width, do not elide."""
+        text = build_string_for_pixels(self.ui, self.max_width - 1)
+
+        maybe_elide_text(self.ui, text, self.max_width)
+
+        self.assertEqual(self.ui.toolTip(), '')
+        self.assertEqual(self.ui.text(), text)
+        self.assertNotIn(u'\u2026', self.ui.text())
+
+    def test_text_not_elided_if_equals_max_width(self):
+        """If text is equal than max_width, do not elide."""
+        text = build_string_for_pixels(self.ui, self.max_width)
+
+        maybe_elide_text(self.ui, text, self.max_width)
+
+        self.assertEqual(self.ui.toolTip(), '')
+        self.assertEqual(self.ui.text(), text)
+        self.assertNotIn(u'\u2026', self.ui.text())
+
+    def test_text_elided_if_bigger_than_max_width(self):
+        """If text is equal than max_width, do not elide."""
+        text = build_string_for_pixels(self.ui, self.max_width + 10)
+
+        maybe_elide_text(self.ui, text, self.max_width)
+
+        self.assertEqual(self.ui.toolTip(), text)
+        expected = unicode(self.ui.text())
+        self.assertTrue(expected.endswith(u'\u2026'))
+        self.assertTrue(text.startswith(expected[:-1]))

=== 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-03-12 19:47:07 +0000
+++ ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-03-14 13:30:25 +0000
@@ -142,13 +142,13 @@
     def test_on_login_error(self):
         """Test the on_login_error method."""
         self.patch(self.ui, "show_error", self._set_called)
-        app_name = 'my_app'
-        self.ui.app_name = app_name
         error = {'errtype': 'UserNotValidated'}
-        self.ui.on_login_error(app_name, error)
+
+        self.ui.on_login_error(self.app_name, error)
+
         self.assertEqual(self._overlay_hide_counter, 0)
         self.assertTrue(self.ui.isEnabled())
-        expected = ((self.ui, 'my_app', ''), {})
+        expected = ((self.ui, self.app_name, ''), {})
         self.assertTrue(expected, self._called)
 
     def test_on_logged_in(self):

=== modified file 'ubuntu_sso/qt/tests/test_email_verification.py'
--- ubuntu_sso/qt/tests/test_email_verification.py	2012-03-12 19:47:07 +0000
+++ ubuntu_sso/qt/tests/test_email_verification.py	2012-03-14 13:30:25 +0000
@@ -78,14 +78,12 @@
         email = 'mail@example'
         self.ui.email = email
         self.ui.set_titles(email)
-        self.assertEqual(unicode(self.ui.header.title_label.text()),
-            email_verification_page.VERIFY_EMAIL_TITLE)
+        self.assert_title_correct(email_verification_page.VERIFY_EMAIL_TITLE)
         expected = email_verification_page.VERIFY_EMAIL_CONTENT % {
                        "app_name": self.app_name,
                        "email": email,
                    }
-        self.assertEqual(unicode(self.ui.header.subtitle_label.toolTip()),
-            expected)
+        self.assert_subtitle_correct(expected)
 
     def test_initialize_page(self):
         """Test the initialization method."""
@@ -100,10 +98,11 @@
     def test_on_email_validation_error(self):
         """Test the validate_email method."""
         self.patch(self.ui, "show_error", self._set_called)
-        app_name = 'my_app'
         error = {email_verification_page: 'error in email_verification_page'}
-        self.ui.on_email_validation_error(app_name, error)
-        expected = ((self.ui, app_name, ''), {})
+
+        self.ui.on_email_validation_error(self.app_name, error)
+
+        expected = ((self.ui, ''), {})
         self.assertTrue(expected, self._called)
         self.assertEqual(self._overlay_hide_counter, 1)
 

=== modified file 'ubuntu_sso/qt/tests/test_forgotten_password.py'
--- ubuntu_sso/qt/tests/test_forgotten_password.py	2012-03-12 19:47:07 +0000
+++ ubuntu_sso/qt/tests/test_forgotten_password.py	2012-03-14 13:30:25 +0000
@@ -113,7 +113,8 @@
         """Test on_password_reset_error method."""
         self.patch(self.ui, "show_error", self._set_called)
         error = {'errtype': 'FooBarBaz'}
+
         self.ui.on_password_reset_error(self.app_name, error)
-        expected = ((self.ui, self.app_name,
-            gui.REQUEST_PASSWORD_TOKEN_WRONG_EMAIL), {})
+
+        expected = ((self.ui, gui.REQUEST_PASSWORD_TOKEN_WRONG_EMAIL), {})
         self.assertTrue(expected, self._called)

=== modified file 'ubuntu_sso/qt/tests/test_loadingoverlay.py'
--- ubuntu_sso/qt/tests/test_loadingoverlay.py	2012-02-23 19:49:02 +0000
+++ ubuntu_sso/qt/tests/test_loadingoverlay.py	2012-03-14 13:30:25 +0000
@@ -29,8 +29,5 @@
 
     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)

=== modified file 'ubuntu_sso/qt/tests/test_reset_password.py'
--- ubuntu_sso/qt/tests/test_reset_password.py	2012-03-12 19:47:07 +0000
+++ ubuntu_sso/qt/tests/test_reset_password.py	2012-03-14 13:30:25 +0000
@@ -70,9 +70,7 @@
 
     def test_initialize(self):
         """Check the Title and Subtitle."""
-        self.ui.show()
         self.ui.initializePage()
-        self.addCleanup(self.ui.hide)
         self.assert_title_correct(RESET_TITLE)
         self.assert_subtitle_correct(RESET_SUBTITLE)
         self.assertEqual(unicode(self.ui.ui.password_label.text()),
@@ -84,15 +82,11 @@
 
     def test_focus_changed_password_visibility(self):
         """Check visibility changes when focus_changed() is executed."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.focus_changed(None, self.ui.ui.password_line_edit)
         self.assertTrue(self.ui.ui.password_assistance.isVisible())
 
     def test_show_hide_event(self):
         """Check connections to focusChanged on show and hide event."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertEqual(QtGui.QApplication.instance().receivers(
             QtCore.SIGNAL("focusChanged(QWidget*, QWidget*)")), 1)
         self.ui.hide()
@@ -104,24 +98,20 @@
     def test_focus_changed_1(self):
         """Check functions execution when focus_changed() is executed."""
         self.patch(common, 'password_default_assistance', self._set_called)
-
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
-
         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(self._called)
 
     def test_focus_changed_2(self):
         """Check functions execution when focus_changed() is executed."""
         self.patch(common, 'password_check_match', self._set_called)
-
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
-
         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(self._called)
 

=== modified file 'ubuntu_sso/qt/tests/test_setup_account.py'
--- ubuntu_sso/qt/tests/test_setup_account.py	2012-03-12 19:47:07 +0000
+++ ubuntu_sso/qt/tests/test_setup_account.py	2012-03-14 13:30:25 +0000
@@ -43,13 +43,9 @@
         """
         self.ui.ui.name_edit.setText("")
         self.ui.name_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertTrue(self.ui.ui.name_assistance.isVisible())
-        self.assertEqual(
-            unicode(self.ui.ui.name_assistance.text()),
-            gui.ERROR_STYLE % gui.EMPTY_NAME)
-        self.ui.hide()
+        self.assert_error_correct(self.ui.ui.name_assistance, gui.EMPTY_NAME,
+                                  max_width=self.ui.header.max_title_width)
 
     def test_enable_setup_button_with_visible_check(self):
         """Test _enable_setup_button method with terms check visible."""
@@ -65,8 +61,6 @@
         self.ui.ui.captcha_solution_edit.setText('captcha solution')
         self.ui.terms_checkbox.setChecked(True)
 
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.terms_checkbox.setVisible(True)
         self.ui.ui.captcha_solution_edit.textEdited.emit('')
         self.assertTrue(self.ui.set_up_button.isEnabled())
@@ -84,8 +78,6 @@
         self.ui.ui.confirm_password_edit.setText(password)
         self.ui.ui.captcha_solution_edit.setText('captcha solution')
 
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.terms_checkbox.setVisible(False)
         self.ui.ui.captcha_solution_edit.textEdited.emit('')
         self.assertTrue(self.ui.set_up_button.isEnabled())
@@ -114,8 +106,6 @@
 
     def test_password_focus_gain(self):
         """Check functions execution when focus_changed() is executed."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.ui.password_assistance.setVisible(False)
         self.assertFalse(self.ui.ui.password_assistance.isVisible())
         self.patch(self.ui, 'name_assistance', self._set_called)
@@ -192,8 +182,6 @@
     def test_initialize_page(self):
         """Widgets are properly initialized."""
         self.ui.initializePage()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
 
         # set up account button
         expected = [QtGui.QWizard.BackButton, QtGui.QWizard.Stretch,
@@ -232,8 +220,6 @@
         self.patch(self.ui, 'set_next_validation', self._set_called)
         self.ui.initializePage()
         self.ui.captcha_received = True
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
 
         self.ui.set_up_button.clicked.emit(False)
         self.assertEqual(self._called, ((False,), {}))
@@ -241,13 +227,10 @@
     def test_set_error_message(self):
         """Check the state of the label after calling: set_error_message."""
         self.ui.email_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.set_error_message(self.ui.ui.email_assistance, "message")
         self.assertTrue(self.ui.ui.email_assistance.isVisible())
-        self.assertEqual(
-            unicode(self.ui.ui.email_assistance.text()),
-            gui.ERROR_STYLE % "message")
+        self.assert_error_correct(self.ui.ui.email_assistance, "message",
+                                  max_width=self.ui.header.max_title_width)
 
     def test_blank_name(self):
         """Status when the name field is blank (spaces).
@@ -257,13 +240,9 @@
         """
         self.ui.ui.name_edit.setText("  ")
         self.ui.name_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertTrue(self.ui.ui.name_assistance.isVisible())
-        self.assertEqual(
-            unicode(self.ui.ui.name_assistance.text()),
-            gui.ERROR_STYLE % gui.EMPTY_NAME)
-        self.ui.hide()
+        self.assert_error_correct(self.ui.ui.name_assistance, gui.EMPTY_NAME,
+                                  max_width=self.ui.header.max_title_width)
 
     def test_valid_name(self):
         """Status when the name field is valid.
@@ -272,10 +251,7 @@
         """
         self.ui.ui.name_edit.setText("John Doe")
         self.ui.name_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertFalse(self.ui.ui.name_assistance.isVisible())
-        self.ui.hide()
 
     def test_invalid_email(self):
         """Status when the email field has no @.
@@ -285,12 +261,10 @@
         """
         self.ui.ui.email_edit.setText("foobar")
         self.ui.email_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertTrue(self.ui.ui.email_assistance.isVisible())
-        self.assertEqual(
-            unicode(self.ui.ui.email_assistance.text()),
-            gui.ERROR_STYLE % gui.INVALID_EMAIL)
+        self.assert_error_correct(self.ui.ui.email_assistance,
+                                  gui.INVALID_EMAIL,
+                                  max_width=self.ui.header.max_title_width)
 
     def test_valid_email(self):
         """Status when the email field has a @.
@@ -299,10 +273,7 @@
         """
         self.ui.ui.email_edit.setText("foo@bar")
         self.ui.email_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertFalse(self.ui.ui.email_assistance.isVisible())
-        self.ui.hide()
 
     def test_matching_emails(self):
         """Status when the email fields match.
@@ -312,10 +283,7 @@
         self.ui.ui.email_edit.setText("foo@bar")
         self.ui.ui.confirm_email_edit.setText("foo@bar")
         self.ui.confirm_email_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertFalse(self.ui.ui.confirm_email_assistance.isVisible())
-        self.ui.hide()
 
     def test_not_matching_emails(self):
         """Status when the email fields don't match.
@@ -326,18 +294,13 @@
         self.ui.ui.email_edit.setText("foo@bar")
         self.ui.ui.confirm_email_edit.setText("foo@baz")
         self.ui.confirm_email_assistance()
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.assertTrue(self.ui.ui.confirm_email_assistance.isVisible())
-        self.assertEqual(
-            unicode(self.ui.ui.confirm_email_assistance.text()),
-            gui.ERROR_STYLE % gui.EMAIL_MATCH)
-        self.ui.hide()
+        self.assert_error_correct(self.ui.ui.confirm_email_assistance,
+                                  gui.EMAIL_MATCH,
+                                  max_width=self.ui.header.max_title_width)
 
     def test_focus_changed_password_visibility(self):
         """Check visibility changes when focus_changed() is executed."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.focus_changed(None, self.ui.ui.password_edit)
         self.assertTrue(self.ui.ui.password_assistance.isVisible())
 
@@ -352,33 +315,41 @@
         self.ui.showEvent(QtGui.QShowEvent())
         self.ui.hideEvent(QtGui.QHideEvent())
 
-    def test_on_captcha_refreshing(self):
+    def test_on_captcha_refreshing_visible(self):
         """Check the state of the overlay on captcha refreshing."""
-        self.assertEqual(self._overlay_show_counter, 0)
-        self.ui.on_captcha_refreshing()
-        self.assertEqual(self._overlay_show_counter, 0)
-        self.assertTrue(self.ui.isEnabled())
-        self.ui.captcha_received = True
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
-        self.assertEqual(self._overlay_show_counter, 0)
-        self.assertTrue(self.ui.isEnabled())
-        self.ui.on_captcha_refreshing()
+        self.ui.hide_overlay()
+
+        self.assertEqual(self._overlay_show_counter, 0)
+        self.assertTrue(self.ui.isEnabled())
+
+        self.ui.on_captcha_refreshing()
+
         self.assertFalse(self.ui.isEnabled())
         self.assertEqual(self._overlay_show_counter, 1)
 
+    def test_on_captcha_refreshing_not_visible(self):
+        """Check the state of the overlay on captcha refreshing."""
+        self.ui.hide_overlay()
+
+        self.assertEqual(self._overlay_show_counter, 0)
+        self.assertTrue(self.ui.isEnabled())
+
+        self.ui.hide()
+        self.ui.on_captcha_refreshing()
+
+        self.assertEqual(self._overlay_show_counter, 0)
+        self.assertTrue(self.ui.isEnabled())
+
     def test_on_captcha_refresh_complete(self):
         """Check the state of the overlay on captcha refreshing complete."""
         self.assertEqual(self._overlay_hide_counter, 0)
-        self.assertTrue(self.ui.isEnabled())
+
         self.ui.on_captcha_refresh_complete()
+
         self.assertEqual(self._overlay_hide_counter, 1)
-        self.assertTrue(self.ui.isEnabled())
 
     def test_hide_error_on_refresh_captcha(self):
         """Test that the errors are hidden on refresh captcha."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
-        self.ui.show_error(self.app_name, 'error-message')
+        self.ui.show_error('error-message')
         self.ui.ui.refresh_label.linkActivated.emit('link')
         self.assertEqual(self.ui.form_errors_label.text(), ' ')

=== modified file 'ubuntu_sso/qt/tests/test_sso_wizard_page.py'
--- ubuntu_sso/qt/tests/test_sso_wizard_page.py	2012-03-05 18:56:50 +0000
+++ ubuntu_sso/qt/tests/test_sso_wizard_page.py	2012-03-14 13:30:25 +0000
@@ -16,98 +16,127 @@
 
 """Test the SSOWizardPage and related."""
 
-from twisted.internet import defer
-
-from ubuntu_sso.qt import PREFERED_UI_SIZE
-from ubuntu_sso.qt.setup_account_page import SetupAccountPage
-from ubuntu_sso.qt.sso_wizard_page import Header
-from ubuntu_sso.qt.tests import BaseTestCase, PageBaseTestCase
-
-
-class HeaderTest(BaseTestCase):
+from ubuntu_sso.qt import PREFERED_UI_SIZE, sso_wizard_page as gui
+from ubuntu_sso.qt.tests import (
+    APP_NAME,
+    BaseTestCase,
+    build_string_for_pixels,
+    PageBaseTestCase,
+)
+
+
+MAX_WIDTH = 100
+
+
+class WizardHeaderTestCase(BaseTestCase):
 
     """Tests for injected Header in each Wizard Page."""
 
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(HeaderTest, self).setUp()
-        self.header = Header()
+    kwargs = dict(max_width=MAX_WIDTH)
+    ui_class = gui.WizardHeader
+    ui_wizard_class = None
 
     def test_label_state(self):
         """Check the title and subtitle properties."""
-        self.assertTrue(self.header.title_label.wordWrap())
-        self.assertTrue(self.header.subtitle_label.wordWrap())
-        self.assertFalse(self.header.title_label.isVisible())
-        self.assertFalse(self.header.subtitle_label.isVisible())
+        self.assertTrue(self.ui.title_label.wordWrap())
+        self.assertTrue(self.ui.subtitle_label.wordWrap())
+        self.assertFalse(self.ui.title_label.isVisible())
+        self.assertFalse(self.ui.subtitle_label.isVisible())
 
     def test_set_title(self):
         """Check if set_title works ok, showing the widget if necessary."""
-        self.header.set_title('title')
-        self.assertEqual(self.header.title_label.text(), 'title')
-        self.header.show()
-        self.assertTrue(self.header.title_label.isVisible())
-        self.header.hide()
+        max_width = self.ui.max_title_width
+        text = build_string_for_pixels(self.ui.title_label, max_width)
+
+        self.ui.set_title(text)
+
+        self.assert_title_correct(self.ui.title_label, text, max_width)
 
     def test_set_elided_title(self):
         """Check if set_title adds the ellipsis when necessary."""
         # add an extra letter so we ensure this needs to be trimmed
-        title = 'a' * int(PREFERED_UI_SIZE['width'] * 0.95) + 'a'
-        self.header.set_title(title)
-        self.assertEqual(self.header.title_label.toolTip(), title)
-        expected = unicode(self.header.title_label.text())
-        self.assertTrue(expected.endswith(u'\u2026'))
+        max_width = self.ui.max_title_width
+        text = build_string_for_pixels(self.ui.title_label, max_width + 10)
+
+        self.ui.set_title(text)
+
+        self.assert_title_correct(self.ui.title_label, text, max_width)
 
     def test_set_empty_title(self):
         """Check if the widget is hidden for empty title."""
-        self.header.set_title('')
-        self.assertFalse(self.header.title_label.isVisible())
+        self.ui.set_title('')
+
+        self.assertEqual(self.ui.title_label.toolTip(), '')
+        self.assertFalse(self.ui.title_label.isVisible())
 
     def test_set_subtitle(self):
         """Check if set_subtitle works ok, showing the widget if necessary."""
-        self.header.set_subtitle('subtitle')
-        self.assertEqual(self.header.subtitle_label.text(), 'subtitle')
-        self.header.show()
-        self.assertTrue(self.header.subtitle_label.isVisible())
-        self.header.hide()
+        max_width = self.ui.max_subtitle_width
+        text = build_string_for_pixels(self.ui.subtitle_label, max_width)
+
+        self.ui.set_subtitle(text)
+
+        self.assert_subtitle_correct(self.ui.subtitle_label, text, max_width)
 
     def test_set_elided_subtitle(self):
         """Check if set_subtitle adds the ellipsis when necessary."""
-        subtitle = 'a' * int(PREFERED_UI_SIZE['width'] * 0.95) + 'a'
-        self.header.set_subtitle(subtitle)
-        self.assertEqual(self.header.subtitle_label.toolTip(), subtitle)
-        expected = unicode(self.header.subtitle_label.text())
-        self.assertTrue(expected.endswith(u'\u2026'))
+        max_width = self.ui.max_subtitle_width
+        text = build_string_for_pixels(self.ui.subtitle_label, max_width + 10)
+
+        self.ui.set_subtitle(text)
+
+        self.assert_subtitle_correct(self.ui.subtitle_label, text, max_width)
 
     def test_set_empty_subtitle(self):
         """Check if the widget is hidden for empty subtitle."""
-        self.header.set_title('')
-        self.assertFalse(self.header.title_label.isVisible())
-
-
-class SSOWizardPageTest(PageBaseTestCase):
-
-    """Tests for SSOWizardPage."""
-
-    ui_class = SetupAccountPage
+        self.ui.set_subtitle('')
+
+        self.assertEqual(self.ui.subtitle_label.toolTip(), '')
+        self.assertFalse(self.ui.subtitle_label.isVisible())
+
+
+class BaseWizardPageTestCase(PageBaseTestCase):
+
+    """Tests for SSOWizardPage."""
+
+    kwargs = {}
+    ui_class = gui.BaseWizardPage
+
+    def test_max_width(self):
+        """The max_width is correct."""
+        self.assertEqual(self.ui.max_width, 0)
+
+
+class SSOWizardPageTestCase(BaseWizardPageTestCase):
+
+    """Tests for SSOWizardPage."""
+
+    kwargs = dict(app_name=APP_NAME)
+    ui_class = gui.SSOWizardPage
+
+    def test_max_width(self):
+        """The max_width is correct."""
+        self.assertEqual(self.ui.max_width, PREFERED_UI_SIZE['width'])
 
     def test_show_error(self):
         """Test show_error with a normal length string."""
         message = 'error-message'
-        self.ui.show_error(self.app_name, message)
-        self.assertEqual(self.ui.form_errors_label.toolTip(), message)
-        expected = unicode(self.ui.form_errors_label.text())
-        self.assertEqual(expected, message)
+        self.ui.show_error(message)
+
+        self.assert_error_correct(self.ui.form_errors_label, message,
+                                  self.ui.header.max_title_width)
 
     def test_show_error_long_text(self):
         """Test show_error with a long length string."""
-        message = 'a' * int(PREFERED_UI_SIZE['width'] * 0.95) + 'a'
-        self.ui.show_error(self.app_name, message)
-        self.assertEqual(self.ui.form_errors_label.toolTip(), message)
-        expected = unicode(self.ui.form_errors_label.text())
-        self.assertTrue(expected.endswith(u'\u2026'))
+        message = build_string_for_pixels(self.ui.form_errors_label,
+                                          self.ui.header.max_title_width + 10)
+        self.ui.show_error(message)
+
+        self.assert_error_correct(self.ui.form_errors_label, message,
+                                  self.ui.header.max_title_width)
 
     def test_hide_error(self):
         """Test show_error with a long length string."""
-        message = ' '
         self.ui.hide_error()
-        self.assertEqual(self.ui.form_errors_label.text(), message)
+
+        self.assertEqual(self.ui.form_errors_label.text(), ' ')

=== modified file 'ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-03-13 20:33:06 +0000
+++ ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-03-14 13:30:25 +0000
@@ -112,8 +112,6 @@
 
     def test_window_size(self):
         """check the window size."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         size = self.ui.size()
         self.assertTrue(size.height() >= PREFERED_UI_SIZE['height'])
         self.assertTrue(size.width() >= PREFERED_UI_SIZE['width'])
@@ -131,6 +129,9 @@
 
     def test_overlay_shows(self):
         """Test if the signals call the overlay.show properly."""
+        # reset the counter
+        self.ui.overlay.show_counter = 0
+
         for page in self.ui._pages:
             page.show_overlay()
 
@@ -138,6 +139,9 @@
 
     def test_overlay_hides(self):
         """Test if the signals call the overlay.show properly."""
+        # reset the counter
+        self.ui.overlay.show_counter = 0
+
         for page in self.ui._pages:
             page.hide_overlay()
 
@@ -157,8 +161,6 @@
 
     def test_email_verification_page_params_from_current_user(self):
         """Tests that email_verification_page receives the proper params."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui._next_id = self.ui.current_user_page_id
         self.ui.next()
         self.ui.current_user.ui.email_edit.setText(EMAIL)
@@ -169,8 +171,6 @@
 
     def test_email_verification_page_params_from_setup(self):
         """Tests that email_verification_page receives the proper params."""
-        self.ui.show()
-        self.addCleanup(self.ui.hide)
         self.ui.setup_account.ui.email_edit.setText(EMAIL)
         self.ui.setup_account.ui.password_edit.setText(PASSWORD)
         self.ui.setup_account.on_user_registered(APP_NAME, {})