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

[Natalia Bidart]

Packaging for upstream version 0.98.

=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2010-08-11 18:19:01 +0000
@@ -0,0 +1,7 @@
+include MANIFEST.in
+include COPYING LICENSE.mocker README
+include run-tests mocker.py
+recursive-include bin *
+recursive-include data *
+recursive-include ubuntu_sso *.py
+recursive-include contrib *.py *.conf test

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-06-16 15:11:04 +0000
+++ PKG-INFO	2010-08-11 18:19:01 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: ubuntu-sso-client
-Version: 0.0.3
+Version: 0.98
 Summary: Ubuntu Single Sign-On client
 Home-page: https://launchpad.net/ubuntu-sso-client
 Author: Natalia Bidart

=== added file 'bin/show_nm_state.py'
--- bin/show_nm_state.py	1970-01-01 00:00:00 +0000
+++ bin/show_nm_state.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,39 @@
+# show_nm_state - Show the state of the NetworkManager daemon
+#
+# Author: Alejandro J. Cura <[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/>.
+"""A test program that just shows the network state."""
+
+import gobject
+
+from dbus.mainloop.glib import DBusGMainLoop
+
+from ubuntu_sso.networkstate import NetworkManagerState, nm_state_names
+
+DBusGMainLoop(set_as_default=True)
+loop = gobject.MainLoop()
+
+
+def got_state(state):
+    """Called when the network state is found."""
+    try:
+        print nm_state_names[state]
+    finally:
+        loop.quit()
+
+nms = NetworkManagerState(got_state)
+nms.find_online_state()
+loop.run()

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2010-06-16 15:11:04 +0000
+++ bin/ubuntu-sso-login	2010-08-11 18:19:01 +0000
@@ -30,12 +30,13 @@
 
 from dbus.mainloop.glib import DBusGMainLoop
 
-from ubuntu_sso import DBUS_IFACE_AUTH_NAME
-from ubuntu_sso.main import Login
+from ubuntu_sso import DBUS_IFACE_AUTH_NAME, DBUS_BUS_NAME, DBUS_CRED_PATH
+from ubuntu_sso.main import Login, SSOLogin, SSOCredentials
 
 from ubuntu_sso.logger import setupLogging
 logger = setupLogging("ubuntu-sso-login")
 
+gtk.gdk.threads_init()
 DBusGMainLoop(set_as_default=True)
 
 _ = gettext.gettext
@@ -55,6 +56,19 @@
 }
 widget_class '*Dialog*' style 'dialogs'
 """
+U1_PAIR_RECORD = "ubuntu_one_pair_record"
+MAP_JS = """function(doc) {
+  if (doc.service_name == "ubuntuone") {
+    if (doc.application_annotations &&
+        doc.application_annotations["Ubuntu One"] &&
+        doc.application_annotations["Ubuntu One"]["%s"] &&
+        doc.application_annotations["Ubuntu One"]["%s"]["deleted"]) {
+        emit(doc._id, 1);
+    } else {
+        emit(doc._id, 0)
+    }
+  }
+}""" % ("private_application_annotations", "private_application_annotations")
 
 
 class LoginMain(object):
@@ -83,7 +97,6 @@
               signal_name="OAuthError",
               dbus_interface=DBUS_IFACE_AUTH_NAME)
 
-
     def new_credentials(self, realm=None, consumer_key=None, sender=None):
         """Signal callback for when we get new credentials."""
         self.set_up_desktopcouch_pairing(consumer_key)
@@ -173,23 +186,9 @@
             return
         # Check whether there is already a record of the Ubuntu One service
         db = CouchDatabase("management", create=True)
-        if not db.view_exists("ubuntu_one_pair_record","ubuntu_one_pair_record"):
-            map_js = """function(doc) {
-                if (doc.service_name == "ubuntuone") {
-                    if (doc.application_annotations &&
-                        doc.application_annotations["Ubuntu One"] &&
-                        doc.application_annotations["Ubuntu One"]["private_application_annotations"] &&
-                        doc.application_annotations["Ubuntu One"]["private_application_annotations"]["deleted"]) {
-                        emit(doc._id, 1);
-                    } else {
-                        emit(doc._id, 0)
-                    }
-                }
-            }"""
-            db.add_view("ubuntu_one_pair_record", map_js, None,
-                "ubuntu_one_pair_record")
-        results = db.execute_view("ubuntu_one_pair_record",
-            "ubuntu_one_pair_record")
+        if not db.view_exists(U1_PAIR_RECORD, U1_PAIR_RECORD):
+            db.add_view(U1_PAIR_RECORD, MAP_JS, None, U1_PAIR_RECORD)
+        results = db.execute_view(U1_PAIR_RECORD, U1_PAIR_RECORD)
         found = False
         # Results should contain either one row or no rows
         # If there is one row, its value will be 0, meaning that there is
@@ -224,7 +223,7 @@
 
     # Register DBus service for making sure we run only one instance
     bus = dbus.SessionBus()
-    name = bus.request_name(DBUS_IFACE_AUTH_NAME,
+    name = bus.request_name(DBUS_BUS_NAME,
                             dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
     if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
         print _("Ubuntu One login manager already running, quitting")
@@ -233,7 +232,13 @@
     from twisted.internet import gtk2reactor
     gtk2reactor.install()
 
-    login = Login(dbus.service.BusName(DBUS_IFACE_AUTH_NAME,
-                                       bus=dbus.SessionBus()))
+    login = Login(dbus.service.BusName(DBUS_BUS_NAME,
+                                             bus=dbus.SessionBus()))
+    ssoLogin = 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)
+
     manager = LoginMain()
     manager.main()

=== added file 'bin/ubuntu-sso-login-gui'
--- bin/ubuntu-sso-login-gui	1970-01-01 00:00:00 +0000
+++ bin/ubuntu-sso-login-gui	2010-08-11 18:19:01 +0000
@@ -0,0 +1,46 @@
+#!/usr/bin/python
+
+# ubuntu-sso-login-gui - GUI for registration and login for Ubuntu SSO
+#
+# 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/>.
+"""Script to run the Ubuntu SSO client GUI."""
+
+import gtk
+
+from ubuntu_sso.gui import UbuntuSSOClientGUI
+
+
+APP_NAME = 'Super Testing App'
+TC_URI = 'http://ubuntu.com'
+HELP_TEXT = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
+            '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__':
+    win = gtk.Window()
+    win.set_title(APP_NAME)
+    win.set_position(gtk.WIN_POS_CENTER)
+    win.set_size_request(800, 600)
+    win.show()
+    xid = win.window.xid
+
+    app = UbuntuSSOClientGUI(close_callback=main_quit, app_name=APP_NAME,
+                             tc_uri=TC_URI, help_text=HELP_TEXT, window_id=xid)
+    gtk.main()

=== added directory 'contrib'
=== added file 'contrib/__init__.py'
--- contrib/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/__init__.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,18 @@
+# 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."""

=== added file 'contrib/dbus_util.py'
--- contrib/dbus_util.py	1970-01-01 00:00:00 +0000
+++ contrib/dbus_util.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,75 @@
+#
+# 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 signal
+import subprocess
+
+from distutils.spawn import find_executable
+
+SRCDIR = os.environ.get('SRCDIR', os.getcwd())
+
+
+class DBusLaunchError(Exception):
+    """Error while launching dbus-daemon"""
+    pass
+
+
+class NotFoundError(Exception):
+    """Not found error"""
+    pass
+
+
+class DBusRunner(object):
+
+    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

=== added file 'contrib/test'
--- contrib/test	1970-01-01 00:00:00 +0000
+++ contrib/test	2010-08-11 18:19:01 +0000
@@ -0,0 +1,146 @@
+#!/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 unit tests 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-msg=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) 

=== added directory 'contrib/testing'
=== added file 'contrib/testing/__init__.py'
--- contrib/testing/__init__.py	1970-01-01 00:00:00 +0000
+++ contrib/testing/__init__.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,1 @@
+"""Testing utilities for Ubuntu One client code."""

=== added file 'contrib/testing/dbus-session.conf'
--- contrib/testing/dbus-session.conf	1970-01-01 00:00:00 +0000
+++ contrib/testing/dbus-session.conf	2010-08-11 18:19:01 +0000
@@ -0,0 +1,63 @@
+<!-- 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>

=== added file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	1970-01-01 00:00:00 +0000
+++ contrib/testing/testcase.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,234 @@
+#
+# 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/>.
+""" Base tests cases and test utilities """
+from __future__ import with_statement
+
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+import contextlib
+import logging
+import os
+import shutil
+import itertools
+
+from ubuntu_sso import DBUS_IFACE_AUTH_NAME
+from ubuntu_sso.main import Login, LoginProcessor
+
+from twisted.internet import defer
+from twisted.python import failure
+from unittest import TestCase
+from zope.interface import implements
+from oauth import oauth
+
+
[e-mail]
+def environ(env_var, new_value):
+    """context manager to replace/add an environ value"""
+    old_value = os.environ.get(env_var, None)
+    os.environ[env_var] = new_value
+    yield
+    if old_value is None:
+        os.environ.pop(env_var)
+    else:
+        os.environ[env_var] = old_value
+
+
+class BaseTestCase(TestCase):
+    """Base TestCase with helper methods to handle temp dir.
+
+    This class provides:
+        mktemp(name): helper to create temporary dirs
+        rmtree(path): support read-only shares
+        makedirs(path): support read-only shares
+    """
+
+    def mktemp(self, name='temp'):
+        """Customized mktemp that accepts an optional name argument. """
+        tempdir = os.path.join(self.tmpdir, name)
+        if os.path.exists(tempdir):
+            self.rmtree(tempdir)
+        self.makedirs(tempdir)
+        return tempdir
+
+    @property
+    def tmpdir(self):
+        """Default tmpdir: module/class/test_method."""
+        # check if we already generated the root path
+        root_dir = getattr(self, '__root', None)
+        if root_dir:
+            return root_dir
+        MAX_FILENAME = 32  # some platforms limit lengths of filenames
+        base = os.path.join(self.__class__.__module__[:MAX_FILENAME],
+                            self.__class__.__name__[:MAX_FILENAME],
+                            self._testMethodName[:MAX_FILENAME])
+        # use _trial_temp dir, it should be os.gwtcwd()
+        # define the root temp dir of the testcase, pylint: disable-msg=W0201
+        self.__root = os.path.join(os.getcwd(), base)
+        return self.__root
+
+    def rmtree(self, path):
+        """Custom rmtree that handle ro parent(s) and childs."""
+        if not os.path.exists(path):
+            return
+        # change perms to rw, so we can delete the temp dir
+        if path != getattr(self, '__root', None):
+            os.chmod(os.path.dirname(path), 0755)
+        if not os.access(path, os.W_OK):
+            os.chmod(path, 0755)
+        # pylint: disable-msg=W0612
+        for dirpath, dirs, files in os.walk(path):
+            for dir in dirs:
+                if not os.access(os.path.join(dirpath, dir), os.W_OK):
+                    os.chmod(os.path.join(dirpath, dir), 0777)
+        shutil.rmtree(path)
+
+    def makedirs(self, path):
+        """Custom makedirs that handle ro parent."""
+        parent = os.path.dirname(path)
+        if os.path.exists(parent):
+            os.chmod(parent, 0755)
+        os.makedirs(path)
+
+
+class DBusTestCase(BaseTestCase):
+    """ Test the DBus event handling """
+
+    def setUp(self):
+        """ Setup the infrastructure fo the test (dbus service). """
+        BaseTestCase.setUp(self)
+        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._tearDown)
+        d.addBoth(lambda _: BaseTestCase.tearDown(self))
+        return d
+
+    def _tearDown(self, *args):
+        """ shutdown """
+        self.dbus_iface.bus.flush()
+        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 FakeLoginProcessor(LoginProcessor):
+    """Stub login processor."""
+
+    def __init__(self, dbus_object):
+        """Initialize the login processor."""
+        LoginProcessor.__init__(self, dbus_object)
+        self.next_login_cb = None
+
+    def login(self, realm, consumer_key, error_handler=None,
+              reply_handler=None, do_login=True):
+        """Stub, call self.next_login_cb or send NewCredentials if
+        self.next_login_cb isn't defined.
+        """
+        self.realm = str(realm)
+        self.consumer_key = str(consumer_key)
+        if self.next_login_cb:
+            cb = self.next_login_cb[0]
+            args = self.next_login_cb[1]
+            self.next_login_cb = None
+            return cb(*args)
+        else:
+            self.dbus_object.NewCredentials(realm, consumer_key)
+
+    def clear_token(self, realm, consumer_key):
+        """Stub, do nothing"""
+        pass
+
+    def next_login_with(self, callback, args=tuple()):
+        """shortcircuit the next call to login and call the specified callback.
+        callback is usually one of: self.got_token, self.got_no_token,
+        self.got_denial or self.got_error.
+        """
+        self.next_login_cb = (callback, args)
+
+
+class FakeLogin(Login):
+    """Stub Object which listens for D-Bus OAuth requests"""
+
+    def __init__(self, bus):
+        """Initiate the object."""
+        self.bus = bus
+        self.busName = dbus.service.BusName(DBUS_IFACE_AUTH_NAME, bus=self.bus)
+        # bypass the parent class __init__ as it has the path hardcoded
+        # and we can't use '/' as the path, as we are already using it
+        # for syncdaemon. pylint: disable-msg=W0233,W0231
+        dbus.service.Object.__init__(self, object_path="/oauthdesktop",
+                                     bus_name=self.busName)
+        self.processor = FakeLoginProcessor(self)
+        self.currently_authing = False
+
+    def shutdown(self):
+        """Shutdown and remove any trace from the bus"""
+        self.busName.get_bus().release_name(self.busName.get_name())
+        self.remove_from_connection()
+
+
+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, msg):
+        """Check that something is logged."""
+        for rec in self.records:
+            if rec.levelno == level and str(msg) in rec.message:
+                return True
+        return False

