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

[Natalia Bidart]

Bug fixes included on upstream versions 0.99.5 and 0.99.6.

[lp:~nataliabidart/ubuntu/maverick/ubuntu-sso-client/ubuntu-sso-client-0.99.6]

14. By Natalia Bidart on 2010-09-09

Fixing typos on pre/postinst.

[Ken VanDine (ken-vandine)]

Approve!

review: Approve

=== removed file 'MANIFEST.in'
--- MANIFEST.in	2010-08-26 01:07:41 +0000
+++ MANIFEST.in	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-include MANIFEST.in
-include COPYING README
-include run-tests
-recursive-include po *
-recursive-include bin *
-recursive-include data *
-recursive-include ubuntu_sso *.py
-recursive-include contrib *.py *.conf test

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-08-27 22:16:40 +0000
+++ PKG-INFO	2010-09-09 14:47:44 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 0.99.4
+Version: 0.99.6
 Summary: Ubuntu Single Sign-On client
 Home-page: https://launchpad.net/ubuntu-sso-client
 Author: Natalia Bidart
@@ -15,12 +15,9 @@
 Requires: gtk
 Requires: mocker
 Requires: oauth
-Requires: testresources
 Requires: twisted.internet
 Requires: twisted.python
 Requires: twisted.trial.unittest
-Requires: twisted.web
 Requires: webkit
 Requires: xdg
-Requires: zope.interface
 Provides: ubuntu_sso

=== removed file 'bin/show_nm_state'
--- bin/show_nm_state	2010-08-24 15:47:58 +0000
+++ bin/show_nm_state	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-#!/usr/bin/python
-
-# 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-08-24 15:47:58 +0000
+++ bin/ubuntu-sso-login	2010-09-09 14:47:44 +0000
@@ -3,8 +3,9 @@
 # ubuntu-sso-login - Client side log-in utility for Ubuntu One
 #
 # Author: Rodney Dawes <[e-mail]>
+# Author: Natalia B. Bidart <[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
@@ -18,196 +19,41 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+"""Run the dbus service for UserManagement and ApplicationCredentials."""
+
 import gtk
-import pango
+import signal
 import sys
 
 import dbus.service
 
 from dbus.mainloop.glib import DBusGMainLoop
 
-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")
-
+from ubuntu_sso import DBUS_BUS_NAME, DBUS_CRED_PATH
+from ubuntu_sso.main import SSOLogin, SSOCredentials
+
+from ubuntu_sso.logger import setup_logging
+
+# Invalid name "ubuntu-sso-login"
+# pylint: disable=C0103
+
+
+logger = setup_logging("ubuntu-sso-login")
 gtk.gdk.threads_init()
 DBusGMainLoop(set_as_default=True)
 
-OAUTH_REALM = "https://ubuntuone.com"
-OAUTH_CONSUMER = "ubuntuone"
-
-NOTIFY_ICON_SIZE = 48
-
-# Why thank you GTK+ for enforcing style-set and breaking API
-RCSTYLE = """
-style 'dialogs' {
-  GtkDialog::action-area-border = 12
-  GtkDialog::button-spacing = 6
-  GtkDialog::content-area-border = 0
-}
-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):
-    """Main login manager process class."""
-
-    def __init__(self, *args, **kw):
-        """Initializes the child threads and dbus monitor."""
-        gtk.rc_parse_string(RCSTYLE)
-
-        logger.info("Starting Ubuntu SSO login manager")
-
-        self.__bus = dbus.SessionBus()
-
-    def _connect_dbus_signals(self):
-        """Set up some signal handlers for DBus signals."""
-        self.__bus.add_signal_receiver(
-              handler_function=self.new_credentials,
-              signal_name="NewCredentials",
-              dbus_interface=DBUS_IFACE_AUTH_NAME)
-        self.__bus.add_signal_receiver(
-              handler_function=self.auth_denied,
-              signal_name="AuthorizationDenied",
-              dbus_interface=DBUS_IFACE_AUTH_NAME)
-        self.__bus.add_signal_receiver(
-              handler_function=self.got_oauth_error,
-              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)
-
-        def got_port(*args, **kwargs):
-            # Discard the value.  We don't really care about the port, here.
-            pass
-
-        def got_error(*args, **kwargs):
-            logger.warn("On trying to start desktopcouch-service via DBus, "
-                    "we got an error.  %s %s" % (args, kwargs,))
-
-        # We have auth, so start desktopcouch service by asking for its port.
-        dc_serv_proxy = self.__bus.get_object("org.desktopcouch.CouchDB", "/")
-        dc_serv_proxy.getPort(reply_handler=got_port, error_handler=got_error)
-
-    def auth_denied(self):
-        """Signal callback for when auth was denied by user."""
-        logger.info("Access to Ubuntu One was denied.")
-
-        from twisted.internet import reactor
-        reactor.stop()
-
-    def got_oauth_error(self, message=None):
-        """Signal callback for when an OAuth error occured."""
-        def dialog_response(dialog, response):
-            """Handle the dialog closing."""
-            dialog.destroy()
-
-        if message:
-            logger.error(message)
-            dialog = gtk.Dialog(title="Ubuntu One: Error",
-                                flags=gtk.DIALOG_NO_SEPARATOR,
-                                buttons=(gtk.STOCK_CLOSE,
-                                         gtk.RESPONSE_CLOSE))
-            dialog.set_default_response(gtk.RESPONSE_CLOSE)
-            dialog.set_icon_name("ubuntu-sso-client")
-
-            area = dialog.get_content_area()
-
-            hbox = gtk.HBox(spacing=12)
-            hbox.set_border_width(12)
-            area.pack_start(hbox)
-            hbox.show()
-
-            image = gtk.Image()
-            image.set_from_icon_name("dialog-error", gtk.ICON_SIZE_DIALOG)
-            image.set_alignment(0.5, 0.0)
-            image.show()
-            hbox.pack_start(image, False, False)
-
-            vbox = gtk.VBox(spacing=12)
-            vbox.show()
-            hbox.pack_start(vbox)
-
-            label = gtk.Label("<b>Authorization Error</b>")
-            label.set_use_markup(True)
-            label.set_alignment(0.0, 0.5)
-            label.show()
-            vbox.pack_start(label, False, False)
-
-            label = gtk.Label(message)
-            label.set_line_wrap(True)
-            label.set_max_width_chars(64)
-            label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
-            label.set_alignment(0.0, 0.0)
-            label.show()
-            vbox.pack_start(label, True, True)
-
-            dialog.connect('close', dialog_response, gtk.RESPONSE_CLOSE)
-            dialog.connect('response', dialog_response)
-
-            dialog.show()
-        else:
-            logger.error("Got an OAuth error with no message.")
-
-    def set_up_desktopcouch_pairing(self, consumer_key):
-        """Add a pairing record between desktopcouch and Ubuntu One"""
-        try:
-            from desktopcouch.pair.couchdb_pairing.couchdb_io import \
-                 put_static_paired_service
-            from desktopcouch.records.server import CouchDatabase
-        except ImportError:
-            # desktopcouch is not installed
-            logger.debug("Not adding desktopcouch pairing since desktopcouch "
-                         "is not installed")
-            return
-        # Check whether there is already a record of the Ubuntu One service
-        db = CouchDatabase("management", create=True)
-        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
-        #   already an Ubuntu One pairing record, or 1, meaning that there
-        #   was an Ubuntu One pairing record but it has since been unpaired
-        # Only create a new record if there is not one already. Specifically,
-        #   do not add the record if there is a deleted one, as this means
-        #   that the user explicitly unpaired it!
-        for row in results:
-            found = True
-            if row.value == 1:
-                logger.debug("Not adding desktopcouch pairing since the user "
-                             "has explicitly unpaired with Ubuntu One")
-            else:
-                logger.debug("Not adding desktopcouch pairing since we are "
-                             "already paired")
-        if not found:
-            put_static_paired_service(None, "ubuntuone")
-            logger.debug("Pairing desktopcouch with Ubuntu One")
-
-    def main(self):
-        """Starts the gtk main loop."""
-        self._connect_dbus_signals()
-
-        from twisted.internet import reactor
-        reactor.run()
+
+def sighup_handler(*a, **kw):
+    """Stop the service.
+
+    This is not thread safe, see the link below for info:
+    www.listware.net/201004/gtk-devel-list/115067-unix-signals-in-glib.html
+    """
+    from twisted.internet import reactor
+    # Module 'twisted.internet.reactor' has no 'stop' member
+    # pylint: disable=E1101
+    logger.info("Stoping Ubuntu SSO login manager since SIGHUP was received.")
+    reactor.stop()
 
 
 if __name__ == "__main__":
@@ -216,19 +62,24 @@
     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"
+        logger.error("Ubuntu SSO login manager already running, quitting.")
         sys.exit(0)
 
+    logger.debug("Installing the Twisted gtk2reactor.")
     from twisted.internet import gtk2reactor
     gtk2reactor.install()
 
-    login = Login(dbus.service.BusName(DBUS_BUS_NAME,
-                                             bus=dbus.SessionBus()))
-    ssoLogin = SSOLogin(dbus.service.BusName(DBUS_BUS_NAME,
-                                             bus=dbus.SessionBus()))
+    logger.debug("Hooking up SIGHUP with handler %r.", sighup_handler)
+    signal.signal(signal.SIGHUP, sighup_handler)
+
+    logger.info("Starting Ubuntu SSO login manager for bus %r.", DBUS_BUS_NAME)
+    SSOLogin(dbus.service.BusName(DBUS_BUS_NAME,
+                                  bus=dbus.SessionBus()))
     SSOCredentials(dbus.service.BusName(DBUS_BUS_NAME,
                                         bus=dbus.SessionBus()),
                    object_path=DBUS_CRED_PATH)
 
-    manager = LoginMain()
-    manager.main()
+    from twisted.internet import reactor
+    # Module 'twisted.internet.reactor' has no 'run' member
+    # pylint: disable=E1101
+    reactor.run()

=== removed file 'bin/ubuntu-sso-login-gui'
--- bin/ubuntu-sso-login-gui	2010-08-24 15:47:58 +0000
+++ bin/ubuntu-sso-login-gui	1970-01-01 00:00:00 +0000
@@ -1,53 +0,0 @@
-#!/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
-import sys
-
-from ubuntu_sso.gui import UbuntuSSOClientGUI
-
-
-APP_NAME = 'Ubuntu'
-TC_URI = 'http://one.ubuntu.com/terms'
-HELP_TEXT = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
-            'Nam sed lorem nibh. Suspendisse gravida nulla non nunc suscipit' \
-            ' pulvinar tempus ut augue.'
-
-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
-
-    if len(sys.argv) > 1 and sys.argv[1] == '--login':
-        app = UbuntuSSOClientGUI(close_callback=main_quit, app_name=APP_NAME,
-                                 tc_uri=None, help_text=HELP_TEXT,
-                                 window_id=xid, login_only=True)
-    else:
-        app = UbuntuSSOClientGUI(close_callback=main_quit, app_name=APP_NAME,
-                                 tc_uri=TC_URI, help_text=HELP_TEXT,
-                                 window_id=xid)
-    gtk.main()

=== modified file 'contrib/dbus_util.py'
--- contrib/dbus_util.py	2010-08-24 15:47:58 +0000
+++ contrib/dbus_util.py	2010-09-09 14:47:44 +0000
@@ -1,7 +1,6 @@
 #
 # 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
@@ -15,6 +14,8 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+"""Utilies to run a separated DBus session."""
+
 import os
 import signal
 import subprocess
@@ -33,6 +34,9 @@
 
 
 class DBusRunner(object):
+    """A DBus runner."""
+
+    # pylint: disable=C0103
 
     def __init__(self):
         self.dbus_address = None

=== modified file 'contrib/test'
--- contrib/test	2010-06-22 14:18:04 +0000
+++ contrib/test	2010-09-09 14:47:44 +0000
@@ -32,7 +32,7 @@
 class TestRunner(object):
 
     def _load_unittest(self, relpath):
-        """Load unit tests from a Python module with the given relative path."""
+        """Load unittests from a Python module with the given relative path."""
         assert relpath.endswith(".py"), (
             "%s does not appear to be a Python module" % relpath)
         modpath = relpath.replace(os.path.sep, ".")[:-3]
@@ -53,7 +53,7 @@
         if test_pattern:
             pattern = re.compile('.*%s.*' % test_pattern)
         else:
-            pattern = None 
+            pattern = None
 
         if testpath:
             module_suite = self._load_unittest(testpath)
@@ -67,7 +67,7 @@
             return suite
 
         # We don't use the dirs variable, so ignore the warning
-        # pylint: disable-msg=W0612
+        # pylint: disable=W0612
         for root, dirs, files in os.walk("ubuntu_sso"):
             for file in files:
                 path = os.path.join(root, file)
@@ -130,9 +130,9 @@
     usage = '%prog [options] path'
     parser = OptionParser(usage=usage)
     parser.add_option("-t", "--test", dest="test",
-                  help = "run specific tests, e.g: className.methodName")
+                      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", 
+                      help="loop selected tests LOOPS number of times",
                       metavar="LOOPS")
 
     (options, args) = parser.parse_args()
@@ -143,4 +143,4 @@
             sys.exit()
     else:
         testpath = None
-    TestRunner().run(testpath, options.test, options.loops) 
+    TestRunner().run(testpath, options.test, options.loops)

=== modified file 'contrib/testing/__init__.py'
--- contrib/testing/__init__.py	2010-08-06 22:01:01 +0000
+++ contrib/testing/__init__.py	2010-09-09 14:47:44 +0000
@@ -1,1 +1,1 @@
-"""Testing utilities for Ubuntu One client code."""
+"""Testing utilities for Ubuntu SSO code."""

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-08-11 14:11:57 +0000
+++ contrib/testing/testcase.py	2010-09-09 14:47:44 +0000
@@ -1,5 +1,6 @@
 #
 # Author: Guillermo Gonzalez <[e-mail]>
+# Author: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2009-2010 Canonical Ltd.
 #
@@ -14,102 +15,23 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-""" Base tests cases and test utilities """
-from __future__ import with_statement
+"""Base tests cases and test utilities."""
+
+import logging
 
 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 """
+from twisted.trial.unittest import TestCase
+
+
+class DBusTestCase(TestCase):
+    """Test the DBus event handling."""
 
     def setUp(self):
-        """ Setup the infrastructure fo the test (dbus service). """
-        BaseTestCase.setUp(self)
+        """Setup the infrastructure fo the test (dbus service)."""
         self.loop = DBusGMainLoop(set_as_default=True)
         self.bus = dbus.bus.BusConnection(mainloop=self.loop)
         # monkeypatch busName.__del__ to avoid errors on gc
@@ -119,31 +41,29 @@
         self.signal_receivers = set()
 
     def tearDown(self):
-        """ Cleanup the test. """
+        """Cleanup the test."""
         d = self.cleanup_signal_receivers(self.signal_receivers)
-        d.addBoth(self._tearDown)
-        d.addBoth(lambda _: BaseTestCase.tearDown(self))
+        d.addBoth(self._tear_down)
         return d
 
-    def _tearDown(self, *args):
-        """ shutdown """
-        self.dbus_iface.bus.flush()
+    def _tear_down(self, _):
+        """Shutdown."""
         self.bus.flush()
         self.bus.close()
 
     def error_handler(self, error):
-        """ default error handler for DBus calls. """
+        """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 """
+        """Cleanup self.signal_receivers and returns a deferred."""
         deferreds = []
         for match in signal_receivers:
             d = defer.Deferred()
 
             def callback(*args):
-                """ callback that accepts *args. """
+                """Callback that accepts *args."""
                 if not d.called:
                     d.callback(args)
 
