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

[Natalia Bidart]

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

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

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

  * New upstream release (1.1.1):

    [ Alejandro J. Cura <email address hidden> ]
      * Call the dbus mainloop thread init (fixes LP: #656545).
    [ Natalia B. Bidart <email address hidden> ]
      * Added the new dbus iface to the executable. Deprecated a few Dbus
      constants.
    [ Natalia B. Bidart <email address hidden> ]
      * Adding a new DBus iface to manage credentials with flexible API (LP:
      #653113).
    [ Natalia B. Bidart <email address hidden> ]
      * Replace twisted gtk reactor with the standard gtk mainloop. (LP:
      #655327).
    [ Natalia B. Bidart <email address hidden> ]
      * The TC browser will not be shown until the TOS page has been loaded. A
      spinner is shown in the mean time (LP: #620456).
      * The TC browser does not allow link navigation other than the TOS page
      (LP: #616961).
    [ Natalia B. Bidart <email address hidden> ]
      * Terms and conditions label is now translatable. Added a button to be
      able to browse the TC (LP: 654534).
    [ Natalia B. Bidart <email address hidden> ]
      * Moved logic from DBus SSOCredentials module into a self-contained, DBus
      agnostic module called 'credentials' (LP: #653113).
    [ Natalia B. Bidart <email address hidden> ]
      * Isolating SSO login processor into a separated module (LP: #637204).
    [ Natalia B. Bidart <email address hidden> ]
      * Cleanup code and modules to prepare the code for the DBus API refactor.
    [ Natalia B. Bidart <email address hidden> ]
      * Made entries name to be unicode to avoid a faulty capitalization when
      using turkish locale (LP: #652939).
    [ Natalia B. Bidart <email address hidden> ]
      * Workaround for LP: #467397 (when using turkish locale, decimal module
      import fails).
    [ Natalia B. Bidart <email address hidden> ]
      * Added encoding declaration on every file. Fixed error passing from GUI
      in GTK signals (LP: #652318).
    [ Natalia B. Bidart <email address hidden> ]
      * Avoiding calling a callback twice for buttons (LP: #652248).
    [ Natalia B. Bidart <email address hidden> ]
      * Removed unneeded assert sentences and replaced with warning logging
      when necessary (LP: #649317).

  * New upstream release (1.1.0):
    [ Natalia B. Bidart <email address hidden> ]
      * Avoiding having the main window freezing when pinging the U1 server
      (LP: #645162).
    [ Natalia B. Bidart <email address hidden> ]
      * Do not create the login keyring, use default instead (LP: #639690).
    [ Natalia B. Bidart <email address hidden> ]
      * Avoid duplicating logging messages for module "main" (LP: #638981).
    [ Natalia B. Bidart <email address hidden> ]
      * Delay import of webkit to be able to build on non-graphical envs (LP:
      #628956).

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

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

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-09-08 19:25:02 +0000
+++ contrib/testing/testcase.py	2010-10-18 13:21:21 +0000
@@ -96,3 +96,28 @@
             if rec.levelno == level and all(m in rec.message for m in msgs):
                 return True
         return False
+
+    def check_debug(self, *msgs):
+        """Shortcut for checking in DEBUG."""
+        return self.check(logging.DEBUG, *msgs)
+
+    def check_info(self, *msgs):
+        """Shortcut for checking in INFO."""
+        return self.check(logging.INFO, *msgs)
+
+    def check_warning(self, *msgs):
+        """Shortcut for checking in WARNING."""
+        return self.check(logging.WARNING, *msgs)
+
+    def check_error(self, *msgs):
+        """Shortcut for checking in ERROR."""
+        return self.check(logging.ERROR, *msgs)
+
+    def check_exception(self, exception_class, *msgs):
+        """Shortcut for checking exceptions."""
+        for rec in self.records:
+            if rec.levelno == logging.ERROR and \
+               all(m in rec.exc_text for m in msgs) and \
+               exception_class == rec.exc_info[0]:
+                return True
+        return False

=== modified file 'data/ui.glade'
--- data/ui.glade	2010-08-27 22:16:40 +0000
+++ data/ui.glade	2010-10-18 13:21:21 +0000
@@ -1,4 +1,4 @@
-<?xml version="1.0"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <requires lib="gtk+" version="2.16"/>
   <!-- interface-naming-policy project-wide -->
@@ -60,12 +60,6 @@
     <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>
@@ -79,7 +73,7 @@
       </object>
       <packing>
         <property name="expand">False</property>
-        <property name="position">2</property>
+        <property name="position">0</property>
       </packing>
     </child>
     <child>
@@ -96,17 +90,18 @@
       </object>
       <packing>
         <property name="expand">False</property>
-        <property name="position">4</property>
+        <property name="position">1</property>
       </packing>
     </child>
     <child>
       <object class="GtkLabel" id="password_help_label">
         <property name="visible">True</property>
+        <property name="label">password help</property>
         <property name="wrap">True</property>
       </object>
       <packing>
         <property name="expand">False</property>
-        <property name="position">5</property>
+        <property name="position">2</property>
       </packing>
     </child>
     <child>
@@ -114,6 +109,8 @@
         <property name="visible">True</property>
         <child>
           <object class="GtkVBox" id="captcha_vbox">
+            <property name="width_request">300</property>
+            <property name="height_request">60</property>
             <property name="visible">True</property>
             <property name="homogeneous">True</property>
             <child>
@@ -184,7 +181,7 @@
         </child>
       </object>
       <packing>
-        <property name="position">7</property>
+        <property name="position">3</property>
       </packing>
     </child>
     <child>
@@ -194,12 +191,9 @@
         <child>
           <placeholder/>
         </child>
-        <child>
-          <placeholder/>
-        </child>
       </object>
       <packing>
-        <property name="position">8</property>
+        <property name="position">4</property>
       </packing>
     </child>
     <child>
@@ -213,12 +207,13 @@
       </object>
       <packing>
         <property name="expand">False</property>
-        <property name="position">9</property>
+        <property name="position">5</property>
       </packing>
     </child>
     <child>
-      <object class="GtkHBox" id="tc_hbox">
+      <object class="GtkVBox" id="tc_vbox">
         <property name="visible">True</property>
+        <property name="spacing">5</property>
         <child>
           <object class="GtkCheckButton" id="yes_to_tc_checkbutton">
             <property name="label" translatable="yes">yes to tc</property>
@@ -234,33 +229,41 @@
           </packing>
         </child>
         <child>
-          <object class="GtkLinkButton" id="tc_button">
-            <property name="label" translatable="yes">tc button</property>
+          <object class="GtkHButtonBox" id="hbuttonbox3">
             <property name="visible">True</property>
-            <property name="can_focus">True</property>
-            <property name="receives_default">True</property>
-            <property name="has_tooltip">True</property>
-            <property name="relief">none</property>
-            <signal name="clicked" handler="on_tc_button_clicked"/>
+            <property name="layout_style">start</property>
+            <child>
+              <object class="GtkButton" id="tc_button">
+                <property name="label">show tc</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <signal name="clicked" handler="on_tc_button_clicked"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
           </object>
           <packing>
-            <property name="expand">False</property>
             <property name="position">1</property>
           </packing>
         </child>
-      </object>
-      <packing>
-        <property name="expand">False</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>
+        <child>
+          <object class="GtkLabel" id="tc_warning_label">
+            <property name="visible">True</property>
+            <property name="label">tc warning</property>
+            <property name="wrap">True</property>
+          </object>
+          <packing>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="position">6</property>
       </packing>
     </child>
     <child>
@@ -300,7 +303,7 @@
       </object>
       <packing>
         <property name="expand">False</property>
-        <property name="position">12</property>
+        <property name="position">7</property>
       </packing>
     </child>
     <child>
@@ -315,12 +318,9 @@
       </object>
       <packing>
         <property name="expand">False</property>
-        <property name="position">13</property>
+        <property name="position">8</property>
       </packing>
     </child>
-    <child>
-      <placeholder/>
-    </child>
   </object>
   <object class="GtkVBox" id="processing_vbox">
     <property name="visible">True</property>
@@ -365,7 +365,6 @@
   <object class="GtkVBox" id="tc_browser_vbox">
     <property name="visible">True</property>
     <signal name="hide" handler="on_tc_browser_vbox_hide"/>
-    <signal name="show" handler="on_tc_browser_vbox_show"/>
     <child>
       <object class="GtkScrolledWindow" id="tc_browser_window">
         <property name="visible">True</property>
@@ -618,6 +617,9 @@
             <property name="label" translatable="yes">label</property>
             <property name="wrap">True</property>
           </object>
+          <packing>
+            <property name="position">1</property>
+          </packing>
         </child>
       </object>
       <packing>

=== modified file 'debian/changelog'
--- debian/changelog	2010-10-01 15:35:43 +0000
+++ debian/changelog	2010-10-18 13:21:21 +0000
@@ -1,3 +1,80 @@
+ubuntu-sso-client (1.1.1-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release (1.1.1):
+
+    [ Alejandro J. Cura <[e-mail]> ]
+      * Call the dbus mainloop thread init (fixes LP: #656545).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Added the new dbus iface to the executable. Deprecated a few Dbus
+      constants.
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Adding a new DBus iface to manage credentials with flexible API (LP:
+      #653113).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Replace twisted gtk reactor with the standard gtk mainloop. (LP:
+      #655327).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * The TC browser will not be shown until the TOS page has been loaded. A
+      spinner is shown in the mean time (LP: #620456).
+      * The TC browser does not allow link navigation other than the TOS page
+      (LP: #616961).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Terms and conditions label is now translatable. Added a button to be
+      able to browse the TC (LP: 654534).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Moved logic from DBus SSOCredentials module into a self-contained, DBus
+      agnostic module called 'credentials' (LP: #653113).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Isolating SSO login processor into a separated module (LP: #637204).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Cleanup code and modules to prepare the code for the DBus API refactor.
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Made entries name to be unicode to avoid a faulty capitalization when
+      using turkish locale (LP: #652939).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Workaround for LP: #467397 (when using turkish locale, decimal module
+      import fails).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Added encoding declaration on every file. Fixed error passing from GUI
+      in GTK signals (LP: #652318).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Avoiding calling a callback twice for buttons (LP: #652248).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Removed unneeded assert sentences and replaced with warning logging
+      when necessary (LP: #649317).
+
+  * New upstream release (1.1.0):
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Avoiding having the main window freezing when pinging the U1 server
+      (LP: #645162).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Do not create the login keyring, use default instead (LP: #639690).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Avoid duplicating logging messages for module "main" (LP: #638981).
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      * Delay import of webkit to be able to build on non-graphical envs (LP:
+      #628956).
+
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Mon, 11 Oct 2010 10:22:28 -0300
+
 ubuntu-sso-client (1.0.3-0ubuntu1) maverick; urgency=low
 
   * New upstream release:

=== modified file 'debian/watch'
--- debian/watch	2010-09-22 18:53:18 +0000
+++ debian/watch	2010-10-18 13:21:21 +0000
@@ -1,3 +1,3 @@
 version=3
-http://launchpad.net/ubuntu-sso-client/+download?start=10  .*/ubuntu-sso-client-([0-9.]+)\.tar\.gz
+http://launchpad.net/ubuntu-sso-client/+download  .*/ubuntu-sso-client-([0-9.]+)\.tar\.gz
 

=== added file 'po/ubuntu-sso-client.pot'
--- po/ubuntu-sso-client.pot	1970-01-01 00:00:00 +0000
+++ po/ubuntu-sso-client.pot	2010-10-18 13:21:21 +0000
@@ -0,0 +1,178 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2010-10-11 09:34-0300\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <[e-mail]>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=CHARSET\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: ../ubuntu_sso/gui.py:207
+msgid "Type the characters above"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:208
+#, python-format
+msgid "To connect this computer to %(app_name)s enter your details below."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:210 ../ubuntu_sso/gui.py:221 ../ubuntu_sso/gui.py:239
+msgid "Email address"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:211
+msgid "Re-type Email address"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:212
+msgid ""
+"The email addresses don't match, please double check and try entering them "
+"again."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:214
+msgid "The email must be a valid email address."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:215
+msgid "Enter code verification here"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:216
+msgid "This field is required."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:217
+msgid "I've forgotten my password"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:218
+#, python-format
+msgid "Create %(app_name)s account"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:219
+msgid "Loading..."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:220
+msgid "Already have an account? Click here to sign in"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:222
+#, python-format
+msgid "Connect to %(app_name)s"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:223 ../ubuntu_sso/gui.py:228
+msgid "Password"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:224
+msgid "Name"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:225
+msgid "Next"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:226
+msgid "One moment please..."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:227
+msgid "Your password was successfully changed."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:229
+msgid "Re-type Password"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:230
+msgid ""
+"The password must have a minimum of 8 characters and include one uppercase "
+"character and one number."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:232
+msgid ""
+"The passwords don't match, please double check and try entering them again."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:234
+msgid "The password is too weak."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:235
+#, python-format
+msgid "To reset your %(app_name)s password, enter your email address below:"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:237
+msgid "Reset password"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:238
+msgid "Reset code"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:240
+#, python-format
+msgid ""
+"A password reset code has been sent to %(email)s.\n"
+"Please enter the code below along with your new password."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:243
+msgid "The process finished successfully. Congratulations!"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:244
+msgid "Show Terms & Conditions"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:245
+msgid "Agreeing to the Ubuntu One Terms & Conditions is required to subscribe."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:247
+msgid ""
+"There was an error when trying to complete the process. Please check the "
+"information and try again."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:249
+msgid "Enter verification code"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:250
+#, python-format
+msgid ""
+"Check %(email)s for an email from Ubuntu Single Sign On. This message "
+"contains a verification code. Enter the code in the field below and click OK "
+"to complete creating your %(app_name)s account"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:255
+#, python-format
+msgid "I agree with the %(app_name)s terms and conditions"
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:256
+#, python-format
+msgid "Yes! Email me %(app_name)s tips and updates."
+msgstr ""
+
+#: ../ubuntu_sso/gui.py:257
+msgid "Reload"
+msgstr ""

=== modified file 'pylintrc'
--- pylintrc	2010-09-08 19:25:02 +0000
+++ pylintrc	2010-10-18 13:21:21 +0000
@@ -25,9 +25,6 @@
 # Pickle collected data for later comparisons.
 persistent=no
 
-# Set the cache size for astng objects.
-cache-size=500
-
 # List of plugins (as comma separated values of python modules names) to load,
 # usually to register additional checkers.
 load-plugins=
@@ -50,7 +47,7 @@
 #disable-cat=
 
 # Disable the message(s) with the given id(s) or categories
-# W0142: *Used * or ** magic*
+# W0142: Used * or ** magic
 # W0613: Unused argument 'yyy'
 # C0302: Too many lines in module
 disable=R,I,W0142,W0613,C0302

=== modified file 'run-tests'
--- run-tests	2010-09-08 19:25:02 +0000
+++ run-tests	2010-10-18 13:21:21 +0000
@@ -15,11 +15,14 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-`which xvfb-run` ./contrib/test "$@"
-pylint contrib ubuntu_sso
-if [ -x `which pep8` ]; then
-    pep8 --repeat bin/ contrib/ ubuntu_sso/
-else
-    echo "Please install the 'pep8' package."
-fi
+style_check() {
+    pylint contrib ubuntu_sso
+    if [ -x `which pep8` ]; then
+        pep8 --repeat bin/ contrib/ ubuntu_sso/
+    else
+        echo "Please install the 'pep8' package."
+    fi
+}
+
+`which xvfb-run` ./contrib/test "$@" && style_check
 rm -rf _trial_temp/

=== modified file 'setup.py'
--- setup.py	2010-10-01 14:57:22 +0000
+++ setup.py	2010-10-18 13:21:21 +0000
@@ -86,7 +86,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='1.0.3',
+    version='1.1.1',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntu_sso/__init__.py'
--- ubuntu_sso/__init__.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/__init__.py	2010-10-18 13:21:21 +0000
@@ -16,10 +16,16 @@
 """Ubuntu Single Sign On client code."""
 
 # constants
-DBUS_PATH_AUTH = "/"
 DBUS_BUS_NAME = "com.ubuntu.sso"
-DBUS_PATH = "/sso"
-DBUS_CRED_PATH = "/credentials"
+DBUS_PATH = "/sso"  # deprecated!
+DBUS_CRED_PATH = "/credentials"  # deprecated!
+DBUS_ACCOUNT_PATH = "/com/ubuntu/sso/accounts"
+
 DBUS_IFACE_AUTH_NAME = "com.ubuntu.sso"
 DBUS_IFACE_USER_NAME = "com.ubuntu.sso.UserManagement"
 DBUS_IFACE_CRED_NAME = "com.ubuntu.sso.ApplicationCredentials"
+
+DBUS_CREDENTIALS_PATH = "/com/ubuntu/sso/credentials"
+DBUS_CREDENTIALS_IFACE = "com.ubuntu.sso.CredentialsManagement"
+
+NO_OP = lambda *args, **kwargs: None

=== added file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/account.py	2010-10-18 13:21:21 +0000
@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+
+# Author: Natalia Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Single Sign On account management."""
+
+import os
+import re
+import urllib2
+
+# Unable to import 'lazr.restfulclient.*'
+# pylint: disable=F0401
+from lazr.restfulclient.authorize import BasicHttpAuthorizer
+from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
+from lazr.restfulclient.errors import HTTPError
+from lazr.restfulclient.resource import ServiceRoot
+# pylint: enable=F0401
+from oauth import oauth
+
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging("ubuntu_sso.account")
+SERVICE_URL = "https://login.ubuntu.com/api/1.0"
+
+
+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."""
+
+
+class Account(object):
+    """Login and register users using the Ubuntu Single Sign On service."""
+
+    def __init__(self, sso_service_class=None):
+        """Create a new SSO Account manager."""
+        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)
+
+        logger.info('Created a new SSO access layer for service url %r',
+                     self.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 key, val in errdict.iteritems():
+            # workaround until bug #624955 is solved
+            if isinstance(val, basestring):
+                result[key] = val
+            else:
+                result[key] = "\n".join(val)
+        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_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)
+        sso_service = self.sso_service_class(None, self.service_url)
+        if not self._valid_email(email):
+            logger.error('register_user: InvalidEmailError for email: %r',
+                         email)
+            raise InvalidEmailError()
+        if not self._valid_password(password):
+            logger.error('register_user: InvalidPasswordError')
+            raise InvalidPasswordError()
+
+        result = sso_service.registrations.register(
+                    email=email, password=password, captcha_id=captcha_id,
+                    captcha_solution=captcha_solution)
+        logger.info('register_user: 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 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 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)

=== removed file 'ubuntu_sso/auth.py'
--- ubuntu_sso/auth.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/auth.py	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-# ubuntu_sso.auth - Client authorization module
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program. If not, see <http://www.gnu.org/licenses/>.
-"""This is an obsolete module.
-
-Do not use it, use the DBus API from main instead (SSOCredentials).
-"""
-
-
-class NoAccessToken(Exception):
-    """No access token available."""

=== added file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/credentials.py	2010-10-18 13:21:21 +0000
@@ -0,0 +1,271 @@
+# -*- coding: utf-8 -*-
+
+# Author: Natalia Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Credential management utilities.
+
+'Credentials' provides the following fault-tolerant methods:
+
+ * find_credentials
+ * clear_credentials
+ * register
+ * login
+
+The first two returns immediately (for now).
+
+The second two use the 'success_cb', 'error_cb' and 'denial_cb' to signal the
+caller when the credentials were retrieved successfully, when there was an
+error or when the user denied the access to the application, respectively.
+
+For details, please read the Credentials class documentation.
+
+"""
+
+import traceback
+import urllib2
+
+from functools import wraps
+
+import gobject
+
+from oauth import oauth
+
+from ubuntu_sso import keyring, NO_OP
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging('ubuntu_sso.credentials')
+
+
+APP_NAME_KEY = 'app_name'
+TC_URL_KEY = 'tc_url'
+HELP_TEXT_KEY = 'help_text'
+WINDOW_ID_KEY = 'window_id'
+PING_URL_KEY = 'ping_url'
+SUCCESS_CB_KEY = 'success_cb'
+ERROR_CB_KEY = 'error_cb'
+DENIAL_CB_KEY = 'denial_cb'
+ERROR_KEY = 'error_message'
+ERROR_DETAIL_KEY = 'detailed_error'
+
+
+def keyring_store_credentials(app_name, credentials):
+    """Store the credentials in the keyring."""
+    logger.info('keyring_store_credentials: app_name "%s".', app_name)
+    keyring.Keyring(app_name).set_ubuntusso_attr(credentials)
+
+
+def keyring_get_credentials(app_name):
+    """Get the credentials from the keyring or None if not there."""
+    creds = keyring.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
+
+
+def keyring_delete_credentials(app_name):
+    """Delete the credentials from the keyring."""
+    logger.info('keyring_delete_credentials: app_name "%s".', app_name)
+    keyring.Keyring(app_name).delete_ubuntusso_attr()
+
+
+def handle_exceptions(msg):
+    """Handle exceptions using 'msg' as error message."""
+
+    def middle(f):
+        """Decorate 'f' to catch all errors."""
+
+        @wraps(f)
+        def inner(self, *a, **kw):
+            """Call 'f' within a try-except block.
+
+            If any exception occurs, self.error_cb is called and the exception
+            is logged.
+            """
+            result = None
+            try:
+                result = f(self, *a, **kw)
+            except:  # pylint: disable=W0702
+                logger.exception('%s (app_name: %s): %s.',
+                                 f.__name__, self.app_name, msg)
+                logger.error('%s (app_name: %s): Calling error_cb at %r.',
+                                 f.__name__, self.app_name, self.error_cb)
+                error_dict = {ERROR_KEY: msg,
+                              ERROR_DETAIL_KEY: traceback.format_exc()}
+                self.error_cb(self.app_name, error_dict)
+            return result
+
+        return inner
+
+    return middle
+
+
+class Credentials(object):
+    """Credentials management gateway."""
+
+    def __init__(self, app_name, tc_url=None, help_text='',
+                 window_id=0, ping_url=None,
+                 success_cb=NO_OP, error_cb=NO_OP, denial_cb=NO_OP):
+        """Return a Credentials management object.
+
+        'app_name' is the application name to be displayed in the GUI.
+
+        'tc_url' is the URL pointing to Terms & Conditions. If None, no
+        TOS agreement will be displayed.
+
+        'help_text' is an explanatory text for the end-users, will be shown
+         below the headers.
+
+        'window_id' is the id of the window which will be set as a parent of
+         the GUI. If 0, no parent will be set.
+
+        'ping_url' is the url that will be pinged when a user registers/logins
+        successfully. The user email will be attached to 'ping_url'.
+
+        'success_cb' will be called when the credentials were retrieved
+        successfully. Two params will be passed: the app_name and the
+        credentials per se. The credentials is a dictionary of the form:
+
+            {'token': <value>,
+             'token_secret': <value>,
+             'consumer_key': <value>,
+             'consumer_secret': <value>,
+             'name': <the token name, matches "[app_name] @ [host name]">}
+
+        'error_cb' will be called when the credentials retrieval failed. Three
+        params will be passed: the app_name, the error message (user friendly,
+        not translatable so far), and the detailed error (usually the
+        traceback).
+
+        'denial_cb' will be called when the user denied the credentials to the
+        caller. A single param is passed: the app_name.
+
+        """
+        self.app_name = app_name
+        self.help_text = help_text
+        self.window_id = window_id
+        self.ping_url = ping_url
+        self.tc_url = tc_url
+        self.success_cb = success_cb
+        self.error_cb = error_cb
+        self.denial_cb = denial_cb
+
+    @handle_exceptions(msg='Problem while retrieving credentials')
+    def _login_success_cb(self, dialog, app_name, email):
+        """Store credentials when the login/registration succeeded.
+
+        Also, open self.ping_url/email to notify about this new token. If any
+        error occur, self.error_cb is called. Otherwise, self.success_cb is
+        called.
+
+        """
+        logger.info('Login/registration was successful for app %r, email %r',
+                    app_name, email)
+        creds = self.find_credentials()
+        if creds is not None:
+            assert len(creds) > 0, 'Creds are empty! This should not happen'
+            status = self._ping_url(app_name, email, creds)
+            if status is None:
+                self.clear_credentials()
+            else:
+                self.success_cb(app_name, creds)
+
+    def _login_error_cb(self, dialog, app_name, error):
+        """Handle UI error when login/registration failed."""
+        logger.warning('Login/registration failed app %r, error %r',
+                       app_name, error)
+        self.error_cb(app_name, {ERROR_KEY: error})
+
+    def _auth_denial_cb(self, dialog, app_name):
+        """The user decided not to allow the registration or login."""
+        logger.warning('Login/registration was denied to app %r', app_name)
+        self.denial_cb(app_name)
+
+    @handle_exceptions(msg='Problem opening the ping_url')
+    def _ping_url(self, app_name, email, credentials):
+        """Ping the self.ping_url with the email attached.
+
+        Sign the request with the user credentials.
+
+        """
+        logger.info('Maybe pinging server for app_name "%s", ping_url: "%s", '
+                    'email "%s".', app_name, self.ping_url, email)
+        if self.ping_url is not None:
+            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 url "%s" with urllib2.urlopen.',
+                         request.get_full_url())
+            response = urllib2.urlopen(request)
+            logger.debug('Url opened. Response: %s.', response.code)
+            return response.code
+
+    @handle_exceptions(msg='Problem opening the Ubuntu SSO user interface')
+    def _show_ui(self, login_only):
+        """Shows the UI, connect outcome signals."""
+        # delay gui import to be able to function on non-graphical envs
+        from ubuntu_sso import gui
+        app = gui.UbuntuSSOClientGUI(app_name=self.app_name,
+                        tc_url=self.tc_url, help_text=self.help_text,
+                        window_id=self.window_id, login_only=login_only)
+
+        app.connect(gui.SIG_LOGIN_SUCCEEDED, self._login_success_cb)
+        app.connect(gui.SIG_LOGIN_FAILED, self._login_error_cb)
+        app.connect(gui.SIG_REGISTRATION_SUCCEEDED, self._login_success_cb)
+        app.connect(gui.SIG_REGISTRATION_FAILED, self._login_error_cb)
+        app.connect(gui.SIG_USER_CANCELATION, self._auth_denial_cb)
+
+    @handle_exceptions(msg='Problem while retrieving credentials')
+    def _login_or_register(self, login_only):
+        """Get credentials if found else prompt the GUI."""
+        token = self.find_credentials()
+        if token is not None and len(token) > 0:
+            self.success_cb(self.app_name, token)
+        elif token == {}:
+            gobject.idle_add(self._show_ui, login_only)
+        else:
+            # something went wrong with find_credentials, already handled.
+            logger.info('_login_or_register: call to "find_credentials" went '
+                        'wrong, and was already handled.')
+
+    @handle_exceptions(msg='Problem while retrieving credentials')
+    def find_credentials(self):
+        """Get the credentials for 'self.app_name'. Return {} if not there."""
+        token = keyring_get_credentials(self.app_name)
+        logger.info('find_credentials: self.app_name "%s", '
+                    'result is {}? %s', self.app_name, token is None)
+        return token if token is not None else {}
+
+    @handle_exceptions(msg='Problem while deleting credentials')
+    def clear_credentials(self):
+        """Clear the credentials for 'self.app_name'."""
+        keyring_delete_credentials(self.app_name)
+
+    def register(self):
+        """Get credentials if found else prompt the GUI to register."""
+        self._login_or_register(login_only=False)
+
+    def login(self):
+        """Get credentials if found else prompt the GUI to login."""
+        self._login_or_register(login_only=True)

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-10-01 14:57:22 +0000
+++ ubuntu_sso/gui.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # ubuntu_sso.gui - GUI for login and registration
 #
 # Author: Natalia Bidart <[e-mail]>
@@ -22,6 +24,7 @@
 import os
 import re
 import tempfile
+import webbrowser
 
 from functools import wraps
 
@@ -29,12 +32,11 @@
 import gettext
 import gobject
 import gtk
-import webkit
 import xdg
 
 from dbus.mainloop.glib import DBusGMainLoop
 
-from ubuntu_sso import DBUS_PATH, DBUS_BUS_NAME, DBUS_IFACE_USER_NAME
+from ubuntu_sso import DBUS_ACCOUNT_PATH, DBUS_BUS_NAME, DBUS_IFACE_USER_NAME
 from ubuntu_sso.logger import setup_logging
 
 
@@ -48,6 +50,22 @@
 DBusGMainLoop(set_as_default=True)
 logger = setup_logging('ubuntu_sso.gui')
 
+# To be removed when Python bindings provide these constants
+# as per http://code.google.com/p/pywebkitgtk/issues/detail?id=44
+# WebKitLoadStatus
+WEBKIT_LOAD_PROVISIONAL = 0
+WEBKIT_LOAD_COMMITTED = 1
+WEBKIT_LOAD_FINISHED = 2
+WEBKIT_LOAD_FIRST_VISUALLY_NON_EMPTY_LAYOUT = 3
+WEBKIT_LOAD_FAILED = 4
+# WebKitWebNavigationReason
+WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED = 0
+WEBKIT_WEB_NAVIGATION_REASON_FORM_SUBMITTED = 1
+WEBKIT_WEB_NAVIGATION_REASON_BACK_FORWARD = 2
+WEBKIT_WEB_NAVIGATION_REASON_RELOAD = 3
+WEBKIT_WEB_NAVIGATION_REASON_FORM_RESUBMITTED = 4
+WEBKIT_WEB_NAVIGATION_REASON_OTHER = 5
+
 
 NO_OP = lambda *args, **kwargs: None
 DEFAULT_WIDTH = 30
@@ -223,7 +241,7 @@
                                '%(email)s.\nPlease enter the code below ' \
                                'along with your new password.')
     SUCCESS = _('The process finished successfully. Congratulations!')
-    TC = _('Terms & Conditions')
+    TC_BUTTON = _('Show Terms & Conditions')
     TC_NOT_ACCEPTED = _('Agreeing to the Ubuntu One Terms & Conditions is ' \
                         'required to subscribe.')
     UNKNOWN_ERROR = _('There was an error when trying to complete the ' \
@@ -234,11 +252,11 @@
                             ' This message contains a verification code.'
                             ' Enter the code in the field below and click OK'
                             ' to complete creating your %(app_name)s account'))
-    YES_TO_TC = _('I agree with the %(app_name)s ')  # Terms&Conditions button
+    YES_TO_TC = _('I agree with the %(app_name)s terms and conditions')
     YES_TO_UPDATES = _('Yes! Email me %(app_name)s tips and updates.')
     CAPTCHA_RELOAD_TOOLTIP = _('Reload')
 
-    def __init__(self, app_name, tc_uri, help_text,
+    def __init__(self, app_name, tc_url, help_text,
                  window_id=0, login_only=False, close_callback=None):
         """Create the GUI and initialize widgets."""
         gtk.link_button_set_uri_hook(NO_OP)
@@ -249,7 +267,7 @@
 
         self.app_name = app_name
         self.app_label = '<b>%s</b>' % self.app_name
-        self.tc_uri = tc_uri
+        self.tc_url = tc_url
         self.help_text = help_text
         self.close_callback = close_callback
 
@@ -278,8 +296,6 @@
                 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)
 
@@ -294,14 +310,14 @@
             label = getattr(self, name.upper())
             is_password = 'password' in name
             entry = LabeledEntry(label=label, is_password=is_password)
+            entry.set_activates_default(True)
             setattr(self, name, entry)
-            assert getattr(self, name) is not None
 
         self.window.set_icon_name('ubuntu-logo')
 
         self.bus = dbus.SessionBus()
         obj = self.bus.get_object(bus_name=DBUS_BUS_NAME,
-                                  object_path=DBUS_PATH,
+                                  object_path=DBUS_ACCOUNT_PATH,
                                   follow_name_owner_changes=True)
         self.iface_name = DBUS_IFACE_USER_NAME
         self.backend = dbus.Interface(object=obj,
@@ -417,8 +433,8 @@
 
             match = self.bus.add_signal_receiver(method, signal_name=signal,
                                                  dbus_interface=iface)
-            logger.info('Connecting signal %r with method %r at iface %r.' \
-                        'Match: %r', signal, method, iface, match)
+            logger.debug('Connecting signal %r with method %r at iface %r.' \
+                         'Match: %r', signal, method, iface, match)
             self._signals_receivers[(iface, signal)] = method
 
     def _debug(self, *args, **kwargs):
@@ -537,7 +553,6 @@
         self.enter_details_vbox.reorder_child(self.name_entry, 0)
         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)
 
@@ -556,19 +571,14 @@
 
         msg = self.YES_TO_UPDATES % {'app_name': self.app_name}
         self.yes_to_updates_checkbutton.set_label(msg)
-        if self.tc_uri:
+        if self.tc_url:
             msg = self.YES_TO_TC % {'app_name': self.app_name}
             self.yes_to_tc_checkbutton.set_label(msg)
-            self.tc_button.set_label(self.TC)
+            self.tc_button.set_label(self.TC_BUTTON)
         else:
-            self.tc_hbox.hide_all()
+            self.tc_vbox.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):
@@ -590,8 +600,6 @@
         self.verify_email_vbox.default_widget = self.verify_token_button
         self.verify_email_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
 
-        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)
 
@@ -623,9 +631,6 @@
         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):
@@ -645,9 +650,6 @@
         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):
@@ -658,12 +660,10 @@
         btn.set_flags(gtk.CAN_DEFAULT)
         self.set_new_password_vbox.default_widget = btn
 
-        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, expand=False)
-            entry.connect('activate', cb)
 
         cb = self.on_set_new_password_entries_changed
         self.reset_code_entry.connect('changed', cb)
@@ -725,8 +725,8 @@
         remove = self.bus.remove_signal_receiver
         for (iface, signal) in self._signals_receivers.keys():
             method = self._signals_receivers.pop((iface, signal))
-            logger.info('Removing signal %r with method %r at iface %r.',
-                        signal, method, iface)
+            logger.debug('Removing signal %r with method %r at iface %r.',
+                         signal, method, iface)
             remove(method, signal_name=signal, dbus_interface=iface)
 
         # hide the main window
@@ -742,6 +742,7 @@
         elif len(self._gtk_signal_log) > 0:
             signal = self._gtk_signal_log[-1][0]
             args = self._gtk_signal_log[-1][1:]
+            logger.info('emitting %r with args %r.', signal, args)
             self.window.emit(signal, *args)
         else:
             self.window.emit(SIG_USER_CANCELATION, self.app_name)
@@ -812,14 +813,6 @@
         f(self.app_name, email1, password1, self._captcha_id, captcha_solution,
           reply_handler=NO_OP, error_handler=NO_OP)
 
-    def on_tc_button_clicked(self, *args, **kwargs):
-        """T & C button was clicked, show the browser with them."""
-        self._set_current_page(self.tc_browser_vbox)
-
-    def on_tc_back_button_clicked(self, *args, **kwargs):
-        """T & C 'back' button was clicked, return to the previous page."""
-        self._set_current_page(self.enter_details_vbox)
-
     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():
@@ -951,15 +944,60 @@
 
         self._set_current_page(self.processing_vbox)
 
-    def on_tc_browser_vbox_show(self, *args, **kwargs):
-        """The T&C page is being shown."""
+    def on_tc_button_clicked(self, *args, **kwargs):
+        """The T&C button was clicked, create the browser and load terms."""
+        # delay the import of webkit to be able to build without it
+        import webkit
         browser = webkit.WebView()
+
+        # The signal WebKitWebView::load-finished is deprecated and should not
+        # be used in newly-written code. Use the "load-status" property
+        # instead. Connect to "notify::load-status" to monitor loading.
+
+        # nataliabidart (2010-10-04): connecting this signal makes the loading
+        # of the Ubuntu One terms URL to fail. So we're using the deprecated
+        # 'load-finished' for now.
+
+        #browser.connect('notify::load-status',
+        #                self.on_tc_browser_notify_load_status)
+        browser.connect('load-finished',
+                        self.on_tc_browser_notify_load_status)
+        browser.connect('navigation-policy-decision-requested',
+                        self.on_tc_browser_navigation_requested)
+
         settings = browser.get_settings()
         settings.set_property("enable-plugins", False)
         settings.set_property("enable-default-context-menu", False)
-        browser.open(self.tc_uri)
+
+        # webkit_web_view_open has been deprecated since version 1.1.1 and
+        # should not be used in newly-written code. Use
+        # webkit_web_view_load_uri() instead.
+        browser.load_uri(self.tc_url)
         browser.show()
         self.tc_browser_window.add(browser)
+        self._set_current_page(self.processing_vbox)
+
+    def on_tc_back_button_clicked(self, *args, **kwargs):
+        """T & C 'back' button was clicked, return to the previous page."""
+        self._set_current_page(self.enter_details_vbox)
+
+    def on_tc_browser_notify_load_status(self, browser, *args, **kwargs):
+        """The T&C page is being loaded."""
+        if browser.get_load_status() == WEBKIT_LOAD_FINISHED:
+            self._set_current_page(self.tc_browser_vbox)
+
+    def on_tc_browser_navigation_requested(self, browser, frame, request,
+                                           action, decision, *args, **kwargs):
+        """The user wants to navigate within the T&C browser."""
+        if action is not None and \
+           action.get_reason() == WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED:
+            if decision is not None:
+                decision.ignore()
+            url = action.get_original_uri()
+            webbrowser.open(url)
+        else:
+            if decision is not None:
+                decision.use()
 
     def on_tc_browser_vbox_hide(self, *args, **kwargs):
         """The T&C page is no longer being shown."""
@@ -987,10 +1025,21 @@
             result = msg1 if msg1 is not None else msg2
         return result
 
+    def _append_error_signal(self, signal, error):
+        """Append 'signal' to the log with a formatted version of 'error'.
+
+        Format DBus dict 'error' into a nice string.
+
+        """
+        msg = '\n'.join('%s: %s' % i for i in error.iteritems())
+        self._gtk_signal_log.append((signal, self.app_name, msg))
+
     @log_call
     def on_captcha_generated(self, app_name, captcha_id, *args, **kwargs):
         """Captcha image has been generated and is available to be shown."""
-        assert captcha_id is not None
+        if captcha_id is None:
+            logger.warning('on_captcha_generated: captcha_id is None for '
+                           'app_name "%s".', app_name)
         self._captcha_id = captcha_id
         self._set_captcha_image()
 
@@ -1021,9 +1070,7 @@
 
         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,
-                                    msg))
+        self._append_error_signal(SIG_REGISTRATION_FAILED, error)
 
     @log_call
     def on_email_validated(self, app_name, email, *args, **kwargs):
@@ -1041,9 +1088,7 @@
 
         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,
-                                     msg))
+        self._append_error_signal(SIG_REGISTRATION_FAILED, error)
 
     @log_call
     def on_logged_in(self, app_name, email, *args, **kwargs):
@@ -1057,8 +1102,7 @@
         """User was not successfully logged in."""
         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,
-                                     msg))
+        self._append_error_signal(SIG_LOGIN_FAILED, error)
 
     @log_call
     def on_password_reset_token_sent(self, app_name, email, *args, **kwargs):

=== modified file 'ubuntu_sso/keyring.py'
--- ubuntu_sso/keyring.py	2010-09-22 16:47:09 +0000
+++ ubuntu_sso/keyring.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # Copyright (C) 2010 Canonical
 #
 # Authors:

=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/logger.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # ubuntu_sso.logger - logging miscellany
 #
 # Author: Stuart Langridge <[e-mail]>
@@ -27,33 +29,32 @@
 
 from logging.handlers import RotatingFileHandler
 
+
 LOGFOLDER = os.path.join(xdg.BaseDirectory.xdg_cache_home, 'sso')
 # create log folder if it doesn't exists
 if not os.path.exists(LOGFOLDER):
     os.makedirs(LOGFOLDER)
 
-LOGFILENAME = os.path.join(LOGFOLDER, 'oauth-login.log')
-FMT = "%(asctime)s:%(msecs)s - %(name)s - %(levelname)s - %(message)s"
-
 if os.environ.get('DEBUG'):
     LOG_LEVEL = logging.DEBUG
 else:
     # Only log this level and above
     LOG_LEVEL = logging.INFO
 
+MAIN_HANDLER = RotatingFileHandler(os.path.join(LOGFOLDER, 'sso-client.log'),
+                                   maxBytes=1048576,
+                                   backupCount=5)
+MAIN_HANDLER.setLevel(LOG_LEVEL)
+FMT = "%(asctime)s:%(msecs)s - %(name)s - %(levelname)s - %(message)s"
+MAIN_HANDLER.setFormatter(logging.Formatter(fmt=FMT))
+
 
 def setup_logging(log_domain):
-    """Create basic logger to set filename"""
-    root_formatter = logging.Formatter(fmt=FMT)
-    root_handler = RotatingFileHandler(LOGFILENAME, maxBytes=1048576,
-                                       backupCount=5)
-    root_handler.setLevel(LOG_LEVEL)
-    root_handler.setFormatter(root_formatter)
-
+    """Create basic logger to set filename."""
     logger = logging.getLogger(log_domain)
     logger.propagate = False
     logger.setLevel(LOG_LEVEL)
-    logger.addHandler(root_handler)
+    logger.addHandler(MAIN_HANDLER)
     if os.environ.get('DEBUG'):
         debug_handler = logging.StreamHandler(sys.stderr)
         logger.addHandler(debug_handler)

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-09-14 19:28:09 +0000
+++ ubuntu_sso/main.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # ubuntu_sso.main - main login handling interface
 #
 # Author: Natalia Bidart <[e-mail]>
@@ -26,25 +28,18 @@
 """
 
 import os
-import re
 import threading
-import traceback
-import urllib2
+import warnings
 
 import dbus.service
-import gobject
-
-# Unable to import 'lazr.restfulclient.*'
-# pylint: disable=F0401
-from lazr.restfulclient.authorize import BasicHttpAuthorizer
-from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
-from lazr.restfulclient.errors import HTTPError
-from lazr.restfulclient.resource import ServiceRoot
-# pylint: enable=F0401
-from oauth import oauth
-
-from ubuntu_sso import DBUS_IFACE_USER_NAME, DBUS_IFACE_CRED_NAME
-from ubuntu_sso.keyring import Keyring, get_token_name, U1_APP_NAME
+
+from ubuntu_sso import (DBUS_ACCOUNT_PATH, DBUS_IFACE_USER_NAME,
+    DBUS_IFACE_CRED_NAME, DBUS_CREDENTIALS_IFACE)
+from ubuntu_sso.account import Account
+from ubuntu_sso.credentials import (Credentials, keyring_store_credentials,
+    HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY, WINDOW_ID_KEY,
+    SUCCESS_CB_KEY, ERROR_CB_KEY, DENIAL_CB_KEY, ERROR_KEY, ERROR_DETAIL_KEY)
+from ubuntu_sso.keyring import get_token_name, U1_APP_NAME
 from ubuntu_sso.logger import setup_logging
 
 
@@ -53,221 +48,21 @@
 
 
 logger = setup_logging("ubuntu_sso.main")
-PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
-SERVICE_URL = "https://login.ubuntu.com/api/1.0"
-
-
-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.
+U1_PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+
+
+class SSOLoginProcessor(Account):
+    """Login and register users using the Ubuntu Single Sign On service.
+
+    Alias classname to maintain backwards compatibility. DO NOT USE, use
+    ubuntu_sso.account.Account instead.
     """
 
-
-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):
-    """Store the credentials in the keyring."""
-    logger.info('keyring_store_credentials: app_name "%s".', app_name)
-    Keyring(app_name).set_ubuntusso_attr(credentials)
-
-
-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_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)
-        sso_service = self.sso_service_class(None, self.service_url)
-        if not self._valid_email(email):
-            logger.error('register_user: InvalidEmailError for email: %r',
-                         email)
-            raise InvalidEmailError()
-        if not self._valid_password(password):
-            logger.error('register_user: InvalidPasswordError')
-            raise InvalidPasswordError()
-
-        result = sso_service.registrations.register(
-                    email=email, password=password, captcha_id=captcha_id,
-                    captcha_solution=captcha_solution)
-        logger.info('register_user: 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 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 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)
+        """Create a new SSO Account manager."""
+        msg = 'Use ubuntu_sso.account.Account instead.'
+        warnings.warn(msg, DeprecationWarning)
+        super(SSOLoginProcessor, self).__init__(sso_service_class)
 
 
 def except_to_errdict(e):
@@ -304,11 +99,11 @@
     # Operator not preceded by a space (fails with dbus decorators)
     # pylint: disable=C0322
 
-    def __init__(self, bus_name,
-                 sso_login_processor_class=SSOLoginProcessor,
+    def __init__(self, bus_name, object_path=DBUS_ACCOUNT_PATH,
+                 sso_login_processor_class=Account,
                  sso_service_class=None):
         """Initiate the Login object."""
-        dbus.service.Object.__init__(self, object_path="/sso",
+        dbus.service.Object.__init__(self, object_path=object_path,
                                      bus_name=bus_name)
         self.sso_login_processor_class = sso_login_processor_class
         self.sso_service_class = sso_service_class
@@ -390,7 +185,6 @@
             credentials = self.processor().login(email, password, token_name)
             logger.debug('login returned not None credentials? %r.',
                          credentials is not None)
-            assert credentials is not None
             keyring_store_credentials(app_name, credentials)
             return email
         blocking(f, app_name, self.LoggedIn, self.LoginError)
@@ -476,103 +270,41 @@
 
     def __init__(self, *args, **kwargs):
         dbus.service.Object.__init__(self, *args, **kwargs)
-        self.ping_url = os.environ.get('USSOC_PING_URL', PING_URL)
+        self.ping_url = os.environ.get('USSOC_PING_URL', U1_PING_URL)
+
+    def _process_error(self, app_name, error_dict):
+        """Process the 'error_dict' and emit CredentialsError."""
+        msg = error_dict.get(ERROR_KEY, 'No error message given.')
+        detail = error_dict.get(ERROR_DETAIL_KEY, 'No detailed error given.')
+        self.CredentialsError(app_name, msg, detail)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
     def AuthorizationDenied(self, app_name):
         """Signal thrown when the user denies the authorization."""
-        logger.info('SSOLogin: emitting AuthorizationDenied with app_name '
-                    '"%s"', app_name)
+        logger.info('SSOCredentials: emitting AuthorizationDenied with '
+                    'app_name "%s"', app_name)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sa{ss}")
     def CredentialsFound(self, app_name, credentials):
         """Signal thrown when the credentials are found."""
-        logger.info('SSOLogin: emitting CredentialsFound with app_name "%s"',
-                    app_name)
+        logger.info('SSOCredentials: emitting CredentialsFound with '
+                    'app_name "%s"', app_name)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sss")
     def CredentialsError(self, app_name, error_message, detailed_error):
         """Signal thrown when there is a problem finding the credentials."""
-        logger.debug('SSOCredentials: emitting CredentialsError with app_name '
+        logger.error('SSOCredentials: emitting CredentialsError with app_name '
                      '"%s" and error_message %r', app_name, error_message)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          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)
+        """Get the credentials from the keyring or {} if not there."""
+        obj = Credentials(app_name=app_name)
+        token = obj.find_credentials()
         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', 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.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())
+                    app_name, token == {})
+        return token
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature="sssx", out_signature="")
@@ -589,24 +321,14 @@
          the GUI. If 0, no parent will be set.
 
         """
-        try:
-            token = keyring_get_credentials(app_name)
-            if token is None:
-                gobject.idle_add(self._show_login_or_register_ui,
-                                 app_name, terms_and_conditions_url,
-                                 help_text, window_id)
-            else:
-                self.CredentialsFound(app_name, token)
-        except:  # pylint: disable=W0702
-            msg = "Problem getting the credentials from the keyring."
-            logger.exception(msg)
-            self.CredentialsError(app_name, msg, traceback.format_exc())
-
-    def _show_login_only_ui(self, app_name, help_text, win_id):
-        """Shows the UI so the user can login."""
-        tc_url = None  # no terms and conditions when only logging in
-        self._show_login_or_register_ui(app_name, tc_url, help_text,
-                                        win_id, login_only=True)
+        ping_url = self.ping_url if app_name == U1_APP_NAME else None
+        obj = Credentials(app_name=app_name, ping_url=ping_url,
+                          tc_url=terms_and_conditions_url,
+                          help_text=help_text, window_id=window_id,
+                          success_cb=self.CredentialsFound,
+                          error_cb=self._process_error,
+                          denial_cb=self.AuthorizationDenied)
+        obj.register()
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature="ssx", out_signature="")
@@ -620,17 +342,13 @@
          the GUI. If 0, no parent will be set.
 
         """
-        try:
-            token = keyring_get_credentials(app_name)
-            if token is None:
-                gobject.idle_add(self._show_login_only_ui, app_name,
-                                 help_text, window_id)
-            else:
-                self.CredentialsFound(app_name, token)
-        except:  # pylint: disable=W0702
-            msg = "Problem getting the credentials from the keyring."
-            logger.exception(msg)
-            self.CredentialsError(app_name, msg, traceback.format_exc())
+        ping_url = self.ping_url if app_name == U1_APP_NAME else None
+        obj = Credentials(app_name=app_name, ping_url=ping_url, tc_url=None,
+                          help_text=help_text, window_id=window_id,
+                          success_cb=self.CredentialsFound,
+                          error_cb=self._process_error,
+                          denial_cb=self.AuthorizationDenied)
+        obj.login()
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature='s', out_signature='')
@@ -639,10 +357,133 @@
 
         'app_name' is the name of the application.
         """
-        try:
-            creds = Keyring(app_name)
-            creds.delete_ubuntusso_attr()
-        except:  # pylint: disable=W0702
-            logger.exception(
-                "problem removing credentials from keyring for %s",
-                app_name)
+        obj = Credentials(app_name=app_name)
+        obj.clear_credentials()
+
+
+class CredentialsManagement(dbus.service.Object):
+    """DBus object that manages credentials.
+
+    Every exposed method in this class requires one mandatory argument:
+
+        - 'app_name': the name of the application. Will be displayed in the
+        GUI header, plus it will be used to find/build/clear tokens.
+
+    And accepts another parameter named 'args', which is a dictionary that
+    can contain the following:
+
+        - 'help_text': an explanatory text for the end-users, will be
+        shown below the header. This is an optional free text field.
+
+        - 'ping_url': the url to open after successful token retrieval. If
+        defined, the email will be attached to the url and will be pinged
+        with a OAuth-signed request.
+
+        - 'tc_url': the link to the Terms and Conditions page. If defined,
+        the checkbox to agree to the terms will link to it.
+
+        - 'window_id': the id of the window which will be set as a parent
+        of the GUI. If not defined, no parent will be set.
+
+    """
+
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
+    def _parse_args(self, args):
+        """Retrieve values from the generic param 'args'."""
+        result = dict((k, v) for k, v in args.iteritems() if k in
+                      (HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY, WINDOW_ID_KEY))
+        result[WINDOW_ID_KEY] = int(args.get(WINDOW_ID_KEY, 0))
+        result[SUCCESS_CB_KEY] = self.CredentialsFound
+        result[ERROR_CB_KEY] = self.CredentialsError
+        result[DENIAL_CB_KEY] = self.AuthorizationDenied
+        return result
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def AuthorizationDenied(self, app_name):
+        """Signal thrown when the user denies the authorization."""
+        logger.info('%s: emitting AuthorizationDenied with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsFound(self, app_name, credentials):
+        """Signal thrown when the credentials are found."""
+        logger.info('%s: emitting CredentialsFound with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsNotFound(self, app_name):
+        """Signal thrown when the credentials are not found."""
+        logger.info('%s: emitting CredentialsNotFound with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsCleared(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+        logger.info('%s: emitting CredentialsCleared with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsError(self, app_name, error_dict):
+        """Signal thrown when there is a problem getting the credentials."""
+        logger.error('%s: emitting CredentialsError with app_name "%s" and '
+                     'error_dict %r.', self.__class__.__name__, app_name,
+                     error_dict)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def find_credentials(self, app_name, args):
+        """Look for the credentials for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be removed.
+
+        - 'args' is a dictionary, currently not used.
+
+        """
+        obj = Credentials(app_name)
+
+        def success_cb(app, token):
+            """Find credentials and notify using signals."""
+            if token is not None and len(token) > 0:
+                self.CredentialsFound(app, token)
+            else:
+                self.CredentialsNotFound(app)
+
+        blocking(obj.find_credentials, app_name,
+                 success_cb, self.CredentialsError)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def clear_credentials(self, app_name, args):
+        """Clear the token for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be removed.
+
+        - 'args' is a dictionary, currently not used.
+
+        """
+        obj = Credentials(app_name)
+
+        def success_cb(app_name, result):
+            """Clear credentials and notify using signals."""
+            self.CredentialsCleared(app_name)
+
+        blocking(obj.clear_credentials, app_name,
+                 success_cb, self.CredentialsError)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def register(self, app_name, args):
+        """Get credentials if found else prompt GUI to register."""
+        obj = Credentials(app_name, **self._parse_args(args))
+        obj.register()
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def login(self, app_name, args):
+        """Get credentials if found else prompt GUI to login."""
+        obj = Credentials(app_name, **self._parse_args(args))
+        obj.login()

=== modified file 'ubuntu_sso/networkstate.py'
--- ubuntu_sso/networkstate.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/networkstate.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # networkstate - detect the current state of the network
 #
 # Author: Alejandro J. Cura <[e-mail]>

=== modified file 'ubuntu_sso/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/tests/__init__.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # Copyright 2009 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -12,4 +14,32 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-"""Tests for OAuth library."""
+"""Tests for the Ubuntu SSO library."""
+
+import os
+
+from ubuntu_sso.keyring import get_token_name
+
+APP_NAME = 'The Super App!'
+CAPTCHA_ID = 'test'
+CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
+                                            'files', 'captcha.png'))
+CAPTCHA_SOLUTION = 'william Byrd'
+EMAIL = '[e-mail]'
+EMAIL_TOKEN = 'B2Pgtf'
+HELP_TEXT = """Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam sed
+lorem nibh. Suspendisse gravida nulla non nunc suscipit pulvinar tempus ut
+augue. Morbi consequat, ligula a elementum pretium, dolor nulla tempus metus,
+sed viverra nisi risus non velit."""
+NAME = 'Juanito Pérez'
+PASSWORD = 'h3lloWorld'
+PING_URL = 'http://localhost/ping-me/'
+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)
+TC_URL = 'http://localhost/'
+WINDOW_ID = 5

=== modified file 'ubuntu_sso/tests/bin/show_gui'
--- ubuntu_sso/tests/bin/show_gui	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/tests/bin/show_gui	2010-10-18 13:21:21 +0000
@@ -26,7 +26,7 @@
 
 
 APP_NAME = 'Ubuntu'
-TC_URI = 'http://one.ubuntu.com/terms'
+TC_URL = 'http://one.ubuntu.com/terms'
 HELP_TEXT = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
             'Nam sed lorem nibh. Suspendisse gravida nulla non nunc suscipit' \
             ' pulvinar tempus ut augue.'
@@ -35,13 +35,13 @@
 
 
 if __name__ == '__main__':
-    tc_uri=TC_URI
+    tc_url=TC_URL
     login_only = False
     xid = 0
 
     if '--login' in sys.argv:
         login_only = True
-        tc_uri = None
+        tc_url = None
 
     if '--with-parent-window' in sys.argv:
         win = gtk.Window()
@@ -52,6 +52,6 @@
         xid = win.window.xid
 
     UbuntuSSOClientGUI(close_callback=main_quit, app_name=APP_NAME,
-                       tc_uri=tc_uri, help_text=HELP_TEXT, window_id=xid,
+                       tc_url=tc_url, help_text=HELP_TEXT, window_id=xid,
                        login_only=login_only)
     gtk.main()

=== added file 'ubuntu_sso/tests/test_account.py'
--- ubuntu_sso/tests/test_account.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/test_account.py	2010-10-18 13:21:21 +0000
@@ -0,0 +1,335 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the SSO account code."""
+
+import os
+
+# Unable to import 'lazr.restfulclient.*'
+# pylint: disable=F0401
+from lazr.restfulclient.errors import HTTPError
+# pylint: enable=F0401
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso.account import (Account, AuthenticationError, EmailTokenError,
+    InvalidEmailError, InvalidPasswordError, NewPasswordError, SERVICE_URL,
+    RegistrationError, ResetPasswordTokenError)
+from ubuntu_sso.tests import (APP_NAME, CAPTCHA_ID, CAPTCHA_PATH,
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, PASSWORD, RESET_PASSWORD_TOKEN,
+    TOKEN, TOKEN_NAME)
+
+
+CANT_RESET_PASSWORD_CONTENT = "CanNotResetPassowrdError: " \
+                              "Can't reset password for this account"
+RESET_TOKEN_INVALID_CONTENT = "AuthToken matching query does not exist."
+EMAIL_ALREADY_REGISTERED = '[e-mail]'
+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}
+
+
+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, 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 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
+
+
+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 AccountTestCase(TestCase):
+    """Test suite for the SSO login processor."""
+
+    def setUp(self):
+        """Init."""
+        self.processor = Account(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.')
+
+    # 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 EnvironOverridesTestCase(TestCase):
+    """Some URLs can be set from the environment for testing/QA purposes."""
+
+    def test_override_service_url(self):
+        """The service url can be set from the env var USSOC_SERVICE_URL."""
+        fake_url = 'this is not really a URL'
+        old_url = os.environ.get('USSOC_SERVICE_URL')
+        os.environ['USSOC_SERVICE_URL'] = fake_url
+        try:
+            proc = Account(sso_service_class=FakedSSOServer)
+            self.assertEqual(proc.service_url, fake_url)
+        finally:
+            if old_url:
+                os.environ['USSOC_SERVICE_URL'] = old_url
+            else:
+                del os.environ['USSOC_SERVICE_URL']
+
+    def test_no_override_service_url(self):
+        """If the environ is unset, the default service url is used."""
+        proc = Account(sso_service_class=FakedSSOServer)
+        self.assertEqual(proc.service_url, SERVICE_URL)

=== added file 'ubuntu_sso/tests/test_credentials.py'
--- ubuntu_sso/tests/test_credentials.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/test_credentials.py	2010-10-18 13:21:21 +0000
@@ -0,0 +1,444 @@
+# -*- coding: utf-8 -*-
+
+# Author: Natalia Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the Credentials module."""
+
+import logging
+import urllib
+
+import gobject
+
+from twisted.trial.unittest import TestCase, FailTest
+
+from contrib.testing.testcase import MementoHandler
+from ubuntu_sso import credentials, gui
+from ubuntu_sso.credentials import (APP_NAME_KEY, HELP_TEXT_KEY, NO_OP,
+    PING_URL_KEY, TC_URL_KEY, WINDOW_ID_KEY, ERROR_KEY, ERROR_DETAIL_KEY)
+from ubuntu_sso.tests import (APP_NAME, EMAIL, HELP_TEXT, PING_URL, TC_URL,
+    TOKEN, WINDOW_ID)
+
+
+# Access to a protected member of a client class
+# pylint: disable=W0212
+
+# Attribute defined outside __init__
+# pylint: disable=W0201
+
+
+KWARGS = {
+    APP_NAME_KEY: APP_NAME,
+    TC_URL_KEY: TC_URL,
+    HELP_TEXT_KEY: HELP_TEXT,
+    WINDOW_ID_KEY: WINDOW_ID,
+    PING_URL_KEY: PING_URL,
+}
+
+
+class BasicTestCase(TestCase):
+    """Test case with a helper tracker."""
+
+    def setUp(self):
+        """Init."""
+        self.patch(gobject, 'idle_add', lambda f, *a, **kw: f(*a, **kw))
+        self._called = False  # helper
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        credentials.logger.addHandler(self.memento)
+
+    def tearDown(self):
+        """Clean up."""
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Set _called to True."""
+        self._called = (args, kwargs)
+
+
+class CredentialsTestCase(BasicTestCase):
+    """Test suite for the Credentials class."""
+
+    def setUp(self):
+        """Init."""
+        super(CredentialsTestCase, self).setUp()
+        self.args = None
+        self.kwargs = None
+        self.signals = []
+
+        class FakedUbuntuSSOClientGUI(object):
+            """Fake a SSO GUI."""
+
+            # Method should have 'self' as first argument
+            # pylint: disable=E0213
+
+            def __init__(sself, *args, **kwargs):
+                self.args = args
+                self.kwargs = kwargs
+                sself.connect = lambda *a: self.signals.append(a)
+
+        self.patch(credentials.keyring.gnomekeyring, 'is_available',
+                   lambda: True)
+        self.patch(gui, 'UbuntuSSOClientGUI', FakedUbuntuSSOClientGUI)
+        self.obj = credentials.Credentials(success_cb=self.success,
+                                           error_cb=self.error,
+                                           denial_cb=self.denial,
+                                           **KWARGS)
+
+    def tearDown(self):
+        """Clean up."""
+        super(CredentialsTestCase, self).tearDown()
+
+    def success(self, *args, **kwargs):
+        """To be called on success."""
+        self._set_called('success', *args, **kwargs)
+
+    def error(self, *args, **kwargs):
+        """To be called on error."""
+        self._set_called('error', *args, **kwargs)
+
+    def denial(self, *args, **kwargs):
+        """To be called on credentials denial."""
+        self._set_called('denial', *args, **kwargs)
+
+    def assert_error_cb_called(self, msg, detailed_error=None):
+        """Check that self.error_cb was called with proper arguments."""
+        self.assertEqual(len(self._called), 2)
+        self.assertEqual(self._called[0][0], 'error')
+        self.assertEqual(self._called[0][1], APP_NAME)
+        error_dict = self._called[0][2]
+        self.assertEqual(error_dict[ERROR_KEY], msg)
+        if detailed_error is not None:
+            self.assertIn(str(detailed_error), error_dict[ERROR_DETAIL_KEY])
+        else:
+            self.assertNotIn(ERROR_DETAIL_KEY, error_dict)
+        self.assertEqual(self._called[1], {})
+
+
+class CredentialsCallbacksTestCase(CredentialsTestCase):
+    """Test suite for the Credentials callbacks."""
+
+    def test_callbacks_are_stored(self):
+        """Creation callbacks are stored."""
+        self.assertEqual(self.obj.success_cb, self.success)
+        self.assertEqual(self.obj.error_cb, self.error)
+        self.assertEqual(self.obj.denial_cb, self.denial)
+
+    def test_callbacks_default_to_no_op(self):
+        """The callbacks are a no-operation if not given."""
+        self.obj = credentials.Credentials(**KWARGS)
+        self.assertEqual(self.obj.success_cb, NO_OP)
+        self.assertEqual(self.obj.error_cb, NO_OP)
+        self.assertEqual(self.obj.denial_cb, NO_OP)
+
+    def test_creation_parameters_are_stored(self):
+        """Creation parameters are stored."""
+        for key, value in KWARGS.iteritems():
+            self.assertEqual(getattr(self.obj, key), value)
+
+    def test_tc_url_defaults_to_none(self):
+        """The T&C url defaults to None."""
+        newkw = KWARGS.copy()
+        newkw.pop(TC_URL_KEY)
+        self.obj = credentials.Credentials(**newkw)
+
+        self.assertEqual(getattr(self.obj, TC_URL_KEY), None)
+
+    def test_help_text_defaults_to_empty_string(self):
+        """The T&C url defaults to the emtpy string."""
+        newkw = KWARGS.copy()
+        newkw.pop(HELP_TEXT_KEY)
+        self.obj = credentials.Credentials(**newkw)
+
+        self.assertEqual(getattr(self.obj, HELP_TEXT_KEY), '')
+
+    def test_window_id_defaults_to_zero(self):
+        """The T&C url defaults to 0."""
+        newkw = KWARGS.copy()
+        newkw.pop(WINDOW_ID_KEY)
+        self.obj = credentials.Credentials(**newkw)
+
+        self.assertEqual(getattr(self.obj, WINDOW_ID_KEY), 0)
+
+    def test_ping_url_defaults_to_none(self):
+        """The ping url defaults to None."""
+        newkw = KWARGS.copy()
+        newkw.pop(PING_URL_KEY)
+        self.obj = credentials.Credentials(**newkw)
+
+        self.assertEqual(getattr(self.obj, PING_URL_KEY), None)
+
+    def test_login_success_cb_if_cred_not_found(self):
+        """On auth success, if cred not found, self.error_cb is called."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: None)
+
+        self.obj._login_success_cb(dialog=None, app_name=APP_NAME, email=EMAIL)
+
+        msg = 'Creds are empty! This should not happen'
+        self.assert_error_cb_called(msg='Problem while retrieving credentials',
+                                    detailed_error=AssertionError(msg))
+
+    def test_login_success_cb_if_cred_error(self):
+        """On auth success, if cred failed, self.error_cb is called."""
+        self.patch(credentials, 'keyring_get_credentials', self.fail)
+
+        self.obj._login_success_cb(dialog=None, app_name=APP_NAME, email=EMAIL)
+
+        msg = 'Problem while retrieving credentials'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(APP_NAME))
+        self.assertTrue(self.memento.check_exception(FailTest, APP_NAME))
+
+    def test_login_success_cb_if_ping_success(self):
+        """Auth success + cred found + ping success, success_cb is called."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
+        self.patch(self.obj, '_ping_url', lambda *a, **kw: 200)
+
+        self.obj._login_success_cb(dialog=None, app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
+
+    def test_login_success_cb_if_ping_error(self):
+        """Auth success + cred found + ping error, error_cb is called.
+
+        Credentials are removed. The exception is logged.
+        """
+        self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
+        error = 'Bla'
+        self.patch(credentials.urllib2, 'urlopen',
+                   lambda *a, **kw: self.fail(error))
+        self._cred_cleared = False
+        self.patch(self.obj, 'clear_credentials',
+                   lambda: setattr(self, '_cred_cleared', True))
+
+        self.obj._login_success_cb(dialog=None, app_name=APP_NAME, email=EMAIL)
+
+        # error cb called correctly
+        msg = 'Problem opening the ping_url'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(error))
+
+        # credentials cleared
+        self.assertTrue(self._cred_cleared)
+
+        # exception logged
+        self.assertTrue(self.memento.check_exception(FailTest, error))
+
+    def test_login_success_cb_pings_url(self):
+        """On auth success, self.ping_url is opened."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
+
+        self._url_pinged = False
+        self.patch(self.obj, '_ping_url',
+                   lambda *a, **kw: setattr(self, '_url_pinged', (a, kw)))
+
+        self.obj._login_success_cb(dialog=None, app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._url_pinged, ((APP_NAME, EMAIL, TOKEN), {}))
+
+    def test_login_error_cb(self):
+        """On login/register error, self.error_cb is called."""
+        self.obj._login_error_cb(dialog=None, app_name=APP_NAME, error='Bla')
+        self.assert_error_cb_called(msg='Bla')
+
+    def test_auth_denial_cb(self):
+        """On auth denied, self.denial_cb is called."""
+        self.obj._auth_denial_cb(dialog=None, app_name=APP_NAME)
+        self.assertEqual(self._called, (('denial', APP_NAME), {}))
+
+
+class PingUrlTestCase(CredentialsTestCase):
+    """Test suite for the URL pinging."""
+
+    def setUp(self):
+        super(PingUrlTestCase, self).setUp()
+        self._request = None
+
+        def faked_urlopen(request):
+            """Fake urlopener."""
+            self._request = request
+            response = urllib.addinfourl(fp=open('/dev/null'),
+                                         headers=request.headers,
+                                         url=request.get_full_url(),
+                                         code=200)
+            return response
+
+        self.patch(credentials.urllib2, 'urlopen', faked_urlopen)
+
+    def test_ping_url_if_url_is_none(self):
+        """self.ping_url is opened."""
+        self.patch(credentials.urllib2, 'urlopen', self.fail)
+        self.obj.ping_url = None
+        self.obj._ping_url(app_name=APP_NAME, email=EMAIL, credentials=TOKEN)
+        # no failure
+
+    def test_ping_url(self):
+        """On auth success, self.ping_url is opened."""
+        self.obj._ping_url(app_name=APP_NAME, email=EMAIL, credentials=TOKEN)
+
+        self.assertIsInstance(self._request, credentials.urllib2.Request)
+        self.assertEqual(self._request.get_full_url(),
+                         self.obj.ping_url + EMAIL)
+
+    def test_request_is_signed_with_credentials(self):
+        """The http request to self.ping_url is signed with the credentials."""
+        result = self.obj._ping_url(APP_NAME, EMAIL, TOKEN)
+        headers = self._request.headers
+
+        self.assertIn('Authorization', headers)
+        oauth_stuff = headers['Authorization']
+
+        expected = 'oauth_consumer_key="xQ7xDAz", ' \
+            'oauth_signature_method="HMAC-SHA1", oauth_version="1.0", ' \
+            'oauth_token="GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo' \
+            '", oauth_signature="'
+        self.assertIn(expected, oauth_stuff)
+        self.assertEqual(result, 200)
+
+    def test_ping_url_error(self):
+        """Exception is handled if ping fails."""
+        error = 'Blu'
+        self.patch(credentials.urllib2, 'urlopen', lambda r: self.fail(error))
+
+        self.obj._ping_url(APP_NAME, EMAIL, TOKEN)
+
+        msg = 'Problem opening the ping_url'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(error))
+        self.assertTrue(self.memento.check_exception(FailTest, error))
+
+
+class FindCredentialsTestCase(CredentialsTestCase):
+    """Test suite for the find_credentials method."""
+
+    def test_find_credentials(self):
+        """The credentials are immediately returned if found."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
+
+        token = self.obj.find_credentials()
+        self.assertEqual(token, TOKEN)
+
+    def test_credentials_not_found(self):
+        """find_credentials immediately returns '' when no token found."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: None)
+
+        token = self.obj.find_credentials()
+        self.assertEqual(token, {})
+
+    def test_keyring_failure(self):
+        """Failures from the keyring are handled."""
+        self.patch(credentials, 'keyring_get_credentials', self.fail)
+
+        self.obj.find_credentials()
+
+        msg = 'Problem while retrieving credentials'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(APP_NAME))
+        self.assertTrue(self.memento.check_exception(FailTest, APP_NAME))
+
+
+class ClearCredentialsTestCase(CredentialsTestCase):
+    """Test suite for the clear_credentials method."""
+
+    def test_clear_credentials(self):
+        """The credentials are cleared."""
+        self.patch(credentials, 'keyring_delete_credentials', self._set_called)
+
+        self.obj.clear_credentials()
+        self.assertEqual(self._called, ((APP_NAME,), {}))
+
+    def test_removed_from_keyring(self):
+        """The credentials are cleared from the keyring."""
+        self.patch(credentials.keyring.Keyring, 'delete_ubuntusso_attr',
+                   self._set_called)
+
+        self.obj.clear_credentials()
+        self.assertEqual(self._called, ((), {}))
+
+    def test_keyring_failure(self):
+        """Failures from the keyring are handled."""
+        self.patch(credentials, 'keyring_delete_credentials', self.fail)
+
+        self.obj.clear_credentials()
+
+        msg = 'Problem while deleting credentials'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(APP_NAME))
+        self.assertTrue(self.memento.check_exception(FailTest, APP_NAME))
+
+
+class RegisterTestCase(CredentialsTestCase):
+    """Test suite for the register method."""
+
+    operation = 'register'
+    login_only = False
+
+    def test_with_existent_token(self):
+        """The operation returns the credentials if already in keyring."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: TOKEN)
+
+        getattr(self.obj, self.operation)()
+
+        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
+
+    def test_without_existent_token(self):
+        """The operation returns the credentials gathered by the GUI."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: None)
+
+        getattr(self.obj, self.operation)()
+
+        expected = KWARGS.copy()
+        expected.pop(PING_URL_KEY)
+        expected['login_only'] = self.login_only
+        self.assertEqual(expected, self.kwargs)
+
+    def test_with_exception_on_credentials(self):
+        """The operation calls the error callback if a exception occurs."""
+        self.patch(credentials, 'keyring_get_credentials', self.fail)
+
+        getattr(self.obj, self.operation)()
+
+        msg = 'Problem while retrieving credentials'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(APP_NAME))
+        self.assertTrue(self.memento.check_exception(FailTest, APP_NAME))
+
+    def test_with_exception_on_gui(self):
+        """The operation calls the error callback if a GUI exception occurs."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: None)
+        err = 'Ble'
+        self.patch(gui, 'UbuntuSSOClientGUI', lambda *a, **kw: self.fail(err))
+
+        getattr(self.obj, self.operation)()
+
+        msg = 'Problem opening the Ubuntu SSO user interface'
+        self.assert_error_cb_called(msg=msg, detailed_error=FailTest(err))
+        self.assertTrue(self.memento.check_exception(FailTest, err))
+
+    def test_connects_gui_signals(self):
+        """Outcome signals from GUI are connected to callbacks."""
+        self.patch(credentials, 'keyring_get_credentials', lambda app: None)
+
+        expected = [
+            (gui.SIG_LOGIN_SUCCEEDED, self.obj._login_success_cb),
+            (gui.SIG_LOGIN_FAILED, self.obj._login_error_cb),
+            (gui.SIG_REGISTRATION_SUCCEEDED, self.obj._login_success_cb),
+            (gui.SIG_REGISTRATION_FAILED, self.obj._login_error_cb),
+            (gui.SIG_USER_CANCELATION, self.obj._auth_denial_cb),
+        ]
+        getattr(self.obj, self.operation)()
+        self.assertEqual(self.signals, expected)
+
+
+class LoginTestCase(RegisterTestCase):
+    """Test suite for the login method."""
+
+    operation = 'login'
+    login_only = True

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-10-18 13:21:21 +0000
@@ -23,6 +23,8 @@
 import logging
 import os
 
+from collections import defaultdict
+
 import dbus
 import gtk
 import webkit
@@ -31,31 +33,17 @@
 
 from contrib.testing.testcase import MementoHandler
 from ubuntu_sso import gui
+from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, RESET_PASSWORD_TOKEN)
 
 
 # Access to a protected member 'yyy' of a client class
 # pylint: disable=W0212
+
 # Instance of 'UbuntuSSOClientGUI' has no 'yyy' member
 # pylint: disable=E1101,E1103
 
 
-APP_NAME = 'The Super testing app!'
-TC_URI = 'http://localhost'
-HELP_TEXT = """Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam sed
-lorem nibh. Suspendisse gravida nulla non nunc suscipit pulvinar tempus ut
-augue. Morbi consequat, ligula a elementum pretium, dolor nulla tempus metus,
-sed viverra nisi risus non velit."""
-
-CAPTCHA_ID = 'test'
-CAPTCHA_SOLUTION = 'william Byrd'
-EMAIL = '[e-mail]'
-EMAIL_TOKEN = 'B2Pgtf'
-NAME = 'Juanito Pérez'
-PASSWORD = 'h3lloWorld'
-RESET_PASSWORD_TOKEN = '8G5Wtq'
-TOKEN_NAME = 'my-testing-host'
-
-
 class FakedSSOBackend(object):
     """Fake a SSO Backend (acts as a dbus.Interface as well)."""
 
@@ -107,7 +95,8 @@
     def get_object(self, bus_name, object_path, introspect=True,
                    follow_name_owner_changes=False, **kwargs):
         """Return a faked proxy for the given remote object."""
-        if bus_name == gui.DBUS_BUS_NAME and object_path == gui.DBUS_PATH:
+        if bus_name == gui.DBUS_BUS_NAME and \
+           object_path == gui.DBUS_ACCOUNT_PATH:
             assert self.obj is None
             kwargs = dict(object_path=object_path,
                           bus_name=bus_name, follow_name_owner_changes=True)
@@ -115,6 +104,56 @@
         return self.obj
 
 
+class Settings(dict):
+    """Faked embedded browser settings."""
+
+    def get_property(self, prop_name):
+        """Alias for __getitem__."""
+        return self[prop_name]
+
+    def set_property(self, prop_name, newval):
+        """Alias for __setitem__."""
+        self[prop_name] = newval
+
+
+class FakedEmbeddedBrowser(gtk.TextView):
+    """Faked an embedded browser."""
+
+    def __init__(self):
+        super(FakedEmbeddedBrowser, self).__init__()
+        self._props = {}
+        self._signals = defaultdict(list)
+        self._settings = Settings()
+
+    def connect(self, signal_name, callback):
+        """Connect 'signal_name' with 'callback'."""
+        self._signals[signal_name].append(callback)
+
+    def load_uri(self, uri):
+        """Navigate to the given 'uri'."""
+        self._props['uri'] = uri
+
+    def set_property(self, prop_name, newval):
+        """Set 'prop_name' to 'newval'."""
+        self._props[prop_name] = newval
+
+    def get_property(self, prop_name):
+        """Return the current value for 'prop_name'."""
+        return self._props[prop_name]
+
+    def get_settings(self,):
+        """Return the current settings."""
+        return self._settings
+
+    def get_load_status(self):
+        """Return the current load status."""
+        return gui.WEBKIT_LOAD_FINISHED
+
+    def show(self):
+        """Show this instance."""
+        self.set_property('visible', True)
+
+
 class BasicTestCase(TestCase):
     """Test case with a helper tracker."""
 
@@ -340,7 +379,7 @@
     """Basic setup and helper functions."""
 
     gui_class = gui.UbuntuSSOClientGUI
-    kwargs = dict(app_name=APP_NAME, tc_uri=TC_URI, help_text=HELP_TEXT)
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT)
 
     def setUp(self):
         """Init."""
@@ -498,7 +537,7 @@
         """SessionBus.get_object is called properly."""
         self.assertIsInstance(self.ui.bus.obj, FakedDbusObject)
         self.assertEqual(self.ui.bus.obj._args, ())
-        expected = dict(object_path=gui.DBUS_PATH,
+        expected = dict(object_path=gui.DBUS_ACCOUNT_PATH,
                         bus_name=gui.DBUS_BUS_NAME,
                         follow_name_owner_changes=True)
         self.assertEqual(expected, self.ui.bus.obj._kwargs)
@@ -549,6 +588,13 @@
             # text content is correct
             self.assertEqual(expected, actual, msg % (name, expected, actual))
 
+    def test_entries_activates_default(self):
+        """Entries have the activates default prop set."""
+        msg = '"%s" must have activates_default set to True.'
+        for name in self.ui.entries:
+            entry = getattr(self.ui, name)
+            self.assertTrue(entry.get_activates_default(), msg % (name,))
+
     def test_initial_size_for_labels(self):
         """Labels have the correct width."""
         expected = (int(self.ui.window.get_size_request()[0] * 0.9), -1)
@@ -585,17 +631,6 @@
             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())
@@ -790,6 +825,13 @@
         self.assertTrue(self.ui.captcha_image.get_property('visible'))
         self.assertEqual(self._called, ((self.ui._captcha_filename,), {}))
 
+    def test_on_captcha_generated_logs_captcha_id_when_none(self):
+        """If the captcha id is None, a warning is logged."""
+        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=None)
+        self.assertTrue(self.memento.check(logging.WARNING, APP_NAME))
+        self.assertTrue(self.memento.check(logging.WARNING,
+                                           'captcha_id is None'))
+
     def test_captcha_reload_button_visible(self):
         """The captcha reload button is initially visible."""
         self.assertTrue(self.ui.captcha_reload_button.get_visible(),
@@ -812,38 +854,6 @@
         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.email1_entry, 'get_text', self._set_called)
@@ -860,11 +870,11 @@
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (with no t&c link)."""
 
-    kwargs = dict(app_name=APP_NAME, tc_uri='', help_text=HELP_TEXT)
+    kwargs = dict(app_name=APP_NAME, tc_url='', help_text=HELP_TEXT)
 
     def test_no_tc_link(self):
         """The T&C button and checkbox are not shown if no link is provided"""
-        self.assertEqual(self.ui.tc_hbox.get_visible(), False)
+        self.assertEqual(self.ui.tc_vbox.get_visible(), False)
 
 
 class TermsAndConditionsTestCase(UbuntuSSOClientTestCase):
@@ -875,61 +885,160 @@
         self.assertEqual(self.ui.tc_button.get_visible(), True)
         self.assertEqual(self.ui.yes_to_tc_checkbutton.get_visible(), True)
 
+
+class TermsAndConditionsBrowserTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the terms & conditions browser."""
+
+    def setUp(self):
+        super(TermsAndConditionsBrowserTestCase, self).setUp()
+        self.patch(webkit, 'WebView', FakedEmbeddedBrowser)
+
+        self.ui.tc_button.clicked()
+        children = self.ui.tc_browser_window.get_children()
+        assert len(children) == 1
+        self.browser = children[0]
+
+    def tearDown(self):
+        self.ui.tc_browser_vbox.hide()
+        super(TermsAndConditionsBrowserTestCase, self).tearDown()
+
     def test_tc_browser_is_created_when_tc_page_is_shown(self):
-        """The webkit browser is created when the TC page is shown."""
-        self.ui.tc_browser_vbox.show()
+        """The browser is created when the TC button is clicked."""
+        self.ui.on_tc_browser_notify_load_status(self.browser)
 
         children = self.ui.tc_browser_window.get_children()
         self.assertEqual(1, len(children))
-        browser = children[0]
-        self.assertIsInstance(browser, webkit.WebView)
-        self.assertTrue(browser.get_property('visible'))
-
-        settings = browser.get_settings()
+
+    def test_is_visible(self):
+        """The browser is visible."""
+        self.assertIsInstance(self.browser, FakedEmbeddedBrowser)
+        self.assertTrue(self.browser.get_property('visible'))
+
+    def test_settings(self):
+        """The browser settings are correct."""
+        settings = self.browser.get_settings()
         self.assertFalse(settings.get_property('enable-plugins'))
         self.assertFalse(settings.get_property('enable-default-context-menu'))
 
-        self.ui.tc_browser_vbox.hide()
-
     def test_tc_browser_is_destroyed_when_tc_page_is_hid(self):
-        """The webkit browser is destroyed when the TC page is hid."""
-        self.ui.tc_browser_vbox.show()
-        browser = self.ui.tc_browser_window.get_children()[0]
-        self.patch(browser, 'destroy', self._set_called)
+        """The browser is destroyed when the TC page is hid."""
+        self.ui.on_tc_browser_notify_load_status(self.browser)
+        self.patch(self.browser, 'destroy', self._set_called)
+        self.ui.tc_browser_vbox.hide()
+        self.assertEqual(self._called, ((), {}))
+
+    def test_tc_browser_is_removed_when_tc_page_is_hid(self):
+        """The browser is removed when the TC page is hid."""
+        self.ui.on_tc_browser_notify_load_status(self.browser)
+
         self.ui.tc_browser_vbox.hide()
 
         children = self.ui.tc_browser_window.get_children()
         self.assertEqual(0, len(children))
-        self.assertEqual(self._called, ((), {}))
 
-    def test_tc_button_clicked_morphs_into_tc_browser_vbox(self):
-        """Terms & Conditions morphs to a browser window."""
-        self.ui.tc_button.clicked()
-        self.assert_pages_visibility(tc_browser=True)
+    def test_tc_button_clicked_morphs_into_processing_page(self):
+        """Clicking the T&C button morphs into processing page."""
+        self.assert_pages_visibility(processing=True)
 
     def test_tc_back_clicked_returns_to_previous_page(self):
         """Terms & Conditions back button return to previous page."""
-        self.ui.tc_button.clicked()
+        self.ui.on_tc_browser_notify_load_status(self.browser)
         self.ui.tc_back_button.clicked()
         self.assert_pages_visibility(enter_details=True)
 
     def test_tc_button_has_the_proper_wording(self):
         """Terms & Conditions has the proper wording."""
-        self.assertEqual(self.ui.tc_button.get_label(), self.ui.TC)
+        self.assertEqual(self.ui.tc_button.get_label(), self.ui.TC_BUTTON)
 
     def test_tc_has_no_help_text(self):
         """The help text is removed."""
-        self.ui.tc_button.clicked()
+        self.ui.on_tc_browser_notify_load_status(self.browser)
         self.assertEqual('', self.ui.help_label.get_text())
 
-    def test_tc_browser_opens_the_proper_uri(self):
+    def test_tc_browser_opens_the_proper_url(self):
         """Terms & Conditions browser shows the proper uri."""
-        self.ui.tc_button.clicked()
-        self.assertEqual(self.ui.tc_browser.get_property('uri'), TC_URI)
+        self.assertEqual(self.browser.get_property('uri'), TC_URL)
+
+    def test_notify_load_status_connected(self):
+        """The 'notify::load-status' signal is connected."""
+        expected = [self.ui.on_tc_browser_notify_load_status]
+        self.assertEqual(self.browser._signals['notify::load-status'],
+                         expected)
 
     # Unused variable 'skip'
     # pylint: disable=W0612
-    test_tc_browser_opens_the_proper_uri.skip = 'The freaking test wont work.'
+    test_notify_load_status_connected.skip = \
+        'Connecting to notify::load-status makes U1 terms navigation fail.'
+
+    def test_notify_load_finished_connected(self):
+        """The 'load-finished' signal is connected."""
+        expected = [self.ui.on_tc_browser_notify_load_status]
+        self.assertEqual(self.browser._signals['load-finished'],
+                         expected)
+
+    def test_tc_loaded_morphs_into_tc_browser_vbox(self):
+        """When the Terms & Conditions is loaded, show the browser window."""
+        self.ui.on_tc_browser_notify_load_status(self.browser)
+        self.assert_pages_visibility(tc_browser=True)
+
+    def test_navigation_requested_connected(self):
+        """The 'navigation-policy-decision-requested' signal is connected."""
+        actual = self.browser._signals['navigation-policy-decision-requested']
+        expected = [self.ui.on_tc_browser_navigation_requested]
+        self.assertEqual(actual, expected)
+
+    def test_navigation_requested_succeeds_for_no_clicking(self):
+        """The navigation request succeeds when user hasn't clicked a link."""
+        action = webkit.WebNavigationAction()
+        action.set_reason(gui.WEBKIT_WEB_NAVIGATION_REASON_OTHER)
+
+        decision = webkit.WebPolicyDecision()
+        decision.use = self._set_called
+
+        kwargs = dict(browser=self.browser, frame=None, request=None,
+                      action=action, decision=decision)
+        self.ui.on_tc_browser_navigation_requested(**kwargs)
+        self.assertEqual(self._called, ((), {}))
+
+    def test_navigation_requested_ignores_clicked_links(self):
+        """The navigation request is ignored if a link was clicked."""
+        action = webkit.WebNavigationAction()
+        action.set_reason(gui.WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED)
+
+        decision = webkit.WebPolicyDecision()
+        decision.ignore = self._set_called
+
+        kwargs = dict(browser=self.browser, frame=None, request=None,
+                      action=action, decision=decision)
+        self.ui.on_tc_browser_navigation_requested(**kwargs)
+        self.assertEqual(self._called, ((), {}))
+
+    def test_navigation_requested_ignores_for_none(self):
+        """The navigation request is ignoref the request if params are None."""
+        kwargs = dict(browser=None, frame=None, request=None,
+                      action=None, decision=None)
+        self.ui.on_tc_browser_navigation_requested(**kwargs)
+
+    def test_navigation_requested_opens_links_when_clicked(self):
+        """The navigation request is opened on user's default browser
+
+        (If the user opened a link by clicking into it).
+
+        """
+        url = 'http://something.com/yadda'
+        action = webkit.WebNavigationAction()
+        action.set_reason(gui.WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED)
+        action.set_original_uri(url)
+
+        decision = webkit.WebPolicyDecision()
+        decision.ignore = gui.NO_OP
+
+        self.patch(gui.webbrowser, 'open', self._set_called)
+
+        kwargs = dict(browser=self.browser, frame=None, request=None,
+                      action=action, decision=decision)
+        self.ui.on_tc_browser_navigation_requested(**kwargs)
+        self.assertEqual(self._called, ((url,), {}))
 
 
 class RegistrationErrorTestCase(UbuntuSSOClientTestCase):
@@ -1059,12 +1168,6 @@
         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)
@@ -1353,18 +1456,6 @@
         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)
@@ -1541,14 +1632,6 @@
         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)
@@ -1673,25 +1756,6 @@
         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)