=== added file 'data/email.png'
Binary files data/email.png	1970-01-01 00:00:00 +0000 and data/email.png	2010-08-11 18:19:01 +0000 differ
=== added file 'data/ui.glade'
--- data/ui.glade	1970-01-01 00:00:00 +0000
+++ data/ui.glade	2010-08-11 18:19:01 +0000
@@ -0,0 +1,689 @@
+<?xml version="1.0"?>
+<interface>
+  <requires lib="gtk+" version="2.16"/>
+  <!-- interface-naming-policy project-wide -->
+  <object class="GtkWindow" id="window">
+    <property name="border_width">20</property>
+    <property name="window_position">center</property>
+    <signal name="delete_event" handler="on_close_clicked"/>
+    <child>
+      <object class="GtkVBox" id="window_vbox">
+        <property name="visible">True</property>
+        <property name="spacing">10</property>
+        <child>
+          <object class="GtkLabel" id="header_label">
+            <property name="visible">True</property>
+            <property name="xalign">0</property>
+            <property name="label" translatable="yes">Header Label	</property>
+            <property name="wrap">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="padding">10</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="help_label">
+            <property name="visible">True</property>
+            <property name="xalign">0</property>
+            <property name="label" translatable="yes">help label</property>
+            <property name="wrap">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="warning_label">
+            <property name="visible">True</property>
+            <property name="xalign">0</property>
+            <property name="label" translatable="yes">warning label</property>
+            <property name="wrap">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+        <child>
+          <placeholder/>
+        </child>
+      </object>
+    </child>
+  </object>
+  <object class="GtkVBox" id="enter_details_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <placeholder/>
+    </child>
+    <child>
+      <object class="GtkLabel" id="name_warning_label">
+        <property name="visible">True</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHBox" id="emails_hbox">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="homogeneous">True</property>
+        <child>
+          <placeholder/>
+        </child>
+        <child>
+          <placeholder/>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">2</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkLabel" id="email_warning_label">
+        <property name="visible">True</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">3</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHBox" id="passwords_hbox">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="homogeneous">True</property>
+        <child>
+          <placeholder/>
+        </child>
+        <child>
+          <placeholder/>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">4</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkLabel" id="password_help_label">
+        <property name="visible">True</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">5</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkLabel" id="password_warning_label">
+        <property name="visible">True</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="position">6</property>
+      </packing>
+    </child>
+    <child>
+      <placeholder/>
+    </child>
+    <child>
+      <object class="GtkEventBox" id="captcha_loading">
+        <property name="width_request">300</property>
+        <property name="height_request">60</property>
+        <property name="visible">True</property>
+        <child>
+          <placeholder/>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">False</property>
+        <property name="position">8</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkImage" id="captcha_image">
+        <property name="visible">True</property>
+        <property name="stock">gtk-missing-image</property>
+      </object>
+      <packing>
+        <property name="position">9</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkVBox" id="captcha_solution_vbox">
+        <property name="visible">True</property>
+        <property name="spacing">10</property>
+        <child>
+          <placeholder/>
+        </child>
+        <child>
+          <object class="GtkLabel" id="captcha_solution_warning_label">
+            <property name="visible">True</property>
+            <property name="wrap">True</property>
+          </object>
+          <packing>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="position">10</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkCheckButton" id="yes_to_updates_checkbutton">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="receives_default">False</property>
+        <property name="active">True</property>
+        <property name="draw_indicator">True</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">11</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHBox" id="hbox1">
+        <property name="visible">True</property>
+        <child>
+          <object class="GtkCheckButton" id="yes_to_tc_checkbutton">
+            <property name="label" translatable="yes">Yes! I agree with</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">False</property>
+            <property name="active">True</property>
+            <property name="draw_indicator">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLinkButton" id="tc_button">
+            <property name="label" translatable="yes">button</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="has_tooltip">True</property>
+            <property name="relief">none</property>
+            <signal name="clicked" handler="on_tc_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">12</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">13</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox1">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="join_cancel_button">
+            <property name="label">gtk-cancel</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="join_ok_button">
+            <property name="label">gtk-go-forward</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_join_ok_button_clicked"/>
+          </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">14</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkLinkButton" id="login_button">
+        <property name="label" translatable="yes">button</property>
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="receives_default">True</property>
+        <property name="has_tooltip">True</property>
+        <property name="relief">none</property>
+        <signal name="clicked" handler="on_sign_in_button_clicked"/>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">15</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkVBox" id="processing_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <placeholder/>
+    </child>
+  </object>
+  <object class="GtkVBox" id="verify_email_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <object class="GtkImage" id="verify_email_image">
+        <property name="visible">True</property>
+        <property name="stock">gtk-missing-image</property>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <placeholder/>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox2">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="verify_token_button">
+            <property name="label">gtk-ok</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_verify_token_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">2</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkVBox" id="tc_browser_vbox">
+    <property name="visible">True</property>
+    <child>
+      <object class="GtkScrolledWindow" id="tc_browser_window">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="border_width">10</property>
+        <property name="hscrollbar_policy">never</property>
+        <property name="vscrollbar_policy">automatic</property>
+        <child>
+          <placeholder/>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox4">
+        <property name="visible">True</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="tc_back_button">
+            <property name="label">gtk-go-back</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_tc_back_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkVBox" id="login_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <object class="GtkAlignment" id="alignment3">
+        <property name="visible">True</property>
+        <property name="xscale">0</property>
+        <property name="yscale">0</property>
+        <child>
+          <object class="GtkVBox" id="login_details_vbox">
+            <property name="visible">True</property>
+            <property name="spacing">5</property>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <object class="GtkLabel" id="login_email_warning_label">
+                <property name="visible">True</property>
+                <property name="label" translatable="yes">label</property>
+              </object>
+              <packing>
+                <property name="position">2</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="login_password_warning_label">
+                <property name="visible">True</property>
+                <property name="label" translatable="yes">label</property>
+              </object>
+              <packing>
+                <property name="position">4</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLinkButton" id="forgotten_password_button">
+                <property name="label" translatable="yes">button</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="has_tooltip">True</property>
+                <property name="relief">none</property>
+                <signal name="clicked" handler="on_forgotten_password_button_clicked"/>
+              </object>
+              <packing>
+                <property name="position">5</property>
+              </packing>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox5">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="login_cancel_button">
+            <property name="label">gtk-cancel</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="login_back_button">
+            <property name="label">gtk-go-back</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_login_back_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="login_ok_button">
+            <property name="label">gtk-connect</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_login_connect_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkVBox" id="reset_password_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <object class="GtkAlignment" id="alignment1">
+        <property name="visible">True</property>
+        <property name="xscale">0</property>
+        <property name="yscale">0</property>
+        <child>
+          <object class="GtkVBox" id="reset_password_details_vbox">
+            <property name="visible">True</property>
+            <property name="spacing">5</property>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox6">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="reset_password_cancel_button">
+            <property name="label">gtk-cancel</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="reset_password_ok_button">
+            <property name="label">gtk-ok</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkVBox" id="reset_email_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <object class="GtkAlignment" id="alignment2">
+        <property name="visible">True</property>
+        <property name="xscale">0</property>
+        <property name="yscale">0</property>
+        <child>
+          <object class="GtkVBox" id="reset_email_details_vbox">
+            <property name="visible">True</property>
+            <property name="spacing">5</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox7">
+        <property name="visible">True</property>
+        <property name="spacing">5</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="reset_email_cancel_button">
+            <property name="label">gtk-cancel</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="reset_email_back_button">
+            <property name="label">gtk-go-back</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_reset_email_back_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="reset_email_ok_button">
+            <property name="label">gtk-ok</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_reset_email_ok_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkVBox" id="success_vbox">
+    <property name="visible">True</property>
+    <property name="spacing">10</property>
+    <child>
+      <object class="GtkLabel" id="success_label">
+        <property name="visible">True</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="padding">10</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="hbuttonbox8">
+        <property name="visible">True</property>
+        <property name="layout_style">end</property>
+        <child>
+          <object class="GtkButton" id="success_close_button">
+            <property name="label">gtk-close</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_close_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+</interface>

=== modified file 'debian/changelog'
--- debian/changelog	2010-06-16 15:11:04 +0000
+++ debian/changelog	2010-08-11 18:19:01 +0000
@@ -1,3 +1,10 @@
+ubuntu-sso-client (0.98-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release.
+  * Switch to dpkg-source 3.0 (quilt) format
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Wed, 11 Aug 2010 15:09:32 -0300
+
 ubuntu-sso-client (0.0.3-0ubuntu1) maverick; urgency=low
 
   * New upstream release.

=== modified file 'debian/control'
--- debian/control	2010-06-16 15:11:04 +0000
+++ debian/control	2010-08-11 18:19:01 +0000
@@ -14,7 +14,16 @@
 Architecture: all
 XB-Python-Version: ${python:Versions}
 Depends: ${misc:Depends},
- ${python:Depends}
+ ${python:Depends},
+ python-dbus,
+ python-gnomekeyring,
+ python-gtk2,
+ python-lazr.restfulclient,
+ python-oauth,
+ python-twisted-core,
+ python-twisted-web,
+ python-webkit,
+ python-xdg
 Description: Ubuntu Single Sign-On client
  Desktop service to allow applications to sign into Ubuntu services via
  SSO

=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2010-08-11 18:19:01 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)

=== modified file 'run-tests'
--- run-tests	2010-06-16 15:11:04 +0000
+++ run-tests	2010-08-11 18:19:01 +0000
@@ -15,4 +15,12 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-trial ubuntu_sso
+`which xvfb-run` ./contrib/test $@
+pyflakes bin ubuntu_sso
+if [ -x `which pep8` ]; then
+    pep8 --repeat bin ubuntu_sso/gui.py ubuntu_sso/main.py \
+    ubuntu_sso/tests/test_gui.py ubuntu_sso/tests/test_main.py contrib/
+else
+    echo "Please install the 'pep8' package."
+fi
+rm -rf _trial_temp/
\ No newline at end of file

