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

[Natalia Bidart]

High priority bug fixes after UI freeze (v0.99.4).

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-08-26 01:07:41 +0000
+++ PKG-INFO	2010-08-27 22:32:43 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 0.99.3
+Version: 0.99.4
 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-08-26 01:07:41 +0000
+++ data/ui.glade	2010-08-27 22:32:43 +0000
@@ -60,6 +60,12 @@
     <property name="visible">True</property>
     <property name="spacing">10</property>
     <child>
+      <placeholder/>
+    </child>
+    <child>
+      <placeholder/>
+    </child>
+    <child>
       <object class="GtkHBox" id="emails_hbox">
         <property name="visible">True</property>
         <property name="spacing">5</property>
@@ -77,9 +83,6 @@
       </packing>
     </child>
     <child>
-      <placeholder/>
-    </child>
-    <child>
       <object class="GtkHBox" id="passwords_hbox">
         <property name="visible">True</property>
         <property name="spacing">5</property>
@@ -107,9 +110,6 @@
       </packing>
     </child>
     <child>
-      <placeholder/>
-    </child>
-    <child>
       <object class="GtkHBox" id="hbox1">
         <property name="visible">True</property>
         <child>
@@ -585,27 +585,43 @@
     <property name="visible">True</property>
     <property name="spacing">10</property>
     <child>
-      <object class="GtkAlignment" id="alignment1">
+      <object class="GtkVBox" id="vbox2">
         <property name="visible">True</property>
-        <property name="xscale">0</property>
-        <property name="yscale">0</property>
-        <child>
-          <object class="GtkVBox" id="set_new_password_details_vbox">
-            <property name="visible">True</property>
-            <property name="spacing">5</property>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
+        <child>
+          <object class="GtkAlignment" id="alignment1">
+            <property name="visible">True</property>
+            <property name="xscale">0</property>
+            <property name="yscale">0</property>
+            <child>
+              <object class="GtkVBox" id="set_new_password_details_vbox">
+                <property name="visible">True</property>
+                <property name="spacing">5</property>
+                <child>
+                  <placeholder/>
+                </child>
+                <child>
+                  <placeholder/>
+                </child>
+                <child>
+                  <placeholder/>
+                </child>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="reset_password_help_label">
+            <property name="visible">True</property>
+            <property name="label" translatable="yes">label</property>
+            <property name="wrap">True</property>
           </object>
         </child>
       </object>
       <packing>
+        <property name="padding">5</property>
         <property name="position">0</property>
       </packing>
     </child>

