Merge lp:~diegosarmentero/ubuntu-sso-client/931452 into lp:ubuntu-sso-client

[Diego Sarmentero]

- Fixed: Qt UI: must call the backend passing reply_handler and error_handler (LP: #931452).

[Brian Curtin (brian.curtin)]

Nice use of functools.partial

The only change I would suggest is fairly minor: Your test conditions are always assertTrue(x in y). You could instead do assertIn(x, y).

review: Needs Fixing

[Manuel de la Peña (mandel)]

+1 nice use of partial!!!

review: Approve

[Natalia Bidart (nataliabidart)]

The reply_handler and error_handler have to be passed to every backend call.
Also, I would advice using something like the gtk assert_backend_called to avoid duplicating the same code to assert the same things in every method.

review: Needs Fixing

[Diego Sarmentero (diegosarmentero)]

> Nice use of functools.partial
>
> The only change I would suggest is fairly minor: Your test conditions are
> always assertTrue(x in y). You could instead do assertIn(x, y).

Thanks for the suggestion Brian, done!

[Diego Sarmentero (diegosarmentero)]

> The reply_handler and error_handler have to be passed to every backend call.
> Also, I would advice using something like the gtk assert_backend_called to
> avoid duplicating the same code to assert the same things in every method.

Done!

[lp:~diegosarmentero/ubuntu-sso-client/931452]

874. By Diego Sarmentero on 2012-02-15

Several fixes regarding the tests

875. By Diego Sarmentero on 2012-02-15

Conflict resolved

876. By Diego Sarmentero on 2012-02-16

Removed commented code.

[Brian Curtin (brian.curtin)]

Looks good to me.

review: Approve

[Natalia Bidart (nataliabidart)]

Branch looks good!

Can you please use the new assert_backend_called in test_validate_email_with_ping and test_validate_email_without_ping?

review: Approve

[Natalia Bidart (nataliabidart)]

Hum, found a test failure, so changing my vote:

===============================================================================
[ERROR]
Traceback (most recent call last):
  File "/home/nessita/canonical/ussoc/review_931452/ubuntu_sso/qt/tests/test_forgotten_password.py", line 220, in test_on_password_reset_token_sent
    self.ui.on_password_reset_token_sent()
exceptions.TypeError: on_password_reset_token_sent() takes exactly 3 arguments (1 given)

ubuntu_sso.qt.tests.test_forgotten_password.ForgottenPasswordTestCase.test_on_password_reset_token_sent

review: Needs Fixing

[lp:~diegosarmentero/ubuntu-sso-client/931452]

877. By Diego Sarmentero on 2012-02-17

Tests fixed

878. By Diego Sarmentero on 2012-02-17

Removing unnecessary lines of tests

[Natalia Bidart (nataliabidart)]

Looks great!

review: Approve

=== modified file 'ubuntu_sso/qt/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-17 14:21:18 +0000
@@ -17,10 +17,12 @@
 """Page to allow the user to login into Ubuntu Single Sign On."""
 
 import gettext
+from functools import partial
 
 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.gui import SSOWizardPage
 from ubuntu_sso.logger import setup_logging
@@ -147,7 +149,9 @@
             args = args + (self.ping_url,)
         else:
             f = self.backend.login
-        f(*args)
+
+        error_handler = partial(self._handle_error, f, self.on_login_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
 
     def on_login_error(self, app_name, error):
         """There was an error when login in."""

=== modified file 'ubuntu_sso/qt/email_verification_page.py'
--- ubuntu_sso/qt/email_verification_page.py	2012-02-13 14:04:27 +0000
+++ ubuntu_sso/qt/email_verification_page.py	2012-02-17 14:21:18 +0000
@@ -16,9 +16,12 @@
 
 """Email Verification page UI."""
 
+from functools import partial
+
 from PyQt4 import 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.gui import SSOWizardPage
 from ubuntu_sso.logger import setup_logging
@@ -115,7 +118,9 @@
         logger.info('Calling validate_email with email %r, password <hidden>, '
                     'app_name %r and email_token %r.', self.email,
                     self.app_name, code)
-        f(*args)
+        error_handler = partial(self._handle_error, f,
+                                self.on_email_validation_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
 
     def on_email_validated(self, app_name, *args, **kwargs):
         """Signal thrown after the email is validated."""

=== modified file 'ubuntu_sso/qt/forgotten_password_page.py'
--- ubuntu_sso/qt/forgotten_password_page.py	2012-02-13 21:50:16 +0000
+++ ubuntu_sso/qt/forgotten_password_page.py	2012-02-17 14:21:18 +0000
@@ -16,9 +16,12 @@
 
 """Forgotten Password page UI."""
 
+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.utils.ui import (
     EMAIL_LABEL,
@@ -139,10 +142,15 @@
     def _connect_ui(self):
         """Connect the diff signals from the Ui."""
         self.email_address_line_edit.textChanged.connect(self._validate)
+        args = (self.app_name, self.email_address)
+        f = self.backend.request_password_reset_token
+
+        error_handler = partial(self._handle_error, f,
+            self.on_password_reset_error)
+
         self.send_button.clicked.connect(
-                            lambda: self.backend.request_password_reset_token(
-                                                self.app_name,
-                                                self.email_address))
+                            lambda: f(*args, reply_handler=NO_OP,
+                                error_handler=error_handler))
         self.try_again_button.clicked.connect(self.on_try_again)
 
     def _validate(self):

=== modified file 'ubuntu_sso/qt/gui.py'
--- ubuntu_sso/qt/gui.py	2012-02-13 16:16:03 +0000
+++ ubuntu_sso/qt/gui.py	2012-02-17 14:21:18 +0000
@@ -37,6 +37,7 @@
 from ubuntu_sso import main
 from ubuntu_sso.qt.loadingoverlay import LoadingOverlay
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils.ui import GENERIC_BACKEND_ERROR
 
 
 _ = gettext.gettext
@@ -149,6 +150,12 @@
             match = self.backend.connect_to_signal(signal, method)
             self._signals_receivers[signal] = match
 
+    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)
+        errordict = {'message': GENERIC_BACKEND_ERROR}
+        handler(self.app_name, errordict)
+
 
 class EnhancedLineEdit(object):
     """Represents and enhanced lineedit.

=== modified file 'ubuntu_sso/qt/reset_password_page.py'
--- ubuntu_sso/qt/reset_password_page.py	2012-02-10 21:09:38 +0000
+++ ubuntu_sso/qt/reset_password_page.py	2012-02-17 14:21:18 +0000
@@ -16,11 +16,14 @@
 
 """Reset Password page UI."""
 
+from functools import partial
+
 from PyQt4.QtCore import SIGNAL
 from PyQt4.QtCore import 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
@@ -193,7 +196,11 @@
         password = unicode(self.ui.password_line_edit.text())
         logger.info('Setting new password for %r and email %r with code %r',
                     self.app_name, email, code)
-        self.backend.set_new_password(self.app_name, email, code, password)
+        args = (self.app_name, email, code, password)
+        f = self.backend.set_new_password
+        error_handler = partial(self._handle_error, f,
+            self.on_password_change_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
 
     def is_correct_password_confirmation(self, password):
         """Return if the password is correct."""

=== modified file 'ubuntu_sso/qt/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-02-17 14:21:18 +0000
@@ -19,6 +19,7 @@
 import StringIO
 import tempfile
 import os
+from functools import partial
 
 # pylint: disable=F0401
 try:
@@ -30,6 +31,7 @@
 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
@@ -284,7 +286,11 @@
         fd = tempfile.TemporaryFile(mode='r')
         file_name = fd.name
         self.captcha_file = file_name
-        self.backend.generate_captcha(self.app_name, file_name)
+        args = (self.app_name, file_name)
+        f = self.backend.generate_captcha
+        error_handler = partial(self._handle_error, f,
+            self.on_captcha_generation_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
         self.on_captcha_refreshing()
 
     def _set_titles(self):
@@ -393,9 +399,12 @@
         # validate the current info of the form, try to perform the action
         # to register the user, and then move foward
         if self.validate_form():
-            self.backend.register_user(self.app_name, email,
-                                       password, name, captcha_id,
-                                       captcha_solution)
+            args = (self.app_name, email, password, name, captcha_id,
+                captcha_solution)
+            f = self.backend.register_user
+            error_handler = partial(self._handle_error, f,
+                self.on_user_registration_error)
+            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

=== modified file 'ubuntu_sso/qt/tests/__init__.py'
--- ubuntu_sso/qt/tests/__init__.py	2012-02-09 18:28:40 +0000
+++ ubuntu_sso/qt/tests/__init__.py	2012-02-17 14:21:18 +0000
@@ -21,7 +21,10 @@
 from twisted.trial.unittest import TestCase
 from ubuntu_sso.qt import loadingoverlay
 
-from ubuntu_sso import main
+from ubuntu_sso import (
+    main,
+    NO_OP,
+)
 
 
 class FakedObject(object):
@@ -29,7 +32,7 @@
 
     next_result = None
     exposed_methods = ['connect_to_signal',
-        'generate_captcha']
+        'generate_captcha', 'request_password_reset_token']
 
     def __init__(self, *args, **kwargs):
         self._args = args
@@ -384,6 +387,23 @@
         """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)
+
+        call = self.ui.backend._called[method]
+        self.assertEqual(call[0], args)
+
+        reply_handler = call[1].pop('reply_handler')
+        self.assertEqual(reply_handler, NO_OP)
+
+        error_handler = call[1].pop('error_handler')
+        self.assertEqual(error_handler.func, self.ui._handle_error)
+
+        self.assertEqual(call[1], kwargs)
+    # pylint: enable=E1101, W0212
+
 
 class BaseTestCaseUI(TestCase):
     """Base Test Case."""

=== 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-13 17:19:05 +0000
+++ ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-02-17 14:21:18 +0000
@@ -48,18 +48,20 @@
             "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.assertTrue('LoggedIn' in self.ui._signals)
-        self.assertTrue('LoginError' in self.ui._signals)
-        self.assertTrue('UserNotValidated' in self.ui._signals)
+        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']))
@@ -81,9 +83,9 @@
         self.patch(self.ui, "_connect_ui",
             faked_object._connect_ui)
         self.ui.setup_page()
-        self.assertTrue('_set_translated_strings' in faked_object._called)
-        self.assertTrue('_setup_signals' in faked_object._called)
-        self.assertTrue('_connect_ui' in faked_object._called)
+        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
 
     def test_on_user_not_validated(self):
@@ -98,7 +100,7 @@
             self.signals_results.append((email, password))
         self.ui.userNotValidated.connect(slot)
         self.ui.on_user_not_validated()
-        self.assertTrue((email, password) in self.signals_results)
+        self.assertIn((email, password), self.signals_results)
 
     def test_initialize_page(self):
         """Test the initialization method."""
@@ -110,8 +112,8 @@
         self.ui.initializePage()
         self.assertEqual(wizard.buttons_text[QtGui.QWizard.CancelButton],
             "Cancel")
-        self.assertTrue(('setButtonLayout',
-            (([QtGui.QWizard.BackButton, QtGui.QWizard.Stretch],), {})) in
+        self.assertIn(('setButtonLayout',
+            (([QtGui.QWizard.BackButton, QtGui.QWizard.Stretch],), {})),
             wizard.called)
         self.assertTrue(button.properties['default'])
         self.assertFalse(button.isEnabled())
@@ -178,12 +180,13 @@
         self.patch(FakedObject, "exposed_methods", exposed_methods)
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
-        self.ui.ui.email_edit.setText('valid@email')
-        self.ui.ui.password_edit.setText('123456')
+        email = 'valid@email'
+        password = '123456'
+        self.ui.ui.email_edit.setText(email)
+        self.ui.ui.password_edit.setText(password)
         self.ui.login()
-        self.assertTrue('login_and_ping' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['login_and_ping'],
-            ((None, u'valid@email', u'123456', ping), {}))
+        self.assert_backend_called('login_and_ping',
+            self.app_name, email, password, ping)
 
     def test_login_without_ping(self):
         """Test the login method."""
@@ -192,12 +195,13 @@
         self.patch(FakedObject, "exposed_methods", exposed_methods)
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
-        self.ui.ui.email_edit.setText('valid@email')
-        self.ui.ui.password_edit.setText('123456')
+        email = 'valid@email'
+        password = '123456'
+        self.ui.ui.email_edit.setText(email)
+        self.ui.ui.password_edit.setText(password)
         self.ui.login()
-        self.assertTrue('login' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['login'],
-            ((None, u'valid@email', u'123456'), {}))
+        self.assert_backend_called('login',
+            self.app_name, email, password)
 
     def test_on_login_error(self):
         """Test the on_login_error method."""
@@ -221,7 +225,7 @@
             self.signals_results.append((app, email))
         self.ui.userLoggedIn.connect(slot)
         self.ui.on_logged_in(app_name, None)
-        self.assertTrue((app_name, email) in self.signals_results)
+        self.assertIn((app_name, email), self.signals_results)
 
     def test_on_forgotten_password(self):
         """Test the on_forgotten_password method."""
@@ -231,7 +235,7 @@
             self.signals_results.append(1)
         self.ui.passwordForgotten.connect(slot)
         self.ui.on_forgotten_password()
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)
 
     def test_on_forgotten_password_link_clicked(self):
         """Test the on_forgotten_password method."""
@@ -241,4 +245,4 @@
             self.signals_results.append(1)
         self.ui.passwordForgotten.connect(slot)
         self.ui.ui.forgot_password_label.linkActivated.emit("link")
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)