=== modified file 'setup.py'
--- setup.py	2010-06-16 15:11:04 +0000
+++ setup.py	2010-08-11 18:19:01 +0000
@@ -71,7 +71,7 @@
 
 setup(
     name='ubuntu-sso-client',
-    version='0.0.3',
+    version='0.98',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',
@@ -80,15 +80,14 @@
         'to Ubuntu services via SSO',
     url='https://launchpad.net/ubuntu-sso-client',
     packages=['ubuntu_sso'],
-    data_files=[('share/dbus-1/services',
-                 ['data/com.ubuntu.sso.service',]),
-                ('/etc/xdg/ubuntu-sso/',
-                 ['data/oauth_urls',]),
-                ('/etc/xdg/ubuntu-sso/oauth_registration.d',
-                 ['data/oauth_registration.d/ubuntuone',]),
-                ('lib/ubuntu-sso-client',
-                 ['bin/ubuntu-sso-login',]),
-                ],
+    data_files=[
+        ('share/dbus-1/services', ['data/com.ubuntu.sso.service',]),
+        ('lib/ubuntu-sso-client', ['bin/ubuntu-sso-login',]),
+        ('share/ubuntu-sso-client/data', ['data/ui.glade', 'data/email.png',]),
+        ('/etc/xdg/ubuntu-sso/', ['data/oauth_urls',]),
+        ('/etc/xdg/ubuntu-sso/oauth_registration.d',
+         ['data/oauth_registration.d/ubuntuone',]),
+    ],
 
     cmdclass = {
         'build' : SSOBuild,

=== modified file 'ubuntu_sso/__init__.py'
--- ubuntu_sso/__init__.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/__init__.py	2010-08-11 18:19:01 +0000
@@ -16,5 +16,10 @@
 """OAuth client authorisation code."""
 
 # constants
+DBUS_PATH_AUTH = "/"
+DBUS_BUS_NAME = "com.ubuntu.sso"
+DBUS_PATH = "/sso"
+DBUS_CRED_PATH = "/credentials"
 DBUS_IFACE_AUTH_NAME = "com.ubuntu.sso"
-DBUS_PATH_AUTH = "/"
+DBUS_IFACE_USER_NAME = "com.ubuntu.sso.UserManagement"
+DBUS_IFACE_CRED_NAME = "com.ubuntu.sso.ApplicationCredentials"

=== modified file 'ubuntu_sso/auth.py'
--- ubuntu_sso/auth.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/auth.py	2010-08-11 18:19:01 +0000
@@ -23,11 +23,12 @@
 
 __metaclass__ = type
 
-import subprocess
-import random
 import dbus
 import os
+import random
+import subprocess
 import socket, httplib, urllib
+import sys
 
 import gnomekeyring
 from oauth import oauth
@@ -231,13 +232,12 @@
 
     def make_token_request(self, oauth_request):
         """Perform the given `OAuthRequest` and return the associated token."""
-        
-        logger.debug("Making a token request")
+        logger.debug("Making a token request.")
         # Note that we monkeypatched httplib above to handle invalid certs
         # Ways this urlopen can fail:
         # bad certificate
         #    raises IOError, e.args[1] == SSLError, e.args[1].errno == 1
-        # No such server 
+        # No such server
         #    raises IOError, e.args[1] == SSLError, e.args[1].errno == -2
         try:
             opener = FancyURLOpenerWithRedirectedPOST()
@@ -245,19 +245,19 @@
             data = fp.read()
         except IOError, e:
             self._forward_error_callback(e)
+            logger.exception("make_token_request failed when getting a token.")
             return
-        
+
         # we deliberately trap anything that might go wrong when parsing the
         # token, because we do not want this to explicitly fail
         # pylint: disable-msg=W0702
         try:
             out_token = oauth.OAuthToken.from_string(data)
-            logger.debug("Token successfully requested")
+            logger.info("Token successfully requested")
             return out_token
         except:
             error = Exception(data)
-            logger.error("Token was not successfully retrieved: data was '%s'",
-               str(error))
+            logger.exception("Token was not retrieved: data was '%s'", data)
             self._forward_error_callback(error)
 
     def open_in_browser(self, url):
@@ -358,6 +358,13 @@
         logger.debug("Making token request")
         self.request_token = self.make_token_request(oauth_request)
 
+        if self.request_token is None:
+            msg = "acquire_access_token: request_token is None after " \
+                  "make_token_request. Stopping reactor and exiting."
+            logger.error(msg)
+            reactor.stop()
+            sys.exit(1)
+
         # Request authorisation from the user
         oauth_request = oauth.OAuthRequest.from_token_and_callback(
             http_url=self.user_authorisation_url,
@@ -416,9 +423,7 @@
             self.callback_parent(access_token)
         except NoAccessToken:
             if self.do_login:
-                access_token = self.acquire_access_token_if_online(
-                    description,
-                    store=True)
+                self.acquire_access_token_if_online(description, store=True)
             else:
                 if self.callback_notoken is not None:
                     self.callback_notoken()

=== added file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/gui.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,797 @@
+# ubuntu_sso.gui - GUI for login and registration
+#
+# 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/>.
+
+"""User registration GUI."""
+
+import logging
+import os
+import re
+import tempfile
+
+from functools import wraps
+
+import dbus
+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.logger import setupLogging
+
+
+_ = gettext.gettext
+DBusGMainLoop(set_as_default=True)
+logger = setupLogging('ubuntu_sso.gui')
+
+
+NO_OP = lambda *args, **kwargs: None
+DEFAULT_WIDTH = 30
+# XXX: to be replaced by values from the theme
+HELP_TEXT_COLOR = gtk.gdk.Color("#bfbfbf")
+WARNING_TEXT_COLOR = gtk.gdk.Color("red")
+
+SIG_LOGIN_FAILED = 'login-failed'
+SIG_LOGIN_SUCCEEDED = 'login-succeeded'
+SIG_REGISTRATION_FAILED = 'registration-failed'
+SIG_REGISTRATION_SUCCEEDED = 'registration-succeeded'
+SIG_USER_CANCELATION = 'user-cancelation'
+
+SIGNAL_ARGUMENTS = [
+    (SIG_LOGIN_FAILED, ()),
+    (SIG_LOGIN_SUCCEEDED, (gobject.TYPE_STRING,)),
+    (SIG_REGISTRATION_FAILED, ()),
+    (SIG_REGISTRATION_SUCCEEDED, (gobject.TYPE_STRING,)),
+    (SIG_USER_CANCELATION, ()),
+]
+
+for sig, args in SIGNAL_ARGUMENTS:
+    gobject.signal_new(sig, gtk.Window, gobject.SIGNAL_RUN_FIRST,
+                       gobject.TYPE_NONE, args)
+
+
+def get_data_dir():
+    """Build absolute path to  the 'data' directory."""
+    module = os.path.dirname(__file__)
+    result = os.path.abspath(os.path.join(module, os.pardir, 'data'))
+    logger.debug('get_data_file: trying to load from %r (exists? %s)',
+                 result, os.path.exists(result))
+    if os.path.exists(result):
+        logger.info('get_data_file: returning data dir located at %r.', result)
+        return result
+
+    # no local data dir, looking within system data dirs
+    data_dirs = xdg.BaseDirectory.xdg_data_dirs
+    for path in data_dirs:
+        result = os.path.join(path, 'ubuntu-sso-client', 'data')
+        result = os.path.abspath(result)
+        logger.debug('get_data_file: trying to load from %r (exists? %s)',
+                     result, os.path.exists(result))
+        if os.path.exists(result):
+            logger.info('get_data_file: data dir located at %r.', result)
+            return result
+    else:
+        msg = 'get_data_file: can not build a valid data path. Giving up.' \
+              '__file__ is %r, data_dirs are %r'
+        logger.error(msg, __file__, data_dirs)
+
+
+def get_data_file(filename):
+    """Build absolute path to 'filename' within the 'data' directory."""
+    return os.path.join(get_data_dir(), filename)
+
+
+class LabeledEntry(gtk.Entry):
+    """An entry that displays the label within itself ina grey color."""
+
+    def __init__(self, label, is_password=False, *args, **kwargs):
+        self.label = label
+        self.is_password = is_password
+        self._user_input = None
+
+        super(LabeledEntry, self).__init__(*args, **kwargs)
+
+        self.set_width_chars(DEFAULT_WIDTH)
+        self._set_label(self, None)
+        self.set_tooltip_text(self.label)
+        self.connect('focus-in-event', self._clear_text)
+        self.connect('focus-out-event', self._set_label)
+        self.show()
+
+    def _clear_text(self, *args, **kwargs):
+        """Clear text and restore text color."""
+        self.set_text(self.get_text())
+
+        self.modify_text(gtk.STATE_NORMAL, None)  # restore to theme's default
+
+        if self.is_password:
+            self.set_visibility(False)
+
+        return False  # propagate the event further
+
+    def _set_label(self, *args, **kwargs):
+        """Set the proper label and proper coloring."""
+        if self.get_text():
+            return
+
+        self.set_text(self.label)
+        self.modify_text(gtk.STATE_NORMAL, HELP_TEXT_COLOR)
+
+        if self.is_password:
+            self.set_visibility(True)
+
+        return False  # propagate the event further
+
+    def get_text(self):
+        """Get text only if it's not the label nor empty."""
+        result = super(LabeledEntry, self).get_text()
+        if result == self.label or result.isspace():
+            result = ''
+        return result
+
+
+class UbuntuSSOClientGUI(object):
+    """Ubuntu single sign on GUI."""
+
+    CAPTCHA_SOLUTION_ENTRY = _('Type the characters above')
+    CONNECT_HELP_LABEL = _('To connect this computer to') + ' %s ' + \
+                         _('enter your details below.')
+    EMAIL1_ENTRY = _('Email address')
+    EMAIL2_ENTRY = _('Re-type Email address')
+    EMAIL_MISMATCH = _('The email addresses don\'t match, please double check '
+                       'and try entering them again.')
+    EMAIL_INVALID = _('The email must be a valid email address.')
+    EMAIL_TOKEN_ENTRY = _('Enter code verification here')
+    FIELD_REQUIRED = _('This field is required.')
+    FORGOTTEN_PASSWORD_BUTTON = _('I\'ve forgotten my password')
+    JOIN_HEADER_LABEL = _('Create') + ' %s ' + _('account')
+    LOADING = _('Loading...')
+    LOGIN_BUTTON_LABEL = _('Already have an account? Click here to sign in')
+    LOGIN_EMAIL_ENTRY = _('Email address')
+    LOGIN_HEADER_LABEL = _('Connect to') + ' %s'
+    LOGIN_PASSWORD_ENTRY = _('Password')
+    NAME_ENTRY = _('Name')
+    NEXT = _('Next')
+    ONE_MOMENT_PLEASE = _('One moment please...')
+    PASSWORD1_ENTRY = RESET_PASSWORD1_ENTRY = _('Password')
+    PASSWORD2_ENTRY = RESET_PASSWORD2_ENTRY = _('Re-type Password')
+    PASSWORD_HELP = _('The password must have a minimum of 8 characters and '
+                      'include one uppercase character and one number.')
+    PASSWORD_MISMATCH = _('The passwords don\'t match, please double check '
+                          'and try entering them again.')
+    PASSWORD_TOO_WEAK = _('The password is too weak.')
+    RESET_CODE_ENTRY = _('Reset code')
+    RESET_EMAIL_ENTRY = _('Email address')
+    RESET_EMAIL_LABEL = _('To reset your password enter your email address '\
+                          'below:')
+    RESET_PASSWORD = _('Reset Password')
+    RESET_PASSWORD_LABEL = _('A password reset code has been sent to %s. ' \
+                             'Please enter the code below along with your ' \
+                             'new password.')
+    SUCCESS = _('The process finished successfully. Congratulations!')
+    TC = _('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 ' \
+                      'process. Please check the information and try again.')
+    VERIFY_EMAIL_LABEL = _("""Enter verification code.
+
+A verification code has just been sent to your email address.
+Please enter this code below.""")
+    YES_TO_TC = _('I agree with the')
+    YES_TO_UPDATES = _('Yes! Email me tips and updates.')
+
+    def __init__(self, app_name, tc_uri, help_text,
+                 window_id=0, close_callback=None):
+        """Create the GUI and initialize widgets."""
+        gtk.link_button_set_uri_hook(NO_OP)
+
+        self._captcha_filename = tempfile.mktemp()
+        self._captcha_id = None
+        self._signals_receivers = {}
+
+        self.app_name = app_name
+        self.app_label = '<b>%s</b>' % app_name
+        self.tc_uri = tc_uri
+        self.help_text = help_text
+        self.close_callback = close_callback
+
+        ui_filename = get_data_file('ui.glade')
+        builder = gtk.Builder()
+        builder.add_from_file(ui_filename)
+        builder.connect_signals(self)
+
+        # XXX: every button should have tests for 'activate' signal
+
+        self.widgets = []
+        self.warnings = []
+        self.cancels = []
+        for obj in builder.get_objects():
+            name = getattr(obj, 'name', None)
+            if name is None and isinstance(obj, gtk.Buildable):
+                # work around bug lp:507739
+                name = gtk.Buildable.get_name(obj)
+            if name is None:
+                logging.warn("%s has no name (??)", obj)
+            else:
+                self.widgets.append(name)
+                setattr(self, name, obj)
+                if 'warning' in name:
+                    self.warnings.append(obj)
+                    obj.hide()
+                if 'cancel_button' in name:
+                    obj.connect('clicked', self.on_close_clicked)
+                    self.cancels.append(obj)
+
+        self.entries = ('name_entry', 'email1_entry', 'email2_entry',
+                        'password1_entry', 'password2_entry',
+                        'captcha_solution_entry', 'email_token_entry',
+                        'login_email_entry', 'login_password_entry',
+                        'reset_email_entry', 'reset_code_entry',
+                        'reset_password1_entry', 'reset_password2_entry')
+
+        for name in self.entries:
+            label = getattr(self, name.upper())
+            is_password = 'password' in name
+            entry = LabeledEntry(label=label, is_password=is_password)
+            setattr(self, name, entry)
+            assert getattr(self, name) is not None
+
+        self.window.set_icon_name('ubuntu-logo')
+
+        self.bus = dbus.SessionBus()
+        self.bus.add_signal_receiver = self._log(self.bus.add_signal_receiver)
+        obj = self.bus.get_object(bus_name=DBUS_BUS_NAME,
+                                  object_path=DBUS_PATH,
+                                  follow_name_owner_changes=True)
+        self.iface_name = DBUS_IFACE_USER_NAME
+        self.backend = dbus.Interface(object=obj,
+                                      dbus_interface=self.iface_name)
+        logger.debug('UbuntuSSOClientGUI: backend created: %r', self.backend)
+
+        self.pages = (self.enter_details_vbox, self.processing_vbox,
+                      self.verify_email_vbox, self.success_vbox,
+                      self.tc_browser_vbox, self.login_vbox,
+                      self.reset_email_vbox, self.reset_password_vbox)
+
+        self._append_page(self._build_enter_details_page())
+        self._append_page(self._build_tc_page())
+        self._append_page(self._build_processing_page())
+        self._append_page(self._build_verify_email_page())
+        self._append_page(self._build_success_page())
+        self._append_page(self._build_login_page())
+        self._append_page(self._build_reset_email_page())
+        self._append_page(self._build_reset_password_page())
+
+        self.login_button.grab_focus()
+        self._set_current_page(self.enter_details_vbox)
+        self._setup_signals()
+
+        if window_id != 0:
+            # be as robust as possible:
+            # if the window_id is not "good", set_transient_for will fail
+            # awfully, and we don't want that: if the window_id is bad we can
+            # still do everything as a standalone window. Also,
+            # window_foreign_new may return None breaking set_transient_for.
+            try:
+                r = gtk.gdk.window_foreign_new(window_id)
+                self.window.realize()
+                self.window.window.set_transient_for(r)
+            except:
+                msg = 'UbuntuSSOClientGUI: failed set_transient_for win id %r'
+                logger.exception(msg, window_id)
+        self.window.show()
+
+    def _setup_signals(self):
+        """Bind signals to callbacks to be able to test the pages."""
+        iface = self.iface_name
+        self._signals = [
+            (iface, 'CaptchaGenerated', self.on_captcha_generated),
+            (iface, 'CaptchaGenerationError',
+             self.on_captcha_generation_error),
+            (iface, 'UserRegistered', self.on_user_registered),
+            (iface, 'UserRegistrationError', self.on_user_registration_error),
+            (iface, 'EmailValidated', self.on_email_validated),
+            (iface, 'EmailValidationError', self.on_email_validation_error),
+            (iface, 'LoggedIn', self.on_logged_in),
+            (iface, 'LoginError', self.on_login_error),
+        ]
+        for iface, signal, method in self._signals:
+            self.bus.add_signal_receiver(method, signal_name=signal,
+                                         dbus_interface=iface)
+
+    def _debug(self, *args, **kwargs):
+        """Do some debugging."""
+        print args, kwargs
+
+    def _log(self, f):
+        """Keep track of added signals to the internal bus."""
+
+        @wraps(f)
+        def inner(method, signal_name, dbus_interface):
+            """Do the deed."""
+            actual = self._signals_receivers.get((dbus_interface, signal_name))
+            assert actual is None
+            f(method, signal_name, dbus_interface)
+            self._signals_receivers[(dbus_interface, signal_name)] = method
+
+        return inner
+
+    def _add_spinner_to_container(self, container, legend=None):
+        """Add a spinner to 'container'."""
+        spinner = gtk.Spinner()
+        spinner.start()
+
+        label = gtk.Label()
+        if legend:
+            label.set_text(legend)
+        else:
+            label.set_text(self.LOADING)
+
+        hbox = gtk.HBox(spacing=5)
+        hbox.pack_start(spinner, expand=False)
+        hbox.pack_start(label, expand=False)
+
+        alignment = gtk.Alignment(xalign=0.5, yalign=0.5)
+        alignment.add(hbox)
+        alignment.show_all()
+
+        container.add(alignment)
+
+    # helpers
+
+    def _set_warning_message(self, widget, message):
+        """Set 'message' as text for 'widget'."""
+        widget.set_text(message)
+        widget.modify_fg(gtk.STATE_NORMAL, WARNING_TEXT_COLOR)
+        widget.show()
+
+    def _clear_warnings(self):
+        """Clear all warning messages."""
+        for widget in self.warnings:
+            widget.set_text('')
+            widget.hide()
+
+    def _non_empty_input(self, widget):
+        """Return weather widget has non empty content."""
+        text = widget.get_text()
+        return bool(text and not text.isspace())
+
+    # build pages
+
+    def _append_page(self, page):
+        """Append 'page' to the 'window'."""
+        self.window.get_children()[0].pack_start(page)
+
+    def _set_header(self, header):
+        """Set 'header' as the window title and header."""
+        markup = '<span size="xx-large">%s</span>'
+        self.header_label.set_markup(markup % header)
+        self.window.set_title(self.header_label.get_text())  # avoid markup
+
+    def _set_current_page(self, current_page, warning_text=None):
+        """Hide all the pages but 'current_page'."""
+        if hasattr(current_page, 'header'):
+            self._set_header(current_page.header)
+
+        if hasattr(current_page, 'help_text'):
+            self.help_label.set_markup(current_page.help_text)
+
+        if warning_text is not None:
+            self._set_warning_message(self.warning_label, warning_text)
+        else:
+            self.warning_label.hide()
+
+        for page in self.pages:
+            if page is current_page:
+                page.show()
+            else:
+                page.hide()
+
+    def _set_captcha_loading(self):
+        """Present a spinner to the user while the captcha is downloaded."""
+        self.captcha_image.hide()
+        self._add_spinner_to_container(self.captcha_loading)
+        white = gtk.gdk.Color('white')
+        self.captcha_loading.modify_bg(gtk.STATE_NORMAL, white)
+        self.captcha_loading.show_all()
+        self.join_ok_button.set_sensitive(False)
+
+    def _set_captcha_image(self):
+        """Present a captcha image to the user to be resolved."""
+        self.captcha_loading.hide()
+        self.join_ok_button.set_sensitive(True)
+        self.captcha_image.set_from_file(self._captcha_filename)
+        self.captcha_image.show()
+
+    def _build_enter_details_page(self):
+        """Build the enter details page."""
+        self.enter_details_vbox.header = (self.JOIN_HEADER_LABEL %
+                                                            self.app_label)
+        self.enter_details_vbox.help_text = self.help_text
+
+        self.enter_details_vbox.pack_start(self.name_entry, expand=False)
+        self.enter_details_vbox.reorder_child(self.name_entry, 0)
+        self.captcha_solution_vbox.pack_start(self.captcha_solution_entry,
+                                              expand=False)
+        self.captcha_solution_vbox.reorder_child(self.captcha_solution_entry,
+                                                 0)
+
+        self.emails_hbox.pack_start(self.email1_entry)
+        self.emails_hbox.pack_start(self.email2_entry)
+
+        self.passwords_hbox.pack_start(self.password1_entry)
+        self.passwords_hbox.pack_start(self.password2_entry)
+        help_msg = '<small>%s</small>' % self.PASSWORD_HELP
+        self.password_help_label.set_markup(help_msg)
+
+        if not os.path.exists(self._captcha_filename):
+            self._set_captcha_loading()
+        else:
+            self._set_captcha_image()
+
+        self.yes_to_updates_checkbutton.set_label(self.YES_TO_UPDATES)
+        self.yes_to_tc_checkbutton.set_label(self.YES_TO_TC)
+        self.tc_button.set_label(self.TC)
+        self.login_button.set_label(self.LOGIN_BUTTON_LABEL)
+
+        logger.info('Calling generate_captcha with filename path at %r',
+                    self._captcha_filename)
+        f = self.backend.generate_captcha
+        f(self._captcha_filename,
+          reply_handler=NO_OP, error_handler=NO_OP)
+
+        return self.enter_details_vbox
+
+    def _build_tc_page(self):
+        """Build the Terms & Conditions page."""
+        self.tc_browser = webkit.WebView()
+        self.tc_browser.open(self.tc_uri)
+        self.tc_browser.show()
+        self.tc_browser_window.add(self.tc_browser)
+
+        return self.tc_browser_vbox
+
+    def _build_processing_page(self):
+        """Build the processing page with a spinner."""
+        self._add_spinner_to_container(self.processing_vbox,
+                                       legend=self.ONE_MOMENT_PLEASE)
+        return self.processing_vbox
+
+    def _build_verify_email_page(self):
+        """Build the verify email page."""
+        self.verify_email_vbox.help_text = self.VERIFY_EMAIL_LABEL
+        self.verify_email_vbox.pack_start(self.email_token_entry, expand=False)
+        self.verify_email_vbox.reorder_child(self.email_token_entry, 1)
+
+        fname = get_data_file('email.png')
+        self._email_example_pixbuf = gtk.gdk.pixbuf_new_from_file(fname)
+        self.verify_email_image.set_from_pixbuf(self._email_example_pixbuf)
+
+        return self.verify_email_vbox
+
+    def _build_success_page(self):
+        """Build the success page."""
+        #self.success_vbox.help_text = ''
+        self.success_label.set_markup('<span size="x-large">%s</span>' %
+                                      self.SUCCESS)
+        return self.success_vbox
+
+    def _build_login_page(self):
+        """Build the login page."""
+        self.login_vbox.header = self.LOGIN_HEADER_LABEL % self.app_label
+        self.login_vbox.help_text = self.CONNECT_HELP_LABEL % self.app_label
+
+        self.login_details_vbox.pack_start(self.login_email_entry)
+        self.login_details_vbox.reorder_child(self.login_email_entry, 0)
+        self.login_details_vbox.pack_start(self.login_password_entry)
+        self.login_details_vbox.reorder_child(self.login_password_entry, 2)
+
+        msg = self.FORGOTTEN_PASSWORD_BUTTON
+        self.forgotten_password_button.set_label(msg)
+        self.login_ok_button.grab_focus()
+
+        return self.login_vbox
+
+    def _build_reset_email_page(self):
+        """Build the login page."""
+        self.reset_email_vbox.header = self.RESET_PASSWORD
+        self.reset_email_vbox.help_text = self.RESET_EMAIL_LABEL
+
+        self.reset_email_details_vbox.pack_start(self.reset_email_entry)
+        self.reset_email_entry.connect('changed',
+                                       self.on_reset_email_entry_changed)
+        self.reset_email_ok_button.set_label(self.NEXT)
+        self.reset_email_ok_button.set_sensitive(False)
+
+        return self.reset_email_vbox
+
+    def _build_reset_password_page(self):
+        """Build the login page."""
+        self.reset_password_vbox.header = self.RESET_PASSWORD
+        self.reset_password_vbox.help_text = self.RESET_PASSWORD_LABEL
+
+        self.reset_password_details_vbox.pack_start(self.reset_code_entry)
+        self.reset_password_details_vbox.pack_start(self.reset_password1_entry)
+        self.reset_password_details_vbox.pack_start(self.reset_password2_entry)
+
+        self.reset_code_entry.connect('changed',
+                                      self.on_reset_password_entry_changed)
+        self.reset_password1_entry.connect('changed',
+                                      self.on_reset_password_entry_changed)
+        self.reset_password2_entry.connect('changed',
+                                      self.on_reset_password_entry_changed)
+
+        self.reset_password_ok_button.set_label(self.RESET_PASSWORD)
+        self.reset_password_ok_button.set_sensitive(False)
+
+        return self.reset_password_vbox
+
+    # GTK callbacks
+
+    def run(self):
+        """Run the application."""
+        gtk.main()
+
+    def connect(self, signal_name, handler):
+        """Connect 'signal_name' with 'handler'."""
+        self.window.connect(signal_name, handler)
+
+    def on_close_clicked(self, *args, **kwargs):
+        """Call self.close_callback if defined."""
+        if os.path.exists(self._captcha_filename):
+            os.remove(self._captcha_filename)
+
+        # remove the signals from DBus
+        remove = self.bus.remove_signal_receiver
+        for (iface, signal) in self._signals_receivers.keys():
+            method = self._signals_receivers.pop((iface, signal))
+            remove(method, signal_name=signal, dbus_interface=iface)
+
+        # destroy main window
+        if self.window is not None:
+            self.window.hide()
+
+        if len(args) > 0 and args[0] in self.cancels:
+            self.window.emit(SIG_USER_CANCELATION)
+
+        # 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)
+
+    def on_sign_in_button_clicked(self, *args, **kwargs):
+        """User wants to sign in, present the Login page."""
+        self._set_current_page(self.login_vbox)
+
+    def on_join_ok_button_clicked(self, *args, **kwargs):
+        """Submit info for processing, present the processing vbox."""
+        self._clear_warnings()
+
+        error = False
+
+        name = self.name_entry.get_text()
+        if not name:
+            self._set_warning_message(self.name_warning_label,
+                                      self.FIELD_REQUIRED)
+            error |= True
+
+        # check email
+        email1 = self.email1_entry.get_text()
+        email2 = self.email2_entry.get_text()
+        if email1 != email2:
+            self._set_warning_message(self.email_warning_label,
+                                      self.EMAIL_MISMATCH)
+            error |= True
+
+        if '@' not in email1:
+            self._set_warning_message(self.email_warning_label,
+                                      self.EMAIL_INVALID)
+            error |= True
+
+        if not email1:
+            self._set_warning_message(self.email_warning_label,
+                                      self.FIELD_REQUIRED)
+            error |= True
+
+        # check password
+        password1 = self.password1_entry.get_text()
+        password2 = self.password2_entry.get_text()
+        if password1 != password2:
+            self._set_warning_message(self.password_warning_label,
+                                      self.PASSWORD_MISMATCH)
+            error |= True
+
+        if (len(password1) < 8 or
+            re.search('[A-Z]', password1) is None or
+            re.search('\d+', password1) is None):
+            self._set_warning_message(self.password_warning_label,
+                                      self.PASSWORD_TOO_WEAK)
+            error |= True
+
+        # check T&C
+        if not self.yes_to_tc_checkbutton.get_active():
+            self._set_warning_message(self.tc_warning_label,
+                                      self.TC_NOT_ACCEPTED)
+            error |= True
+
+        captcha_solution = self.captcha_solution_entry.get_text()
+        if not captcha_solution:
+            self._set_warning_message(self.captcha_solution_warning_label,
+                                      self.FIELD_REQUIRED)
+            error |= True
+
+        if error:
+            return
+
+        self._clear_warnings()
+        self._set_current_page(self.processing_vbox)
+
+        logger.info('Calling register_user with email %r, password <hidden>,' \
+                    ' captcha_id %r and captcha_solution %r.', email1,
+                    self._captcha_id, captcha_solution)
+        f = self.backend.register_user
+        f(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!"""
+        email = self.email1_entry.get_text()
+        password = self.password1_entry.get_text()
+        email_token = self.email_token_entry.get_text()
+
+        logger.info('Calling validate_email with email %r, password <hidden>' \
+                    ', app_name %r and email_token %r.', email,
+                    self.app_name, email_token)
+        f = self.backend.validate_email
+        f(email, password, self.app_name, email_token,
+          reply_handler=NO_OP, error_handler=NO_OP)
+
+        self._set_current_page(self.processing_vbox)
+
+    def on_login_connect_button_clicked(self, *args, **kwargs):
+        """User wants to connect!"""
+        self._clear_warnings()
+
+        error = False
+        email = self.login_email_entry.get_text()
+
+        if '@' not in email:
+            self._set_warning_message(self.login_email_warning_label,
+                                      self.EMAIL_INVALID)
+            error |= True
+
+        if not email:
+            self._set_warning_message(self.login_email_warning_label,
+                                      self.FIELD_REQUIRED)
+            error |= True
+
+        password = self.login_password_entry.get_text()
+
+        if not password:
+            self._set_warning_message(self.login_password_warning_label,
+                                      self.FIELD_REQUIRED)
+            error |= True
+
+        if error:
+            return
+
+        self._clear_warnings()
+
+        f = self.backend.login
+        f(email, password, self.app_name,
+          reply_handler=NO_OP, error_handler=NO_OP)
+
+        self._set_current_page(self.processing_vbox)
+
+    def on_login_back_button_clicked(self, *args, **kwargs):
+        """User wants to go to the previous page."""
+        self._set_current_page(self.enter_details_vbox)
+
+    def on_forgotten_password_button_clicked(self, *args, **kwargs):
+        """User wants to reset the password."""
+        self._set_current_page(self.reset_email_vbox)
+
+    def on_reset_email_ok_button_clicked(self, *args, **kwargs):
+        """User entered the email address."""
+        email = self.reset_email_entry.get_text()
+        self.reset_password_vbox.help_text = self.RESET_PASSWORD_LABEL % email
+        self._set_current_page(self.reset_password_vbox)
+
+    def on_reset_email_back_button_clicked(self, *args, **kwargs):
+        """User wants to go to the previous page."""
+        self._set_current_page(self.login_vbox)
+
+    def on_reset_email_entry_changed(self, widget, *args, **kwargs):
+        """User is changing the 'widget' entry in the reset email page."""
+        self.reset_email_ok_button.set_sensitive(self._non_empty_input(widget))
+
+    def on_reset_password_entry_changed(self, *args, **kwargs):
+        """User is changing the 'widget' entry in the reset password page."""
+        sensitive = True
+        for entry in (self.reset_code_entry, self.reset_password1_entry,
+                      self.reset_password2_entry):
+            sensitive &= self._non_empty_input(entry)
+        self.reset_password_ok_button.set_sensitive(sensitive)
+
+    # backend callbacks
+
+    def on_captcha_generated(self, captcha_id, *args, **kwargs):
+        """Captcha image has been generated and is available to be shown."""
+        assert captcha_id is not None
+        self._captcha_id = captcha_id
+        self._set_captcha_image()
+
+    def on_captcha_generation_error(self, *args, **kwargs):
+        """Captcha image generation failed."""
+        logger.warning('on_captcha_generation_error: args %r, kwargs %r',
+                       args, kwargs)
+
+    def on_user_registered(self, *args, **kwargs):
+        """Registration can go on, user needs to verify email."""
+        logger.info('on_user_registered: user was successfully registered! ' \
+                    'args %r, kwargs %r.', args, kwargs)
+        self._set_current_page(self.verify_email_vbox)
+
+    def on_user_registration_error(self, *args, **kwargs):
+        """Captcha image generation failed."""
+        logger.warning('on_user_registration_error: args %r, kwargs %r',
+                       args, kwargs)
+        self._set_current_page(self.enter_details_vbox,
+                               warning_text=self.UNKNOWN_ERROR)
+        self.window.emit(SIG_REGISTRATION_FAILED)
+
+    def on_email_validated(self, app_name, *args, **kwargs):
+        """User email was successfully verified."""
+        logger.info('on_email_validated: email was successfully validated! ' \
+                    'app_name %r, args %r, kwargs %r.', app_name, args, kwargs)
+        self._set_current_page(self.success_vbox)
+        self.window.emit(SIG_REGISTRATION_SUCCEEDED, app_name)
+
+    def on_email_validation_error(self, *args, **kwargs):
+        """User email validation failed."""
+        logger.warning('on_email_validation_error: args %r, kwargs %r',
+                       args, kwargs)
+        # XXX: show something to the user!!!
+        self.window.emit(SIG_REGISTRATION_FAILED)
+
+    def on_logged_in(self, app_name, *args, **kwargs):
+        """User was successfully logged in."""
+        logger.info('on_logged_in: user was successfully logged in! '
+                    'args %r, kwargs %r', args, kwargs)
+        self._set_current_page(self.success_vbox)
+        self.window.emit(SIG_LOGIN_SUCCEEDED, app_name)
+
+    def on_login_error(self, *args, **kwargs):
+        """User was not successfully logged in."""
+        logger.warning('on_login_error: args %r, kwargs %r', args, kwargs)
+        self._set_current_page(self.login_vbox,
+                               warning_text=self.UNKNOWN_ERROR)
+        self.window.emit(SIG_LOGIN_FAILED)

=== added file 'ubuntu_sso/keyring.py'
--- ubuntu_sso/keyring.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,111 @@
+# Copyright (C) 2010 Canonical
+#
+# Authors:
+#  Andrew Higginson
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 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, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import gnomekeyring
+
+from urllib import urlencode
+from urlparse import parse_qsl
+
+class Keyring(object):
+
+    KEYRING_NAME = "login"
+
+    def __init__(self, app_name):
+
+        if not gnomekeyring.is_available():
+            raise gnomekeyring.NoKeyringDaemonError
+        self.app_name = app_name
+
+    def _create_keyring(self, name):
+        """
+        Creates a keyring, if it already exists,
+        it does nothing
+        """
+        keyring_names = gnomekeyring.list_keyring_names_sync()
+        if not name in keyring_names:
+            gnomekeyring.create_sync(name)
+
+    def _item_exists(self, sync, name):
+        """
+        Returns whether a named item exists in a
+        named keyring
+        """
+        return self._get_item_id_from_name(sync, name) != None
+
+    def _get_item_id_from_name(self, sync, name):
+        """
+        Returns the ID for a named item
+        """
+        for item_id in gnomekeyring.list_item_ids_sync(sync):
+            item_info = gnomekeyring.item_get_info_sync(sync, item_id)
+            display_name = item_info.get_display_name()
+            if display_name == name:
+                return item_id
+        return None
+
+    def _get_item_info_from_name(self, sync, name):
+        """
+        Returns the ID for a named item
+        """
+        for item_id in gnomekeyring.list_item_ids_sync(sync):
+            item_info = gnomekeyring.item_get_info_sync(sync, item_id)
+            display_name = item_info.get_display_name()
+            if display_name == name:
+                return item_info
+        return None
+
+    def set_ubuntusso_attr(self, attr):
+        """
+        Sets the attributes of the Ubuntu SSO item
+        """
+        # Creates the secret from the attributes
+        secret = urlencode(attr)
+
+        # Create the keyring
+        self._create_keyring(self.KEYRING_NAME)
+
+        # If the item already exists, delete it
+        if self._item_exists(self.KEYRING_NAME, self.app_name):
+            item_id = self._get_item_id_from_name(self.KEYRING_NAME,
+                                                  self.app_name)
+            gnomekeyring.item_delete_sync(self.KEYRING_NAME, item_id)
+
+        # Add our SSO item
+        gnomekeyring.item_create_sync(self.KEYRING_NAME,
+                gnomekeyring.ITEM_GENERIC_SECRET, self.app_name, {},
+                secret, True)
+
+    def get_ubuntusso_attr(self):
+        """
+        Returns the secret of the SSO item in a dictionary
+        """
+        # If we have no attributes, return None
+        if self._get_item_info_from_name(self.KEYRING_NAME,
+                                         self.app_name) == None:
+            return None
+        secret = self._get_item_info_from_name(self.KEYRING_NAME,
+                                               self.app_name).get_secret()
+        return dict(parse_qsl(secret))
+
+if __name__ == "__main__":
+    SSO_ITEM_NAME = "Software Center UbuntuSSO token"
+    keyring = Keyring(SSO_ITEM_NAME)
+    keyring.set_ubuntusso_attr({"ha":"hehddddeff", "hi":"hggehes", "ho":"he"})
+    print keyring.get_ubuntusso_attr()
+
+

=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/logger.py	2010-08-11 18:19:01 +0000
@@ -15,9 +15,13 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 """Miscellaneous logging functions."""
+
+import logging
 import os
-import logging
+import sys
+
 import xdg.BaseDirectory
 
 from logging.handlers import RotatingFileHandler
@@ -31,7 +35,7 @@
 LOGFILENAME = os.path.join(LOGFOLDER, 'oauth-login.log')
 
 # Only log this level and above
-LOG_LEVEL = logging.INFO
+LOG_LEVEL = logging.DEBUG # logging.INFO
 
 root_formatter = logging.Formatter(
     fmt="%(asctime)s:%(msecs)s %(name)s %(message)s")
@@ -40,10 +44,16 @@
 root_handler.setLevel(LOG_LEVEL)
 root_handler.setFormatter(root_formatter)
 
+
 def setupLogging(log_domain):
     """Create basic logger to set filename"""
     logger = logging.getLogger(log_domain)
     logger.propagate = False
     logger.setLevel(LOG_LEVEL)
     logger.addHandler(root_handler)
+    if os.environ.get('DEBUG'):
+        debug_handler = logging.StreamHandler(sys.stderr)
+        debug_handler.setLevel(logging.DEBUG)
+        logger.addHandler(debug_handler)
+
     return logger

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/main.py	2010-08-11 18:19:01 +0000
@@ -3,6 +3,8 @@
 # ubuntu_sso.main - main login handling interface
 #
 # Author: Stuart Langridge <[e-mail]>
+# Author: Natalia Bidart <[e-mail]>
+# Author: Alejandro J. Cura <[e-mail]>
 #
 # Copyright 2009 Canonical Ltd.
 #
@@ -25,39 +27,485 @@
 signal so they can retrieve the new token.
 """
 
-import dbus.service, urlparse, time, gobject
-import pynotify
+import re
+import socket
+import time
+import threading
+import urllib
+import urllib2
+import urlparse
+
+import dbus.service
+import gobject
 
 from dbus.mainloop.glib import DBusGMainLoop
+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
+from oauth.oauth import OAuthToken
 
-from ubuntu_sso import DBUS_IFACE_AUTH_NAME
+from keyring import Keyring
+from ubuntu_sso import (DBUS_IFACE_AUTH_NAME, DBUS_IFACE_USER_NAME,
+    DBUS_IFACE_CRED_NAME, DBUS_CRED_PATH, DBUS_BUS_NAME, gui)
 from ubuntu_sso.config import get_config
-
 from ubuntu_sso.logger import setupLogging
 logger = setupLogging("ubuntu_sso.main")
 
 DBusGMainLoop(set_as_default=True)
-
 # Disable the invalid name warning, as we have a lot of DBus style names
 # pylint: disable-msg=C0103
 
+
 class NoDefaultConfigError(Exception):
     """No default section in configuration file"""
-    pass
+
 
 class BadRealmError(Exception):
-    """Realm must be a URL"""
-    pass
+    """Realm must be a URL."""
+
+
+class InvalidEmailError(Exception):
+    """The email is not valid."""
+
+
+class InvalidPasswordError(Exception):
+    """The password is not valid.
+
+    Must provide at least 8 characters, one upper case, one number.
+    """
+
+
+class RegistrationError(Exception):
+    """The registration failed."""
+
+
+class AuthenticationError(Exception):
+    """The authentication failed."""
+
+
+class EmailTokenError(Exception):
+    """The email token is not valid."""
+
+
+class ResetPasswordTokenError(Exception):
+    """The token for password reset could not be generated."""
+
+
+class NewPasswordError(Exception):
+    """The new password could not be set."""
+
+
+def keyring_store_credentials(app_name, credentials):
+    """Store the credentials in the 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."""
+    return Keyring(app_name).get_ubuntusso_attr()
+
+
+def get_token_name(app_name):
+    """Build the token name."""
+    quoted_app_name = urllib.quote(app_name)
+    computer_name = socket.gethostname()
+    quoted_computer_name = urllib.quote(computer_name)
+    return "%s - %s" % (quoted_app_name, quoted_computer_name)
+
+
+class SSOLoginProcessor(object):
+    """Login and register users using the Ubuntu Single Sign On service."""
+
+    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 = 'https://login.ubuntu.com/api/1.0'
+
+    def _valid_email(self, email):
+        """Validate the given email."""
+        # XXX: to be improved as per django validation
+        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 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':
+            raise RegistrationError(result['errors'])
+        elif result['status'] != 'ok':
+            raise RegistrationError('Received unknown status: %s' % result)
+        else:
+            return True
+
+    def login(self, email, password, app_name):
+        """Login a user with 'email' and 'password'."""
+        logger.debug('login: email: %r password: <hidden>, app_name: %r',
+                     email, app_name)
+        basic = BasicHttpAuthorizer(email, password)
+        sso_service = self.sso_service_class(basic, self.service_url)
+        service = sso_service.authentications.authenticate
+
+        token_name = get_token_name(app_name)
+        try:
+            credentials = service(token_name=token_name)
+        except HTTPError:
+            logger.exception('login failed with:')
+            raise AuthenticationError()
+
+        logger.debug('login: authentication successful! consumer_key: %r',
+                     credentials['consumer_key'])
+        keyring_store_credentials(app_name, credentials)
+        return credentials
+
+    def validate_email(self, email, password, app_name, email_token):
+        """Validate an email token for user with 'email' and 'password'."""
+        logger.debug('validate_email: email: %r password: <hidden>, '
+                     'app_name: %r, email_token: %r',
+                     email, app_name, email_token)
+        token = self.login(email=email, password=password,
+                           app_name=app_name)
+
+        oauth_token = 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:
+            raise EmailTokenError(result['errors'])
+        elif 'email' in result:
+            return True
+        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)
+
+        if result['status'] == 'ok':
+            return True
+        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)
+
+        if result['status'] == 'ok':
+            return True
+        else:
+            raise NewPasswordError('Received invalid reply: %s' % result)
+
+
+def blocking(f, result_cb, error_cb):
+    """Run f in a thread; return or throw an exception thru the callbacks."""
+    def _in_thread():
+        """The part that runs inside the thread."""
+        try:
+            result_cb(f())
+        except Exception, e:
+            msg = "Exception while running DBus blocking code in a thread."""
+            logger.exception(msg)
+            error_cb(str(e))
+    threading.Thread(target=_in_thread).start()
+
+
+class SSOLogin(dbus.service.Object):
+    """Login thru the Single Sign On service."""
+
+    def __init__(self, bus_name,
+                 sso_login_processor_class=SSOLoginProcessor,
+                 sso_service_class=None):
+        """Initiate the Login object."""
+        dbus.service.Object.__init__(self, object_path="/sso",
+                                     bus_name=bus_name)
+        self.sso_login_processor_class = sso_login_processor_class
+        self.sso_service_class = sso_service_class
+
+    def processor(self):
+        """Create a login processor with the given class and service class."""
+        return self.sso_login_processor_class(
+                                    sso_service_class=self.sso_service_class)
+
+    # generate_capcha signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def CaptchaGenerated(self, result):
+        """Signal thrown after the captcha is generated."""
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def CaptchaGenerationError(self, error):
+        """Signal thrown when there's a problem generating the captcha."""
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='s')
+    def generate_captcha(self, filename):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor().generate_captcha(filename)
+        blocking(f, self.CaptchaGenerated, self.CaptchaGenerationError)
+
+    # register_user signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="b")
+    def UserRegistered(self, result):
+        """Signal thrown when the user is registered."""
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def UserRegistrationError(self, error):
+        """Signal thrown when there's a problem registering the user."""
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssss')
+    def register_user(self, email, password, captcha_id, captcha_solution):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor().register_user(email, password,
+                                              captcha_id, captcha_solution)
+        blocking(f, self.UserRegistered, self.UserRegistrationError)
+
+    # login signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def LoggedIn(self, result):
+        """Signal thrown when the user is logged in."""
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def LoginError(self, error):
+        """Signal thrown when there is a problem in the login."""
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='sss')
+    def login(self, email, password, app_name):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            credentials = self.processor().login(email, password, app_name)
+            assert credentials is not None
+            return app_name
+        blocking(f, self.LoggedIn, self.LoginError)
+
+    # validate_email signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def EmailValidated(self, app_name):
+        """Signal thrown after the email is validated."""
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def EmailValidationError(self, error):
+        """Signal thrown when there's a problem validating the email."""
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssss')
+    def validate_email(self, email, password, app_name, email_token):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            self.processor().validate_email(email, password,
+                                               app_name, email_token)
+            return app_name
+        blocking(f, self.EmailValidated, self.EmailValidationError)
+
+    # request_password_reset_token signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def PasswordResetTokenSent(self, email):
+        """Signal thrown when the token is succesfully sent."""
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def PasswordResetError(self, error):
+        """Signal thrown when there's a problem sending the token."""
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='s')
+    def request_password_reset_token(self, email):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            self.processor().request_password_reset_token(email)
+            return email
+        blocking(f, self.PasswordResetTokenSent, self.PasswordResetError)
+
+    # set_new_password signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def PasswordChanged(self, email):
+        """Signal thrown when the token is succesfully sent."""
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
+    def PasswordChangeError(self, error):
+        """Signal thrown when there's a problem sending the token."""
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='sss')
+    def set_new_password(self, email, token, new_password):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            self.processor().set_new_password(email, token, new_password)
+            return email
+        blocking(f, self.PasswordChanged, self.PasswordChangeError)
+
+
+class SSOCredentials(dbus.service.Object):
+    """DBus object that gets credentials, and login/registers if needed."""
+
+    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
+    def AuthorizationDenied(self, app_name):
+        """Signal thrown when the user denies the authorization."""
+
+    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="a{ss}")
+    def CredentialsFound(self, app_name):
+        """Signal thrown when the credentials are found."""
+
+    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
+    def CredentialsError(self, error):
+        """Signal thrown when there is a problem finding the credentials."""
+
+    @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)
+        if token is None:
+            return {}
+        else:
+            return token
+
+    def _login_success_cb(self, dialog, app_name):
+        """Handles the response from the UI dialog."""
+        try:
+            creds = keyring_get_credentials(app_name)
+            self.CredentialsFound(creds)
+        except Exception, e:
+            logger.exception("problem when getting credentials from keyring")
+            self.CredentialsError(str(e))
+
+    def _login_error_cb(self, dialog):
+        """Handles a problem in the UI."""
+        msg = "misc problem getting the credentials"
+        self.CredentialsError(msg)
+        logger.error(msg)
+
+    def _login_auth_denied_cb(self, dialog):
+        """The user decides not to allow the registration or login."""
+        self.AuthorizationDenied()
+
+    def _show_login_or_register_ui(self, app_name, tc_url, help_text, win_id):
+        """Shows the UI so the user can login or register."""
+        try:
+            gui_app = gui.UbuntuSSOClientGUI(app_name, tc_url,
+                                             help_text, win_id)
+            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 Exception, e:
+            msg = '_show_login_or_register_ui failed when calling ' \
+                  'gui.UbuntuSSOClientGUI(%r, %r, %r, %r)'
+            logger.exception(msg, app_name, tc_url, help_text, win_id)
+            self.CredentialsError(str(e))
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
+                         in_signature="sssx", out_signature="")
+    def login_or_register_to_get_credentials(self, app_name,
+                                             terms_and_conditions_url,
+                                             help_text, window_id):
+        """Get credentials if found else prompt GUI to login or register.
+
+        'app_name' will be displayed in the GUI.
+        'terms_and_conditions_url' will be the URL pointing to T&C.
+        '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.
+
+        """
+        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(token)
+        except Exception, e:
+            logger.exception("problem while getting the credentials")
+            self.CredentialsError(str(e))
+
 
 class LoginProcessor:
-    """Actually do the work of processing passed parameters"""
-    def __init__(self, dbus_object, use_libnotify=True):
+    """Actually do the work of processing passed parameters."""
+
+    def __init__(self, dbus_object):
         """Initialize the login processor."""
         logger.debug("Creating a LoginProcessor")
-        self.use_libnotify = use_libnotify
-        if self.use_libnotify and pynotify:
-            logger.debug("Hooking libnotify")
-            pynotify.init("UbuntuOne Login")
         self.note1 = None
         self.realm = None
         self.consumer_key = None
@@ -68,13 +516,13 @@
     def login(self, realm, consumer_key, do_login=True):
         """Initiate an OAuth login"""
         logger.debug("Initiating OAuth login in LoginProcessor")
-        self.realm = str(realm) # because they are dbus.Strings, not str
+        self.realm = str(realm)  # because they are dbus.Strings, not str
         self.consumer_key = str(consumer_key)
 
         logger.debug("Obtaining OAuth urls")
         (request_token_url, user_authorisation_url,
-          access_token_url, consumer_secret) =  self.get_config_urls(realm)
-        logger.debug("OAuth URLs are: request='%s', userauth='%s', " +\
+          access_token_url, consumer_secret) = self.get_config_urls(realm)
+        logger.debug("OAuth URLs are: request='%s', userauth='%s', " + \
                      "access='%s', secret='%s'", request_token_url,
                      user_authorisation_url, access_token_url, consumer_secret)
 
