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

[Natalia Bidart]

  * New upstream release:

    [ Natalia B. Bidart <email address hidden>]
     - The service should shutdown when unused
       (LP: #701606),
     - On error, {find,clear,store}_credentials send proper CredentialsError
       signal (LP: #696676).
     - No more gobject dependency on non-GUI classes!
       (LP: #695798).
     - After login, if the storing of credentials fails, send LoginError
       (LP: #693531).
     - Use ubuntuone-dev-tools to run the tests and the lint checker
       (LP: #686606).

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-12-16 16:31:34 +0000
+++ PKG-INFO	2011-01-13 00:33:10 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 1.1.7
+Version: 1.1.8
 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-11 13:22:16 +0000
+++ bin/ubuntu-sso-login	2011-01-13 00:33:10 +0000
@@ -21,7 +21,9 @@
 
 """Run the dbus service for UserManagement and ApplicationCredentials."""
 
-# import decimal even if we don't need it.
+# Invalid name "ubuntu-sso-login", pylint: disable=C0103
+
+# import decimal even if we don't need it, pylint: disable=W0611
 import decimal
 # This is a workaround for LP: #467397. Some module in our depency chain sets
 # the locale and imports decimal, and that generates the following trace:
@@ -70,8 +72,8 @@
     # 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.
+    # 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.")
     gtk.main_quit()
 
@@ -92,6 +94,8 @@
     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)
+    CredentialsManagement(timeout_func=gtk.timeout_add,
+                          shutdown_func=gtk.main_quit,
+                          bus_name=bus_name, object_path=DBUS_CREDENTIALS_PATH)
 
     gtk.main()

=== removed directory 'contrib'
=== removed file 'contrib/__init__.py'
--- contrib/__init__.py	2010-06-22 14:18:04 +0000
+++ contrib/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-# contrib - Extra required code to build/install the client
-#
-# Author: Rodney Dawes <[e-mail]>
-#
-# Copyright 2009-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/>.
-"""Extra things we need to build, test, or install the client."""

=== removed file 'contrib/dbus_util.py'
--- contrib/dbus_util.py	2010-09-08 19:25:02 +0000
+++ contrib/dbus_util.py	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-#
-# Author: Guillermo Gonzalez <[e-mail]>
-#
-#
-# 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/>.
-
-"""Utilies to run a separated DBus session."""
-
-import os
-import signal
-import subprocess
-
-from distutils.spawn import find_executable
-
-SRCDIR = os.environ.get('SRCDIR', os.getcwd())
-
-
-class DBusLaunchError(Exception):
-    """Error while launching dbus-daemon."""
-
-
-class NotFoundError(Exception):
-    """Not found error."""
-
-
-class DBusRunner(object):
-    """A DBus runner."""
-
-    # pylint: disable=C0103
-
-    def __init__(self):
-        self.dbus_address = None
-        self.dbus_pid = None
-        self.running = False
-
-    def startDBus(self):
-        """Start our own session bus daemon for testing."""
-        dbus = find_executable("dbus-daemon")
-        if not dbus:
-            raise NotFoundError("dbus-daemon was not found.")
-
-        config_file = os.path.join(os.path.abspath(SRCDIR),
-                                   "contrib", "testing",
-                                   "dbus-session.conf")
-        dbus_args = ["--fork",
-                     "--config-file=" + config_file,
-                     "--print-address=1",
-                     "--print-pid=2"]
-        p = subprocess.Popen([dbus] + dbus_args,
-                             bufsize=4096, stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-
-        self.dbus_address = "".join(p.stdout.readlines()).strip()
-        self.dbus_pid = int("".join(p.stderr.readlines()).strip())
-
-        if self.dbus_address != "":
-            os.environ["DBUS_SESSION_BUS_ADDRESS"] = self.dbus_address
-        else:
-            os.kill(self.dbus_pid, signal.SIGKILL)
-            raise DBusLaunchError("There was a problem launching dbus-daemon.")
-        self.running = True
-
-    def stopDBus(self):
-        """Stop our DBus session bus daemon."""
-        del os.environ["DBUS_SESSION_BUS_ADDRESS"]
-        os.kill(self.dbus_pid, signal.SIGKILL)
-        self.running = False

=== removed file 'contrib/test'
--- contrib/test	2010-09-08 19:25:02 +0000
+++ contrib/test	1970-01-01 00:00:00 +0000
@@ -1,146 +0,0 @@
-#!/usr/bin/env python
-#
-# Author: Guillermo Gonzalez <[e-mail]>
-#
-# Copyright 2009-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/>.
-
-import os
-import re
-import signal
-import sys
-import string
-import subprocess
-import unittest
-
-sys.path.insert(0, os.path.abspath("."))
-
-from distutils.spawn import find_executable
-
-
-class TestRunner(object):
-
-    def _load_unittest(self, relpath):
-        """Load unittests from a Python module with the given relative path."""
-        assert relpath.endswith(".py"), (
-            "%s does not appear to be a Python module" % relpath)
-        modpath = relpath.replace(os.path.sep, ".")[:-3]
-        module = __import__(modpath, None, None, [""])
-
-        # If the module has a 'suite' or 'test_suite' function, use that
-        # to load the tests.
-        if hasattr(module, "suite"):
-            return module.suite()
-        elif hasattr(module, "test_suite"):
-            return module.test_suite()
-        else:
-            return unittest.defaultTestLoader.loadTestsFromModule(module)
-
-    def _collect_tests(self, testpath, test_pattern):
-        """Return the set of unittests."""
-        suite = unittest.TestSuite()
-        if test_pattern:
-            pattern = re.compile('.*%s.*' % test_pattern)
-        else:
-            pattern = None
-
-        if testpath:
-            module_suite = self._load_unittest(testpath)
-            if pattern:
-                for inner_suite in module_suite._tests:
-                    for test in inner_suite._tests:
-                        if pattern.match(test.id()):
-                            suite.addTest(test)
-            else:
-                suite.addTests(module_suite)
-            return suite
-
-        # We don't use the dirs variable, so ignore the warning
-        # pylint: disable=W0612
-        for root, dirs, files in os.walk("ubuntu_sso"):
-            for file in files:
-                path = os.path.join(root, file)
-                if file.endswith(".py") and file.startswith("test_"):
-                    module_suite = self._load_unittest(path)
-                    if pattern:
-                        for inner_suite in module_suite._tests:
-                            for test in inner_suite._tests:
-                                if pattern.match(test.id()):
-                                    suite.addTest(test)
-                    else:
-                        suite.addTests(module_suite)
-        return suite
-
-    def run(self, testpath, test_pattern=None, loops=None):
-        """run the tests. """
-        # install the glib2reactor before any import of the reactor to avoid
-        # using the default SelectReactor and be able to run the dbus tests
-        from twisted.internet import glib2reactor
-        glib2reactor.install()
-        from twisted.internet import reactor
-        from twisted.trial.reporter import TreeReporter
-        from twisted.trial.runner import TrialRunner
-
-        from contrib.dbus_util import DBusRunner
-        dbus_runner = DBusRunner()
-        dbus_runner.startDBus()
-
-        workingDirectory = os.path.join(os.getcwd(), "_trial_temp", "tmp")
-        runner = TrialRunner(reporterFactory=TreeReporter, realTimeErrors=True,
-                            workingDirectory=workingDirectory)
-
-        # setup a custom XDG_CACHE_HOME and create the logs directory
-        xdg_cache = os.path.join(os.getcwd(), "_trial_temp", "xdg_cache")
-        os.environ["XDG_CACHE_HOME"] = xdg_cache
-        # setup the ROOTDIR env var
-        os.environ['ROOTDIR'] = os.getcwd()
-        if not os.path.exists(xdg_cache):
-            os.makedirs(xdg_cache)
-        success = 0
-        try:
-            suite = self._collect_tests(testpath, test_pattern)
-            if loops:
-                old_suite = suite
-                suite = unittest.TestSuite()
-                for x in xrange(loops):
-                    suite.addTest(old_suite)
-            result = runner.run(suite)
-            success = result.wasSuccessful()
-        finally:
-            dbus_runner.stopDBus()
-        if not success:
-            sys.exit(1)
-        else:
-            sys.exit(0)
-
-
-if __name__ == '__main__':
-    from optparse import OptionParser
-    usage = '%prog [options] path'
-    parser = OptionParser(usage=usage)
-    parser.add_option("-t", "--test", dest="test",
-                      help="run specific tests, e.g: className.methodName")
-    parser.add_option("-l", "--loop", dest="loops", type="int", default=1,
-                      help="loop selected tests LOOPS number of times",
-                      metavar="LOOPS")
-
-    (options, args) = parser.parse_args()
-    if args:
-        testpath = args[0]
-        if not os.path.exists(testpath):
-            print "the path to test does not exists!"
-            sys.exit()
-    else:
-        testpath = None
-    TestRunner().run(testpath, options.test, options.loops)

=== removed directory 'contrib/testing'
=== removed file 'contrib/testing/__init__.py'
--- contrib/testing/__init__.py	2010-09-08 19:25:02 +0000
+++ contrib/testing/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-"""Testing utilities for Ubuntu SSO code."""

=== removed file 'contrib/testing/dbus-session.conf'
--- contrib/testing/dbus-session.conf	2010-06-18 20:51:58 +0000
+++ contrib/testing/dbus-session.conf	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-<!-- This configuration file controls our test-only session bus -->
-
-<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
- "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
-<busconfig>
-  <!-- We only use a session bus -->
-  <type>session</type>
-
-  <listen>unix:tmpdir=/tmp</listen>
-
-  <!-- Load our own services.
-       To make other dbus service in this session bus, just add another servicedir entry. -->
-  <servicedir>dbus-session</servicedir>
-  <!-- Load the standard session services -->
-  <!--standard_session_servicedirs /-->
-
-  <policy context="default">
-    <!-- Allow everything to be sent -->
-    <allow send_destination="*" eavesdrop="true"/>
-    <!-- Allow everything to be received -->
-    <allow eavesdrop="true"/>
-    <!-- Allow anyone to own anything -->
-    <allow own="*"/>
-  </policy>
-
-  <!-- Config files are placed here that among other things, 
-       further restrict the above policy for specific services. -->
-  <includedir>/etc/dbus-1/session.d</includedir>
-
-  <!-- raise the service start timeout to 40 seconds as it can timeout
-       on the live cd on slow machines -->
-  <limit name="service_start_timeout">60000</limit>
-
-  <!-- This is included last so local configuration can override what's 
-       in this standard file -->
-  <include ignore_missing="yes">session-local.conf</include>
-
-  <include ignore_missing="yes" if_selinux_enabled="yes" selinux_root_relative="yes">contexts/dbus_contexts</include>
-
-  <!-- For the session bus, override the default relatively-low limits 
-       with essentially infinite limits, since the bus is just running 
-       as the user anyway, using up bus resources is not something we need 
-       to worry about. In some cases, we do set the limits lower than 
-       "all available memory" if exceeding the limit is almost certainly a bug, 
-       having the bus enforce a limit is nicer than a huge memory leak. But the 
-       intent is that these limits should never be hit. -->
-
-  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
-  <limit name="max_incoming_bytes">1000000000</limit>
-  <limit name="max_outgoing_bytes">1000000000</limit>
-  <limit name="max_message_size">1000000000</limit>
-  <limit name="service_start_timeout">120000</limit>  
-  <limit name="auth_timeout">240000</limit>
-  <limit name="max_completed_connections">100000</limit>  
-  <limit name="max_incomplete_connections">10000</limit>
-  <limit name="max_connections_per_user">100000</limit>
-  <limit name="max_pending_service_starts">10000</limit>
-  <limit name="max_names_per_connection">50000</limit>
-  <limit name="max_match_rules_per_connection">50000</limit>
-  <limit name="max_replies_per_connection">50000</limit>
-  <limit name="reply_timeout">300000</limit>
-
-</busconfig>

=== removed file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-10-11 13:22:16 +0000
+++ contrib/testing/testcase.py	1970-01-01 00:00:00 +0000
@@ -1,123 +0,0 @@
-#
-# Author: Guillermo Gonzalez <[e-mail]>
-# Author: Natalia B. Bidart <[e-mail]>
-#
-# Copyright 2009-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/>.
-"""Base tests cases and test utilities."""
-
-import logging
-
-import dbus
-
-from dbus.mainloop.glib import DBusGMainLoop
-from twisted.internet import defer
-from twisted.python import failure
-from twisted.trial.unittest import TestCase
-
-
-class DBusTestCase(TestCase):
-    """Test the DBus event handling."""
-
-    def setUp(self):
-        """Setup the infrastructure fo the test (dbus service)."""
-        self.loop = DBusGMainLoop(set_as_default=True)
-        self.bus = dbus.bus.BusConnection(mainloop=self.loop)
-        # monkeypatch busName.__del__ to avoid errors on gc
-        # we take care of releasing the name in shutdown
-        dbus.service.BusName.__del__ = lambda _: None
-        self.bus.set_exit_on_disconnect(False)
-        self.signal_receivers = set()
-
-    def tearDown(self):
-        """Cleanup the test."""
-        d = self.cleanup_signal_receivers(self.signal_receivers)
-        d.addBoth(self._tear_down)
-        return d
-
-    def _tear_down(self, _):
-        """Shutdown."""
-        self.bus.flush()
-        self.bus.close()
-
-    def error_handler(self, error):
-        """Default error handler for DBus calls."""
-        if isinstance(error, failure.Failure):
-            self.fail(error.getErrorMessage())
-
-    def cleanup_signal_receivers(self, signal_receivers):
-        """Cleanup self.signal_receivers and returns a deferred."""
-        deferreds = []
-        for match in signal_receivers:
-            d = defer.Deferred()
-
-            def callback(*args):
-                """Callback that accepts *args."""
-                if not d.called:
-                    d.callback(args)
-
-            self.bus.call_async(dbus.bus.BUS_DAEMON_NAME,
-                                dbus.bus.BUS_DAEMON_PATH,
-                                dbus.bus.BUS_DAEMON_IFACE, 'RemoveMatch', 's',
-                                (str(match),), callback, self.error_handler)
-            deferreds.append(d)
-        if deferreds:
-            return defer.DeferredList(deferreds)
-        else:
-            return defer.succeed(True)
-
-
-class MementoHandler(logging.Handler):
-    """A handler class which store logging records in a list."""
-
-    def __init__(self, *args, **kwargs):
-        """Create the instance, and add a records attribute."""
-        logging.Handler.__init__(self, *args, **kwargs)
-        self.records = []
-
-    def emit(self, record):
-        """Just add the record to self.records."""
-        self.records.append(record)
-
-    def check(self, level, *msgs):
-        """Verifies that the msgs are logged in the specified level."""
-        for rec in self.records:
-            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 'debian/changelog'
--- debian/changelog	2010-12-17 20:25:51 +0000
+++ debian/changelog	2011-01-13 00:33:10 +0000
@@ -1,3 +1,21 @@
+ubuntu-sso-client (1.1.8-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release:
+
+    [ Natalia B. Bidart <[e-mail]>]
+     - The service should shutdown when unused
+       (LP: #701606),
+     - On error, {find,clear,store}_credentials send proper CredentialsError
+       signal (LP: #696676).
+     - No more gobject dependency on non-GUI classes!
+       (LP: #695798).
+     - After login, if the storing of credentials fails, send LoginError
+       (LP: #693531).
+     - Use ubuntuone-dev-tools to run the tests and the lint checker
+       (LP: #686606).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Wed, 12 Jan 2011 15:59:23 -0300
+
 ubuntu-sso-client (1.1.7-0ubuntu1) natty; urgency=low
 
   * New upstream release.

=== modified file 'run-tests'
--- run-tests	2010-10-11 13:22:16 +0000
+++ run-tests	2011-01-13 00:33:10 +0000
@@ -15,14 +15,23 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+if [ $# -ne 0 ]; then
+    # an extra argument was given
+    MODULE="$@"
+else
+    # run all tests, useful for tarmac and reviews
+    MODULE="ubuntu_sso"
+fi
+
 style_check() {
-    pylint contrib ubuntu_sso
+    u1lint
     if [ -x `which pep8` ]; then
-        pep8 --repeat bin/ contrib/ ubuntu_sso/
+        pep8 --repeat bin/ $MODULE
     else
         echo "Please install the 'pep8' package."
     fi
 }
 
-`which xvfb-run` ./contrib/test "$@" && style_check
-rm -rf _trial_temp/
+echo "Running test suite for ""$MODULE"
+`which xvfb-run` u1trial "$MODULE" && style_check
+rm -rf _trial_temp

=== modified file 'setup.py'
--- setup.py	2010-12-16 16:31:34 +0000
+++ setup.py	2011-01-13 00:33:10 +0000
@@ -31,16 +31,15 @@
 assert DistUtilsExtra.auto.__version__ >= '2.18', \
        'needs DistUtilsExtra.auto >= 2.18'
 
-from distutils.core import setup
 from distutils.spawn import find_executable
-from distutils.command import clean, build
+from distutils.command import clean
 
 # Defining variables for various rules here, similar to a Makefile.am
 CLEANFILES = ['data/com.ubuntu.sso.service', 'po/ubuntu-sso-client.pot',
               'MANIFEST']
 
 
-# XXX: This needs some serious cleanup
+# This needs some serious cleanup
 class SSOBuild(build_extra.build_extra):
     """Class to build the extra files."""
 
@@ -87,7 +86,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='1.1.7',
+    version='1.1.8',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/credentials.py	2011-01-13 00:33:10 +0000
@@ -22,10 +22,12 @@
 
  * find_credentials
  * clear_credentials
+ * store_credentials
  * register
  * login
 
-The first two returns immediately (for now).
+The first three return a Deferred that will be fired when the operation was
+completed.
 
 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
@@ -41,8 +43,6 @@
 
 from functools import wraps
 
-import gobject
-
 from oauth import oauth
 from twisted.internet.defer import inlineCallbacks, returnValue
 
@@ -187,13 +187,15 @@
 
     @handle_failures(msg='Problem while retrieving credentials')
     @inlineCallbacks
-    def _login_success_cb(self, dialog, app_name, email):
+    def _login_success_cb(self, 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.
 
+        Return 0 on success, and a non-zero value (or None) on error.
+
         """
         logger.info('Login/registration was successful for app %r, email %r',
                     app_name, email)
@@ -202,19 +204,21 @@
             assert len(creds) > 0, 'Creds are empty! This should not happen'
             # ping a server with the credentials if we were requested to
             if self.ping_url is not None:
-                status = self._ping_url(app_name, email, creds)
+                status = yield self._ping_url(app_name, email, creds)
                 if status is None:
                     yield self.clear_credentials()
                     return
 
             self.success_cb(creds)
+            returnValue(0)
 
-    def _auth_denial_cb(self, dialog, app_name):
+    def _auth_denial_cb(self, 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')
+    @handle_failures(msg='Problem opening the ping_url')
+    @inlineCallbacks
     def _ping_url(self, app_name, email, credentials):
         """Ping the self.ping_url with the email attached.
 
@@ -237,9 +241,12 @@
         request = urllib2.Request(url, headers=oauth_req.to_header())
         logger.debug('Opening the url "%s" with urllib2.urlopen.',
                      request.get_full_url())
+        # This code is blocking, we should change this.
+        # I've tried with deferToThread an twisted.web.client.getPage
+        # but the returned deferred will never be fired (nataliabidart).
         response = urllib2.urlopen(request)
         logger.debug('Url opened. Response: %s.', response.code)
-        return response.code
+        returnValue(response.code)
 
     @handle_exceptions(msg='Problem opening the Ubuntu SSO user interface')
     def _show_ui(self, login_only):
@@ -252,10 +259,9 @@
                         tc_url=self.tc_url, help_text=self.help_text,
                         window_id=self.window_id, login_only=login_only)
 
-        self.gui.connect(gui.SIG_LOGIN_SUCCEEDED, self._login_success_cb)
-        self.gui.connect(gui.SIG_REGISTRATION_SUCCEEDED,
-                         self._login_success_cb)
-        self.gui.connect(gui.SIG_USER_CANCELATION, self._auth_denial_cb)
+        self.gui.login_success_callback = self._login_success_cb
+        self.gui.registration_success_callback = self._login_success_cb
+        self.gui.user_cancellation_callback = self._auth_denial_cb
 
     @handle_failures(msg='Problem while retrieving credentials')
     @inlineCallbacks
@@ -265,35 +271,23 @@
         if token is not None and len(token) > 0:
             self.success_cb(token)
         elif token == {}:
-            gobject.idle_add(self._show_ui, login_only)
+            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.')
 
     def error_cb(self, error_dict):
-        """Handle error.
-
-        Notify the caller and finish the GUI with error.
-
-        """
+        """Handle error and notify the caller."""
+        logger.error('Calling error callback at %r (error is %r).',
+                     self._error_cb, error_dict)
         self._error_cb(self.app_name, error_dict)
-        if self.gui is not None:
-            self.gui.finish_error(error=error_dict)
-        self.gui = None
 
     def success_cb(self, creds):
-        """Handle success.
-
-        Notify the caller and finish the GUI with success.
-
-        """
+        """Handle success and notify the caller."""
+        logger.debug('Calling success callback at %r.', self._success_cb)
         self._success_cb(self.app_name, creds)
-        if self.gui is not None:
-            self.gui.finish_success()
-        self.gui = None
 
-    @handle_failures(msg='Problem while retrieving credentials')
     @inlineCallbacks
     def find_credentials(self):
         """Get the credentials for 'self.app_name'. Return {} if not there."""
@@ -302,13 +296,11 @@
                     'result is {}? %s', self.app_name, creds is None)
         returnValue(creds if creds is not None else {})
 
-    @handle_failures(msg='Problem while deleting credentials')
     @inlineCallbacks
     def clear_credentials(self):
         """Clear the credentials for 'self.app_name'."""
         yield Keyring().delete_credentials(self.app_name)
 
-    @handle_failures(msg='Problem while storing credentials')
     @inlineCallbacks
     def store_credentials(self, token):
         """Store the credentials for 'self.app_name'."""

=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/gtk/gui.py	2011-01-13 00:33:10 +0000
@@ -30,11 +30,11 @@
 
 import dbus
 import gettext
-import gobject
 import gtk
 import xdg
 
 from dbus.mainloop.glib import DBusGMainLoop
+from twisted.internet.defer import inlineCallbacks
 
 from ubuntu_sso import (DBUS_ACCOUNT_PATH, DBUS_BUS_NAME, DBUS_IFACE_USER_NAME,
     NO_OP)
@@ -72,20 +72,6 @@
 HELP_TEXT_COLOR = gtk.gdk.Color("#bfbfbf")
 WARNING_TEXT_COLOR = gtk.gdk.Color("red")
 
-SIG_LOGIN_SUCCEEDED = 'login-succeeded'
-SIG_REGISTRATION_SUCCEEDED = 'registration-succeeded'
-SIG_USER_CANCELATION = 'user-cancelation'
-
-SIGNAL_ARGUMENTS = [
-    (SIG_LOGIN_SUCCEEDED, (gobject.TYPE_STRING, gobject.TYPE_STRING,)),
-    (SIG_REGISTRATION_SUCCEEDED, (gobject.TYPE_STRING, gobject.TYPE_STRING,)),
-    (SIG_USER_CANCELATION, (gobject.TYPE_STRING,)),
-]
-
-for sig, sig_args in SIGNAL_ARGUMENTS:
-    gobject.signal_new(sig, gtk.Window, gobject.SIGNAL_RUN_FIRST,
-                       gobject.TYPE_NONE, sig_args)
-
 
 def get_data_dir():
     """Build absolute path to  the 'data' directory."""
@@ -198,7 +184,7 @@
 
 
 class UbuntuSSOClientGUI(object):
-    """Ubuntu single sign on GUI."""
+    """Ubuntu single sign-on GUI."""
 
     CAPTCHA_SOLUTION_ENTRY = _('Type the characters above')
     CAPTCHA_LOAD_ERROR = _('There was a problem getting the captcha, '
@@ -256,7 +242,7 @@
     CAPTCHA_RELOAD_TOOLTIP = _('Reload')
 
     def __init__(self, app_name, tc_url='', help_text='',
-                 window_id=0, login_only=False, close_callback=None):
+                 window_id=0, login_only=False):
         """Create the GUI and initialize widgets."""
         gtk.link_button_set_uri_hook(NO_OP)
 
@@ -270,7 +256,12 @@
         self.tc_url = tc_url
         self.help_text = help_text
         self.login_only = login_only
-        self.close_callback = close_callback
+
+        self.close_callback = NO_OP
+        self.login_success_callback = NO_OP
+        self.registration_success_callback = NO_OP
+        self.user_cancellation_callback = NO_OP
+
         self.user_email = None
         self.user_password = None
 
@@ -730,17 +721,12 @@
                      signal_name, handler, args, kwargs)
         self.window.connect(signal_name, handler, *args, **kwargs)
 
-    def emit(self, *args, **kwargs):
-        """Emit a signal proxing the main window."""
-        logger.debug('emit: args  %r, kwargs, %r', args, kwargs)
-        self.window.emit(*args, **kwargs)
-
     def finish_success(self):
         """The whole process was completed succesfully. Show success page."""
         self._done = True
         self._set_current_page(self.success_vbox)
 
-    def finish_error(self, error):
+    def finish_error(self):
         """The whole process was not completed succesfully. Show error page."""
         self._done = True
         self._set_current_page(self.error_vbox)
@@ -766,18 +752,17 @@
         if self.window is not None:
             self.window.hide()
 
-        # process any pending events before emitting signals
+        # process any pending events before callbacking with result
         while gtk.events_pending():
             gtk.main_iteration()
 
         if not self._done:
-            self.emit(SIG_USER_CANCELATION, self.app_name)
+            self.user_cancellation_callback(self.app_name)
 
         # call user defined callback
-        if self.close_callback is not None:
-            logger.info('Calling custom close_callback %r with params %r, %r',
-                        self.close_callback, args, kwargs)
-            self.close_callback(*args, **kwargs)
+        logger.info('Calling custom close_callback %r with params %r, %r',
+                    self.close_callback, args, kwargs)
+        self.close_callback(*args, **kwargs)
 
     def on_sign_in_button_clicked(self, *args, **kwargs):
         """User wants to sign in, present the Login page."""
@@ -1096,10 +1081,15 @@
         self._set_current_page(self.enter_details_vbox, warning_text=msg)
 
     @log_call
+    @inlineCallbacks
     def on_email_validated(self, app_name, email, *args, **kwargs):
         """User email was successfully verified."""
         self._done = True
-        self.emit(SIG_REGISTRATION_SUCCEEDED, self.app_name, email)
+        result = yield self.registration_success_callback(self.app_name, email)
+        if result == 0:
+            self.finish_success()
+        else:
+            self.finish_error()
 
     @log_call
     def on_email_validation_error(self, app_name, error, *args, **kwargs):
@@ -1112,10 +1102,15 @@
         self._set_current_page(self.verify_email_vbox, warning_text=msg)
 
     @log_call
+    @inlineCallbacks
     def on_logged_in(self, app_name, email, *args, **kwargs):
         """User was successfully logged in."""
         self._done = True
-        self.emit(SIG_LOGIN_SUCCEEDED, self.app_name, email)
+        result = yield self.login_success_callback(self.app_name, email)
+        if result == 0:
+            self.finish_success()
+        else:
+            self.finish_error()
 
     @log_call
     def on_login_error(self, app_name, error, *args, **kwargs):

=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2011-01-13 00:33:10 +0000
@@ -30,8 +30,8 @@
 import webkit
 
 from twisted.trial.unittest import TestCase
+from ubuntuone.devtools.handlers import MementoHandler
 
-from contrib.testing.testcase import MementoHandler
 from ubuntu_sso.gtk 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)
@@ -517,6 +517,11 @@
         self.assertTrue(self._called,
                         'close_callback was called when window was closed.')
 
+    def test_close_callback_if_not_set(self):
+        """The close_callback is a no op if not set."""
+        self.ui.on_close_clicked()
+        # no crash when close_callback is not set
+
     def test_app_name_is_stored(self):
         """The app_name is stored for further use."""
         self.assertIn(APP_NAME, self.ui.app_name)
@@ -555,18 +560,6 @@
 
         self.assertEqual(self.ui.bus.callbacks, {})
 
-    def test_close_callback(self):
-        """A close_callback parameter is called when closing the window."""
-        ui = self.gui_class(close_callback=self._set_called, **self.kwargs)
-        ui.on_close_clicked()
-        self.assertTrue(self._called, 'close_callback was called on close.')
-
-    def test_close_callback_if_none(self):
-        """A close_callback parameter is not called if is None."""
-        ui = self.gui_class(close_callback=None, **self.kwargs)
-        ui.on_close_clicked()
-        # no crash when close_callback is None
-
     def test_pages_are_packed_into_container(self):
         """All the pages are packed in the main container."""
         children = self.ui.content.get_children()
@@ -620,8 +613,7 @@
         buttons = filter(lambda name: 'cancel_button' in name or
                                       'close_button' in name, self.ui.widgets)
         for name in buttons:
-            self.ui = self.gui_class(close_callback=self._set_called,
-                                     **self.kwargs)
+            self.ui.close_callback = self._set_called
             widget = getattr(self.ui, name)
             widget.clicked()
             self.assertEqual(self._called, ((widget,), {}), msg % name)
@@ -661,7 +653,7 @@
 
     def test_finish_error_shows_error_page(self):
         """When calling 'finish_error' the error page is shown."""
-        self.ui.finish_error(error=self.error)
+        self.ui.finish_error()
         self.assert_pages_visibility(finish=True)
         self.assertEqual(self.ui.ERROR, self.ui.finish_vbox.label.get_text())
 
@@ -1164,10 +1156,10 @@
         self.click_verify_email_with_valid_data()
         self.assert_warnings_visibility()
 
-    def test_on_email_validated_shows_processing_page(self):
-        """On email validated the procesing page is still shown."""
+    def test_on_email_validated_shows_finish_page(self):
+        """On email validated the finish page is shown."""
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(processing=True)
+        self.assert_pages_visibility(finish=True)
 
     def test_on_email_validated_does_not_clear_the_help_text(self):
         """On email validated the help text is not removed."""
@@ -1227,6 +1219,32 @@
         self.ui.verify_token_button.clicked()
         self.assertTrue(self._called)
 
+    def test_after_registration_success_finish_success(self):
+        """After REGISTRATION_SUCCESS is called, finish_success is called.
+
+        Only when REGISTRATION_SUCCESS returns 0.
+
+        """
+        self.patch(self.ui, 'finish_success', self._set_called)
+        self.ui.registration_success_callback = lambda app, email: 0
+
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_after_registration_error_finish_error(self):
+        """After REGISTRATION_SUCCESS is called, finish_error is called.
+
+        Only when REGISTRATION_SUCCESS returns a non-zero value.
+
+        """
+        self.patch(self.ui, 'finish_error', self._set_called)
+        self.ui.registration_success_callback = lambda app, email: -1
+
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, ((), {}))
+
 
 class VerifyEmailValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration validation (verify email page)."""
@@ -1480,11 +1498,11 @@
         self.click_connect_with_valid_data()
         self.assert_pages_visibility(processing=True)
 
-    def test_on_logged_in_morphs_to_processing_page(self):
-        """When user logged in the processing page is still shown."""
+    def test_on_logged_in_morphs_to_finish_page(self):
+        """When user logged in the finish page is shown."""
         self.click_connect_with_valid_data()
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(processing=True)
+        self.assert_pages_visibility(finish=True)
 
     def test_on_login_error_morphs_to_login_page(self):
         """On user login error, the previous page is shown."""
@@ -1541,6 +1559,32 @@
         self.assertEqual(self.ui.user_email, EMAIL)
         self.assertEqual(self.ui.user_password, PASSWORD)
 
+    def test_after_login_success_finish_success(self):
+        """After LOGIN_SUCCESSFULL is called, finish_success is called.
+
+        Only when LOGIN_SUCCESSFULL returns 0.
+
+        """
+        self.patch(self.ui, 'finish_success', self._set_called)
+        self.ui.login_success_callback = lambda app, email: 0
+
+        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_after_login_error_finish_error(self):
+        """After LOGIN_SUCCESSFULL is called, finish_error is called.
+
+        Only when LOGIN_SUCCESSFULL returns a non-zero value.
+
+        """
+        self.patch(self.ui, 'finish_error', self._set_called)
+        self.ui.login_success_callback = lambda app, email: -1
+
+        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, ((), {}))
+
 
 class LoginValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user login validation."""
@@ -2060,119 +2104,144 @@
         self.assertEqual(self.ui.help_label.get_text(), HELP_TEXT)
 
 
-class SignalsTestCase(UbuntuSSOClientTestCase):
-    """Test the GTK signal emission."""
+class CallbacksTestCase(UbuntuSSOClientTestCase):
+    """Test the GTK callback calls."""
+
+    LOGIN_SUCCESSFULL = 'login_success_callback'
+    REGISTRATION_SUCCESS = 'registration_success_callback'
+    USER_CANCELLATION = 'user_cancellation_callback'
 
     def setUp(self):
         """Init."""
-        super(SignalsTestCase, self).setUp()
+        super(CallbacksTestCase, self).setUp()
         self._called = {}
-        for sig_name, _ in gui.SIGNAL_ARGUMENTS:
-            self.ui.connect(sig_name, self._set_called, sig_name)
-
-    def _set_called(self, widget, *args, **kwargs):
-        """Keep trace of signals emition."""
+        for name in (self.LOGIN_SUCCESSFULL,
+                     self.REGISTRATION_SUCCESS,
+                     self.USER_CANCELLATION):
+            setattr(self.ui, name, self._set_called(name))
+
+    def _set_called(self, callback_name):
+        """Keep trace of callbacks calls."""
+
         # pylint: disable=W0221
-        self._called[args[-1]] = (widget, args[:-1], kwargs)
-
-    def test_closing_main_window_sends_outcome_as_signal(self):
-        """A signal is sent when closing the main window."""
+
+        def inner(*args, **kwargs):
+            """Store arguments used in this call."""
+            self._called[callback_name] = args
+
+        return inner
+
+    def test_closing_main_window(self):
+        """When closing the main window, USER_CANCELLATION is called."""
         self.ui.window.emit('delete-event', gtk.gdk.Event(gtk.gdk.DELETE))
-        expected = (self.ui.window, (APP_NAME,), {})
-        self.assertEqual(self._called[gui.SIG_USER_CANCELATION], expected)
+        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
 
-    def test_every_cancel_emits_proper_signal(self):
-        """Clicking on any cancel button, 'user-cancelation' signal is sent."""
-        sig = gui.SIG_USER_CANCELATION
-        msg = 'user-cancelation is emitted when "%s" is clicked.'
+    def test_every_cancel_calls_proper_callback(self):
+        """When any cancel button is clicked, USER_CANCELLATION is called."""
+        msg = 'user_cancellation_callback is called when "%s" is clicked.'
         buttons = filter(lambda name: 'cancel_button' in name, self.ui.widgets)
         for name in buttons:
-            self.ui = self.gui_class(**self.kwargs)
-            self.ui.connect(sig, self._set_called, sig)
             widget = getattr(self.ui, name)
             widget.clicked()
-            expected_args = (self.ui.window, (APP_NAME,), {})
-            self.assertEqual(self._called[sig], expected_args, msg % name)
+            self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,),
+                             msg % name)
             self._called = {}
 
-    def test_on_user_registration_error_proper_signal_is_emitted(self):
-        """On UserRegistrationError, SIG_USER_CANCELATION signal is sent."""
+    def test_on_user_registration_error_proper_callback_is_called(self):
+        """On UserRegistrationError, USER_CANCELLATION is called."""
         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.assertEqual(expected,
-                         self._called[gui.SIG_USER_CANCELATION])
-
-    def test_on_email_validated_proper_signals_is_emitted(self):
-        """On EmailValidated, 'registration-succeeded' signal is sent."""
+
+        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+
+    def test_on_email_validated_proper_callback_is_called(self):
+        """On EmailValidated, REGISTRATION_SUCCESS is called."""
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME, EMAIL), {}),
-                          self._called[gui.SIG_REGISTRATION_SUCCEEDED])
-
-    def test_on_email_validation_error_proper_signals_is_emitted(self):
-        """On EmailValidationError, SIG_USER_CANCELATION signal is sent."""
+
+        self.assertEqual(self._called[self.REGISTRATION_SUCCESS],
+                         (APP_NAME, EMAIL))
+
+    def test_on_email_validation_error_proper_callback_is_called(self):
+        """On EmailValidationError, USER_CANCELLATION is called."""
         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.assertEqual(expected,
-                         self._called[gui.SIG_USER_CANCELATION])
-
-    def test_on_logged_in_proper_signals_is_emitted(self):
-        """On LoggedIn, 'login-succeeded' signal is sent."""
+
+        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+
+    def test_on_logged_in_proper_callback_is_called(self):
+        """On LoggedIn, LOGIN_SUCCESSFULL is called."""
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME, EMAIL), {}),
-                          self._called[gui.SIG_LOGIN_SUCCEEDED])
-
-    def test_on_login_error_proper_signals_is_emitted(self):
-        """On LoginError, SIG_USER_CANCELATION signal is sent."""
+
+        self.assertEqual(self._called[self.LOGIN_SUCCESSFULL],
+                         (APP_NAME, EMAIL))
+
+    def test_on_login_error_proper_callback_is_called(self):
+        """On LoginError, USER_CANCELLATION is called."""
         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.assertEqual(expected,
-                         self._called[gui.SIG_USER_CANCELATION])
-
-    def test_registration_successfull_even_if_prior_registration_error(self):
-        """Only one signal is sent with the final outcome."""
+
+        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+
+    def test_registration_success_even_if_prior_registration_error(self):
+        """Only one callback is called with the final outcome.
+
+        When the user successfully registers, REGISTRATION_SUCCESS is
+        called even if there were errors before.
+
+        """
         self.click_join_with_valid_data()
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.click_join_with_valid_data()
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(len(self._called), 1)
-        self.assertTrue(gui.SIG_REGISTRATION_SUCCEEDED in self._called)
-
-    def test_login_successfull_even_if_prior_login_error(self):
-        """Only one signal is sent with the final outcome."""
+        self.assertEqual(self._called[self.REGISTRATION_SUCCESS],
+                         (APP_NAME, EMAIL))
+
+    def test_login_success_even_if_prior_login_error(self):
+        """Only one callback is called with the final outcome.
+
+        When the user successfully logins, LOGIN_SUCCESSFULL is called even if
+        there were errors before.
+
+        """
         self.click_connect_with_valid_data()
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.click_connect_with_valid_data()
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(len(self._called), 1)
-        self.assertTrue(gui.SIG_LOGIN_SUCCEEDED in self._called)
+        self.assertEqual(self._called[self.LOGIN_SUCCESSFULL],
+                         (APP_NAME, EMAIL))
 
     def test_user_cancelation_even_if_prior_registration_error(self):
