Merge lp:~nataliabidart/ubuntu-sso-client/restore-register-api into lp:ubuntu-sso-client

[Natalia Bidart]

- Restoring former API for register_user. Added a new method call register_with_name to ensure no API is broke (LP: #709494).

To properly test please use the SRU instructions in the attached bug report. Thanks!

Unmerged revisions

646. By Natalia Bidart on 2011-03-29

Making UI using the new register_with_name backend metod.

645. By Natalia Bidart on 2011-03-29

Restoring former API for register_user. Added a new method call
register_with_name to ensure no API is broke (LP: #709494).

644. By Natalia Bidart on 2011-03-24

- Register now uses the 'displayname' field to pass it on to SSO as display name (LP: #709494).

643. By Natalia Bidart on 2010-12-16

[release] v1.0.8

642. By Natalia Bidart on 2010-12-16

 * Avoid generating an extra token when attempting to validate a user account (LP: #687523).

641. By Natalia Bidart on 2010-11-04

[release] 1.0.7

640. By Alejandro J. Cura on 2010-11-04

Store credentials on the keyring *only* from the main thread (LP: #656545)

639. By Natalia Bidart on 2010-11-03

The verify email page should be always built, not only on registration.

638. By Natalia Bidart on 2010-11-03

[release] 1.0.6.

637. By Natalia Bidart on 2010-11-02

* Added a new DBus signal UserNotValidated to indicate when a user is registered but not validated (LP: #667899).
* Added new workflow so email validation is requested if necessary.

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2011-01-11 19:13:19 +0000
+++ bin/ubuntu-sso-login	2011-03-29 17:35:28 +0000
@@ -21,6 +21,7 @@
 
 """Run the dbus service for UserManagement and ApplicationCredentials."""
 
+<<<<<<< TREE
 # Invalid name "ubuntu-sso-login", pylint: disable=C0103
 
 # import decimal even if we don't need it, pylint: disable=W0611
@@ -41,6 +42,26 @@
 #     val = globals()[globalname]
 # KeyError: 'ROUND_CEiLiNG'
 
+=======
+# import decimal even if we don't need it.
+import decimal
+# This is a workaround for LP: #467397. Some module in our depency chain sets
+# the locale and imports decimal, and that generates the following trace:
+# Traceback (most recent call last):
+#   File "/usr/lib/ubuntu-sso-client/ubuntu-sso-login", line 33
+#     from ubuntu_sso.main import SSOLogin, SSOCredentials
+#   File "/usr/lib/pymodules/python2.6/ubuntu_sso/main.py", line 42
+#     from lazr.restfulclient.resource import ServiceRoot
+#   File "/usr/lib/python2.6/dist-packages/lazr/restfulclient/resource.py",
+# line 34
+#     import simplejson
+#   File "/usr/lib/pymodules/python2.6/simplejson/__init__.py", line 109
+#     from decimal import Decimal
+#   File "/usr/lib/python2.6/decimal.py", line 3649, in <module>
+#     val = globals()[globalname]
+# KeyError: 'ROUND_CEiLiNG'
+
+>>>>>>> MERGE-SOURCE
 import signal
 import sys
 
@@ -67,6 +88,7 @@
 
 
 def sighup_handler(*a, **kw):
+<<<<<<< TREE
     """Stop the service."""
     # This handler may be called in any thread, so is not thread safe.
     # See the link below for info:
@@ -74,6 +96,15 @@
     #
     # gtk.main_quit and the logger methods are safe to be called from any
     # thread. Just don't call other random stuff here.
+=======
+    """Stop the service."""
+    # This handler may be called in any thread, so is not thread safe.
+    # See the link below for info:
+    # www.listware.net/201004/gtk-devel-list/115067-unix-signals-in-glib.html
+    #
+    # gtk.main_quit and the logger methods are safe to be called from any thread.
+    # Just don't call other random stuff here.
+>>>>>>> MERGE-SOURCE
     logger.info("Stoping Ubuntu SSO login manager since SIGHUP was received.")
     gtk.main_quit()
 
 
=== modified file 'data/ui.glade'
--- data/ui.glade	2010-11-29 16:04:26 +0000
+++ data/ui.glade	2011-03-29 17:35:28 +0000
@@ -279,16 +279,42 @@
       </object>
       <packing>
         <property name="expand">False</property>
+<<<<<<< TREE
         <property name="position">6</property>
       </packing>
     </child>
     <child>
       <object class="GtkHBox" id="hbox2">
-        <property name="visible">True</property>
+=======
+        <property name="position">10</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkLabel" id="tc_warning_label">
+        <property name="visible">True</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="position">11</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHBox" id="hbox2">
+>>>>>>> MERGE-SOURCE
+        <property name="visible">True</property>
+<<<<<<< TREE
         <property name="spacing">5</property>
+=======
+>>>>>>> MERGE-SOURCE
         <child>
+<<<<<<< TREE
           <object class="GtkHButtonBox" id="hbuttonbox9">
+=======
+          <object class="GtkLinkButton" id="login_button">
+            <property name="label">login button</property>
+>>>>>>> MERGE-SOURCE
             <property name="visible">True</property>
+<<<<<<< TREE
             <property name="layout_style">start</property>
             <child>
               <object class="GtkLinkButton" id="login_button">
@@ -305,15 +331,26 @@
                 <property name="position">0</property>
               </packing>
             </child>
+=======
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="relief">none</property>
+            <signal name="clicked" handler="on_sign_in_button_clicked" swapped="no"/>
+>>>>>>> MERGE-SOURCE
           </object>
           <packing>
             <property name="expand">False</property>
+<<<<<<< TREE
+=======
+            <property name="fill">True</property>
+>>>>>>> MERGE-SOURCE
             <property name="position">0</property>
           </packing>
         </child>
         <child>
           <object class="GtkHButtonBox" id="hbuttonbox1">
             <property name="visible">True</property>
+<<<<<<< TREE
             <property name="spacing">5</property>
             <property name="layout_style">end</property>
             <child>
@@ -345,6 +382,40 @@
                 <property name="position">1</property>
               </packing>
             </child>
+=======
+            <property name="can_focus">False</property>
+            <property name="spacing">5</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="join_cancel_button">
+                <property name="label">gtk-cancel</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="join_ok_button">
+                <property name="label">gtk-go-forward</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+                <signal name="clicked" handler="on_join_ok_button_clicked" swapped="no"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+>>>>>>> MERGE-SOURCE
           </object>
           <packing>
             <property name="expand">False</property>
@@ -355,10 +426,16 @@
       </object>
       <packing>
         <property name="expand">False</property>
+<<<<<<< TREE
         <property name="pack_type">end</property>
         <property name="position">7</property>
       </packing>
     </child>
+=======
+        <property name="position">12</property>
+      </packing>
+    </child>
+>>>>>>> MERGE-SOURCE
   </object>
   <object class="GtkVBox" id="processing_vbox">
     <property name="visible">True</property>
 
=== modified file 'run-tests'
--- run-tests	2011-03-18 09:30:20 +0000
+++ run-tests	2011-03-29 17:35:28 +0000
@@ -15,9 +15,16 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+<<<<<<< TREE
 if [ $# -ne 0 ]; then
     # an extra argument was given
     MODULE="$@"
+=======
+`which xvfb-run` ./contrib/test "$@"
+pylint ubuntu_sso
+if [ -x `which pep8` ]; then
+    pep8 --repeat bin/ contrib/ ubuntu_sso/
+>>>>>>> MERGE-SOURCE
 else
     # run all tests, useful for tarmac and reviews
     MODULE="ubuntu_sso"
 
=== modified file 'setup.py'
--- setup.py	2011-03-22 22:32:28 +0000
+++ setup.py	2011-03-29 17:35:28 +0000
@@ -86,7 +86,11 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
+<<<<<<< TREE
     version='1.1.12',
+=======
+    version='1.0.8',
+>>>>>>> MERGE-SOURCE
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',
 
=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2011-03-16 01:36:07 +0000
+++ ubuntu_sso/gtk/gui.py	2011-03-29 17:35:28 +0000
@@ -30,7 +30,13 @@
 
 import dbus
 import gettext
+<<<<<<< TREE
 import gtk
+=======
+import gobject
+import gtk  # pylint: disable=W0403
+import webkit
+>>>>>>> MERGE-SOURCE
 import xdg
 
 from dbus.mainloop.glib import DBusGMainLoop
@@ -125,7 +131,7 @@
         self.is_password = is_password
         self.warning = None
 
-        super(LabeledEntry, self).__init__(*args, **kwargs)
+        gtk.Entry.__init__(self, *args, **kwargs)
 
         self.set_width_chars(DEFAULT_WIDTH)
         self._set_label(self, None)
@@ -161,7 +167,7 @@
 
     def get_text(self):
         """Get text only if it's not the label nor empty."""
-        result = super(LabeledEntry, self).get_text()
+        result = gtk.Entry.get_text(self)
         if result == self.label or result.isspace():
             result = ''
         return result
@@ -255,6 +261,7 @@
         self.app_label = '<b>%s</b>' % self.app_name
         self.tc_url = tc_url
         self.help_text = help_text
+<<<<<<< TREE
         self.login_only = login_only
 
         self.close_callback = NO_OP
@@ -264,6 +271,11 @@
 
         self.user_email = None
         self.user_password = None
+=======
+        self.close_callback = close_callback
+        self.user_email = None
+        self.user_password = None
+>>>>>>> MERGE-SOURCE
 
         ui_filename = get_data_file('ui.glade')
         builder = gtk.Builder()
@@ -325,7 +337,35 @@
                       self.request_password_token_vbox,
                       self.set_new_password_vbox)
 
+<<<<<<< TREE
         self._append_pages()
+=======
+        self._append_page(self._build_processing_page())
+        self._append_page(self._build_success_page())
+        self._append_page(self._build_login_page())
+        self._append_page(self._build_request_password_token_page())
+        self._append_page(self._build_set_new_password_page())
+        self._append_page(self._build_verify_email_page())
+
+        window_size = None
+        if not login_only:
+            window_size = (550, 500)
+            self._append_page(self._build_enter_details_page())
+            self._append_page(self._build_tc_page())
+            self.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)
+>>>>>>> MERGE-SOURCE
 
         self._signals = {
             'CaptchaGenerated':
@@ -750,12 +790,27 @@
         if self.window is not None:
             self.window.hide()
 
+<<<<<<< TREE
         # process any pending events before callbacking with result
         while gtk.events_pending():
             gtk.main_iteration()
 
         if not self._done:
             self.user_cancellation_callback(self.app_name)
+=======
+        # process any pending events before emitting signals
+        while gtk.events_pending():
+            gtk.main_iteration()
+
+        if len(args) > 0 and args[0] in self.cancels:
+            self.window.emit(SIG_USER_CANCELATION, self.app_name)
+        elif len(self._gtk_signal_log) > 0:
+            signal = self._gtk_signal_log[-1][0]
+            args = self._gtk_signal_log[-1][1:]
+            self.window.emit(signal, *args)
+        else:
+            self.window.emit(SIG_USER_CANCELATION, self.app_name)
+>>>>>>> MERGE-SOURCE
 
         # call user defined callback
         logger.info('Calling custom close_callback %r with params %r, %r',
@@ -816,12 +871,21 @@
         self.user_email = email1
         self.user_password = password1
 
+<<<<<<< TREE
         logger.info('Calling register_user with email %r, password <hidden>,' \
                     ' name %r, captcha_id %r and captcha_solution %r.', email1,
                     name, self._captcha_id, captcha_solution)
         f = self.backend.register_user
         f(self.app_name, email1, password1, name,
           self._captcha_id, captcha_solution,
+=======
+        logger.info('Calling register_with_name with email %r, password, '
+                    '<hidden> name %r, captcha_id %r and captcha_solution %r.',
+                    email1, name, self._captcha_id, captcha_solution)
+        f = self.backend.register_with_name
+        f(self.app_name, email1, password1, name,
+          self._captcha_id, captcha_solution,
+>>>>>>> MERGE-SOURCE
           reply_handler=NO_OP, error_handler=NO_OP)
 
     def on_verify_token_button_clicked(self, *args, **kwargs):
@@ -1122,6 +1186,11 @@
         self.on_user_registered(app_name, email)
 
     @log_call
+    def on_user_not_validated(self, app_name, email, *args, **kwargs):
+        """User was not validated."""
+        self.on_user_registered(app_name, email)
+
+    @log_call
     def on_password_reset_token_sent(self, app_name, email, *args, **kwargs):
         """Password reset token was successfully sent."""
         msg = self.SET_NEW_PASSWORD_LABEL % {'email': email}
 
=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2011-03-16 01:36:07 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2011-03-29 17:35:28 +0000
@@ -51,7 +51,7 @@
         self._args = args
         self._kwargs = kwargs
         self._called = {}
-        for i in ('generate_captcha', 'login', 'register_user',
+        for i in ('generate_captcha', 'login', 'register_with_name',
                   'validate_email', 'request_password_reset_token',
                   'set_new_password'):
             setattr(self, i, self._record_call(i))
@@ -709,8 +709,8 @@
         """Clicking 'join_ok_button' sends info to backend using 'register'."""
         self.click_join_with_valid_data()
 
-        # assert register_user was called
-        expected = 'register_user'
+        # assert register_with_name was called
+        expected = 'register_with_name'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
                          ((APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
@@ -866,6 +866,7 @@
         self.ui.join_ok_button.clicked()
         self.assertTrue(self._called)
 
+<<<<<<< TREE
     def test_user_and_pass_are_cached(self):
         """Username and password are temporarly cached for further use."""
         self.click_join_with_valid_data()
@@ -880,6 +881,14 @@
                                           self.ui.CAPTCHA_LOAD_ERROR)
         self.assertEqual(self._called, ((), {}))
 
+=======
+    def test_user_and_pass_are_cached(self):
+        """Username and password are temporarly cached for further use."""
+        self.click_join_with_valid_data()
+        self.assertEqual(self.ui.user_email, EMAIL)
+        self.assertEqual(self.ui.user_password, PASSWORD)
+
+>>>>>>> MERGE-SOURCE
 
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (with no t&c link)."""
@@ -1282,20 +1291,37 @@
         self.assert_warnings_visibility()
 
 
-class VerifyEmailLoginOnlyTestCase(VerifyEmailTestCase):
-    """Test suite for the user login (verify email page)."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
-                  login_only=True)
-
-
-class VerifyEmailValidationLoginOnlyTestCase(VerifyEmailValidationTestCase):
-    """Test suite for the user login validation (verify email page)."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
-                  login_only=True)
-
-
+<<<<<<< TREE
+class VerifyEmailLoginOnlyTestCase(VerifyEmailTestCase):
+    """Test suite for the user login (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
+                  login_only=True)
+
+
+class VerifyEmailValidationLoginOnlyTestCase(VerifyEmailValidationTestCase):
+    """Test suite for the user login validation (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
+                  login_only=True)
+
+
+=======
+class VerifyEmailLoginOnlyTestCase(VerifyEmailTestCase):
+    """Test suite for the user login (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_uri=TC_URI, help_text=HELP_TEXT,
+                  login_only=True)
+
+
+class VerifyEmailValidationLoginOnlyTestCase(VerifyEmailValidationTestCase):
+    """Test suite for the user login validation (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_uri=TC_URI, help_text=HELP_TEXT,
+                  login_only=True)
+
+
+>>>>>>> MERGE-SOURCE
 class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration  validations."""
 
@@ -1312,8 +1338,13 @@
 
         self.assert_correct_entry_warning(self.ui.name_entry,
                                           self.ui.FIELD_REQUIRED)
+<<<<<<< TREE
         self.assertNotIn('register_user', self.ui.backend._called)
 
+=======
+        self.assertNotIn('register_with_name', self.ui.backend._called)
+
+>>>>>>> MERGE-SOURCE
     def test_warning_is_shown_if_empty_email(self):
         """A warning message is shown if emails are empty."""
         self.ui.email1_entry.set_text('')
@@ -1325,7 +1356,7 @@
                                           self.ui.FIELD_REQUIRED)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_email_mismatch(self):
         """A warning message is shown if emails doesn't match."""
@@ -1338,7 +1369,7 @@
                                           self.ui.EMAIL_MISMATCH)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.EMAIL_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_invalid_email(self):
         """A warning message is shown if email is invalid."""
@@ -1351,7 +1382,7 @@
                                           self.ui.EMAIL_INVALID)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.EMAIL_INVALID)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_password_help_is_always_shown(self):
         """Password help text is correctly displayed."""
@@ -1359,7 +1390,7 @@
                         'password help text is visible.')
         self.assertEqual(self.ui.password_help_label.get_text(),
                          self.ui.PASSWORD_HELP)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_password_mismatch(self):
         """A warning message is shown if password doesn't match."""
@@ -1372,7 +1403,7 @@
                                           self.ui.PASSWORD_MISMATCH)
         self.assert_correct_entry_warning(self.ui.password2_entry,
                                           self.ui.PASSWORD_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_password_too_weak(self):
         """A warning message is shown if password is too weak."""
@@ -1387,7 +1418,7 @@
                                               self.ui.PASSWORD_TOO_WEAK)
             self.assert_correct_entry_warning(self.ui.password2_entry,
                                               self.ui.PASSWORD_TOO_WEAK)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_tc_not_accepted(self):
         """A warning message is shown if TC are not accepted."""
@@ -1398,7 +1429,7 @@
 
         self.assert_correct_label_warning(self.ui.tc_warning_label,
                                           self.ui.TC_NOT_ACCEPTED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_not_captcha_solution(self):
         """A warning message is shown if TC are not accepted."""
@@ -1409,7 +1440,7 @@
 
         self.assert_correct_entry_warning(self.ui.captcha_solution_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_no_warning_messages_if_valid_data(self):
         """No warning messages are shown if the data is valid."""
@@ -1548,6 +1579,7 @@
         self.ui.login_ok_button.clicked()
         self.assertTrue(self._called)
 
+<<<<<<< TREE
     def test_user_and_pass_are_cached(self):
         """Username and password are temporarly cached for further use."""
         self.click_connect_with_valid_data()
@@ -1580,6 +1612,14 @@
 
         self.assertEqual(self._called, ((), {}))
 
+=======
+    def test_user_and_pass_are_cached(self):
+        """Username and password are temporarly cached for further use."""
+        self.click_connect_with_valid_data()
+        self.assertEqual(self.ui.user_email, EMAIL)
+        self.assertEqual(self.ui.user_password, PASSWORD)
+
+>>>>>>> MERGE-SOURCE
 
 class LoginValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user login validation."""
 
=== modified file 'ubuntu_sso/keyring/linux.py'
--- ubuntu_sso/keyring/linux.py	2011-03-03 15:19:29 +0000
+++ ubuntu_sso/keyring/linux.py	2011-03-29 17:35:28 +0000
@@ -29,6 +29,7 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntu_sso.logger import setup_logging
+<<<<<<< TREE
 from ubuntu_sso.utils.txsecrets import SecretService
 from ubuntu_sso.keyring import (
     get_token_name,
@@ -38,17 +39,58 @@
 
 
 logger = setup_logging("ubuntu_sso.keyring")
+=======
+
+
+logger = setup_logging("ubuntu_sso.keyring")
+TOKEN_SEPARATOR = ' @ '
+SEPARATOR_REPLACEMENT = ' AT '
+
+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_old_token_name(app_name):
+    """Build the token name (old style)."""
+    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)
+
+
+def get_token_name(app_name):
+    """Build the token name."""
+    computer_name = socket.gethostname()
+    computer_name = computer_name.replace(TOKEN_SEPARATOR,
+                                          SEPARATOR_REPLACEMENT)
+    return TOKEN_SEPARATOR.join((app_name, computer_name)).encode('utf-8')
+>>>>>>> MERGE-SOURCE
 
 
 class Keyring(object):
     """A Keyring for a given application name."""
 
+<<<<<<< TREE
     def __init__(self):
         """Initialize this instance."""
         self.service = SecretService()
 
     @inlineCallbacks
     def _find_keyring_item(self, app_name, attr=None):
+=======
+    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 _find_keyring_item(self, attr=None):
+>>>>>>> MERGE-SOURCE
         """Return the keyring item or None if not found."""
         if attr is None:
             logger.debug("getting attr")
@@ -75,11 +117,19 @@
         # Creates the secret from the credentials
         secret = urllib.urlencode(cred)
 
+<<<<<<< TREE
         attr = self._get_keyring_attr(app_name)
+=======
+>>>>>>> MERGE-SOURCE
         # Add our SSO credentials to the keyring
+<<<<<<< TREE
         yield self.service.open_session()
         collection = yield self.service.get_default_collection()
         yield collection.create_item(app_name, attr, secret, True)
+=======
+        gnomekeyring.item_create_sync(None, gnomekeyring.ITEM_GENERIC_SECRET,
+                        self.app_name, self._get_keyring_attr(), secret, True)
+>>>>>>> MERGE-SOURCE
 
     @inlineCallbacks
     def _migrate_old_token_name(self, app_name):
 
=== modified file 'ubuntu_sso/keyring/tests/test_linux.py'
--- ubuntu_sso/keyring/tests/test_linux.py	2011-03-18 09:30:20 +0000
+++ ubuntu_sso/keyring/tests/test_linux.py	2011-03-29 17:35:28 +0000
@@ -65,6 +65,7 @@
         return True
 
 
+<<<<<<< TREE
 class MockCollection(object):
     """A collection of items containing secrets."""
 
@@ -114,6 +115,44 @@
         if len(self.collections) == 0:
             self.create_collection("default")
         return defer.succeed(self.collections["default"])
+=======
+class MockGnomeKeyring(object):
+    """A mock keyring that stores keys according to a given attr."""
+
+    def __init__(self):
+        """Initialize this instance."""
+        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):
+        """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):
+        """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 is_available(self):
+        """A very available keyring."""
+        return True
+>>>>>>> MERGE-SOURCE
 
 
 class TestTokenNameBuilder(TestCase):
@@ -160,9 +199,17 @@
 
     def setUp(self):
         """Initialize the mock used in these tests."""
+<<<<<<< TREE
         self.mock_service = None
         self.service = self.patch(keyring, "SecretService",
                                   self.get_mock_service)
+=======
+        self.mgk = MockGnomeKeyring()
+        self.patch(gnomekeyring, "item_create_sync", self.mgk.item_create_sync)
+        self.patch(gnomekeyring, "is_available", self.mgk.is_available)
+        self.patch(gnomekeyring, "find_items_sync", self.mgk.find_items_sync)
+        self.patch(gnomekeyring, "item_delete_sync", self.mgk.item_delete_sync)
+>>>>>>> MERGE-SOURCE
         fake_gethostname = build_fake_gethostname("darkstar")
         self.patch(socket, "gethostname", fake_gethostname)
 
@@ -177,6 +224,7 @@
         """Test that the set method does not erase previous keys."""
         sample_creds = {"name": "sample creds name"}
         sample_creds2 = {"name": "sample creds name 2"}
+<<<<<<< TREE
         kr = keyring.Keyring()
         yield kr.set_credentials("appname", sample_creds)
         yield kr.set_credentials("appname", sample_creds2)
@@ -186,6 +234,15 @@
 
     @inlineCallbacks
     def test_delete_credentials(self):
+=======
+        keyring.Keyring("appname").set_ubuntusso_attr(sample_creds)
+        keyring.Keyring("appname").set_ubuntusso_attr(sample_creds2)
+
+        self.assertEqual(len(self.mgk.store), 2)
+        self.assertEqual(len(self.mgk.deleted), 0)
+
+    def test_delete_ubuntusso(self):
+>>>>>>> MERGE-SOURCE
         """Test that a given key is deleted."""
         sample_creds = {"name": "sample creds name"}
         kr = keyring.Keyring()
@@ -225,11 +282,22 @@
             "oauth_token": sample_oauth_token,
             "oauth_token_secret": sample_oauth_secret,
         }
+<<<<<<< TREE
         u1kr = common_keyring.UbuntuOneOAuthKeyring()
         yield u1kr.set_credentials(keyring.U1_APP_NAME, old_creds)
 
         kr = keyring.Keyring()
         result = yield kr.get_credentials(keyring.U1_APP_NAME)
+=======
+        secret = urllib.urlencode(old_creds)
+        self.mgk.item_create_sync(None, None,
+                                  keyring.U1_APP_NAME,
+                                  keyring.U1_KEY_ATTR,
+                                  secret, True)
+
+        result = keyring.Keyring(keyring.U1_APP_NAME).get_ubuntusso_attr()
+
+>>>>>>> MERGE-SOURCE
         self.assertIn("token", result)
         self.assertEqual(result["token"], sample_oauth_token)
         self.assertIn("token_secret", result)
@@ -244,8 +312,16 @@
             "oauth_token": sample_oauth_token,
             "oauth_token_secret": sample_oauth_secret,
         }
+<<<<<<< TREE
         u1kr = common_keyring.UbuntuOneOAuthKeyring()
         yield u1kr.set_credentials(keyring.U1_APP_NAME, old_creds)
+=======
+        secret = urllib.urlencode(old_creds)
+        self.mgk.item_create_sync(None, None,
+                                  keyring.U1_APP_NAME,
+                                  keyring.U1_KEY_ATTR,
+                                  secret, True)
+>>>>>>> MERGE-SOURCE
 
         kr = keyring.Keyring()
         result = yield kr.get_credentials("Software Center")
 
=== modified file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	2011-03-29 14:16:36 +0000
+++ ubuntu_sso/main/linux.py	2011-03-29 17:35:28 +0000
@@ -45,6 +45,279 @@
 
 
 logger = setup_logging("ubuntu_sso.main")
+<<<<<<< TREE
+=======
+PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+SERVICE_URL = "https://login.ubuntu.com/api/1.0"
+NO_OP = lambda *args, **kwargs: None
+
+
+class NoDefaultConfigError(Exception):
+    """No default section in configuration file"""
+
+
+class BadRealmError(Exception):
+    """Realm must be a URL."""
+
+
+class InvalidEmailError(Exception):
+    """The email is not valid."""
+
+
+class InvalidPasswordError(Exception):
+    """The password is not valid.
+
+    Must provide at least 8 characters, one upper case, one number.
+    """
+
+
+class RegistrationError(Exception):
+    """The registration failed."""
+
+
+class AuthenticationError(Exception):
+    """The authentication failed."""
+
+
+class EmailTokenError(Exception):
+    """The email token is not valid."""
+
+
+class ResetPasswordTokenError(Exception):
+    """The token for password reset could not be generated."""
+
+
+class NewPasswordError(Exception):
+    """The new password could not be set."""
+
+
+def keyring_store_credentials(app_name, credentials, callback, *cb_args):
+    """Store the credentials in the keyring."""
+
+    def _inner():
+        """Store the credentials, and trigger the callback."""
+        logger.info('keyring_store_credentials: app_name "%s".', app_name)
+        Keyring(app_name).set_ubuntusso_attr(credentials)
+        callback(*cb_args)
+
+    gobject.idle_add(_inner)
+
+
+def keyring_get_credentials(app_name):
+    """Get the credentials from the keyring or None if not there."""
+    creds = Keyring(app_name).get_ubuntusso_attr()
+    logger.info('keyring_get_credentials: app_name "%s", resulting credentials'
+                ' is not None? %r', app_name, creds is not None)
+    return creds
+
+
+class SSOLoginProcessor(object):
+    """Login and register users using the Ubuntu Single Sign On service."""
+
+    def __init__(self, sso_service_class=None):
+        """Create a new SSO login processor."""
+        if sso_service_class is None:
+            self.sso_service_class = ServiceRoot
+        else:
+            self.sso_service_class = sso_service_class
+
+        self.service_url = os.environ.get('USSOC_SERVICE_URL', SERVICE_URL)
+
+    def _valid_email(self, email):
+        """Validate the given email."""
+        return email is not None and '@' in email
+
+    def _valid_password(self, password):
+        """Validate the given password."""
+        res = (len(password) > 7 and  # at least 8 characters
+               re.search('[A-Z]', password) and  # one upper case
+               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',
+                     filename)
+        sso_service = self.sso_service_class(None, self.service_url)
+        captcha = sso_service.captchas.new()
+
+        # download captcha and save to 'filename'
+        logger.debug('generate_captcha: server answered: %r', captcha)
+        try:
+            res = urllib2.urlopen(captcha['image_url'])
+            with open(filename, 'wb') as f:
+                f.write(res.read())
+        except:
+            msg = 'generate_captcha crashed while downloading the image.'
+            logger.exception(msg)
+            raise
+
+        return captcha['captcha_id']
+
+    def register_with_name(self, email, password, displayname,
+                      captcha_id, captcha_solution):
+        """Register a new user with 'email' and 'password'."""
+        logger.debug('register_with_name: email: %r password: <hidden>, '
+                     'displayname: %r, captcha_id: %r, captcha_solution: %r',
+                     email, displayname, captcha_id, captcha_solution)
+        sso_service = self.sso_service_class(None, self.service_url)
+        if not self._valid_email(email):
+            logger.error('register_with_name: InvalidEmailError for email: %r',
+                         email)
+            raise InvalidEmailError()
+        if not self._valid_password(password):
+            logger.error('register_with_name: InvalidPasswordError')
+            raise InvalidPasswordError()
+
+        result = sso_service.registrations.register(
+                    email=email, password=password,
+                    displayname=displayname,
+                    captcha_id=captcha_id,
+                    captcha_solution=captcha_solution)
+        logger.info('register_with_name: email: %r result: %r', email, result)
+
+        if result['status'] == 'error':
+            errorsdict = self._format_webservice_errors(result['errors'])
+            raise RegistrationError(errorsdict)
+        elif result['status'] != 'ok':
+            raise RegistrationError('Received unknown status: %s' % result)
+        else:
+            return email
+
+    def register_user(self, email, password,
+                      captcha_id, captcha_solution):
+        """Register a new user with 'email' and 'password'."""
+        logger.debug('register_user: email: %r password: <hidden>, '
+                     'captcha_id: %r, captcha_solution: %r',
+                     email, captcha_id, captcha_solution)
+        res = self.register_with_name(email, password, displayname='',
+                                      captcha_id=captcha_id,
+                                      captcha_solution=captcha_solution)
+        return res
+
+    def login(self, email, password, token_name):
+        """Login a user with 'email' and 'password'."""
+        logger.debug('login: email: %r password: <hidden>, token_name: %r',
+                     email, token_name)
+        basic = BasicHttpAuthorizer(email, password)
+        sso_service = self.sso_service_class(basic, self.service_url)
+        service = sso_service.authentications.authenticate
+
+        try:
+            credentials = service(token_name=token_name)
+        except HTTPError:
+            logger.exception('login failed with:')
+            raise AuthenticationError()
+
+        logger.debug('login: authentication successful! consumer_key: %r, ' \
+                     'token_name: %r', credentials['consumer_key'], token_name)
+        return credentials
+
+    def is_validated(self, token, sso_service=None):
+        """Return if user with 'email' and 'password' is validated."""
+        logger.debug('is_validated: requesting accounts.me() info.')
+        if sso_service is None:
+            oauth_token = oauth.OAuthToken(token['token'],
+                                           token['token_secret'])
+            authorizer = OAuthAuthorizer(token['consumer_key'],
+                                         token['consumer_secret'],
+                                         oauth_token)
+            sso_service = self.sso_service_class(authorizer, self.service_url)
+
+        me_info = sso_service.accounts.me()
+        key = 'preferred_email'
+        result = key in me_info and me_info[key] != None
+
+        logger.info('is_validated: consumer_key: %r, result: %r.',
+                    token['consumer_key'], result)
+        return result
+
+    def validate_email(self, email, password, email_token, token_name):
+        """Validate an email token for user with 'email' and 'password'."""
+        logger.debug('validate_email: email: %r password: <hidden>, '
+                     'email_token: %r, token_name: %r.',
+                     email, email_token, token_name)
+        token = self.login(email=email, password=password,
+                           token_name=token_name)
+
+        oauth_token = oauth.OAuthToken(token['token'], token['token_secret'])
+        authorizer = OAuthAuthorizer(token['consumer_key'],
+                                     token['consumer_secret'],
+                                     oauth_token)
+        sso_service = self.sso_service_class(authorizer, self.service_url)
+        result = sso_service.accounts.validate_email(email_token=email_token)
+        logger.info('validate_email: email: %r result: %r', email, result)
+        if 'errors' in result:
+            errorsdict = self._format_webservice_errors(result['errors'])
+            raise EmailTokenError(errorsdict)
+        elif 'email' in result:
+            return token
+        else:
+            raise EmailTokenError('Received invalid reply: %s' % result)
+
+    def request_password_reset_token(self, email):
+        """Request a token to reset the password for the account 'email'."""
+        sso_service = self.sso_service_class(None, self.service_url)
+        service = sso_service.registrations.request_password_reset_token
+        try:
+            result = service(email=email)
+        except HTTPError, e:
+            logger.exception('request_password_reset_token failed with:')
+            raise ResetPasswordTokenError(e.content.split('\n')[0])
+
+        if result['status'] == 'ok':
+            return email
+        else:
+            raise ResetPasswordTokenError('Received invalid reply: %s' %
+                                          result)
+
+    def set_new_password(self, email, token, new_password):
+        """Set a new password for the account 'email' to be 'new_password'.
+
+        The 'token' has to be the one resulting from a call to
+        'request_password_reset_token'.
+
+        """
+        sso_service = self.sso_service_class(None, self.service_url)
+        service = sso_service.registrations.set_new_password
+        try:
+            result = service(email=email, token=token,
+                             new_password=new_password)
+        except HTTPError, e:
+            logger.exception('set_new_password failed with:')
+            raise NewPasswordError(e.content.split('\n')[0])
+
+        if result['status'] == 'ok':
+            return email
+        else:
+            raise NewPasswordError('Received invalid reply: %s' % result)
+
+
+def except_to_errdict(e):
+    """Turn an exception into a dictionary to return thru DBus."""
+    result = {
+        "errtype": e.__class__.__name__,
+    }
+    if len(e.args) == 0:
+        result["message"] = e.__class__.__doc__
+    elif isinstance(e.args[0], dict):
+        result.update(e.args[0])
+    elif isinstance(e.args[0], basestring):
+        result["message"] = e.args[0]
+
+    return result
+>>>>>>> MERGE-SOURCE
 
 
 def blocking(f, app_name, result_cb, error_cb):
@@ -72,7 +345,13 @@
         """Initiate the Login object."""
         dbus.service.Object.__init__(self, object_path=object_path,
                                      bus_name=bus_name)
+<<<<<<< TREE
         self.root = SSOLoginRoot(sso_login_processor_class, sso_service_class)
+=======
+        self.sso_login_processor_class = sso_login_processor_class
+        self.processor = self.sso_login_processor_class(
+                                    sso_service_class=sso_service_class)
+>>>>>>> MERGE-SOURCE
 
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -91,9 +370,17 @@
                          in_signature='ss')
     def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
+<<<<<<< TREE
         self.root.generate_captcha(app_name, filename, blocking,
                                    self.CaptchaGenerated,
                                    self.CaptchaGenerationError)
+=======
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.generate_captcha(filename)
+        blocking(f, app_name, self.CaptchaGenerated,
+                 self.CaptchaGenerationError)
+>>>>>>> MERGE-SOURCE
 
     # register_user signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -113,10 +400,29 @@
     def register_user(self, app_name, email, password, name,
                       captcha_id, captcha_solution):
         """Call the matching method in the processor."""
+<<<<<<< TREE
         self.root.register_user(app_name, email, password, name, captcha_id,
                                 captcha_solution, blocking,
                                 self.UserRegistered,
                                 self.UserRegistrationError)
+=======
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.register_user(email, password,
+                                                captcha_id, captcha_solution)
+        blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssssss')
+    def register_with_name(self, app_name, email, password, name,
+                           captcha_id, captcha_solution):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.register_with_name(email, password, name,
+                                                captcha_id, captcha_solution)
+        blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
+>>>>>>> MERGE-SOURCE
 
     # login signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -141,8 +447,31 @@
                          in_signature='sss')
     def login(self, app_name, email, password):
         """Call the matching method in the processor."""
+<<<<<<< TREE
         self.root.login(app_name, email, password, blocking, self.LoggedIn,
                         self.LoginError, self.UserNotValidated)
+=======
+        def f():
+            """Inner function that will be run in a thread."""
+            token_name = get_token_name(app_name)
+            logger.debug('login: token_name %r, email %r, password <hidden>.',
+                         token_name, email)
+            credentials = self.processor.login(email, password, token_name)
+            logger.debug('login returned not None credentials? %r.',
+                         credentials is not None)
+            return credentials
+
+        def success_cb(app_name, credentials):
+            """Login finished successfull."""
+            is_validated = self.processor.is_validated(credentials)
+            logger.debug('user is validated? %r.', is_validated)
+            if is_validated:
+                keyring_store_credentials(app_name, credentials,
+                                          self.LoggedIn, app_name, email)
+            else:
+                self.UserNotValidated(app_name, email)
+        blocking(f, app_name, success_cb, self.LoginError)
+>>>>>>> MERGE-SOURCE
 
     # validate_email signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -161,9 +490,25 @@
                          in_signature='ssss')
     def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
+<<<<<<< TREE
         self.root.validate_email(app_name, email, password, email_token,
                                  blocking, self.EmailValidated,
                                  self.EmailValidationError)
+=======
+        def f():
+            """Inner function that will be run in a thread."""
+            token_name = get_token_name(app_name)
+            credentials = self.processor.validate_email(email, password,
+                                                      email_token, token_name)
+
+            def _email_stored():
+                """The email was stored, so call the signal."""
+                self.EmailValidated(app_name, email)
+
+            keyring_store_credentials(app_name, credentials, _email_stored)
+
+        blocking(f, app_name, NO_OP, self.EmailValidationError)
+>>>>>>> MERGE-SOURCE
 
     # request_password_reset_token signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -182,9 +527,17 @@
                          in_signature='ss')
     def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
+<<<<<<< TREE
         self.root.request_password_reset_token(app_name, email, blocking,
                                                self.PasswordResetTokenSent,
                                                self.PasswordResetError)
+=======
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.request_password_reset_token(email)
+        blocking(f, app_name, self.PasswordResetTokenSent,
+                 self.PasswordResetError)
+>>>>>>> MERGE-SOURCE
 
     # set_new_password signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -203,9 +556,17 @@
                          in_signature='ssss')
     def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
+<<<<<<< TREE
         self.root.set_new_password(app_name, email, token, new_password,
                                    blocking, self.PasswordChanged,
                                    self.PasswordChangeError)
+=======
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.set_new_password(email, token,
+                                                   new_password)
+        blocking(f, app_name, self.PasswordChanged, self.PasswordChangeError)
+>>>>>>> MERGE-SOURCE
 
 
 class SSOCredentials(dbus.service.Object):
@@ -243,11 +604,92 @@
                      '"%s" and error_message %r', app_name, error_message)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
+<<<<<<< TREE
                          in_signature="s", out_signature="a{ss}",
                          async_callbacks=("callback", "errback"))
     def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
         """Get the credentials from the keyring or {} if not there."""
         self.root.find_credentials(app_name, callback, errback)
+=======
+                         in_signature="s", out_signature="a{ss}")
+    def find_credentials(self, app_name):
+        """Get the credentials from the keyring or '' if not there."""
+        token = keyring_get_credentials(app_name)
+        logger.info('find_credentials: app_name "%s", result is {}? %s',
+                    app_name, token is None)
+        if token is None:
+            return {}
+        else:
+            return token
+
+    def _login_success_cb(self, dialog, app_name, email):
+        """Handles the response from the UI dialog."""
+        logger.info('Login successful for app %r, email %r. Still pending to '
+                    'ping server and send result signal.', app_name, email)
+        try:
+            creds = keyring_get_credentials(app_name)
+            self._ping_url(app_name, email, creds)
+            self.CredentialsFound(app_name, creds)
+        except:  # pylint: disable=W0702
+            msg = "Problem getting the credentials from the keyring."
+            logger.exception(msg)
+            self.clear_token(app_name)
+            self.CredentialsError(app_name, msg, traceback.format_exc())
+
+    def _login_error_cb(self, dialog, app_name, error):
+        """Handles a problem in the UI."""
+        logger.info('Login unsuccessful for app %r, error %r', app_name, error)
+        msg = "Problem getting the credentials from the keyring."
+        self.CredentialsError(app_name, msg, "no more info available")
+
+    def _login_auth_denied_cb(self, dialog, app_name):
+        """The user decides not to allow the registration or login."""
+        self.AuthorizationDenied(app_name)
+
+    def _ping_url(self, app_name, email, credentials):
+        """Ping the given url."""
+        logger.info('Maybe pinging server for app_name "%s"', app_name)
+        if app_name == U1_APP_NAME:
+            url = self.ping_url + email
+            consumer = oauth.OAuthConsumer(credentials['consumer_key'],
+                                           credentials['consumer_secret'])
+            token = oauth.OAuthToken(credentials['token'],
+                                     credentials['token_secret'])
+            get_request = oauth.OAuthRequest.from_consumer_and_token
+            oauth_req = get_request(oauth_consumer=consumer, token=token,
+                                    http_method="GET", http_url=url)
+            oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
+                                   consumer, token)
+            request = urllib2.Request(url, headers=oauth_req.to_header())
+            logger.debug('Opening the ping url %s with urllib2.urlopen. ' \
+                         'Request to: %s', PING_URL, request.get_full_url())
+            response = urllib2.urlopen(request)
+            logger.debug('Url opened. Response: %s.', response.code)
+            return response.code
+
+    def _show_login_or_register_ui(self, app_name, tc_url, help_text,
+                                   win_id, login_only=False):
+        """Shows the UI so the user can login or register."""
+        try:
+            # delay gui import to be able to function on non-graphical envs
+            from ubuntu_sso import gui
+            gui_app = gui.UbuntuSSOClientGUI(app_name, tc_url,
+                                             help_text, win_id, login_only)
+            gui_app.connect(gui.SIG_LOGIN_SUCCEEDED, self._login_success_cb)
+            gui_app.connect(gui.SIG_LOGIN_FAILED, self._login_error_cb)
+            gui_app.connect(gui.SIG_REGISTRATION_SUCCEEDED,
+                            self._login_success_cb)
+            gui_app.connect(gui.SIG_REGISTRATION_FAILED, self._login_error_cb)
+            gui_app.connect(gui.SIG_USER_CANCELATION,
+                            self._login_auth_denied_cb)
+        except:  # pylint: disable=W0702
+            msg = '_show_login_or_register_ui failed when calling ' \
+                  'gui.UbuntuSSOClientGUI(%r, %r, %r, %r, %r)'
+            logger.exception(msg, app_name, tc_url, help_text,
+                             win_id, login_only)
+            msg = "Problem opening the Ubuntu SSO user interface."
+            self.CredentialsError(app_name, msg, traceback.format_exc())
+>>>>>>> MERGE-SOURCE
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature="sssx", out_signature="")
@@ -296,6 +738,7 @@
 
         'app_name' is the name of the application.
         """
+<<<<<<< TREE
         self.root.clear_token(app_name, callback, errback)
 
 
@@ -452,3 +895,13 @@
     def login(self, app_name, args):
         """Get credentials if found else prompt GUI to login."""
         self.root.login(app_name, args)
+=======
+        logger.info('Clearing credentials for app %r.', app_name)
+        try:
+            creds = Keyring(app_name)
+            creds.delete_ubuntusso_attr()
+        except:  # pylint: disable=W0702
+            logger.exception(
+                "problem removing credentials from keyring for %s",
+                app_name)
+>>>>>>> MERGE-SOURCE
 
=== modified file 'ubuntu_sso/main/tests/test_linux.py'
--- ubuntu_sso/main/tests/test_linux.py	2011-03-29 14:16:36 +0000
+++ ubuntu_sso/main/tests/test_linux.py	2011-03-29 17:35:28 +0000
@@ -50,6 +50,369 @@
 # pylint: disable=W0212
 
 
+<<<<<<< TREE
+=======
+APP_NAME = 'The Coolest App Ever'
+CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
+                                            'files', 'captcha.png'))
+CAPTCHA_ID = 'test'
+CAPTCHA_SOLUTION = 'william Byrd'
+CANT_RESET_PASSWORD_CONTENT = "CanNotResetPassowrdError: " \
+                              "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'
+NAME = 'Juanito Pérez'
+PASSWORD = 'be4tiFul'
+RESET_PASSWORD_TOKEN = '8G5Wtq'
+TOKEN = {u'consumer_key': u'xQ7xDAz',
+         u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
+         u'token_name': u'test',
+         u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
+         u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
+TOKEN_NAME = get_token_name(APP_NAME)
+STATUS_UNKNOWN = {'status': 'yadda-yadda'}
+STATUS_ERROR = {'status': 'error', 'errors': {'something': ['Bla', 'Ble']}}
+STATUS_OK = {'status': 'ok'}
+STATUS_EMAIL_UNKNOWN = {'status': 'yadda-yadda'}
+STATUS_EMAIL_ERROR = {'errors': {'email_token': ['Error1', 'Error2']}}
+STATUS_EMAIL_OK = {'email': EMAIL}
+TC_URL = 'tcurl'
+WINDOW_ID = 5
+
+NO_OP = lambda *args, **kwargs: None
+LOGIN_OR_REGISTER_ARGS = (APP_NAME, TC_URL, HELP, WINDOW_ID)
+LOGIN_OR_REGISTER_GUI_ARGS = LOGIN_OR_REGISTER_ARGS + (False,)
+LOGIN_ONLY_ARGS = (APP_NAME, HELP, WINDOW_ID)
+LOGIN_ONLY_GUI_ARGS = (APP_NAME, None, HELP, WINDOW_ID, True)
+
+
+class FakedResponse(object):
+    """Fake a urlopen response."""
+
+    def __init__(self, *args, **kwargs):
+        for k, val in kwargs.iteritems():
+            setattr(self, k, val)
+
+
+class FakedCaptchas(object):
+    """Fake the captcha generator."""
+
+    def new(self):
+        """Return a fix captcha)."""
+        return {'image_url': 'file://%s' % CAPTCHA_PATH,
+                'captcha_id': CAPTCHA_ID}
+
+
+class FakedRegistrations(object):
+    """Fake the registrations service."""
+
+    def register(self, email, password, displayname,
+                 captcha_id, captcha_solution):
+        """Fake registration. Return a fix result."""
+        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
+        else:
+            return STATUS_OK
+
+    def request_password_reset_token(self, email):
+        """Fake password reset token. Return a fix result."""
+        if email is None:
+            return STATUS_UNKNOWN
+        elif email != EMAIL:
+            raise HTTPError(response=None, content=CANT_RESET_PASSWORD_CONTENT)
+        else:
+            return STATUS_OK
+
+    def set_new_password(self, email, token, new_password):
+        """Fake the setting of new password. Return a fix result."""
+        if email is None and token is None and new_password is None:
+            return STATUS_UNKNOWN
+        elif email != EMAIL or token != RESET_PASSWORD_TOKEN:
+            raise HTTPError(response=None, content=RESET_TOKEN_INVALID_CONTENT)
+        else:
+            return STATUS_OK
+
+
+class FakedAuthentications(object):
+    """Fake the authentications service."""
+
+    def authenticate(self, token_name):
+        """Fake authenticate. Return a fix result."""
+        if not token_name.startswith(TOKEN_NAME):
+            raise HTTPError(response=None, content=None)
+        else:
+            return TOKEN
+
+
+class FakedAccounts(object):
+    """Fake the accounts service."""
+
+    def __init__(self):
+        self.preferred_email = EMAIL
+
+    def validate_email(self, email_token):
+        """Fake the email validation. Return a fix result."""
+        if email_token is None:
+            return STATUS_EMAIL_UNKNOWN
+        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
+
+    # pylint: disable=E0202, C0103
+
+    def me(self):
+        """Fake the 'me' information."""
+        return {u'username': u'Wh46bKY',
+                u'preferred_email': self.preferred_email,
+                u'displayname': u'',
+                u'unverified_emails': [u'[e-mail]'],
+                u'verified_emails': [],
+                u'openid_identifier': u'Wh46bKY'}
+
+
+class FakedSSOServer(object):
+    """Fake an SSO server."""
+
+    def __init__(self, authorizer, service_root):
+        self.captchas = FakedCaptchas()
+        self.registrations = FakedRegistrations()
+        self.authentications = FakedAuthentications()
+        self.accounts = FakedAccounts()
+
+
+class SSOLoginProcessorTestCase(TestCase, MockerTestCase):
+    """Test suite for the SSO login processor."""
+
+    def setUp(self):
+        """Init."""
+        self.processor = SSOLoginProcessor(sso_service_class=FakedSSOServer)
+        self.register_kwargs = dict(email=EMAIL, password=PASSWORD,
+                                    captcha_id=CAPTCHA_ID,
+                                    captcha_solution=CAPTCHA_SOLUTION)
+        self.login_kwargs = dict(email=EMAIL, password=PASSWORD,
+                                 token_name=TOKEN_NAME)
+
+    def tearDown(self):
+        """Clean up."""
+        self.processor = None
+
+    def test_generate_captcha(self):
+        """Captcha can be generated."""
+        filename = self.mktemp()
+        self.addCleanup(lambda: os.remove(filename))
+        captcha_id = self.processor.generate_captcha(filename)
+        self.assertEqual(CAPTCHA_ID, captcha_id, 'captcha id must be correct.')
+        self.assertTrue(os.path.isfile(filename), '%s must exist.' % filename)
+
+        with open(CAPTCHA_PATH) as f:
+            expected = f.read()
+        with open(filename) as f:
+            actual = f.read()
+        self.assertEqual(expected, actual, 'captcha image must be correct.')
+
+    def test_register_user_checks_valid_email(self):
+        """Email is validated."""
+        self.register_kwargs['email'] = 'notavalidemail'
+        self.assertRaises(InvalidEmailError,
+                          self.processor.register_user, **self.register_kwargs)
+
+    def test_register_user_checks_valid_password(self):
+        """Password is validated."""
+        self.register_kwargs['password'] = ''
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+        # 7 chars, one less than expected
+        self.register_kwargs['password'] = 'tesT3it'
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+        self.register_kwargs['password'] = 'test3it!'  # no upper case
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+        self.register_kwargs['password'] = 'testIt!!'  # no number
+        self.assertRaises(InvalidPasswordError,
+                          self.processor.register_user, **self.register_kwargs)
+
+    # register
+
+    def test_register_user_if_status_ok(self):
+        """A user is succesfuy registered into the SSO server."""
+        result = self.processor.register_user(**self.register_kwargs)
+        self.assertEqual(EMAIL, result, 'registration was successful.')
+
+    def test_register_user_if_status_error(self):
+        """Proper error is raised if register fails."""
+        self.register_kwargs['captcha_id'] = CAPTCHA_ID * 2  # incorrect
+        failure = self.assertRaises(RegistrationError,
+                                    self.processor.register_user,
+                                    **self.register_kwargs)
+        for k, val in failure.args[0].items():
+            self.assertIn(k, STATUS_ERROR['errors'])
+            self.assertEqual(val, "\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, val in failure.args[0].items():
+            self.assertIn(k, {'email': 'Email already registered'})
+            self.assertEqual(val, 'Email already registered')
+
+    def test_register_user_if_status_unknown(self):
+        """Proper error is raised if register returns an unknown status."""
+        self.register_kwargs['captcha_id'] = None
+        self.register_kwargs['captcha_solution'] = None
+        failure = self.assertRaises(RegistrationError,
+                                    self.processor.register_user,
+                                    **self.register_kwargs)
+        self.assertIn('Received unknown status: %s' % STATUS_UNKNOWN, failure)
+
+    # login
+
+    def test_login_if_http_error(self):
+        """Proper error is raised if authentication fails."""
+        self.login_kwargs['token_name'] = APP_NAME * 2  # invalid token name
+        self.assertRaises(AuthenticationError,
+                          self.processor.login, **self.login_kwargs)
+
+    def test_login_if_no_error(self):
+        """A user can be succesfully logged in into the SSO service."""
+        result = self.processor.login(**self.login_kwargs)
+        self.assertEqual(TOKEN, result, 'authentication was successful.')
+
+    # is_validated
+
+    def test_is_validated(self):
+        """If preferred email is not None, user is validated."""
+        result = self.processor.is_validated(token=TOKEN)
+        self.assertTrue(result, 'user must be validated.')
+
+    def test_is_not_validated(self):
+        """If preferred email is None, user is not validated."""
+        service = FakedSSOServer(None, None)
+        service.accounts.preferred_email = None
+        result = self.processor.is_validated(sso_service=service,
+                                             token=TOKEN)
+        self.assertFalse(result, 'user must not be validated.')
+
+    def test_is_not_validated_empty_result(self):
+        """If preferred email is None, user is not validated."""
+        service = FakedSSOServer(None, None)
+        service.accounts.me = lambda: {}
+        result = self.processor.is_validated(sso_service=service,
+                                             token=TOKEN)
+        self.assertFalse(result, 'user must not be validated.')
+
+    # validate_email
+
+    def test_validate_email_if_status_ok(self):
+        """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(TOKEN, result, 'email validation was successful.')
+
+    def test_validate_email_if_status_error(self):
+        """Proper error is raised if email validation fails."""
+        self.login_kwargs['email_token'] = EMAIL_TOKEN * 2  # invalid token
+        failure = self.assertRaises(EmailTokenError,
+                                    self.processor.validate_email,
+                                    **self.login_kwargs)
+        for k, val in failure.args[0].items():
+            self.assertIn(k, STATUS_EMAIL_ERROR['errors'])
+            self.assertEqual(val, "\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, val in failure.args[0].items():
+            self.assertIn(k, {'email': 'Email already registered'})
+            self.assertEqual(val, 'Email already registered')
+
+    def test_validate_email_if_status_unknown(self):
+        """Proper error is raised if email validation returns unknown."""
+        self.login_kwargs['email_token'] = None
+        failure = self.assertRaises(EmailTokenError,
+                                    self.processor.validate_email,
+                                    **self.login_kwargs)
+        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, failure)
+
+    # reset_password
+
+    def test_request_password_reset_token_if_status_ok(self):
+        """A reset password token is succesfuly sent."""
+        result = self.processor.request_password_reset_token(email=EMAIL)
+        self.assertEqual(EMAIL, result,
+                         'password reset token must be successful.')
+
+    def test_request_password_reset_token_if_http_error(self):
+        """Proper error is raised if password token request fails."""
+        exc = self.assertRaises(ResetPasswordTokenError,
+                                self.processor.request_password_reset_token,
+                                email=EMAIL * 2)
+        self.assertIn(CANT_RESET_PASSWORD_CONTENT, exc)
+
+    def test_request_password_reset_token_if_status_unknown(self):
+        """Proper error is raised if password token request returns unknown."""
+        exc = self.assertRaises(ResetPasswordTokenError,
+                                self.processor.request_password_reset_token,
+                                email=None)
+        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
+
+    def test_set_new_password_if_status_ok(self):
+        """A new password is succesfuy set."""
+        result = self.processor.set_new_password(email=EMAIL,
+                                                 token=RESET_PASSWORD_TOKEN,
+                                                 new_password=PASSWORD)
+        self.assertEqual(EMAIL, result,
+                         'new password must be set successfully.')
+
+    def test_set_new_password_if_http_error(self):
+        """Proper error is raised if setting a new password fails."""
+        exc = self.assertRaises(NewPasswordError,
+                                self.processor.set_new_password,
+                                email=EMAIL * 2,
+                                token=RESET_PASSWORD_TOKEN * 2,
+                                new_password=PASSWORD)
+        self.assertIn(RESET_TOKEN_INVALID_CONTENT, exc)
+
+    def test_set_new_password_if_status_unknown(self):
+        """Proper error is raised if setting a new password returns unknown."""
+        exc = self.assertRaises(NewPasswordError,
+                                self.processor.set_new_password,
+                                email=None, token=None, new_password=None)
+        self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
+
+
+class SSORegistrationWithNameTestCase(SSOLoginProcessorTestCase):
+    """Test suite for the SSO login processor for register_with_name."""
+
+    def setUp(self):
+        """Init."""
+        super(SSORegistrationWithNameTestCase, self).setUp()
+        self.register_kwargs['displayname'] = NAME
+        self.processor.register_user = self.processor.register_with_name
+
+
+>>>>>>> MERGE-SOURCE
 class BlockingSampleException(Exception):
     """The exception that will be thrown by the fake blocking."""
 
@@ -84,13 +447,21 @@
         mockbus._register_object_path(ARGS)
         self.mockprocessorclass = None
 
+<<<<<<< TREE
         def ksc(keyring, k, val):
+=======
+        def ksc(k, val, callback, *cb_args):
+>>>>>>> MERGE-SOURCE
             """Assert over token and app_name."""
             self.assertEqual(k, APP_NAME)
             self.assertEqual(val, TOKEN)
             self.keyring_was_set = True
             self.keyring_values = k, val
+<<<<<<< TREE
             return defer.succeed(None)
+=======
+            callback(*cb_args)
+>>>>>>> MERGE-SOURCE
 
         self.patch(ubuntu_sso.main.Keyring, "set_credentials", ksc)
         self.keyring_was_set = False
@@ -164,8 +535,13 @@
         """Test that the register_user method works ok."""
         d = Deferred()
         expected_result = "expected result"
+<<<<<<< TREE
         self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
             CAPTCHA_ID, CAPTCHA_SOLUTION)
+=======
+        self.create_mock_processor().register_user(EMAIL, PASSWORD,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+>>>>>>> MERGE-SOURCE
         self.mocker.result(expected_result)
         self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
@@ -188,8 +564,13 @@
         """Test that the register_user method fails as expected."""
         d = Deferred()
         expected_result = "expected result"
+<<<<<<< TREE
         self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
             CAPTCHA_ID, CAPTCHA_SOLUTION)
+=======
+        self.create_mock_processor().register_user(EMAIL, PASSWORD,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+>>>>>>> MERGE-SOURCE
         self.mocker.result(expected_result)
         self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
         self.mocker.replay()
@@ -208,15 +589,69 @@
                              CAPTCHA_SOLUTION)
         return d
 
+    def test_register_with_name(self):
+        """Test that the register_with_name method works ok."""
+        d = Deferred()
+        expected_result = "expected result"
+        self.create_mock_processor().register_with_name(EMAIL, PASSWORD, NAME,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", verify)
+        self.patch(client, "UserRegistrationError", d.errback)
+        client.register_with_name(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
+    def test_register_with_name_error(self):
+        """Test that the register_with_name method fails as expected."""
+        d = Deferred()
+        expected_result = "expected result"
+        self.create_mock_processor().register_with_name(EMAIL, PASSWORD, NAME,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", d.errback)
+        self.patch(client, "UserRegistrationError", verify)
+        client.register_with_name(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
     def test_login(self):
         """Test that the login method works ok."""
         d = Deferred()
         processor = self.create_mock_processor()
         processor.login(EMAIL, PASSWORD, TOKEN_NAME)
         self.mocker.result(TOKEN)
+<<<<<<< TREE
         processor.is_validated(TOKEN)
         self.mocker.result(True)
         self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+=======
+        processor.is_validated(TOKEN)
+        self.mocker.result(True)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+>>>>>>> MERGE-SOURCE
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -230,6 +665,7 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "LoggedIn", verify)
         self.patch(client, "LoginError", d.errback)
+<<<<<<< TREE
         self.patch(client, "UserNotValidated", d.errback)
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
@@ -265,6 +701,43 @@
         d = Deferred()
         self.create_mock_processor()
         self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+=======
+        self.patch(client, "UserNotValidated", d.errback)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_login_user_not_validated(self):
+        """Test that the login sends EmailNotValidated signal."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        processor.is_validated(TOKEN)
+        self.mocker.result(False)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, email):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(email, EMAIL)
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "LoggedIn", d.errback)
+        self.patch(client, "LoginError", d.errback)
+        self.patch(client, "UserNotValidated", verify)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_login_error(self):
+        """Test that the login method fails as expected."""
+        d = Deferred()
+        self.create_mock_processor()
+        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+>>>>>>> MERGE-SOURCE
 
         def fake_gtn(*args):
             """A fake get_token_name that fails."""
@@ -284,6 +757,7 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "LoggedIn", d.errback)
         self.patch(client, "LoginError", verify)
+<<<<<<< TREE
         self.patch(client, "UserNotValidated", d.errback)
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
@@ -319,6 +793,9 @@
         self.patch(client, "LoggedIn", fail)
         self.patch(client, "LoginError", verify)
         self.patch(client, "UserNotValidated", fail)
+=======
+        self.patch(client, "UserNotValidated", d.errback)
+>>>>>>> MERGE-SOURCE
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
@@ -348,8 +825,13 @@
     def test_validate_email_error(self):
         """Test that the validate_email method fails as expected."""
         d = Deferred()
+<<<<<<< TREE
         self.create_mock_processor()
         self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+=======
+        self.create_mock_processor()
+        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+>>>>>>> MERGE-SOURCE
 
         def fake_gtn(*args):
             """A fake get_token_name that fails."""
@@ -559,6 +1041,58 @@
         self.assertEqual(result["errtype"], e.__class__.__name__)
 
 
+<<<<<<< TREE
+=======
+class KeyringCredentialsTestCase(TestCase, MockerTestCase):
+    """Check the functions that access the keyring."""
+
+    # Invalid name (should match ([a-z_][a-z0-9_]*|[A-Z_][A-Z0-9_]*)$)
+    # pylint: disable=C0103
+
+    def test_keyring_store_cred(self):
+        """Verify the method that stores credentials."""
+        idle_add = lambda f, *args, **kwargs: f(*args, **kwargs)
+        self.patch(gobject, "idle_add", idle_add)
+        token_value = TOKEN
+        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
+        mockKeyringClass(APP_NAME)
+        mockKeyring = self.mocker.mock()
+        callback = self.mocker.mock()
+        self.mocker.result(mockKeyring)
+        mockKeyring.set_ubuntusso_attr(token_value)
+        callback(1, 2, 3)
+        self.mocker.replay()
+
+        keyring_store_credentials(APP_NAME, token_value, callback, 1, 2, 3)
+
+    def test_keyring_get_cred(self):
+        """The method returns the right token."""
+        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
+        mockKeyringClass(APP_NAME)
+        mockKeyring = self.mocker.mock()
+        self.mocker.result(mockKeyring)
+        mockKeyring.get_ubuntusso_attr()
+        self.mocker.result(TOKEN)
+        self.mocker.replay()
+
+        token = keyring_get_credentials(APP_NAME)
+        self.assertEqual(token, TOKEN)
+
+    def test_keyring_get_cred_not_found(self):
+        """The method returns None when the token is not found."""
+        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
+        mockKeyringClass(APP_NAME)
+        mockKeyring = self.mocker.mock()
+        self.mocker.result(mockKeyring)
+        mockKeyring.get_ubuntusso_attr()
+        self.mocker.result(None)
+        self.mocker.replay()
+
+        token = keyring_get_credentials(APP_NAME)
+        self.assertEqual(token, None)
+
+
+>>>>>>> MERGE-SOURCE
 class RegisterSampleException(Exception):
     """A mock exception thrown just when testing."""
 
@@ -677,6 +1211,24 @@
         client = SSOCredentials(self.mocker.mock())
         client.clear_token(APP_NAME)
 
+    def test_credentials_are_not_stored_if_ping_failed(self):
+        """Credentials are not stored if the ping fails."""
+
+        def fail(*args, **kwargs):
+            """Raise an exception."""
+            self.args = AssertionError((args, kwargs))
+            # pylint: disable=E0702
+            raise self.args
+
+        self.patch(self.client, '_ping_url', fail)
+        self._patch('clear_token')
+
+        self.client._login_success_cb(None, APP_NAME, EMAIL)
+
+        self.assertEqual(len(self.calls), 1)
+        self.assertEqual(self.calls[0][0], 'clear_token')
+        self.assertEqual(self.calls[0][1][0], APP_NAME)
+
 
 class EnvironOverridesTestCase(TestCase):
     """Some URLs can be set from the environment for testing/QA purposes."""