@@ -1896,7 +1960,7 @@
 class LoginOnlyTestCase(UbuntuSSOClientTestCase):
     """Test suite for the login only GUI."""
 
-    kwargs = dict(app_name=APP_NAME, tc_uri=None, help_text=HELP_TEXT,
+    kwargs = dict(app_name=APP_NAME, tc_url=None, help_text=HELP_TEXT,
                   login_only=True)
 
     def test_login_is_first_page(self):
@@ -1922,6 +1986,8 @@
     def setUp(self):
         """Init."""
         super(SignalsTestCase, self).setUp()
+        self._expected_error = (APP_NAME, '\n'.join('%s: %s' % i
+                                          for i in self.error.iteritems()))
         self._called = {}
         for sig_name, _ in gui.SIGNAL_ARGUMENTS:
             self.ui.connect(sig_name, self._set_called, sig_name)
@@ -1955,7 +2021,7 @@
         """On UserRegistrationError, 'registration-failed' signal is sent."""
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
-        expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
+        expected = (self.ui.window, self._expected_error, {})
         self.assertEqual(expected,
                          self._called[gui.SIG_REGISTRATION_FAILED])
 
@@ -1970,7 +2036,7 @@
         """On EmailValidationError, 'registration-failed' signal is sent."""
         self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
-        expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
+        expected = (self.ui.window, self._expected_error, {})
         self.assertEqual(expected,
                          self._called[gui.SIG_REGISTRATION_FAILED])
 
@@ -1986,7 +2052,7 @@
         self.click_connect_with_valid_data()
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
-        expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
+        expected = (self.ui.window, self._expected_error, {})
         self.assertEqual(expected,
                          self._called[gui.SIG_LOGIN_FAILED])
 

=== modified file 'ubuntu_sso/tests/test_keyring.py'
--- ubuntu_sso/tests/test_keyring.py	2010-09-22 16:47:09 +0000
+++ ubuntu_sso/tests/test_keyring.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # test_keyring - tests for ubuntu_sso.keyring
 #
 # Author: Alejandro J. Cura <[e-mail]>
@@ -26,8 +28,7 @@
 from twisted.trial.unittest import TestCase
 
 from ubuntu_sso import keyring
-
-APP_NAME = 'Yadda Yadda Doo'
+from ubuntu_sso.tests import APP_NAME
 
 
 def build_fake_gethostname(fake_hostname):

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/tests/test_main.py	2010-10-18 13:21:21 +0000
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # test_main - tests for ubuntu_sso.main
 #
 # Author: Natalia Bidart <[e-mail]>
@@ -20,15 +22,8 @@
 
 import logging
 import os
-import urllib2
-
-import gobject
-
-# Unable to import 'lazr.restfulclient.*'
-# pylint: disable=F0401
-from lazr.restfulclient.errors import HTTPError
-# pylint: enable=F0401
-from mocker import Mocker, MockerTestCase, ARGS, KWARGS, ANY
+
+from mocker import Mocker, MockerTestCase, ARGS, KWARGS
 from twisted.internet.defer import Deferred
 from twisted.trial.unittest import TestCase
 
@@ -36,342 +31,45 @@
 import ubuntu_sso.main
 
 from contrib.testing.testcase import MementoHandler
-from ubuntu_sso import gui
-from ubuntu_sso.keyring import get_token_name, U1_APP_NAME
-from ubuntu_sso.main import (
-    AuthenticationError, blocking, EmailTokenError,
-    except_to_errdict, InvalidEmailError, InvalidPasswordError,
-    keyring_get_credentials, keyring_store_credentials, logger,
-    NewPasswordError, PING_URL, SERVICE_URL,
-    RegistrationError, ResetPasswordTokenError,
-    SSOCredentials, SSOLogin, SSOLoginProcessor)
+from ubuntu_sso import credentials, DBUS_CREDENTIALS_IFACE
+from ubuntu_sso.keyring import U1_APP_NAME
+from ubuntu_sso.main import (U1_PING_URL, blocking, except_to_errdict,
+    CredentialsManagement, keyring_store_credentials, SSOCredentials, SSOLogin)
+from ubuntu_sso.main import (HELP_TEXT_KEY, PING_URL_KEY,
+    TC_URL_KEY, WINDOW_ID_KEY, SUCCESS_CB_KEY, ERROR_CB_KEY, DENIAL_CB_KEY)
+from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, PASSWORD, PING_URL, TOKEN,
+    TOKEN_NAME, WINDOW_ID)
 
 
 # Access to a protected member 'yyy' of a client class
 # pylint: disable=W0212
 
 