@@ -158,62 +78,6 @@
             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."""
 
@@ -226,9 +90,9 @@
         """Just add the record to self.records."""
         self.records.append(record)
 
-    def check(self, level, msg):
-        """Check that something is logged."""
+    def check(self, level, *msgs):
+        """Verifies that the msgs are logged in the specified level."""
         for rec in self.records:
-            if rec.levelno == level and str(msg) in rec.message:
+            if rec.levelno == level and all(m in rec.message for m in msgs):
                 return True
         return False

=== removed directory 'data/oauth_registration.d'
=== removed file 'data/oauth_registration.d/ubuntuone'
--- data/oauth_registration.d/ubuntuone	2010-06-16 15:11:04 +0000
+++ data/oauth_registration.d/ubuntuone	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-[storagefs-live]
-realm = https://ubuntuone.com
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-syncdaemon
-
-[storagefs-local]
-realm = http://localhost
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-syncdaemon
-
-[control-panel]
-realm = https://ubuntuone.com
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-preferences
-
-[launcher]
-realm = https://ubuntuone.com
-consumer_key = ubuntuone
-exe_path = /usr/bin/python
-application_name = ubuntuone-launch

=== removed file 'data/oauth_urls'
--- data/oauth_urls	2010-06-16 15:11:04 +0000
+++ data/oauth_urls	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-[default]
-request_token_url = /oauth/request/
-user_authorisation_url = /oauth/authorize/
-access_token_url = /oauth/access/
-consumer_secret=hammertime

=== modified file 'debian/changelog'
--- debian/changelog	2010-08-30 17:10:34 +0000
+++ debian/changelog	2010-09-09 14:47:44 +0000
@@ -1,3 +1,58 @@
+ubuntu-sso-client (0.99.6-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release (0.99.6):
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Restoring NoAccessToken, DBUS_IFACE_AUTH_NAME, and DBUS_PATH_AUTH to avoid
+    API breakage on old versions of ubuntuone-client (LP: #633220).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Added handler for SIGHUP to stop the service (LP: #633300).
+
+  * New upstream release (0.99.5):
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Signals from the DBus "UserManagement" service are now filtered by app
+    name (LP: #629025).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Fixed indentantion block (LP: #632043).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Removed all the old auth mechanism (LP: #616121).
+    * Added pylint check, fixed all pylint errors.
+
+  [John R. Lenton <[e-mail]>]
+    * Enable setting USSOC_PING_URL and USSOC_SERVICE_URL to override the
+    (otherwise hardcoded) ping url and service url in ussoc (LP: #616110).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Hiding unused fields to make the registration UI a bit shorter (LP:
+    #627440).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * U1 url to ping server with tokens needs to be https (LP: #627700).
+
+  [Alejandro J. Cura <[e-mail]>]
+    * Disabled support for plugins for the embedded webkit (LP: #617041)
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Token name is now built using '@'. Old quoted tokens are migrated to
+    the new names (LP: #628158).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Pages have now a default_widget attribute that is the default widget
+    when the page is displayed to the user (LP: #62552).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * User-cancelation signal is sent when the window is close and no other
+    event was generated (LP: #627419).
+
+  [Natalia B. Bidart <[e-mail]>]
+    * Made DBus signal connection more robust (LP: #624127).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Wed, 08 Sep 2010 16:25:02 -0300
+
 ubuntu-sso-client (0.99.4-0ubuntu1) maverick; urgency=low
 
   * New upstream release:

=== added file 'debian/postinst'
--- debian/postinst	1970-01-01 00:00:00 +0000
+++ debian/postinst	2010-09-09 14:47:44 +0000
@@ -0,0 +1,25 @@
+#!/bin/sh
+set -e
+
+LASTVERSION="0.99.4-0ubuntu1"
+
+dpkg-maintscript-helper rm_conffile \
+/etc/xdg/ubuntu-sso/oauth_registration.d/ubuntuone "$LASTVERSION" -- "$@"
+
+dpkg-maintscript-helper rm_conffile \
+/etc/xdg/ubuntu-sso/oauth_urls "$LASTVERSION" -- "$@"
+
+rm_confdir() {
+    local DIR="$1"
+    if [ -d $DIR ]; then rmdir $DIR; fi || true
+}
+
+case "$1" in
+configure)
+    if dpkg --compare-versions "$2" le "$LASTVERSION"; then
+        rm_confdir "/etc/xdg/ubuntu-sso/oauth_registration.d"
+        rm_confdir "/etc/xdg/ubuntu-sso/"
+    fi
+esac
+
+#DEBHELPER#

=== added file 'debian/postrm'
--- debian/postrm	1970-01-01 00:00:00 +0000
+++ debian/postrm	2010-09-09 14:47:44 +0000
@@ -0,0 +1,15 @@
+#!/bin/sh
+set -e
+
+LASTVERSION="0.99.4-0ubuntu1"
+
+dpkg-maintscript-helper rm_conffile \
+/etc/xdg/ubuntu-sso/oauth_registration.d/ubuntuone "$LASTVERSION" -- "$@"
+
+dpkg-maintscript-helper rm_conffile \
+/etc/xdg/ubuntu-sso/oauth_urls "$LASTVERSION" -- "$@"
+
+rmdir "/etc/xdg/ubuntu-sso/oauth_registration.d/" 2>/dev/null || true
+rmdir "/etc/xdg/ubuntu-sso/" 2>/dev/null || true
+
+#DEBHELPER#

=== added file 'debian/preinst'
--- debian/preinst	1970-01-01 00:00:00 +0000
+++ debian/preinst	2010-09-09 14:47:44 +0000
@@ -0,0 +1,14 @@
+#!/bin/sh
+set -e
+
+LASTVERSION="0.99.4-0ubuntu1"
+
+pkill -HUP ubuntu-sso-login || true
+
+dpkg-maintscript-helper rm_conffile \
+/etc/xdg/ubuntu-sso/oauth_registration.d/ubuntuone "$LASTVERSION" -- "$@"
+
+dpkg-maintscript-helper rm_conffile \
+/etc/xdg/ubuntu-sso/oauth_urls "$LASTVERSION" -- "$@"
+
+#DEBHELPER#

=== added file 'pylintrc'
--- pylintrc	1970-01-01 00:00:00 +0000
+++ pylintrc	2010-09-09 14:47:44 +0000
@@ -0,0 +1,309 @@
+# lint Python modules using external checkers.
+#
+# This is the main checker controlling the other ones and the reports
+# generation. It is itself both a raw checker and an astng checker in order
+# to:
+# * handle message activation / deactivation at the module level
+# * handle some basic but necessary stats'data (number of classes, methods...)
+#
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Profiled execution.
+profile=no
+
+# Add <file or directory> to the black list. It should be a base name, not a
+# path. You may set this option multiple times.
+#ignore=<somedir>
+
+# Pickle collected data for later comparisons.
+persistent=no
+
+# Set the cache size for astng objects.
+cache-size=500
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+
+[MESSAGES CONTROL]
+
+# Enable only checker(s) with the given id(s). This option conflicts with the
+# disable-checker option
+#enable-checker=
+
+# Enable all checker(s) except those with the given id(s). This option
+# conflicts with the enable-checker option
+#disable-checker=
+
+# Enable all messages in the listed categories.
+#enable-cat=
+
+# Disable all messages in the listed categories.
+#disable-cat=
+
+# Disable the message(s) with the given id(s) or categories
+# W0142: *Used * or ** magic*
+# W0613: Unused argument 'yyy'
+# C0302: Too many lines in module
+disable=R,I,W0142,W0613,C0302
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html
+output-format=colorized
+
+# Include message's id in output
+include-ids=yes
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]".
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (R0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Add a comment according to your evaluation note. This is used by the global
+# evaluation report (R0004).
+comment=no
+
+# Enable the report(s) with the given id(s).
+#enable-report=
+
+# Disable the report(s) with the given id(s).
+#disable-report=
+
+
+# try to find bugs in the code using type inference
+#
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of classes names for which member attributes should not be checked
+# (useful for classes with attributes dynamically set).
+ignored-classes=
+
+# When zope mode is activated, add a predefined set of Zope acquired attributes
+# to generated-members.
+zope=no
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E0201 when accessed.
+generated-members=REQUEST,acl_users,aq_parent
+
+
+# checks for
+# * unused variables / imports
+# * undefined variables
+# * redefinition of variable from builtins or from an outer scope
+# * use of variable before assignment
+#
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=yes
+
+# A regular expression matching names used for dummy variables (i.e. not used).
+dummy-variables-rgx=_|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+
+# checks for :
+# * doc strings
+# * modules / classes / functions / methods / arguments / variables name
+# * number of arguments, local variables, branches, returns and statements in
+# functions, methods
+# * required module attributes
+# * dangerous default values as arguments
+# * redefinition of function / method / class
+# * uses of the global statement
+#
+[BASIC]
+
+# Required attributes for module, separated by a comma
+required-attributes=
+
+# Regular expression which should only match functions or classes name which do
+# not require a docstring
+no-docstring-rgx=(__.*__|setUp|tearDown)
+
+# Regular expression which should only match correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression which should only match correct module level names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression which should only match correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression which should only match correct function names
+function-rgx=[a-z_][a-z0-9_]{2,79}$
+
+# Regular expression which should only match correct method names
+method-rgx=([a-z_][a-z0-9_]{2,79}$|setUp|tearDown)
+
+# Regular expression which should only match correct instance attribute names
+attr-rgx=[a-z_][a-z0-9_]{1,30}$
+
+# Regular expression which should only match correct argument names
+argument-rgx=[a-z_][a-z0-9_]{1,30}$
+
+# Regular expression which should only match correct variable names
+variable-rgx=[a-z_][a-z0-9_]{1,30}$
+
+# Regular expression which should only match correct list comprehension /
+# generator expression variable names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=d,e,f,g,i,j,k,ex,logger,Run,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# List of builtins function names that should not be used, separated by a comma
+bad-functions=apply,input
+
+
+# checks for sign of poor/misdesign:
+# * number of methods, attributes, local variables...
+# * size, complexity of functions, methods
+#
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=5
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branchs=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+
+# checks for :
+# * methods without self as first argument
+# * overridden methods signature
+# * access only to existent members via self
+# * attributes not defined in the __init__ method
+# * supported interfaces implementation
+# * unreachable code
+#
+[CLASSES]
+
+# List of interface methods to ignore, separated by a comma. This is used for
+# instance to not check methods defines in Zopes Interface base class.
+#ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by,providedBy
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp
+
+
+# checks for
+# * external modules dependencies
+# * relative / wildcard imports
+# * cyclic imports
+# * uses of deprecated modules
+#
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,string,TERMIOS,Bastion,rexec
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+
+# checks for :
+# * unauthorized constructions
+# * strict indentation
+# * line length
+# * use of <> instead of !=
+#
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=79
+
+# Maximum number of lines in a module
+max-module-lines=2000
+
+# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+
+# checks for similarities and duplicated code. This computation may be
+# memory / CPU intensive, so you should disable it if you experiments some
+# problems.
+#
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+
+# checks for:
+# * warning notes in the code like FIXME, XXX
+# * PEP 263: source code with non ascii character but no encoding declaration
+#
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO,fixme,xxx,todo

=== modified file 'run-tests'
--- run-tests	2010-08-26 01:07:41 +0000
+++ run-tests	2010-09-09 14:47:44 +0000
@@ -16,12 +16,9 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 `which xvfb-run` ./contrib/test "$@"
-pyflakes bin ubuntu_sso
+pylint contrib ubuntu_sso
 if [ -x `which pep8` ]; then
-    pep8 --repeat bin/ contrib/ \
-    ubuntu_sso/gui.py ubuntu_sso/main.py ubuntu_sso/keyring.py \
-    ubuntu_sso/tests/test_gui.py ubuntu_sso/tests/test_main.py \
-    ubuntu_sso/tests/test_keyring.py
+    pep8 --repeat bin/ contrib/ ubuntu_sso/
 else
     echo "Please install the 'pep8' package."
 fi

=== modified file 'setup.py'
--- setup.py	2010-08-27 22:16:40 +0000
+++ setup.py	2010-09-09 14:47:44 +0000
@@ -1,6 +1,8 @@
 #!/usr/bin/env python
 # setup.py - Build system for Ubuntu SSO Client package
 #
+# Author: Natalia B. Bidart <[e-mail]>
+#
 # Copyright 2010 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -36,6 +38,7 @@
 # Defining variables for various rules here, similar to a Makefile.am
 CLEANFILES = ['data/com.ubuntu.sso.service']
 
+
 # XXX: This needs some serious cleanup
 class SSOBuild(build_extra.build_extra):
     """Class to build the extra files."""
@@ -53,7 +56,8 @@
         out_file = 'data/com.ubuntu.sso.service'
         replaced_path = '/usr/lib/ubuntu-sso-client'
 
-        os.system("%(cmd)s -e 's|\@libexecdir\@|%(rep)s|g' < %(in)s > %(out)s" %
+        cmd = "%(cmd)s -e 's|\@libexecdir\@|%(rep)s|g' < %(in)s > %(out)s"
+        os.system( cmd %
                   {'cmd' : sed,
                    'rep' : replaced_path,
                    'in' : in_file,
@@ -82,7 +86,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='0.99.4',
+    version='0.99.6',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',
@@ -92,16 +96,9 @@
     url='https://launchpad.net/ubuntu-sso-client',
     packages=['ubuntu_sso'],
     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',]),
-        ('/etc/xdg/ubuntu-sso/', ['data/oauth_urls',]),
-        ('/etc/xdg/ubuntu-sso/oauth_registration.d',
-         ['data/oauth_registration.d/ubuntuone',]),
-    ],
-
-    cmdclass = {
+        ('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'])],
+    cmdclass={
         'build' : SSOBuild,
-        'clean' : SSOClean,
-    },
-)
+        'clean' : SSOClean})

=== modified file 'ubuntu_sso/__init__.py'
--- ubuntu_sso/__init__.py	2010-08-11 17:03:11 +0000
+++ ubuntu_sso/__init__.py	2010-09-09 14:47:44 +0000
@@ -1,6 +1,6 @@
-# ubuntu_sso - OAuth client support for desktop apps
+# ubuntu_sso - Ubuntu Single Sign On client support for desktop apps
 #
-# 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
@@ -13,7 +13,7 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth client authorisation code."""
+"""Ubuntu Single Sign On client code."""
 
 # constants
 DBUS_PATH_AUTH = "/"

=== modified file 'ubuntu_sso/auth.py'
--- ubuntu_sso/auth.py	2010-08-11 17:03:11 +0000
+++ ubuntu_sso/auth.py	2010-09-09 14:47:44 +0000
@@ -11,475 +11,15 @@
 # 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.
+# 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/>.
-"""OAuth client authorisation code.
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+"""This is an obsolete module.
 