=== modified file 'ubuntu_sso/qt/tests/test_email_verification.py'
--- ubuntu_sso/qt/tests/test_email_verification.py	2012-02-13 14:04:27 +0000
+++ ubuntu_sso/qt/tests/test_email_verification.py	2012-02-17 14:21:18 +0000
@@ -51,8 +51,8 @@
 
     def test_init(self):
         """Test the construction of the object."""
-        self.assertTrue('EmailValidated' in self.ui._signals)
-        self.assertTrue('EmailValidationError' in self.ui._signals)
+        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)
@@ -70,8 +70,8 @@
         self.patch(self.ui, "_connect_ui_elements",
             faked_object._connect_ui_elements)
         self.ui.setup_page()
-        self.assertTrue('_setup_signals' in faked_object._called)
-        self.assertTrue('_connect_ui_elements' in faked_object._called)
+        self.assertIn('_setup_signals', faked_object._called)
+        self.assertIn('_connect_ui_elements', faked_object._called)
     # pylint: enable=E1101
 
     def test_verification_code(self):
@@ -166,7 +166,7 @@
             self.signals_results.append((app, email))
         self.ui.registrationSuccess.connect(slot)
         self.ui.on_email_validated(app_name)
-        self.assertTrue((app_name, email) in self.signals_results)
+        self.assertIn((app_name, email), self.signals_results)
 
     def test_validate_email_with_ping(self):
         """Test the login method."""