-        """Only one signal is sent with the final outcome."""
+        """Only one callback is called with the final outcome.
+
+        When the user closes the window, USER_CANCELLATION is called even if
+        there were registration errors before.
+
+        """
         self.click_join_with_valid_data()
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.join_cancel_button.clicked()
 
-        self.assertEqual(len(self._called), 1)
-        self.assertTrue(gui.SIG_USER_CANCELATION in self._called)
+        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
 
     def test_user_cancelation_even_if_prior_login_error(self):
-        """Only one signal is sent with the final outcome."""
+        """Only one callback is called with the final outcome.
+
+        When the user closes the window, USER_CANCELLATION is called even if
+        there were login errors before.
+
+        """
         self.click_connect_with_valid_data()
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.login_cancel_button.clicked()
 
-        self.assertEqual(len(self._called), 1)
-        self.assertTrue(gui.SIG_USER_CANCELATION in self._called)
+        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
 
 
 class DefaultButtonsTestCase(UbuntuSSOClientTestCase):

=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/logger.py	2011-01-13 00:33:10 +0000
@@ -57,6 +57,7 @@
     logger.addHandler(MAIN_HANDLER)
     if os.environ.get('DEBUG'):
         debug_handler = logging.StreamHandler(sys.stderr)
+        debug_handler.setFormatter(logging.Formatter(fmt=FMT))
         logger.addHandler(debug_handler)
 
     return logger

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-12-16 16:31:34 +0000
+++ ubuntu_sso/main.py	2011-01-13 00:33:10 +0000
@@ -50,6 +50,7 @@
 
 logger = setup_logging("ubuntu_sso.main")
 U1_PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+TIMEOUT_INTERVAL = 500
 
 
 class SSOLoginProcessor(Account):