=== modified file 'debian/changelog'
--- debian/changelog	2010-08-26 13:05:03 +0000
+++ debian/changelog	2010-08-27 22:32:43 +0000
@@ -1,3 +1,46 @@
+ubuntu-sso-client (0.99.4-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release:
+
+  [ [e-mail] ]
+    * Validate form data for verify token page, request password token and set
+    new password (LP: #625361).
+    * Validate password strength on reset password page (LP: #616528).
+    * Labels are not as wide as the parent windowm but a little bit less wide
+    (LP: #625009).
+
+  [ Alejandro J. Cura <[e-mail]> ]
+    * Store the credentials after the email validation step (LP: #625003)
+
+  [ [e-mail]
+    * Every form can be submitted by activating the buttons and/or the entries
+    (LP: #616421).
+
+  [ David Planella <[e-mail]> ]
+    * Make setup.py actually use python-distutils-extra, which will allow the
+    .deb package to build the POT file required to import translations into
+    Launchpad (LP: #624891).
+
+  [ [e-mail] ]
+    * Errors from SSO servers are being shown now to users, matching
+    error-specific to fields (LP: #616101).
+    * Also, be robust when SSO server answer with a string where it's supposed
+    to be a list (LP: #623447).
+
+  [ Alejandro J. Cura <[e-mail]> ]
+    * Use the keyring unlocking gnomekeyring APIs (LP: #623622)
+    * Search all keyrings for the credentials (LP: #624033)
+
+  [ [e-mail] ]
+    * Customize "help_text" for the login only dialog (LP: #624097).
+    * Label areas are as wide as the parent window (LP: #616551).
+
+  [ Alejandro J. Cura <[e-mail]> ]
+    * The list of error strings as returned by the SSO webservice can't go thru
+    DBus (LP: #624358).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Fri, 27 Aug 2010 19:16:55 -0300
+
 ubuntu-sso-client (0.99.3-0ubuntu1) maverick; urgency=low
 
   * New upstream release:

=== modified file 'setup.py'
--- setup.py	2010-08-26 01:07:41 +0000
+++ setup.py	2010-08-27 22:32:43 +0000
@@ -21,6 +21,7 @@
 
 try:
     import DistUtilsExtra.auto
+    from DistUtilsExtra.command import build_extra
 except ImportError:
     print >> sys.stderr, 'To build this program you need '\
                          'https://launchpad.net/python-distutils-extra'
@@ -36,7 +37,7 @@
 CLEANFILES = ['data/com.ubuntu.sso.service']
 
 # XXX: This needs some serious cleanup
-class SSOBuild(build.build):
+class SSOBuild(build_extra.build_extra):
     """Class to build the extra files."""
 
     description = 'build extra files needed by ubuntu-sso-client'
@@ -61,7 +62,7 @@
                   )
 
         # Run the parent build command
-        build.build.run(self)
+        build_extra.build_extra.run(self)
 
 
 class SSOClean(clean.clean):
@@ -81,7 +82,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='0.99.3',
+    version='0.99.4',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-08-26 01:07:41 +0000
+++ ubuntu_sso/gui.py	2010-08-27 22:32:43 +0000
@@ -168,6 +168,7 @@
         self.warning = warning_msg
         self.set_property('secondary-icon-stock', gtk.STOCK_DIALOG_WARNING)
         self.set_property('secondary-icon-sensitive', True)
+        self.set_property('secondary-icon-activatable', False)
         self.set_property('secondary-icon-tooltip-text', warning_msg)
 
     def clear_warning(self):
@@ -175,6 +176,7 @@
         self.warning = None
         self.set_property('secondary-icon-stock', None)
         self.set_property('secondary-icon-sensitive', False)
+        self.set_property('secondary-icon-activatable', False)
         self.set_property('secondary-icon-tooltip-text', None)
 
 
@@ -253,12 +255,10 @@
         builder.add_from_file(ui_filename)
         builder.connect_signals(self)
 
-        # XXX: every button should have tests for 'activate' signal
-        # see LP: #616421
-
         self.widgets = []
         self.warnings = []
         self.cancels = []
+        self.labels = []
         for obj in builder.get_objects():
             name = getattr(obj, 'name', None)
             if name is None and isinstance(obj, gtk.Buildable):
@@ -275,6 +275,10 @@
                 if 'cancel_button' in name:
                     obj.connect('clicked', self.on_close_clicked)
                     self.cancels.append(obj)
+                if '_button' in name:
+                    obj.connect('activate', lambda w: w.clicked())
+                if 'label' in name:
+                    self.labels.append(obj)
 
         self.entries = ('name_entry', 'email1_entry', 'email2_entry',
                         'password1_entry', 'password2_entry',
@@ -292,7 +296,6 @@
             assert getattr(self, name) is not None
 
         self.window.set_icon_name('ubuntu-logo')
-        self.captcha_reload_button.set_tooltip_text(self.CAPTCHA_RELOAD_TOOLTIP)
 
         self.bus = dbus.SessionBus()
         self.bus.add_signal_receiver = self._log(self.bus.add_signal_receiver)
@@ -316,17 +319,26 @@
         self._append_page(self._build_request_password_token_page())
         self._append_page(self._build_set_new_password_page())
 
+        window_size = None
         if not login_only:
+            window_size = (550, 600)
             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:
+            window_size = (400, 350)
             self.login_back_button.hide()
             self.login_ok_button.grab_focus()
+            self.login_vbox.help_text = help_text
             self._set_current_page(self.login_vbox)
 
+        self.window.set_size_request(*window_size)
+        size_req = (int(window_size[0] * 0.9), -1)
+        for label in self.labels:
+            label.set_size_request(*size_req)
+
         self._setup_signals()
         self._gtk_signal_log = []
 
@@ -487,16 +499,17 @@
 
         self.enter_details_vbox.pack_start(self.name_entry, expand=False)
         self.enter_details_vbox.reorder_child(self.name_entry, 0)
-        self.captcha_solution_vbox.pack_start(self.captcha_solution_entry,
-                                              expand=False)
-        self.captcha_solution_vbox.reorder_child(self.captcha_solution_entry,
-                                                 0)
-
-        self.emails_hbox.pack_start(self.email1_entry)
-        self.emails_hbox.pack_start(self.email2_entry)
-
-        self.passwords_hbox.pack_start(self.password1_entry)
-        self.passwords_hbox.pack_start(self.password2_entry)
+        entry = self.captcha_solution_entry
+        self.captcha_solution_vbox.pack_start(entry, expand=False)
+        self.captcha_solution_vbox.reorder_child(entry, 0)
+        msg = self.CAPTCHA_RELOAD_TOOLTIP
+        self.captcha_reload_button.set_tooltip_text(msg)
+
+        self.emails_hbox.pack_start(self.email1_entry, expand=False)
+        self.emails_hbox.pack_start(self.email2_entry, expand=False)
+
+        self.passwords_hbox.pack_start(self.password1_entry, expand=False)
+        self.passwords_hbox.pack_start(self.password2_entry, expand=False)
         help_msg = '<small>%s</small>' % self.PASSWORD_HELP
         self.password_help_label.set_markup(help_msg)
 
@@ -515,6 +528,11 @@
             self.tc_hbox.hide_all()
         self.login_button.set_label(self.LOGIN_BUTTON_LABEL)
 
+        for entry in (self.name_entry, self.email1_entry, self.email2_entry,
+                      self.password1_entry, self.password2_entry,
+                      self.captcha_solution_entry):
+            entry.connect('activate', lambda w: self.join_ok_button.clicked())
+
         return self.enter_details_vbox
 
     def _build_tc_page(self):
@@ -530,6 +548,8 @@
 
     def _build_verify_email_page(self):
         """Build the verify email page."""
+        cb = lambda w: self.verify_token_button.clicked()
+        self.email_token_entry.connect('activate', cb)
         self.verify_email_vbox.pack_start(self.email_token_entry, expand=False)
         self.verify_email_vbox.reorder_child(self.email_token_entry, 0)
 
@@ -537,7 +557,6 @@
 
     def _build_success_page(self):
         """Build the success page."""
-        #self.success_vbox.help_text = ''
         self.success_label.set_markup('<span size="x-large">%s</span>' %
                                       self.SUCCESS)
         return self.success_vbox
@@ -557,6 +576,9 @@
         self.forgotten_password_button.set_label(msg)
         self.login_ok_button.grab_focus()
 
+        for entry in (self.login_email_entry, self.login_password_entry):
+            entry.connect('activate', lambda w: self.login_ok_button.clicked())
+
         return self.login_vbox
 
     def _build_request_password_token_page(self):
@@ -566,12 +588,16 @@
         self.request_password_token_vbox.help_text = text
 
         entry = self.reset_email_entry
-        self.request_password_token_details_vbox.pack_start(entry)
+        self.request_password_token_details_vbox.pack_start(entry,
+                                                            expand=False)
         cb = self.on_reset_email_entry_changed
         self.reset_email_entry.connect('changed', cb)
         self.request_password_token_ok_button.set_label(self.NEXT)
         self.request_password_token_ok_button.set_sensitive(False)
 
+        cb = lambda w: self.request_password_token_ok_button.clicked()
+        self.reset_email_entry.connect('activate', cb)
+
         return self.request_password_token_vbox
 
     def _build_set_new_password_page(self):
@@ -579,21 +605,52 @@
         self.set_new_password_vbox.header = self.RESET_PASSWORD
         self.set_new_password_vbox.help_text = self.SET_NEW_PASSWORD_LABEL
 
+        cb = lambda w: self.set_new_password_ok_button.clicked()
         for entry in (self.reset_code_entry,
                       self.reset_password1_entry,
                       self.reset_password2_entry):
-            self.set_new_password_details_vbox.pack_start(entry)
+            self.set_new_password_details_vbox.pack_start(entry, expand=False)
+            entry.connect('activate', cb)
 
         cb = self.on_set_new_password_entries_changed
         self.reset_code_entry.connect('changed', cb)
         self.reset_password1_entry.connect('changed', cb)
         self.reset_password2_entry.connect('changed', cb)
+        help_msg = '<small>%s</small>' % self.PASSWORD_HELP
+        self.reset_password_help_label.set_markup(help_msg)
 
         self.set_new_password_ok_button.set_label(self.RESET_PASSWORD)
         self.set_new_password_ok_button.set_sensitive(False)
 
         return self.set_new_password_vbox
 
+    def _validate_email(self, email1, email2=None):
+        """Validate 'email1', return error message if not valid.
+
+        If 'email2' is given, must match 'email1'.
+        """
+        if email2 is not None and email1 != email2:
+            return self.EMAIL_MISMATCH
+
+        if not email1:
+            return self.FIELD_REQUIRED
+
+        if '@' not in email1:
+            return self.EMAIL_INVALID
+
+    def _validate_password(self, password1, password2=None):
+        """Validate 'password1', return error message if not valid.
+
+        If 'password2' is given, must match 'email1'.
+        """
+        if password2 is not None and password1 != password2:
+            return self.PASSWORD_MISMATCH
+
+        if (len(password1) < 8 or
+            re.search('[A-Z]', password1) is None or
+            re.search('\d+', password1) is None):
+            return self.PASSWORD_TOO_WEAK
+
     # GTK callbacks
 
     def run(self):
@@ -640,6 +697,9 @@
 
     def on_join_ok_button_clicked(self, *args, **kwargs):
         """Submit info for processing, present the processing vbox."""
+        if not self.join_ok_button.is_sensitive():
+            return
+
         self._clear_warnings()
 
         error = False
@@ -647,56 +707,40 @@
         name = self.name_entry.get_text()
         if not name:
             self.name_entry.set_warning(self.FIELD_REQUIRED)
-            error |= True
+            error = True
 
         # check email
         email1 = self.email1_entry.get_text()
         email2 = self.email2_entry.get_text()
-        if email1 != email2:
-            self.email1_entry.set_warning(self.EMAIL_MISMATCH)
-            self.email2_entry.set_warning(self.EMAIL_MISMATCH)
-            error |= True
-
-        if '@' not in email1:
-            self.email1_entry.set_warning(self.EMAIL_INVALID)
-            self.email2_entry.set_warning(self.EMAIL_INVALID)
-            error |= True
-
-        if not email1:
-            self.email1_entry.set_warning(self.FIELD_REQUIRED)
-            self.email2_entry.set_warning(self.FIELD_REQUIRED)
-            error |= True
+        msg = self._validate_email(email1, email2)
+        if msg is not None:
+            self.email1_entry.set_warning(msg)
+            self.email2_entry.set_warning(msg)
+            error = True
 
         # check password
         password1 = self.password1_entry.get_text()
         password2 = self.password2_entry.get_text()
-        if password1 != password2:
-            self.password1_entry.set_warning(self.PASSWORD_MISMATCH)
-            self.password2_entry.set_warning(self.PASSWORD_MISMATCH)
-            error |= True
-
-        if (len(password1) < 8 or
-            re.search('[A-Z]', password1) is None or
-            re.search('\d+', password1) is None):
-            self.password1_entry.set_warning(self.PASSWORD_TOO_WEAK)
-            self.password2_entry.set_warning(self.PASSWORD_TOO_WEAK)
-            error |= True
+        msg = self._validate_password(password1, password2)
+        if msg is not None:
+            self.password1_entry.set_warning(msg)
+            self.password2_entry.set_warning(msg)
+            error = True
 
         # check T&C
         if not self.yes_to_tc_checkbutton.get_active():
             self._set_warning_message(self.tc_warning_label,
                                       self.TC_NOT_ACCEPTED)
-            error |= True
+            error = True
 
         captcha_solution = self.captcha_solution_entry.get_text()
         if not captcha_solution:
             self.captcha_solution_entry.set_warning(self.FIELD_REQUIRED)
-            error |= True
+            error = True
 
         if error:
             return
 
-        self._clear_warnings()
         self._set_current_page(self.processing_vbox)
 
         logger.info('Calling register_user with email %r, password <hidden>,' \
@@ -716,14 +760,22 @@
 
     def on_verify_token_button_clicked(self, *args, **kwargs):
         """The user entered the email token, let's verify!"""
+        if not self.verify_token_button.is_sensitive():
+            return
+
+        self._clear_warnings()
+
+        email_token = self.email_token_entry.get_text()
+        if not email_token:
+            self.email_token_entry.set_warning(self.FIELD_REQUIRED)
+            return
+
         email = self.email1_entry.get_text()
         password = self.password1_entry.get_text()
-        email_token = self.email_token_entry.get_text()
-
+        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, email_token)
-        f = self.backend.validate_email
+                    ', app_name %r and email_token %r.', email, self.app_name,
+                    email_token)
         f(self.app_name, email, password, email_token,
           reply_handler=NO_OP, error_handler=NO_OP)
 
@@ -731,30 +783,27 @@
 
     def on_login_connect_button_clicked(self, *args, **kwargs):
         """User wants to connect!"""
+        if not self.login_ok_button.is_sensitive():
+            return
+
         self._clear_warnings()
 
         error = False
+
         email = self.login_email_entry.get_text()
-
-        if '@' not in email:
-            self.login_email_entry.set_warning(self.EMAIL_INVALID)
-            error |= True
-
-        if not email:
-            self.login_email_entry.set_warning(self.FIELD_REQUIRED)
-            error |= True
+        msg = self._validate_email(email)
+        if msg is not None:
+            self.login_email_entry.set_warning(msg)
+            error = True
 
         password = self.login_password_entry.get_text()
-
         if not password:
             self.login_password_entry.set_warning(self.FIELD_REQUIRED)
-            error |= True
+            error = True
 
         if error:
             return
 
-        self._clear_warnings()
-
         f = self.backend.login
         f(self.app_name, email, password,
           reply_handler=NO_OP, error_handler=NO_OP)
@@ -771,7 +820,16 @@
 
     def on_request_password_token_ok_button_clicked(self, *args, **kwargs):
         """User entered the email address to reset the password."""
+        if not self.request_password_token_ok_button.is_sensitive():
+            return
+
+        self._clear_warnings()
+
         email = self.reset_email_entry.get_text()
+        msg = self._validate_email(email)
+        if msg is not None:
+            self.reset_email_entry.set_warning(msg)
+            return
 
         logger.info('Calling request_password_reset_token with %r.', email)
         f = self.backend.request_password_reset_token
@@ -799,13 +857,30 @@
 
     def on_set_new_password_ok_button_clicked(self, *args, **kwargs):
         """User entered reset code and new passwords."""
-        email = self.reset_email_entry.get_text()
+        if not self.set_new_password_ok_button.is_sensitive():
+            return
+
+        self._clear_warnings()
+
+        error = False
+
         token = self.reset_code_entry.get_text()
-        # XXX: validate passwords!
-        # see LP: #616528
+        if not token:
+            self.reset_code_entry.set_warning(self.FIELD_REQUIRED)
+            error = True
+
         password1 = self.reset_password1_entry.get_text()
-        #password2 = self.reset_password2_entry.get_text()
-
+        password2 = self.reset_password2_entry.get_text()
+        msg = self._validate_password(password1, password2)
+        if msg is not None:
+            self.reset_password1_entry.set_warning(msg)
+            self.reset_password2_entry.set_warning(msg)
+            error = True
+
+        if error:
+            return
+
+        email = self.reset_email_entry.get_text()
         logger.info('Calling set_new_password with email %r, token %r and ' \
                     'new password: <hidden>.', email, token)
         f = self.backend.set_new_password
@@ -836,6 +911,17 @@
 
     # backend callbacks
 
+    def _build_general_error_message(self, errordict):
+        """Concatenate __all__ and message from the errordict."""
+        result = None
+        msg1 = errordict.get('__all__')
+        msg2 = errordict.get('message')
+        if msg1 is not None and msg2 is not None:
+            result = '\n'.join((msg1, msg2))
+        else:
+            result = msg1 if msg1 is not None else msg2
+        return result
+
     @log_call
     def on_captcha_generated(self, app_name, captcha_id, *args, **kwargs):
         """Captcha image has been generated and is available to be shown."""
@@ -858,10 +944,21 @@
     @log_call
     def on_user_registration_error(self, app_name, error, *args, **kwargs):
         """Captcha image generation failed."""
-        self._set_current_page(self.enter_details_vbox,
-                               warning_text=self.UNKNOWN_ERROR)
+        msg = error.get('email')
+        if msg is not None:
+            self.email1_entry.set_warning(msg)
+            self.email2_entry.set_warning(msg)
+
+        msg = error.get('password')
+        if msg is not None:
+            self.password1_entry.set_warning(msg)
+            self.password2_entry.set_warning(msg)
+
+        msg = self._build_general_error_message(error)
+        self._set_current_page(self.enter_details_vbox, warning_text=msg)
+
         self._gtk_signal_log.append((SIG_REGISTRATION_FAILED, self.app_name,
-                                     error))
+                                    msg))
 
     @log_call
     def on_email_validated(self, app_name, email, *args, **kwargs):
@@ -873,10 +970,15 @@
     @log_call
     def on_email_validation_error(self, app_name, error, *args, **kwargs):
         """User email validation failed."""
-        self._set_current_page(self.verify_email_vbox,
-                               warning_text=self.UNKNOWN_ERROR)
+        msg = error.get('email_token')
+        if msg is not None:
+            self.email_token_entry.set_warning(msg)
+
+        msg = self._build_general_error_message(error)
+        self._set_current_page(self.verify_email_vbox, warning_text=msg)
+
         self._gtk_signal_log.append((SIG_REGISTRATION_FAILED, self.app_name,
-                                     error))
+                                     msg))
 
     @log_call
     def on_logged_in(self, app_name, email, *args, **kwargs):
@@ -888,10 +990,10 @@
     @log_call
     def on_login_error(self, app_name, error, *args, **kwargs):
         """User was not successfully logged in."""
-        self._set_current_page(self.login_vbox,
-                               warning_text=self.UNKNOWN_ERROR)
+        msg = self._build_general_error_message(error)
+        self._set_current_page(self.login_vbox, warning_text=msg)
         self._gtk_signal_log.append((SIG_LOGIN_FAILED, self.app_name,
-                                     error))
+                                     msg))
 
     @log_call
     def on_password_reset_token_sent(self, app_name, email, *args, **kwargs):
@@ -903,8 +1005,8 @@
     @log_call
     def on_password_reset_error(self, app_name, error, *args, **kwargs):
         """Password reset failed."""
-        self._set_current_page(self.login_vbox,
-                               warning_text=self.UNKNOWN_ERROR)
+        msg = self._build_general_error_message(error)
+        self._set_current_page(self.login_vbox, warning_text=msg)
 
     @log_call
     def on_password_changed(self, app_name, email, *args, **kwargs):
@@ -915,5 +1017,6 @@
     @log_call
     def on_password_change_error(self, app_name, error, *args, **kwargs):
         """Password reset failed."""
+        msg = self._build_general_error_message(error)
         self._set_current_page(self.request_password_token_vbox,
-                               warning_text=self.UNKNOWN_ERROR)
+                               warning_text=msg)

=== modified file 'ubuntu_sso/keyring.py'
--- ubuntu_sso/keyring.py	2010-08-19 16:02:09 +0000
+++ ubuntu_sso/keyring.py	2010-08-27 22:32:43 +0000
@@ -19,77 +19,128 @@
 
 """Handle keys in the gnome kerying."""
 
+import socket
+import urllib
+import urlparse
+
 import gnomekeyring
 
-from urllib import urlencode
-from urlparse import parse_qsl
+from ubuntu_sso.logger import setupLogging
+logger = setupLogging("ubuntu_sso.main")
+
+U1_APP_NAME = "Ubuntu One"
+U1_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
+U1_KEY_ATTR = {
+    "oauth-consumer-key": "ubuntuone",
+    "ubuntuone-realm": "https://ubuntuone.com",
+}
+
+
+def get_token_name(app_name):
+    """Build the token name."""
+    quoted_app_name = urllib.quote(app_name)
+    computer_name = socket.gethostname()
+    quoted_computer_name = urllib.quote(computer_name)
+    return "%s - %s" % (quoted_app_name, quoted_computer_name)
 
 
 class Keyring(object):
-
+    """A Keyring for a given application name."""
     KEYRING_NAME = "login"
 
     def __init__(self, app_name):
+        """Initialize this instance given the app_name."""
         if not gnomekeyring.is_available():
             raise gnomekeyring.NoKeyringDaemonError
         self.app_name = app_name
+        self.token_name = get_token_name(self.app_name)
 
     def _create_keyring(self, name):
-        """Creates a keyring, if it already exists, do nothing."""
+        """Creates a keyring, or if it already exists, it does nothing."""
         keyring_names = gnomekeyring.list_keyring_names_sync()
         if not name in keyring_names:
             gnomekeyring.create_sync(name)
 
-    def _get_item_id_from_name(self, sync, name):
-        """Return the ID for a named item."""
-        for item_id in gnomekeyring.list_item_ids_sync(sync):
-            item_info = gnomekeyring.item_get_info_sync(sync, item_id)
-            display_name = item_info.get_display_name()
-            if display_name == name:
-                return item_id
-
-    def _get_item_info_from_name(self, sync, name):
-        """Return the ID for a named item."""
-        for item_id in gnomekeyring.list_item_ids_sync(sync):
-            item_info = gnomekeyring.item_get_info_sync(sync, item_id)
-            display_name = item_info.get_display_name()
-            if display_name == name:
-                return item_info
+    def _find_keyring_item(self):
+        """Return the keyring item or None if not found."""
+        try:
+            items = gnomekeyring.find_items_sync(
+                                        gnomekeyring.ITEM_GENERIC_SECRET,
+                                        self._get_keyring_attr())
+        except gnomekeyring.NoMatchError:
+            # if no items found, return None
+            return None
+
+        # we priorize the item in the "login" keyring
+        for item in items:
+            if item.keyring == "login":
+                return item
+
+        # if not on the "login" keyring, we return the first item
+        return items[0]
+
+    def _get_keyring_attr(self):
+        """Build the keyring attributes for this credentials."""
+        attr = {"key-type": "Ubuntu SSO credentials",
+                "token-name": self.token_name}
+        return attr
 
     def set_ubuntusso_attr(self, cred):
         """Set the credentials of the Ubuntu SSO item."""
         # Creates the secret from the credentials
-        secret = urlencode(cred)
+        secret = urllib.urlencode(cred)
 
-        # Create the keyring
+        # Create the keyring if it does not exists
         self._create_keyring(self.KEYRING_NAME)
 
-        # No need to delete the item if it already exists
-
-        # A set of attributes for this credentials
-        attr = {"key-type": "Ubuntu SSO credentials",
-                "token-name": cred["name"].encode("utf8")}
-
         # Add our SSO credentials to the keyring
         gnomekeyring.item_create_sync(self.KEYRING_NAME,
-                gnomekeyring.ITEM_GENERIC_SECRET, self.app_name, attr,
-                secret, True)
+                gnomekeyring.ITEM_GENERIC_SECRET, self.app_name,
+                self._get_keyring_attr(), secret, True)
 
     def get_ubuntusso_attr(self):
         """Return the secret of the SSO item in a dictionary."""
         # If we have no attributes, return None
-        exist = self._get_item_info_from_name(self.KEYRING_NAME, self.app_name)
-        if exist is not None:
-            secret = self._get_item_info_from_name(self.KEYRING_NAME,
-                                                   self.app_name).get_secret()
-            return dict(parse_qsl(secret))
+        item = self._find_keyring_item()
+        if item is not None:
+            return dict(urlparse.parse_qsl(item.secret))
+        else:
+            # if no item found, try getting the old credentials
+            if self.app_name == U1_APP_NAME:
+                return try_old_credentials(self.app_name)
+        # nothing was found
+        return None
 
     def delete_ubuntusso_attr(self):
         """Delete a set of credentials from the keyring."""
-        item_id = self._get_item_id_from_name(self.KEYRING_NAME,
-                                              self.app_name)
-        if item_id is not None:
-            gnomekeyring.item_delete_sync(self.KEYRING_NAME, item_id)
+        item = self._find_keyring_item()
+        if item is not None:
+            gnomekeyring.item_delete_sync(item.keyring, item.item_id)
+
+
+class UbuntuOneOAuthKeyring(Keyring):
+
+    def _get_keyring_attr(self):
+        """Build the keyring attributes for this credentials."""
+        return U1_KEY_ATTR
+
+
+def try_old_credentials(app_name):
+    """Try to get old U1 credentials and format them as new."""
+    logger.debug('trying to get old credentials.')
+    old_creds = UbuntuOneOAuthKeyring(U1_KEY_NAME).get_ubuntusso_attr()
+    if old_creds is not None:
+        # Old creds found, build a new credentials dict with them
+        creds = {
+            'consumer_key': "ubuntuone",
+            'consumer_secret': "hammertime",
+            'name': U1_KEY_NAME,
+            'token': old_creds["oauth_token"],
+            'token_secret': old_creds["oauth_token_secret"],
+        }
+        logger.debug('found old credentials')
+        return creds
+    logger.debug('try_old_credentials: No old credentials for this app.')
 
 
 if __name__ == "__main__":

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-08-26 01:07:41 +0000
+++ ubuntu_sso/main.py	2010-08-27 22:32:43 +0000
@@ -28,11 +28,9 @@
 """
 
 import re
-import socket
 import time
 import threading
 import traceback
-import urllib
 import urllib2
 import urlparse
 
@@ -49,7 +47,7 @@
 from ubuntu_sso import (DBUS_IFACE_AUTH_NAME, DBUS_IFACE_USER_NAME,
     DBUS_IFACE_CRED_NAME, DBUS_CRED_PATH, DBUS_BUS_NAME, gui)
 from ubuntu_sso.config import get_config
-from ubuntu_sso.keyring import Keyring
+from ubuntu_sso.keyring import Keyring, get_token_name, U1_APP_NAME
 from ubuntu_sso.logger import setupLogging
 logger = setupLogging("ubuntu_sso.main")
 
@@ -57,8 +55,6 @@
 # Disable the invalid name warning, as we have a lot of DBus style names
 # pylint: disable-msg=C0103
 
-OLD_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
-U1_APP_NAME = "Ubuntu One"
 PING_URL = "http://edge.one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
 
 
@@ -113,32 +109,9 @@
     creds = Keyring(app_name).get_ubuntusso_attr()
     logger.debug('keyring_get_credentials: Keyring returned credentials? %r',
                  creds is not None)
-    if creds is None and app_name == U1_APP_NAME:
-        logger.debug('keyring_get_credentials: trying for old service.')
-        # No new creds, try to get old credentials
-        old_creds = Keyring(OLD_KEY_NAME).get_ubuntusso_attr()
-        if old_creds is not None:
-            # Old creds found, build a new credentials dict with them
-            creds = {
-                'consumer_key': "ubuntuone",
-                'consumer_secret': "hammertime",
-                'token_name': OLD_KEY_NAME,
-                'token': old_creds["oauth_token"],
-                'token_secret': old_creds["oauth_token_secret"],
-            }
-    else:
-        logger.debug('keyring_get_credentials: Keyring returned credentials.')
     return creds
 
 
-def get_token_name(app_name):
-    """Build the token name."""
-    quoted_app_name = urllib.quote(app_name)
-    computer_name = socket.gethostname()
-    quoted_computer_name = urllib.quote(computer_name)
-    return "%s - %s" % (quoted_app_name, quoted_computer_name)
-
-
 class SSOLoginProcessor(object):
     """Login and register users using the Ubuntu Single Sign On service."""
 
@@ -163,6 +136,17 @@
                re.search('\d+', password))  # one number
         return res
 
+    def _format_webservice_errors(self, errdict):
+        """Turn each list of strings in the errdict into a LF separated str."""
+        result = {}
+        for k, v in errdict.iteritems():
+            # workaround until bug #624955 is solved
+            if isinstance(v, basestring):
+                result[k] = v
+            else:
+                result[k] = "\n".join(v)
+        return result
+
     def generate_captcha(self, filename):
         """Generate a captcha using the SSO service."""
         logger.debug('generate_captcha: requesting captcha, filename: %r',
@@ -203,7 +187,8 @@
         logger.info('register_user: email: %r result: %r', email, result)
 
         if result['status'] == 'error':
-            raise RegistrationError(result['errors'])
+            errorsdict = self._format_webservice_errors(result['errors'])
+            raise RegistrationError(errorsdict)
         elif result['status'] != 'ok':
             raise RegistrationError('Received unknown status: %s' % result)
         else:
@@ -243,9 +228,10 @@
         result = sso_service.accounts.validate_email(email_token=email_token)
         logger.info('validate_email: email: %r result: %r', email, result)
         if 'errors' in result:
-            raise EmailTokenError(result['errors'])
+            errorsdict = self._format_webservice_errors(result['errors'])
+            raise EmailTokenError(errorsdict)
         elif 'email' in result:
-            return result['email']
+            return token
         else:
             raise EmailTokenError('Received invalid reply: %s' % result)
 
@@ -257,7 +243,7 @@
             result = service(email=email)
         except HTTPError, e:
             logger.exception('request_password_reset_token failed with:')
-            raise ResetPasswordTokenError(e.content)
+            raise ResetPasswordTokenError(e.content.split('\n')[0])
 
         if result['status'] == 'ok':
             return email
@@ -279,7 +265,7 @@
                              new_password=new_password)
         except HTTPError, e:
             logger.exception('set_new_password failed with:')
-            raise NewPasswordError(e.content)
+            raise NewPasswordError(e.content.split('\n')[0])
 
         if result['status'] == 'ok':
             return email
@@ -291,7 +277,6 @@
     """Turn an exception into a dictionary to return thru DBus."""
     result = {
         "errtype": e.__class__.__name__,
-        "errargs": repr(e.args),
     }
     if len(e.args) == 0:
         result["message"] = e.__class__.__doc__
@@ -414,8 +399,10 @@
         def f():
             """Inner function that will be run in a thread."""
             token_name = get_token_name(app_name)
-            return self.processor().validate_email(email, password,
+            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)
 
     # request_password_reset_token signals

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-08-26 01:07:41 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-08-27 22:32:43 +0000
@@ -44,7 +44,6 @@
 CAPTCHA_SOLUTION = 'william Byrd'
 EMAIL = '[e-mail]'
 EMAIL_TOKEN = 'B2Pgtf'
-ERROR = 'Something bad happened!'
 NAME = 'Juanito Pérez'
 PASSWORD = 'h3lloWorld'
 RESET_PASSWORD_TOKEN = '8G5Wtq'
@@ -269,6 +268,8 @@
                          None)
         self.assertEqual(self.entry.get_property('secondary-icon-sensitive'),
                          False)
+        self.assertEqual(self.entry.get_property('secondary-icon-activatable'),
+                         False)
         prop = self.entry.get_property('secondary-icon-tooltip-text')
         self.assertEqual(prop, None)
 
@@ -281,6 +282,8 @@
                          gtk.STOCK_DIALOG_WARNING)
         self.assertEqual(self.entry.get_property('secondary-icon-sensitive'),
                          True)
+        self.assertEqual(self.entry.get_property('secondary-icon-activatable'),
+                         False)
         prop = self.entry.get_property('secondary-icon-tooltip-text')
         self.assertEqual(prop, msg)
 
@@ -292,6 +295,8 @@
                          None)
         self.assertEqual(self.entry.get_property('secondary-icon-sensitive'),
                          False)
+        self.assertEqual(self.entry.get_property('secondary-icon-activatable'),
+                         False)
         prop = self.entry.get_property('secondary-icon-tooltip-text')
         self.assertEqual(prop, None)
 
@@ -338,6 +343,7 @@
                       'tc_browser', 'login', 'request_password_token',
                       'set_new_password')
         self.ui = self.gui_class(**self.kwargs)
+        self.ERROR = {'message': self.ui.UNKNOWN_ERROR}
 
     def tearDown(self):
         """Clean up."""
@@ -358,11 +364,13 @@
     def assert_warnings_visibility(self, visible=False):
         """Every warning label should be 'visible'."""
         msg = '"%s" should be %svisible.'
-        warnings = filter(lambda name: 'warning' in name, self.ui.widgets)
-        for name in warnings:
+        for name in self.ui.widgets:
             widget = getattr(self.ui, name)
-            self.assertEqual(visible, widget.get_property('visible'),
-                             msg % (name, '' if visible else 'not '))
+            if 'warning' in name:
+                self.assertEqual(visible, widget.get_property('visible'),
+                                 msg % (name, '' if visible else 'not '))
+            elif 'entry' in name:
+                self.assertEqual(widget.warning, '')
 
     def assert_correct_label_warning(self, label, message):
         """Check that a warning is shown displaying 'message'."""
@@ -533,6 +541,16 @@
             # text content is correct
             self.assertEqual(expected, actual, msg % (name, expected, actual))
 
+    def test_initial_size_for_labels(self):
+        """Labels have the correct width."""
+        expected = (int(self.ui.window.get_size_request()[0] * 0.9), -1)
+        msg = 'Label %r must have size request %s (got %s instead).'
+        labels = [i for i in self.ui.widgets if 'label' in i]
+        for label in labels:
+            widget = getattr(self.ui, label)
+            actual = widget.get_size_request()
+            self.assertEqual(expected, actual, msg % (label, expected, actual))
+
     def test_password_fields_are_password(self):
         msg = '"%s" should be a password LabeledEntry instance.'
         passwords = filter(lambda name: 'password' in name,
@@ -543,7 +561,7 @@
 
     def test_warning_fields_are_hidden(self):
         """Every warning label should be not visible."""
-        self.assert_warnings_visibility(visible=False)
+        self.assert_warnings_visibility()
 
     def test_cancel_buttons_close_window(self):
         """Every cancel button should close the window when clicked."""
@@ -558,6 +576,17 @@
             self.assertEqual(self._called, ((widget,), {}), msg % name)
             self._called = False
 
+    def test_all_buttons_are_activatable(self):
+        """Every button should be activatable."""
+        msg = '"%s" should be activatable.'
+        buttons = filter(lambda name: '_button' in name, self.ui.widgets)
+        for name in buttons:
+            widget = getattr(self.ui, name)
+            widget.connect('clicked', self._set_called)
+            widget.activate()
+            self.assertEqual(self._called, ((widget,), {}), msg % name)
+            self._called = False
+
     def test_window_icon(self):
         """Main window has the proper icon."""
         self.assertEqual('ubuntu-logo', self.ui.window.get_icon_name())
@@ -585,7 +614,7 @@
         self.assertEqual(self._called, ((xid,), {}))
 
 
-class RegistrationEnterDetailsTestCase(UbuntuSSOClientTestCase):
+class EnterDetailsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (enter details page)."""
 
     def test_initial_text_for_header_label(self):
@@ -774,6 +803,50 @@
         actual = self.ui.login_button.get_label()
         self.assertEqual(self.ui.LOGIN_BUTTON_LABEL, actual)
 
+    def test_activate_name_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.name_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_activate_email_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.email1_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+        self._called = False
+        self.ui.email2_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_activate_password_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.password1_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+        self._called = False
+        self.ui.password2_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_activate_captcha_solution_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.captcha_solution_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_join_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The join form can only be submitted if the button is sensitive."""
+        self.patch(self.ui.name_entry, 'get_text', self._set_called)
+
+        self.ui.join_ok_button.set_sensitive(False)
+        self.ui.join_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.join_ok_button.set_sensitive(True)
+        self.ui.join_ok_button.clicked()
+        self.assertTrue(self._called)
+
 
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (with no t&c link)."""
@@ -843,24 +916,46 @@
     test_tc_browser_opens_the_proper_uri.skip = 'The freaking test wont work.'
 
 
-class UserRegistrationErrorTestCase(UbuntuSSOClientTestCase):
+class RegistrationErrorTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration error handling."""
 
     def setUp(self):
         """Init."""
-        super(UserRegistrationErrorTestCase, self).setUp()
+        super(RegistrationErrorTestCase, self).setUp()
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
 
     def test_previous_page_is_shown(self):
         """On UserRegistrationError the previous page is shown."""
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
         self.assert_pages_visibility(enter_details=True)
 
     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)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
 
+    def test_specific_errors_from_backend_are_shown(self):
+        """Specific errors from backend are used."""
+        error = {'errtype': 'RegistrationError',
+                 'message': 'We\'re so doomed.',
+                 'email': 'Enter a valid e-mail address.',
+                 'password': 'I don\'t like your password.',
+                 '__all__': 'Wrong captcha solution.'}
+
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=error)
+
+        expected = '\n'.join((error['__all__'], error['message']))
+        self.assert_correct_label_warning(self.ui.warning_label, expected)
+        self.assert_correct_entry_warning(self.ui.email1_entry,
+                                          error['email'])
+        self.assert_correct_entry_warning(self.ui.email2_entry,
+                                          error['email'])
+        self.assert_correct_entry_warning(self.ui.password1_entry,
+                                          error['password'])
+        self.assert_correct_entry_warning(self.ui.password2_entry,
+                                          error['password'])
+
 
 class VerifyEmailTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (verify email page)."""
@@ -899,30 +994,44 @@
         self.click_verify_email_with_valid_data()
         self.assert_pages_visibility(processing=True)
 
-    def test_no_warning_messages_if_valid_data_on_verify_token(self):
+    def test_no_warning_messages_if_valid_data(self):
         """No warning messages are shown if the data is valid."""
         # this will certainly NOT generate warnings
         self.click_verify_email_with_valid_data()
-        self.assert_warnings_visibility(visible=False)
+        self.assert_warnings_visibility()
 
     def test_on_email_validated_shows_success_page(self):
         """On email validated the success page is shown."""
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.assert_pages_visibility(success=True)
 
-    def test_on_email_validated_clears_the_help_text(self):
-        """On email validated the help text is removed."""
+    def test_on_email_validated_does_not_clear_the_help_text(self):
+        """On email validated the help text is not removed."""
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.assertEqual('', self.ui.help_label.get_text())
-    test_on_email_validated_clears_the_help_text.skip = 'Maybe this is wrong.'
+        self.assertEqual(self.ui.verify_email_vbox.help_text,
+                         self.ui.help_label.get_label())
 
     def test_on_email_validation_error_verify_email_is_shown(self):
         """On email validation error, the verify_email page is shown."""
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.ERROR)
         self.assert_pages_visibility(verify_email=True)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
 
+    def test_specific_errors_from_backend_are_shown(self):
+        """Specific errors from backend are used."""
+        error = {'errtype': 'EmailValidationError',
+                 'message': 'We\'re so doomed.',
+                 'email_token': 'Enter a valid e-mail address.',
+                 '__all__': 'We all are gonna die.'}
+
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=error)
+
+        expected = '\n'.join((error['__all__'], error['message']))
+        self.assert_correct_label_warning(self.ui.warning_label, expected)
+        self.assert_correct_entry_warning(self.ui.email_token_entry,
+                                          error['email_token'])
+
     def test_success_label_is_correct(self):
         """The success message is correct."""
         self.assertEqual(self.ui.SUCCESS, self.ui.success_label.get_text())
@@ -934,15 +1043,74 @@
         self.ui.success_close_button.clicked()
         self.assertFalse(self.ui.window.get_property('visible'))
 
+    def test_activate_email_token_entry_clicks_verify_token(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.verify_token_button.connect('clicked', self._set_called)
+        self.ui.email_token_entry.activate()
+        self.assertEqual(self._called, ((self.ui.verify_token_button,), {}))
+
+    def test_verify_token_button_does_nothing_if_clicked_but_disabled(self):
+        """The email token can only be submitted if the button is sensitive."""
+        self.patch(self.ui.email_token_entry, 'get_text', self._set_called)
+
+        self.ui.verify_token_button.set_sensitive(False)
+        self.ui.verify_token_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.verify_token_button.set_sensitive(True)
+        self.ui.verify_token_button.clicked()
+        self.assertTrue(self._called)
+
+
+class VerifyEmailValidationTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user registration (verify email page)."""
+
+    def setUp(self):
+        """Init."""
+        super(VerifyEmailValidationTestCase, self).setUp()
+        self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
+
+    def test_warning_is_shown_if_empty_email_token(self):
+        """A warning message is shown if email token is empty."""
+        self.ui.email_token_entry.set_text('')
+
+        self.ui.verify_token_button.clicked()
+
+        self.assert_correct_entry_warning(self.ui.email_token_entry,
+                                          self.ui.FIELD_REQUIRED)
+        self.assertNotIn('validate_email', self.ui.backend._called)
+
+    def test_no_warning_messages_if_valid_data(self):
+        """No warning messages are shown if the data is valid."""
+        # this will certainly NOT generate warnings
+        self.click_verify_email_with_valid_data()
+
+        self.assert_warnings_visibility()
+
+    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
+        """No warnings if the data is valid (with prior invalid data)."""
+        # this will certainly generate warnings
+        self.ui.verify_token_button.clicked()
+
+        # this will certainly NOT generate warnings
+        self.click_verify_email_with_valid_data()
+
+        self.assert_warnings_visibility()
+
 
 class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration  validations."""
 
+    def setUp(self):
+        """Init."""
+        super(RegistrationValidationTestCase, self).setUp()
+        self.ui.join_ok_button.set_sensitive(True)
+
     def test_warning_is_shown_if_name_empty(self):
         """A warning message is shown if name is empty."""
         self.ui.name_entry.set_text('')
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.name_entry,
                                           self.ui.FIELD_REQUIRED)
@@ -953,7 +1121,7 @@
         self.ui.email1_entry.set_text('')
         self.ui.email2_entry.set_text('')
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.email1_entry,
                                           self.ui.FIELD_REQUIRED)
@@ -966,7 +1134,7 @@
         self.ui.email1_entry.set_text(EMAIL)
         self.ui.email2_entry.set_text(EMAIL * 2)
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.email1_entry,
                                           self.ui.EMAIL_MISMATCH)
@@ -979,7 +1147,7 @@
         self.ui.email1_entry.set_text('q')
         self.ui.email2_entry.set_text('q')
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.email1_entry,
                                           self.ui.EMAIL_INVALID)
@@ -1000,7 +1168,7 @@
         self.ui.password1_entry.set_text(PASSWORD)
         self.ui.password2_entry.set_text(PASSWORD * 2)
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.password1_entry,
                                           self.ui.PASSWORD_MISMATCH)