@@ -185,9 +185,8 @@
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
         self.ui.validate_email()
-        self.assertTrue('validate_email_and_ping' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['validate_email_and_ping'],
-            ((app_name, email, password, code, ping), {}))
+        self.assert_backend_called('validate_email_and_ping',
+            app_name, email, password, code, ping)
 
     def test_validate_email_without_ping(self):
         """Test the login method."""
@@ -206,6 +205,5 @@
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
         self.ui.validate_email()
-        self.assertTrue('validate_email' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['validate_email'],
-            ((app_name, email, password, code), {}))
+        self.assert_backend_called('validate_email',
+            app_name, email, password, code)

=== modified file 'ubuntu_sso/qt/tests/test_forgotten_password.py'
--- ubuntu_sso/qt/tests/test_forgotten_password.py	2012-02-13 21:50:16 +0000
+++ ubuntu_sso/qt/tests/test_forgotten_password.py	2012-02-17 14:21:18 +0000
@@ -40,19 +40,20 @@
     def setUp(self):
         yield super(ForgottenPasswordTestCase, self).setUp()
         self.signals_results = []
+        self.patch(gui.main, "get_sso_client", FakedBackend)
         self.patch(forgotten_password_page.ForgottenPasswordPage,
             "passwordResetTokenSent", FakeSignal())