-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'
-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, 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 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
-
-
-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.')
-
-    # 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 BlockingSampleException(Exception):
     """The exception that will be thrown by the fake blocking."""
 
 
+def fake_ok_blocking(f, app, cb, eb):
+    """A fake blocking function that succeeds."""
+    cb(app, f())
+
+
+def fake_err_blocking(f, app, cb, eb):
+    """A fake blocking function that fails."""
+    try:
+        f()
+    except Exception, e:  # pylint: disable=W0703
+        eb(app, except_to_errdict(e))
+    else:
+        eb(app, except_to_errdict(BlockingSampleException()))
+
+
 class SsoDbusTestCase(TestCase):
     """Test the SSOLogin DBus interface."""
 
     def setUp(self):
         """Create the mocking bus."""
-        self.real_blocking = ubuntu_sso.main.blocking
         self.mocker = Mocker()
         self.mockbusname = self.mocker.mock()
         mockbus = self.mocker.mock()
@@ -396,19 +94,6 @@
         self.mocker.verify()
         self.mocker.restore()
 
-    def fake_ok_blocking(self, f, app, cb, eb):
-        """A fake blocking function that succeeds."""
-        cb(app, f())
-
-    def fake_err_blocking(self, f, app, cb, eb):
-        """A fake blocking function that fails."""
-        try:
-            f()
-        except Exception, e:  # pylint: disable=W0703
-            eb(app, except_to_errdict(e))
-        else:
-            eb(app, except_to_errdict(BlockingSampleException()))
-
     def test_creation(self):
         """Test that the object creation is successful."""
         self.mocker.replay()
