Merge lp:~nataliabidart/ubuntu/natty/ubuntu-sso-client/ubuntu-sso-client-1.1.2 into lp:ubuntu/natty/ubuntu-sso-client

[Natalia Bidart]

  * Adding dpkg (>= 1.15.7.2) as Pre-Depends (fixes LP: #658768).

  * Adding gnome-keyring as dep since python-gnomekeyring doesn't install it.

  * New upstream release:
    [ Natalia B. Bidart <email address hidden> ]
      * The success page is not shown until the backend notifies that the ping
      finished successfully (LP: #667893).
      * Added a new DBus signal UserNotValidated to indicate when a user is
      registered but not validated (LP: #667899).
      * Added new workflow so email validation is requested if necessary.

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-10-11 13:22:16 +0000
+++ PKG-INFO	2010-11-04 15:07:47 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 1.1.1
+Version: 1.1.2
 Summary: Ubuntu Single Sign-On client
 Home-page: https://launchpad.net/ubuntu-sso-client
 Author: Natalia Bidart

=== modified file 'data/ui.glade'
--- data/ui.glade	2010-10-11 13:22:16 +0000
+++ data/ui.glade	2010-11-04 15:07:47 +0000
@@ -105,21 +105,42 @@
       </packing>
     </child>
     <child>
-      <object class="GtkHBox" id="hbox1">
+      <object class="GtkAlignment" id="alignment5">
         <property name="visible">True</property>
+        <property name="xscale">0</property>
+        <property name="yscale">0</property>
         <child>
-          <object class="GtkVBox" id="captcha_vbox">
-            <property name="width_request">300</property>
-            <property name="height_request">60</property>
+          <object class="GtkHBox" id="hbox1">
             <property name="visible">True</property>
-            <property name="homogeneous">True</property>
             <child>
-              <object class="GtkEventBox" id="captcha_loading">
+              <object class="GtkVBox" id="captcha_vbox">
                 <property name="width_request">300</property>
                 <property name="height_request">60</property>
                 <property name="visible">True</property>
                 <child>
-                  <placeholder/>
+                  <object class="GtkEventBox" id="captcha_loading">
+                    <property name="width_request">300</property>
+                    <property name="height_request">60</property>
+                    <property name="visible">True</property>
+                    <child>
+                      <placeholder/>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkImage" id="captcha_image">
+                    <property name="width_request">300</property>
+                    <property name="visible">True</property>
+                    <property name="stock">gtk-missing-image</property>
+                  </object>
+                  <packing>
+                    <property name="position">1</property>
+                  </packing>
                 </child>
               </object>
               <packing>
@@ -129,55 +150,41 @@
               </packing>
             </child>
             <child>
-              <object class="GtkImage" id="captcha_image">
-                <property name="width_request">300</property>
-                <property name="height_request">60</property>
+              <object class="GtkVBox" id="vbox1">
                 <property name="visible">True</property>
-                <property name="stock">gtk-missing-image</property>
+                <child>
+                  <object class="GtkButton" id="captcha_reload_button">
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="relief">none</property>
+                    <property name="focus_on_click">False</property>
+                    <signal name="clicked" handler="on_captcha_reload_button_clicked"/>
+                    <child>
+                      <object class="GtkImage" id="image1">
+                        <property name="visible">True</property>
+                        <property name="icon_name">reload</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <placeholder/>
+                </child>
+                <child>
+                  <placeholder/>
+                </child>
               </object>
               <packing>
+                <property name="expand">False</property>
                 <property name="position">1</property>
               </packing>
             </child>
           </object>
-          <packing>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkVBox" id="vbox1">
-            <property name="visible">True</property>
-            <child>
-              <object class="GtkButton" id="captcha_reload_button">
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="relief">none</property>
-                <property name="focus_on_click">False</property>
-                <signal name="clicked" handler="on_captcha_reload_button_clicked"/>
-                <child>
-                  <object class="GtkImage" id="image1">
-                    <property name="visible">True</property>
-                    <property name="icon_name">reload</property>
-                  </object>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="position">1</property>
-          </packing>
         </child>
       </object>
       <packing>
@@ -333,7 +340,22 @@
     <property name="visible">True</property>
     <property name="spacing">10</property>
     <child>
-      <placeholder/>
+      <object class="GtkAlignment" id="alignment4">
+        <property name="visible">True</property>
+        <property name="xscale">0</property>
+        <property name="yscale">0</property>
+        <child>
+          <object class="GtkVBox" id="verify_email_details_vbox">
+            <property name="visible">True</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
     </child>
     <child>
       <object class="GtkHButtonBox" id="hbuttonbox2">
@@ -668,11 +690,11 @@
       </packing>
     </child>
   </object>
-  <object class="GtkVBox" id="success_vbox">
+  <object class="GtkVBox" id="finish_vbox">
     <property name="visible">True</property>
     <property name="spacing">10</property>
     <child>
-      <object class="GtkLabel" id="success_label">
+      <object class="GtkLabel" id="finish_label">
         <property name="visible">True</property>
         <property name="wrap">True</property>
       </object>
@@ -686,7 +708,7 @@
         <property name="visible">True</property>
         <property name="layout_style">end</property>
         <child>
-          <object class="GtkButton" id="success_close_button">
+          <object class="GtkButton" id="finish_close_button">
             <property name="label">gtk-close</property>
             <property name="visible">True</property>
             <property name="can_focus">True</property>

=== modified file 'debian/changelog'
--- debian/changelog	2010-10-18 15:03:42 +0000
+++ debian/changelog	2010-11-04 15:07:47 +0000
@@ -1,3 +1,16 @@
+ubuntu-sso-client (1.1.2-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release:
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * The success page is not shown until the backend notifies that the ping
+      finished successfully (LP: #667893).
+      * Added a new DBus signal UserNotValidated to indicate when a user is
+      registered but not validated (LP: #667899).
+      * Added new workflow so email validation is requested if necessary.
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Thu, 04 Nov 2010 11:00:45 -0300
+
 ubuntu-sso-client (1.1.1-0ubuntu1) natty; urgency=low
 
   * New upstream release (1.1.1):

=== modified file 'debian/control'
--- debian/control	2010-09-13 15:02:42 +0000
+++ debian/control	2010-11-04 15:07:47 +0000
@@ -13,9 +13,10 @@
 Package: ubuntu-sso-client
 Architecture: all
 XB-Python-Version: ${python:Versions}
+Pre-Depends: dpkg (>=1.15.7.2),
 Depends: ${misc:Depends},
  ${python:Depends},
- dpkg (>=1.15.7.2),
+ gnome-keyring,
  python-dbus,
  python-gnomekeyring,
  python-gtk2,

=== modified file 'setup.py'
--- setup.py	2010-10-11 13:22:16 +0000
+++ setup.py	2010-11-04 15:07:47 +0000
@@ -86,7 +86,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='1.1.1',
+    version='1.1.2',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/account.py	2010-11-04 15:07:47 +0000
@@ -170,6 +170,27 @@
                      'token_name: %r', credentials['consumer_key'], token_name)
         return credentials
 
+    def is_validated(self, email, password, token_name, sso_service=None):
+        """Return if user with 'email' and 'password' is validated."""
+        if sso_service is None:
+            token = self.login(email=email, password=password,
+                               token_name=token_name)
+
+            oauth_token = oauth.OAuthToken(token['token'],
+                                           token['token_secret'])
+            authorizer = OAuthAuthorizer(token['consumer_key'],
+                                         token['consumer_secret'],
+                                         oauth_token)
+            sso_service = self.sso_service_class(authorizer, self.service_url)
+
+        me_info = sso_service.accounts.me()
+        key = 'preferred_email'
+        result = key in me_info and me_info[key] != None
+
+        logger.debug('is_validated: email: %r token_name: %r, result: %r.',
+                     email, token_name, result)
+        return result
+
     def validate_email(self, email, password, email_token, token_name):
         """Validate an email token for user with 'email' and 'password'."""
         logger.debug('validate_email: email: %r password: <hidden>, '

=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/credentials.py	2010-11-04 15:07:47 +0000
@@ -105,7 +105,7 @@
                                  f.__name__, self.app_name, self.error_cb)
                 error_dict = {ERROR_KEY: msg,
                               ERROR_DETAIL_KEY: traceback.format_exc()}
-                self.error_cb(self.app_name, error_dict)
+                self.error_cb(error_dict)
             return result
 
         return inner
@@ -145,10 +145,10 @@
              'consumer_secret': <value>,
              'name': <the token name, matches "[app_name] @ [host name]">}
 
-        'error_cb' will be called when the credentials retrieval failed. Three
-        params will be passed: the app_name, the error message (user friendly,
-        not translatable so far), and the detailed error (usually the
-        traceback).
+        'error_cb' will be called when the credentials retrieval failed. Two
+        params will be passed: the app_name, and an error dict with 2 keys:
+        the error message (user friendly, not translatable so far), and
+        the detailed error (usually the traceback).
 
         'denial_cb' will be called when the user denied the credentials to the
         caller. A single param is passed: the app_name.
@@ -159,9 +159,10 @@
         self.window_id = window_id
         self.ping_url = ping_url
         self.tc_url = tc_url
-        self.success_cb = success_cb
-        self.error_cb = error_cb
+        self._success_cb = success_cb
+        self._error_cb = error_cb
         self.denial_cb = denial_cb
+        self.gui = None  # will hold the GUI instance
 
     @handle_exceptions(msg='Problem while retrieving credentials')
     def _login_success_cb(self, dialog, app_name, email):
@@ -181,13 +182,13 @@
             if status is None:
                 self.clear_credentials()
             else:
-                self.success_cb(app_name, creds)
+                self.success_cb(creds)
 
     def _login_error_cb(self, dialog, app_name, error):
         """Handle UI error when login/registration failed."""
         logger.warning('Login/registration failed app %r, error %r',
                        app_name, error)
-        self.error_cb(app_name, {ERROR_KEY: error})
+        self.error_cb({ERROR_KEY: error})
 
     def _auth_denial_cb(self, dialog, app_name):
         """The user decided not to allow the registration or login."""
@@ -226,22 +227,23 @@
         """Shows the UI, connect outcome signals."""
         # delay gui import to be able to function on non-graphical envs
         from ubuntu_sso import gui
-        app = gui.UbuntuSSOClientGUI(app_name=self.app_name,
+        self.gui = gui.UbuntuSSOClientGUI(app_name=self.app_name,
                         tc_url=self.tc_url, help_text=self.help_text,
                         window_id=self.window_id, login_only=login_only)
 
-        app.connect(gui.SIG_LOGIN_SUCCEEDED, self._login_success_cb)
-        app.connect(gui.SIG_LOGIN_FAILED, self._login_error_cb)
-        app.connect(gui.SIG_REGISTRATION_SUCCEEDED, self._login_success_cb)
-        app.connect(gui.SIG_REGISTRATION_FAILED, self._login_error_cb)
-        app.connect(gui.SIG_USER_CANCELATION, self._auth_denial_cb)
+        self.gui.connect(gui.SIG_LOGIN_SUCCEEDED, self._login_success_cb)
+        self.gui.connect(gui.SIG_LOGIN_FAILED, self._login_error_cb)
+        self.gui.connect(gui.SIG_REGISTRATION_SUCCEEDED,
+                         self._login_success_cb)
+        self.gui.connect(gui.SIG_REGISTRATION_FAILED, self._login_error_cb)
+        self.gui.connect(gui.SIG_USER_CANCELATION, self._auth_denial_cb)
 
     @handle_exceptions(msg='Problem while retrieving credentials')
     def _login_or_register(self, login_only):
         """Get credentials if found else prompt the GUI."""
         token = self.find_credentials()
         if token is not None and len(token) > 0:
-            self.success_cb(self.app_name, token)
+            self.success_cb(token)
         elif token == {}:
             gobject.idle_add(self._show_ui, login_only)
         else:
@@ -249,6 +251,28 @@
             logger.info('_login_or_register: call to "find_credentials" went '
                         'wrong, and was already handled.')
 
+    def error_cb(self, error_dict):
+        """Handle error.
+
+        Notify the caller and finish the GUI with error.
+
+        """
+        self._error_cb(self.app_name, error_dict)
+        if self.gui is not None:
+            self.gui.finish_error(error=error_dict)
+        self.gui = None
+
+    def success_cb(self, creds):
+        """Handle success.
+
+        Notify the caller and finish the GUI with success.
+
+        """
+        self._success_cb(self.app_name, creds)
+        if self.gui is not None:
+            self.gui.finish_success()
+        self.gui = None
+
     @handle_exceptions(msg='Problem while retrieving credentials')
     def find_credentials(self):
         """Get the credentials for 'self.app_name'. Return {} if not there."""

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/gui.py	2010-11-04 15:07:47 +0000
@@ -205,6 +205,8 @@
     """Ubuntu single sign on GUI."""
 
     CAPTCHA_SOLUTION_ENTRY = _('Type the characters above')
+    CAPTCHA_LOAD_ERROR = _('There was a problem getting the captcha, '
+                           'reloading...')
     CONNECT_HELP_LABEL = _('To connect this computer to %(app_name)s ' \
                            'enter your details below.')
     EMAIL1_ENTRY = _('Email address')
@@ -213,6 +215,7 @@
                        'and try entering them again.')
     EMAIL_INVALID = _('The email must be a valid email address.')
     EMAIL_TOKEN_ENTRY = _('Enter code verification here')
+    ERROR = _('The process did not finish successfully.')
     FIELD_REQUIRED = _('This field is required.')
     FORGOTTEN_PASSWORD_BUTTON = _('I\'ve forgotten my password')
     JOIN_HEADER_LABEL = _('Create %(app_name)s account')
@@ -256,7 +259,7 @@
     YES_TO_UPDATES = _('Yes! Email me %(app_name)s tips and updates.')
     CAPTCHA_RELOAD_TOOLTIP = _('Reload')
 
-    def __init__(self, app_name, tc_url, help_text,
+    def __init__(self, app_name, tc_url='', help_text='',
                  window_id=0, login_only=False, close_callback=None):
         """Create the GUI and initialize widgets."""
         gtk.link_button_set_uri_hook(NO_OP)
@@ -264,12 +267,15 @@
         self._captcha_filename = tempfile.mktemp()
         self._captcha_id = None
         self._signals_receivers = {}
+        self._done = False  # whether the whole process was completed or not
 
         self.app_name = app_name
         self.app_label = '<b>%s</b>' % self.app_name
         self.tc_url = tc_url
         self.help_text = help_text
         self.close_callback = close_callback
+        self.user_email = None
+        self.user_password = None
 
         ui_filename = get_data_file('ui.glade')
         builder = gtk.Builder()
@@ -325,23 +331,23 @@
         logger.debug('UbuntuSSOClientGUI: backend created: %r', self.backend)
 
         self.pages = (self.enter_details_vbox, self.processing_vbox,
-                      self.verify_email_vbox, self.success_vbox,
+                      self.verify_email_vbox, self.finish_vbox,
                       self.tc_browser_vbox, self.login_vbox,
                       self.request_password_token_vbox,
                       self.set_new_password_vbox)
 
         self._append_page(self._build_processing_page())
-        self._append_page(self._build_success_page())
+        self._append_page(self._build_finish_page())
         self._append_page(self._build_login_page())
         self._append_page(self._build_request_password_token_page())
         self._append_page(self._build_set_new_password_page())
+        self._append_page(self._build_verify_email_page())
 
         window_size = None
         if not login_only:
             window_size = (550, 500)
             self._append_page(self._build_enter_details_page())
             self._append_page(self._build_tc_page())
-            self._append_page(self._build_verify_email_page())
             self.login_button.grab_focus()
             self._set_current_page(self.enter_details_vbox)
         else:
@@ -373,6 +379,8 @@
              self._filter_by_app_name(self.on_logged_in),
             'LoginError':
              self._filter_by_app_name(self.on_login_error),
+            'UserNotValidated':
+             self._filter_by_app_name(self.on_user_not_validated),
             'PasswordResetTokenSent':
              self._filter_by_app_name(self.on_password_reset_token_sent),
             'PasswordResetError':
@@ -383,7 +391,6 @@
              self._filter_by_app_name(self.on_password_change_error),
         }
         self._setup_signals()
-        self._gtk_signal_log = []
 
         if window_id != 0:
             # be as robust as possible:
@@ -405,6 +412,22 @@
 
         self.window.show()
 
+    @property
+    def success_vbox(self):
+        """The success page."""
+        self.finish_vbox.label.set_markup('<span size="x-large">%s</span>' %
+                                          self.SUCCESS)
+        return self.finish_vbox
+
+    @property
+    def error_vbox(self):
+        """The error page."""
+        self.finish_vbox.label.set_markup('<span size="x-large">%s</span>' %
+                                          self.ERROR)
+        return self.finish_vbox
+
+    # helpers
+
     def _filter_by_app_name(self, f):
         """Excecute the decorated function only for 'self.app_name'."""
 
@@ -460,10 +483,14 @@
         alignment.add(hbox)
         alignment.show_all()
 
+        # remove children to avoid:
+        # GtkWarning: Attempting to add a widget with type GtkAlignment to a
+        # GtkEventBox, but as a GtkBin subclass a GtkEventBox can only contain
+        # one widget at a time
+        for child in container.get_children():
+            container.remove(child)
         container.add(alignment)
 
-    # helpers
-
     def _set_warning_message(self, widget, message):
         """Set 'message' as text for 'widget'."""
         widget.set_text(message)
@@ -600,19 +627,17 @@
         self.verify_email_vbox.default_widget = self.verify_token_button
         self.verify_email_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
 
-        self.verify_email_vbox.pack_start(self.email_token_entry, expand=False)
-        self.verify_email_vbox.reorder_child(self.email_token_entry, 0)
+        self.verify_email_details_vbox.pack_start(self.email_token_entry,
+                                                  expand=False)
 
         return self.verify_email_vbox
 
-    def _build_success_page(self):
+    def _build_finish_page(self):
         """Build the success page."""
-        self.success_vbox.default_widget = self.success_close_button
-        self.success_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
-
-        self.success_label.set_markup('<span size="x-large">%s</span>' %
-                                      self.SUCCESS)
-        return self.success_vbox
+        self.finish_vbox.default_widget = self.finish_close_button
+        self.finish_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
+        self.finish_vbox.label = self.finish_label
+        return self.finish_vbox
 
     def _build_login_page(self):
         """Build the login page."""
@@ -716,6 +741,21 @@
                      signal_name, handler, args, kwargs)
         self.window.connect(signal_name, handler, *args, **kwargs)
 
+    def emit(self, *args, **kwargs):
+        """Emit a signal proxing the main window."""
+        logger.debug('emit: args  %r, kwargs, %r', args, kwargs)
+        self.window.emit(*args, **kwargs)
+
+    def finish_success(self):
+        """The whole process was completed succesfully. Show success page."""
+        self._done = True
+        self._set_current_page(self.success_vbox)
+
+    def finish_error(self, error):
+        """The whole process was not completed succesfully. Show error page."""
+        self._done = True
+        self._set_current_page(self.error_vbox)
+
     def on_close_clicked(self, *args, **kwargs):
         """Call self.close_callback if defined."""
         if os.path.exists(self._captcha_filename):
@@ -737,15 +777,8 @@
         while gtk.events_pending():
             gtk.main_iteration()
 
-        if len(args) > 0 and args[0] in self.cancels:
-            self.window.emit(SIG_USER_CANCELATION, self.app_name)
-        elif len(self._gtk_signal_log) > 0:
-            signal = self._gtk_signal_log[-1][0]
-            args = self._gtk_signal_log[-1][1:]
-            logger.info('emitting %r with args %r.', signal, args)
-            self.window.emit(signal, *args)
-        else:
-            self.window.emit(SIG_USER_CANCELATION, self.app_name)
+        if not self._done:
+            self.emit(SIG_USER_CANCELATION, self.app_name)
 
         # call user defined callback
         if self.close_callback is not None:
@@ -805,6 +838,8 @@
             return
 
         self._set_current_page(self.processing_vbox)
+        self.user_email = email1
+        self.user_password = password1
 
         logger.info('Calling register_user with email %r, password <hidden>,' \
                     ' captcha_id %r and captcha_solution %r.', email1,
@@ -825,8 +860,8 @@
             self.email_token_entry.set_warning(self.FIELD_REQUIRED)
             return
 
-        email = self.email1_entry.get_text()
-        password = self.password1_entry.get_text()
+        email = self.user_email
+        password = self.user_password
         f = self.backend.validate_email
         logger.info('Calling validate_email with email %r, password <hidden>' \
                     ', app_name %r and email_token %r.', email, self.app_name,
@@ -864,6 +899,8 @@
           reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
+        self.user_email = email
+        self.user_password = password
 
     def on_login_back_button_clicked(self, *args, **kwargs):
         """User wants to go to the previous page."""
@@ -1025,15 +1062,6 @@
             result = msg1 if msg1 is not None else msg2
         return result
 
-    def _append_error_signal(self, signal, error):
-        """Append 'signal' to the log with a formatted version of 'error'.
-
-        Format DBus dict 'error' into a nice string.
-
-        """
-        msg = '\n'.join('%s: %s' % i for i in error.iteritems())
-        self._gtk_signal_log.append((signal, self.app_name, msg))
-
     @log_call
     def on_captcha_generated(self, app_name, captcha_id, *args, **kwargs):
         """Captcha image has been generated and is available to be shown."""
@@ -1046,6 +1074,8 @@
     @log_call
     def on_captcha_generation_error(self, app_name, error, *args, **kwargs):
         """Captcha image generation failed."""
+        self._set_warning_message(self.warning_label, self.CAPTCHA_LOAD_ERROR)
+        self._generate_captcha()
 
     @log_call
     def on_user_registered(self, app_name, email, *args, **kwargs):
@@ -1069,15 +1099,14 @@
             self.password2_entry.set_warning(msg)
 
         msg = self._build_general_error_message(error)
+        self._generate_captcha()
         self._set_current_page(self.enter_details_vbox, warning_text=msg)
-        self._append_error_signal(SIG_REGISTRATION_FAILED, error)
 
     @log_call
     def on_email_validated(self, app_name, email, *args, **kwargs):
         """User email was successfully verified."""
-        self._set_current_page(self.success_vbox)
-        self._gtk_signal_log.append((SIG_REGISTRATION_SUCCEEDED, self.app_name,
-                                    email))
+        self._done = True
+        self.emit(SIG_REGISTRATION_SUCCEEDED, self.app_name, email)
 
     @log_call
     def on_email_validation_error(self, app_name, error, *args, **kwargs):
@@ -1088,21 +1117,23 @@
 
         msg = self._build_general_error_message(error)
         self._set_current_page(self.verify_email_vbox, warning_text=msg)
-        self._append_error_signal(SIG_REGISTRATION_FAILED, error)
 
     @log_call
     def on_logged_in(self, app_name, email, *args, **kwargs):
         """User was successfully logged in."""
-        self._set_current_page(self.success_vbox)
-        self._gtk_signal_log.append((SIG_LOGIN_SUCCEEDED, self.app_name,
-                                    email))
+        self._done = True
+        self.emit(SIG_LOGIN_SUCCEEDED, self.app_name, email)
 
     @log_call
     def on_login_error(self, app_name, error, *args, **kwargs):
         """User was not successfully logged in."""
         msg = self._build_general_error_message(error)
         self._set_current_page(self.login_vbox, warning_text=msg)
-        self._append_error_signal(SIG_LOGIN_FAILED, error)
+
+    @log_call
+    def on_user_not_validated(self, app_name, email, *args, **kwargs):
+        """User was not validated."""
+        self.on_user_registered(app_name, email)
 
     @log_call
     def on_password_reset_token_sent(self, app_name, email, *args, **kwargs):

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/main.py	2010-11-04 15:07:47 +0000
@@ -106,12 +106,8 @@
         dbus.service.Object.__init__(self, object_path=object_path,
                                      bus_name=bus_name)
         self.sso_login_processor_class = sso_login_processor_class
-        self.sso_service_class = sso_service_class
-
-    def processor(self):
-        """Create a login processor with the given class and service class."""
-        return self.sso_login_processor_class(
-                                    sso_service_class=self.sso_service_class)
+        self.processor = self.sso_login_processor_class(
+                                    sso_service_class=sso_service_class)
 
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -132,7 +128,7 @@
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            return self.processor().generate_captcha(filename)
+            return self.processor.generate_captcha(filename)
         blocking(f, app_name, self.CaptchaGenerated,
                  self.CaptchaGenerationError)
 
@@ -156,8 +152,8 @@
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            return self.processor().register_user(email, password,
-                                                  captcha_id, captcha_solution)
+            return self.processor.register_user(email, password,
+                                                captcha_id, captcha_solution)
         blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
 
     # login signals
@@ -173,6 +169,12 @@
         logger.debug('SSOLogin: emitting LoginError with '
                      'app_name "%s" and error %r', app_name, error)
 
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def UserNotValidated(self, app_name, result):
+        """Signal thrown when the user is not validated."""
+        logger.debug('SSOLogin: emitting UserNotValidated with app_name "%s" '
+                     'and result %r', app_name, result)
+
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='sss')
     def login(self, app_name, email, password):
@@ -182,12 +184,23 @@
             token_name = get_token_name(app_name)
             logger.debug('login: token_name %r, email %r, password <hidden>.',
                          token_name, email)
-            credentials = self.processor().login(email, password, token_name)
+            credentials = self.processor.login(email, password, token_name)
             logger.debug('login returned not None credentials? %r.',
                          credentials is not None)
-            keyring_store_credentials(app_name, credentials)
-            return email
-        blocking(f, app_name, self.LoggedIn, self.LoginError)
+            return credentials
+
+        def success_cb(app_name, credentials):
+            """Login finished successfull."""
+            token_name = get_token_name(app_name)
+            is_validated = self.processor.is_validated(email, password,
+                                                       token_name)
+            logger.debug('user is validated? %r.', is_validated)
+            if is_validated:
+                keyring_store_credentials(app_name, credentials)
+                self.LoggedIn(app_name, email)
+            else:
+                self.UserNotValidated(app_name, email)
+        blocking(f, app_name, success_cb, self.LoginError)
 
     # validate_email signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -209,8 +222,8 @@
         def f():
             """Inner function that will be run in a thread."""
             token_name = get_token_name(app_name)
-            credentials = self.processor().validate_email(email, password,
-                                                   email_token, token_name)
+            credentials = self.processor.validate_email(email, password,
+                                                      email_token, token_name)
             keyring_store_credentials(app_name, credentials)
             return email
         blocking(f, app_name, self.EmailValidated, self.EmailValidationError)
@@ -234,7 +247,7 @@
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            return self.processor().request_password_reset_token(email)
+            return self.processor.request_password_reset_token(email)
         blocking(f, app_name, self.PasswordResetTokenSent,
                  self.PasswordResetError)
 
@@ -257,8 +270,8 @@
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            return self.processor().set_new_password(email, token,
-                                                     new_password)
+            return self.processor.set_new_password(email, token,
+                                                   new_password)
         blocking(f, app_name, self.PasswordChanged, self.PasswordChangeError)
 
 

=== modified file 'ubuntu_sso/tests/test_account.py'
--- ubuntu_sso/tests/test_account.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/tests/test_account.py	2010-11-04 15:07:47 +0000
@@ -102,6 +102,9 @@
 class FakedAccounts(object):
     """Fake the accounts service."""
 
+    def __init__(self):
+        self.preferred_email = EMAIL
+
     def validate_email(self, email_token):
         """Fake the email validation. Return a fix result."""
         if email_token is None:
@@ -114,6 +117,17 @@
         else:
             return STATUS_EMAIL_OK
 
+    # pylint: disable=E0202, C0103
+
+    def me(self):
+        """Fake the 'me' information."""
+        return {u'username': u'Wh46bKY',
+                u'preferred_email': self.preferred_email,
+                u'displayname': u'',
+                u'unverified_emails': [u'[e-mail]'],
+                u'verified_emails': [],
+                u'openid_identifier': u'Wh46bKY'}
+
 
 class FakedSSOServer(object):
     """Fake an SSO server."""
@@ -229,6 +243,29 @@
         result = self.processor.login(**self.login_kwargs)
         self.assertEqual(TOKEN, result, 'authentication was successful.')
 
+    # is_validated
+
+    def test_is_validated(self):
+        """If preferred email is not None, user is validated."""
+        result = self.processor.is_validated(**self.login_kwargs)
+        self.assertTrue(result, 'user must be validated.')
+
+    def test_is_not_validated(self):
+        """If preferred email is None, user is not validated."""
+        service = FakedSSOServer(None, None)
+        service.accounts.preferred_email = None
+        result = self.processor.is_validated(sso_service=service,
+                                             **self.login_kwargs)
+        self.assertFalse(result, 'user must not be validated.')
+
+    def test_is_not_validated_empty_result(self):
+        """If preferred email is None, user is not validated."""
+        service = FakedSSOServer(None, None)
+        service.accounts.me = lambda: {}
+        result = self.processor.is_validated(sso_service=service,
+                                             **self.login_kwargs)
+        self.assertFalse(result, 'user must not be validated.')
+
     # validate_email
 
     def test_validate_email_if_status_ok(self):

=== modified file 'ubuntu_sso/tests/test_credentials.py'
--- ubuntu_sso/tests/test_credentials.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/tests/test_credentials.py	2010-11-04 15:07:47 +0000
@@ -78,6 +78,7 @@
         self.args = None
         self.kwargs = None
         self.signals = []
+        self.methods = []
 
         class FakedUbuntuSSOClientGUI(object):
             """Fake a SSO GUI."""
@@ -90,6 +91,14 @@
                 self.kwargs = kwargs
                 sself.connect = lambda *a: self.signals.append(a)
 
+            def finish_success(sself):
+                """Fake the success finish."""
+                self.methods.append('finish_success')
+
+            def finish_error(sself, error):
+                """Fake the error finish."""
+                self.methods.append(('finish_error', error))
+
         self.patch(credentials.keyring.gnomekeyring, 'is_available',
                    lambda: True)
         self.patch(gui, 'UbuntuSSOClientGUI', FakedUbuntuSSOClientGUI)
@@ -133,15 +142,15 @@
 
     def test_callbacks_are_stored(self):
         """Creation callbacks are stored."""
-        self.assertEqual(self.obj.success_cb, self.success)
-        self.assertEqual(self.obj.error_cb, self.error)
+        self.assertEqual(self.obj._success_cb, self.success)
+        self.assertEqual(self.obj._error_cb, self.error)
         self.assertEqual(self.obj.denial_cb, self.denial)
 
     def test_callbacks_default_to_no_op(self):
         """The callbacks are a no-operation if not given."""
         self.obj = credentials.Credentials(**KWARGS)
-        self.assertEqual(self.obj.success_cb, NO_OP)
-        self.assertEqual(self.obj.error_cb, NO_OP)
+        self.assertEqual(self.obj._success_cb, NO_OP)
+        self.assertEqual(self.obj._error_cb, NO_OP)
         self.assertEqual(self.obj.denial_cb, NO_OP)
 
     def test_creation_parameters_are_stored(self):
@@ -181,7 +190,55 @@
 
         self.assertEqual(getattr(self.obj, PING_URL_KEY), None)
 
-    def test_login_success_cb_if_cred_not_found(self):
+    def test_success_cb_gui_none(self):
+        """Success callback calls the caller but not the GUI."""
+        self.obj.gui = None
+        self.obj.success_cb(creds=TOKEN)
+
+        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}),
+                         'caller _success_cb was called.')
+        self.assertEqual(self.methods, [],
+                         'GUI finish_success was not called.')
+
+    def test_success_cb_gui_not_none(self):
+        """Success callback calls the caller and finish the GUI."""
+        self.obj.gui = gui.UbuntuSSOClientGUI(APP_NAME)
+        self.obj.success_cb(creds=TOKEN)
+
+        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}),
+                         'caller _success_cb was called.')
+        self.assertEqual(self.methods, ['finish_success'],
+                         'GUI finish_success was called.')
+        self.assertTrue(self.obj.gui is None, 'gui is reset to None.')
+
+    def test_error_cb_gui_none(self):
+        """Error callback calls the caller but not the GUI."""
+        self.obj.gui = None
+        error_dict = {'foo': 'bar'}
+        self.obj.error_cb(error_dict=error_dict)
+
+        self.assertEqual(self._called, (('error', APP_NAME, error_dict), {}),
+                         'caller _error_cb was called.')
+        self.assertEqual(self.methods, [],
+                         'GUI finish_error was not called.')
+
+    def test_error_cb_gui_not_none(self):
+        """Error callback calls the caller and finish the GUI."""
+        self.obj.gui = gui.UbuntuSSOClientGUI(APP_NAME)
+        error_dict = {'foo': 'bar'}
+        self.obj.error_cb(error_dict=error_dict)
+
+        self.assertEqual(self._called, (('error', APP_NAME, error_dict), {}),
+                         'caller _error_cb was called.')
+        self.assertEqual(self.methods, [('finish_error', error_dict)],
+                         'GUI finish_error was called.')
+        self.assertTrue(self.obj.gui is None, 'gui is reset to None.')
+
+
+class CredentialsLoginSuccessTestCase(CredentialsTestCase):
+    """Test suite for the Credentials login success callback."""
+
+    def test_cred_not_found(self):
         """On auth success, if cred not found, self.error_cb is called."""
         self.patch(credentials, 'keyring_get_credentials', lambda app: None)
 