@@ -1015,7 +1183,7 @@
             self.ui.password1_entry.set_text(w)
             self.ui.password2_entry.set_text(w)
 
-            self.ui.join_ok_button.clicked()  # submit form
+            self.ui.join_ok_button.clicked()
 
             self.assert_correct_entry_warning(self.ui.password1_entry,
                                               self.ui.PASSWORD_TOO_WEAK)
@@ -1028,7 +1196,7 @@
         # don't agree to TC
         self.ui.yes_to_tc_checkbutton.set_active(False)
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_label_warning(self.ui.tc_warning_label,
                                           self.ui.TC_NOT_ACCEPTED)
@@ -1039,18 +1207,18 @@
         # captcha solution will be empty
         self.ui.captcha_solution_entry.set_text('')
 
-        self.ui.join_ok_button.clicked()  # submit form
+        self.ui.join_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.captcha_solution_entry,
                                           self.ui.FIELD_REQUIRED)
         self.assertNotIn('register_user', self.ui.backend._called)
 
-    def test_no_warning_messages_if_valid_data_on_enter_details(self):
+    def test_no_warning_messages_if_valid_data(self):
         """No warning messages are shown if the data is valid."""
         # this will certainly NOT generate warnings
         self.click_join_with_valid_data()
 
-        self.assert_warnings_visibility(visible=False)
+        self.assert_warnings_visibility()
 
     def test_no_warning_messages_if_valid_data_after_invalid_data(self):
         """No warnings if the data is valid (with prior invalid data)."""