-This code handles acquisition of an OAuth access token for a service,
-managed through the GNOME keyring for future use, and asynchronously.
+Do not use it, use the DBus API from main instead (SSOCredentials).
 """
 
-__metaclass__ = type
-
-import dbus
-import os
-import random
-import subprocess
-import socket, httplib, urllib
-import sys
-
-import gnomekeyring
-from oauth import oauth
-try:
-    from ubuntuone.clientdefs import VERSION
-    ubuntuone_client_version = VERSION
-except ImportError:
-    ubuntuone_client_version = "Unknown"
-from ubuntu_sso.key_acls import set_all_key_acls
-
-from threading import Thread
-from twisted.internet import reactor
-from twisted.web import server, resource
-
-from ubuntu_sso.logger import setupLogging
-logger = setupLogging("ubuntu_sso.auth")
-
 
 class NoAccessToken(Exception):
     """No access token available."""
-
-# NetworkManager State constants
-NM_STATE_UNKNOWN = 0
-NM_STATE_ASLEEP = 1
-NM_STATE_CONNECTING = 2
-NM_STATE_CONNECTED = 3
-NM_STATE_DISCONNECTED = 4
-
-# Monkeypatch httplib so that urllib will fail on invalid certificate
-# Only patch if we can import ssl to work around fail in 2.5
-try:
-    import ssl
-except ImportError:
-    pass
-else:
-    def _connect_wrapper(self):
-        """Override HTTPSConnection.connect to require certificate checks"""
-        sock = socket.create_connection((self.host, self.port), self.timeout)
-        try:
-            if self._tunnel_host:
-                self.sock = sock
-                self._tunnel()
-        except AttributeError:
-            pass
-        self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
-                cert_reqs=ssl.CERT_REQUIRED, 
-                ca_certs="/etc/ssl/certs/ca-certificates.crt")
-    httplib.HTTPSConnection.connect = _connect_wrapper
-
-
-class FancyURLOpenerWithRedirectedPOST(urllib.FancyURLopener):
-    """FancyURLopener does not redirect postdata when redirecting POSTs"""
-    version = "Ubuntu One/Login (%s)" % ubuntuone_client_version
-    def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
-        """Actually perform a redirect"""
-        # All the same as the original, except passing data, below
-        if 'location' in headers:
-            newurl = headers['location']
-        elif 'uri' in headers:
-            newurl = headers['uri']
-        else:
-            return
-        fp.read()
-        fp.close()
-        # In case the server sent a relative URL, join with original:
-        newurl = urllib.basejoin(self.type + ":" + url, newurl)
-        
-        # pass data if present when we redirect
-        if data:
-            return self.open(newurl, data)
-        else:
-            return self.open(newurl)
-
-class AuthorisationClient(object):
-    """OAuth authorisation client."""
-    def __init__(self, realm, request_token_url, user_authorisation_url,
-                 access_token_url, consumer_key, consumer_secret,
-                 callback_parent, callback_denied=None,
-                 callback_notoken=None, callback_error=None, do_login=True,
-                 keyring=gnomekeyring):
-        """Create an `AuthorisationClient` instance.
-
-        @param realm: the OAuth realm.
-        @param request_token_url: the OAuth request token URL.
-        @param user_authorisation_url: the OAuth user authorisation URL.
-        @param access_token_url: the OAuth access token URL.
-        @param consumer_key: the OAuth consumer key.
-        @param consumer_secret: the OAuth consumer secret.
-        @param callback_parent: a function in the includer to call with a token
-
-        The preceding parameters are defined in sections 3 and 4.1 of the
-        OAuth Core 1.0 specification.  The following parameters are not:
-
-        @param callback_denied: a function to call if no token is available
-        @param do_login: whether to create a token if one is not cached
-        @param keychain: the keyring object to use (defaults to gnomekeyring)
-
-        """
-        self.realm = realm
-        self.request_token_url = request_token_url
-        self.user_authorisation_url = user_authorisation_url
-        self.access_token_url = access_token_url
-        self.consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
-        self.callback_parent = callback_parent
-        self.callback_denied = callback_denied
-        self.callback_notoken = callback_notoken
-        self.callback_error = callback_error
-        self.do_login = do_login
-        self.request_token = None
-        self.saved_acquire_details = (None, None, None)
-        self.keyring = keyring
-        logger.debug("auth.AuthorisationClient created with parameters "+ \
-           "realm='%s', request_token_url='%s', user_authorisation_url='%s',"+\
-           "access_token_url='%s', consumer_key='%s', callback_parent='%s'",
-           realm, request_token_url, user_authorisation_url, access_token_url,
-           consumer_key, callback_parent)
-
-    def _get_keyring_items(self):
-        """Raw interface to obtain keyring items."""
-        return self.keyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET,
-                                            {'ubuntuone-realm': self.realm,
-                                             'oauth-consumer-key':
-                                             self.consumer.key})
-
-    def _forward_error_callback(self, error):
-        """Forward an error through callback_error()"""
-        if self.callback_error:
-            self.callback_error(str(error))
-        else:
-            raise error
-
-    def get_access_token(self):
-        """Get the access token from the keyring.
-
-        If no token is available in the keyring, `NoAccessToken` is raised.
-        """
-        logger.debug("Trying to fetch the token from the keyring")
-        try:
-            items = self._get_keyring_items()
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            logger.debug("Access token was not in the keyring")
-            raise NoAccessToken("No access token found.")
-        logger.debug("Access token successfully found in the keyring")
-        return oauth.OAuthToken.from_string(items[0].secret)
-
-    def clear_token(self):
-        """Clear any stored tokens from the keyring."""
-        logger.debug("Searching keyring for existing tokens to delete.")
-        try:
-            items = self._get_keyring_items()
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            logger.debug("No preexisting tokens found")
-        else:
-            logger.debug("Deleting %s tokens from the keyring" % len(items))
-            for item in items:
-                try:
-                    self.keyring.item_delete_sync(None, item.item_id)
-                except gnomekeyring.DeniedError:
-                    logger.debug("Permission denied deleting token")
-
-    def store_token(self, access_token):
-        """Store the given access token in the keyring.
-
-        The keyring item is identified by the OAuth realm and consumer
-        key to support multiple instances.
-        """
-        logger.debug("Trying to store the token in the keyring")
-        try:
-            item_id = self.keyring.item_create_sync(
-                None,
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                'UbuntuOne token for %s' % self.realm,
-                {'ubuntuone-realm': self.realm,
-                 'oauth-consumer-key': self.consumer.key},
-                access_token.to_string(),
-                True)
-        except gnomekeyring.DeniedError:
-            logger.debug("Permission denied storing token")
-        else:
-            # set ACLs on the key for all apps listed in xdg BaseDir, but only
-            # the root level one, not the user-level one
-            logger.debug("Setting ACLs on the token in the keyring")
-            set_all_key_acls(item_id=item_id)
-
-            # keyring seems to take a while to actually apply the change
-            # for when other people retrieve it, so sleep a bit.
-            # this ought to get fixed.
-            import time
-            time.sleep(4)
-
-    def have_access_token(self):
-        """Returns true if an access token is available from the keyring."""
-        try:
-            self.get_access_token()
-        except NoAccessToken:
-            return False
-        else:
-            return True
-
-    def make_token_request(self, oauth_request):
-        """Perform the given `OAuthRequest` and return the associated token."""
-        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
-        #    raises IOError, e.args[1] == SSLError, e.args[1].errno == -2
-        try:
-            opener = FancyURLOpenerWithRedirectedPOST()
-            fp = opener.open(oauth_request.http_url, oauth_request.to_postdata())
-            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.info("Token successfully requested")
-            return out_token
-        except:
-            error = Exception(data)
-            logger.exception("Token was not retrieved: data was '%s'", data)
-            self._forward_error_callback(error)
-
-    def open_in_browser(self, url):
-        """Open the given URL in the user's web browser."""
-        logger.debug("Opening '%s' in the browser", url)
-        p = subprocess.Popen(["xdg-open", url], bufsize=4096,
-                             stderr=subprocess.PIPE)
-        p.wait()
-        if p.returncode != 0:
-            errors = "".join(p.stderr.readlines())
-            if errors != "":
-                self._forward_error_callback(IOError(errors))
-
-    def acquire_access_token_if_online(self, description=None, store=False):
-        """Check to see if we are online before trying to acquire"""
-        # Get NetworkManager state
-        logger.debug("Checking whether we are online")
-        try:
-            nm = dbus.SystemBus().get_object('org.freedesktop.NetworkManager',
-                                             '/org/freedesktop/NetworkManager',
-                                             follow_name_owner_changes=True)
-        except dbus.exceptions.DBusException:
-            logger.warn("Unable to connect to NetworkManager. Trying anyway.")
-            self.acquire_access_token(description, store)
-        else:
-            iface = dbus.Interface(nm, 'org.freedesktop.NetworkManager')
-
-            def got_state(state):
-                """Handler for when state() call succeeds."""
-                if state == NM_STATE_CONNECTED:
-                    logger.debug("We are online")
-                    self.acquire_access_token(description, store)
-                elif state == NM_STATE_CONNECTING:
-                    logger.debug("We are currently going online")
-                    # attach to NM's StateChanged signal
-                    signal_match = nm.connect_to_signal(
-                        signal_name="StateChanged",
-                        handler_function=self.connection_established,
-                        dbus_interface="org.freedesktop.NetworkManager")
-                    # stash the details so the handler_function can get at them
-                    self.saved_acquire_details = (signal_match, description,
-                                                  store)
-                else:
-                    # NM is not connected: fail
-                    logger.debug("We are not online")
-
-            def got_error(error):
-                """Handler for D-Bus errors when calling state()."""
-                if error.get_dbus_name() == \
-                        'org.freedesktop.DBus.Error.ServiceUnknown':
-                    logger.debug("NetworkManager not available.")
-                    self.acquire_access_token(description, store)
-                else:
-                    logger.error("Error contacting NetworkManager: %s" % \
-                                     str(error))
-
-
-            iface.state(reply_handler=got_state, error_handler=got_error)
-
-    def connection_established(self, state):
-        """NetworkManager's state has changed, and we're watching for
-           a connection"""
-        logger.debug("Online status has changed to %s" % state)
-        if int(state) == NM_STATE_CONNECTED:
-            signal_match, description, store = self.saved_acquire_details
-            # disconnect the signal so we don't get called again
-            signal_match.remove()
-            # call the real acquire_access_token now it has a connection
-            logger.debug("Correctly connected: now starting auth process")
-            self.acquire_access_token(description, store)
-        else:
-            # connection changed but not to "connected", so keep waiting
-            logger.debug("Not yet connected: continuing to wait")
-
-    def acquire_access_token(self, description=None, store=False):
-        """Create an OAuth access token authorised against the user."""
-        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
-
-        # Create a request token ...
-        logger.debug("Creating a request token to begin access request")
-        parameters = {}
-        if description:
-            parameters['description'] = description
-        # Add a nonce to the query so we know the callback (to our temp
-        # webserver) came from us
-        nonce = random.randint(1000000, 10000000)
-
-        # start temporary webserver to receive browser response
-        callback_url = self.get_temporary_httpd(nonce,
-           self.retrieve_access_token, store)
-
-        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-            callback=callback_url,
-            http_url=self.request_token_url,
-            oauth_consumer=self.consumer,
-            parameters=parameters)
-        oauth_request.sign_request(signature_method, self.consumer, None)
-        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,
-            token=self.request_token)
-        nodename = os.uname()[1]
-        if nodename:
-            oauth_request.set_parameter("description", nodename)
-        Thread(target=self.open_in_browser, name="authorization",
-               args=(oauth_request.to_url(),)).start()
-
-    def get_temporary_httpd(self, nonce, retrieve_function, store):
-        "A separate class so it can be mocked in testing"
-        logger.debug("Creating a listening temp web server")
-        site = TemporaryTwistedWebServer(nonce=nonce,
-          retrieve_function=retrieve_function, store_yes_no=store)
-        temphttpd = server.Site(site)
-        temphttpdport = reactor.listenTCP(0, temphttpd)
-        callback_url = "http://localhost:%s/?nonce=%s" % (
-          temphttpdport.getHost().port, nonce)
-        site.set_port(temphttpdport)
-        logger.debug("Webserver listening on port '%s'", temphttpdport)
-        return callback_url
-
-    def retrieve_access_token(self, store=False, verifier=None):
-        """Retrieve the access token, once OAuth is done. This is a callback."""
-        logger.debug("Access token callback from temp webserver")
-        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
-        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-            http_url=self.access_token_url,
-            oauth_consumer=self.consumer,
-            token=self.request_token)
-        oauth_request.set_parameter("oauth_verifier", verifier)
-        oauth_request.sign_request(
-            signature_method, self.consumer, self.request_token)
-        logger.debug("Retrieving access token from OAuth")
-        access_token = self.make_token_request(oauth_request)
-        if not access_token:
-            logger.error("Failed to get access token.")
-            if self.callback_denied is not None:
-                self.callback_denied()
-        else:
-            if store:
-                logger.debug("Storing access token in keyring")
-                self.store_token(access_token)
-            logger.debug("Calling the callback_parent")
-            self.callback_parent(access_token)
-
-    def ensure_access_token(self, description=None):
-        """Returns an access token, either from the keyring or newly acquired.
-
-        If a new token is acquired, it will be stored in the keyring
-        for future use.
-        """
-        try:
-            access_token = self.get_access_token()
-            self.callback_parent(access_token)
-        except NoAccessToken:
-            if self.do_login:
-                self.acquire_access_token_if_online(description, store=True)
-            else:
-                if self.callback_notoken is not None:
-                    self.callback_notoken()
-
-
-class TemporaryTwistedWebServer(resource.Resource):
-    """A temporary httpd for the oauth process to call back to"""
-    isLeaf = True
-    def __init__(self, nonce, store_yes_no, retrieve_function):
-        """Initialize the temporary web server."""
-        resource.Resource.__init__(self)
-        self.nonce = nonce
-        self.store_yes_no = store_yes_no
-        self.retrieve_function = retrieve_function
-        reactor.callLater(600, self.stop) # ten minutes
-        self.port = None
-    def set_port(self, port):
-        """Save the Twisted port object so we can stop it later"""
-        self.port = port
-    def stop(self):
-        """Stop the httpd"""
-        logger.debug("Stopping temp webserver")
-        self.port.stopListening()
-    def render_GET(self, request):
-        """Handle incoming web requests"""
-        logger.debug("Incoming temp webserver hit received")
-        nonce = request.args.get("nonce", [None])[0]
-        url = request.args.get("return", ["https://one.ubuntu.com/"])[0]
-        verifier = request.args.get("oauth_verifier", [None])[0]
-        logger.debug("Got verifier %s" % verifier)
-        if nonce and (str(nonce) == str(self.nonce) and verifier):
-            self.retrieve_function(store=self.store_yes_no, verifier=verifier)
-            reactor.callLater(3, self.stop)
-            return """<!doctype html>
-        <html><head><meta http-equiv="refresh"
-        content="0;url=%(url)s">
-        </head>
-        <body>
-        <p>You should now automatically <a
-        href="%(url)s">return to %(url)s</a>.</p>
-        </body>
-        </html>
-        """ % { 'url' : url }
-        else:
-            self.retrieve_function(store=self.store_yes_no, verifier=verifier)
-            reactor.callLater(3, self.stop)
-            request.setResponseCode(400)
-            return """<!doctype html>
-        <html><head><title>Error</title></head>
-        <body>
-        <h1>There was an error</h1>
-        <p>The authentication process has not succeeded. This may be a
-        temporary problem; please try again in a few minutes.</p>
-        </body>
-        </html>
-        """
-
-
-