@@ -191,7 +248,7 @@
         self.assert_error_cb_called(msg='Problem while retrieving credentials',
                                     detailed_error=AssertionError(msg))
 
-    def test_login_success_cb_if_cred_error(self):
+    def test_cred_error(self):
         """On auth success, if cred failed, self.error_cb is called."""
         self.patch(credentials, 'keyring_get_credentials', self.fail)
 
@@ -201,7 +258,7 @@
         self.assert_error_cb_called(msg=msg, detailed_error=FailTest(APP_NAME))
         self.assertTrue(self.memento.check_exception(FailTest, APP_NAME))
 
-    def test_login_success_cb_if_ping_success(self):
+    def test_ping_success(self):
         """Auth success + cred found + ping success, success_cb is called."""
         self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
         self.patch(self.obj, '_ping_url', lambda *a, **kw: 200)
@@ -210,7 +267,7 @@
 
         self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
 
-    def test_login_success_cb_if_ping_error(self):
+    def test_ping_error(self):
         """Auth success + cred found + ping error, error_cb is called.
 
         Credentials are removed. The exception is logged.
@@ -235,7 +292,7 @@
         # exception logged
         self.assertTrue(self.memento.check_exception(FailTest, error))
 
-    def test_login_success_cb_pings_url(self):
+    def test_pings_url(self):
         """On auth success, self.ping_url is opened."""
         self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
 
@@ -247,15 +304,24 @@
 
         self.assertEqual(self._url_pinged, ((APP_NAME, EMAIL, TOKEN), {}))
 
+
+class CredentialsLoginErrorTestCase(CredentialsTestCase):
+    """Test suite for the Credentials login error callback."""
+
     def test_login_error_cb(self):
         """On login/register error, self.error_cb is called."""
         self.obj._login_error_cb(dialog=None, app_name=APP_NAME, error='Bla')
         self.assert_error_cb_called(msg='Bla')
 
+
+class CredentialsAuthDeniedTestCase(CredentialsTestCase):
+    """Test suite for the Credentials auth denied callback."""
+
     def test_auth_denial_cb(self):
         """On auth denied, self.denial_cb is called."""
         self.obj._auth_denial_cb(dialog=None, app_name=APP_NAME)
         self.assertEqual(self._called, (('denial', APP_NAME), {}))
+        self.assertEqual(self.methods, [], 'no GUI method was called.')
 
 
 class PingUrlTestCase(CredentialsTestCase):
@@ -436,6 +502,20 @@
         getattr(self.obj, self.operation)()
         self.assertEqual(self.signals, expected)
 
+    def test_gui_is_created(self):
+        """The GUI is created and stored."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: None)
+
+        getattr(self.obj, self.operation)()
+
+        self.assertIsInstance(self.obj.gui, gui.UbuntuSSOClientGUI)
+        self.assertEqual(self.args, ())
+
+        expected = KWARGS.copy()
+        expected.pop(PING_URL_KEY)
+        expected['login_only'] = self.login_only
+        self.assertEqual(self.kwargs, expected)
+
 
 class LoginTestCase(RegisterTestCase):
     """Test suite for the login method."""

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-11-04 15:07:47 +0000
@@ -386,7 +386,7 @@
         super(UbuntuSSOClientTestCase, self).setUp()
         self.patch(dbus, 'SessionBus', FakedSessionBus)
         self.patch(dbus, 'Interface', FakedSSOBackend)