@@ -98,7 +546,7 @@
         self.realm = str(realm)
         self.consumer_key = str(consumer_key)
         (request_token_url, user_authorisation_url,
-          access_token_url, consumer_secret) =  self.get_config_urls(self.realm)
+          access_token_url, consumer_secret) = self.get_config_urls(self.realm)
         from ubuntu_sso.auth import AuthorisationClient
         client = AuthorisationClient(self.realm,
                                      request_token_url,
@@ -114,7 +562,7 @@
     def error_handler(self, failure):
         """Deal with errors returned from auth process"""
         logger.debug("Error returned from auth process")
-        self.dbus_object.currently_authing = False # not block future requests
+        self.dbus_object.currently_authing = False  # not block future requests
 
     def get_config_urls(self, realm):
         """Look up the URLs to use in the config file"""
@@ -209,7 +657,8 @@
 
 
 class Login(dbus.service.Object):
-    """Object which listens for D-Bus OAuth requests"""
+    """Object which listens for D-Bus OAuth requests."""
+
     def __init__(self, bus_name):
         """Initiate the Login object."""
         dbus.service.Object.__init__(self, object_path="/", bus_name=bus_name)
@@ -218,9 +667,9 @@
         logger.debug("Login D-Bus service starting up")
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_AUTH_NAME,
-                                           in_signature='ss', out_signature='')
+                         in_signature='ss', out_signature='')
     def login(self, realm, consumer_key):
-        """D-Bus method, exported over the bus, to initiate an OAuth login"""
+        """D-Bus method, to initiate an OAuth login."""
         logger.debug("login() D-Bus message received with realm='%s', " +
                      "consumer_key='%s'", realm, consumer_key)
         if self.currently_authing:
@@ -230,11 +679,9 @@
         self.processor.login(realm, consumer_key)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_AUTH_NAME,
-                                           in_signature='ssb', out_signature='')
+                         in_signature='ssb', out_signature='')
     def maybe_login(self, realm, consumer_key, do_login):
-        """
-        D-Bus method, exported over the bus, to maybe initiate an OAuth login
-        """
+        """D-Bus method, to maybe initiate an OAuth login."""
         logger.debug("maybe_login() D-Bus message received with realm='%s', " +
                      "consumer_key='%s'", realm, consumer_key)
         if self.currently_authing:
@@ -246,9 +693,7 @@
     @dbus.service.method(dbus_interface=DBUS_IFACE_AUTH_NAME,
                          in_signature='ss', out_signature='')
     def clear_token(self, realm, consumer_key):
-        """
-        D-Bus method, exported over the bus, to clear the existing token.
-        """
+        """D-Bus method, to clear the existing token."""
         self.processor.clear_token(realm, consumer_key)
 
     @dbus.service.signal(dbus_interface=DBUS_IFACE_AUTH_NAME, signature='ss')
@@ -274,17 +719,25 @@
         self.currently_authing = False
         return message
 
+
 def main():
     """Start everything"""
+    dbus.mainloop.glib.threads_init()
+    gobject.threads_init()
     logger.debug("Starting up at %s", time.asctime())
     logger.debug("Installing the Twisted glib2reactor")
-    from twisted.internet import glib2reactor # for non-GUI apps
+    from twisted.internet import glib2reactor  # for non-GUI apps
     glib2reactor.install()
     from twisted.internet import reactor
 
     logger.debug("Creating the D-Bus service")
-    Login(dbus.service.BusName(DBUS_IFACE_AUTH_NAME,
-                               bus=dbus.SessionBus()))
+    Login(dbus.service.BusName(DBUS_BUS_NAME,
+                               bus=dbus.SessionBus()))
+    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)
     # cleverness here to say:
     # am I already running (bound to this d-bus name)?
     # if so, send a signal to the already running instance
@@ -292,4 +745,3 @@
     # to kick off the signin process
     logger.debug("Starting the reactor mainloop")
     reactor.run()
-

=== added file 'ubuntu_sso/networkstate.py'
--- ubuntu_sso/networkstate.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,106 @@
+# networkstate - detect the current state of the network
+#
+# Author: Alejandro J. Cura <[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/>.
+"""Implementation of network state detection."""
+
+import dbus
+
+from ubuntu_sso.logger import setupLogging
+logger = setupLogging("ubuntu_sso.networkstate")
+
+# Values returned by the callback
+ONLINE, OFFLINE, UNKNOWN = object(), object(), object()
+
+nm_state_names = {
+    ONLINE: "online",
+    OFFLINE: "offline",
+    UNKNOWN: "unknown",
+}
+
+# Internal NetworkManager State constants
+NM_STATE_UNKNOWN = 0
+NM_STATE_ASLEEP = 1
+NM_STATE_CONNECTING = 2
+NM_STATE_CONNECTED = 3
+NM_STATE_DISCONNECTED = 4
+
+NM_DBUS_INTERFACE = "org.freedesktop.NetworkManager"
+NM_DBUS_OBJECTPATH = "/org/freedesktop/NetworkManager"
+DBUS_UNKNOWN_SERVICE = "org.freedesktop.DBus.Error.ServiceUnknown"
+
+
+class NetworkManagerState(object):
+    """Checks the state of NetworkManager thru DBus."""
+
+    def __init__(self, result_cb, dbus=dbus):
+        """Initialize this instance with a result and error callbacks."""
+        self.result_cb = result_cb
+        self.dbus = dbus
+        self.state_signal = None
+
+    def call_result_cb(self, state):
+        """Return the state thru the result callback."""
+        if self.state_signal:
+            self.state_signal.remove()
+        self.result_cb(state)
+
+    def got_state(self, state):
+        """Called by DBus when the state is retrieved from NM."""
+        if state == NM_STATE_CONNECTED:
+            self.call_result_cb(ONLINE)
+        elif state == NM_STATE_CONNECTING:
+            logger.debug("Currently connecting, waiting for signal")
+        else:
+            self.call_result_cb(OFFLINE)
+
+    def got_error(self, error):
+        """Called by DBus when the state is retrieved from NM."""
+        if isinstance(error, self.dbus.exceptions.DBusException) and \
+                error.get_dbus_name() == DBUS_UNKNOWN_SERVICE:
+            logger.debug("Network Manager not present")
+            self.call_result_cb(UNKNOWN)
+        else:
+            logger.error("Error contacting NetworkManager: %s" % \
+                             str(error))
+            self.call_result_cb(UNKNOWN)
+
+    def state_changed(self, state):
+        """Called when a signal is emmited by Network Manager."""
+        if int(state) == NM_STATE_CONNECTED:
+            self.call_result_cb(ONLINE)
+        elif int(state) == NM_STATE_DISCONNECTED:
+            self.call_result_cb(OFFLINE)
+        else:
+            logger.debug("Not yet connected: continuing to wait")
+
+    def find_online_state(self):
+        """Get the network state and return it thru the set callback."""
+        try:
+            sysbus = self.dbus.SystemBus()
+            nm_proxy = sysbus.get_object(NM_DBUS_INTERFACE,
+                                         NM_DBUS_OBJECTPATH,
+                                         follow_name_owner_changes=True)
+            nm_if = self.dbus.Interface(nm_proxy, NM_DBUS_INTERFACE)
+            self.state_signal = nm_if.connect_to_signal(
+                        signal_name="StateChanged",
+                        handler_function=self.state_changed,
+                        dbus_interface=NM_DBUS_INTERFACE)
+            nm_proxy.Get(NM_DBUS_INTERFACE, "State",
+                         reply_handler=self.got_state,
+                         error_handler=self.got_error)
+        except Exception, e:
+            self.got_error(e)