=== removed file 'ubuntu_sso/config.py'
--- ubuntu_sso/config.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/config.py	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-# ubuntu_sso.config - Configuration for OAuthDesktop
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Find the config file for ubuntu-oauth-config."""
-
-import os, ConfigParser
-from xdg.BaseDirectory import load_first_config
-
-def get_config(use_tmpconfig=True):
-    """Return a ConfigParser object from a config file.
-
-    Config file is looked for in the source tree first and then in the
-    FreeDesktop BaseDirectory folders.
-    """
-    # if tmpconfig exists, then we are running out of the source tree
-    tmpconfig = os.path.realpath(os.path.join(__file__,
-                                              "../../../data/oauth_urls"))
-    if os.path.isfile(tmpconfig) and use_tmpconfig:
-        config_file = tmpconfig
-    else:
-        config_file = load_first_config('ubuntu-sso','oauth_urls')
-
-    cfp = ConfigParser.ConfigParser()
-    cfp.FILENAME = None
-    if config_file is not None:
-        try:
-            cfp.read(config_file)
-            cfp.FILENAME = config_file
-        except ConfigParser.Error:
-            cfp = ConfigParser.ConfigParser()
-            cfp.FILENAME = None
-    return cfp
-

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-08-27 22:16:40 +0000
+++ ubuntu_sso/gui.py	2010-09-09 14:47:44 +0000
@@ -35,20 +35,23 @@
 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
+from ubuntu_sso.logger import setup_logging
+
+
+# Instance of 'UbuntuSSOClientGUI' has no 'yyy' member
+# pylint: disable=E1101
 
 
 _ = gettext.gettext
 gettext.textdomain('ubuntu-sso-client')
 
 DBusGMainLoop(set_as_default=True)
-logger = setupLogging('ubuntu_sso.gui')
+logger = setup_logging('ubuntu_sso.gui')
 
 
 NO_OP = lambda *args, **kwargs: None
 DEFAULT_WIDTH = 30
-# XXX: to be replaced by values from the theme
-# see LP: #616526
+# To be replaced by values from the theme (LP: #616526)
 HELP_TEXT_COLOR = gtk.gdk.Color("#bfbfbf")
 WARNING_TEXT_COLOR = gtk.gdk.Color("red")
 
@@ -66,9 +69,9 @@
     (SIG_USER_CANCELATION, (gobject.TYPE_STRING,)),
 ]
 
-for sig, args in SIGNAL_ARGUMENTS:
+for sig, sig_args in SIGNAL_ARGUMENTS:
     gobject.signal_new(sig, gtk.Window, gobject.SIGNAL_RUN_FIRST,
-                       gobject.TYPE_NONE, args)
+                       gobject.TYPE_NONE, sig_args)
 
 
 def get_data_dir():
@@ -298,7 +301,6 @@
         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)
@@ -321,7 +323,7 @@
 
         window_size = None
         if not login_only:
-            window_size = (550, 600)
+            window_size = (550, 500)
             self._append_page(self._build_enter_details_page())
             self._append_page(self._build_tc_page())
             self._append_page(self._build_verify_email_page())
@@ -339,6 +341,32 @@
         for label in self.labels:
             label.set_size_request(*size_req)
 
+        self._signals = {
+            'CaptchaGenerated':
+             self._filter_by_app_name(self.on_captcha_generated),
+            'CaptchaGenerationError':
+             self._filter_by_app_name(self.on_captcha_generation_error),
+            'UserRegistered':
+             self._filter_by_app_name(self.on_user_registered),
+            'UserRegistrationError':
+             self._filter_by_app_name(self.on_user_registration_error),
+            'EmailValidated':
+             self._filter_by_app_name(self.on_email_validated),
+            'EmailValidationError':
+             self._filter_by_app_name(self.on_email_validation_error),
+            'LoggedIn':
+             self._filter_by_app_name(self.on_logged_in),
+            'LoginError':
+             self._filter_by_app_name(self.on_login_error),
+            'PasswordResetTokenSent':
+             self._filter_by_app_name(self.on_password_reset_token_sent),
+            'PasswordResetError':
+             self._filter_by_app_name(self.on_password_reset_error),
+            'PasswordChanged':
+             self._filter_by_app_name(self.on_password_changed),
+            'PasswordChangeError':
+             self._filter_by_app_name(self.on_password_change_error),
+        }
         self._setup_signals()
         self._gtk_signal_log = []
 
@@ -349,51 +377,55 @@
             # 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)
+                win = gtk.gdk.window_foreign_new(window_id)
                 self.window.realize()
-                self.window.window.set_transient_for(r)
-            except:
+                self.window.window.set_transient_for(win)
+            except:  # pylint: disable=W0702
                 msg = 'UbuntuSSOClientGUI: failed set_transient_for win id %r'
                 logger.exception(msg, window_id)
+
+        # Hidding unused widgets to save some space (LP #627440).
+        self.name_entry.hide()
+        self.yes_to_updates_checkbutton.hide()
+
         self.window.show()
 
+    def _filter_by_app_name(self, f):
+        """Excecute the decorated function only for 'self.app_name'."""
+
+        @wraps(f)
+        def inner(app_name, *args, **kwargs):
+            """Execute 'f' only if 'app_name' matches 'self.app_name'."""
+            result = None
+            if app_name == self.app_name:
+                result = f(app_name, *args, **kwargs)
+            else:
+                logger.info('%s: ignoring call since received app_name '\
+                            '"%s" (expected "%s")',
+                            f.__name__, app_name, self.app_name)
+            return result
+
+        return inner
+
     def _setup_signals(self):
         """Bind signals to callbacks to be able to test the pages."""
-        self._signals = [
-            ('CaptchaGenerated', self.on_captcha_generated),
-            ('CaptchaGenerationError', self.on_captcha_generation_error),
-            ('UserRegistered', self.on_user_registered),
-            ('UserRegistrationError', self.on_user_registration_error),
-            ('EmailValidated', self.on_email_validated),
-            ('EmailValidationError', self.on_email_validation_error),
-            ('LoggedIn', self.on_logged_in),
-            ('LoginError', self.on_login_error),
-            ('PasswordResetTokenSent', self.on_password_reset_token_sent),
-            ('PasswordResetError', self.on_password_reset_error),
-            ('PasswordChanged', self.on_password_changed),
-            ('PasswordChangeError', self.on_password_change_error),
-        ]
-        for signal, method in self._signals:
-            self.bus.add_signal_receiver(method, signal_name=signal,
-                                         dbus_interface=self.iface_name)
+        iface = self.iface_name
+        for signal, method in self._signals.iteritems():
+            actual = self._signals_receivers.get((iface, signal))
+            if actual is not None:
+                msg = 'Signal %r is already connected with %r at iface %r.'
+                logger.warning(msg, signal, actual, iface)
+
+            match = self.bus.add_signal_receiver(method, signal_name=signal,
+                                                 dbus_interface=iface)
+            logger.info('Connecting signal %r with method %r at iface %r.' \
+                        'Match: %r', signal, method, iface, match)
+            self._signals_receivers[(iface, signal)] = method
 
     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()
@@ -467,6 +499,9 @@
             else:
                 page.hide()
 
+        if current_page.default_widget is not None:
+            current_page.default_widget.grab_default()
+
     def _generate_captcha(self):
         """Ask for a new captcha; update the ui to reflect the fact."""
         logger.info('Calling generate_captcha with filename path at %r',
@@ -496,6 +531,8 @@
         d = {'app_name': self.app_label}
         self.enter_details_vbox.header = self.JOIN_HEADER_LABEL % d
         self.enter_details_vbox.help_text = self.help_text
+        self.enter_details_vbox.default_widget = self.join_ok_button
+        self.join_ok_button.set_flags(gtk.CAN_DEFAULT)
 
         self.enter_details_vbox.pack_start(self.name_entry, expand=False)
         self.enter_details_vbox.reorder_child(self.name_entry, 0)
@@ -538,16 +575,22 @@
     def _build_tc_page(self):
         """Build the Terms & Conditions page."""
         self.tc_browser_vbox.help_text = ''
+        self.tc_browser_vbox.default_widget = self.tc_back_button
+        self.tc_browser_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
         return self.tc_browser_vbox
 
     def _build_processing_page(self):
         """Build the processing page with a spinner."""
+        self.processing_vbox.default_widget = None
         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.default_widget = self.verify_token_button
+        self.verify_email_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
+
         cb = lambda w: self.verify_token_button.clicked()
         self.email_token_entry.connect('activate', cb)
         self.verify_email_vbox.pack_start(self.email_token_entry, expand=False)
@@ -557,6 +600,9 @@
 
     def _build_success_page(self):
         """Build the success page."""
+        self.success_vbox.default_widget = self.success_close_button
+        self.success_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
+
         self.success_label.set_markup('<span size="x-large">%s</span>' %
                                       self.SUCCESS)
         return self.success_vbox
@@ -566,6 +612,8 @@
         d = {'app_name': self.app_label}
         self.login_vbox.header = self.LOGIN_HEADER_LABEL % d
         self.login_vbox.help_text = self.CONNECT_HELP_LABEL % d
+        self.login_vbox.default_widget = self.login_ok_button
+        self.login_vbox.default_widget.set_flags(gtk.CAN_DEFAULT)
 
         self.login_details_vbox.pack_start(self.login_email_entry)
         self.login_details_vbox.reorder_child(self.login_email_entry, 0)
@@ -586,6 +634,9 @@
         self.request_password_token_vbox.header = self.RESET_PASSWORD
         text = self.REQUEST_PASSWORD_TOKEN_LABEL % {'app_name': self.app_label}
         self.request_password_token_vbox.help_text = text
+        btn = self.request_password_token_ok_button
+        btn.set_flags(gtk.CAN_DEFAULT)
+        self.request_password_token_vbox.default_widget = btn
 
         entry = self.reset_email_entry
         self.request_password_token_details_vbox.pack_start(entry,
@@ -604,6 +655,9 @@
         """Build the login page."""
         self.set_new_password_vbox.header = self.RESET_PASSWORD
         self.set_new_password_vbox.help_text = self.SET_NEW_PASSWORD_LABEL
+        btn = self.set_new_password_ok_button
+        btn.set_flags(gtk.CAN_DEFAULT)
+        self.set_new_password_vbox.default_widget = btn
 
         cb = lambda w: self.set_new_password_ok_button.clicked()
         for entry in (self.reset_code_entry,
@@ -672,6 +726,8 @@
         remove = self.bus.remove_signal_receiver
         for (iface, signal) in self._signals_receivers.keys():
             method = self._signals_receivers.pop((iface, signal))
+            logger.info('Removing signal %r with method %r at iface %r.',
+                        signal, method, iface)
             remove(method, signal_name=signal, dbus_interface=iface)
 
         # destroy main window
@@ -684,6 +740,8 @@
             signal = self._gtk_signal_log[-1][0]
             args = self._gtk_signal_log[-1][1:]
             self.window.emit(signal, *args)
+        else:
+            self.window.emit(SIG_USER_CANCELATION, self.app_name)
 
         # call user defined callback
         if self.close_callback is not None:
@@ -704,10 +762,11 @@
 
         error = False
 
-        name = self.name_entry.get_text()
-        if not name:
-            self.name_entry.set_warning(self.FIELD_REQUIRED)
-            error = True
+        # Hidding unused widgets to save some space (LP #627440).
+        #name = self.name_entry.get_text()
+        #if not name:
+        #    self.name_entry.set_warning(self.FIELD_REQUIRED)
+        #    error = True
 
         # check email
         email1 = self.email1_entry.get_text()
@@ -892,6 +951,9 @@
     def on_tc_browser_vbox_show(self, *args, **kwargs):
         """The T&C page is being shown."""
         browser = webkit.WebView()
+        settings = browser.get_settings()
+        settings.set_property("enable-plugins", False)
+        settings.set_property("enable-default-context-menu", False)
         browser.open(self.tc_uri)
         browser.show()
         self.tc_browser_window.add(browser)

=== removed file 'ubuntu_sso/key_acls.py'
--- ubuntu_sso/key_acls.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/key_acls.py	1970-01-01 00:00:00 +0000
@@ -1,157 +0,0 @@
-# ubuntu_sso.key_acls - OAuth ACL handling for keyring
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth client authorisation code.
-
-This code finds all apps that have pre-registered themselves as wanting to
-access OAuth tokens from the Gnome keyring without the user having to approve
-that, and sets ACLs on relevant keys so they can do so.
-
-Apps pre-register themselves by dropping an ini file in
-/etc/xdg/ubuntuone/oauth_registration.d/ in which each section has keys
-realm, consumer_key, exe_path, application_name.
-"""
-
-import xdg.BaseDirectory, os, ConfigParser, gnomekeyring
-
-def get_privileged_config_folder(use_source_tree_folder=True):
-    """Find the XDG config folder to use which is not the user's personal
-       config (i.e., ~/.config) so that files in it are root-owned"""
-    # First, check for folder (if we're running from the source tree)
-    if use_source_tree_folder:
-        source_tree_folder = os.path.join(
-             os.path.split(__file__)[0],
-             "../../data/oauth_registration.d")
-        if os.path.isdir(source_tree_folder):
-            return os.path.join(source_tree_folder, "..")
-
-    # Otherwise, check for proper XDG folders
-    privileged_folders = [x for x in
-       xdg.BaseDirectory.load_config_paths('ubuntu-sso')
-       if not x.startswith(xdg.BaseDirectory.xdg_config_home)]
-    if privileged_folders:
-        return privileged_folders[0]
-    else:
-        return None
-
-def get_acl_preregistrations(use_source_tree_folder=True):
-    "Return a list of all config files in the pre-registration folder"
-    config_folder = get_privileged_config_folder(use_source_tree_folder)
-    if config_folder:
-        conf_dir = os.path.join(config_folder, "oauth_registration.d")
-        if os.path.isdir(conf_dir):
-            return [os.path.join(conf_dir, x) for x in os.listdir(conf_dir)]
-    return []
-
-def get_item_ids_for_realm(realm, consumer_key):
-    "Find all keyring tokens for a specific realm/consumer_key"
-    if realm == "http://localhost":
-        # if realm (from the config file) is localhost, then the token
-        # will have ubuntuone-realm == http://localhost:SOMETHING
-        # so find all keys with this consumer_key, and pass on any
-        # where ubuntuone-realm begins with http://localhost:
-        try:
-            items = gnomekeyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'oauth-consumer-key': consumer_key})
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            return []
-        items = [x.item_id for x in items if
-        x.attributes.get("ubuntuone-realm", "").startswith("http://localhost:")]
-        return items
-    else:
-        # realm was not localhost, so search for it explicitly
-        try:
-            items = gnomekeyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'ubuntuone-realm': realm,
-                 'oauth-consumer-key': consumer_key})
-        except (gnomekeyring.NoMatchError,
-                gnomekeyring.DeniedError):
-            return []
-        return [x.item_id for x in items]
-
-def set_single_acl(app_sets, specific_item_id=None):
-    """Allow a specified set of apps to access a matching keyring
-       token without prompts"""
-    for realm, consumer_key, exe_path, application_name in app_sets:
-        if specific_item_id is None:
-            items = get_item_ids_for_realm(realm, consumer_key)
-        else:
-            # item_id specified
-            items = [specific_item_id]
-
-        # set an ACL on the key so the calling app can read it without
-        # a prompt dialog
-        for item_id in items:
-            acl = gnomekeyring.item_get_acl_sync(None, item_id)
-            new_acls = False
-            real_exe_path = os.path.realpath(exe_path)
-            for acl_item in acl:
-                if acl_item.get_display_name() == application_name and \
-                   acl_item.get_path_name() == real_exe_path:
-                    # this ACL is already set
-                    break
-            else:
-                appref = gnomekeyring.ApplicationRef()
-                ac = gnomekeyring.AccessControl(appref,
-                   gnomekeyring.ACCESS_READ |
-                   gnomekeyring.ACCESS_WRITE | gnomekeyring.ACCESS_REMOVE)
-                ac.set_display_name(application_name)
-                ac.set_path_name(real_exe_path)
-                acl.append(ac)
-                new_acls = True
-            if new_acls:
-                gnomekeyring.item_set_acl_sync(None, item_id, acl)
-
-def set_all_key_acls(item_id=None, use_source_tree_folder=True):
-    """For each file in the config folder, get the (realm, key) pair that
-       the program therein is interested in and register the program as able
-       to access those keys by setting an ACL on them."""
-    for config_file in get_acl_preregistrations(use_source_tree_folder):
-        cfp = ConfigParser.ConfigParser()
-        try:
-            cfp.read(config_file)
-        except ConfigParser.Error:
-            continue
-
-        app_sets = []
-
-        for section in cfp.sections():
-            try:
-                realm = cfp.get(section, "realm")
-            except ConfigParser.NoOptionError:
-                realm = None
-            try:
-                consumer_key = cfp.get(section, "consumer_key")
-            except ConfigParser.NoOptionError:
-                consumer_key = None
-            try:
-                exe_path = cfp.get(section, "exe_path")
-            except ConfigParser.NoOptionError:
-                exe_path = None
-            try:
-                application_name = cfp.get(section, "application_name")
-            except ConfigParser.NoOptionError:
-                application_name = None
-            if realm and consumer_key and exe_path and application_name:
-                app_sets.append((realm, consumer_key, exe_path,
-                                 application_name))
-        if app_sets:
-            set_single_acl(app_sets, specific_item_id=item_id)
-

=== modified file 'ubuntu_sso/keyring.py'
--- ubuntu_sso/keyring.py	2010-08-27 22:16:40 +0000
+++ ubuntu_sso/keyring.py	2010-09-09 14:47:44 +0000
@@ -25,8 +25,12 @@
 
 import gnomekeyring
 
-from ubuntu_sso.logger import setupLogging
-logger = setupLogging("ubuntu_sso.main")
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging("ubuntu_sso.main")
+TOKEN_SEPARATOR = ' @ '
+SEPARATOR_REPLACEMENT = ' AT '
 
 U1_APP_NAME = "Ubuntu One"
 U1_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
@@ -36,14 +40,22 @@
 }
 
 
-def get_token_name(app_name):
-    """Build the token name."""
+def get_old_token_name(app_name):
+    """Build the token name (old style)."""
     quoted_app_name = urllib.quote(app_name)
     computer_name = socket.gethostname()
     quoted_computer_name = urllib.quote(computer_name)
     return "%s - %s" % (quoted_app_name, quoted_computer_name)
 
 
+def get_token_name(app_name):
+    """Build the token name."""
+    computer_name = socket.gethostname()
+    computer_name = computer_name.replace(TOKEN_SEPARATOR,
+                                          SEPARATOR_REPLACEMENT)
+    return TOKEN_SEPARATOR.join((app_name, computer_name)).encode('utf-8')
+
+
 class Keyring(object):
     """A Keyring for a given application name."""
     KEYRING_NAME = "login"
@@ -61,12 +73,14 @@
         if not name in keyring_names:
             gnomekeyring.create_sync(name)
 
-    def _find_keyring_item(self):
+    def _find_keyring_item(self, attr=None):
         """Return the keyring item or None if not found."""
+        if attr is None:
+            attr = self._get_keyring_attr()
         try:
             items = gnomekeyring.find_items_sync(
                                         gnomekeyring.ITEM_GENERIC_SECRET,
-                                        self._get_keyring_attr())
+                                        attr)
         except gnomekeyring.NoMatchError:
             # if no items found, return None
             return None
@@ -98,10 +112,24 @@
                 gnomekeyring.ITEM_GENERIC_SECRET, self.app_name,
                 self._get_keyring_attr(), secret, True)
 
+    def _migrate_old_token_name(self):
+        """Migrate credentials with old name, store them with new name."""
+        attr = self._get_keyring_attr()
+        attr['token-name'] = get_old_token_name(self.app_name)
+        item = self._find_keyring_item(attr=attr)
+        if item is not None:
+            self.set_ubuntusso_attr(dict(urlparse.parse_qsl(item.secret)))
+            gnomekeyring.item_delete_sync(item.keyring, item.item_id)
+
+        return self._find_keyring_item()
+
     def get_ubuntusso_attr(self):
         """Return the secret of the SSO item in a dictionary."""
         # If we have no attributes, return None
         item = self._find_keyring_item()
+        if item is None:
+            item = self._migrate_old_token_name()
+
         if item is not None:
             return dict(urlparse.parse_qsl(item.secret))
         else:
@@ -119,6 +147,7 @@
 
 
 class UbuntuOneOAuthKeyring(Keyring):
+    """A particular Keyring for Ubuntu One."""
 
     def _get_keyring_attr(self):
         """Build the keyring attributes for this credentials."""
@@ -144,6 +173,8 @@
 
 
 if __name__ == "__main__":
+    # pylint: disable=C0103
+
     kr1 = Keyring("Test key 1")
     kr2 = Keyring("Test key 2")
 

=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2010-08-11 17:03:11 +0000
+++ ubuntu_sso/logger.py	2010-09-09 14:47:44 +0000
@@ -1,6 +1,7 @@
 # ubuntu_sso.logger - logging miscellany
 #
 # Author: Stuart Langridge <[e-mail]>
+# Author: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2009 Canonical Ltd.
 #
@@ -26,34 +27,35 @@
 
 from logging.handlers import RotatingFileHandler
 
-home = xdg.BaseDirectory.xdg_cache_home
-LOGFOLDER = os.path.join(home, 'sso')
+LOGFOLDER = os.path.join(xdg.BaseDirectory.xdg_cache_home, 'sso')
 # create log folder if it doesn't exists
 if not os.path.exists(LOGFOLDER):
     os.makedirs(LOGFOLDER)
 
 LOGFILENAME = os.path.join(LOGFOLDER, 'oauth-login.log')
-
-# Only log this level and above
-LOG_LEVEL = logging.DEBUG # logging.INFO
-
-root_formatter = logging.Formatter(
-    fmt="%(asctime)s:%(msecs)s %(name)s %(message)s")
-root_handler = RotatingFileHandler(LOGFILENAME, maxBytes=1048576,
-                                   backupCount=1)
-root_handler.setLevel(LOG_LEVEL)
-root_handler.setFormatter(root_formatter)
-
-
-def setupLogging(log_domain):
+FMT = "%(asctime)s:%(msecs)s - %(name)s - %(levelname)s - %(message)s"
+
+if os.environ.get('DEBUG'):
+    LOG_LEVEL = logging.DEBUG
+else:
+    # Only log this level and above
+    LOG_LEVEL = logging.INFO
+
+
+def setup_logging(log_domain):
     """Create basic logger to set filename"""
+    root_formatter = logging.Formatter(fmt=FMT)
+    root_handler = RotatingFileHandler(LOGFILENAME, maxBytes=1048576,
+                                       backupCount=5)
+    root_handler.setLevel(LOG_LEVEL)
+    root_handler.setFormatter(root_formatter)
+
     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-08-27 22:16:40 +0000
+++ ubuntu_sso/main.py	2010-09-09 14:47:44 +0000
@@ -1,8 +1,5 @@
-#!/usr/bin/python
-
 # ubuntu_sso.main - main login handling interface
 #
-# Author: Stuart Langridge <[e-mail]>
 # Author: Natalia Bidart <[e-mail]>
 # Author: Alejandro J. Cura <[e-mail]>
 #
@@ -19,43 +16,45 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""OAuth login handler.
-
-A command-line utility which accepts requests for OAuth login over D-Bus,
-handles the OAuth process (including adding the OAuth access token to the
-gnome keyring), and then alerts the calling app (and others) with a D-Bus
-signal so they can retrieve the new token.
+"""Single Sign On login handler.
+
+An utility which accepts requests for Ubuntu Single Sign On login over D-Bus.
+
+The OAuth process is handled, including adding the OAuth access token to the
+gnome keyring.
+
 """
 
+import os
 import re
-import time
 import threading
 import traceback
 import urllib2
-import urlparse
 
 import dbus.service
 import gobject
 
-from dbus.mainloop.glib import DBusGMainLoop
+# Unable to import 'lazr.restfulclient.*'
+# pylint: disable=F0401
 from lazr.restfulclient.authorize import BasicHttpAuthorizer
 from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
 from lazr.restfulclient.errors import HTTPError
 from lazr.restfulclient.resource import ServiceRoot