@@ -429,7 +114,7 @@
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -452,7 +137,7 @@
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -475,7 +160,7 @@
         self.create_mock_processor().register_user(EMAIL, PASSWORD, CAPTCHA_ID,
                                                    CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -499,7 +184,7 @@
         self.create_mock_processor().register_user(EMAIL, PASSWORD, CAPTCHA_ID,
                                                    CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -521,7 +206,7 @@
         d = Deferred()
         self.create_mock_processor().login(EMAIL, PASSWORD, TOKEN_NAME)
         self.mocker.result(TOKEN)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -542,7 +227,7 @@
         """Test that the login method fails as expected."""
         d = Deferred()
         self.mockprocessorclass = self.mocker.mock()
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
 
         def fake_gtn(*args):
             """A fake get_token_name that fails."""
@@ -571,7 +256,7 @@
         self.create_mock_processor().validate_email(EMAIL, PASSWORD,
                                                     EMAIL_TOKEN, TOKEN_NAME)
         self.mocker.result(TOKEN)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -592,7 +277,7 @@
         """Test that the validate_email method fails as expected."""
         d = Deferred()
         self.mockprocessorclass = self.mocker.mock()
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
 
         def fake_gtn(*args):
             """A fake get_token_name that fails."""
@@ -620,7 +305,7 @@
         d = Deferred()
         processor = self.create_mock_processor()
         processor.request_password_reset_token(EMAIL)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.result(EMAIL)
         self.mocker.replay()
 
@@ -643,7 +328,7 @@
 
         self.create_mock_processor().request_password_reset_token(EMAIL)
         self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -665,7 +350,7 @@
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
                                                       PASSWORD)
         self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -689,7 +374,7 @@
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
                                                       PASSWORD)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -830,7 +515,7 @@
         self.mocker.result(TOKEN)
         self.mocker.replay()
 