@@ -198,7 +199,9 @@
                 # pylint: disable=E1101
                 d = Keyring().set_credentials(app_name, credentials)
                 d.addCallback(lambda _: self.LoggedIn(app_name, email))
-                d.addErrback(lambda _: self.UserNotValidated(app_name, email))
+                d.addErrback(lambda failure: \
+                             self.LoginError(app_name,
+                                             except_to_errdict(failure.value)))
             else:
                 self.UserNotValidated(app_name, email)
         blocking(f, app_name, success_cb, self.LoginError)
@@ -419,6 +422,12 @@
 
     """
 
+    def __init__(self, timeout_func, shutdown_func, *args, **kwargs):
+        super(CredentialsManagement, self).__init__(*args, **kwargs)
+        self._ref_count = 0
+        self.timeout_func = timeout_func
+        self.shutdown_func = shutdown_func
+
     # Operator not preceded by a space (fails with dbus decorators)
     # pylint: disable=C0322
 
@@ -434,39 +443,70 @@
         result[DENIAL_CB_KEY] = self.AuthorizationDenied
         return result
 
+    def _process_failure(self, failure, app_name):
+        """Process the 'failure' and emit CredentialsError."""
+        self.CredentialsError(app_name, except_to_errdict(failure.value))
+
+    def _get_ref_count(self):
+        """Get value of ref_count."""
+        logger.debug('ref_count is %r.', self._ref_count)
+        return self._ref_count
+
+    def _set_ref_count(self, new_value):
+        """Set a new value to ref_count."""
+        logger.debug('ref_count is %r, changing value to %r.',
+                     self._ref_count, new_value)
+        if new_value < 0:
+            self._ref_count = 0
+            msg = 'Attempting to decrease ref_count to a negative value (%r).'
+            logger.warning(msg, new_value)
+        else:
+            self._ref_count = new_value
+
+        if self._ref_count == 0:
+            self.timeout_func(TIMEOUT_INTERVAL, self.shutdown_func)
+
+    ref_count = property(fget=_get_ref_count, fset=_set_ref_count)
+
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
     def AuthorizationDenied(self, app_name):
         """Signal thrown when the user denies the authorization."""
+        self.ref_count -= 1
         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."""