=== added file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,1220 @@
+# -*- coding: utf-8 -*-
+#
+# test_gui - tests for ubuntu_sso.gui
+#
+# 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 GUI for registration/login."""
+
+import itertools
+import logging
+import os
+import socket
+
+import dbus
+import gtk
+
+from twisted.trial.unittest import TestCase
+
+from contrib.testing.testcase import MementoHandler
+from ubuntu_sso import gui
+
+
+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."""
+
+NAME = 'Juanito Pérez'
+EMAIL = '[e-mail]'
+PASSWORD = 'h3lloWorld'
+CAPTCHA_ID = 'test'
+CAPTCHA_SOLUTION = 'william Byrd'
+TOKEN_NAME = 'my-testing-host'
+EMAIL_TOKEN = 'B2Pgtf'
+APP_NAME = "my-testing-app"
+
+
+class FakedSSOBackend(object):
+    """Fake a SSO Backend (acts as a dbus.Interface as well)."""
+
+    def __init__(self, *args, **kwargs):
+        self._args = args
+        self._kwargs = kwargs
+        self._called = {}
+        for i in ('generate_captcha', 'login', 'register_user',
+                  'validate_email'):
+            setattr(self, i, self._record_call(i))
+
+    def _record_call(self, func_name):
+        """Store values when calling 'func_name'."""
+
+        def inner(*args, **kwargs):
+            """Fake 'func_name'."""
+            self._called[func_name] = (args, kwargs)
+
+        return inner
+
+
+class FakedDbusObject(object):
+    """Fake a dbus."""
+
+    def __init__(self, *args, **kwargs):
+        """Init."""
+        self._args = args
+        self._kwargs = kwargs
+
+
+class FakedSessionBus(object):
+    """Fake the session bus."""
+
+    def __init__(self):
+        """Init."""
+        self.obj = None
+        self.callbacks = {}
+
+    def add_signal_receiver(self, method, signal_name, dbus_interface):
+        """Add a signal receiver."""
+        self.callbacks[(dbus_interface, signal_name)] = method
+
+    def remove_signal_receiver(self, match, signal_name, dbus_interface):
+        """Remove the signal receiver."""
+        assert (dbus_interface, signal_name) in self.callbacks
+        del self.callbacks[(dbus_interface, signal_name)]
+
+    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:
+            assert self.obj is None
+            kwargs = dict(object_path=object_path,
+                          bus_name=bus_name, follow_name_owner_changes=True)
+            self.obj = FakedDbusObject(**kwargs)
+        return self.obj
+
+
+class BasicTestCase(TestCase):
+    """Test case with a helper tracker."""
+
+    def setUp(self):
+        """Init."""
+        self._called = False  # helper
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        gui.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 LabeledEntryTestCase(BasicTestCase):
+    """Test suite for the labeled entry."""
+
+    def setUp(self):
+        """Init."""
+        super(LabeledEntryTestCase, self).setUp()
+        self.label = 'Test me please'
+        self.entry = gui.LabeledEntry(label=self.label)
+
+        # we need a window to be able to realize ourselves
+        window = gtk.Window()
+        window.add(self.entry)
+        window.show_all()
+
+    def tearDown(self):
+        """Clean up."""
+        self.entry = None
+        super(LabeledEntryTestCase, self).tearDown()
+
+    def grab_focus(self, focus_in=True):
+        """Grab focus on widget, if None use self.entry."""
+        direction = 'in' if focus_in else 'out'
+        self.entry.emit('focus-%s-event' % direction, None)
+
+    def assert_correct_label(self):
+        """Check that the entry has the correct label."""
+        # text content is correct
+        msg = 'Text content must be "%s" (got "%s" instead).'
+        expected = self.label
+        actual = super(gui.LabeledEntry, self.entry).get_text()
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+        # text color is correct
+        msg = 'Text color must be "%s" (got "%s" instead).'
+        expected = gui.HELP_TEXT_COLOR
+        actual = self.entry.style.text[gtk.STATE_NORMAL]
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+    def test_initial_text(self):
+        """Entry have the correct text at startup."""
+        self.assert_correct_label()
+
+    def test_width_chars(self):
+        """Entry have the correct width."""
+        self.assertEqual(self.entry.get_width_chars(), gui.DEFAULT_WIDTH)
+
+    def test_tooltip(self):
+        """Entry have the correct tooltip."""
+        msg = 'Tooltip must be "%s" (got "%s" instead).'
+        expected = self.label
+        actual = self.entry.get_tooltip_text()
+        # tooltip is correct
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+    def test_clear_entry_on_focus_in(self):
+        """Entry are cleared when focused."""
+        self.grab_focus()
+
+        msg = 'Entry must be cleared on focus in.'
+        self.assertEqual('', self.entry.get_text(), msg)
+
+    def test_text_defaults_to_theme_color_when_focus_in(self):
+        """Entry restore its text color when focused in."""
+        self.patch(self.entry, 'modify_text', self._set_called)
+
+        self.grab_focus()
+
+        self.assertEqual(((gtk.STATE_NORMAL, None), {}), self._called,
+                         'Entry text color must be restore on focus in.')
+
+    def test_refill_entry_on_focus_out_if_no_input(self):
+        """Entry is re-filled with label when focused out if no user input."""
+
+        self.grab_focus()  # grab focus
+        self.grab_focus(focus_in=False)  # loose focus
+
+        # Entry must be re-filled on focus out
+        self.assert_correct_label()
+
+    def test_refill_entry_on_focus_out_if_empty_input(self):
+        """Entry is re-filled with label when focused out if empty input."""
+
+        self.grab_focus()  # grab focus
+
+        self.entry.set_text('        ')  # add empty text to the entry
+
+        self.grab_focus(focus_in=False)  # loose focus
+
+        # Entry must be re-filled on focus out
+        self.assert_correct_label()
+
+    def test_preserve_input_on_focus_out_if_user_input(self):
+        """Entry is unmodified when focused out if user input."""
+        msg = 'Entry must be left unmodified on focus out when user input.'
+        expected = 'test me please'
+
+        self.grab_focus()  # grab focus
+
+        self.entry.set_text(expected)  # add empty text to the entry
+
+        self.grab_focus(focus_in=False)  # loose focus
+
+        self.assertEqual(expected, self.entry.get_text(), msg)
+
+    def test_preserve_input_on_focus_out_and_in_again(self):
+        """Entry is unmodified when focused out and then in again."""
+        msg = 'Entry must be left unmodified on focus out and then in again.'
+        expected = 'test me I mean it'
+
+        self.grab_focus()  # grab focus
+
+        self.entry.set_text(expected)  # add text to the entry
+
+        self.grab_focus(focus_in=False)  # loose focus
+        self.grab_focus()  # grab focus again!
+
+        self.assertEqual(expected, self.entry.get_text(), msg)
+
+    def test_get_text_ignores_label(self):
+        """Entry's text is only user input (label is ignored)."""
+        self.assertEqual(self.entry.get_text(), '')
+
+    def test_get_text_ignores_empty_input(self):
+        """Entry's text is only user input (empty text is ignored)."""
+        self.entry.set_text('       ')
+        self.assertEqual(self.entry.get_text(), '')
+
+    def test_get_text_doesnt_ignore_user_input(self):
+        """Entry's text is user input."""
+        self.entry.set_text('a')
+        self.assertEqual(self.entry.get_text(), 'a')
+
+
+class PasswordLabeledEntryTestCase(LabeledEntryTestCase):
+    """Test suite for the labeled entry when is_password is True."""
+
+    def setUp(self):
+        """Init."""
+        super(PasswordLabeledEntryTestCase, self).setUp()
+        self.entry.is_password = True
+
+    def test_password_fields_are_visible_at_startup(self):
+        """Password entrys show the helping text at startup."""
+        self.assertTrue(self.entry.get_visibility(),
+                        'Password entry should be visible at start up.')
+
+    def test_password_field_is_visible_if_no_input_and_focus_out(self):
+        """Password entry show the label when focus out."""
+        self.grab_focus()  # user cliked or TAB'd to the entry
+        self.grab_focus(focus_in=False)  # loose focus
+        self.assertTrue(self.entry.get_visibility(),
+                        'Entry should be visible when focus out and no input.')
+
+    def test_password_fields_are_not_visible_when_editing(self):
+        """Password entrys show the hidden chars instead of the password."""
+        self.grab_focus()  # user cliked or TAB'd to the entry
+        self.assertFalse(self.entry.get_visibility(),
+                         'Entry should not be visible when editing.')
+
+
+class UbuntuSSOClientTestCase(BasicTestCase):
+    """Basic setup and helper functions."""
+
+    gui_class = gui.UbuntuSSOClientGUI
+    kwargs = dict(app_name=APP_NAME, tc_uri=TC_URI, help_text=HELP_TEXT)
+
+    def setUp(self):
+        """Init."""
+        super(UbuntuSSOClientTestCase, self).setUp()
+        self.patch(dbus, 'SessionBus', FakedSessionBus)
+        self.patch(dbus, 'Interface', FakedSSOBackend)
+        self.patch(socket, 'gethostname', lambda: TOKEN_NAME)
+        self.pages = ('enter_details', 'processing', 'verify_email', 'success',
+                      'tc_browser', 'login', 'reset_email', 'reset_password')
+        self.ui = self.gui_class(**self.kwargs)
+
+    def tearDown(self):
+        """Clean up."""
+        self.ui.bus.callbacks = {}
+        self.ui = None
+        super(UbuntuSSOClientTestCase, self).tearDown()
+
+    def assert_entries_are_packed_to_ui(self, container_name, entries):
+        """Every entry is properly packed in the ui 'container_name'."""
+        msg = 'Entry "%s" must be packed in "%s" but is not.'
+        container = getattr(self.ui, container_name)
+        for kind in entries:
+            name = '%s_entry' % kind
+            entry = getattr(self.ui, name)
+            self.assertIsInstance(entry, gui.LabeledEntry)
+            self.assertIn(entry, container, msg % (name, container_name))
+
+    def assert_warnings_visibility(self, visible=False):
+        """Every warning label should be 'visible'."""
+        msg = '"%s" should be %svisible.'
+        warnings = filter(lambda name: 'warning' in name, self.ui.widgets)
+        for name in warnings:
+            widget = getattr(self.ui, name)
+            self.assertEqual(visible, widget.get_property('visible'),
+                             msg % (name, '' if visible else 'not '))
+
+    def assert_correct_warning(self, label, message):
+        """Check that a warning is shown displaying 'message'."""
+        # warning label is visible
+        self.assertTrue(label.get_property('visible'))
+
+        # warning content is correct
+        actual = label.get_text()
+        self.assertEqual(actual, message)
+
+        # content color is correct
+        expected = gui.WARNING_TEXT_COLOR
+        actual = label.style.fg[gtk.STATE_NORMAL]
+        self.assertEqual(expected, actual)  # until realized this will fail
+
+    def assert_pages_visibility(self, **kwargs):
+        """The pages has the correct visibility."""
+        for i in self.pages:
+            kwargs.setdefault(i, False)
+
+        msg = 'page %r must %sbe visible.'
+        for name, expected in kwargs.iteritems():
+            page = getattr(self.ui, '%s_vbox' % name)
+            actual = page.get_property('visible')
+            self.assertEqual(expected, actual,
+                             msg % (name, '' if expected else 'not '))
+
+    def click_join_with_valid_data(self):
+        """Move to the next page after entering details."""
+        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)  # we have captcha!
+
+        self.ui.name_entry.set_text(NAME)
+        # match emails
+        self.ui.email1_entry.set_text(EMAIL)
+        self.ui.email2_entry.set_text(EMAIL)
+        # match passwords
+        self.ui.password1_entry.set_text(PASSWORD)
+        self.ui.password2_entry.set_text(PASSWORD)
+        # agree to TC
+        self.ui.yes_to_tc_checkbutton.set_active(True)
+        # resolve captcha properly
+        self.ui.captcha_solution_entry.set_text(CAPTCHA_SOLUTION)
+
+        self.ui.join_ok_button.clicked()
+
+    def click_verify_email_with_valid_data(self):
+        """Move to the next page after entering email token."""
+        self.click_join_with_valid_data()
+
+        # resolve email token properly
+        self.ui.email_token_entry.set_text(EMAIL_TOKEN)
+
+        self.ui.verify_token_button.clicked()
+
+    def click_connect_with_valid_data(self):
+        """Move to the next page."""
+        # enter email
+        self.ui.login_email_entry.set_text(EMAIL)
+        # enter password
+        self.ui.login_password_entry.set_text(PASSWORD)
+
+        self.ui.login_ok_button.clicked()
+
+
+class BasicUbuntuSSOClientTestCase(UbuntuSSOClientTestCase):
+    """Test suite for basic functionality."""
+
+    def test_main_window_is_visible_at_startup(self):
+        """The main window is shown at startup."""
+        self.assertTrue(self.ui.window.get_property('visible'))
+
+    def test_closing_main_window_calls_close_callback(self):
+        """The close_callback is called when closing the main window."""
+        self.ui.close_callback = self._set_called
+        self.ui.on_close_clicked()
+        self.assertTrue(self._called,
+                        'close_callback was called when window was closed.')
+
+    def test_app_name_is_stored(self):
+        """The app_name is stored for further use."""
+        self.assertIn(APP_NAME, self.ui.app_name)
+
+    def test_session_bus_is_correct(self):
+        """The session bus is created and is correct."""
+        self.assertIsInstance(self.ui.bus, FakedSessionBus)
+
+    def test_iface_name_is_correct(self):
+        """The session bus is created and is correct."""
+        self.assertEqual(self.ui.iface_name, gui.DBUS_IFACE_USER_NAME)
+
+    def test_bus_object_is_created(self):
+        """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,
+                        bus_name=gui.DBUS_BUS_NAME,
+                        follow_name_owner_changes=True)
+        self.assertEqual(expected, self.ui.bus.obj._kwargs)
+
+    def test_bus_interface_is_created(self):
+        """dbus.Interface is called properly."""
+        self.assertIsInstance(self.ui.backend, FakedSSOBackend)
+        self.assertEqual(self.ui.backend._args, ())
+        expected = dict(object=self.ui.bus.obj,
+                        dbus_interface=gui.DBUS_IFACE_USER_NAME)
+        self.assertEqual(expected, self.ui.backend._kwargs)
+
+    def test_dbus_signals_are_removed(self):
+        """The hooked signals are removed at shutdown time."""
+        self.ui.bus.add_signal_receiver(gui.NO_OP, 'com.iface', 'signal_test')
+        assert len(self.ui.bus.callbacks) > 0  # at least one callback
+
+        self.ui.on_close_clicked()
+
+        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_window(self):
+        """All the pages are packed in the main window."""
+        children = self.ui.window.get_children()[0].get_children()
+        for page_name in self.pages:
+            page = getattr(self.ui, '%s_vbox' % page_name)
+            self.assertIn(page, children)
+
+    def test_initial_text_for_entries(self):
+        """Entries have the correct text at startup."""
+        msg = 'Text for "%s" must be "%s" (got "%s" instead).'
+        for name in self.ui.entries:
+            entry = getattr(self.ui, name)
+            expected = getattr(self.ui, name.upper())
+            actual = entry.label
+            # text content is correct
+            self.assertEqual(expected, actual, msg % (name, expected, actual))
+
+    def test_password_fields_are_password(self):
+        msg = '"%s" should be a password LabeledEntry instance.'
+        passwords = filter(lambda name: 'password' in name,
+                           self.ui.entries)
+        for name in passwords:
+            widget = getattr(self.ui, name)
+            self.assertTrue(widget.is_password, msg % name)
+
+    def test_warning_fields_are_hidden(self):
+        """Every warning label should be not visible."""
+        self.assert_warnings_visibility(visible=False)
+
+    def test_cancel_buttons_close_window(self):
+        """Every cancel button should close the window when clicked."""
+        msg = '"%s" should close the window when clicked.'
+        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)
+            widget = getattr(self.ui, name)
+            widget.clicked()
+            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())
+
+    def test_every_cancel_emits_proper_signal(self):
+        """Clicking on any cancel button, 'user-cancelation' signal is sent."""
+        msg = 'user-cancelation is emitted 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(gui.SIG_USER_CANCELATION, self._set_called)
+            widget = getattr(self.ui, name)
+            widget.clicked()
+            self.assertEqual(self._called, ((self.ui.window,), {}), msg % name)
+            self._called = False
+
+    def test_transient_window_is_None_if_window_id_is_zero(self):
+        """The transient window is correct."""
+        self.patch(gtk.gdk, 'window_foreign_new', self._set_called)
+        self.gui_class(window_id=0, **self.kwargs)
+        self.assertFalse(self._called, 'set_transient_for must not be called.')
+
+    def test_transient_window_is_correct(self):
+        """The transient window is correct."""
+        xid = 5
+        self.patch(gtk.gdk, 'window_foreign_new', self._set_called)
+        self.gui_class(window_id=xid, **self.kwargs)
+        self.assertTrue(self.memento.check(logging.ERROR, 'set_transient_for'))
+        self.assertTrue(self.memento.check(logging.ERROR, str(xid)))
+        self.assertEqual(self._called, ((xid,), {}))
+
+    def test_transient_window_accepts_negative_id(self):
+        """The transient window accepts a negative window id."""
+        xid = -5
+        self.patch(gtk.gdk, 'window_foreign_new', self._set_called)
+        self.gui_class(window_id=xid, **self.kwargs)
+        self.assertEqual(self._called, ((xid,), {}))
+
+
+class RegistrationEnterDetailsTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user registration (enter details page)."""
+
+    def test_initial_text_for_header_label(self):
+        """The header must have the correct text at startup."""
+        msg = 'Text for the header must be "%s" (got "%s" instead).'
+        expected = self.ui.JOIN_HEADER_LABEL % APP_NAME
+        actual = self.ui.header_label.get_text()
+        # text content is correct
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+    def test_entries_are_packed_to_ui(self):
+        """Every entry is properly packed in the ui."""
+        for kind in ('email', 'password'):
+            container_name = '%ss_hbox' % kind
+            entries = ('%s%s' % (kind, i) for i in xrange(1, 3))
+            self.assert_entries_are_packed_to_ui(container_name, entries)
+
+        self.assert_entries_are_packed_to_ui('enter_details_vbox', ('name',))
+        self.assert_entries_are_packed_to_ui('captcha_solution_vbox',
+                                             ('captcha_solution',))
+        self.assert_entries_are_packed_to_ui('verify_email_vbox',
+                                             ('email_token',))
+
+    def test_initial_texts_for_checkbuttons(self):
+        """Check buttons have the correct text at startup."""
+        msg = 'Text for "%s" must be "%s" (got "%s" instead).'
+        expected = self.ui.YES_TO_UPDATES
+        actual = self.ui.yes_to_updates_checkbutton.get_label()
+        self.assertEqual(expected, actual, msg % ('yes_to_updates_checkbutton',
+                                                  expected, actual))
+        expected = self.ui.YES_TO_TC
+        actual = self.ui.yes_to_tc_checkbutton.get_label()
+        self.assertEqual(expected, actual,
+                         msg % ('yes_to_tc_checkbutton', expected, actual))
+
+    def test_checkbuttons_are_checked_at_startup(self):
+        """Checkbuttons are checked by default."""
+        msg = '"%s" is checked by default.'
+        for name in ('yes_to_updates_checkbutton', 'yes_to_tc_checkbutton'):
+            widget = getattr(self.ui, name)
+            self.assertTrue(widget.get_active(), msg % name)
+
+    def test_vboxes_visible_properties(self):
+        """Only 'enter_details' vbox is visible at start up."""
+        self.assert_pages_visibility(enter_details=True)
+
+    def test_join_ok_button_clicked(self):
+        """Clicking 'join_ok_button' sends info to backend using 'register'."""
+        self.click_join_with_valid_data()
+
+        # assert register_user was called
+        expected = 'register_user'
+        self.assertIn(expected, self.ui.backend._called)
+        self.assertEqual(self.ui.backend._called[expected],
+                         ((EMAIL, PASSWORD, CAPTCHA_ID, CAPTCHA_SOLUTION),
+                          dict(reply_handler=gui.NO_OP,
+                               error_handler=gui.NO_OP)))
+
+    def test_join_ok_button_clicked_morphs_to_processing_page(self):
+        """Clicking 'join_ok_button' presents the processing vbox."""
+        self.click_join_with_valid_data()
+        self.assert_pages_visibility(processing=True)
+
+    def test_processing_vbox_displays_an_active_spinner(self):
+        """When processing the registration, an active spinner is shown."""
+        self.click_join_with_valid_data()
+
+        self.assertTrue(self.ui.processing_vbox.get_property('visible'),
+                        'the processing box should be visible.')
+
+        box = self.ui.processing_vbox.get_children()[0].get_children()[0]
+        self.assertEqual(2, len(box.get_children()),
+                         'processing_vbox must have two children.')
+
+        spinner, label = box.get_children()
+        self.assertIsInstance(spinner, gtk.Spinner)
+        self.assertIsInstance(label, gtk.Label)
+
+        self.assertTrue(spinner.get_property('visible'),
+                        'the processing spinner should be visible.')
+        self.assertTrue(spinner.get_property('active'),
+                        'the processing spinner should be active.')
+        self.assertTrue(label.get_property('visible'),
+                        'the processing label should be visible.')
+        self.assertEqual(label.get_text(), self.ui.ONE_MOMENT_PLEASE,
+                        'the processing label text must be correct.')
+
+    def test_captcha_image_is_not_visible_at_startup(self):
+        """Captcha image is not shown at startup."""
+        self.assertFalse(self.ui.captcha_image.get_property('visible'),
+                        'the captcha_image should not be visible.')
+
+    def test_captcha_filename_is_different_each_time(self):
+        """The captcha image is different each time."""
+        ui = self.gui_class(**self.kwargs)
+        self.assertNotEqual(self.ui._captcha_filename, ui._captcha_filename)
+
+    def test_captcha_image_is_removed_when_exiting(self):
+        """The captcha image is removed at shutdown time."""
+        open(self.ui._captcha_filename, 'w').close()
+        assert os.path.exists(self.ui._captcha_filename)
+        self.ui.on_close_clicked()
+
+        self.assertFalse(os.path.exists(self.ui._captcha_filename),
+                         'captcha image must be removed when exiting.')
+
+    def test_captcha_image_is_a_spinner_at_first(self):
+        """Captcha image shows a spinner until the image is downloaded."""
+        self.assertTrue(self.ui.captcha_loading.get_property('visible'),
+                        'the captcha_loading box should be visible.')
+
+        box = self.ui.captcha_loading.get_children()[0].get_children()[0]
+        self.assertEqual(2, len(box.get_children()),
+                         'captcha_loading must have two children.')
+
+        spinner, label = box.get_children()
+        self.assertIsInstance(spinner, gtk.Spinner)
+        self.assertIsInstance(label, gtk.Label)
+
+        self.assertTrue(spinner.get_property('visible'),
+                        'the captcha_loading spinner should be visible.')
+        self.assertTrue(spinner.get_property('active'),
+                        'the captcha_loading spinner should be active.')
+        self.assertTrue(label.get_property('visible'),
+                        'the captcha_loading label should be visible.')
+        self.assertEqual(label.get_text(), self.ui.LOADING,
+                        'the captcha_loading label text must be correct.')
+
+    def test_join_ok_button_is_disabled_until_captcha_is_available(self):
+        """The join_ok_button is not sensitive until captcha is available."""
+        self.assertFalse(self.ui.join_ok_button.is_sensitive())
+
+    def test_join_ok_button_is_enabled_when_captcha_is_available(self):
+        """The join_ok_button is sensitive when captcha is available."""
+        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.assertTrue(self.ui.join_ok_button.is_sensitive())
+
+    def test_captcha_loading_is_hid_when_captcha_is_available(self):
+        """The captcha_loading is hid when captcha is available."""
+        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.assertFalse(self.ui.captcha_loading.get_property('visible'),
+                         'captcha_loading is not visible.')
+
+    def test_captcha_id_is_stored_when_captcha_is_available(self):
+        """The captcha_id is stored when captcha is available."""
+        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.assertEqual(CAPTCHA_ID, self.ui._captcha_id)
+
+    def test_captcha_image_is_requested_as_startup(self):
+        """The captcha image is requested at startup."""
+        # assert generate_captcha was called
+        expected = 'generate_captcha'
+        self.assertIn(expected, self.ui.backend._called)
+        self.assertEqual(self.ui.backend._called[expected],
+                         ((self.ui._captcha_filename,),
+                          dict(reply_handler=gui.NO_OP,
+                               error_handler=gui.NO_OP)))
+
+    def test_captcha_is_shown_when_available(self):
+        """The captcha image is shown when available."""
+        self.patch(self.ui.captcha_image, 'set_from_file', self._set_called)
+        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.assertTrue(self.ui.captcha_image.get_property('visible'))
+        self.assertEqual(self._called, ((self.ui._captcha_filename,), {}))
+
+    def test_login_button_has_correct_wording(self):
+        """The sign in button has the proper wording."""
+        actual = self.ui.login_button.get_label()
+        self.assertEqual(self.ui.LOGIN_BUTTON_LABEL, actual)
+
+
+class TermsAndConditionsTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user registration (terms & conditions page)."""
+
+    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_back_clicked_returns_to_previous_page(self):
+        """Terms & Conditions back button return to previous page."""
+        self.ui.tc_button.clicked()
+        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)
+
+    def test_tc_browser_opens_the_proper_uri(self):
+        """Terms & Conditions browser shows the proper uri."""
+        self.ui.tc_button.clicked()
+        self.assertEqual(self.ui.tc_browser.get_property('uri'), TC_URI)
+    test_tc_browser_opens_the_proper_uri.skip = 'The freaking test wont work.'
+
+
+class UserRegistrationErrorTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user registration error handling."""
+
+    def setUp(self):
+        """Init."""
+        super(UserRegistrationErrorTestCase, self).setUp()
+        self.click_join_with_valid_data()
+        self.ui.on_user_registration_error()
+
+    def test_previous_page_is_shown(self):
+        """On UserRegistrationError the previous page is shown."""
+        self.assert_pages_visibility(enter_details=True)
+
+    def test_warning_label_is_shown(self):
+        """On UserRegistrationError the warning label is shown."""
+        self.assert_correct_warning(self.ui.warning_label,
+                                    self.ui.UNKNOWN_ERROR)
+
+    def test_proper_signal_is_emitted(self):
+        """On UserRegistrationError, 'registration-failed' signal is sent."""
+        self.ui.connect(gui.SIG_REGISTRATION_FAILED, self._set_called)
+        self.ui.on_user_registration_error()
+        self.assertEqual(((self.ui.window,), {}), self._called)
+
+
+class VerifyEmailTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user registration (verify email page)."""
+
+    def test_verify_email_image_is_correct(self):
+        """The email-example image is shown."""
+        pixbuf = self.ui.verify_email_image.get_pixbuf()
+        self.assertTrue(pixbuf is not None)
+        self.assertEqual(self.ui._email_example_pixbuf, pixbuf)
+
+    def test_registration_successful_shows_verify_email_vbox(self):
+        """Receiving 'registration_successful' shows the verify email vbox."""
+        self.ui.on_user_registered()
+        self.assert_pages_visibility(verify_email=True)
+
+    def test_help_label_display_correct_wording(self):
+        """The help_label display VERIFY_EMAIL_LABEL."""
+        self.ui.on_user_registered()
+        msg = 'help_label must read "%s" (got "%s" instead).'
+        actual = self.ui.help_label.get_text()
+        expected = self.ui.VERIFY_EMAIL_LABEL
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+    def test_on_verify_token_button_clicked_calls_validate_email(self):
+        """Verify token button triggers call to backend."""
+        self.click_verify_email_with_valid_data()
+        expected = 'validate_email'
+        self.assertIn(expected, self.ui.backend._called)
+        self.assertEqual(self.ui.backend._called[expected],
+                         ((EMAIL, PASSWORD, APP_NAME, EMAIL_TOKEN),
+                          dict(reply_handler=gui.NO_OP,
+                               error_handler=gui.NO_OP)))
+
+    def test_on_verify_token_button_shows_processing_page(self):
+        """Verify token button triggers call to backend."""
+        self.click_verify_email_with_valid_data()
+        self.assert_pages_visibility(processing=True)
+
+    def test_no_warning_messages_if_valid_data_on_verify_token(self):
+        """No warning messages are shown if the data is valid."""
+        # this will certainly NOT generate warnings
+        self.click_verify_email_with_valid_data()
+        self.assert_warnings_visibility(visible=False)
+
+    def test_on_email_validated_shows_success_page(self):
+        """On email validated the success page is shown."""
+        self.ui.on_email_validated(APP_NAME)
+        self.assert_pages_visibility(success=True)
+
+    def test_on_email_validated_clears_the_help_text(self):
+        """On email validated the help text is removed."""
+        self.ui.on_email_validated(APP_NAME)
+        self.assertEqual('', self.ui.help_label.get_text())
+    test_on_email_validated_clears_the_help_text.skip = 'Maybe this is wrong.'
+
+    def test_on_email_validated_proper_signals_is_emitted(self):
+        """On email validated, 'registration-succeeded' signal is sent."""
+        self.ui.connect(gui.SIG_REGISTRATION_SUCCEEDED, self._set_called)
+        self.ui.on_email_validated(APP_NAME)
+        self.assertEqual(((self.ui.window, APP_NAME), {}), self._called)
+
+    def test_on_email_validation_error_proper_signals_is_emitted(self):
+        """On email validation error, 'registration-failed' signal is sent."""
+        self.ui.connect(gui.SIG_REGISTRATION_FAILED, self._set_called)
+        self.ui.on_email_validation_error()
+        self.assertEqual(((self.ui.window,), {}), self._called)
+
+    def test_success_label_is_correct(self):
+        """The success message is correct."""
+        self.assertEqual(self.ui.SUCCESS, self.ui.success_label.get_text())
+        markup = self.ui.success_label.get_label()
+        self.assertTrue('<span size="x-large">' in markup)
+
+    def test_on_success_close_button_clicked_closes_window(self):
+        """When done the window is closed."""
+        self.ui.success_close_button.clicked()
+        self.assertFalse(self.ui.window.get_property('visible'))
+
+
+class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user registration  validations."""
+
+    def test_warning_is_shown_if_name_empty(self):
+        """A warning message is shown if name is empty."""
+        self.ui.name_entry.set_text('')
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.name_warning_label,
+                                    self.ui.FIELD_REQUIRED)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_empty_email(self):
+        """A warning message is shown if emails are empty."""
+        self.ui.email1_entry.set_text('')
+        self.ui.email2_entry.set_text('')
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.email_warning_label,
+                                    self.ui.FIELD_REQUIRED)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_email_mismatch(self):
+        """A warning message is shown if emails doesn't match."""
+        self.ui.email1_entry.set_text(EMAIL)
+        self.ui.email2_entry.set_text(EMAIL * 2)
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.email_warning_label,
+                                    self.ui.EMAIL_MISMATCH)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_invalid_email(self):
+        """A warning message is shown if email is invalid."""
+        self.ui.email1_entry.set_text('q')
+        self.ui.email2_entry.set_text('q')
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.email_warning_label,
+                                    self.ui.EMAIL_INVALID)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_password_help_is_always_shown(self):
+        """Password help text is correctly displayed."""
+        self.assertTrue(self.ui.password_help_label.get_property('visible'),
+                        'password help text is visible.')
+        self.assertEqual(self.ui.password_help_label.get_text(),
+                         self.ui.PASSWORD_HELP)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_password_mismatch(self):
+        """A warning message is shown if password doesn't match."""
+        self.ui.password1_entry.set_text(PASSWORD)
+        self.ui.password2_entry.set_text(PASSWORD * 2)
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.password_warning_label,
+                                    self.ui.PASSWORD_MISMATCH)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_password_too_weak(self):
+        """A warning message is shown if password is too weak."""
+        # password will match but will be too weak
+        for w in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
+            self.ui.password1_entry.set_text(w)
+            self.ui.password2_entry.set_text(w)
+
+            self.ui.join_ok_button.clicked()  # submit form
+
+            self.assert_correct_warning(self.ui.password_warning_label,
+                                        self.ui.PASSWORD_TOO_WEAK)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_tc_not_accepted(self):
+        """A warning message is shown if TC are not accepted."""
+        # don't agree to TC
+        self.ui.yes_to_tc_checkbutton.set_active(False)
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.tc_warning_label,
+                                    self.ui.TC_NOT_ACCEPTED)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_warning_is_shown_if_not_captcha_solution(self):
+        """A warning message is shown if TC are not accepted."""
+        # captcha solution will be empty
+        self.ui.captcha_solution_entry.set_text('')
+
+        self.ui.join_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.captcha_solution_warning_label,
+                                    self.ui.FIELD_REQUIRED)
+        self.assertNotIn('register_user', self.ui.backend._called)
+
+    def test_no_warning_messages_if_valid_data_on_enter_details(self):
+        """No warning messages are shown if the data is valid."""
+        # this will certainly NOT generate warnings
+        self.click_join_with_valid_data()
+
+        self.assert_warnings_visibility(visible=False)
+
+    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
+        """No warnings if the data is valid (with prior invalid data)."""
+        # this will certainly generate warnings
+        self.ui.join_ok_button.clicked()
+
+        # this will certainly NOT generate warnings
+        self.click_join_with_valid_data()
+
+        self.assert_warnings_visibility(visible=False)
+
+
+class LoginTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user login pages."""
+
+    def setUp(self):
+        """Init."""
+        super(LoginTestCase, self).setUp()
+        self.ui.login_button.clicked()
+
+    def test_login_button_clicked_morphs_to_login_page(self):
+        """Clicking sig_in_button morphs window into login page."""
+        self.assert_pages_visibility(login=True)
+
+    def test_initial_text_for_header_label(self):
+        """The header must have the correct text when logging in."""
+        msg = 'Text for the header must be "%s" (got "%s" instead).'
+        expected = self.ui.LOGIN_HEADER_LABEL % APP_NAME
+        actual = self.ui.header_label.get_text()
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+    def test_initial_text_for_help_label(self):
+        """The help must have the correct text at startup."""
+        msg = 'Text for the help must be "%s" (got "%s" instead).'
+        expected = self.ui.CONNECT_HELP_LABEL % APP_NAME
+        actual = self.ui.help_label.get_text()
+        self.assertEqual(expected, actual, msg % (expected, actual))
+
+    def test_entries_are_packed_to_ui_for_login(self):
+        """Every entry is properly packed in the ui for the login page."""
+        entries = ('login_email', 'login_password')
+        self.assert_entries_are_packed_to_ui('login_details_vbox', entries)
+
+    def test_entries_are_packed_to_ui_for_reset_password(self):
+        """Every entry is packed in the ui for the reset password page."""
+        entries = ('reset_code', 'reset_password1', 'reset_password2')
+        self.assert_entries_are_packed_to_ui('reset_password_details_vbox',
+                                             entries)
+
+    def test_entries_are_packed_to_ui_for_reset_email(self):
+        """Every entry is packed in the ui for the reset email page."""
+        entries = ('reset_email',)
+        self.assert_entries_are_packed_to_ui('reset_email_details_vbox',
+                                             entries)
+
+    def test_on_login_back_button_clicked(self):
+        """Clicking login_back_button show registration screen."""
+        self.ui.login_back_button.clicked()
+        self.assert_pages_visibility(enter_details=True)
+
+    def test_on_login_connect_button_clicked(self):
+        """Clicking login_ok_button calls backend.login."""
+        self.click_connect_with_valid_data()
+
+        expected = 'login'
+        self.assertIn(expected, self.ui.backend._called)
+        self.assertEqual(self.ui.backend._called[expected],
+                         ((EMAIL, PASSWORD, APP_NAME),
+                          dict(reply_handler=gui.NO_OP,
+                               error_handler=gui.NO_OP)))
+
+    def test_on_login_connect_button_clicked_morphs_to_processing_page(self):
+        """Clicking login_ok_button morphs to the processing page."""
+        self.click_connect_with_valid_data()
+        self.assert_pages_visibility(processing=True)
+
+    def test_on_logged_in_proper_signals_is_emitted(self):
+        """On user logged in, 'login-succeeded' signal is sent."""
+        self.ui.connect(gui.SIG_LOGIN_SUCCEEDED, self._set_called)
+        self.ui.on_logged_in(APP_NAME)
+        self.assertEqual(((self.ui.window, APP_NAME), {}), self._called)
+
+    def test_on_logged_in_morphs_to_success_page(self):
+        """On user logged in, the success page is shown."""
+        self.click_connect_with_valid_data()
+        self.ui.on_logged_in(APP_NAME)
+        self.assert_pages_visibility(success=True)
+
+    def test_on_login_error_morphs_to_login_page(self):
+        """On user login error, the previous page is shown."""
+        self.click_connect_with_valid_data()
+        self.ui.on_login_error()
+        self.assert_pages_visibility(login=True)
+
+    def test_on_login_error_a_warning_is_shown(self):
+        """On user login error, a warning is shown with proper wording."""
+        self.click_connect_with_valid_data()
+        self.ui.on_login_error()
+        self.assert_correct_warning(self.ui.warning_label,
+                                    self.ui.UNKNOWN_ERROR)
+
+    def test_back_to_registration_hides_warning(self):
+        """After user login error, warning is hidden when clicking 'Back'."""
+        self.click_connect_with_valid_data()
+        self.ui.on_login_error()
+        self.ui.login_back_button.clicked()
+        self.assertFalse(self.ui.warning_label.get_property('visible'))
+
+    def test_on_email_validation_error_proper_signals_is_emitted(self):
+        """On user login error, 'login-failed' signal is sent."""
+        self.ui.connect(gui.SIG_LOGIN_FAILED, self._set_called)
+        self.click_connect_with_valid_data()
+        self.ui.on_login_error()
+        self.assertEqual(((self.ui.window,), {}), self._called)
+
+
+class LoginValidationTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the user login validation."""
+
+    def setUp(self):
+        """Init."""
+        super(LoginValidationTestCase, self).setUp()
+        self.ui.login_button.clicked()
+
+    def test_warning_is_shown_if_empty_email(self):
+        """A warning message is shown if email is empty."""
+        self.ui.login_email_entry.set_text('')
+
+        self.ui.login_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.login_email_warning_label,
+                                    self.ui.FIELD_REQUIRED)
+        self.assertNotIn('login', self.ui.backend._called)
+
+    def test_warning_is_shown_if_invalid_email(self):
+        """A warning message is shown if email is invalid."""
+        self.ui.login_email_entry.set_text('q')
+
+        self.ui.login_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.login_email_warning_label,
+                                    self.ui.EMAIL_INVALID)
+        self.assertNotIn('login', self.ui.backend._called)
+
+    def test_warning_is_shown_if_empty_password(self):
+        """A warning message is shown if password is empty."""
+        self.ui.login_password_entry.set_text('')
+
+        self.ui.login_ok_button.clicked()  # submit form
+
+        self.assert_correct_warning(self.ui.login_password_warning_label,
+                                    self.ui.FIELD_REQUIRED)
+        self.assertNotIn('login', self.ui.backend._called)
+
+    def test_no_warning_messages_if_valid_data(self):
+        """No warning messages are shown if the data is valid."""
+        # this will certainly NOT generate warnings
+        self.click_connect_with_valid_data()
+
+        self.assert_warnings_visibility(visible=False)
+
+    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
+        """No warnings if the data is valid (with prior invalid data)."""
+        # this will certainly generate warnings
+        self.ui.login_ok_button.clicked()
+
+        # this will certainly NOT generate warnings
+        self.click_connect_with_valid_data()
+
+        self.assert_warnings_visibility(visible=False)
+
+
+class ResetPasswordTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the reset password functionality."""
+
+    def setUp(self):
+        """Init."""
+        super(ResetPasswordTestCase, self).setUp()
+        self.ui.login_button.clicked()
+        self.ui.forgotten_password_button.clicked()
+
+    def test_forgotten_password_button_has_the_proper_wording(self):
+        """The forgotten_password_button has the proper wording."""
+        self.assertEqual(self.ui.forgotten_password_button.get_label(),
+                         self.ui.FORGOTTEN_PASSWORD_BUTTON)
+
+    def test_on_forgotten_password_button_clicked_help_text(self):
+        """Clicking forgotten_password_button the help is properly changed."""
+        self.assertEqual(self.ui.help_label.get_text(),
+                         self.ui.RESET_EMAIL_LABEL)
+
+    def test_on_forgotten_password_button_clicked_header_label(self):
+        """Clicking forgotten_password_button the title is properly changed."""
+        self.assertEqual(self.ui.header_label.get_text(),
+                         self.ui.RESET_PASSWORD)
+
+    def test_on_forgotten_password_button_clicked_ok_button(self):
+        """Clicking forgotten_password_button the ok button reads 'Next'."""
+        self.assertEqual(self.ui.reset_email_ok_button.get_label(),
+                         self.ui.NEXT)
+
+    def test_on_forgotten_password_button_clicked_morphs_window(self):
+        """Clicking forgotten_password_button the proper page is shown."""
+        self.assert_pages_visibility(reset_email=True)
+
+    def test_on_reset_email_back_button_clicked(self):
+        """Clicking reset_email_back_button show login screen."""
+        self.ui.reset_email_back_button.clicked()
+        self.assert_pages_visibility(login=True)
+
+    def test_on_reset_email_ok_button_disabled_until_email_added(self):
+        """The reset_email_ok_button is disabled until email added."""
+        self.assertFalse(self.ui.reset_email_ok_button.get_sensitive())
+
+        self.ui.reset_email_entry.set_text('a')
+        self.assertTrue(self.ui.reset_email_ok_button.get_sensitive())
+
+        self.ui.reset_email_entry.set_text('')
+        self.assertFalse(self.ui.reset_email_ok_button.get_sensitive())
+
+        self.ui.reset_email_entry.set_text('         ')
+        self.assertFalse(self.ui.reset_email_ok_button.get_sensitive())
+
+    def test_on_reset_email_ok_button_clicked_help_text(self):
+        """Clicking reset_email_ok_button the help is properly changed."""
+        expected = '[e-mail]'
+        self.ui.reset_email_entry.set_text(expected)
+        self.ui.reset_email_ok_button.clicked()
+
+        self.assertEqual(self.ui.help_label.get_text(),
+                         self.ui.RESET_PASSWORD_LABEL % expected)
+
+    def test_on_reset_email_ok_button_clicked_ok_button(self):
+        """Clicking reset_email_ok_button the ok button reads 'Next'."""
+        self.ui.reset_email_ok_button.clicked()
+
+        self.assertEqual(self.ui.reset_password_ok_button.get_label(),
+                         self.ui.RESET_PASSWORD)
+
+    def test_on_reset_email_ok_button_clicked_morphs_window(self):
+        """Clicking reset_email_ok_button the proper page is shown."""
+        self.ui.reset_email_ok_button.clicked()
+        self.assert_pages_visibility(reset_password=True)
+
+    def test_on_reset_password_ok_button_disabled(self):
+        """The reset_password_ok_button is disabled until values added."""
+        self.ui.reset_email_ok_button.clicked()
+        self.assertFalse(self.ui.reset_password_ok_button.get_sensitive())
+
+        msg = 'reset_password_ok_button must be sensitive(%s) for entries %r.'
+        entries = (self.ui.reset_code_entry,
+                   self.ui.reset_password1_entry,
+                   self.ui.reset_password2_entry)
+        for xs in itertools.product(('', ' ', 'a'), repeat=3):
+            expected = True
+            for entry, x in zip(entries, xs):
+                entry.set_text(x)
+                expected &= bool(x and not x.isspace())
+
+            actual = self.ui.reset_password_ok_button.get_sensitive()
+            self.assertEqual(expected, actual, msg % (expected, xs))
+
+
+class DbusTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the dbus calls."""
+
+    def test_signal_receivers_are_connected(self):
+        """Callbacks are connected to signals of interest."""
+        msg1 = 'callback %r for signal %r must be added to the internal bus.'
+        msg2 = 'callback %r for signal %r must be added to the ui log.'
+        for dbus_iface, signal, method in self.ui._signals:
+            actual = self.ui.bus.callbacks.get((dbus_iface, signal))
+            self.assertEqual(method, actual, msg1 % (method, signal))
+            actual = self.ui._signals_receivers.get((dbus_iface, signal))
+            self.assertEqual(method, actual, msg2 % (method, signal))