-        self.patch(gui.main, "get_sso_client", FakedBackend)
+        self.app_name = 'my_app'
         self.ui = forgotten_password_page.ForgottenPasswordPage(
             forgotten_password_ui.Ui_ForgottenPasswordPage(),
-            parent=None)
+            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.assertTrue('PasswordResetTokenSent' in self.ui._signals)
-        self.assertTrue('PasswordResetError' in self.ui._signals)
+        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)
@@ -78,11 +79,11 @@
         self.patch(self.ui, "_register_fields",
             faked_object._register_fields)
         self.ui.setup_page()
-        self.assertTrue('_setup_signals' in faked_object._called)
-        self.assertTrue('_set_translated_strings' in faked_object._called)
-        self.assertTrue('_connect_ui' in faked_object._called)
-        self.assertTrue('_set_enhanced_line_edit' in faked_object._called)
-        self.assertTrue('_register_fields' in faked_object._called)
+        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."""
@@ -120,6 +121,12 @@
         self.assertEqual(value, self.ui.ui.send_button)
         self.assertTrue(isinstance(value, QtGui.QPushButton))
 
+    def test_send_button_clicked(self):
+        """Test the send_button property."""
+        self.ui.send_button.clicked.emit(True)
+        self.assert_backend_called('request_password_reset_token',
+            self.app_name, '')
+
     def test_try_again_widget(self):
         """Test the try_again_widget property."""
         value = self.ui.try_again_widget

=== modified file 'ubuntu_sso/qt/tests/test_network_detection.py'
--- ubuntu_sso/qt/tests/test_network_detection.py	2012-02-02 15:44:18 +0000
+++ ubuntu_sso/qt/tests/test_network_detection.py	2012-02-17 14:21:18 +0000
@@ -60,10 +60,8 @@
             "wizard", FakeWizardButtonStyle)
         self.network_detection.initializePage()
         self.assertTrue(self.network_detection.btn_try_again.isDefault())
-        self.assertTrue(
-            'polish' in self.network_detection.btn_try_again.data)
-        self.assertTrue(
-            'unpolish' in self.network_detection.btn_try_again.data)
+        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)

=== modified file 'ubuntu_sso/qt/tests/test_reset_password.py'
--- ubuntu_sso/qt/tests/test_reset_password.py	2012-02-09 18:09:29 +0000
+++ ubuntu_sso/qt/tests/test_reset_password.py	2012-02-17 14:21:18 +0000
@@ -19,7 +19,6 @@
 
 from PyQt4 import QtGui, QtCore
 from twisted.internet import defer
-from twisted.trial.unittest import TestCase
 
 from ubuntu_sso.utils.ui import (
     PASSWORD1_ENTRY,
@@ -33,7 +32,12 @@
     RESET_TITLE,
 )
 from ubuntu_sso.qt.ui.reset_password_ui import Ui_ResetPasswordPage
-from ubuntu_sso.qt.tests import FakedBackend
+from ubuntu_sso.qt.tests import (
+    BaseTestCase,
+    FakedBackend,
+    FakedObject,
+    FakeWizard,
+)
 
 
 class FakePasswordAssistance(object):
@@ -50,52 +54,76 @@
         FakePasswordAssistance._called = False
 
 
-class ResetPasswordTestCase(TestCase):
+# We need this Fake until a future refactor.
+class FakeForgottenPage(object):
+
+    """Fake Forgotten Page."""
+
+    def __init__(self):
+        self.ui = self
+        self.email_line_edit = self
+        self.line_text = ''
+
+    # pylint: disable=C0103
+    def setText(self, text):
+        """Fake setText for Line edit."""
+        self.line_text = text
+    # pylint: enable=C0103
+
+    def text(self):
+        """Fake text for line edit."""
+        return self.line_text
+
+
+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.page = ResetPasswordPage(Ui_ResetPasswordPage(),
-                                                'app_name',
-                                                None)
+        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()
 
     def test_init(self):
         """Check the initial state of ResetPassword."""
-        self.assertEqual(self.page.ui.password_line_edit.receivers(
+        self.assertEqual(self.ui.ui.password_line_edit.receivers(
             QtCore.SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.page.ui.confirm_password_line_edit.receivers(
+        self.assertEqual(self.ui.ui.confirm_password_line_edit.receivers(
             QtCore.SIGNAL('textEdited(QString)')), 1)
 
     def test_initialize(self):
         """Check the Title and Subtitle."""
-        self.page.show()
-        self.page.initializePage()
-        self.addCleanup(self.page.hide)
-        self.assertEqual(self.page.header.title_label.text(), RESET_TITLE)
-        self.assertEqual(self.page.header.subtitle_label.text(),
+        self.ui.show()
+        self.ui.initializePage()
+        self.addCleanup(self.ui.hide)
+        self.assertEqual(self.ui.header.title_label.text(), RESET_TITLE)
+        self.assertEqual(self.ui.header.subtitle_label.text(),
             RESET_SUBTITLE)
-        self.assertEqual(self.page.ui.password_label.text(), PASSWORD1_ENTRY)
-        self.assertEqual(self.page.ui.confirm_password_label.text(),
+        self.assertEqual(self.ui.ui.password_label.text(), PASSWORD1_ENTRY)
+        self.assertEqual(self.ui.ui.confirm_password_label.text(),
             PASSWORD2_ENTRY)
-        self.assertEqual(self.page.ui.reset_code.text(), RESET_CODE_ENTRY)
+        self.assertEqual(self.ui.ui.reset_code.text(), RESET_CODE_ENTRY)
 
     def test_focus_changed_password_visibility(self):
         """Check visibility changes when focus_changed() is executed."""
-        self.page.show()
-        self.addCleanup(self.page.hide)
-        self.page.focus_changed(None, self.page.ui.password_line_edit)
-        self.assertTrue(self.page.ui.password_assistance.isVisible())
+        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.page.show()
-        self.addCleanup(self.page.hide)
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
         self.assertEqual(QtGui.QApplication.instance().receivers(
             QtCore.SIGNAL("focusChanged(QWidget*, QWidget*)")), 1)
-        self.page.hide()
+        self.ui.hide()
         self.assertEqual(QtGui.QApplication.instance().receivers(
             QtCore.SIGNAL("focusChanged(QWidget*, QWidget*)")), 0)
 
@@ -105,22 +133,40 @@
         """Check functions execution when focus_changed() is executed."""
         self.patch(common, 'password_default_assistance', self.fake.call)
         self.addCleanup(self.fake.clenaup)
-        self.page.show()
-        self.addCleanup(self.page.hide)
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
         self.assertFalse(FakePasswordAssistance._called)
-        self.page.focus_changed(None, self.page.ui.password_line_edit)
-        self.assertTrue(self.page.ui.password_assistance.isVisible())
+        self.ui.focus_changed(None, self.ui.ui.password_line_edit)
+        self.assertTrue(self.ui.ui.password_assistance.isVisible())
         self.assertTrue(FakePasswordAssistance._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.page.show()
-        self.addCleanup(self.page.hide)
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
         self.assertFalse(FakePasswordAssistance._called)
-        self.page.focus_changed(None, self.page.ui.confirm_password_line_edit)
-        self.assertTrue(self.page.ui.password_assistance.isVisible())
+        self.ui.focus_changed(None, self.ui.ui.confirm_password_line_edit)
+        self.assertTrue(self.ui.ui.password_assistance.isVisible())
         self.assertTrue(FakePasswordAssistance._called)
 
     # pylint: enable=W0212
+
+    def test_set_new_password(self):
+        """Test set_new_password method."""
+        email = '[e-mail]'
+        code = 'code'
+        password = 'password'
+        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-10 21:09:38 +0000
+++ ubuntu_sso/qt/tests/test_setup_account.py	2012-02-17 14:21:18 +0000
@@ -44,11 +44,13 @@
         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)
@@ -155,7 +157,10 @@
             self.signals_results.append((email, password))
         self.ui.userRegistered.connect(slot)
         self.ui.set_next_validation()
-        self.assertTrue((email, password) in self.signals_results)
+        self.assertIn((email, password), self.signals_results)
+        self.assert_backend_called('register_user',
+            self.app_name, email, password, name, captcha_id,
+            captcha_solution)
 
     def test_set_next_validation(self):
         """Test on_user_registered method."""
@@ -169,7 +174,13 @@
             self.signals_results.append((email, password))
         self.ui.userRegistered.connect(slot)
         self.ui.on_user_registered('app_name', None)
-        self.assertTrue((email, password) in self.signals_results)
+        self.assertIn((email, password), self.signals_results)
+
+    def test_captcha_image_is_requested_as_startup(self):
+        """The captcha image is requested at startup."""
+        # assert generate_captcha was called
+        self.assert_backend_called('generate_captcha',
+            self.app_name, self.ui.captcha_file)
 
 
 class SetupAccountFakeWizardTestCase(BaseTestCase):

=== modified file 'ubuntu_sso/qt/tests/test_sign_in_page.py'
--- ubuntu_sso/qt/tests/test_sign_in_page.py	2012-02-10 21:09:38 +0000
+++ ubuntu_sso/qt/tests/test_sign_in_page.py	2012-02-17 14:21:18 +0000
@@ -55,7 +55,7 @@
             self.signals_results.append(1)
         self.ui.existingAccountSelected.connect(slot)
         self.ui._set_next_existing()
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)
 
     def test_set_next_new(self):
         """Test _set_next_existing method."""
@@ -65,5 +65,5 @@
             self.signals_results.append(1)
         self.ui.newAccountSelected.connect(slot)
         self.ui._set_next_new()
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)
     # pylint: enable=W0212

=== modified file 'ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-02-13 20:37:57 +0000
+++ ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-02-17 14:21:18 +0000
@@ -89,6 +89,6 @@
         self.ui.show()
         self.addCleanup(self.ui.hide)
         self.ui.sign_in_page.ui.cancel_button.clicked.emit(True)
-        self.assertTrue('close' in faked_object._called)
-        self.assertTrue('reject' not in faked_object._called)
+        self.assertIn('close', faked_object._called)
+        self.assertNotIn('reject', faked_object._called)
     # pylint: enable=W0212, E1101