+# pylint: enable=F0401
 from oauth import oauth
 
-from ubuntu_sso import (DBUS_IFACE_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 import DBUS_IFACE_USER_NAME, DBUS_IFACE_CRED_NAME, gui
 from ubuntu_sso.keyring import Keyring, get_token_name, U1_APP_NAME
-from ubuntu_sso.logger import setupLogging
-logger = setupLogging("ubuntu_sso.main")
-
-DBusGMainLoop(set_as_default=True)
+from ubuntu_sso.logger import setup_logging
+
+
 # Disable the invalid name warning, as we have a lot of DBus style names
-# pylint: disable-msg=C0103
-
-PING_URL = "http://edge.one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+# pylint: disable=C0103
+
+
+logger = setup_logging("ubuntu_sso.main")
+PING_URL = "https://edge.one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+SERVICE_URL = "https://login.ubuntu.com/api/1.0"
 
 
 class NoDefaultConfigError(Exception):
@@ -99,16 +98,15 @@
 
 def keyring_store_credentials(app_name, credentials):
     """Store the credentials in the keyring."""
-    logger.debug('keyring_store_credentials: app_name %r.', app_name)
+    logger.info('keyring_store_credentials: app_name "%s".', app_name)
     Keyring(app_name).set_ubuntusso_attr(credentials)
 
 
 def keyring_get_credentials(app_name):
     """Get the credentials from the keyring or None if not there."""
-    logger.debug('keyring_get_credentials: app_name %r', app_name)
     creds = Keyring(app_name).get_ubuntusso_attr()
-    logger.debug('keyring_get_credentials: Keyring returned credentials? %r',
-                 creds is not None)
+    logger.info('keyring_get_credentials: app_name "%s", resulting credentials'
+                ' is not None? %r', app_name, creds is not None)
     return creds
 
 
@@ -122,11 +120,10 @@
         else:
             self.sso_service_class = sso_service_class
 
-        self.service_url = 'https://login.ubuntu.com/api/1.0'
+        self.service_url = os.environ.get('USSOC_SERVICE_URL', SERVICE_URL)
 
     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):
@@ -294,7 +291,7 @@
         """The part that runs inside the thread."""
         try:
             result_cb(app_name, f())
-        except Exception, e:
+        except Exception, e:  # pylint: disable=W0703
             msg = "Exception while running DBus blocking code in a thread:"
             logger.exception(msg)
             error_cb(app_name, except_to_errdict(e))
@@ -304,6 +301,9 @@
 class SSOLogin(dbus.service.Object):
     """Login thru the Single Sign On service."""
 
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
     def __init__(self, bus_name,
                  sso_login_processor_class=SSOLoginProcessor,
                  sso_service_class=None):
@@ -322,10 +322,14 @@
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def CaptchaGenerated(self, app_name, result):
         """Signal thrown after the captcha is generated."""