@@ -1060,7 +1228,7 @@
         # this will certainly NOT generate warnings
         self.click_join_with_valid_data()
 
-        self.assert_warnings_visibility(visible=False)
+        self.assert_warnings_visibility()
 
 
 class LoginTestCase(UbuntuSSOClientTestCase):
@@ -1136,23 +1304,58 @@
     def test_on_login_error_morphs_to_login_page(self):
         """On user login error, the previous page is shown."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
         self.assert_pages_visibility(login=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()
-        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
 
+    def test_specific_errors_from_backend_are_shown(self):
+        """Specific errors from backend are used."""
+        error = {'errtype': 'AuthenticationError',
+                 'message': 'We\'re so doomed.',
+                 '__all__': 'We all are gonna die.'}
+
+        self.ui.on_login_error(app_name=APP_NAME, error=error)
+
+        expected = '\n'.join((error['__all__'], error['message']))
+        self.assert_correct_label_warning(self.ui.warning_label, expected)
+
     def test_back_to_registration_hides_warning(self):
         """After user login error, warning is hidden when clicking 'Back'."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
         self.ui.login_back_button.clicked()
         self.assertFalse(self.ui.warning_label.get_property('visible'))
 
+    def test_activate_email_entry_clicks_login(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.login_ok_button.connect('clicked', self._set_called)
+        self.ui.login_email_entry.activate()
+        self.assertEqual(self._called, ((self.ui.login_ok_button,), {}))
+
+    def test_activate_password_entry_clicks_login(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.login_ok_button.connect('clicked', self._set_called)
+        self.ui.login_password_entry.activate()
+        self.assertEqual(self._called, ((self.ui.login_ok_button,), {}))
+
+    def test_login_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The join form can only be submitted if the button is sensitive."""
+        self.patch(self.ui.login_email_entry, 'get_text', self._set_called)
+
+        self.ui.login_ok_button.set_sensitive(False)
+        self.ui.login_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.login_ok_button.set_sensitive(True)
+        self.ui.login_ok_button.clicked()
+        self.assertTrue(self._called)
+
 
 class LoginValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user login validation."""
@@ -1166,7 +1369,7 @@
         """A warning message is shown if email is empty."""
         self.ui.login_email_entry.set_text('')
 
-        self.ui.login_ok_button.clicked()  # submit form
+        self.ui.login_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.login_email_entry,
                                           self.ui.FIELD_REQUIRED)
@@ -1176,7 +1379,7 @@
         """A warning message is shown if email is invalid."""
         self.ui.login_email_entry.set_text('q')
 
-        self.ui.login_ok_button.clicked()  # submit form
+        self.ui.login_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.login_email_entry,
                                           self.ui.EMAIL_INVALID)