-        self.pages = ('enter_details', 'processing', 'verify_email', 'success',
+        self.pages = ('enter_details', 'processing', 'verify_email', 'finish',
                       'tc_browser', 'login', 'request_password_token',
                       'set_new_password')
         self.ui = self.gui_class(**self.kwargs)
@@ -657,6 +657,18 @@
         self.gui_class(window_id=xid, **self.kwargs)
         self.assertEqual(self._called, ((xid,), {}))
 
+    def test_finish_success_shows_success_page(self):
+        """When calling 'finish_success' the success page is shown."""
+        self.ui.finish_success()
+        self.assert_pages_visibility(finish=True)
+        self.assertEqual(self.ui.SUCCESS, self.ui.finish_vbox.label.get_text())
+
+    def test_finish_error_shows_error_page(self):
+        """When calling 'finish_error' the error page is shown."""
+        self.ui.finish_error(error=self.error)
+        self.assert_pages_visibility(finish=True)
+        self.assertEqual(self.ui.ERROR, self.ui.finish_vbox.label.get_text())
+
 
 class EnterDetailsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (enter details page)."""
@@ -679,7 +691,7 @@
         self.assert_entries_are_packed_to_ui('enter_details_vbox', ('name',))
         self.assert_entries_are_packed_to_ui('captcha_solution_vbox',
                                              ('captcha_solution',))
-        self.assert_entries_are_packed_to_ui('verify_email_vbox',
+        self.assert_entries_are_packed_to_ui('verify_email_details_vbox',
                                              ('email_token',))
 
     def test_initial_texts_for_checkbuttons(self):
@@ -866,6 +878,20 @@
         self.ui.join_ok_button.clicked()
         self.assertTrue(self._called)
 
+    def test_user_and_pass_are_cached(self):
+        """Username and password are temporarly cached for further use."""
+        self.click_join_with_valid_data()
+        self.assertEqual(self.ui.user_email, EMAIL)
+        self.assertEqual(self.ui.user_password, PASSWORD)
+
+    def test_on_captcha_generation_error(self):
+        """on_captcha_generation_error shows an error and reloads captcha."""
+        self.patch(self.ui, '_generate_captcha', self._set_called)
+        self.ui.on_captcha_generation_error(APP_NAME, error=self.error)
+        self.assert_correct_label_warning(self.ui.warning_label,
+                                          self.ui.CAPTCHA_LOAD_ERROR)
+        self.assertEqual(self._called, ((), {}))
+
 
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (with no t&c link)."""
@@ -1054,6 +1080,12 @@
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.assert_pages_visibility(enter_details=True)
 
+    def test_captcha_is_reloaded(self):
+        """On UserRegistrationError the captcha is reloaded."""
+        self.patch(self.ui, '_generate_captcha', self._set_called)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
+        self.assertEqual(self._called, ((), {}))
+
     def test_warning_label_is_shown(self):
         """On UserRegistrationError the warning label is shown."""
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
@@ -1114,6 +1146,17 @@
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
+    def test_on_verify_token_button_clicked(self):
+        """Verify token uses cached user_email and user_password."""
+        self.ui.user_email = '[e-mail]'
+        self.ui.user_password = 'yadda-yedda'
+        self.ui.on_verify_token_button_clicked()
+        self.assertEqual(self.ui.backend._called['validate_email'],
+                         ((APP_NAME, self.ui.user_email,
+                           self.ui.user_password, EMAIL_TOKEN),
+                          dict(reply_handler=gui.NO_OP,
+                               error_handler=gui.NO_OP)))
+
     def test_on_verify_token_button_shows_processing_page(self):
         """Verify token button triggers call to backend."""
         self.click_verify_email_with_valid_data()
@@ -1125,10 +1168,10 @@
         self.click_verify_email_with_valid_data()
         self.assert_warnings_visibility()
 
-    def test_on_email_validated_shows_success_page(self):
-        """On email validated the success page is shown."""
+    def test_on_email_validated_shows_processing_page(self):
+        """On email validated the procesing page is still shown."""
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(success=True)
+        self.assert_pages_visibility(processing=True)
 
     def test_on_email_validated_does_not_clear_the_help_text(self):
         """On email validated the help text is not removed."""
@@ -1159,13 +1202,21 @@
 
     def test_success_label_is_correct(self):
         """The success message is correct."""
-        self.assertEqual(self.ui.SUCCESS, self.ui.success_label.get_text())
-        markup = self.ui.success_label.get_label()
-        self.assertTrue('<span size="x-large">' in markup)
-
-    def test_on_success_close_button_clicked_closes_window(self):
+        self.assertEqual(self.ui.SUCCESS,
+                         self.ui.success_vbox.label.get_text())
+        markup = self.ui.success_vbox.label.get_label()
+        self.assertTrue('<span size="x-large">' in markup)
+
+    def test_error_label_is_correct(self):
+        """The error message is correct."""
+        self.assertEqual(self.ui.ERROR,
+                         self.ui.error_vbox.label.get_text())
+        markup = self.ui.error_vbox.label.get_label()
+        self.assertTrue('<span size="x-large">' in markup)
+
+    def test_on_finish_close_button_clicked_closes_window(self):
         """When done the window is closed."""
-        self.ui.success_close_button.clicked()
+        self.ui.finish_close_button.clicked()
         self.assertFalse(self.ui.window.get_property('visible'))
 
     def test_verify_token_button_does_nothing_if_clicked_but_disabled(self):
@@ -1182,7 +1233,7 @@
 
 
 class VerifyEmailValidationTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user registration (verify email page)."""
+    """Test suite for the user registration validation (verify email page)."""
 
     def setUp(self):
         """Init."""
@@ -1217,6 +1268,20 @@
         self.assert_warnings_visibility()
 
 
+class VerifyEmailLoginOnlyTestCase(VerifyEmailTestCase):
+    """Test suite for the user login (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
+                  login_only=True)
+
+
+class VerifyEmailValidationLoginOnlyTestCase(VerifyEmailValidationTestCase):
+    """Test suite for the user login validation (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
+                  login_only=True)
+
+
 class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration  validations."""
 
@@ -1419,11 +1484,11 @@
         self.click_connect_with_valid_data()
         self.assert_pages_visibility(processing=True)
 
-    def test_on_logged_in_morphs_to_success_page(self):
-        """When user logged in the success page is shown."""
+    def test_on_logged_in_morphs_to_processing_page(self):
+        """When user logged in the processing page is still shown."""
         self.click_connect_with_valid_data()
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(success=True)
+        self.assert_pages_visibility(processing=True)
 
     def test_on_login_error_morphs_to_login_page(self):
         """On user login error, the previous page is shown."""
@@ -1431,6 +1496,12 @@
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.assert_pages_visibility(login=True)
 
+    def test_on_user_not_validated_morphs_to_verify_page(self):
+        """On user not validated, the verify page is shown."""
+        self.click_connect_with_valid_data()
+        self.ui.on_user_not_validated(app_name=APP_NAME, email=EMAIL)
+        self.assert_pages_visibility(verify_email=True)
+
     def test_on_login_error_a_warning_is_shown(self):
         """On user login error, a warning is shown with proper wording."""
         self.click_connect_with_valid_data()
@@ -1468,6 +1539,12 @@
         self.ui.login_ok_button.clicked()
         self.assertTrue(self._called)
 
+    def test_user_and_pass_are_cached(self):
+        """Username and password are temporarly cached for further use."""
+        self.click_connect_with_valid_data()
+        self.assertEqual(self.ui.user_email, EMAIL)
+        self.assertEqual(self.ui.user_password, PASSWORD)
+
 
 class LoginValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user login validation."""
@@ -1731,8 +1808,8 @@
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
-    def test_on_password_changed_shows_success_page(self):
-        """When password was successfuly changed the success page is shown."""
+    def test_on_password_changed_shows_login_page(self):
+        """When password was successfuly changed the login page is shown."""
         self.ui.on_password_changed(app_name=APP_NAME, email=EMAIL)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.PASSWORD_CHANGED)
@@ -1846,7 +1923,7 @@
         """All the backend signals are listed to be binded."""
         for sig in ('CaptchaGenerated', 'CaptchaGenerationError',
                     'UserRegistered', 'UserRegistrationError',
-                    'LoggedIn', 'LoginError',
+                    'LoggedIn', 'LoginError', 'UserNotValidated',
                     'EmailValidated', 'EmailValidationError',
                     'PasswordResetTokenSent', 'PasswordResetError',
                     'PasswordChanged', 'PasswordChangeError'):
@@ -1928,6 +2005,13 @@
         self.ui._signals['LoginError'](mismatch_app_name, 'dummy')
         self.assertFalse(self._called)
 
+    def test_on_user_not_validated_is_not_called(self):
+        """on_user_not_validated is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_user_not_validated', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['UserNotValidated'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
     def test_on_password_reset_token_sent_is_not_called(self):
         """on_password_reset_token_sent is not called if incorrect app_name."""
         self.patch(self.ui, 'on_password_reset_token_sent', self._set_called)
@@ -1986,8 +2070,6 @@
     def setUp(self):
         """Init."""
         super(SignalsTestCase, self).setUp()
-        self._expected_error = (APP_NAME, '\n'.join('%s: %s' % i
-                                          for i in self.error.iteritems()))
         self._called = {}
         for sig_name, _ in gui.SIGNAL_ARGUMENTS:
             self.ui.connect(sig_name, self._set_called, sig_name)
@@ -2018,12 +2100,12 @@
             self._called = {}
 
     def test_on_user_registration_error_proper_signal_is_emitted(self):
-        """On UserRegistrationError, 'registration-failed' signal is sent."""
+        """On UserRegistrationError, SIG_USER_CANCELATION signal is sent."""
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
-        expected = (self.ui.window, self._expected_error, {})
+        expected = (self.ui.window, (APP_NAME,), {})
         self.assertEqual(expected,
-                         self._called[gui.SIG_REGISTRATION_FAILED])
+                         self._called[gui.SIG_USER_CANCELATION])
 
     def test_on_email_validated_proper_signals_is_emitted(self):
         """On EmailValidated, 'registration-succeeded' signal is sent."""