-        token = keyring_get_credentials(APP_NAME)
+        token = credentials.keyring_get_credentials(APP_NAME)
         self.assertEqual(token, TOKEN)
 
     def test_keyring_get_cred_not_found(self):
@@ -843,7 +528,7 @@
         self.mocker.result(None)
         self.mocker.replay()
 
-        token = keyring_get_credentials(APP_NAME)
+        token = credentials.keyring_get_credentials(APP_NAME)
         self.assertEqual(token, None)
 
 
@@ -851,521 +536,112 @@
     """A mock exception thrown just when testing."""
 
 
-class CredentialsTestCase(TestCase, MockerTestCase):
-    """Tests for the credentials related DBus methods."""
-
-    # Invalid name (should match ([a-z_][a-z0-9_]*|[A-Z_][A-Z0-9_]*)$)
-    # pylint: disable=C0103
+class ApplicationCredentialsTestCase(TestCase, MockerTestCase):
+    """Tests for the ApplicationCredentials related DBus methods."""
 
     timeout = 5
 
+    def setUp(self):
+        MockerTestCase.setUp(self)
+
+        self.client = SSOCredentials(self.mocker.mock())
+
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=APP_NAME)
+        self.creds_obj = self.mocker.mock()
+        self.mocker.result(self.creds_obj)
+
     def test_find_credentials(self):
         """find_credentials immediately returns the token when found."""
         expected_token = "expected token"
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
+        self.creds_obj.find_credentials()
         self.mocker.result(expected_token)
         self.mocker.replay()
 