@@ -1186,7 +1389,7 @@
         """A warning message is shown if password is empty."""
         self.ui.login_password_entry.set_text('')
 
-        self.ui.login_ok_button.clicked()  # submit form
+        self.ui.login_ok_button.clicked()
 
         self.assert_correct_entry_warning(self.ui.login_password_entry,
                                           self.ui.FIELD_REQUIRED)
@@ -1197,7 +1400,7 @@
         # this will certainly NOT generate warnings
         self.click_connect_with_valid_data()
 
-        self.assert_warnings_visibility(visible=False)
+        self.assert_warnings_visibility()
 
     def test_no_warning_messages_if_valid_data_after_invalid_data(self):
         """No warnings if the data is valid (with prior invalid data)."""
@@ -1207,7 +1410,7 @@
         # this will certainly NOT generate warnings
         self.click_connect_with_valid_data()
 
-        self.assert_warnings_visibility(visible=False)
+        self.assert_warnings_visibility()
 
 
 class ResetPasswordTestCase(UbuntuSSOClientTestCase):
@@ -1301,11 +1504,86 @@
 
     def test_on_password_reset_error_shows_login_page(self):
         """When reset token wasn't successfuly sent the login page is shown."""
-        self.ui.on_password_reset_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_password_reset_error(app_name=APP_NAME, error=self.ERROR)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
         self.assert_pages_visibility(login=True)
 