+        logger.debug('SSOLogin: emitting CaptchaGenerated with app_name "%s" '
+                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def CaptchaGenerationError(self, app_name, error):
         """Signal thrown when there's a problem generating the captcha."""
+        logger.debug('SSOLogin: emitting CaptchaGenerationError with '
+                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ss')
@@ -341,10 +345,14 @@
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def UserRegistered(self, app_name, result):
         """Signal thrown when the user is registered."""
+        logger.debug('SSOLogin: emitting UserRegistered with app_name "%s" '
+                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def UserRegistrationError(self, app_name, error):
         """Signal thrown when there's a problem registering the user."""
+        logger.debug('SSOLogin: emitting UserRegistrationError with '
+                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='sssss')
@@ -361,10 +369,14 @@
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def LoggedIn(self, app_name, result):
         """Signal thrown when the user is logged in."""
+        logger.debug('SSOLogin: emitting LoggedIn with app_name "%s" '
+                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def LoginError(self, app_name, error):
         """Signal thrown when there is a problem in the login."""
+        logger.debug('SSOLogin: emitting LoginError with '
+                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='sss')
@@ -387,10 +399,14 @@
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def EmailValidated(self, app_name, result):
         """Signal thrown after the email is validated."""
+        logger.debug('SSOLogin: emitting EmailValidated with app_name "%s" '
+                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def EmailValidationError(self, app_name, error):
         """Signal thrown when there's a problem validating the email."""
+        logger.debug('SSOLogin: emitting EmailValidationError with '
+                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssss')
@@ -407,12 +423,16 @@
 
     # request_password_reset_token signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def PasswordResetTokenSent(self, app_name, email):
+    def PasswordResetTokenSent(self, app_name, result):
         """Signal thrown when the token is succesfully sent."""
+        logger.debug('SSOLogin: emitting PasswordResetTokenSent with app_name '
+                     '"%s" and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def PasswordResetError(self, app_name, error):
         """Signal thrown when there's a problem sending the token."""
+        logger.debug('SSOLogin: emitting PasswordResetError with '
+                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ss')
@@ -426,12 +446,16 @@
 
     # set_new_password signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def PasswordChanged(self, app_name, email):
+    def PasswordChanged(self, app_name, result):
         """Signal thrown when the token is succesfully sent."""
+        logger.debug('SSOLogin: emitting PasswordChanged with app_name "%s" '
+                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def PasswordChangeError(self, app_name, error):
         """Signal thrown when there's a problem sending the token."""
+        logger.debug('SSOLogin: emitting PasswordChangeError with '
+                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssss')
@@ -447,23 +471,38 @@
 class SSOCredentials(dbus.service.Object):
     """DBus object that gets credentials, and login/registers if needed."""
 
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
+    def __init__(self, *args, **kwargs):
+        dbus.service.Object.__init__(self, *args, **kwargs)
+        self.ping_url = os.environ.get('USSOC_PING_URL', PING_URL)
+
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
     def AuthorizationDenied(self, app_name):
         """Signal thrown when the user denies the authorization."""
+        logger.info('SSOLogin: emitting AuthorizationDenied with app_name '
+                    '"%s"', app_name)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sa{ss}")
     def CredentialsFound(self, app_name, credentials):
         """Signal thrown when the credentials are found."""
+        logger.info('SSOLogin: emitting CredentialsFound with app_name "%s"',
+                    app_name)
 
     @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sss")
     def CredentialsError(self, app_name, error_message, detailed_error):
         """Signal thrown when there is a problem finding the credentials."""
+        logger.debug('SSOCredentials: emitting CredentialsError with app_name '
+                     '"%s" and error_message %r', app_name, error_message)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature="s", out_signature="a{ss}")
     def find_credentials(self, app_name):
         """Get the credentials from the keyring or '' if not there."""
         token = keyring_get_credentials(app_name)
+        logger.info('find_credentials: app_name "%s", result is {}? %s',
+                    app_name, token is None)
         if token is None:
             return {}
         else:
@@ -476,7 +515,7 @@
             creds = keyring_get_credentials(app_name)
             self._ping_url(app_name, email, creds)
             self.CredentialsFound(app_name, creds)
-        except Exception:
+        except:  # pylint: disable=W0702
             msg = "Problem getting the credentials from the keyring."
             logger.exception(msg)
             self.CredentialsError(app_name, msg, traceback.format_exc())
@@ -493,9 +532,9 @@
 
     def _ping_url(self, app_name, email, credentials):
         """Ping the given url."""
-        logger.info('Maybe pinging url %s for app_name %r', PING_URL, app_name)
+        logger.info('Maybe pinging server for app_name "%s"', app_name)
         if app_name == U1_APP_NAME:
-            url = PING_URL + email
+            url = self.ping_url + email
             consumer = oauth.OAuthConsumer(credentials['consumer_key'],
                                            credentials['consumer_secret'])
             token = oauth.OAuthToken(credentials['token'],
@@ -506,8 +545,8 @@
             oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
                                    consumer, token)
             request = urllib2.Request(url, headers=oauth_req.to_header())
-            logger.debug('Opening the ping url with urllib2.urlopen. ' \
-                         'Request to: %s', request.get_full_url())
+            logger.debug('Opening the ping url %s with urllib2.urlopen. ' \
+                         'Request to: %s', PING_URL, request.get_full_url())
             response = urllib2.urlopen(request)
             logger.debug('Url opened. Response: %s.', response.code)
             return response.code
@@ -525,7 +564,7 @@
             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:
+        except:  # pylint: disable=W0702
             msg = '_show_login_or_register_ui failed when calling ' \
                   'gui.UbuntuSSOClientGUI(%r, %r, %r, %r, %r)'
             logger.exception(msg, app_name, tc_url, help_text,
@@ -556,7 +595,7 @@
                                  help_text, window_id)
             else:
                 self.CredentialsFound(app_name, token)
-        except Exception:
+        except:  # pylint: disable=W0702
             msg = "Problem getting the credentials from the keyring."
             logger.exception(msg)
             self.CredentialsError(app_name, msg, traceback.format_exc())
@@ -586,7 +625,7 @@
                                  help_text, window_id)
             else:
                 self.CredentialsFound(app_name, token)
-        except Exception:
+        except:  # pylint: disable=W0702
             msg = "Problem getting the credentials from the keyring."
             logger.exception(msg)
             self.CredentialsError(app_name, msg, traceback.format_exc())
@@ -601,254 +640,7 @@
         try:
             creds = Keyring(app_name)
             creds.delete_ubuntusso_attr()
-        except Exception:
+        except:  # pylint: disable=W0702
             logger.exception(
                 "problem removing credentials from keyring for %s",
                 app_name)
-
-
-class LoginProcessor:
-    """Actually do the work of processing passed parameters."""
-
-    def __init__(self, dbus_object):
-        """Initialize the login processor."""
-        logger.debug("Creating a LoginProcessor")
-        self.note1 = None
-        self.realm = None
-        self.consumer_key = None
-        self.dbus_object = dbus_object
-        logger.debug("Getting configuration")
-        self.config = get_config()
-
-    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.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='%s', secret='%s'", request_token_url,
-                     user_authorisation_url, access_token_url, consumer_secret)
-
-        from ubuntu_sso.auth import AuthorisationClient
-        client = AuthorisationClient(self.realm,
-                                     request_token_url,
-                                     user_authorisation_url,
-                                     access_token_url, self.consumer_key,
-                                     consumer_secret,
-                                     callback_parent=self.got_token,
-                                     callback_denied=self.got_denial,
-                                     callback_notoken=self.got_no_token,
-                                     callback_error=self.got_error,
-                                     do_login=do_login)
-
-        logger.debug("Calling auth.client.ensure_access_token in thread")
-        gobject.timeout_add_seconds(1, client.ensure_access_token)
-
-    def clear_token(self, realm, consumer_key):
-        """Remove the currently stored OAuth token from the keyring."""
-        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)
-        from ubuntu_sso.auth import AuthorisationClient
-        client = AuthorisationClient(self.realm,
-                                     request_token_url,
-                                     user_authorisation_url,
-                                     access_token_url,
-                                     self.consumer_key, consumer_secret,
-                                     callback_parent=self.got_token,
-                                     callback_denied=self.got_denial,
-                                     callback_notoken=self.got_no_token,
-                                     callback_error=self.got_error)
-        gobject.timeout_add_seconds(1, client.clear_token)
-
-    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
-
-    def get_config_urls(self, realm):
-        """Look up the URLs to use in the config file"""
-        logger.debug("Fetching config URLs for realm='%s'", realm)
-        if self.config.has_section(realm):
-            logger.debug("Realm '%s' is in config", realm)
-            request_token_url = self.__get_url(realm, "request_token_url")
-            user_authorisation_url = self.__get_url(realm,
-              "user_authorisation_url")
-            access_token_url = self.__get_url(realm, "access_token_url")
-            consumer_secret = self.__get_option(realm, "consumer_secret")
-        elif realm.startswith("http://localhost") and \
-          self.config.has_section("http://localhost"):
-            logger.debug("Realm is localhost and is in config")
-            request_token_url = self.__get_url("http://localhost",
-              "request_token_url", realm)
-            user_authorisation_url = self.__get_url("http://localhost",
-              "user_authorisation_url", realm)
-            access_token_url = self.__get_url("http://localhost",
-              "access_token_url", realm)
-            consumer_secret = self.__get_option("http://localhost",
-              "consumer_secret")
-        elif self.is_valid_url(realm):
-            logger.debug("Realm '%s' is not in config", realm)
-            request_token_url = self.__get_url("default",
-              "request_token_url", realm)
-            user_authorisation_url = self.__get_url("default",
-              "user_authorisation_url", realm)
-            access_token_url = self.__get_url("default",
-              "access_token_url", realm)
-            consumer_secret = self.__get_option(realm, "consumer_secret")
-        else:
-            logger.debug("Realm '%s' is a bad realm", realm)
-            raise BadRealmError
-        return (request_token_url, user_authorisation_url,
-                access_token_url, consumer_secret)
-
-    def is_valid_url(self, url):
-        """Simple check for URL validity"""
-        # pylint: disable-msg=W0612
-        scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
-        if scheme and netloc:
-            return True
-        else:
-            return False
-
-    def got_token(self, access_token):
-        """Callback function when access token has been retrieved"""
-        logger.debug("Token retrieved, calling NewCredentials function")
-        self.dbus_object.NewCredentials(self.realm, self.consumer_key)
-
-    def got_denial(self):
-        """Callback function when request token has been denied"""
-        self.dbus_object.AuthorizationDenied()
-
-    def got_no_token(self):
-        """Callback function when access token is not in keyring."""
-        self.dbus_object.NoCredentials()
-
-    def got_error(self, message):
-        """Callback function to emit an error message over DBus."""
-        self.dbus_object.OAuthError(message)
-
-    def __get_url(self, realm, option, actual_realm=None):
-        """Construct a full URL from realm and a URLpath for that realm in
-           the config file."""
-        if actual_realm:
-            realm_to_use = actual_realm
-        else:
-            realm_to_use = realm
-        urlstub = self.__get_option(realm, option)
-        return urlparse.urljoin(realm_to_use, urlstub)
-
-    def __get_option(self, realm, option):
-        """Return a specific option for that realm in
-           the config file. If the realm does not exist in the config file,
-           fall back to the [default] section."""
-        if self.config.has_section(realm) and \
-           self.config.has_option(realm, option):
-            urlstub = self.config.get(realm, option)
-            return urlstub
-
-        # either the realm exists and this url does not, or
-        # the realm doesn't exist; either way, fall back to [default] section
-        urlstub = self.config.get("default", option, None)
-        if urlstub is not None:
-            return urlstub
-
-        # this url does not exist in default section either
-        # this shouldn't happen
-        raise NoDefaultConfigError("No default configuration for %s" % option)
-
-
-class Login(dbus.service.Object):
-    """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)
-        self.processor = LoginProcessor(self)
-        self.currently_authing = False
-        logger.debug("Login D-Bus service starting up")
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_AUTH_NAME,
-                         in_signature='ss', out_signature='')
-    def login(self, realm, consumer_key):
-        """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:
-            logger.debug("Currently in the middle of OAuth: rejecting this")
-            return
-        self.currently_authing = True
-        self.processor.login(realm, consumer_key)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_AUTH_NAME,
-                         in_signature='ssb', out_signature='')
-    def maybe_login(self, realm, consumer_key, do_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:
-            logger.debug("Currently in the middle of OAuth: rejecting this")
-            return
-        self.currently_authing = True
-        self.processor.login(realm, consumer_key, do_login)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_AUTH_NAME,
-                         in_signature='ss', out_signature='')
-    def clear_token(self, realm, consumer_key):
-        """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')
-    def NewCredentials(self, realm, consumer_key):
-        """Fire D-Bus signal when the user accepts authorization."""
-        logger.debug("Firing the NewCredentials signal")
-        self.currently_authing = False
-        return (self.processor.realm, self.processor.consumer_key)
-
-    @dbus.service.signal(dbus_interface=DBUS_IFACE_AUTH_NAME)
-    def AuthorizationDenied(self):
-        """Fire the signal when the user denies authorization."""
-        self.currently_authing = False
-
-    @dbus.service.signal(dbus_interface=DBUS_IFACE_AUTH_NAME)
-    def NoCredentials(self):
-        """Fired when the user does not have a token in the keyring."""
-        self.currently_authing = False
-
-    @dbus.service.signal(dbus_interface=DBUS_IFACE_AUTH_NAME, signature='s')
-    def OAuthError(self, message):
-        """Fire the signal when an error needs to be propagated to the user."""
-        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
-    glib2reactor.install()
-    from twisted.internet import reactor
-
-    logger.debug("Creating the D-Bus service")
-    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
-    # this means that this app can be started from an x-ubutnuone: URL
-    # to kick off the signin process
-    logger.debug("Starting the reactor mainloop")
-    reactor.run()

=== modified file 'ubuntu_sso/networkstate.py'
--- ubuntu_sso/networkstate.py	2010-08-11 17:03:11 +0000
+++ ubuntu_sso/networkstate.py	2010-09-09 14:47:44 +0000
@@ -19,13 +19,13 @@
 
 import dbus
 
-from ubuntu_sso.logger import setupLogging
-logger = setupLogging("ubuntu_sso.networkstate")
+from ubuntu_sso.logger import setup_logging
+logger = setup_logging("ubuntu_sso.networkstate")
 
 # Values returned by the callback
 ONLINE, OFFLINE, UNKNOWN = object(), object(), object()
 
-nm_state_names = {
+NM_STATE_NAMES = {
     ONLINE: "online",
     OFFLINE: "offline",
     UNKNOWN: "unknown",
@@ -46,10 +46,10 @@
 class NetworkManagerState(object):
     """Checks the state of NetworkManager thru DBus."""
 
-    def __init__(self, result_cb, dbus=dbus):
+    def __init__(self, result_cb, dbus_module=dbus):
         """Initialize this instance with a result and error callbacks."""
         self.result_cb = result_cb
-        self.dbus = dbus
+        self.dbus = dbus_module
         self.state_signal = None
 
     def call_result_cb(self, state):
@@ -102,5 +102,5 @@
             nm_proxy.Get(NM_DBUS_INTERFACE, "State",
                          reply_handler=self.got_state,
                          error_handler=self.got_error)
-        except Exception, e:
+        except Exception, e:  # pylint: disable=W0703
             self.got_error(e)

=== added directory 'ubuntu_sso/tests/bin'
=== added file 'ubuntu_sso/tests/bin/show_gui'
--- ubuntu_sso/tests/bin/show_gui	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/bin/show_gui	2010-09-09 14:47:44 +0000
@@ -0,0 +1,57 @@
+#!/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
+import sys
+
+from ubuntu_sso.gui import UbuntuSSOClientGUI
+
+
+APP_NAME = 'Ubuntu'
+TC_URI = 'http://one.ubuntu.com/terms'
+HELP_TEXT = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
+            'Nam sed lorem nibh. Suspendisse gravida nulla non nunc suscipit' \
+            ' pulvinar tempus ut augue.'
+
+main_quit = lambda *args, **kwargs: gtk.main_quit()
+
+
+if __name__ == '__main__':
+    tc_uri=TC_URI
+    login_only = False
+    xid = 0
+
+    if '--login' in sys.argv:
+        login_only = True
+        tc_uri = None
+
+    if '--with-parent-window' in sys.argv:
+        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
+
+    UbuntuSSOClientGUI(close_callback=main_quit, app_name=APP_NAME,
+                       tc_uri=tc_uri, help_text=HELP_TEXT, window_id=xid,
+                       login_only=login_only)
+    gtk.main()

=== added file 'ubuntu_sso/tests/bin/show_nm_state'
--- ubuntu_sso/tests/bin/show_nm_state	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/bin/show_nm_state	2010-09-09 14:47:44 +0000
@@ -0,0 +1,41 @@
+#!/usr/bin/python
+
+# 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()

=== added directory 'ubuntu_sso/tests/files'
=== added file 'ubuntu_sso/tests/files/captcha.png'
Binary files ubuntu_sso/tests/files/captcha.png	1970-01-01 00:00:00 +0000 and ubuntu_sso/tests/files/captcha.png	2010-09-09 14:47:44 +0000 differ
=== removed file 'ubuntu_sso/tests/test_auth.py'
--- ubuntu_sso/tests/test_auth.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/tests/test_auth.py	1970-01-01 00:00:00 +0000
@@ -1,261 +0,0 @@
-# test_auth - Tests for ubuntu_sso.auth module
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the OAuth client code for StorageFS."""
-
-import gnomekeyring
-from mocker import ANY, IN, MockerTestCase
-import testresources
-
-from oauth import oauth
-from twisted.trial.unittest import TestCase as TwistedTestCase
-from ubuntu_sso.auth import AuthorisationClient, NoAccessToken
-
-
-# Adding TwistedTestCase as parent to be able to skip
-# test_ensure_access_token_no_token
-class AuthorisationClientTests(MockerTestCase, TwistedTestCase):
-    """Test the GNOME keyring integration portions of the auth code."""
-
-    def setUp(self):
-        """Sets up a mock keyring."""
-        MockerTestCase.setUp(self)
-        self.keyring = self.mocker.mock()
-        self.client = None
-        self.item = self.mocker.mock(gnomekeyring.Found)
-
-        self.item_id = 999
-
-        ex = self.expect(self.item.item_id)
-        ex.result(self.item_id)
-        ex.count(0, None)
-
-        ex = self.expect(self.item.secret)
-        ex.result('oauth_token=access_key&oauth_token_secret=access_secret')
-        ex.count(0, None)
-
-    def expect_token_query(self):
-        """Expects the keyring to be queried for a token."""
-        return self.expect(
-            self.keyring.find_items_sync(
-                gnomekeyring.ITEM_GENERIC_SECRET,
-                {'ubuntuone-realm': 'realm',
-                 'oauth-consumer-key': 'consumer_key'})
-            )
-
-    def expect_token_store(self):
-        """Expects the token to be stored in the keyring."""
-        return self.expect(self.keyring.item_create_sync(
-                None, gnomekeyring.ITEM_GENERIC_SECRET,
-                'UbuntuOne token for realm',
-                {'ubuntuone-realm': 'realm',
-                 'oauth-consumer-key': 'consumer_key'},
-                # Either order for the token and secret is valid
-                IN(['oauth_token=access_key&oauth_token_secret=access_secret',
-                    'oauth_token_secret=access_secret&oauth_token=access_key']),
-                True))
-
-    def expect_token_store_denied(self):
-        """Expects the token to be denied for storing in keyring."""
-        self.expect_token_store().throw(gnomekeyring.DeniedError)
-
-    def mock_has_token(self):
-        """Mocks a cached token in the keyring."""
-        self.expect_token_query().result([self.item])
-
-    def mock_no_token(self, exception):
-        """Mocks no token in the keyring."""
-        self.expect_token_query().throw(exception)
-
-    def replay(self, callback_parent=None, callback_denied=None,
-                     do_login=True):
-        """Starts the replay phase and sets up a client object to be tested,
-        wired up to the mock keyring.
-
-        """
-        self.mocker.replay()
-        self.client = AuthorisationClient(
-            'realm', 'request_token_url', 'user_authorisation_url',
-            'access_token_url', 'consumer_key', 'consumer_secret',
-            callback_parent, callback_denied, do_login, keyring=self.keyring)
-
-    def test_get_access_token(self):
-        """The get_access_token method returns the access token"""
-        self.mock_has_token()
-        self.replay()
-        token = self.client.get_access_token()
-        self.assertTrue(isinstance(token, oauth.OAuthToken))
-        self.assertEqual(token.key, 'access_key')
-        self.assertEqual(token.secret, 'access_secret')
-
-    def test_get_access_token_no_match(self):
-        """The get_access_token method fails if there are no matching items"""
-        self.mock_no_token(gnomekeyring.NoMatchError)
-        self.replay()
-        self.assertRaises(NoAccessToken, self.client.get_access_token)
-
-    def test_get_access_token_denied(self):
-        """The get_access_token method fails if access is denied"""
-        self.mock_no_token(gnomekeyring.DeniedError)
-        self.replay()
-        self.assertRaises(NoAccessToken, self.client.get_access_token)
-
-    def test_have_access_token(self):
-        """The `have_access_token` method returns True if a the
-        keyring contains a token."""
-        self.mock_has_token()
-        self.replay()
-        self.assertEqual(self.client.have_access_token(), True)
-
-    def test_have_access_token_fail(self):
-        """The `have_access_token` method returns False if the keyring
-        does not contain a token."""
-        self.mock_no_token(gnomekeyring.NoMatchError)
-        self.replay()
-        self.assertEqual(self.client.have_access_token(), False)
-
-    def test_store_token(self):
-        """The store_token method correctly stores an item in the keyring,
-           and correctly sets an ACL on it."""
-        self.expect_token_store().result(self.item_id)
-        saka = self.mocker.replace("ubuntu_sso.key_acls.set_all_key_acls")
-        saka(item_id=self.item_id)
-        self.mocker.result(None)
-
-        sleep = self.mocker.replace("time.sleep")
-        sleep(4)
-        self.mocker.result(None)
-
-        self.replay()
-        self.client.store_token(oauth.OAuthToken('access_key', 'access_secret'))
-
-    def test_store_token_denied(self):
-        """The store_token method correctly stores an item in the keyring,
-           and correctly sets an ACL on it."""
-        self.expect_token_store_denied()
-
-        self.replay()
-        self.client.store_token(oauth.OAuthToken('access_key', 'access_secret'))
-
-    def test_clear_existing_token(self):
-        """Makes sure that clear token clears an existing token."""
-        self.mock_has_token()
-        self.expect(self.keyring.item_delete_sync(None, self.item_id))
-        self.replay()
-        self.client.clear_token()
-
-    def test_clear_no_existing_token(self):
-        """Makes sure that clear with no existing token still works."""
-        self.mock_no_token(gnomekeyring.NoMatchError)
-        self.replay()
-        self.client.clear_token()
-
-    def test_ensure_access_token(self):
-        """If the user already has a token, no new token is requested."""
-        self.mock_has_token()
-        callback_function = self.mocker.mock()
-        callback_function(ANY)
-        self.replay(callback_parent=callback_function)
-        self.client.ensure_access_token()
-
-    def test_ensure_access_token_no_token(self):
-        """If the user has no token, a new one is requested and stored, via
-           an OAuth callback to the internal webserver."""
-
-        self.mock_no_token(gnomekeyring.NoMatchError)
-
-        request_token = self.mocker.mock()
-        self.expect(request_token.key).result('access_key').count(0, None)
-        ex = self.expect(request_token.secret)
-        ex.result('access_secret').count(0, None)
-        make_token_request = self.mocker.mock()
-        self.expect(make_token_request(ANY)).result(request_token)
-
-        open_in_browser = self.mocker.mock()
-        open_in_browser(ANY)
-
-        ri = self.mocker.replace("random.randint")
-        ri(1000000, 10000000)
-        self.mocker.result(12345678)
-        get_temporary_httpd = self.mocker.mock()
-        get_temporary_httpd(12345678, ANY, True)
-        self.mocker.result("http://callbackurl")
-
-        self.replay(callback_parent=lambda a: None)
-
-        self.client.make_token_request = make_token_request
-        self.client.open_in_browser = open_in_browser
-        self.client.get_temporary_httpd = get_temporary_httpd
-        # skip the "are we online, via networkmanager" bit
-        self.client.acquire_access_token_if_online = \
-            self.client.acquire_access_token
-        self.client.ensure_access_token()
-    test_ensure_access_token_no_token.skip = \
-        "Fails with exceptions.AssertionError: [Mocker] Unmet expectations, "\
-        "see bug #488933"
-
-
-class AcquireAccessTokenTests(testresources.ResourcedTestCase):
-    """OAuth token acquisition tests."""
-
-    def setUp(self):
-        super(AcquireAccessTokenTests, self).setUp()
-
-    def tearDown(self):
-        super(AcquireAccessTokenTests, self).tearDown()
-
-    def test_acquire_access_token(self):
-        """Test that acquire_access_token() can acquire the access token."""
-
-        def make_token_request(oauth_request):
-            """Make an OAuth token request via the test browser."""
-            return oauth.OAuthToken.from_string("oauth_token=access_token&" +
-                                                "oauth_token_secret=" +
-                                                "access_secret")
-
-        def open_in_browser(url):
-            """Just return as we aren't subscribed to the page."""
-            return
-
-        def got_token(token):
-            """Called with the token once auth is completed"""
-            self.assertTrue(isinstance(token, oauth.OAuthToken))
-
-        def get_temporary_httpd(nonce, retrieve_function, store):
-            """Mock the temporary httpd and return a callback URL"""
-            # returns callback URL; this is an invalid URL, of course,
-            # (port is too high) but we check later that the mechanize
-            # browser tries to navigate there
-            return "http://localhost:99999/?nonce=99999"
-
-        def store_token(token):
-            """Don't use the keyring; do nothing"""
-            pass
-
-        client = AuthorisationClient(
-            'http://ubuntuone/',
-            'http://ubuntuone/oauth/request/',
-            'http://ubuntuone/oauth/authorize/',
-            'http://ubuntuone/oauth/access/',
-            'consumer_key', 'consumer_secret',
-            callback_parent=got_token)
-        client.make_token_request = make_token_request
-        client.open_in_browser = open_in_browser
-        client.get_temporary_httpd = get_temporary_httpd
-        client.store_token = store_token
-
-        client.acquire_access_token('token description')

=== removed file 'ubuntu_sso/tests/test_config.py'
--- ubuntu_sso/tests/test_config.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/tests/test_config.py	1970-01-01 00:00:00 +0000
@@ -1,85 +0,0 @@
-# test_config - tests for ubuntu_sso.config
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the OAuth client code for StorageFS."""
-
-import os, StringIO
-from mocker import MockerTestCase
-from ubuntu_sso import config
-from ubuntu_sso.config import get_config
-
-class ConfigFileTests(MockerTestCase):
-    """Test the config file finder."""
-
-    def test_get_file_from_tmp(self):
-        """Does the tmp file get chosen?"""
-        # mock that tmp config file exists
-        tmp_config_file = os.path.realpath(os.path.join(
-          os.path.split(config.__file__)[0], "../../data/oauth_urls"
-        ))
-        osp = self.mocker.replace("os.path")
-        osp.isfile(tmp_config_file)
-        self.mocker.result(True)
-        self.mocker.replay()
-
-        conf = get_config()
-        self.assertEqual(conf.FILENAME, tmp_config_file)
-
-    def test_get_file_from_home(self):
-        """Does our home config file get chosen?"""
-        # mock that home config file exists
-        home_config_file = os.path.expanduser("~/.config/ubuntu-sso/oauth_urls")
-        osp = self.mocker.replace("os.path")
-        osp.exists(home_config_file)
-        self.mocker.result(True)
-        self.mocker.replay()
-
-        conf = get_config(use_tmpconfig=False) # pretend not in source tree
-        self.assertEqual(conf.FILENAME, home_config_file)
-
-    def test_get_file_from_etc(self):
-        """Does our /etc config file get chosen?"""
-        # mock that etc config file exists
-        etc_config_file = os.path.expanduser("/etc/xdg/ubuntu-sso/oauth_urls")
-        osp = self.mocker.replace("os.path")
-        osp.exists(etc_config_file)
-        self.mocker.result(True)
-        self.mocker.replay()
-
-        conf = get_config(use_tmpconfig=False) # pretend not in source tree
-        self.assertEqual(conf.FILENAME, etc_config_file)
-
-    def test_tmp_file_parses(self):
-        """Does the tmp file get chosen and parse correctly?"""
-        # mock that tmp config file exists
-        tmp_config_file = os.path.realpath(os.path.join(
-          os.path.split(config.__file__)[0], "../../data/oauth_urls"
-        ))
-        osp = self.mocker.replace("os.path")
-        osp.isfile(tmp_config_file)
-        self.mocker.result(True)
-
-        sio = StringIO.StringIO("[default]\n")
-        mock_open = self.mocker.replace(open)
-        mock_open(tmp_config_file)
-        self.mocker.result(sio)
-
-        self.mocker.replay()
-
-        conf = get_config()
-        self.assertTrue(conf.has_section("default"))
-

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-08-27 22:16:40 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-09-09 14:47:44 +0000
@@ -33,6 +33,12 @@
 from ubuntu_sso import gui
 
 
+# Access to a protected member 'yyy' of a client class
+# pylint: disable=W0212
+# Instance of 'UbuntuSSOClientGUI' has no 'yyy' member
+# pylint: disable=E1101,E1103
+
+
 APP_NAME = 'The Super testing app!'
 TC_URI = 'http://localhost'
 HELP_TEXT = """Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam sed
@@ -153,6 +159,8 @@
         direction = 'in' if focus_in else 'out'
         self.entry.emit('focus-%s-event' % direction, None)
 
+    # Bad first argument 'LabeledEntry' given to super class
+    # pylint: disable=E1003
     def assert_correct_label(self):
         """Check that the entry has the correct label."""
         # text content is correct
@@ -343,7 +351,7 @@
                       'tc_browser', 'login', 'request_password_token',
                       'set_new_password')
         self.ui = self.gui_class(**self.kwargs)
-        self.ERROR = {'message': self.ui.UNKNOWN_ERROR}
+        self.error = {'message': self.ui.UNKNOWN_ERROR}
 
     def tearDown(self):
         """Clean up."""
@@ -505,7 +513,7 @@
 
     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')
+        self.ui._setup_signals()
         assert len(self.ui.bus.callbacks) > 0  # at least one callback
 
         self.ui.on_close_clicked()
@@ -552,6 +560,7 @@
             self.assertEqual(expected, actual, msg % (label, expected, actual))
 
     def test_password_fields_are_password(self):
+        """Password fields have the is_password flag set."""
         msg = '"%s" should be a password LabeledEntry instance.'
         passwords = filter(lambda name: 'password' in name,
                            self.ui.entries)
@@ -591,7 +600,7 @@
         """Main window has the proper icon."""
         self.assertEqual('ubuntu-logo', self.ui.window.get_icon_name())
 
-    def test_transient_window_is_None_if_window_id_is_zero(self):
+    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)
@@ -837,7 +846,7 @@
 
     def test_join_ok_button_does_nothing_if_clicked_but_disabled(self):
         """The join form can only be submitted if the button is sensitive."""
-        self.patch(self.ui.name_entry, 'get_text', self._set_called)
+        self.patch(self.ui.email1_entry, 'get_text', self._set_called)
 
         self.ui.join_ok_button.set_sensitive(False)
         self.ui.join_ok_button.clicked()
@@ -876,6 +885,10 @@
         self.assertIsInstance(browser, webkit.WebView)
         self.assertTrue(browser.get_property('visible'))
 
+        settings = browser.get_settings()
+        self.assertFalse(settings.get_property('enable-plugins'))
+        self.assertFalse(settings.get_property('enable-default-context-menu'))
+
         self.ui.tc_browser_vbox.hide()
 
     def test_tc_browser_is_destroyed_when_tc_page_is_hid(self):
@@ -913,6 +926,9 @@
         """Terms & Conditions browser shows the proper uri."""
         self.ui.tc_button.clicked()
         self.assertEqual(self.ui.tc_browser.get_property('uri'), TC_URI)
+
+    # Unused variable 'skip'
+    # pylint: disable=W0612
     test_tc_browser_opens_the_proper_uri.skip = 'The freaking test wont work.'
 
 
@@ -926,12 +942,12 @@
 
     def test_previous_page_is_shown(self):
         """On UserRegistrationError the previous page is shown."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.assert_pages_visibility(enter_details=True)
 
     def test_warning_label_is_shown(self):
         """On UserRegistrationError the warning label is shown."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
 
@@ -1013,7 +1029,7 @@
 
     def test_on_email_validation_error_verify_email_is_shown(self):
         """On email validation error, the verify_email page is shown."""
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
         self.assert_pages_visibility(verify_email=True)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
@@ -1116,6 +1132,11 @@
                                           self.ui.FIELD_REQUIRED)
         self.assertNotIn('register_user', self.ui.backend._called)
 
+    # Unused variable 'skip'
+    # pylint: disable=W0612
+    test_warning_is_shown_if_name_empty.skip = \
+        'Unused for now, will be hidden to save space (LP: #627440).'
+
     def test_warning_is_shown_if_empty_email(self):
         """A warning message is shown if emails are empty."""
         self.ui.email1_entry.set_text('')
@@ -1179,9 +1200,9 @@
     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)
+        for pwd in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
+            self.ui.password1_entry.set_text(pwd)
+            self.ui.password2_entry.set_text(pwd)
 
             self.ui.join_ok_button.clicked()
 
@@ -1304,13 +1325,13 @@
     def test_on_login_error_morphs_to_login_page(self):
         """On user login error, the previous page is shown."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.assert_pages_visibility(login=True)
 
     def test_on_login_error_a_warning_is_shown(self):
         """On user login error, a warning is shown with proper wording."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
 
@@ -1328,7 +1349,7 @@
     def test_back_to_registration_hides_warning(self):
         """After user login error, warning is hidden when clicking 'Back'."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.login_back_button.clicked()
         self.assertFalse(self.ui.warning_label.get_property('visible'))
 
@@ -1504,7 +1525,7 @@
 
     def test_on_password_reset_error_shows_login_page(self):
         """When reset token wasn't successfuly sent the login page is shown."""
-        self.ui.on_password_reset_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_password_reset_error(app_name=APP_NAME, error=self.error)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
         self.assert_pages_visibility(login=True)
@@ -1603,14 +1624,14 @@
         entries = (self.ui.reset_code_entry,
                    self.ui.reset_password1_entry,
                    self.ui.reset_password2_entry)
-        for xs in itertools.product(('', ' ', 'a'), repeat=3):
+        for values 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())
+            for entry, val in zip(entries, values):
+                entry.set_text(val)
+                expected &= bool(val and not val.isspace())
 
             actual = self.ui.set_new_password_ok_button.get_sensitive()