-        client = SSOCredentials(self.mocker.mock())
-        token = client.find_credentials(APP_NAME)
+        token = self.client.find_credentials(APP_NAME)
         self.assertEqual(token, expected_token)
 
     def test_credentials_not_found(self):
-        """find_credentials immediately returns '' when no token found."""
+        """find_credentials immediately returns {} when no token found."""
         expected_creds = {}
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.result(None)
+        self.creds_obj.find_credentials()
+        self.mocker.result(expected_creds)
         self.mocker.replay()
 
-        client = SSOCredentials(self.mocker.mock())
-        token = client.find_credentials(APP_NAME)
+        token = self.client.find_credentials(APP_NAME)
         self.assertEqual(token, expected_creds)
 
+
+class ApplicationCredentialsGUITestCase(TestCase, MockerTestCase):
+    """Tests for the ApplicationCredentials register/login DBus method."""
+
+    app_name = APP_NAME
+    ping_url = None
+
+    def setUp(self):
+        MockerTestCase.setUp(self)
+        self.client = SSOCredentials(self.mocker.mock())
+        self.args = {PING_URL_KEY: self.ping_url,
+                     TC_URL_KEY: TC_URL, HELP_TEXT_KEY: HELP_TEXT,
+                     WINDOW_ID_KEY: WINDOW_ID,
+                     SUCCESS_CB_KEY: self.client.CredentialsFound,
+                     ERROR_CB_KEY: self.client._process_error,
+                     DENIAL_CB_KEY: self.client.AuthorizationDenied}
+
     def test_login_or_register(self):