+        self.ref_count -= 1
         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."""
+        self.ref_count -= 1
         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."""
+        self.ref_count -= 1
         logger.info('%s: emitting CredentialsCleared with app_name "%s".',
                     self.__class__.__name__, app_name)
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
     def CredentialsStored(self, app_name):
         """Signal thrown when the credentials were cleared."""
+        self.ref_count -= 1
         logger.info('%s: emitting CredentialsStored 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."""
+        self.ref_count -= 1
         logger.error('%s: emitting CredentialsError with app_name "%s" and '
                      'error_dict %r.', self.__class__.__name__, app_name,
                      error_dict)
@@ -482,6 +522,7 @@
         - 'args' is a dictionary, currently not used.
 
         """
+        self.ref_count += 1
 
         def success_cb(credentials):
             """Find credentials and notify using signals."""
@@ -494,7 +535,7 @@
         d = obj.find_credentials()
         # pylint: disable=E1101
         d.addCallback(success_cb)
-        d.addErrback(self.CredentialsError)
+        d.addErrback(self._process_failure, app_name)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
@@ -507,11 +548,13 @@
         - 'args' is a dictionary, currently not used.
 
         """
+        self.ref_count += 1
+
         obj = Credentials(app_name)
         d = obj.clear_credentials()
         # pylint: disable=E1101
         d.addCallback(lambda _: self.CredentialsCleared(app_name))
-        d.addErrback(self.CredentialsError)
+        d.addErrback(self._process_failure, app_name)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
@@ -526,16 +569,20 @@
         'consumer_secret'.
 
         """
+        self.ref_count += 1
+
         obj = Credentials(app_name)
         d = obj.store_credentials(args)
         # pylint: disable=E1101
         d.addCallback(lambda _: self.CredentialsStored(app_name))
-        d.addErrback(self.CredentialsError)
+        d.addErrback(self._process_failure, app_name)
 
     @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."""
+        self.ref_count += 1
+
         obj = Credentials(app_name, **self._parse_args(args))
         obj.register()
 
@@ -543,5 +590,7 @@
                          in_signature='sa{ss}', out_signature='')
     def login(self, app_name, args):
         """Get credentials if found else prompt GUI to login."""