-            self.assertEqual(expected, actual, msg % (expected, xs))
+            self.assertEqual(expected, actual, msg % (expected, values))
 
     def test_on_set_new_password_ok_button_clicked_morphs_window(self):
         """Clicking set_new_password_ok_button the processing page is shown."""
@@ -1636,7 +1657,7 @@
 
     def test_on_password_change_error_shows_login_page(self):
         """When password wasn't changed the reset password page is shown."""
-        self.ui.on_password_change_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_password_change_error(app_name=APP_NAME, error=self.error)
         self.assert_correct_label_warning(self.ui.warning_label,
                                           self.ui.UNKNOWN_ERROR)
         self.assert_pages_visibility(request_password_token=True)
@@ -1723,9 +1744,9 @@
     def test_warning_is_shown_if_password_too_weak(self):
         """A warning message is shown if password is too weak."""
         # password will match but will be too weak
-        for w in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
-            self.ui.reset_password1_entry.set_text(w)
-            self.ui.reset_password2_entry.set_text(w)
+        for pwd in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
+            self.ui.reset_password1_entry.set_text(pwd)
+            self.ui.reset_password2_entry.set_text(pwd)
 
             self.ui.set_new_password_ok_button.set_sensitive(True)
             self.ui.set_new_password_ok_button.clicked()
@@ -1759,26 +1780,118 @@
 
     def test_all_the_signals_are_listed(self):
         """All the backend signals are listed to be binded."""
-        names = [sig for (sig, cb) in self.ui._signals]
         for sig in ('CaptchaGenerated', 'CaptchaGenerationError',
                     'UserRegistered', 'UserRegistrationError',
                     'LoggedIn', 'LoginError',
                     'EmailValidated', 'EmailValidationError',
                     'PasswordResetTokenSent', 'PasswordResetError',
                     'PasswordChanged', 'PasswordChangeError'):
-            self.assertIn(sig, names)
+            self.assertIn(sig, self.ui._signals)
 
     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.'
         dbus_iface = self.ui.iface_name
-        for signal, method in self.ui._signals:
+        for signal, method in self.ui._signals.iteritems():
             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))
 