-        """login_or_register_... throws the signal when token is found."""
-        expected_creds = TOKEN
-        d = Deferred()
-
-        def verify(app_name, credentials):
-            """The actual test."""
-            self.assertEqual(credentials, expected_creds)
-            d.callback("ok")
-
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.result(expected_creds)
-        self.mocker.replay()
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "_show_login_or_register_ui", self.fail)
-        self.patch(client, "CredentialsFound", verify)
-        self.patch(client, "CredentialsError", self.fail)
-        client.login_or_register_to_get_credentials(*LOGIN_OR_REGISTER_ARGS)
-        return d
-
-    def test_login_or_register_not_found(self):
-        """Check that login_or_register_... opens the ui when no cred found."""
-        d = Deferred()
-
-        def verify(result, *a):
-            """The actual test."""
-            self.assertEqual(result, APP_NAME)
-            d.callback("ok")
-
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.result(None)
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "_show_login_or_register_ui", verify)
-        self.patch(client, "CredentialsFound", self.fail)
-        self.patch(client, "CredentialsError", self.fail)
-        client.login_or_register_to_get_credentials(*LOGIN_OR_REGISTER_ARGS)
-        return d
-
-    def test_login_or_register_problem(self):
-        """login_or_register_... returns the right signal on error."""
-        expected_error = "Sample Error - not for resale"
-        d = Deferred()
-
-        def verify(app_name, error_message, detailed_error):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("ok")
-
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.throw(RegisterSampleException(expected_error))
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "_show_login_or_register_ui", self.fail)
-        self.patch(client, "CredentialsFound", self.fail)
-        self.patch(client, "CredentialsError", verify)
-        client.login_or_register_to_get_credentials(*LOGIN_OR_REGISTER_ARGS)
-        return d
+        """login_or_register is correct."""
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=self.app_name, **self.args)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        creds_obj.register()
+        self.mocker.replay()
+
+        args = (self.app_name, TC_URL, HELP_TEXT, WINDOW_ID)
+        self.client.login_or_register_to_get_credentials(*args)
 
     def test_login_only(self):
-        """login_only_... throws the signal when token is found."""
-        expected_creds = TOKEN
-        d = Deferred()
-
-        def verify(app_name, credentials):
-            """The actual test."""
-            self.assertEqual(credentials, expected_creds)
-            d.callback("ok")
-
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.result(expected_creds)
-        self.mocker.replay()
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "_show_login_only_ui", self.fail)
-        self.patch(client, "CredentialsFound", verify)
-        self.patch(client, "CredentialsError", self.fail)
-        client.login_to_get_credentials(*LOGIN_ONLY_ARGS)
-        return d
-
-    def test_login_only_not_found(self):
-        """Check that login_only_... opens the ui when no cred found."""
-        d = Deferred()
-
-        def verify(result, *a):
-            """The actual test."""
-            self.assertEqual(result, APP_NAME)
-            d.callback("ok")
-
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.result(None)
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "_show_login_only_ui", verify)
-        self.patch(client, "CredentialsFound", self.fail)
-        self.patch(client, "CredentialsError", self.fail)
-        client.login_to_get_credentials(*LOGIN_ONLY_ARGS)
-        return d
-
-    def test_login_only_problem(self):
-        """login_only_... returns the right signal on error."""
-        expected_error = "Sample Error - not for resale"
-        d = Deferred()
-
-        def verify(app_name, error_message, detailed_error):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("ok")
-
-        kgt = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgt(ARGS)
-        self.mocker.throw(RegisterSampleException(expected_error))
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "_show_login_only_ui", self.fail)
-        self.patch(client, "CredentialsFound", self.fail)
-        self.patch(client, "CredentialsError", verify)
-        client.login_to_get_credentials(*LOGIN_ONLY_ARGS)
-        return d
+        """login_or_register is correct."""
+        self.args[TC_URL_KEY] = None
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=self.app_name, **self.args)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        creds_obj.login()
+        self.mocker.replay()
+
+        args = (self.app_name, HELP_TEXT, WINDOW_ID)
+        self.client.login_to_get_credentials(*args)
+
+
+class ApplicationCredentialsU1TestCase(ApplicationCredentialsGUITestCase):
+    """Tests for the ApplicationCredentials register/login DBus method.
+
+    Specifically for APP_NAME == U1_APP_NAME.
+
+    """
+
+    app_name = U1_APP_NAME
+    ping_url = U1_PING_URL
+
+
+class ApplicationCredentialsClearTokenTestCase(TestCase, MockerTestCase):
+    """Tests for the ApplicationCredentials related DBus methods."""
 
     def test_clear_token(self):
         """Check that clear_token tries removing the correct token."""