@@ -2033,12 +2115,12 @@
                           self._called[gui.SIG_REGISTRATION_SUCCEEDED])
 
     def test_on_email_validation_error_proper_signals_is_emitted(self):
-        """On EmailValidationError, 'registration-failed' signal is sent."""
+        """On EmailValidationError, SIG_USER_CANCELATION signal is sent."""
         self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
-        expected = (self.ui.window, self._expected_error, {})
+        expected = (self.ui.window, (APP_NAME,), {})
         self.assertEqual(expected,
-                         self._called[gui.SIG_REGISTRATION_FAILED])
+                         self._called[gui.SIG_USER_CANCELATION])
 
     def test_on_logged_in_proper_signals_is_emitted(self):
         """On LoggedIn, 'login-succeeded' signal is sent."""
@@ -2048,13 +2130,13 @@
                           self._called[gui.SIG_LOGIN_SUCCEEDED])
 
     def test_on_login_error_proper_signals_is_emitted(self):
-        """On LoginError, 'login-failed' signal is sent."""
+        """On LoginError, SIG_USER_CANCELATION signal is sent."""
         self.click_connect_with_valid_data()
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
-        expected = (self.ui.window, self._expected_error, {})
+        expected = (self.ui.window, (APP_NAME,), {})
         self.assertEqual(expected,
-                         self._called[gui.SIG_LOGIN_FAILED])
+                         self._called[gui.SIG_USER_CANCELATION])
 
     def test_registration_successfull_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
