Merge lp:~nataliabidart/ubuntu/maverick/ubuntu-sso-client/ubuntu-sso-client-1.0.9 into lp:ubuntu/maverick/ubuntu-sso-client

[Natalia Bidart]

  * New upstream release:
    [ Natalia B. Bidart <email address hidden> ]
      - Register now uses the 'displayname' field to pass it on to SSO as display name (LP: #709494).

Unmerged revisions

22. By Natalia Bidart on 2011-04-12

Attaching bug Bug #709494.

21. By Natalia Bidart on 2011-03-29

* New upstream release:
  [ Natalia B. Bidart <email address hidden> ]
    - Register now uses the 'displayname' field to pass it on to SSO as
    display name (LP: #709494).

20. By Natalia Bidart on 2010-12-16

* New upstream release.

  [ Natalia B. Bidart <email address hidden> ]
     * Avoid generating an extra token when attempting to validate a user
     account (LP: #687523).

19. By Sebastien Bacher on 2010-11-05

releasing version 1.0.7-0ubuntu1

18. By Natalia Bidart on 2010-10-12

* New upstream release:

[ Alejandro J. Cura <email address hidden> ]
  * Replace twisted gtk reactor with the standard gtk mainloop. (LP: #655327).

[ Alejandro J. Cura <email address hidden> ]
  * Call the dbus mainloop thread init (fixes LP: #656545).

* Adding .bzr-builddeb/default.conf as per Michael Vog (mvo) request.

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

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

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-10-01 14:57:22 +0000
+++ PKG-INFO	2011-04-12 19:01:16 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 1.0.3
+Version: 1.0.9
 Summary: Ubuntu Single Sign-On client
 Home-page: https://launchpad.net/ubuntu-sso-client
 Author: Natalia Bidart

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2010-10-01 14:57:22 +0000
+++ bin/ubuntu-sso-login	2011-04-12 19:01:16 +0000
@@ -42,6 +42,7 @@
 import signal
 import sys
 
+import dbus.mainloop.glib
 import dbus.service
 import gtk
 
@@ -57,21 +58,21 @@
 
 
 logger = setup_logging("ubuntu-sso-login")
+dbus.mainloop.glib.threads_init()
 gtk.gdk.threads_init()
 DBusGMainLoop(set_as_default=True)
 
 
 def sighup_handler(*a, **kw):
-    """Stop the service.
-
-    This is not thread safe, see the link below for info:
-    www.listware.net/201004/gtk-devel-list/115067-unix-signals-in-glib.html
-    """
-    from twisted.internet import reactor
-    # Module 'twisted.internet.reactor' has no 'stop' member
-    # pylint: disable=E1101
+    """Stop the service."""
+    # This handler may be called in any thread, so is not thread safe.
+    # See the link below for info:
+    # www.listware.net/201004/gtk-devel-list/115067-unix-signals-in-glib.html
+    #
+    # gtk.main_quit and the logger methods are safe to be called from any thread.
+    # Just don't call other random stuff here.
     logger.info("Stoping Ubuntu SSO login manager since SIGHUP was received.")
-    reactor.stop()
+    gtk.main_quit()
 
 
 if __name__ == "__main__":
@@ -83,10 +84,6 @@
         logger.error("Ubuntu SSO login manager already running, quitting.")
         sys.exit(0)
 
-    logger.debug("Installing the Twisted gtk2reactor.")
-    from twisted.internet import gtk2reactor
-    gtk2reactor.install()
-
     logger.debug("Hooking up SIGHUP with handler %r.", sighup_handler)
     signal.signal(signal.SIGHUP, sighup_handler)
 
@@ -97,7 +94,4 @@
                                         bus=dbus.SessionBus()),
                    object_path=DBUS_CRED_PATH)
 
-    from twisted.internet import reactor
-    # Module 'twisted.internet.reactor' has no 'run' member
-    # pylint: disable=E1101
-    reactor.run()
+    gtk.main()

=== modified file 'data/ui.glade'
--- data/ui.glade	2010-08-27 22:16:40 +0000
+++ data/ui.glade	2011-04-12 19:01:16 +0000
@@ -264,36 +264,62 @@
       </packing>
     </child>
     <child>
-      <object class="GtkHButtonBox" id="hbuttonbox1">
+      <object class="GtkHBox" id="hbox2">
         <property name="visible">True</property>
-        <property name="spacing">5</property>
-        <property name="layout_style">end</property>
         <child>
-          <object class="GtkButton" id="join_cancel_button">
-            <property name="label">gtk-cancel</property>
+          <object class="GtkLinkButton" id="login_button">
+            <property name="label">login button</property>
             <property name="visible">True</property>
             <property name="can_focus">True</property>
             <property name="receives_default">True</property>
-            <property name="use_stock">True</property>
+            <property name="relief">none</property>
+            <signal name="clicked" handler="on_sign_in_button_clicked" swapped="no"/>
           </object>
           <packing>
             <property name="expand">False</property>
-            <property name="fill">False</property>
+            <property name="fill">True</property>
             <property name="position">0</property>
           </packing>
         </child>
         <child>
-          <object class="GtkButton" id="join_ok_button">
-            <property name="label">gtk-go-forward</property>
+          <object class="GtkHButtonBox" id="hbuttonbox1">
             <property name="visible">True</property>
-            <property name="can_focus">True</property>
-            <property name="receives_default">True</property>
-            <property name="use_stock">True</property>
-            <signal name="clicked" handler="on_join_ok_button_clicked"/>
+            <property name="can_focus">False</property>
+            <property name="spacing">5</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="join_cancel_button">
+                <property name="label">gtk-cancel</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="join_ok_button">
+                <property name="label">gtk-go-forward</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+                <signal name="clicked" handler="on_join_ok_button_clicked" swapped="no"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
           </object>
           <packing>
             <property name="expand">False</property>
-            <property name="fill">False</property>
+            <property name="pack_type">end</property>
             <property name="position">1</property>
           </packing>
         </child>
@@ -303,24 +329,6 @@
         <property name="position">12</property>
       </packing>
     </child>
-    <child>
-      <object class="GtkLinkButton" id="login_button">
-        <property name="label" translatable="yes">login button</property>
-        <property name="visible">True</property>
-        <property name="can_focus">True</property>
-        <property name="receives_default">True</property>
-        <property name="has_tooltip">True</property>
-        <property name="relief">none</property>
-        <signal name="clicked" handler="on_sign_in_button_clicked"/>
-      </object>
-      <packing>
-        <property name="expand">False</property>
-        <property name="position">13</property>
-      </packing>
-    </child>
-    <child>
-      <placeholder/>
-    </child>
   </object>
   <object class="GtkVBox" id="processing_vbox">
     <property name="visible">True</property>

=== modified file 'debian/changelog'
--- debian/changelog	2010-10-01 15:35:43 +0000
+++ debian/changelog	2011-04-12 19:01:16 +0000
@@ -1,3 +1,64 @@
+ubuntu-sso-client (1.0.9-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release:
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      - Register now uses the 'displayname' field to pass it on to SSO as
+      display name (LP: #709494).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Tue, 29 Mar 2011 16:26:42 -0300
+
+ubuntu-sso-client (1.0.8-0ubuntu1) maverick-proposed; urgency=low
+
+  * New upstream release.
+
+    [ Natalia B. Bidart <[e-mail]> ]
+       * Avoid generating an extra token when attempting to validate a user
+       account (LP: #687523).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Thu, 16 Dec 2010 13:19:01 -0300
+
+ubuntu-sso-client (1.0.7-0ubuntu1) maverick-proposed; urgency=low
+
+  * New upstream release (1.0.6, 1.0.7):
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * 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.
+      * The verify email page should be always built, not only on registration.
+
+    [ Alejandro J. Cura <[e-mail]> ]
+      * Store credentials on the keyring *only* from the main thread (LP:
+      #656545).
+
+  * New upstream release (1.0.5):
+
+    [ Natalia B. Bidart <[e-mail]> ]
+
+      * Credentials are removed if the pinging to the server fails or any
+      other exception occurs (LP: #660516).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Thu, 04 Nov 2010 09:21:00 -0300
+
+ubuntu-sso-client (1.0.4-0ubuntu1) maverick-proposed; urgency=low
+
+  * New upstream release:
+
+  [ Alejandro J. Cura <[e-mail]> ]
+    * Replace twisted gtk reactor with the standard gtk mainloop. (LP: #655327).
+
+  [ Alejandro J. Cura <[e-mail]> ]
+    * Call the dbus mainloop thread init (fixes LP: #656545).
+
+  * Adding .bzr-builddeb/default.conf as per Michael Vog (mvo) request.
+
+  * Adding dpkg (>= 1.15.7.2) as Pre-Depends (fixes LP: #658768).
+
+  * Adding gnome-keyring as dep since python-gnomekeyring doesn't install it.
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Tue, 12 Oct 2010 10:07:55 -0300
+
 ubuntu-sso-client (1.0.3-0ubuntu1) maverick; urgency=low
 
   * New upstream release:

=== modified file 'debian/control'
--- debian/control	2010-09-13 15:02:42 +0000
+++ debian/control	2011-04-12 19:01:16 +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 'debian/watch'
--- debian/watch	2010-09-22 18:53:18 +0000
+++ debian/watch	2011-04-12 19:01:16 +0000
@@ -1,3 +1,3 @@
 version=3
-http://launchpad.net/ubuntu-sso-client/+download?start=10  .*/ubuntu-sso-client-([0-9.]+)\.tar\.gz
+http://launchpad.net/ubuntu-sso-client/+download?start=20  .*/ubuntu-sso-client-([0-9.]+)\.tar\.gz
 

=== modified file 'run-tests'
--- run-tests	2010-09-08 19:25:02 +0000
+++ run-tests	2011-04-12 19:01:16 +0000
@@ -16,7 +16,7 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 `which xvfb-run` ./contrib/test "$@"
-pylint contrib ubuntu_sso
+pylint ubuntu_sso
 if [ -x `which pep8` ]; then
     pep8 --repeat bin/ contrib/ ubuntu_sso/
 else

=== modified file 'setup.py'
--- setup.py	2010-10-01 14:57:22 +0000
+++ setup.py	2011-04-12 19:01:16 +0000
@@ -36,7 +36,8 @@
 from distutils.command import clean, build
 
 # Defining variables for various rules here, similar to a Makefile.am
-CLEANFILES = ['data/com.ubuntu.sso.service']
+CLEANFILES = ['data/com.ubuntu.sso.service', 'po/ubuntu-sso-client.pot',
+              'MANIFEST']
 
 
 # XXX: This needs some serious cleanup
@@ -86,7 +87,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='1.0.3',
+    version='1.0.9',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-10-01 14:57:22 +0000
+++ ubuntu_sso/gui.py	2011-04-12 19:01:16 +0000
@@ -28,7 +28,7 @@
 import dbus
 import gettext
 import gobject
-import gtk
+import gtk  # pylint: disable=W0403
 import webkit
 import xdg
 
@@ -125,7 +125,7 @@
         self.is_password = is_password
         self.warning = None
 
-        super(LabeledEntry, self).__init__(*args, **kwargs)
+        gtk.Entry.__init__(self, *args, **kwargs)
 
         self.set_width_chars(DEFAULT_WIDTH)
         self._set_label(self, None)
@@ -161,7 +161,7 @@
 
     def get_text(self):
         """Get text only if it's not the label nor empty."""
-        result = super(LabeledEntry, self).get_text()
+        result = gtk.Entry.get_text(self)
         if result == self.label or result.isspace():
             result = ''
         return result
@@ -252,6 +252,8 @@
         self.tc_uri = tc_uri
         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()
@@ -319,13 +321,13 @@
         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:
@@ -357,6 +359,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,8 +387,6 @@
                 msg = 'UbuntuSSOClientGUI: failed set_transient_for win id %r'
                 logger.exception(msg, window_id)
 
-        # Hidding unused widgets to save some space (LP #627440).
-        self.name_entry.hide()
         self.yes_to_updates_checkbutton.hide()
 
         self.window.show()
@@ -417,8 +419,8 @@
 
             match = self.bus.add_signal_receiver(method, signal_name=signal,
                                                  dbus_interface=iface)
-            logger.info('Connecting signal %r with method %r at iface %r.' \
-                        'Match: %r', signal, method, iface, match)
+            logger.debug('Connecting signal %r with method %r at iface %r.' \
+                         'Match: %r', signal, method, iface, match)
             self._signals_receivers[(iface, signal)] = method
 
     def _debug(self, *args, **kwargs):
@@ -725,8 +727,8 @@
         remove = self.bus.remove_signal_receiver
         for (iface, signal) in self._signals_receivers.keys():
             method = self._signals_receivers.pop((iface, signal))
-            logger.info('Removing signal %r with method %r at iface %r.',
-                        signal, method, iface)
+            logger.debug('Removing signal %r with method %r at iface %r.',
+                         signal, method, iface)
             remove(method, signal_name=signal, dbus_interface=iface)
 
         # hide the main window
@@ -765,11 +767,10 @@
 
         error = False
 
-        # Hidding unused widgets to save some space (LP #627440).
-        #name = self.name_entry.get_text()
-        #if not name:
-        #    self.name_entry.set_warning(self.FIELD_REQUIRED)
-        #    error = True
+        name = self.name_entry.get_text()
+        if not name:
+            self.name_entry.set_warning(self.FIELD_REQUIRED)
+            error = True
 
         # check email
         email1 = self.email1_entry.get_text()
@@ -804,12 +805,15 @@
             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,
-                    self._captcha_id, captcha_solution)
-        f = self.backend.register_user
-        f(self.app_name, email1, password1, self._captcha_id, captcha_solution,
+        logger.info('Calling register_with_name with email %r, password, '
+                    '<hidden> name %r, captcha_id %r and captcha_solution %r.',
+                    email1, name, self._captcha_id, captcha_solution)
+        f = self.backend.register_with_name
+        f(self.app_name, email1, password1, name,
+          self._captcha_id, captcha_solution,
           reply_handler=NO_OP, error_handler=NO_OP)
 
     def on_tc_button_clicked(self, *args, **kwargs):
@@ -832,8 +836,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,
@@ -871,6 +875,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."""
@@ -1061,6 +1067,11 @@
                                      msg))
 
     @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):
         """Password reset token was successfully sent."""
         msg = self.SET_NEW_PASSWORD_LABEL % {'email': email}

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-09-14 19:28:09 +0000
+++ ubuntu_sso/main.py	2011-04-12 19:01:16 +0000
@@ -55,6 +55,7 @@
 logger = setup_logging("ubuntu_sso.main")
 PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
 SERVICE_URL = "https://login.ubuntu.com/api/1.0"
+NO_OP = lambda *args, **kwargs: None
 
 
 class NoDefaultConfigError(Exception):
@@ -96,10 +97,16 @@
     """The new password could not be set."""
 
 
-def keyring_store_credentials(app_name, credentials):
+def keyring_store_credentials(app_name, credentials, callback, *cb_args):
     """Store the credentials in the keyring."""
-    logger.info('keyring_store_credentials: app_name "%s".', app_name)
-    Keyring(app_name).set_ubuntusso_attr(credentials)
+
+    def _inner():
+        """Store the credentials, and trigger the callback."""
+        logger.info('keyring_store_credentials: app_name "%s".', app_name)
+        Keyring(app_name).set_ubuntusso_attr(credentials)
+        callback(*cb_args)
+
+    gobject.idle_add(_inner)
 
 
 def keyring_get_credentials(app_name):
@@ -164,24 +171,27 @@
 
         return captcha['captcha_id']
 
-    def register_user(self, email, password, captcha_id, captcha_solution):
+    def register_with_name(self, email, password, displayname,
+                      captcha_id, captcha_solution):
         """Register a new user with 'email' and 'password'."""
-        logger.debug('register_user: email: %r password: <hidden>, '
-                     'captcha_id: %r, captcha_solution: %r',
-                     email, captcha_id, captcha_solution)
+        logger.debug('register_with_name: email: %r password: <hidden>, '
+                     'displayname: %r, captcha_id: %r, captcha_solution: %r',
+                     email, displayname, captcha_id, captcha_solution)
         sso_service = self.sso_service_class(None, self.service_url)
         if not self._valid_email(email):
-            logger.error('register_user: InvalidEmailError for email: %r',
+            logger.error('register_with_name: InvalidEmailError for email: %r',
                          email)
             raise InvalidEmailError()
         if not self._valid_password(password):
-            logger.error('register_user: InvalidPasswordError')
+            logger.error('register_with_name: InvalidPasswordError')
             raise InvalidPasswordError()
 
         result = sso_service.registrations.register(
-                    email=email, password=password, captcha_id=captcha_id,
+                    email=email, password=password,
+                    displayname=displayname,
+                    captcha_id=captcha_id,
                     captcha_solution=captcha_solution)
-        logger.info('register_user: email: %r result: %r', email, result)
+        logger.info('register_with_name: email: %r result: %r', email, result)
 
         if result['status'] == 'error':
             errorsdict = self._format_webservice_errors(result['errors'])
@@ -191,6 +201,17 @@
         else:
             return email
 
+    def register_user(self, email, password,
+                      captcha_id, captcha_solution):
+        """Register a new user with 'email' and 'password'."""
+        logger.debug('register_user: email: %r password: <hidden>, '
+                     'captcha_id: %r, captcha_solution: %r',
+                     email, captcha_id, captcha_solution)
+        res = self.register_with_name(email, password, displayname='',
+                                      captcha_id=captcha_id,
+                                      captcha_solution=captcha_solution)
+        return res
+
     def login(self, email, password, token_name):
         """Login a user with 'email' and 'password'."""
         logger.debug('login: email: %r password: <hidden>, token_name: %r',
@@ -209,6 +230,25 @@
                      'token_name: %r', credentials['consumer_key'], token_name)
         return credentials
 
+    def is_validated(self, token, sso_service=None):
+        """Return if user with 'email' and 'password' is validated."""
+        logger.debug('is_validated: requesting accounts.me() info.')
+        if sso_service is None:
+            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.info('is_validated: consumer_key: %r, result: %r.',
+                    token['consumer_key'], 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>, '
@@ -311,12 +351,8 @@
         dbus.service.Object.__init__(self, object_path="/sso",
                                      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")
@@ -337,7 +373,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)
 
@@ -361,8 +397,19 @@
         """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)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssssss')
+    def register_with_name(self, app_name, email, password, name,
+                           captcha_id, captcha_solution):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.register_with_name(email, password, name,
+                                                captcha_id, captcha_solution)
         blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
 
     # login signals
@@ -378,6 +425,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):
@@ -387,13 +440,21 @@
             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)
-            assert 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."""
+            is_validated = self.processor.is_validated(credentials)
+            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")
@@ -415,11 +476,16 @@
         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)
-            keyring_store_credentials(app_name, credentials)
-            return email
-        blocking(f, app_name, self.EmailValidated, self.EmailValidationError)
+            credentials = self.processor.validate_email(email, password,
+                                                      email_token, token_name)
+
+            def _email_stored():
+                """The email was stored, so call the signal."""
+                self.EmailValidated(app_name, email)
+
+            keyring_store_credentials(app_name, credentials, _email_stored)
+
+        blocking(f, app_name, NO_OP, self.EmailValidationError)
 
     # request_password_reset_token signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -440,7 +506,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)
 
@@ -463,8 +529,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)
 
 
@@ -481,19 +547,19 @@
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
     def AuthorizationDenied(self, app_name):
         """Signal thrown when the user denies the authorization."""
-        logger.info('SSOLogin: emitting AuthorizationDenied with app_name '
-                    '"%s"', app_name)
+        logger.info('SSOCredentials: emitting AuthorizationDenied with '
+                    'app_name "%s"', app_name)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sa{ss}")
     def CredentialsFound(self, app_name, credentials):
         """Signal thrown when the credentials are found."""
-        logger.info('SSOLogin: emitting CredentialsFound with app_name "%s"',
-                    app_name)
+        logger.info('SSOCredentials: emitting CredentialsFound with '
+                    'app_name "%s"', app_name)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sss")
     def CredentialsError(self, app_name, error_message, detailed_error):
         """Signal thrown when there is a problem finding the credentials."""
-        logger.debug('SSOCredentials: emitting CredentialsError with app_name '
+        logger.error('SSOCredentials: emitting CredentialsError with app_name '
                      '"%s" and error_message %r', app_name, error_message)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
@@ -510,7 +576,8 @@
 
     def _login_success_cb(self, dialog, app_name, email):
         """Handles the response from the UI dialog."""
-        logger.info('Login successful for app %r, email %r', app_name, email)
+        logger.info('Login successful for app %r, email %r. Still pending to '
+                    'ping server and send result signal.', app_name, email)
         try:
             creds = keyring_get_credentials(app_name)
             self._ping_url(app_name, email, creds)
@@ -518,6 +585,7 @@
         except:  # pylint: disable=W0702
             msg = "Problem getting the credentials from the keyring."
             logger.exception(msg)
+            self.clear_token(app_name)
             self.CredentialsError(app_name, msg, traceback.format_exc())
 
     def _login_error_cb(self, dialog, app_name, error):
@@ -639,6 +707,7 @@
 
         'app_name' is the name of the application.
         """
+        logger.info('Clearing credentials for app %r.', app_name)
         try:
             creds = Keyring(app_name)
             creds.delete_ubuntusso_attr()

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/tests/test_gui.py	2011-04-12 19:01:16 +0000
@@ -63,7 +63,7 @@
         self._args = args
         self._kwargs = kwargs
         self._called = {}
-        for i in ('generate_captcha', 'login', 'register_user',
+        for i in ('generate_captcha', 'login', 'register_with_name',
                   'validate_email', 'request_password_reset_token',
                   'set_new_password'):
             setattr(self, i, self._record_call(i))
@@ -674,11 +674,11 @@
         """Clicking 'join_ok_button' sends info to backend using 'register'."""
         self.click_join_with_valid_data()
 
-        # assert register_user was called
-        expected = 'register_user'
+        # assert register_with_name was called
+        expected = 'register_with_name'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
+                         ((APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
                            CAPTCHA_SOLUTION),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
@@ -856,6 +856,12 @@
         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)
+
 
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (with no t&c link)."""
@@ -1005,6 +1011,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()
@@ -1079,7 +1096,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."""
@@ -1114,6 +1131,20 @@
         self.assert_warnings_visibility()
 
 
+class VerifyEmailLoginOnlyTestCase(VerifyEmailTestCase):
+    """Test suite for the user login (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_uri=TC_URI, 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_uri=TC_URI, help_text=HELP_TEXT,
+                  login_only=True)
+
+
 class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration  validations."""
 
@@ -1130,12 +1161,7 @@
 
         self.assert_correct_entry_warning(self.ui.name_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    # Unused variable 'skip'
-    # pylint: disable=W0612
-    test_warning_is_shown_if_name_empty.skip = \
-        'Unused for now, will be hidden to save space (LP: #627440).'
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_empty_email(self):
         """A warning message is shown if emails are empty."""
@@ -1148,7 +1174,7 @@
                                           self.ui.FIELD_REQUIRED)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_email_mismatch(self):
         """A warning message is shown if emails doesn't match."""
@@ -1161,7 +1187,7 @@
                                           self.ui.EMAIL_MISMATCH)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.EMAIL_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_invalid_email(self):
         """A warning message is shown if email is invalid."""
@@ -1174,7 +1200,7 @@
                                           self.ui.EMAIL_INVALID)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.EMAIL_INVALID)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_password_help_is_always_shown(self):
         """Password help text is correctly displayed."""
@@ -1182,7 +1208,7 @@
                         'password help text is visible.')
         self.assertEqual(self.ui.password_help_label.get_text(),
                          self.ui.PASSWORD_HELP)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_password_mismatch(self):
         """A warning message is shown if password doesn't match."""
@@ -1195,7 +1221,7 @@
                                           self.ui.PASSWORD_MISMATCH)
         self.assert_correct_entry_warning(self.ui.password2_entry,
                                           self.ui.PASSWORD_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_password_too_weak(self):
         """A warning message is shown if password is too weak."""
@@ -1210,7 +1236,7 @@
                                               self.ui.PASSWORD_TOO_WEAK)
             self.assert_correct_entry_warning(self.ui.password2_entry,
                                               self.ui.PASSWORD_TOO_WEAK)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_tc_not_accepted(self):
         """A warning message is shown if TC are not accepted."""
@@ -1221,7 +1247,7 @@
 
         self.assert_correct_label_warning(self.ui.tc_warning_label,
                                           self.ui.TC_NOT_ACCEPTED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_not_captcha_solution(self):
         """A warning message is shown if TC are not accepted."""
@@ -1232,7 +1258,7 @@
 
         self.assert_correct_entry_warning(self.ui.captcha_solution_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_no_warning_messages_if_valid_data(self):
         """No warning messages are shown if the data is valid."""
@@ -1328,6 +1354,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()
@@ -1377,6 +1409,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."""
@@ -1782,7 +1820,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'):
@@ -1864,6 +1902,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)

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/tests/test_main.py	2011-04-12 19:01:16 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # test_main - tests for ubuntu_sso.main
 #
 # Author: Natalia Bidart <[e-mail]>
@@ -63,6 +65,7 @@
 EMAIL_ALREADY_REGISTERED = '[e-mail]'
 EMAIL_TOKEN = 'B2Pgtf'
 HELP = 'help text'
+NAME = 'Juanito Pérez'
 PASSWORD = 'be4tiFul'
 RESET_PASSWORD_TOKEN = '8G5Wtq'
 TOKEN = {u'consumer_key': u'xQ7xDAz',
@@ -107,7 +110,8 @@
 class FakedRegistrations(object):
     """Fake the registrations service."""
 
-    def register(self, email, password, captcha_id, captcha_solution):
+    def register(self, email, password, displayname,
+                 captcha_id, captcha_solution):
         """Fake registration. Return a fix result."""
         if email == EMAIL_ALREADY_REGISTERED:
             return {'status': 'error',
@@ -152,6 +156,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:
@@ -164,6 +171,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."""
@@ -279,6 +297,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(token=TOKEN)
+        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,
+                                             token=TOKEN)
+        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,
+                                             token=TOKEN)
+        self.assertFalse(result, 'user must not be validated.')
+
     # validate_email
 
     def test_validate_email_if_status_ok(self):
@@ -362,6 +403,16 @@
         self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
 
 
+class SSORegistrationWithNameTestCase(SSOLoginProcessorTestCase):
+    """Test suite for the SSO login processor for register_with_name."""
+
+    def setUp(self):
+        """Init."""
+        super(SSORegistrationWithNameTestCase, self).setUp()
+        self.register_kwargs['displayname'] = NAME
+        self.processor.register_user = self.processor.register_with_name
+
+
 class BlockingSampleException(Exception):
     """The exception that will be thrown by the fake blocking."""
 
@@ -380,12 +431,13 @@
         mockbus._register_object_path(ARGS)
         self.mockprocessorclass = None
 
-        def ksc(k, val):
+        def ksc(k, val, callback, *cb_args):
             """Assert over token and app_name."""
             self.assertEqual(k, APP_NAME)
             self.assertEqual(val, TOKEN)
             self.keyring_was_set = True
             self.keyring_values = k, val
+            callback(*cb_args)
 
         self.patch(ubuntu_sso.main, "keyring_store_credentials", ksc)
         self.keyring_was_set = False
@@ -472,8 +524,8 @@
         """Test that the register_user method works ok."""
         d = Deferred()
         expected_result = "expected result"
-        self.create_mock_processor().register_user(EMAIL, PASSWORD, CAPTCHA_ID,
-                                                   CAPTCHA_SOLUTION)
+        self.create_mock_processor().register_user(EMAIL, PASSWORD,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
@@ -496,8 +548,8 @@
         """Test that the register_user method fails as expected."""
         d = Deferred()
         expected_result = "expected result"
-        self.create_mock_processor().register_user(EMAIL, PASSWORD, CAPTCHA_ID,
-                                                   CAPTCHA_SOLUTION)
+        self.create_mock_processor().register_user(EMAIL, PASSWORD,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
@@ -516,11 +568,62 @@
                              CAPTCHA_SOLUTION)
         return d
 
+    def test_register_with_name(self):
+        """Test that the register_with_name method works ok."""
+        d = Deferred()
+        expected_result = "expected result"
+        self.create_mock_processor().register_with_name(EMAIL, PASSWORD, NAME,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", verify)
+        self.patch(client, "UserRegistrationError", d.errback)
+        client.register_with_name(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
+    def test_register_with_name_error(self):
+        """Test that the register_with_name method fails as expected."""
+        d = Deferred()
+        expected_result = "expected result"
+        self.create_mock_processor().register_with_name(EMAIL, PASSWORD, NAME,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", d.errback)
+        self.patch(client, "UserRegistrationError", verify)
+        client.register_with_name(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
     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(TOKEN)
+        self.mocker.result(True)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
@@ -535,13 +638,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(TOKEN)
+        self.mocker.result(False)
+        self.patch(ubuntu_sso.main, "blocking", self.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", self.fake_err_blocking)
 
         def fake_gtn(*args):
@@ -562,6 +692,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
 
@@ -591,7 +722,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", self.fake_err_blocking)
 
         def fake_gtn(*args):
@@ -802,7 +933,7 @@
         self.assertEqual(result["errtype"], e.__class__.__name__)
 
 
-class KeyringCredentialsTestCase(MockerTestCase):
+class KeyringCredentialsTestCase(TestCase, MockerTestCase):
     """Check the functions that access the keyring."""
 
     # Invalid name (should match ([a-z_][a-z0-9_]*|[A-Z_][A-Z0-9_]*)$)
@@ -810,15 +941,19 @@
 
     def test_keyring_store_cred(self):
         """Verify the method that stores credentials."""
+        idle_add = lambda f, *args, **kwargs: f(*args, **kwargs)
+        self.patch(gobject, "idle_add", idle_add)
         token_value = TOKEN
         mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
         mockKeyringClass(APP_NAME)
         mockKeyring = self.mocker.mock()
+        callback = self.mocker.mock()
         self.mocker.result(mockKeyring)
         mockKeyring.set_ubuntusso_attr(token_value)
+        callback(1, 2, 3)
         self.mocker.replay()
 
-        keyring_store_credentials(APP_NAME, token_value)
+        keyring_store_credentials(APP_NAME, token_value, callback, 1, 2, 3)
 
     def test_keyring_get_cred(self):
         """The method returns the right token."""
@@ -1367,6 +1502,24 @@
         self.assertEqual(self.calls[0][0], 'CredentialsError')
         self.assertEqual(self.calls[0][1][0], APP_NAME)
 
+    def test_credentials_are_not_stored_if_ping_failed(self):
+        """Credentials are not stored if the ping fails."""
+
+        def fail(*args, **kwargs):
+            """Raise an exception."""
+            self.args = AssertionError((args, kwargs))
+            # pylint: disable=E0702
+            raise self.args
+
+        self.patch(self.client, '_ping_url', fail)
+        self._patch('clear_token')
+
+        self.client._login_success_cb(None, APP_NAME, EMAIL)
+
+        self.assertEqual(len(self.calls), 1)
+        self.assertEqual(self.calls[0][0], 'clear_token')
+        self.assertEqual(self.calls[0][1][0], APP_NAME)
+
 
 class EnvironOverridesTestCase(TestCase):
     """Some URLs can be set from the environment for testing/QA purposes."""