+    def test_specific_errors_from_backend_are_shown(self):
+        """Specific errors from backend are used."""
+        error = {'errtype': 'ResetPasswordTokenError',
+                 'message': 'We\'re so doomed.',
+                 '__all__': 'We all are gonna die.'}
+
+        self.ui.on_password_reset_error(app_name=APP_NAME, error=error)
+
+        expected = '\n'.join((error['__all__'], error['message']))
+        self.assert_correct_label_warning(self.ui.warning_label, expected)
+
+    def test_activate_reset_email_entry_clicks_login(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.request_password_token_ok_button.connect('clicked',
+                                                         self._set_called)
+        self.ui.reset_email_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.request_password_token_ok_button,), {}))
+
+    def test_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The password token can be requested if the button is sensitive."""
+        self.patch(self.ui.reset_email_entry, 'get_text', self._set_called)
+
+        self.ui.request_password_token_ok_button.set_sensitive(False)
+        self.ui.request_password_token_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.request_password_token_ok_button.set_sensitive(True)
+        self.ui.request_password_token_ok_button.clicked()
+        self.assertTrue(self._called)
+
+
+class ResetPasswordValidationTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the password reset validations."""
+
+    def test_warning_is_shown_if_empty_email(self):
+        """A warning message is shown if emails are empty."""
+        self.ui.reset_email_entry.set_text(' ')
+
+        self.ui.request_password_token_ok_button.set_sensitive(True)
+        self.ui.request_password_token_ok_button.clicked()
+
+        self.assert_correct_entry_warning(self.ui.reset_email_entry,
+                                          self.ui.FIELD_REQUIRED)
+        self.assertNotIn('request_password_reset_token',
+                         self.ui.backend._called)
+
+    def test_warning_is_shown_if_invalid_email(self):
+        """A warning message is shown if email is invalid."""
+        self.ui.reset_email_entry.set_text('q')
+
+        self.ui.request_password_token_ok_button.clicked()
+
+        self.assert_correct_entry_warning(self.ui.reset_email_entry,
+                                          self.ui.EMAIL_INVALID)
+        self.assertNotIn('request_password_reset_token',
+                         self.ui.backend._called)
+
+    def test_no_warning_messages_if_valid_data(self):
+        """No warning messages are shown if the data is valid."""
+        # this will certainly NOT generate warnings
+        self.click_request_password_token_with_valid_data()
+
+        self.assert_warnings_visibility()
+
+    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
+        """No warnings if the data is valid (with prior invalid data)."""
+        # this will certainly generate warnings
+        self.ui.request_password_token_ok_button.clicked()
+
+        # this will certainly NOT generate warnings
+        self.click_request_password_token_with_valid_data()
+
+        self.assert_warnings_visibility()
+
 
 class SetNewPasswordTestCase(UbuntuSSOClientTestCase):
     """Test suite for setting a new password functionality."""
@@ -1358,11 +1636,123 @@
 
     def test_on_password_change_error_shows_login_page(self):
         """When password wasn't changed the reset password page is shown."""
-        self.ui.on_password_change_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_password_change_error(app_name=APP_NAME, error=self.ERROR)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
         self.assert_pages_visibility(request_password_token=True)
 
+    def test_specific_errors_from_backend_are_shown(self):
+        """Specific errors from backend are used."""
+        error = {'errtype': 'NewPasswordError',
+                 'message': 'We\'re so doomed.',
+                 '__all__': 'We all are gonna die.'}
+
+        self.ui.on_password_change_error(app_name=APP_NAME, error=error)
+
+        expected = '\n'.join((error['__all__'], error['message']))
+        self.assert_correct_label_warning(self.ui.warning_label, expected)
+
+    def test_activate_reset_code_entry_clicks_set_new_password(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.set_new_password_ok_button.connect('clicked', self._set_called)
+        self.ui.reset_code_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.set_new_password_ok_button,), {}))
+
+    def test_activate_password_entry_clicks_set_new_password(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.set_new_password_ok_button.connect('clicked', self._set_called)
+        self.ui.reset_password1_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.set_new_password_ok_button,), {}))
+
+        self._called = False
+        self.ui.reset_password2_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.set_new_password_ok_button,), {}))
+
+    def test_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The new passwrd can only be set if the button is sensitive."""
+        self.patch(self.ui.reset_code_entry, 'get_text', self._set_called)
+
+        self.ui.set_new_password_ok_button.set_sensitive(False)
+        self.ui.set_new_password_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.set_new_password_ok_button.set_sensitive(True)
+        self.ui.set_new_password_ok_button.clicked()
+        self.assertTrue(self._called)
+
+
+class SetNewPasswordValidationTestCase(UbuntuSSOClientTestCase):
+    """Test suite for validations for setting a new password."""
+
+    def test_warning_is_shown_if_reset_code_empty(self):
+        """A warning message is shown if reset_code is empty."""
+        self.ui.reset_code_entry.set_text('')
+
+        self.ui.set_new_password_ok_button.set_sensitive(True)
+        self.ui.set_new_password_ok_button.clicked()
+
+        self.assert_correct_entry_warning(self.ui.reset_code_entry,
+                                          self.ui.FIELD_REQUIRED)
+        self.assertNotIn('set_new_password', self.ui.backend._called)
+
+    def test_password_help_is_always_shown(self):
+        """Password help text is correctly displayed."""
+        visible = self.ui.reset_password_help_label.get_property('visible')
+        self.assertTrue(visible, 'password help text is visible.')
+        self.assertEqual(self.ui.reset_password_help_label.get_text(),
+                         self.ui.PASSWORD_HELP)
+        self.assertNotIn('set_new_password', self.ui.backend._called)
+
+    def test_warning_is_shown_if_password_mismatch(self):
+        """A warning message is shown if password doesn't match."""
+        self.ui.reset_password1_entry.set_text(PASSWORD)
+        self.ui.reset_password2_entry.set_text(PASSWORD * 2)
+
+        self.ui.set_new_password_ok_button.set_sensitive(True)
+        self.ui.set_new_password_ok_button.clicked()
+
+        self.assert_correct_entry_warning(self.ui.reset_password1_entry,
+                                          self.ui.PASSWORD_MISMATCH)
+        self.assert_correct_entry_warning(self.ui.reset_password2_entry,
+                                          self.ui.PASSWORD_MISMATCH)
+        self.assertNotIn('set_new_password', self.ui.backend._called)
+
+    def test_warning_is_shown_if_password_too_weak(self):
+        """A warning message is shown if password is too weak."""
+        # password will match but will be too weak
+        for w in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
+            self.ui.reset_password1_entry.set_text(w)
+            self.ui.reset_password2_entry.set_text(w)
+
+            self.ui.set_new_password_ok_button.set_sensitive(True)
+            self.ui.set_new_password_ok_button.clicked()
+
+            self.assert_correct_entry_warning(self.ui.reset_password1_entry,
+                                              self.ui.PASSWORD_TOO_WEAK)
+            self.assert_correct_entry_warning(self.ui.reset_password2_entry,
+                                              self.ui.PASSWORD_TOO_WEAK)
+        self.assertNotIn('set_new_password', self.ui.backend._called)
+
+    def test_no_warning_messages_if_valid_data(self):
+        """No warning messages are shown if the data is valid."""
+        # this will certainly NOT generate warnings
+        self.click_set_new_password_with_valid_data()
+
+        self.assert_warnings_visibility()
+
+    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
+        """No warnings if the data is valid (with prior invalid data)."""
+        # this will certainly generate warnings
+        self.ui.set_new_password_ok_button.clicked()
+
+        # this will certainly NOT generate warnings
+        self.click_set_new_password_with_valid_data()
+
+        self.assert_warnings_visibility()
+
 
 class DbusTestCase(UbuntuSSOClientTestCase):
     """Test suite for the dbus calls."""
@@ -1408,6 +1798,10 @@
         """The login_ok_button has the focus."""
         self.assertTrue(self.ui.login_ok_button.is_focus())
 
+    def test_help_text_is_used(self):
+        """The passed help_text is used."""
+        self.assertEqual(self.ui.help_label.get_text(), HELP_TEXT)
+
 
 class SignalsTestCase(UbuntuSSOClientTestCase):
 