+        self.ref_count += 1
+
         obj = Credentials(app_name, **self._parse_args(args))
         obj.login()

=== modified file 'ubuntu_sso/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/tests/__init__.py	2011-01-13 00:33:10 +0000
@@ -18,6 +18,8 @@
 
 import os
 
+from twisted.trial import unittest
+
 from ubuntu_sso.keyring import get_token_name
 
 APP_NAME = 'The Super App!'
@@ -45,3 +47,15 @@
 TOKEN_NAME = get_token_name(APP_NAME)
 TC_URL = 'http://localhost/'
 WINDOW_ID = 5
+
+
+class TestCase(unittest.TestCase):
+    """Customized test case that keeps tracks of method calls."""
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Keep track of a method call."""
+        self._called = (args, kwargs)

=== modified file 'ubuntu_sso/tests/bin/show_gui'
--- ubuntu_sso/tests/bin/show_gui	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/tests/bin/show_gui	2011-01-13 00:33:10 +0000
@@ -31,11 +31,12 @@
             'Nam sed lorem nibh. Suspendisse gravida nulla non nunc suscipit' \
             ' pulvinar tempus ut augue.'
 
-main_quit = lambda *args, **kwargs: gtk.main_quit()
-
 
 if __name__ == '__main__':
-    tc_url=TC_URL
+
+    # pylint: disable=C0103, E1101
+
+    tc_url = TC_URL
     login_only = False
     xid = 0
 
@@ -51,7 +52,7 @@
         win.show()
         xid = win.window.xid
 
-    UbuntuSSOClientGUI(close_callback=main_quit, app_name=APP_NAME,
-                       tc_url=tc_url, help_text=HELP_TEXT, window_id=xid,
-                       login_only=login_only)
+    UbuntuSSOClientGUI(close_callback=lambda *args, **kwargs: gtk.main_quit(),
+                       app_name=APP_NAME, tc_url=tc_url, help_text=HELP_TEXT,
+                       window_id=xid, login_only=login_only)
     gtk.main()

=== modified file 'ubuntu_sso/tests/bin/show_nm_state'
--- ubuntu_sso/tests/bin/show_nm_state	2010-09-08 19:25:02 +0000
+++ ubuntu_sso/tests/bin/show_nm_state	2011-01-13 00:33:10 +0000
@@ -26,7 +26,6 @@
 from ubuntu_sso.networkstate import NetworkManagerState, NM_STATE_NAMES
 
 DBusGMainLoop(set_as_default=True)
-loop = gobject.MainLoop()
 
 
 def got_state(state):
@@ -34,8 +33,9 @@
     try:
         print NM_STATE_NAMES[state]
     finally:
-        loop.quit()
+        gobject.MainLoop().quit()
 
+# pylint: disable=C0103
 nms = NetworkManagerState(got_state)
 nms.find_online_state()
-loop.run()
+gobject.MainLoop().run()

=== modified file 'ubuntu_sso/tests/test_credentials.py'
--- ubuntu_sso/tests/test_credentials.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/tests/test_credentials.py	2011-01-13 00:33:10 +0000
@@ -21,13 +21,11 @@
 import logging
 import urllib
 
-import gobject
-
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks
 from twisted.trial.unittest import TestCase, FailTest
+from ubuntuone.devtools.handlers import MementoHandler
 
-from contrib.testing.testcase import MementoHandler
 from ubuntu_sso import credentials
 from ubuntu_sso.credentials import (APP_NAME_KEY, HELP_TEXT_KEY, NO_OP,
     PING_URL_KEY, TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
@@ -60,10 +58,6 @@
     WINDOW_ID_KEY: WINDOW_ID,
 }
 
-SIG_LOGIN_SUCCEEDED = '1'
-SIG_REGISTRATION_SUCCEEDED = '2'
-SIG_USER_CANCELATION = '3'
-
 
 class SampleMiscException(Exception):
     """An error to be used while testing."""
@@ -82,17 +76,9 @@
     def __init__(self, *args, **kwargs):
         self.args = args
         self.kwargs = kwargs
-        self.signals = []
-        self.methods = []
-        self.connect = lambda *a: self.signals.append(a)
-
-    def finish_success(self):
-        """Fake the success finish."""
-        self.methods.append('finish_success')
-
-    def finish_error(self, error):
-        """Fake the error finish."""
-        self.methods.append(('finish_error', error))
+        self.login_success_callback = None
+        self.registration_success_callback = None
+        self.user_cancellation_callback = None
 
 
 class BasicTestCase(TestCase):
@@ -100,7 +86,6 @@
 
     def setUp(self):
         """Init."""
-        self.patch(gobject, 'idle_add', lambda f, *a, **kw: f(*a, **kw))
         self._called = False  # helper
 
         self.memento = MementoHandler()
@@ -226,45 +211,21 @@
 
         self.assertEqual(getattr(self.obj, UI_MODULE_KEY), GTK_GUI_MODULE)
 
-    def test_success_cb_gui_none(self):
-        """Success callback calls the caller but not the GUI."""
-        self.obj.gui = None
-        self.obj.success_cb(creds=TOKEN)
-
-        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}),
-                         'caller _success_cb was called.')
-
-    def test_success_cb_gui_not_none(self):
-        """Success callback calls the caller and finish the GUI."""
-        self.obj.gui = ui = FakedClientGUI(APP_NAME)
-        self.obj.success_cb(creds=TOKEN)
-
-        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}),
-                         'caller _success_cb was called.')
-        self.assertEqual(ui.methods, ['finish_success'],
-                         'GUI finish_success was called.')
-        self.assertTrue(self.obj.gui is None, 'gui is reset to None.')
-
-    def test_error_cb_gui_none(self):
-        """Error callback calls the caller but not the GUI."""
-        self.obj.gui = None
-        error_dict = {'foo': 'bar'}
-        self.obj.error_cb(error_dict=error_dict)
-
-        self.assertEqual(self._called, (('error', APP_NAME, error_dict), {}),
-                         'caller _error_cb was called.')
-
-    def test_error_cb_gui_not_none(self):
-        """Error callback calls the caller and finish the GUI."""
-        self.obj.gui = ui = FakedClientGUI(APP_NAME)
-        error_dict = {'foo': 'bar'}
-        self.obj.error_cb(error_dict=error_dict)
-
-        self.assertEqual(self._called, (('error', APP_NAME, error_dict), {}),
-                         'caller _error_cb was called.')
-        self.assertEqual(ui.methods, [('finish_error', error_dict)],
-                         'GUI finish_error was called.')
-        self.assertTrue(self.obj.gui is None, 'gui is reset to None.')
+    def test_success_cb(self):
+        """Success callback calls the caller."""
+        self.obj.gui = None
+        self.obj.success_cb(creds=TOKEN)
+
+        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}),
+                         'caller _success_cb was called.')
+
+    def test_error_cb(self):
+        """Error callback calls the caller."""
+        error_dict = {'foo': 'bar'}
+        self.obj.error_cb(error_dict=error_dict)
+
+        self.assertEqual(self._called, (('error', APP_NAME, error_dict), {}),
+                         'caller _error_cb was called.')
 
 
 class CredentialsLoginSuccessTestCase(CredentialsTestCase):
@@ -276,12 +237,12 @@
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
 
-        yield self.obj._login_success_cb(dialog=None, app_name=APP_NAME,
-                                         email=EMAIL)
+        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
 
         msg = 'Creds are empty! This should not happen'
         self.assert_error_cb_called(msg='Problem while retrieving credentials',
                                     detailed_error=AssertionError(msg))
+        self.assertEqual(result, None)
 
     @inlineCallbacks
     def test_cred_error(self):
@@ -290,11 +251,11 @@
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.fail(expected_error))
 
-        yield self.obj._login_success_cb(dialog=None, app_name=APP_NAME,
-                                         email=EMAIL)
+        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
 
         msg = 'Problem while retrieving credentials'
         self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
+        self.assertEqual(result, None)
         self.assertTrue(self.memento.check_exception(SampleMiscException))
 
     @inlineCallbacks
@@ -304,10 +265,10 @@
                    lambda kr, app: defer.succeed(TOKEN))
         self.patch(self.obj, '_ping_url', lambda *a, **kw: 200)
 
-        yield self.obj._login_success_cb(dialog=None, app_name=APP_NAME,
-                                         email=EMAIL)
+        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
 
         self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
+        self.assertEqual(result, 0)
 
     @inlineCallbacks
     def test_ping_error(self):
@@ -324,12 +285,12 @@
         self.patch(self.obj, 'clear_credentials',
                    lambda: setattr(self, '_cred_cleared', True))
 
-        yield self.obj._login_success_cb(dialog=None, app_name=APP_NAME,
-                                         email=EMAIL)
+        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
 
         # error cb called correctly
         msg = 'Problem opening the ping_url'
         self.assert_error_cb_called(msg=msg, detailed_error=FailTest(error))
+        self.assertEqual(result, None)
 
         # credentials cleared
         self.assertTrue(self._cred_cleared)
@@ -349,8 +310,7 @@
         self.patch(self.obj, '_ping_url',
                    lambda *a, **kw: setattr(self, '_url_pinged', (a, kw)))
 
-        yield self.obj._login_success_cb(dialog=None, app_name=APP_NAME,
-                                         email=EMAIL)
+        yield self.obj._login_success_cb(APP_NAME, EMAIL)
 
         self.assertEqual(self._url_pinged, ((APP_NAME, EMAIL, TOKEN), {}))
 
@@ -366,10 +326,10 @@
         self.patch(self.obj, 'clear_credentials', self._set_called)
         self.obj.ping_url = None
 
-        yield self.obj._login_success_cb(dialog=None, app_name=APP_NAME,
-                                         email=EMAIL)
+        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
 
         self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
+        self.assertEqual(result, 0)
 
 
 class CredentialsAuthDeniedTestCase(CredentialsTestCase):
@@ -377,10 +337,9 @@
 
     def test_auth_denial_cb(self):
         """On auth denied, self.denial_cb is called."""
-        self.obj.gui = ui = FakedClientGUI(APP_NAME)
-        self.obj._auth_denial_cb(dialog=None, app_name=APP_NAME)
+        self.obj._auth_denial_cb(app_name=APP_NAME)
+
         self.assertEqual(self._called, (('denial', APP_NAME), {}))
-        self.assertEqual(ui.methods, [], 'no GUI method was called.')
 
 
 class PingUrlTestCase(CredentialsTestCase):
@@ -401,24 +360,29 @@
 
         self.patch(credentials.urllib2, 'urlopen', faked_urlopen)
 
+    @inlineCallbacks
     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)
+        yield self.obj._ping_url(app_name=APP_NAME, email=EMAIL,
+                                 credentials=TOKEN)
         # no failure
 
+    @inlineCallbacks
     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)
+        yield 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)
 
+    @inlineCallbacks
     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)
+        result = yield self.obj._ping_url(APP_NAME, EMAIL, TOKEN)
         headers = self._request.headers
 
         self.assertIn('Authorization', headers)
@@ -431,12 +395,13 @@
         self.assertIn(expected, oauth_stuff)
         self.assertEqual(result, 200)
 
+    @inlineCallbacks
     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)
+        yield 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))
@@ -472,11 +437,8 @@
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.fail(expected_error))
 
-        yield self.obj.find_credentials()
-
-        msg = 'Problem while retrieving credentials'
-        self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
-        self.assertTrue(self.memento.check_exception(SampleMiscException))
+        yield self.assertFailure(self.obj.find_credentials(),
+                                 SampleMiscException)
 
 
 class ClearCredentialsTestCase(CredentialsTestCase):
@@ -498,11 +460,8 @@
         self.patch(credentials.Keyring, 'delete_credentials',
                    lambda kr, app: defer.fail(expected_error))
 
-        yield self.obj.clear_credentials()
-
-        msg = 'Problem while deleting credentials'
-        self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
-        self.assertTrue(self.memento.check_exception(SampleMiscException))
+        yield self.assertFailure(self.obj.clear_credentials(),
+                                 SampleMiscException)
 
 
 class StoreCredentialsTestCase(CredentialsTestCase):
@@ -524,11 +483,8 @@
         self.patch(credentials.Keyring, 'set_credentials',
                    lambda kr, app, token: defer.fail(expected_error))
 
-        yield self.obj.store_credentials(TOKEN)
-
-        msg = 'Problem while storing credentials'
-        self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
-        self.assertTrue(self.memento.check_exception(SampleMiscException))
+        yield self.assertFailure(self.obj.store_credentials(TOKEN),
+                                 SampleMiscException)
 
 
 class RegisterTestCase(CredentialsTestCase):
@@ -592,17 +548,17 @@
 
     @inlineCallbacks
     def test_connects_gui_signals(self):
-        """Outcome signals from GUI are connected to callbacks."""
+        """GUI callbacks are properly connected."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
-
-        expected = [
-            (SIG_LOGIN_SUCCEEDED, self.obj._login_success_cb),
-            (SIG_REGISTRATION_SUCCEEDED, self.obj._login_success_cb),
-            (SIG_USER_CANCELATION, self.obj._auth_denial_cb),
-        ]
         yield getattr(self.obj, self.operation)()