=== added file 'ubuntu_sso/tests/test_login.py'
--- ubuntu_sso/tests/test_login.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/test_login.py	2010-08-11 18:19:01 +0000
@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Rodney Dawes <[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 ubuntuone-login script """
+
+import dbus.service
+import new
+import os
+
+from contrib.testing.testcase import DBusTestCase, FakeLogin
+from twisted.internet import defer
+from twisted.python.failure import Failure
+
+
+class InvalidSignalError(Exception):
+    """Exception for when we get the wrong signal called."""
+    pass
+
+
+class LoginTests(DBusTestCase):
+    """Basic tests for the ubuntuone-login script """
+
+    _path = os.path.join(os.getcwd(), "bin", "ubuntu-sso-login")
+    u1login = new.module('u1login')
+    execfile(_path, u1login.__dict__)
+
+    def setUp(self):
+        DBusTestCase.setUp(self)
+        self.oauth = FakeLogin(self.bus)
+
+    def tearDown(self):
+        # collect all signal receivers registered during the test
+        signal_receivers = set()
+        with self.bus._signals_lock:
+            for group in self.bus._signal_recipients_by_object_path.values():
+                for matches in group.values():
+                    for match in matches.values():
+                        signal_receivers.update(match)
+        d = self.cleanup_signal_receivers(signal_receivers)
+
+        def shutdown(r):
+            """Shutdown."""
+            self.oauth.shutdown()
+
+        d.addBoth(shutdown)
+        d.addBoth(lambda _: DBusTestCase.tearDown(self))
+        return d
+
+    def main(self):
+        """ Override LoginMain.main """
+        return
+
+    def test_new_credentials(self):
+        """ Test logging in """
+        def new_creds(realm=None, consumer_key=None, sender=None):
+            """ Override the callback """
+            d.callback(True)
+
+        def auth_denied():
+            """ Override the callback """
+            d.errback(Failure(InvalidSignalError()))
+
+        def got_oauth_error(message=None):
+            """ Override the callback """
+            d.errback(Failure(InvalidSignalError()))
+
+        def set_up_desktopcouch_pairing(consumer_key):
+            """ Override the method """
+            return
+
+        login = self.u1login.LoginMain()
+        login.main = self.main
+        login.new_credentials = new_creds
+        login.auth_denied = auth_denied
+        login.got_oauth_error = got_oauth_error
+        login.set_up_desktopcouch_pairing = set_up_desktopcouch_pairing
+
+        login._connect_dbus_signals()
+
+        client = self.bus.get_object(self.u1login.DBUS_IFACE_AUTH_NAME,
+                                     '/oauthdesktop',
+                                     follow_name_owner_changes=True)
+        d = defer.Deferred()
+
+        def login_handler():
+            """ login handler """
+            return
+
+        iface = dbus.Interface(client, self.u1login.DBUS_IFACE_AUTH_NAME)
+        iface.login('http://localhost', self.u1login.OAUTH_CONSUMER,
+                    reply_handler=login_handler,
+                    error_handler=self.error_handler)
+        return d
+
+    def test_auth_denied(self):
+        """ Test that denying authorization works correctly. """
+
+        def new_creds(realm=None, consumer_key=None, sender=None):
+            """ Override the callback """
+            d.errback(Failure(InvalidSignalError()))
+
+        def auth_denied():
+            """ Override the callback """
+            d.callback(True)
+
+        def got_oauth_error(message=None):
+            """ override the callback """
+            d.errback(Failure(InvalidSignalError()))
+
+        login = self.u1login.LoginMain()
+        login.main = self.main
+        login.new_credentials = new_creds
+        login.auth_denied = auth_denied
+        login.got_oauth_error = got_oauth_error
+
+        login._connect_dbus_signals()
+
+        self.oauth.processor.next_login_with(self.oauth.processor.got_denial)
+
+        client = self.bus.get_object(self.u1login.DBUS_IFACE_AUTH_NAME,
+                                     '/oauthdesktop',
+                                     follow_name_owner_changes=True)
+        d = defer.Deferred()
+
+        def login_handler():
+            """ login handler """
+            return
+
+        iface = dbus.Interface(client, self.u1login.DBUS_IFACE_AUTH_NAME)
+        iface.login('http://localhost', self.u1login.OAUTH_CONSUMER,
+                    reply_handler=login_handler,
+                    error_handler=self.error_handler)
+        return d
+
+    def test_oauth_error(self):
+        """ Test that getting an error works correctly. """
+
+        def new_creds(realm=None, consumer_key=None, sender=None):
+            """ Override the callback """
+            d.errback(Failure(InvalidSignalError()))
+
+        def auth_denied():
+            """ Override the callback """
+            d.errback(Failure(InvalidSignalError()))
+
+        def got_oauth_error(message=None):
+            """ override the callback """
+            d.callback(True)
+
+        login = self.u1login.LoginMain()
+        login.main = self.main
+        login.new_credentials = new_creds
+        login.auth_denied = auth_denied
+        login.got_oauth_error = got_oauth_error
+
+        login._connect_dbus_signals()
+
+        self.oauth.processor.next_login_with(self.oauth.processor.got_error,
+                                             ('error!',))
+
+        client = self.bus.get_object(self.u1login.DBUS_IFACE_AUTH_NAME,
+                                     '/oauthdesktop',
+                                     follow_name_owner_changes=True)
+        d = defer.Deferred()
+
+        def login_handler():
+            """ login handler """
+            return
+
+        iface = dbus.Interface(client, self.u1login.DBUS_IFACE_AUTH_NAME)
+        iface.login('http://localhost', self.u1login.OAUTH_CONSUMER,
+                    reply_handler=login_handler,
+                    error_handler=self.error_handler)
+        return d

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/tests/test_main.py	2010-08-11 18:19:01 +0000
@@ -1,8 +1,10 @@
 # test_main - tests for ubuntu_sso.main
 #
 # Author: Stuart Langridge <[e-mail]>
+# Author: Natalia Bidart <[e-mail]>
+# Author: Alejandro J. Cura <[e-mail]>
 #
-# Copyright 2009 Canonical Ltd.
+# 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
@@ -15,29 +17,317 @@
 #
 # 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 OAuth client code for StorageFS."""
-
-import os, StringIO
-from mocker import MockerTestCase
-from ubuntu_sso import config
-from ubuntu_sso.main import LoginProcessor, BadRealmError
+"""Tests for the OAuth client code."""
+
+import logging
+import os
+import StringIO
+
+import gobject
+
+from lazr.restfulclient.errors import HTTPError
+from mocker import Mocker, MockerTestCase, ARGS, KWARGS
+from twisted.internet.defer import Deferred
+from twisted.trial.unittest import TestCase
+
+import ubuntu_sso.main
+
+from contrib.testing.testcase import MementoHandler
+from ubuntu_sso import config, gui
+from ubuntu_sso.main import (
+    AuthenticationError, BadRealmError, blocking, EmailTokenError,
+    InvalidEmailError, InvalidPasswordError, SSOLogin, SSOCredentials,
+    get_token_name, keyring_get_credentials, keyring_store_credentials, logger,
+    LoginProcessor, NewPasswordError, SSOLoginProcessor, RegistrationError,
+    ResetPasswordTokenError)
+
+
+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_TOKEN = 'B2Pgtf'
+HELP = 'help text'
+PASSWORD = 'be4tiFul'
+RESET_PASSWORD_TOKEN = '8G5Wtq'
+TOKEN = {u'consumer_key': u'xQ7xDAz',
+         u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
+         u'name': u'test',
+         u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
+         u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
+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': '[e-mail]'}
+TC_URL = 'tcurl'
+WINDOW_ID = 5
+
+DEFAULT_ARGS = (APP_NAME, TC_URL, HELP, WINDOW_ID)
+
+
+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 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(get_token_name(APP_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
+        if 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,
+                                 app_name=APP_NAME)
+
+        def ksc(k, v):
+            self.assertEqual(k, APP_NAME)
+            self.assertEqual(v, TOKEN)
+
+        self.patch(ubuntu_sso.main, "keyring_store_credentials", ksc)
+
+    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)