@@ -1438,9 +1832,10 @@
 
     def test_on_user_registration_error_proper_signal_is_emitted(self):
         """On UserRegistrationError, 'registration-failed' signal is sent."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME, ERROR), {}),
+        expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
+        self.assertEqual(expected,
                          self._called[gui.SIG_REGISTRATION_FAILED])
 
     def test_on_email_validated_proper_signals_is_emitted(self):
@@ -1452,10 +1847,11 @@
 
     def test_on_email_validation_error_proper_signals_is_emitted(self):
         """On EmailValidationError, 'registration-failed' signal is sent."""
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.ERROR)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME, ERROR), {}),
-                          self._called[gui.SIG_REGISTRATION_FAILED])
+        expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
+        self.assertEqual(expected,
+                         self._called[gui.SIG_REGISTRATION_FAILED])
 
     def test_on_logged_in_proper_signals_is_emitted(self):
         """On LoggedIn, 'login-succeeded' signal is sent."""
@@ -1467,15 +1863,16 @@
     def test_on_login_error_proper_signals_is_emitted(self):
         """On LoginError, 'login-failed' signal is sent."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME, ERROR), {}),
-                          self._called[gui.SIG_LOGIN_FAILED])
+        expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
+        self.assertEqual(expected,
+                         self._called[gui.SIG_LOGIN_FAILED])
 
     def test_registration_successfull_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
         self.click_join_with_valid_data()
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
@@ -1486,7 +1883,7 @@
     def test_login_successfull_even_if_prior_login_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
         self.click_connect_with_valid_data()
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
@@ -1497,7 +1894,7 @@
     def test_user_cancelation_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
         self.ui.join_cancel_button.clicked()
 
         self.assertEqual(len(self._called), 1)
@@ -1506,7 +1903,7 @@
     def test_user_cancelation_even_if_prior_login_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
         self.ui.login_cancel_button.clicked()
 
         self.assertEqual(len(self._called), 1)