@@ -2111,7 +2193,8 @@
             ('request_password_token_vbox',
              'request_password_token_ok_button'),
             ('set_new_password_vbox', 'set_new_password_ok_button'),
-            ('success_vbox', 'success_close_button'),
+            ('success_vbox', 'finish_close_button'),
+            ('error_vbox', 'finish_close_button'),
             ('processing_vbox', None))
 
     def test_pages_have_default_widget_set(self):

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/tests/test_main.py	2010-11-04 15:07:47 +0000
@@ -204,8 +204,11 @@
     def test_login(self):
         """Test that the login method works ok."""
         d = Deferred()
-        self.create_mock_processor().login(EMAIL, PASSWORD, TOKEN_NAME)
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
         self.mocker.result(TOKEN)
+        processor.is_validated(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(True)
         self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
@@ -220,13 +223,40 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "LoggedIn", verify)
         self.patch(client, "LoginError", d.errback)
+        self.patch(client, "UserNotValidated", d.errback)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_login_user_not_validated(self):
+        """Test that the login sends EmailNotValidated signal."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        processor.is_validated(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(False)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, email):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(email, EMAIL)
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "LoggedIn", d.errback)
+        self.patch(client, "LoginError", d.errback)
+        self.patch(client, "UserNotValidated", verify)
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
     def test_login_error(self):
         """Test that the login method fails as expected."""
         d = Deferred()
-        self.mockprocessorclass = self.mocker.mock()
+        self.create_mock_processor()
         self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
 
         def fake_gtn(*args):
@@ -247,6 +277,7 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "LoggedIn", d.errback)
         self.patch(client, "LoginError", verify)
+        self.patch(client, "UserNotValidated", d.errback)
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
@@ -276,7 +307,7 @@
     def test_validate_email_error(self):
         """Test that the validate_email method fails as expected."""
         d = Deferred()
-        self.mockprocessorclass = self.mocker.mock()
+        self.create_mock_processor()
         self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
 
         def fake_gtn(*args):
@@ -710,6 +741,10 @@
 
     timeout = 5
 
+    def setUp(self):
+        super(CredentialsManagementFindClearTestCase, self).setUp()
+        self.patch(ubuntu_sso.main, 'blocking', fake_ok_blocking)
+
     def test_find_credentials(self):
         """The credentials are asked and returned in signals."""
         self.create_mock_backend().find_credentials()