+    def test_callbacks_only_log_when_app_name_doesnt_match(self):
+        """Callbacks do nothing but logging when app_name doesn't match."""
+        mismatch_app_name = self.ui.app_name * 2
+        for method in self.ui._signals.itervalues():
+            msgs = ('ignoring', method.__name__, mismatch_app_name)
+            method(mismatch_app_name, 'dummy')
+            self.assertTrue(self.memento.check(logging.INFO, *msgs))
+            self.memento.records = []
+
+    def test_on_captcha_generated_is_not_called(self):
+        """on_captcha_generated is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_captcha_generated', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['CaptchaGenerated'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_captcha_generation_error_is_not_called(self):
+        """on_captcha_generation_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_captcha_generation_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['CaptchaGenerationError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_user_registered_is_not_called(self):
+        """on_user_registered is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_user_registered', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['UserRegistered'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_user_registration_error_is_not_called(self):
+        """on_user_registration_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_user_registration_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['UserRegistrationError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_email_validated_is_not_called(self):
+        """on_email_validated is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_email_validated', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['EmailValidated'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_email_validation_error_is_not_called(self):
+        """on_email_validation_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_email_validation_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['EmailValidationError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_logged_in_is_not_called(self):
+        """on_logged_in is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_logged_in', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['LoggedIn'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_login_error_is_not_called(self):
+        """on_login_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_login_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['LoginError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_reset_token_sent_is_not_called(self):
+        """on_password_reset_token_sent is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_reset_token_sent', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordResetTokenSent'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_reset_error_is_not_called(self):
+        """on_password_reset_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_reset_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordResetError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_changed_is_not_called(self):
+        """on_password_changed is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_changed', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordChanged'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_change_error_is_not_called(self):
+        """on_password_change_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_change_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordChangeError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
 
 class LoginOnlyTestCase(UbuntuSSOClientTestCase):
     """Test suite for the login only GUI."""
@@ -1804,6 +1917,7 @@
 
 
 class SignalsTestCase(UbuntuSSOClientTestCase):
+    """Test the GTK signal emission."""
 
     def setUp(self):
         """Init."""
@@ -1814,8 +1928,15 @@
 
     def _set_called(self, widget, *args, **kwargs):
         """Keep trace of signals emition."""
+        # pylint: disable=W0221
         self._called[args[-1]] = (widget, args[:-1], kwargs)
 
+    def test_closing_main_window_sends_outcome_as_signal(self):
+        """A signal is sent when closing the main window."""
+        self.ui.window.emit('delete-event', gtk.gdk.Event(gtk.gdk.DELETE))
+        expected = (self.ui.window, (APP_NAME,), {})
+        self.assertEqual(self._called[gui.SIG_USER_CANCELATION], expected)
+
     def test_every_cancel_emits_proper_signal(self):
         """Clicking on any cancel button, 'user-cancelation' signal is sent."""
         sig = gui.SIG_USER_CANCELATION
@@ -1832,7 +1953,7 @@
 
     def test_on_user_registration_error_proper_signal_is_emitted(self):
         """On UserRegistrationError, 'registration-failed' signal is sent."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
         expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
         self.assertEqual(expected,
@@ -1847,7 +1968,7 @@
 
     def test_on_email_validation_error_proper_signals_is_emitted(self):
         """On EmailValidationError, 'registration-failed' signal is sent."""
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
         expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
         self.assertEqual(expected,
@@ -1863,7 +1984,7 @@
     def test_on_login_error_proper_signals_is_emitted(self):
         """On LoginError, 'login-failed' signal is sent."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
         expected = (self.ui.window, (APP_NAME, self.ui.UNKNOWN_ERROR), {})
         self.assertEqual(expected,
@@ -1872,7 +1993,7 @@
     def test_registration_successfull_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.click_join_with_valid_data()
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
@@ -1883,7 +2004,7 @@
     def test_login_successfull_even_if_prior_login_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.click_connect_with_valid_data()
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
@@ -1894,7 +2015,7 @@
     def test_user_cancelation_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.join_cancel_button.clicked()
 
         self.assertEqual(len(self._called), 1)
@@ -1903,8 +2024,56 @@
     def test_user_cancelation_even_if_prior_login_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.ERROR)
+        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.login_cancel_button.clicked()
 
         self.assertEqual(len(self._called), 1)
         self.assertTrue(gui.SIG_USER_CANCELATION in self._called)
+
+
+class DefaultButtonsTestCase(UbuntuSSOClientTestCase):
+    """Each UI page has a default button when visible."""
+
+    def setUp(self):
+        """Init."""
+        super(DefaultButtonsTestCase, self).setUp()
+        self.mapping = (
+            ('enter_details_vbox', 'join_ok_button'),
+            ('tc_browser_vbox', 'tc_back_button'),
+            ('verify_email_vbox', 'verify_token_button'),
+            ('login_vbox', 'login_ok_button'),
+            ('request_password_token_vbox',
+             'request_password_token_ok_button'),
+            ('set_new_password_vbox', 'set_new_password_ok_button'),
+            ('success_vbox', 'success_close_button'),
+            ('processing_vbox', None))
+
+    def test_pages_have_default_widget_set(self):
+        """Each page has a proper button as default widget."""
+        msg = 'Page %r must have %r as default_widget (got %r instead).'
+        for pname, bname in self.mapping:
+            page = getattr(self.ui, pname)
+            button = bname and getattr(self.ui, bname)
+            self.assertTrue(page.default_widget is button,
+                            msg % (pname, bname, page.default_widget))
+
+    def test_default_widget_can_default(self):
+        """Each default button can default."""
+        msg = 'Button %r must have can-default enabled.'
+        for _, bname in self.mapping:
+            if bname is not None:
+                button = getattr(self.ui, bname)
+                self.assertTrue(button.get_property('can-default'),
+                                msg % bname)
+
+    def test_set_current_page_grabs_focus_for_default_button(self):
+        """Setting the current page marks the default widget as default."""
+        msg = '%r "has_default" must be True when %r if the current page.'
+        for pname, bname in self.mapping:
+            if bname is not None:
+                page = getattr(self.ui, pname)
+                self.patch(page.default_widget, 'grab_default',
+                           self._set_called)
+                self.ui._set_current_page(page)
+                self.assertEqual(self._called, ((), {}), msg % (bname, pname))
+                self._called = False

=== removed file 'ubuntu_sso/tests/test_key_acls.py'
--- ubuntu_sso/tests/test_key_acls.py	2010-06-16 15:11:04 +0000
+++ ubuntu_sso/tests/test_key_acls.py	1970-01-01 00:00:00 +0000
@@ -1,166 +0,0 @@
-# test_key_acls - tests for ubuntu_sso.key_acls
-#
-# Author: Stuart Langridge <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Tests for the ACL setting code for ubuntuone-oauth-login."""
-
-import os, StringIO
-import xdg.BaseDirectory
-from mocker import MockerTestCase, IN, ANY
-from ubuntu_sso.key_acls import (
-    get_privileged_config_folder, get_acl_preregistrations,
-    set_all_key_acls, set_single_acl
-)
-
-ETC_FOLDER = "/etc/xdg/ubuntu-sso"
-ETC_FILES_FOLDER = "/etc/xdg/ubuntu-sso/oauth_registration.d"
-
-class Loader(MockerTestCase):
-    """Confirm only the /etc/xdg config files are loaded."""
-
-    def test_etc_found(self):
-        """Is the /etc/xdg folder found if present?"""
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        self.mocker.replay()
-
-        self.assertEqual(ETC_FOLDER,
-          get_privileged_config_folder(use_source_tree_folder=False))
-
-    def test_etc_found_despite_home(self):
-        """Is the /etc/xdg folder found even if the $HOME folder is present?"""
-        HOME_FOLDER = os.path.join(xdg.BaseDirectory.xdg_config_home,
-                                   "ubuntu-sso")
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        osp.exists(HOME_FOLDER)
-        self.mocker.result(True)
-        self.mocker.replay()
-
-        self.assertEqual(ETC_FOLDER,
-          get_privileged_config_folder(use_source_tree_folder=False))
-
-    def test_etc_files_found(self):
-        """Are files in /etc found?"""
-        FILE_LIST = ["a", "b"]
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        osp.isdir(ETC_FILES_FOLDER)
-        self.mocker.result(True)
-        listdir = self.mocker.replace("os.listdir")
-        listdir(ETC_FILES_FOLDER)
-        self.mocker.result(FILE_LIST)
-        self.mocker.replay()
-
-        our_list = sorted(
-          [os.path.join(ETC_FILES_FOLDER, x) for x in FILE_LIST])
-        their_list = sorted(
-          get_acl_preregistrations(use_source_tree_folder=False))
-        self.assertEqual(our_list, their_list)
-
-    def test_set_single_acl(self):
-        """Does set_single_acl work?"""
-        giifr = self.mocker.replace("ubuntu_sso.key_acls.get_item_ids_for_realm")
-        igas = self.mocker.replace("gnomekeyring.item_get_acl_sync")
-        isas = self.mocker.replace("gnomekeyring.item_set_acl_sync")
-        acon = self.mocker.replace("gnomekeyring.AccessControl")
-        self.expect(giifr("realm", "consumer_key")).result([999])
-        self.expect(igas(None, 999)).result([])
-        ac1 = self.mocker.mock()
-        self.expect(acon(ANY, ANY)).result(ac1)
-        ac1.set_display_name("application_name")
-        ac1.set_path_name("/tmp/exe_path")
-        self.expect(isas(None, 999, [ac1])).result(None)
-        self.expect(giifr("realm2", "consumer_key2")).result([9999])
-        self.expect(igas(None, 9999)).result([])
-        ac2 = self.mocker.mock()
-        self.expect(acon(ANY, ANY)).result(ac2)
-        ac2.set_display_name("application_name2")
-        ac2.set_path_name("/tmp/exe_path2")
-        self.expect(isas(None, 9999, [ac2])).result(None)
-        self.mocker.replay()
-
-        set_single_acl([
-          ("realm", "consumer_key", "/tmp/exe_path", "application_name"),
-          ("realm2", "consumer_key2", "/tmp/exe_path2", "application_name2"),
-        ])
-
-    def test_etc_files_parsed(self):
-        """Are files in /etc parsed correctly?"""
-        FILE_LIST = ["a", "b"]
-        osp = self.mocker.replace("os.path")
-        osp.exists(ETC_FOLDER)
-        self.mocker.result(True)
-        osp.isdir(ETC_FILES_FOLDER)
-        self.mocker.result(True)
-        listdir = self.mocker.replace("os.listdir")
-        listdir(ETC_FILES_FOLDER)
-        self.mocker.result(FILE_LIST)
-
-        sio1 = StringIO.StringIO("""[app1]
-realm = https://realm.example.com/
-consumer_key = example_key
-exe_path = /nowhere/executable/path
-application_name = example_app_name
-
-[app2]
-realm = https://other.example.com/
-consumer_key = example_key
-exe_path = /nowhere/executable/path
-application_name = example_app_name
-
-""")
-        sio2 = StringIO.StringIO("""[app3]
-exe_path = /nowhere/path/2
-application_name = example_app_name2
-consumer_key = example_key2
-realm = https://realm2.example.com/
-""")
-        mock_open = self.mocker.replace(open)
-        mock_open(os.path.join(ETC_FILES_FOLDER, "a"))
-        self.mocker.result(sio1)
-        mock_open(os.path.join(ETC_FILES_FOLDER, "b"))
-        self.mocker.result(sio2)
-
-        ssa = self.mocker.replace("ubuntu_sso.key_acls.set_single_acl")
-        # list may come up in any order
-        ssa(IN([
-              [
-                ("https://realm.example.com/", "example_key",
-                "/nowhere/executable/path", "example_app_name"),
-                ("https://other.example.com/", "example_key",
-                "/nowhere/executable/path", "example_app_name"),
-              ],
-              [
-                ("https://other.example.com/", "example_key",
-                "/nowhere/executable/path", "example_app_name"),
-                ("https://realm.example.com/", "example_key",
-                "/nowhere/executable/path", "example_app_name"),
-              ],
-            ]), specific_item_id=None
-        )
-        self.mocker.result(None)
-        ssa([
-            ("https://realm2.example.com/", "example_key2",
-            "/nowhere/path/2", "example_app_name2")
-            ], specific_item_id=None)
-        self.mocker.result(None)
-        self.mocker.replay()
-
-        set_all_key_acls(use_source_tree_folder=False)

=== modified file 'ubuntu_sso/tests/test_keyring.py'
--- ubuntu_sso/tests/test_keyring.py	2010-08-27 22:16:40 +0000
+++ ubuntu_sso/tests/test_keyring.py	2010-09-09 14:47:44 +0000
@@ -1,6 +1,7 @@
 # test_keyring - tests for ubuntu_sso.keyring
 #
 # Author: Alejandro J. Cura <[e-mail]>
+# Author: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -26,6 +27,8 @@
 
 from ubuntu_sso import keyring
 
+APP_NAME = 'Yadda Yadda Doo'
+
 
 def build_fake_gethostname(fake_hostname):
     """Return a fake hostname getter."""
@@ -35,19 +38,19 @@
 class MockKeyringItem(object):
     """A mock object that fakes an item found in a keyring search."""
 
-    def __init__(self, item_id, keyring, attributes, secret):
+    def __init__(self, item_id, keyring_name, attributes, secret):
         """Initialize this instance."""
         self.item_id = item_id
-        self.keyring = keyring
+        self.keyring = keyring_name
         self.attributes = attributes
         self.secret = secret
 
     def matches(self, search_attr):
         """See if this item matches a given search."""
-        for k, v in search_attr.items():
+        for k, val in search_attr.items():
             if k not in self.attributes:
                 return False
-            if self.attributes[k] != v:
+            if self.attributes[k] != val:
                 return False
         return True
 
@@ -106,18 +109,29 @@
         """A simple token name is built right."""
         sample_app_name = "UbuntuTwo"
         sample_hostname = "Darkstar"
-        expected_result = "UbuntuTwo - Darkstar"
-
-        fake_gethostname = build_fake_gethostname(sample_hostname)
-        self.patch(socket, "gethostname", fake_gethostname)
-        result = keyring.get_token_name(sample_app_name)
-        self.assertEqual(result, expected_result)
-
-    def test_get_complex_token_name(self):
+        expected_result = "UbuntuTwo @ Darkstar"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+    def test_get_complex_token_name_for_app_name(self):
+        """A complex token name is built right too."""
+        sample_app_name = "Ubuntu @ Eleven"
+        sample_hostname = "Mate+Cocido"
+        expected_result = "Ubuntu @ Eleven @ Mate+Cocido"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+    def test_get_complex_token_name_for_hostname(self):
         """A complex token name is built right too."""
         sample_app_name = "Ubuntu Eleven"
-        sample_hostname = "Mate+Cocido"
-        expected_result = "Ubuntu%20Eleven - Mate%2BCocido"
+        sample_hostname = "Mate @ Cocido"
+        expected_result = "Ubuntu Eleven @ Mate AT Cocido"
 
         fake_gethostname = build_fake_gethostname(sample_hostname)
         self.patch(socket, "gethostname", fake_gethostname)
@@ -167,6 +181,16 @@
         result = keyring.Keyring("appname").get_ubuntusso_attr()
         self.assertEqual(result, sample_creds)
 
+    def test_get_credentials_migrating_token(self):
+        """Test that credentials are properly retrieved and migrated."""
+        sample_creds = {"name": "sample creds name"}
+        obj = keyring.Keyring(APP_NAME)
+        obj.token_name = keyring.get_old_token_name(APP_NAME)
+        obj.set_ubuntusso_attr(sample_creds)
+
+        result = keyring.Keyring(APP_NAME).get_ubuntusso_attr()
+        self.assertEqual(result, sample_creds)
+
     def test_get_old_cred_found(self):
         """The method returns a new set of creds if old creds are found."""
         sample_oauth_token = "sample oauth token"

=== removed file 'ubuntu_sso/tests/test_login.py'
--- ubuntu_sso/tests/test_login.py	2010-08-11 17:03:11 +0000
+++ ubuntu_sso/tests/test_login.py	1970-01-01 00:00:00 +0000
@@ -1,188 +0,0 @@
-# -*- 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-08-27 22:16:40 +0000
+++ ubuntu_sso/tests/test_main.py	2010-09-09 14:47:44 +0000
@@ -1,6 +1,5 @@
 # test_main - tests for ubuntu_sso.main
 #
-# Author: Stuart Langridge <[e-mail]>
 # Author: Natalia Bidart <[e-mail]>
 # Author: Alejandro J. Cura <[e-mail]>
 #
@@ -17,16 +16,18 @@
 #
 # 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."""
+"""Tests for the main SSO client code."""
 
 import logging
 import os
-import StringIO
 import urllib2
 
 import gobject
 
+# Unable to import 'lazr.restfulclient.*'
+# pylint: disable=F0401
 from lazr.restfulclient.errors import HTTPError
+# pylint: enable=F0401
 from mocker import Mocker, MockerTestCase, ARGS, KWARGS, ANY
 from twisted.internet.defer import Deferred
 from twisted.trial.unittest import TestCase
@@ -35,17 +36,21 @@
 import ubuntu_sso.main
 
 from contrib.testing.testcase import MementoHandler
-from ubuntu_sso import config, gui
+from ubuntu_sso import gui
 from ubuntu_sso.keyring import get_token_name, U1_APP_NAME
 from ubuntu_sso.main import (
-    AuthenticationError, BadRealmError, blocking, EmailTokenError,
+    AuthenticationError, blocking, EmailTokenError,
     except_to_errdict, InvalidEmailError, InvalidPasswordError,
     keyring_get_credentials, keyring_store_credentials, logger,
-    LoginProcessor, NewPasswordError, PING_URL,
+    NewPasswordError, PING_URL, SERVICE_URL,
     RegistrationError, ResetPasswordTokenError,
     SSOCredentials, SSOLogin, SSOLoginProcessor)
 
 
+# Access to a protected member 'yyy' of a client class
+# pylint: disable=W0212
+
+
 APP_NAME = 'The Coolest App Ever'
 CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
                                             'files', 'captcha.png'))
@@ -86,8 +91,8 @@
     """Fake a urlopen response."""
 
     def __init__(self, *args, **kwargs):
-        for k, v in kwargs.iteritems():
-            setattr(self, k, v)
+        for k, val in kwargs.iteritems():
+            setattr(self, k, val)
 
 
 class FakedCaptchas(object):
@@ -238,9 +243,9 @@
         failure = self.assertRaises(RegistrationError,
                                     self.processor.register_user,
                                     **self.register_kwargs)
-        for k, v in failure.args[0].items():
+        for k, val in failure.args[0].items():
             self.assertIn(k, STATUS_ERROR['errors'])
-            self.assertEqual(v, "\n".join(STATUS_ERROR['errors'][k]))
+            self.assertEqual(val, "\n".join(STATUS_ERROR['errors'][k]))
 
     def test_register_user_if_status_error_with_string_message(self):
         """Proper error is raised if register fails."""
@@ -248,9 +253,9 @@
         failure = self.assertRaises(RegistrationError,
                                     self.processor.register_user,
                                     **self.register_kwargs)
-        for k, v in failure.args[0].items():
+        for k, val in failure.args[0].items():
             self.assertIn(k, {'email': 'Email already registered'})
-            self.assertEqual(v, 'Email already registered')
+            self.assertEqual(val, 'Email already registered')
 
     def test_register_user_if_status_unknown(self):
         """Proper error is raised if register returns an unknown status."""
@@ -288,9 +293,9 @@
         failure = self.assertRaises(EmailTokenError,
                                     self.processor.validate_email,
                                     **self.login_kwargs)
-        for k, v in failure.args[0].items():
+        for k, val in failure.args[0].items():
             self.assertIn(k, STATUS_EMAIL_ERROR['errors'])
-            self.assertEqual(v, "\n".join(STATUS_EMAIL_ERROR['errors'][k]))
+            self.assertEqual(val, "\n".join(STATUS_EMAIL_ERROR['errors'][k]))
 
     def test_validate_email_if_status_error_with_string_message(self):
         """Proper error is raised if register fails."""
@@ -298,9 +303,9 @@
         failure = self.assertRaises(EmailTokenError,
                                     self.processor.validate_email,
                                     **self.login_kwargs)
-        for k, v in failure.args[0].items():
+        for k, val in failure.args[0].items():
             self.assertIn(k, {'email': 'Email already registered'})
-            self.assertEqual(v, 'Email already registered')
+            self.assertEqual(val, 'Email already registered')
 
     def test_validate_email_if_status_unknown(self):
         """Proper error is raised if email validation returns unknown."""
@@ -357,72 +362,6 @@
         self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
 
 
-class Realm(MockerTestCase):
-    """Test the realm handling finder"""
-
-    def test_invalid_realm(self):
-        """Are invalid realms rejected?"""
-        login = LoginProcessor(None)
-        self.assertRaises(BadRealmError, login.login, "bad realm", "key")
-
-    def test_realms(self):
-        """Are realm URLs correctly retrieved from the config?"""
-        # mock that tmp config file exists
-        tmp = os.path.realpath(os.path.join(os.path.split(config.__file__)[0],
-                                            "../../data/oauth_urls"))
-        osp = self.mocker.replace("os.path")
-        osp.isfile(tmp)
-        self.mocker.result(True)
-
-        sio = StringIO.StringIO("""[default]
-request_token_url = /rtu-default
-user_authorisation_url = /uau-default
-access_token_url = /atu-default
-consumer_secret = foo-default
-
-[http://localhost]
-request_token_url = /rtu-localhost
-user_authorisation_url = /uau-localhost
-access_token_url = /atu-localhost
-consumer_secret = foo-localhost
-
-[http://ubuntuone.com]
-request_token_url = /rtu-ubuntuone
-user_authorisation_url = /uau-ubuntuone
-access_token_url = /atu-ubuntuone
-consumer_secret = foo-ubuntuone
-
-""")
-        mock_open = self.mocker.replace(open)
-        mock_open(tmp)
-        self.mocker.result(sio)
-
-        self.mocker.replay()
-
-        login = LoginProcessor(None)
-
-        # are localhost:XXXX URLs correctly fetched?
-        (rtu, uau, atu, cs) = login.get_config_urls("http://localhost:9876")
-        self.assertEqual(rtu, "http://localhost:9876/rtu-localhost")
-        self.assertEqual(uau, "http://localhost:9876/uau-localhost")
-        self.assertEqual(atu, "http://localhost:9876/atu-localhost")
-        self.assertEqual(cs, "foo-localhost")
-
-        # is a URL specifically in the config correctly fetched?
-        (rtu, uau, atu, cs) = login.get_config_urls("http://ubuntuone.com")
-        self.assertEqual(rtu, "http://ubuntuone.com/rtu-ubuntuone")
-        self.assertEqual(uau, "http://ubuntuone.com/uau-ubuntuone")
-        self.assertEqual(atu, "http://ubuntuone.com/atu-ubuntuone")
-        self.assertEqual(cs, "foo-ubuntuone")
-
-        # is a URL not in the config correctly fetched as default?
-        (rtu, uau, atu, cs) = login.get_config_urls("http://other.example.net")
-        self.assertEqual(rtu, "http://other.example.net/rtu-default")
-        self.assertEqual(uau, "http://other.example.net/uau-default")
-        self.assertEqual(atu, "http://other.example.net/atu-default")
-        self.assertEqual(cs, "foo-default")
-
-
 class BlockingSampleException(Exception):
     """The exception that will be thrown by the fake blocking."""
 
@@ -439,34 +378,36 @@
         self.mockbusname.get_bus()
         self.mocker.result(mockbus)
         mockbus._register_object_path(ARGS)
+        self.mockprocessorclass = None
 
-        def ksc(k, v):
+        def ksc(k, val):
             """Assert over token and app_name."""
             self.assertEqual(k, APP_NAME)
-            self.assertEqual(v, TOKEN)
+            self.assertEqual(val, TOKEN)
             self.keyring_was_set = True
-            self.keyring_values = k, v
+            self.keyring_values = k, val
 
         self.patch(ubuntu_sso.main, "keyring_store_credentials", ksc)
         self.keyring_was_set = False
+        self.keyring_values = None
 
     def tearDown(self):
         """Verify the mocking bus and shut it down."""
         self.mocker.verify()
         self.mocker.restore()
 
-    def fake_ok_blocking(self, f, a, cb, eb):
+    def fake_ok_blocking(self, f, app, cb, eb):
         """A fake blocking function that succeeds."""
-        cb(a, f())
+        cb(app, f())
 
-    def fake_err_blocking(self, f, a, cb, eb):
+    def fake_err_blocking(self, f, app, cb, eb):
         """A fake blocking function that fails."""
         try:
             f()
-        except Exception, e:
-            eb(a, except_to_errdict(e))
+        except Exception, e:  # pylint: disable=W0703
+            eb(app, except_to_errdict(e))
         else:
-            eb(a, except_to_errdict(BlockingSampleException()))
+            eb(app, except_to_errdict(BlockingSampleException()))
 
     def test_creation(self):
         """Test that the object creation is successful."""
@@ -492,6 +433,7 @@
         self.mocker.replay()
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, expected_result)
             self.assertEqual(app_name, APP_NAME)
             d.callback(result)
@@ -514,6 +456,7 @@
         self.mocker.replay()
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
@@ -536,6 +479,7 @@
         self.mocker.replay()
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, expected_result)
             self.assertEqual(app_name, APP_NAME)
             d.callback(result)
@@ -559,6 +503,7 @@
         self.mocker.replay()
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
@@ -580,6 +525,7 @@
         self.mocker.replay()
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, EMAIL)
             self.assertEqual(app_name, APP_NAME)
             self.assertTrue(self.keyring_was_set, "The keyring should be set")
@@ -606,6 +552,7 @@
         self.mocker.replay()
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertFalse(self.keyring_was_set, "Keyring should not be set")
@@ -628,6 +575,7 @@
         self.mocker.replay()
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, EMAIL)
             self.assertEqual(app_name, APP_NAME)
             self.assertTrue(self.keyring_was_set, "The keyring should be set")
@@ -654,6 +602,7 @@
         self.mocker.replay()
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertFalse(self.keyring_was_set, "Keyring should not be set")
@@ -676,6 +625,7 @@
         self.mocker.replay()
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, EMAIL)
             self.assertEqual(app_name, APP_NAME)
             d.callback(result)
@@ -697,6 +647,7 @@
         self.mocker.replay()
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
@@ -718,6 +669,7 @@
         self.mocker.replay()
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, EMAIL)
             self.assertEqual(app_name, APP_NAME)
             d.callback(result)
@@ -741,6 +693,7 @@
         self.mocker.replay()
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
@@ -764,9 +717,11 @@
         expected_result = "expected result"
 
         def f():
+            """No failure."""
             return expected_result
 
         def verify(app_name, result):
+            """The actual test."""
             self.assertEqual(result, expected_result)
             self.assertEqual(app_name, APP_NAME)
             d.callback(result)
@@ -780,9 +735,11 @@
         expected_error_message = "expected error message"
 
         def f():
+            """Failure."""
             raise BlockingSampleException(expected_error_message)
 
         def verify(app_name, errdict):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertEqual(errdict["message"], expected_error_message)
@@ -846,7 +803,10 @@
 
 
 class KeyringCredentialsTestCase(MockerTestCase):
-    """Checks the functions that access the keyring."""
+    """Check the functions that access the keyring."""
+
+    # Invalid name (should match ([a-z_][a-z0-9_]*|[A-Z_][A-Z0-9_]*)$)
+    # pylint: disable=C0103
 
     def test_keyring_store_cred(self):
         """Verify the method that stores credentials."""
@@ -894,6 +854,9 @@
 class CredentialsTestCase(TestCase, MockerTestCase):
     """Tests for the credentials related DBus methods."""
 
+    # Invalid name (should match ([a-z_][a-z0-9_]*|[A-Z_][A-Z0-9_]*)$)
+    # pylint: disable=C0103
+
     timeout = 5
 
     def test_find_credentials(self):
@@ -926,6 +889,7 @@
         d = Deferred()
 
         def verify(app_name, credentials):
+            """The actual test."""
             self.assertEqual(credentials, expected_creds)
             d.callback("ok")
 
@@ -945,6 +909,7 @@
         d = Deferred()
 
         def verify(result, *a):
+            """The actual test."""
             self.assertEqual(result, APP_NAME)
             d.callback("ok")
 
@@ -966,6 +931,7 @@
         d = Deferred()
 
         def verify(app_name, error_message, detailed_error):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             d.callback("ok")
 
@@ -987,6 +953,7 @@
         d = Deferred()
 
         def verify(app_name, credentials):
+            """The actual test."""
             self.assertEqual(credentials, expected_creds)
             d.callback("ok")
 
@@ -1006,6 +973,7 @@
         d = Deferred()
 
         def verify(result, *a):
+            """The actual test."""
             self.assertEqual(result, APP_NAME)
             d.callback("ok")
 
@@ -1027,6 +995,7 @@
         d = Deferred()
 
         def verify(app_name, error_message, detailed_error):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             d.callback("ok")
 
@@ -1071,6 +1040,7 @@
         d = Deferred()
 
         def verify(app_name, error_message, detailed_error):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             d.callback("ok")
 
@@ -1090,6 +1060,7 @@
         self.mocker.replay()
 
         def verify(app_name, msg, full_error):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             d.callback("ok")
 
@@ -1109,6 +1080,7 @@
         self.mocker.replay()
 
         def verify(app_name, credentials):
+            """The actual test."""
             self.assertEqual(credentials, expected_creds)
             d.callback("ok")
 
@@ -1127,6 +1099,7 @@
         self.mocker.replay()
 
         def verify(app_name, msg, full_error):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             d.callback("ok")
 
@@ -1142,6 +1115,7 @@
         self.mocker.replay()
 
         def verify(app_name):
+            """The actual test."""
             self.assertEqual(app_name, APP_NAME)
             d.callback("ok")
 
@@ -1157,6 +1131,9 @@
 
     def setUp(self):
         """Init."""
+        self.args = None
+        self.kwargs = None
+
         idle_add = lambda f, *args, **kwargs: f(*args, **kwargs)
         self.patch(gobject, "idle_add", idle_add)