=== modified file 'ubuntu_sso/tests/test_keyring.py'
--- ubuntu_sso/tests/test_keyring.py	2010-08-19 16:02:09 +0000
+++ ubuntu_sso/tests/test_keyring.py	2010-08-27 22:32:43 +0000
@@ -17,24 +17,39 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Tests for the keyring.py module."""
 
+import itertools
+import socket
+import urllib
+
 import gnomekeyring
 from twisted.trial.unittest import TestCase
 
 from ubuntu_sso import keyring
 
 
-class MockInfoSync(object):
-    """A mock object that represents a fake key."""
-
-    def __init__(self, (key, key_name, secret)):
+def build_fake_gethostname(fake_hostname):
+    """Return a fake hostname getter."""
+    return lambda *a: fake_hostname
+
+
+class MockKeyringItem(object):
+    """A mock object that fakes an item found in a keyring search."""
+
+    def __init__(self, item_id, keyring, attributes, secret):
         """Initialize this instance."""
-        self.key = key
-        self.key_name = key_name
+        self.item_id = item_id
+        self.keyring = keyring
+        self.attributes = attributes
         self.secret = secret
 
-    def get_display_name(self):
-        """Return info on the mocked object."""
-        return self.key_name
+    def matches(self, search_attr):
+        """See if this item matches a given search."""
+        for k, v in search_attr.items():
+            if k not in self.attributes:
+                return False
+            if self.attributes[k] != v:
+                return False
+        return True
 
 
 class MockGnomeKeyring(object):
@@ -43,28 +58,33 @@
     def __init__(self):
         """Initialize this instance."""
         self.keyrings = set()
-        self.store = []
+        self.id_counter = itertools.count()
+        self.store = {}
         self.deleted = []
 
+    def _get_next_id(self):
+        """Return the next keyring id."""
+        return self.id_counter.next()
+
     def item_create_sync(self, keyring_name, item_type, key_name, attr,
                          secret, update_if_exists):
-        """Sets a value in the keyring."""
-        # we'll use the attr as the dict key, so make it a tuple
-        key = tuple(attr.items())
-        self.store.append((key, key_name, secret))
+        """Add a key to a keyring."""
+        new_id = self._get_next_id()
+        i = MockKeyringItem(new_id, keyring_name, attr, secret)
+        self.store[new_id] = i
 
     def item_delete_sync(self, keyring_name, item_id):
-        """Makes a list of deleted items."""
-        key, key_name, secret = self.store.pop(item_id)
-        self.deleted.append(key_name)
-
-    def list_item_ids_sync(self, keyring_name):
-        """Return a list of ids for all the items."""
-        return [n for n, v in enumerate(self.store)]
-
-    def item_get_info_sync(self, keyring_name, item_id):
-        """Return an info sync object for the item."""
-        return MockInfoSync(self.store[item_id])
+        """Delete a key from a keyring, and keep a list of deleted keys."""
+        item = self.store.pop(item_id)
+        assert keyring_name == item.keyring
+        self.deleted.append(item)
+
+    def find_items_sync(self, item_type, attr):
+        """Find all keys that match the given attributes."""
+        items = [i for i in self.store.values() if i.matches(attr)]
+        if len(items) == 0:
+            raise gnomekeyring.NoMatchError()
+        return items
 
     def list_keyring_names_sync(self):
         """The keyring you are looking for may be here."""
@@ -79,6 +99,32 @@
         return True
 
 
+class TestTokenNameBuilder(TestCase):
+    """Test the method that builds the token name."""
+
+    def test_get_simple_token_name(self):
+        """A simple token name is built right."""
+        sample_app_name = "UbuntuTwo"
+        sample_hostname = "Darkstar"
+        expected_result = "UbuntuTwo - Darkstar"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+    def test_get_complex_token_name(self):
+        """A complex token name is built right too."""
+        sample_app_name = "Ubuntu Eleven"
+        sample_hostname = "Mate+Cocido"
+        expected_result = "Ubuntu%20Eleven - Mate%2BCocido"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+
 class TestKeyring(TestCase):
     """Test the gnome keyring related functions."""
     def setUp(self):
@@ -89,11 +135,10 @@
         self.patch(gnomekeyring, "create_sync", self.mgk.create_sync)
         self.patch(gnomekeyring, "list_keyring_names_sync",
                                               self.mgk.list_keyring_names_sync)
-        self.patch(gnomekeyring, "list_item_ids_sync",
-                                                   self.mgk.list_item_ids_sync)
-        self.patch(gnomekeyring, "item_get_info_sync",
-                                                   self.mgk.item_get_info_sync)
+        self.patch(gnomekeyring, "find_items_sync", self.mgk.find_items_sync)
         self.patch(gnomekeyring, "item_delete_sync", self.mgk.item_delete_sync)
+        fake_gethostname = build_fake_gethostname("darkstar")
+        self.patch(socket, "gethostname", fake_gethostname)
 
     def test_set_ubuntusso(self):
         """Test that the set method does not erase previous keys."""
@@ -113,3 +158,54 @@
 
         self.assertEqual(len(self.mgk.store), 0)
         self.assertEqual(len(self.mgk.deleted), 1)
+
+    def test_get_credentials(self):
+        """Test that credentials are properly retrieved."""
+        sample_creds = {"name": "sample creds name"}
+        keyring.Keyring("appname").set_ubuntusso_attr(sample_creds)
+
+        result = keyring.Keyring("appname").get_ubuntusso_attr()
+        self.assertEqual(result, sample_creds)
+
+    def test_get_old_cred_found(self):
+        """The method returns a new set of creds if old creds are found."""
+        sample_oauth_token = "sample oauth token"
+        sample_oauth_secret = "sample oauth secret"
+        old_creds = {
+            "oauth_token": sample_oauth_token,
+            "oauth_token_secret": sample_oauth_secret,
+        }
+        secret = urllib.urlencode(old_creds)
+        self.mgk.item_create_sync(keyring.U1_APP_NAME, None,
+                                  keyring.Keyring.KEYRING_NAME,
+                                  keyring.U1_KEY_ATTR,
+                                  secret, True)
+
+        result = keyring.Keyring(keyring.U1_APP_NAME).get_ubuntusso_attr()
+
+        self.assertIn("token", result)
+        self.assertEqual(result["token"], sample_oauth_token)
+        self.assertIn("token_secret", result)
+        self.assertEqual(result["token_secret"], sample_oauth_secret)
+
+    def test_get_old_cred_found_but_not_asked_for(self):
+        """Returns None if old creds are present but the appname is not U1"""
+        sample_oauth_token = "sample oauth token"
+        sample_oauth_secret = "sample oauth secret"
+        old_creds = {
+            "oauth_token": sample_oauth_token,
+            "oauth_token_secret": sample_oauth_secret,
+        }
+        secret = urllib.urlencode(old_creds)
+        self.mgk.item_create_sync(keyring.U1_APP_NAME, None,
+                                  keyring.Keyring.KEYRING_NAME,
+                                  keyring.U1_KEY_ATTR,
+                                  secret, True)
+
+        result = keyring.Keyring("Software Center").get_ubuntusso_attr()
+        self.assertEqual(result, None)
+
+    def test_get_old_cred_not_found(self):
+        """The method returns None if no old nor new credentials found."""
+        result = keyring.Keyring(keyring.U1_APP_NAME).get_ubuntusso_attr()
+        self.assertEqual(result, None)

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-08-26 01:07:41 +0000
+++ ubuntu_sso/tests/test_main.py	2010-08-27 22:32:43 +0000
@@ -31,19 +31,19 @@
 from twisted.internet.defer import Deferred
 from twisted.trial.unittest import TestCase
 
+import ubuntu_sso.keyring
 import ubuntu_sso.main
 
 from contrib.testing.testcase import MementoHandler
 from ubuntu_sso import config, gui
+from ubuntu_sso.keyring import get_token_name, U1_APP_NAME
 from ubuntu_sso.main import (
     AuthenticationError, BadRealmError, blocking, EmailTokenError,
-    except_to_errdict, get_token_name,
-    InvalidEmailError, InvalidPasswordError,
+    except_to_errdict, InvalidEmailError, InvalidPasswordError,
     keyring_get_credentials, keyring_store_credentials, logger,
-    LoginProcessor, NewPasswordError, OLD_KEY_NAME, PING_URL,
+    LoginProcessor, NewPasswordError, PING_URL,
     RegistrationError, ResetPasswordTokenError,
-    SSOCredentials, SSOLogin, SSOLoginProcessor,
-    U1_APP_NAME)
+    SSOCredentials, SSOLogin, SSOLoginProcessor)
 
 
 APP_NAME = 'The Coolest App Ever'
@@ -55,6 +55,7 @@
                               "Can't reset password for this account"
 RESET_TOKEN_INVALID_CONTENT = "AuthToken matching query does not exist."
 EMAIL = '[e-mail]'
+EMAIL_ALREADY_REGISTERED = '[e-mail]'
 EMAIL_TOKEN = 'B2Pgtf'
 HELP = 'help text'
 PASSWORD = 'be4tiFul'
@@ -103,7 +104,10 @@
 
     def register(self, email, password, captcha_id, captcha_solution):
         """Fake registration. Return a fix result."""
-        if captcha_id is None and captcha_solution is None:
+        if email == EMAIL_ALREADY_REGISTERED:
+            return {'status': 'error',
+                    'errors': {'email': 'Email already registered'}}
+        elif captcha_id is None and captcha_solution is None:
             return STATUS_UNKNOWN
         elif captcha_id != CAPTCHA_ID or captcha_solution != CAPTCHA_SOLUTION:
             return STATUS_ERROR
@@ -147,7 +151,10 @@
         """Fake the email validation. Return a fix result."""
         if email_token is None:
             return STATUS_EMAIL_UNKNOWN
-        if email_token != EMAIL_TOKEN:
+        elif email_token == EMAIL_ALREADY_REGISTERED:
+            return {'status': 'error',
+                    'errors': {'email': 'Email already registered'}}
+        elif email_token != EMAIL_TOKEN:
             return STATUS_EMAIL_ERROR
         else:
             return STATUS_EMAIL_OK
@@ -231,7 +238,19 @@
         failure = self.assertRaises(RegistrationError,
                                     self.processor.register_user,
                                     **self.register_kwargs)
-        self.assertIn(STATUS_ERROR['errors'], failure)
+        for k, v in failure.args[0].items():
+            self.assertIn(k, STATUS_ERROR['errors'])
+            self.assertEqual(v, "\n".join(STATUS_ERROR['errors'][k]))
+
+    def test_register_user_if_status_error_with_string_message(self):
+        """Proper error is raised if register fails."""
+        self.register_kwargs['email'] = EMAIL_ALREADY_REGISTERED
+        failure = self.assertRaises(RegistrationError,
+                                    self.processor.register_user,
+                                    **self.register_kwargs)
+        for k, v in failure.args[0].items():
+            self.assertIn(k, {'email': 'Email already registered'})
+            self.assertEqual(v, 'Email already registered')
 
     def test_register_user_if_status_unknown(self):
         """Proper error is raised if register returns an unknown status."""
@@ -261,7 +280,7 @@
         """A email is succesfuy validated in the SSO server."""
         self.login_kwargs['email_token'] = EMAIL_TOKEN  # valid email token
         result = self.processor.validate_email(**self.login_kwargs)
-        self.assertEqual(EMAIL, result, 'email validation was successful.')
+        self.assertEqual(TOKEN, result, 'email validation was successful.')
 
     def test_validate_email_if_status_error(self):
         """Proper error is raised if email validation fails."""
@@ -269,7 +288,19 @@
         failure = self.assertRaises(EmailTokenError,
                                     self.processor.validate_email,
                                     **self.login_kwargs)
-        self.assertIn(STATUS_EMAIL_ERROR['errors'], failure)
+        for k, v in failure.args[0].items():
+            self.assertIn(k, STATUS_EMAIL_ERROR['errors'])
+            self.assertEqual(v, "\n".join(STATUS_EMAIL_ERROR['errors'][k]))
+
+    def test_validate_email_if_status_error_with_string_message(self):
+        """Proper error is raised if register fails."""
+        self.login_kwargs['email_token'] = EMAIL_ALREADY_REGISTERED
+        failure = self.assertRaises(EmailTokenError,
+                                    self.processor.validate_email,
+                                    **self.login_kwargs)
+        for k, v in failure.args[0].items():
+            self.assertIn(k, {'email': 'Email already registered'})
+            self.assertEqual(v, 'Email already registered')
 
     def test_validate_email_if_status_unknown(self):
         """Proper error is raised if email validation returns unknown."""
@@ -413,8 +444,11 @@
             """Assert over token and app_name."""
             self.assertEqual(k, APP_NAME)
             self.assertEqual(v, TOKEN)
+            self.keyring_was_set = True
+            self.keyring_values = k, v
 
         self.patch(ubuntu_sso.main, "keyring_store_credentials", ksc)
+        self.keyring_was_set = False
 
     def tearDown(self):
         """Verify the mocking bus and shut it down."""
@@ -427,8 +461,12 @@
 
     def fake_err_blocking(self, f, a, cb, eb):
         """A fake blocking function that fails."""
-        f()
-        eb(a, except_to_errdict(BlockingSampleException()))
+        try:
+            f()
+        except Exception, e:
+            eb(a, except_to_errdict(e))
+        else:
+            eb(a, except_to_errdict(BlockingSampleException()))
 
     def test_creation(self):
         """Test that the object creation is successful."""
@@ -544,6 +582,7 @@
         def verify(app_name, result):
             self.assertEqual(result, EMAIL)
             self.assertEqual(app_name, APP_NAME)
+            self.assertTrue(self.keyring_was_set, "The keyring should be set")
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
@@ -556,14 +595,20 @@
     def test_login_error(self):
         """Test that the login method fails as expected."""
         d = Deferred()
-        self.create_mock_processor().login(EMAIL, PASSWORD, TOKEN_NAME)
-        self.mocker.result(TOKEN)
+        self.mockprocessorclass = self.mocker.mock()
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+
+        def fake_gtn(*args):
+            """A fake get_token_name that fails."""
+            raise BlockingSampleException()
+
+        self.patch(ubuntu_sso.main, "get_token_name", fake_gtn)
         self.mocker.replay()
 
         def verify(app_name, errdict):
             self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
             d.callback("Ok")
 
         client = SSOLogin(self.mockbusname,
@@ -578,13 +623,14 @@
         d = Deferred()
         self.create_mock_processor().validate_email(EMAIL, PASSWORD,
                                                     EMAIL_TOKEN, TOKEN_NAME)
-        self.mocker.result(EMAIL)
+        self.mocker.result(TOKEN)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
             self.assertEqual(result, EMAIL)
             self.assertEqual(app_name, APP_NAME)
+            self.assertTrue(self.keyring_was_set, "The keyring should be set")
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
@@ -597,17 +643,20 @@
     def test_validate_email_error(self):
         """Test that the validate_email method fails as expected."""
         d = Deferred()
-        expected_result = "expected result"
-
-        self.create_mock_processor().validate_email(EMAIL, PASSWORD,
-                                                    EMAIL_TOKEN, TOKEN_NAME)
-        self.mocker.result(expected_result)
+        self.mockprocessorclass = self.mocker.mock()
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+
+        def fake_gtn(*args):
+            """A fake get_token_name that fails."""
+            raise BlockingSampleException()
+
+        self.patch(ubuntu_sso.main, "get_token_name", fake_gtn)
         self.mocker.replay()
 
         def verify(app_name, errdict):
             self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
             d.callback("Ok")
 
         client = SSOLogin(self.mockbusname,
@@ -794,7 +843,6 @@
         e = TestExceptToErrdictException(*sample_args)
         result = except_to_errdict(e)
         self.assertEqual(result["errtype"], e.__class__.__name__)
-        self.assertEqual(result["errargs"], repr(sample_args))
 
 
 class KeyringCredentialsTestCase(MockerTestCase):
@@ -838,58 +886,6 @@
         token = keyring_get_credentials(APP_NAME)
         self.assertEqual(token, None)
 
-    def test_keyring_get_old_cred_found(self):
-        """The method returns a new set of creds if old creds are found."""
-        sample_oauth_token = "sample oauth token"
-        sample_oauth_secret = "sample oauth secret"
-        old_creds = {
-            "oauth_token": sample_oauth_token,
-            "oauth_token_secret": sample_oauth_secret,
-        }
-
-        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
-        mockKeyringClass(U1_APP_NAME)
-        mockKeyring = self.mocker.mock()
-        self.mocker.result(mockKeyring)
-        mockKeyring.get_ubuntusso_attr()
-        self.mocker.result(None)
-
-        mockKeyringClass(OLD_KEY_NAME)
-        mockKeyring2 = self.mocker.mock()
-        self.mocker.result(mockKeyring2)
-        mockKeyring2.get_ubuntusso_attr()
-        self.mocker.result(old_creds)
-
-        self.mocker.replay()
-
-        new_creds = keyring_get_credentials(U1_APP_NAME)
-        self.assertIn("token", new_creds)
-        self.assertEqual(new_creds["token"], sample_oauth_token)
-        self.assertIn("token_secret", new_creds)
-        self.assertEqual(new_creds["token_secret"], sample_oauth_secret)
-        self.assertIn("token_name", new_creds)
-        self.assertEqual(new_creds["token_name"], OLD_KEY_NAME)
-
-    def test_keyring_get_old_cred_not_found(self):
-        """The method returns None if no old nor new credentials found."""
-        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
-        mockKeyringClass(U1_APP_NAME)
-        mockKeyring = self.mocker.mock()
-        self.mocker.result(mockKeyring)
-        mockKeyring.get_ubuntusso_attr()
-        self.mocker.result(None)
-
-        mockKeyringClass(OLD_KEY_NAME)
-        mockKeyring2 = self.mocker.mock()
-        self.mocker.result(mockKeyring2)
-        mockKeyring2.get_ubuntusso_attr()
-        self.mocker.result(None)
-
-        self.mocker.replay()
-
-        token = keyring_get_credentials(U1_APP_NAME)
-        self.assertEqual(token, None)
-
 
 class RegisterSampleException(Exception):
     """A mock exception thrown just when testing."""