-        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
-        mockKeyringClass(APP_NAME)
-        mockKeyring = self.mocker.mock()
-        self.mocker.result(mockKeyring)
-        mockKeyring.delete_ubuntusso_attr()
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        client.clear_token(APP_NAME)
-
-    def test_clear_token_failed(self):
-        """Check that clear_token fails correctly."""
-        mockKeyringClass = self.mocker.replace("ubuntu_sso.keyring.Keyring")
-        mockKeyringClass(APP_NAME)
-        self.mocker.throw(self.mocker.mock())
-        fake_logger = self.mocker.replace("ubuntu_sso.main.logger")
-        fake_logger.exception(ANY, APP_NAME)
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        client.clear_token(APP_NAME)
-
-    def test_login_error_cb(self):
-        """The login error callback should throw the signal."""
-        d = Deferred()
-
-        def verify(app_name, error_message, detailed_error):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("ok")
-
-        self.mocker.replay()
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "CredentialsError", verify)
-
-        client._login_error_cb(None, APP_NAME, 'some error')
-        return d
-
-    def test_show_login_or_register_ui_error(self):
-        """An error happens when trying to register."""
-        d = Deferred()
-        mockgui = self.mocker.replace("ubuntu_sso.gui.UbuntuSSOClientGUI")
-        mockgui(ARGS)
-        self.mocker.throw(Exception())
-        self.mocker.replay()
-
-        def verify(app_name, msg, full_error):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("ok")
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "CredentialsError", verify)
-
-        client._show_login_or_register_ui(APP_NAME, "http:tc_url", "help", 0)
-        return d
-
-    def test_login_success_cb_works(self):
-        """Check that the right signal is sent."""
-        expected_creds = TOKEN
-        d = Deferred()
-        kgc = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgc(ARGS)
-        self.mocker.result(expected_creds)
-        self.mocker.replay()
-
-        def verify(app_name, credentials):
-            """The actual test."""
-            self.assertEqual(credentials, expected_creds)
-            d.callback("ok")
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "CredentialsFound", verify)
-
-        client._login_success_cb(None, APP_NAME, EMAIL)
-        return d
-
-    def test_login_success_cb_error(self):
-        """An error happens when accessing the keyring."""
-        d = Deferred()
-        kgc = self.mocker.replace("ubuntu_sso.main.keyring_get_credentials")
-        kgc(ARGS)
-        self.mocker.throw(Exception())
-        self.mocker.replay()
-
-        def verify(app_name, msg, full_error):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("ok")
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "CredentialsError", verify)
-
-        client._login_success_cb(None, APP_NAME, EMAIL)
-        return d
-
-    def test_auth_denied_cb(self):
-        """When the user decides not to allow the registration or login."""
-        d = Deferred()
-        self.mocker.replay()
-
-        def verify(app_name):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("ok")
-
-        client = SSOCredentials(self.mocker.mock())
-        self.patch(client, "AuthorizationDenied", verify)
-
-        client._login_auth_denied_cb(None, APP_NAME)
-        return d
-
-
-class CredentialsGUITestCase(TestCase):
-    """login_or_register_to_get_credentials opens the proper GUI."""
-
-    def setUp(self):
-        """Init."""
-        self.args = None
-        self.kwargs = None
-
-        idle_add = lambda f, *args, **kwargs: f(*args, **kwargs)
-        self.patch(gobject, "idle_add", idle_add)
-        self.patch(ubuntu_sso.main, 'keyring_get_credentials', lambda n: None)
-
-        self.memento = MementoHandler()
-        self.memento.setLevel(logging.DEBUG)
-        logger.addHandler(self.memento)
-
-        self.client = SSOCredentials(None)
-        self.login_or_register = \
-            self.client.login_or_register_to_get_credentials
-        self.login_only = self.client.login_to_get_credentials
-
-    def test_login_or_register_opens_proper_ui(self):
-        """The proper GUI is created if the token is None."""
-
-        class FakedUbuntuSSOClientGUI(object):
-            """Fake a SSO GUI."""
-
-            # Method should have "self" as first argument
-            # pylint: disable=E0213
-
-            def __init__(sself, *args, **kwargs):
-                self.args = args
-                self.kwargs = kwargs
-                sself.connect = lambda *a: None
-
-        self.patch(gui, "UbuntuSSOClientGUI", FakedUbuntuSSOClientGUI)
-        self.login_or_register(*LOGIN_OR_REGISTER_ARGS)
-
-        self.assertEqual(self.args, LOGIN_OR_REGISTER_GUI_ARGS)
-        self.assertEqual(self.kwargs, {})
-
-    def test_ui_exceptions_are_logged(self):
-        """If GUI fails the exception is logged."""
-
-        def fail(*args, **kwargs):
-            """Raise an exception."""
-            self.args = AssertionError((args, kwargs))
-            # pylint: disable=E0702
-            raise self.args
-
-        self.patch(gui, "UbuntuSSOClientGUI", fail)
-        self.login_or_register(*LOGIN_OR_REGISTER_ARGS)
-
-        self.assertTrue(1, len(self.memento.records))
-        self.assertTrue(self.memento.check(logging.ERROR,
-                                           str(LOGIN_OR_REGISTER_GUI_ARGS)))
-        exc_info = self.memento.records[0].exc_info
-        self.assertIn(self.args, exc_info)
-
-    def test_ui_signals_are_connected(self):
-        """Signals from GUI are properly connected."""
-
-        self.args = []
-
-        class FakedUbuntuSSOClientGUI(object):
-            """Fake a SSO GUI."""
-
-            # Method should have "self" as first argument
-            # pylint: disable=E0213
-
-            def __init__(sself, *args, **kwargs):
-                sself.connect = lambda *a: self.args.append(a)
-
-        expected = [
-            (gui.SIG_LOGIN_SUCCEEDED, self.client._login_success_cb),
-            (gui.SIG_LOGIN_FAILED, self.client._login_error_cb),
-            (gui.SIG_REGISTRATION_SUCCEEDED, self.client._login_success_cb),
-            (gui.SIG_REGISTRATION_FAILED, self.client._login_error_cb),
-            (gui.SIG_USER_CANCELATION, self.client._login_auth_denied_cb),
-        ]
-        self.patch(gui, "UbuntuSSOClientGUI", FakedUbuntuSSOClientGUI)
-        self.login_or_register(*LOGIN_OR_REGISTER_ARGS)
-        self.assertEqual(self.args, expected)
-
-    def test_login_only_opens_proper_ui(self):
-        """The proper GUI is created if the token is None."""
-
-        class FakedUbuntuSSOClientGUI(object):
-            """Fake a SSO GUI."""
-
-            # Method should have "self" as first argument
-            # pylint: disable=E0213
-
-            def __init__(sself, *args, **kwargs):
-                self.args = args
-                self.kwargs = kwargs
-                sself.connect = lambda *a: None
-
-        self.patch(gui, "UbuntuSSOClientGUI", FakedUbuntuSSOClientGUI)
-        self.login_only(*LOGIN_ONLY_ARGS)
-
-        self.assertEqual(self.args, LOGIN_ONLY_GUI_ARGS)
-        self.assertEqual(self.kwargs, {})
-
-    def test_login_only_ui_exceptions_are_logged(self):
-        """If GUI fails the exception is logged."""
-
-        def fail(*args, **kwargs):
-            """Raise an exception."""
-            self.args = AssertionError((args, kwargs))
-            # pylint: disable=E0702
-            raise self.args
-
-        self.patch(gui, "UbuntuSSOClientGUI", fail)
-        self.login_only(*LOGIN_ONLY_ARGS)
-
-        self.assertTrue(1, len(self.memento.records))
-        self.assertTrue(self.memento.check(logging.ERROR,
-                                           str(LOGIN_ONLY_GUI_ARGS)))
-        exc_info = self.memento.records[0].exc_info
-        self.assertIn(self.args, exc_info)
-
-    def test_login_only_ui_signals_are_connected(self):
-        """Signals from GUI are properly connected."""
-
-        self.args = []
-
-        class FakedUbuntuSSOClientGUI(object):
-            """Fake a SSO GUI."""
-
-            # Method should have "self" as first argument
-            # pylint: disable=E0213
-
-            def __init__(sself, *args, **kwargs):
-                sself.connect = lambda *a: self.args.append(a)
-
-        expected = [
-            (gui.SIG_LOGIN_SUCCEEDED, self.client._login_success_cb),
-            (gui.SIG_LOGIN_FAILED, self.client._login_error_cb),
-            (gui.SIG_REGISTRATION_SUCCEEDED, self.client._login_success_cb),
-            (gui.SIG_REGISTRATION_FAILED, self.client._login_error_cb),
-            (gui.SIG_USER_CANCELATION, self.client._login_auth_denied_cb),
-        ]
-        self.patch(gui, "UbuntuSSOClientGUI", FakedUbuntuSSOClientGUI)
-        self.login_only(*LOGIN_ONLY_ARGS)
-        self.assertEqual(self.args, expected)
-
-
-class PingServerTestCase(TestCase):
-    """On successful login/registration, the U1 server is pinged."""
-
-    def setUp(self):
-        """Init."""
-        self.patch(ubuntu_sso.main, 'keyring_get_credentials', lambda a: TOKEN)
-        self.calls = []
-        self.args = None
-        self.kwargs = None
-
-        def fake_it(*args, **kwargs):
-            """Fake a call."""
-            self.args = args
-            self.kwargs = kwargs
-            return FakedResponse(code=200)
-
-        self.patch(urllib2, 'urlopen', fake_it)
-
-        self.client = SSOCredentials(None)
-
-        self.memento = MementoHandler()
-        self.memento.setLevel(logging.DEBUG)
-        logger.addHandler(self.memento)
-
-    def _patch(self, name):
-        """Patch a method so when it's called its name is stored."""
-        self.patch(self.client, name,
-                   lambda *a, **kw: self.calls.append((name, a, kw)))
-
-    def test_on_registration_successful_u1_server_is_pinged(self):
-        """When a registration is successful, the PING_URL is pinged."""
-        self.client._login_success_cb(None, U1_APP_NAME, EMAIL)
-
-        self.assertEqual(len(self.args), 1)
-        self.assertEqual(self.args[0].get_full_url(), PING_URL + EMAIL)
-        self.assertEqual(self.kwargs, {})
-
-    def test_on_registration_successful_no_server_is_pinged(self):
-        """When a registration is successful, the PING_URL is not pinged."""
-        self.client._login_success_cb(None, APP_NAME, EMAIL)
-
-        self.assertEqual(self.args, None)
-        self.assertEqual(self.kwargs, None)
-
-    def test_ping_is_signed_with_credentials(self):
-        """Ping to PING_URL is signed with user credentials."""
-        result = self.client._ping_url(U1_APP_NAME, EMAIL, TOKEN)
-        headers = self.args[0].headers
-        self.assertIn('Authorization', headers)
-        oauth_stuff = headers['Authorization']
-
-        expected = 'oauth_consumer_key="xQ7xDAz", ' \
-            'oauth_signature_method="HMAC-SHA1", oauth_version="1.0", ' \
-            'oauth_token="GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo' \
-            '", oauth_signature="'
-        self.assertIn(expected, oauth_stuff)
-        self.assertEqual(result, 200)
-
-    def test_ping_is_done_before_sending_signal(self):
-        """Ping the server before sending any credential signal."""
-        self._patch('_ping_url')
-        self._patch('CredentialsFound')
-        self._patch('CredentialsError')
-        self._patch('AuthorizationDenied')
-
-        self.client._login_success_cb(None, APP_NAME, EMAIL)
-
-        self.assertEqual(len(self.calls), 2)
-        self.assertEqual(self.calls[0], ('_ping_url',
-                                         (APP_NAME, EMAIL, TOKEN), {}))
-        self.assertEqual(self.calls[1], ('CredentialsFound',
-                                         (APP_NAME, TOKEN), {}))
-
-    def test_send_error_if_ping_failed(self):
-        """Ping the server before sending any credential signal."""
-
-        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('CredentialsFound')
-        self._patch('CredentialsError')
-        self._patch('AuthorizationDenied')
-
-        self.client._login_success_cb(None, APP_NAME, EMAIL)
-
-        self.assertEqual(len(self.calls), 1)
-        self.assertEqual(self.calls[0][0], 'CredentialsError')
-        self.assertEqual(self.calls[0][1][0], APP_NAME)
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=APP_NAME)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        creds_obj.clear_credentials()
+        self.mocker.replay()
+
+        client = SSOCredentials(self.mocker.mock())
+        client.clear_token(APP_NAME)
 
 
 class EnvironOverridesTestCase(TestCase):
@@ -1388,23 +664,246 @@
     def test_no_override_ping_url(self):
         """If the environ is unset, the default ping url is used."""
         creds = SSOCredentials(None)
-        self.assertEqual(creds.ping_url, PING_URL)
-
-    def test_override_service_url(self):
-        """The service url can be set from the env var USSOC_SERVICE_URL."""
-        fake_url = 'this is not really a URL'
-        old_url = os.environ.get('USSOC_SERVICE_URL')
-        os.environ['USSOC_SERVICE_URL'] = fake_url
-        try:
-            proc = SSOLoginProcessor(sso_service_class=FakedSSOServer)
-            self.assertEqual(proc.service_url, fake_url)
-        finally:
-            if old_url:
-                os.environ['USSOC_SERVICE_URL'] = old_url
-            else:
-                del os.environ['USSOC_SERVICE_URL']
-
-    def test_no_override_service_url(self):
-        """If the environ is unset, the default service url is used."""
-        proc = SSOLoginProcessor(sso_service_class=FakedSSOServer)
-        self.assertEqual(proc.service_url, SERVICE_URL)
+        self.assertEqual(creds.ping_url, U1_PING_URL)
+
+
+class CredentialsManagementTestCase(TestCase):
+    """Tests for the CredentialsManagement DBus interface."""
+
+    base_args = {HELP_TEXT_KEY: HELP_TEXT, PING_URL_KEY: PING_URL,
+                 TC_URL_KEY: TC_URL, WINDOW_ID_KEY: WINDOW_ID}
+
+    def setUp(self):
+        self.mocker = Mocker()
+        self.client = CredentialsManagement()
+        self.args = {}
+        self.cred_args = {}
+
+    def tearDown(self):
+        """Verify the mocking stuff and shut it down."""
+        self.mocker.verify()
+        self.mocker.restore()
+
+    def assert_dbus_method_correct(self, method):
+        """Check that 'method' is a dbus method with proper signatures."""
+        self.assertTrue(method._dbus_is_method)
+        self.assertEqual(method._dbus_interface, DBUS_CREDENTIALS_IFACE)
+        self.assertEqual(method._dbus_in_signature, 'sa{ss}')
+        self.assertEqual(method._dbus_out_signature, '')
+
+    def create_mock_backend(self):
+        """Create a mock backend."""
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(APP_NAME, **self.cred_args)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        return creds_obj
+
+    def test_is_dbus_object(self):
+        """CredentialsManagement is a Dbus object."""
+        self.assertIsInstance(self.client, ubuntu_sso.main.dbus.service.Object)
+
+
+class CredentialsManagementFindClearTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement find/clear methods."""
+
+    timeout = 5
+
+    def test_find_credentials(self):
+        """The credentials are asked and returned in signals."""
+        self.create_mock_backend().find_credentials()
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.find_credentials)
+
+    def test_find_credentials_does_not_block_when_found(self):
+        """Calling find_credentials does not block but return thru signals.
+
+        If the creds are found, CredentialsFound is emitted.
+
+        """
+        d = Deferred()
+
+        def verify(app_name, creds):
+            """The actual test."""
+            try:
+                self.assertEqual(app_name, APP_NAME)
+                self.assertEqual(creds, TOKEN)
+            except Exception, e:  # pylint: disable=W0703
+                d.errback(e)
+            else:
+                d.callback(creds)
+
+        self.patch(ubuntu_sso.main, 'blocking', fake_ok_blocking)
+        self.patch(self.client, 'CredentialsFound', verify)
+        self.patch(self.client, 'CredentialsNotFound', d.errback)
+
+        self.create_mock_backend().find_credentials()
+        self.mocker.result(TOKEN)
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        return d
+
+    def test_find_credentials_does_not_block_when_not_found(self):
+        """Calling find_credentials does not block but return thru signals.
+
+        If the creds are not found, CredentialsNotFound is emitted.
+
+        """
+        d = Deferred()
+
+        def verify(app_name):
+            """The actual test."""
+            try:
+                self.assertEqual(app_name, APP_NAME)
+            except Exception, e:  # pylint: disable=W0703
+                d.errback(e)
+            else:
+                d.callback(app_name)
+
+        self.patch(ubuntu_sso.main, 'blocking', fake_ok_blocking)
+        self.patch(self.client, 'CredentialsFound', d.errback)
+        self.patch(self.client, 'CredentialsNotFound', verify)
+
+        self.create_mock_backend().find_credentials()
+        self.mocker.result({})
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        return d
+
+    def test_clear_credentials(self):
+        """The credentials are removed."""
+        self.create_mock_backend().clear_credentials()
+        self.mocker.replay()
+
+        self.client.clear_credentials(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.clear_credentials)
+
+    def test_clear_credentials_does_not_block(self):
+        """Calling clear_credentials does not block but return thru signals."""
+        d = Deferred()
+
+        def verify(app_name):