-        self.assertEqual(self.obj.gui.signals, expected)
+
+        self.assertEqual(self.obj.gui.login_success_callback,
+                         self.obj._login_success_cb)
+        self.assertEqual(self.obj.gui.registration_success_callback,
+                         self.obj._login_success_cb)
+        self.assertEqual(self.obj.gui.user_cancellation_callback,
+                         self.obj._auth_denial_cb)
 
     @inlineCallbacks
     def test_gui_is_created(self):

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-12-16 16:31:34 +0000
+++ ubuntu_sso/tests/test_main.py	2011-01-13 00:33:10 +0000
@@ -27,21 +27,22 @@
 from twisted.internet import defer
 from twisted.internet.defer import Deferred, inlineCallbacks
 from twisted.trial.unittest import TestCase
+from ubuntuone.devtools.handlers import MementoHandler
 
 import ubuntu_sso.keyring
 import ubuntu_sso.main
 
-from contrib.testing.testcase import MementoHandler
 from ubuntu_sso import DBUS_CREDENTIALS_IFACE
 from ubuntu_sso.keyring import U1_APP_NAME
-from ubuntu_sso.main import (U1_PING_URL, blocking, except_to_errdict,
+from ubuntu_sso.main import (U1_PING_URL, TIMEOUT_INTERVAL,
+    blocking, except_to_errdict,
     CredentialsManagement, SSOCredentials, SSOLogin)
 from ubuntu_sso.main import (HELP_TEXT_KEY, PING_URL_KEY,
     TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_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)
+    TOKEN_NAME, WINDOW_ID, TestCase)
 
 
 # Access to a protected member 'yyy' of a client class
@@ -70,6 +71,8 @@
 class SsoDbusTestCase(TestCase):
     """Test the SSOLogin DBus interface."""
 
+    timeout = 2
+
     def setUp(self):
         """Create the mocking bus."""
         self.mocker = Mocker()
@@ -256,8 +259,8 @@
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
-    def test_login_error(self):
-        """Test that the login method fails as expected."""
+    def test_login_error_get_token_name(self):
+        """The login method fails as expected when get_token_name fails."""
         d = Deferred()
         self.create_mock_processor()
         self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
@@ -284,6 +287,40 @@
         client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
+    def test_login_error_set_credentials(self):
+        """The login method fails as expected when set_credentials fails."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        processor.is_validated(TOKEN)
+        self.mocker.result(True)
+
+        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+
+        def fake_set_creds(*args):
+            """A fake Keyring.set_credentials that fails."""
+            return defer.fail(BlockingSampleException())
+
+        self.patch(ubuntu_sso.main.Keyring, "set_credentials", fake_set_creds)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        fail = lambda app, res: d.errback((app, res))
+        self.patch(client, "LoggedIn", fail)
+        self.patch(client, "LoginError", verify)
+        self.patch(client, "UserNotValidated", fail)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
     def test_validate_email(self):
         """Test that the validate_email method works ok."""
         d = Deferred()
@@ -666,21 +703,30 @@
 class CredentialsManagementTestCase(TestCase):
     """Tests for the CredentialsManagement DBus interface."""
 
+    timeout = 2
     base_args = {HELP_TEXT_KEY: HELP_TEXT, PING_URL_KEY: PING_URL,
                  TC_URL_KEY: TC_URL, WINDOW_ID_KEY: WINDOW_ID,
                  UI_CLASS_KEY: 'SuperUI', UI_MODULE_KEY: 'foo.bar.baz',
                 }
 
     def setUp(self):
+        super(CredentialsManagementTestCase, self).setUp()
+
         self.mocker = Mocker()
-        self.client = CredentialsManagement()
+        self.client = CredentialsManagement(timeout_func=lambda *a: None,
+                                            shutdown_func=lambda *a: None)
         self.args = {}
         self.cred_args = {}
 
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        ubuntu_sso.main.logger.addHandler(self.memento)
+
     def tearDown(self):
         """Verify the mocking stuff and shut it down."""
         self.mocker.verify()
         self.mocker.restore()
+        super(CredentialsManagementTestCase, self).tearDown()
 
     def assert_dbus_method_correct(self, method):
         """Check that 'method' is a dbus method with proper signatures."""
@@ -703,10 +749,168 @@
         self.assertIsInstance(self.client, ubuntu_sso.main.dbus.service.Object)
 
 
-class CredentialsManagementFindClearTestCase(CredentialsManagementTestCase):
-    """Tests for the CredentialsManagement find/clear/store methods."""
-
-    timeout = 5
+class CredentialsManagementRefCountingTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement ref counting."""
+
+    def test_ref_counting(self):
+        """Ref counting is in place."""
+        self.assertEqual(self.client.ref_count, 0)
+
+    def test_find_credentials(self):
+        """Keep proper track of on going requests."""
+        self.client.find_credentials(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_clear_credentials(self):
+        """Keep proper track of on going requests."""
+        self.client.clear_credentials(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_store_credentials(self):
+        """Keep proper track of on going requests."""
+        self.client.store_credentials(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_register(self):
+        """Keep proper track of on going requests."""
+        self.client.register(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_login(self):
+        """Keep proper track of on going requests."""
+        self.client.login(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_several_requests(self):
+        """Requests can be nested."""
+        self.client.login(APP_NAME, self.args)
+        self.client.clear_credentials(APP_NAME, self.args)
+        self.client.find_credentials(APP_NAME, self.args)
+        self.client.register(APP_NAME, self.args)
+        self.client.store_credentials(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 5)
+
+    def test_credentials_found(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_not_found(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsNotFound(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_cleared(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsCleared(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_stored(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsStored(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_error(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsError(APP_NAME, {'error_type': 'test'})
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_authorization_denied(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.AuthorizationDenied(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_found_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_not_found_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsNotFound(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_cleared_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsCleared(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_stored_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsStored(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_error_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsError(APP_NAME, {'error_type': 'test'})
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_autorization_denied_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.AuthorizationDenied(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_on_zero_ref_count_shutdown(self):
+        """When ref count reaches 0, queue shutdown op."""
+        self.client.timeout_func = self._set_called
+        self.client.find_credentials(APP_NAME, self.args)
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+
+        self.assertEqual(self._called,
+                         ((TIMEOUT_INTERVAL, self.client.shutdown_func), {}))
+
+    def test_on_non_zero_ref_count_do_not_shutdown(self):
+        """If ref count is not 0, do not queue shutdown op."""
+        self.client.timeout_func = self._set_called
+        self.client.find_credentials(APP_NAME, self.args)
+
+        self.assertEqual(self._called, False)
+
+
+class CredentialsManagementFindTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement find method."""
 
     def test_find_credentials(self):
         """The credentials are asked and returned in signals."""
@@ -762,7 +966,8 @@
             else:
                 d.callback(app_name)
 
-        self.patch(self.client, 'CredentialsFound', d.errback)
+        self.patch(self.client, 'CredentialsFound',
+                   lambda app, creds: d.errback(app))
         self.patch(self.client, 'CredentialsNotFound', verify)
 
         self.create_mock_backend().find_credentials()
@@ -772,6 +977,32 @@
         self.client.find_credentials(APP_NAME, self.args)
         return d
 
+    def test_find_credentials_error(self):
+        """If find_credentials fails, CredentialsError is sent."""
+        d = Deferred()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        self.patch(self.client, 'CredentialsFound',
+                   lambda app, creds: d.errback(app))
+        self.patch(self.client, 'CredentialsNotFound', d.errback)
+        self.patch(self.client, 'CredentialsError', verify)
+
+        self.create_mock_backend().find_credentials()
+        self.mocker.result(defer.fail(BlockingSampleException()))
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        return d
+
+
+class CredentialsManagementClearTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement clear method."""
+
     def test_clear_credentials(self):
         """The credentials are removed."""
         self.create_mock_backend().clear_credentials()
@@ -795,7 +1026,8 @@
                 d.callback(app_name)
 
         self.patch(self.client, 'CredentialsCleared', verify)
-        self.patch(self.client, 'CredentialsError', d.errback)
+        self.patch(self.client, 'CredentialsError',
+                   lambda app, err: d.errback(app))
 
         self.create_mock_backend().clear_credentials()
         self.mocker.result(defer.succeed(APP_NAME))
@@ -804,6 +1036,30 @@
         self.client.clear_credentials(APP_NAME, self.args)
         return d
 
+    def test_clear_credentials_error(self):
+        """If clear_credentials fails, CredentialsError is sent."""
+        d = Deferred()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        self.patch(self.client, 'CredentialsCleared', d.errback)
+        self.patch(self.client, 'CredentialsError', verify)
+
+        self.create_mock_backend().clear_credentials()
+        self.mocker.result(defer.fail(BlockingSampleException()))
+        self.mocker.replay()
+
+        self.client.clear_credentials(APP_NAME, self.args)
+        return d
+
+
+class CredentialsManagementStoreTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement store method."""
+
     def test_store_credentials(self):
         """The credentials are stored and the outcome is a signal."""
         self.create_mock_backend().store_credentials(TOKEN)
@@ -831,7 +1087,8 @@
                 d.callback(app_name)
 
         self.patch(self.client, 'CredentialsStored', verify)
-        self.patch(self.client, 'CredentialsError', d.errback)
+        self.patch(self.client, 'CredentialsError',
+                   lambda app, err: d.errback(app))
 
         self.create_mock_backend().store_credentials(TOKEN)
         self.mocker.result(defer.succeed(APP_NAME))
@@ -840,6 +1097,26 @@
         self.client.store_credentials(APP_NAME, TOKEN)
         return d
 
+    def test_store_credentials_error(self):
+        """If store_credentials fails, CredentialsError is sent."""
+        d = Deferred()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        self.patch(self.client, 'CredentialsStored', d.errback)
+        self.patch(self.client, 'CredentialsError', verify)
+
+        self.create_mock_backend().store_credentials(TOKEN)
+        self.mocker.result(defer.fail(BlockingSampleException()))
+        self.mocker.replay()
+
+        self.client.store_credentials(APP_NAME, TOKEN)
+        return d
+
 
 class CredentialsManagementOpsTestCase(CredentialsManagementTestCase):
     """Tests for the CredentialsManagement login/register methods."""
@@ -881,7 +1158,8 @@
     """Tests for the CredentialsManagement DBus signals."""
 
     def setUp(self):
-        self.client = CredentialsManagement()
+        self.client = CredentialsManagement(timeout_func=lambda *a: None,
+                                            shutdown_func=lambda *a: None)
 
         self.memento = MementoHandler()
         self.memento.setLevel(logging.DEBUG)