Merge lp:~nataliabidart/ubuntu-sso-client/stable-3-0-update into lp:ubuntu-sso-client/stable-3-0

[Natalia Bidart]

[ Alejandro J. Cura <email address hidden> ]
  - An async webclient with qtnetwork and libsoup backends, to be used for
    proxy support.
  - Use the dedicated time url (LP: #891644).

[ Diego Sarmentero <email address hidden> ]
  - Fixed pep8 issue.
  - Fix double back navigation in SSO reset code page (LP: #862403).

[ Manuel de la Pena <email address hidden> ]
  - Fixed the tests by ensuring that the server and the client are correctly
    closed.
  - Changed the import from ubuntuone-dev-tools so that we do not use the
    deprecated API.

[ Natalia B. Bidart <email address hidden> ]
  - Do not hardcode the app_name when showing the TC_NOT_ACCEPTED message
    (LP: #904917).
  - Pass module for test to u1trial properly.
  - Have a single executable to start the service (LP: #890416).
  - Lint fixes (LP: #890349).

All green in ubuntu, and windows (tested windows 7).

IRL tested on Ubuntu.

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2011-09-27 14:06:12 +0000
+++ bin/ubuntu-sso-login	2011-12-19 19:46:24 +0000
@@ -1,9 +1,5 @@
-#!/usr/bin/python
-
-# ubuntu-sso-login - Client side log-in utility for Ubuntu One
-#
-# Author: Rodney Dawes <[e-mail]>
-# Author: Natalia B. Bidart <[e-mail]>
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
 #
 # Copyright 2009-2010 Canonical Ltd.
 #
@@ -19,7 +15,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/>.
 
-"""Run the dbus service for UserManagement and ApplicationCredentials."""
+"""Start the sso service."""
 
 # Invalid name "ubuntu-sso-login", pylint: disable=C0103
 
@@ -41,60 +37,19 @@
 #     val = globals()[globalname]
 # KeyError: 'ROUND_CEiLiNG'
 
-import signal
 import sys
 
-import dbus.mainloop.glib
-import dbus.service
-import gtk
-
-from dbus.mainloop.glib import DBusGMainLoop
-
-from ubuntu_sso import (DBUS_BUS_NAME, DBUS_ACCOUNT_PATH, DBUS_CRED_PATH,
-    DBUS_CREDENTIALS_PATH)
-from ubuntu_sso.main import SSOLogin, CredentialsManagement
-
-from ubuntu_sso.logger import setup_logging
-
-# Invalid name "ubuntu-sso-login"
-# pylint: disable=C0103
-
-
-logger = setup_logging("ubuntu-sso-login")
-dbus.mainloop.glib.threads_init()
-gtk.gdk.threads_init()
-DBusGMainLoop(set_as_default=True)
-
-
-def sighup_handler(*a, **kw):
-    """Stop the service."""
-    # This handler may be called in any thread, so is not thread safe.
-    # See the link below for info:
-    # www.listware.net/201004/gtk-devel-list/115067-unix-signals-in-glib.html
-    #
-    # gtk.main_quit and the logger methods are safe to be called from any
-    # thread. Just don't call other random stuff here.
-    logger.info("Stoping Ubuntu SSO login manager since SIGHUP was received.")
-    gtk.main_quit()
+if sys.platform == 'win32':
+    from PyQt4 import QtGui
+    # need to create the QApplication before installing the reactor
+    QtGui.QApplication(sys.argv)
+
+    # pylint: disable=F0401
+    import qt4reactor
+    qt4reactor.install()
+
+from ubuntu_sso.main import main
 
 
 if __name__ == "__main__":
-    # Register DBus service for making sure we run only one instance
-    bus = dbus.SessionBus()
-    name = bus.request_name(DBUS_BUS_NAME,
-                            dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-    if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-        logger.error("Ubuntu SSO login manager already running, quitting.")
-        sys.exit(0)
-
-    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)
-    bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
-    SSOLogin(bus_name, object_path=DBUS_ACCOUNT_PATH)
-    CredentialsManagement(timeout_func=gtk.timeout_add,
-                          shutdown_func=gtk.main_quit,
-                          bus_name=bus_name, object_path=DBUS_CREDENTIALS_PATH)
-
-    gtk.main()
+    main()

=== removed file 'bin/windows-ubuntu-sso-login'
--- bin/windows-ubuntu-sso-login	2011-11-10 20:14:29 +0000
+++ bin/windows-ubuntu-sso-login	1970-01-01 00:00:00 +0000
@@ -1,86 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Authors: Manuel de la Pena <[e-mail]>
-#          Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2011 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/>.
-"""Start the sso service on a windows machine."""
-
-# disable the name warning and complains about twisted
-# pylint: disable=C0103, E1101, F0401
-import sys
-
-from PyQt4 import QtGui
-# need to create the QApplication before installing the reactor
-app = QtGui.QApplication(sys.argv)
-import qt4reactor
-qt4reactor.install()
-
-from twisted.internet import reactor, defer
-from twisted.spread.pb import PBServerFactory
-from twisted.internet.task import LoopingCall
-from twisted.python import log
-
-from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.main.windows import (
-    CredentialsManagement,
-    LOCALHOST,
-    SSOLogin,
-    UbuntuSSORoot,
-    get_activation_config,
-)
-from ubuntu_sso.utils import tcpactivation
-
-
-logger = setup_logging("windows-ubuntu-sso-login")
-
-
-def add_timeout(interval, callback, *args, **kwargs):
-    """Add a timeout callback as a task."""
-    time_out_task = LoopingCall(callback, *args, **kwargs)
-    time_out_task.start(interval/1000, now=False)
-
-
[e-mail]
-def main():
-    """Initialize and start this process."""
-    ai = tcpactivation.ActivationInstance(get_activation_config())
-    port = yield ai.get_port()
-
-    login = SSOLogin('ignored')
-    creds_management = CredentialsManagement(add_timeout, reactor.stop)
-    root = UbuntuSSORoot(sso_login=login, cred_manager=creds_management)
-
-    reactor.listenTCP(port, PBServerFactory(root), interface=LOCALHOST)
-
-
-def handle_already_started(failure):
-    """Handle the already started error by shutting down this process."""
-    failure.trap(tcpactivation.AlreadyStartedError)
-    print "Ubuntu SSO login manager already running."
-    reactor.stop()
-
-
-def utter_failure(failure):
-    """Handle an utter failure by logging it and quiting."""
-    log.err(failure)
-    reactor.stop()
-
-
-if __name__ == '__main__':
-    d = main()
-    d.addErrback(handle_already_started)
-    d.addErrback(utter_failure)
-    reactor.run()

=== modified file 'run-tests.bat'
--- run-tests.bat	2011-11-10 19:45:36 +0000
+++ run-tests.bat	2011-12-19 19:46:24 +0000
@@ -55,7 +55,7 @@
 "%PYTHONEXEPATH%\python.exe" setup.py build
 ECHO Running tests
 :: execute the tests with a number of ignored linux only modules
-"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1trial" -c ubuntu_sso -i "test_gui.py, test_linux.py, test_txsecrets.py" --reactor=qt4 --gui %*
+"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1trial" -c -i "test_gui.py, test_linux.py, test_txsecrets.py" --reactor=qt4 --gui %* ubuntu_sso 
 :: Clean the build from the setupt.py
 ECHO Cleaning the generated code before running the style checks...
 "%PYTHONEXEPATH%\python.exe" setup.py clean

=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2011-11-14 12:02:39 +0000
+++ ubuntu_sso/gtk/gui.py	2011-12-19 19:46:24 +0000
@@ -743,7 +743,7 @@
         # check T&C
         if not self.yes_to_tc_checkbutton.get_active():
             self._set_warning_message(self.tc_warning_label,
-                                      TC_NOT_ACCEPTED)
+                TC_NOT_ACCEPTED % {'app_name': self.app_name})
             error = True
 
         captcha_solution = self.captcha_solution_entry.get_text()

=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2011-11-11 17:12:19 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2011-12-19 19:46:24 +0000
@@ -1420,7 +1420,7 @@
         self.ui.join_ok_button.clicked()
 
         self.assert_correct_label_warning(self.ui.tc_warning_label,
-                                          gui.TC_NOT_ACCEPTED)
+            gui.TC_NOT_ACCEPTED % {'app_name': APP_NAME})
         self.assertNotIn('register_user', self.ui.backend._called)
 
     def test_warning_is_shown_if_not_captcha_solution(self):

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2011-09-27 14:06:12 +0000
+++ ubuntu_sso/main/__init__.py	2011-12-19 19:46:24 +0000
@@ -338,16 +338,16 @@
 
 if sys.platform == 'win32':
     from ubuntu_sso.main import windows
-    SSOLogin = windows.SSOLogin
-    CredentialsManagement = windows.CredentialsManagement
+    source = windows
     TIMEOUT_INTERVAL = 10000000000  # forever
-    thread_execute = windows.blocking
-    get_sso_login_backend = windows.get_sso_login_backend
 else:
     from ubuntu_sso.main import linux
-    SSOLogin = linux.SSOLogin
-    CredentialsManagement = linux.CredentialsManagement
-    thread_execute = linux.blocking
-    get_sso_login_backend = linux.get_sso_login_backend
+    source = linux
+
+CredentialsManagement = source.CredentialsManagement
+get_sso_login_backend = source.get_sso_login_backend
+main = source.main
+SSOLogin = source.SSOLogin
+thread_execute = source.blocking
 
 # pylint: enable=C0103

=== modified file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	2011-09-29 20:49:45 +0000
+++ ubuntu_sso/main/linux.py	2011-12-19 19:46:24 +0000
@@ -1,11 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# ubuntu_sso.main - main login handling interface
-#
-# Author: Natalia Bidart <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
+# Copyright 2009-2011 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
@@ -28,12 +23,19 @@
 """
 
 import threading
+import signal
+import sys
 
+import dbus.mainloop.glib
 import dbus.service
+import gtk
+
 
 from ubuntu_sso import (
     DBUS_ACCOUNT_PATH,
+    DBUS_BUS_NAME,
     DBUS_CREDENTIALS_IFACE,
+    DBUS_CREDENTIALS_PATH,
     DBUS_IFACE_USER_NAME,
     NO_OP,
 )
@@ -50,7 +52,7 @@
 # pylint: disable=C0103
 
 
-logger = setup_logging("ubuntu_sso.main")
+logger = setup_logging("ubuntu_sso.main.linux")
 
 
 def blocking(f, app_name, result_cb, error_cb):
@@ -410,3 +412,42 @@
 def get_sso_login_backend():
     """Get the backend for the Login service."""
     raise NotImplementedError()
+
+
+def sighup_handler(*a, **kw):
+    """Stop the service."""
+    # This handler may be called in any thread, so is not thread safe.
+    # See the link below for info:
+    # www.listware.net/201004/gtk-devel-list/115067-unix-signals-in-glib.html
+    #
+    # gtk.main_quit and the logger methods are safe to be called from any
+    # thread. Just don't call other random stuff here.
+    logger.info("Stoping Ubuntu SSO login manager since SIGHUP was received.")
+    gtk.main_quit()
+
+
+def main():
+    """Run the backend service."""
+    dbus.mainloop.glib.threads_init()
+    gtk.gdk.threads_init()
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+    bus = dbus.SessionBus()
+    # Register DBus service for making sure we run only one instance
+    name = bus.request_name(DBUS_BUS_NAME,
+                            dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
+    if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
+        logger.error("Ubuntu SSO login manager already running, quitting.")
+        sys.exit(0)
+
+    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)
+    bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
+    SSOLogin(bus_name, object_path=DBUS_ACCOUNT_PATH)
+    CredentialsManagement(timeout_func=gtk.timeout_add,
+                          shutdown_func=gtk.main_quit,
+                          bus_name=bus_name, object_path=DBUS_CREDENTIALS_PATH)
+
+    gtk.main()

=== modified file 'ubuntu_sso/main/tests/test_linux.py'
--- ubuntu_sso/main/tests/test_linux.py	2011-11-14 18:31:46 +0000
+++ ubuntu_sso/main/tests/test_linux.py	2011-12-19 19:46:24 +0000
@@ -585,6 +585,7 @@
         self.memento = MementoHandler()
         self.memento.setLevel(logging.DEBUG)
         ubuntu_sso.main.logger.addHandler(self.memento)
+        self.addCleanup(ubuntu_sso.main.logger.removeHandler, self.memento)
 
     @defer.inlineCallbacks
     def tearDown(self):
@@ -1204,7 +1205,9 @@
 
         self.memento = MementoHandler()
         self.memento.setLevel(logging.DEBUG)
-        ubuntu_sso.main.logger.addHandler(self.memento)
+        ubuntu_sso.main.linux.logger.addHandler(self.memento)
+        self.addCleanup(ubuntu_sso.main.linux.logger.removeHandler,
+                        self.memento)
 
     def assert_dbus_signal_correct(self, signal, signature):
         """Check that 'signal' is a dbus signal with proper 'signature'."""

=== modified file 'ubuntu_sso/main/tests/test_windows.py' (properties changed: -x to +x)
--- ubuntu_sso/main/tests/test_windows.py	2011-11-02 16:56:12 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2011-12-19 19:46:24 +0000
@@ -28,6 +28,7 @@
     DeadReferenceError,
     PBClientFactory,
     PBServerFactory,
+    Broker,
 )
 from ubuntu_sso import main
 from ubuntu_sso.main import windows
@@ -46,7 +47,7 @@
 
 # because we are using twisted we have java like names C0103 and
 # the issues that mocker brings with it like W0104
-# pylint: disable=C0103,W0104
+# pylint: disable=C0103,W0104,E1101,W0201
 
 
 class SaveProtocolServerFactory(PBServerFactory):
@@ -59,6 +60,77 @@
         self.protocolInstance = protocol
 
 
+class SaveClientFactory(PBClientFactory):
+    """Client Factory that knows when we disconnected."""
+
+    def __init__(self, connected_d, disconnected_d):
+        """Create a new instance."""
+        PBClientFactory.__init__(self)
+        self.connected_d = connected_d
+        self.disconnected_d = disconnected_d
+
+    def clientConnectionMade(self, broker):
+        """Connection made."""
+        PBClientFactory.clientConnectionMade(self, broker)
+        self.connected_d.callback(True)
+
+    def clientConnectionLost(self, connector, reason, reconnecting=0):
+        """Connection lost."""
+        self.disconnected_d.callback(True)
+
+
+class ServerProtocol(Broker):
+    """Server protocol that allows us to clean the tests."""
+
+    def connectionLost(self, *a):
+        self.factory.onConnectionLost.callback(self)
+
+
+class ConnectedTestCase(TestCase):
+    """Base test case with a client and a server."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up for the tests."""
+        yield super(ConnectedTestCase, self).setUp()
+        self.server_disconnected = defer.Deferred()
+        self.client_disconnected = defer.Deferred()
+        self.listener = None
+        self.connector = None
+        self.server_factory = None
+        self.client_factory = None
+
+    def setup_client_server(self, sso_root):
+        """Set tests."""
+        port = get_sso_pb_port()
+        self.listener = self._listen_server(sso_root, self.server_disconnected,
+                port)
+        connected = defer.Deferred()
+        self.connector = self._connect_client(connected,
+                self.client_disconnected, port)
+        self.addCleanup(self.teardown_client_server)
+        return connected
+
+    def _listen_server(self, sso_root, d, port):
+        """Start listenting."""
+        self.server_factory = SaveProtocolServerFactory(sso_root)
+        self.server_factory.onConnectionLost = d
+        self.server_factory.protocol = ServerProtocol
+        return reactor.listenTCP(port, self.server_factory)
+
+    def _connect_client(self, d1, d2, port):
+        """Connect client."""
+        self.client_factory = SaveClientFactory(d1, d2)
+        return reactor.connectTCP(LOCALHOST, port, self.client_factory)
+
+    def teardown_client_server(self):
+        """Clean resources."""
+        self.connector.disconnect()
+        d = defer.maybeDeferred(self.listener.stopListening)
+        return defer.gatherResults([d, self.client_disconnected,
+            self.server_disconnected])
+
+
 class FakeDecoratedObject(object):
     """An object that has decorators."""
 
@@ -240,7 +312,7 @@
         self.assertEqual(name, self.signal_names[signal_index])
 
 
-class SSOLoginTestCase(SignalHandlingTestCase):
+class SSOLoginTestCase(ConnectedTestCase, SignalHandlingTestCase):
     """Test the login class."""
 
     signal_names = [
@@ -268,35 +340,12 @@
         self.login = SSOLogin(None)
         # start pb
         self.sso_root = UbuntuSSORoot(sso_login=self.login)
-        self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
-        port = get_sso_pb_port()
-        self.listener = reactor.listenTCP(port, self.server_factory)
-        self.client_factory = PBClientFactory()
-        self.connector = reactor.connectTCP(LOCALHOST, port,
-                                            self.client_factory)
+        yield self.setup_client_server(self.sso_root)
         self.client = yield self._get_client()
         # pylint: enable=E1101
 
     @defer.inlineCallbacks
-    def tearDown(self):
-        """Clean reactor."""
-        yield super(SSOLoginTestCase, self).tearDown()
-        if self.server_factory.protocolInstance is not None:
-            self.server_factory.protocolInstance.transport.loseConnection()
-        yield defer.gatherResults([self._tearDownServer(),
-                                    self._tearDownClient()])
-
-    def _tearDownServer(self):
-        """Teardown the server."""
-        return defer.maybeDeferred(self.listener.stopListening)
-
-    def _tearDownClient(self):
-        """Tear down the client."""
-        self.connector.disconnect()
-        return defer.succeed(None)
-
-    @defer.inlineCallbacks
     def _get_client(self):
         """Get the client."""
         # request the remote object and create a client
@@ -541,7 +590,7 @@
         self.mocker.verify()
 
 
-class CredentialsManagementTestCase(TestCase):
+class CredentialsManagementTestCase(ConnectedTestCase, TestCase):
     """Test the management class."""
 
     @defer.inlineCallbacks
@@ -556,35 +605,12 @@
         self.creds.root = self.root
         # start pb
         self.sso_root = UbuntuSSORoot(cred_manager=self.creds)
-        self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
-        port = get_sso_pb_port()
-        self.listener = reactor.listenTCP(port, self.server_factory)
-        self.client_factory = PBClientFactory()
-        self.connector = reactor.connectTCP(LOCALHOST, port,
-                                            self.client_factory)
+        yield self.setup_client_server(self.sso_root)
         self.client = yield self._get_client()
         # pylint: enable=E1101
 
     @defer.inlineCallbacks
-    def tearDown(self):
-        """Clean reactor."""
-        yield super(CredentialsManagementTestCase, self).tearDown()
-        if self.server_factory.protocolInstance is not None:
-            self.server_factory.protocolInstance.transport.loseConnection()
-        yield defer.gatherResults([self._tearDownServer(),
-                                    self._tearDownClient()])
-
-    def _tearDownServer(self):
-        """Teardown the server."""
-        return defer.maybeDeferred(self.listener.stopListening)
-
-    def _tearDownClient(self):
-        """Tear down the client."""
-        self.connector.disconnect()
-        return defer.succeed(None)
-
-    @defer.inlineCallbacks
     def _get_client(self):
         """Get the client."""
         # request the remote object and create a client
@@ -592,6 +618,7 @@
         remote = yield root.callRemote('get_cred_manager')
         client = CredentialsManagementClient(remote)
         yield client.register_to_signals()
+        self.addCleanup(client.unregister_to_signals)
         # set the cb
         for signal_name in ['on_authorization_denied_cb',
                             'on_credentials_found_cb',

=== modified file 'ubuntu_sso/main/windows.py'
--- ubuntu_sso/main/windows.py	2011-09-27 14:06:12 +0000
+++ ubuntu_sso/main/windows.py	2011-12-19 19:46:24 +0000
@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-# Authors: Manuel de la Pena <[e-mail]>
-#          Alejandro J. Cura <[e-mail]>
 #
 # Copyright 2011 Canonical Ltd.
 #
@@ -26,10 +24,12 @@
 # pylint: enable=F0401
 
 from twisted.internet import defer, reactor
+from twisted.internet.task import LoopingCall
 from twisted.internet.threads import deferToThread
 from twisted.spread.pb import (
     DeadReferenceError,
     PBClientFactory,
+    PBServerFactory,
     Referenceable,
     Root,
 )
@@ -41,7 +41,12 @@
     SSOLoginRoot,
     except_to_errdict,
 )
-from ubuntu_sso.utils.tcpactivation import ActivationConfig, ActivationClient
+from ubuntu_sso.utils.tcpactivation import (
+    ActivationClient,
+    ActivationConfig,
+    ActivationInstance,
+    AlreadyStartedError,
+)
 
 
 logger = setup_logging("ubuntu_sso.main.windows")
@@ -857,3 +862,41 @@
     root = UbuntuSSOClient()
     yield root.connect()
     defer.returnValue(root.sso_login)
+
+
+def add_timeout(interval, callback, *args, **kwargs):
+    """Add a timeout callback as a task."""
+    time_out_task = LoopingCall(callback, *args, **kwargs)
+    time_out_task.start(interval / 1000, now=False)
+
+
+# the reactor does have run and stop methods
+# pylint: disable=E1101
+
[e-mail]
+def start_service():
+    """Initialize and start this process."""
+    try:
+        ai = ActivationInstance(get_activation_config())
+        port = yield ai.get_port()
+        logger.info("Starting Ubuntu SSO login manager for port %r.", port)
+
+        login = SSOLogin('ignored')
+        creds_management = CredentialsManagement(add_timeout, reactor.stop)
+        root = UbuntuSSORoot(sso_login=login, cred_manager=creds_management)
+
+        reactor.listenTCP(port, PBServerFactory(root), interface=LOCALHOST)
+    except AlreadyStartedError:
+        logger.error("Ubuntu SSO login manager already running, quitting.")
+        reactor.stop()
+    except:
+        logger.exception('Can not start Ubuntu SSO login manager:')
+        reactor.stop()
+
+
+def main():
+    """Run the backend service."""
+    start_service()
+    reactor.run()
+
+# pylint: enable=E1101

=== modified file 'ubuntu_sso/qt/controllers.py'
--- ubuntu_sso/qt/controllers.py	2011-11-11 20:34:57 +0000
+++ ubuntu_sso/qt/controllers.py	2011-12-19 19:46:24 +0000
@@ -828,8 +828,12 @@
         email = unicode(self.view.wizard().forgotten.ui.email_line_edit.text())
         self.view.wizard().current_user.ui.email_edit.setText(email)
         self.view.wizard().overlay.hide()
-        self.view.wizard().back()
-        self.view.wizard().back()
+        current_user_id = self.view.wizard().current_user_page_id
+        visited_pages = self.view.wizard().visitedPages()
+        for index in reversed(visited_pages):
+            if index == current_user_id:
+                break
+            self.view.wizard().back()
 
     def on_password_change_error(self, app_name, error):
         """Let the user know that there was an error."""
@@ -844,7 +848,7 @@
         email = unicode(self.view.wizard().forgotten.ui.email_line_edit.text())
         code = unicode(self.view.ui.reset_code_line_edit.text())
         password = unicode(self.view.ui.password_line_edit.text())
-        logger.info('Settig new password for %s and email %s with code %s',
+        logger.info('Setting new password for %r and email %r with code %r',
                     app_name, email, code)
         self.backend.set_new_password(app_name, email, code, password)
 

=== modified file 'ubuntu_sso/qt/tests/test_controllers.py'
--- ubuntu_sso/qt/tests/test_controllers.py	2011-11-11 20:34:57 +0000
+++ ubuntu_sso/qt/tests/test_controllers.py	2011-12-19 19:46:24 +0000
@@ -669,6 +669,7 @@
         self.count_back = 0
         self.hide_value = False
         self.text_value = '[e-mail]'
+        self.current_user_page_id = 4
 
     def wizard(self):
         """Fake wizard function for view."""
@@ -690,6 +691,10 @@
     def setText(self, text):
         """Fake setText for QLineEdit."""
         self.text_value = text
+
+    def visitedPages(self):
+        """Return an int list of fake visited pages."""
+        return [1, 4, 6, 8]
     # pylint: enable=C0103
 
 
@@ -2094,5 +2099,17 @@
         """Test that on_password_changed execute the proper operation."""
         self.controller.on_password_changed('app_name', '')
         self.assertTrue(self.controller.view.hide_value)
-        self.assertEqual(self.controller.view.count_back, 2)
+        times_visited = 2
+        self.assertEqual(self.controller.view.count_back, times_visited)
+        self.assertEqual(self.controller.view.text_value, '[e-mail]')
+
+    def test_on_password_changed_not_visited(self):
+        """Test that on_password_changed execute the proper operation."""
+        current_user_page_id = 20
+        self.patch(self.controller.view, "current_user_page_id",
+            current_user_page_id)
+        self.controller.on_password_changed('app_name', '')
+        self.assertTrue(self.controller.view.hide_value)
+        times_visited = 4
+        self.assertEqual(self.controller.view.count_back, times_visited)
         self.assertEqual(self.controller.view.text_value, '[e-mail]')

=== modified file 'ubuntu_sso/utils/__init__.py'
--- ubuntu_sso/utils/__init__.py	2011-10-06 19:38:19 +0000
+++ ubuntu_sso/utils/__init__.py	2011-12-19 19:46:24 +0000
@@ -45,7 +45,7 @@
 
     CHECKING_INTERVAL = 60 * 60  # in seconds
     ERROR_INTERVAL = 30  # in seconds
-    SERVER_URL = "http://one.ubuntu.com/"
+    SERVER_URL = "http://one.ubuntu.com/api/time"
 
     def __init__(self):
         """Initialize this instance."""

=== modified file 'ubuntu_sso/utils/tests/test_tcpactivation.py'
--- ubuntu_sso/utils/tests/test_tcpactivation.py	2011-10-28 10:41:18 +0000
+++ ubuntu_sso/utils/tests/test_tcpactivation.py	2011-12-19 19:46:24 +0000
@@ -51,12 +51,25 @@
         """Echo the data received."""
         self.transport.write(data)
 
+    #pylint:disable=E1101
+    def connectionLost(self, *a):
+        self.factory.onConnectionLost.callback(self)
+    #pylint:enable=E1101
+
 
 class FakeServerFactory(protocol.Factory):
     """A factory for the test server."""
 
     protocol = FakeServerProtocol
 
+    #pylint:disable=W0201
+    def __init__(self, testcase=None):
+        """Create a new instance for the testcase."""
+        if testcase is not None:
+            self.onConnectionLost = defer.Deferred()
+            testcase.addCleanup(lambda: self.onConnectionLost)
+    #pylint:enable=W0201
+
 
 class FakeTransport(object):
     """A fake transport."""
@@ -197,7 +210,7 @@
     @defer.inlineCallbacks
     def test_is_already_running(self):
         """The is_already_running method returns True if already started."""
-        f = FakeServerFactory()
+        f = FakeServerFactory(self)
         # pylint: disable=E1101
         listener = reactor.listenTCP(SAMPLE_PORT, f,
                                      interface=tcpactivation.LOCALHOST)
@@ -319,18 +332,20 @@
         port = yield ai.get_port()
         self.assertEqual(port, SAMPLE_PORT)
 
+    #pylint:disable=W0201
     @defer.inlineCallbacks
     def test_get_port_fails_if_service_already_started(self):
         """The get_port method fails if service already started."""
         ai1 = ActivationInstance(self.config)
         port1 = yield ai1.get_port()
-        f = FakeServerFactory()
+        f = FakeServerFactory(self)
         # pylint: disable=E1101
         listener = reactor.listenTCP(port1, f,
                                      interface=tcpactivation.LOCALHOST)
         self.addCleanup(listener.stopListening)
         ai2 = ActivationInstance(self.config)
         yield self.assertFailure(ai2.get_port(), AlreadyStartedError)
+    #pylint:enable=W0201
 
 
 def server_test(config):

=== modified file 'ubuntu_sso/utils/tests/test_txsecrets.py'
--- ubuntu_sso/utils/tests/test_txsecrets.py	2011-10-28 10:41:18 +0000
+++ ubuntu_sso/utils/tests/test_txsecrets.py	2011-12-19 19:46:24 +0000
@@ -22,7 +22,7 @@
 import dbus.service
 
 from twisted.internet.defer import inlineCallbacks, returnValue
-from ubuntuone.devtools.testcase import DBusTestCase
+from ubuntuone.devtools.testcases.dbus import DBusTestCase
 
 from ubuntu_sso.utils import txsecrets
 

=== modified file 'ubuntu_sso/utils/ui.py'
--- ubuntu_sso/utils/ui.py	2011-10-20 14:15:46 +0000
+++ ubuntu_sso/utils/ui.py	2011-12-19 19:46:24 +0000
@@ -88,8 +88,8 @@
 SUCCESS = _('You are now logged into %(app_name)s.')
 SURNAME_ENTRY = _('Surname')
 TC_BUTTON = _('Show Terms & Conditions')
-TC_NOT_ACCEPTED = _('Agreeing to the Ubuntu One Terms & Conditions is ' \
-                        'required to subscribe.')
+TC_NOT_ACCEPTED = _('Agreeing to the %(app_name)s Terms & Conditions is ' \
+                    'required to subscribe.')
 TOS_LABEL = _("You can also find these terms at <a href='%(url)s'>%(url)s</a>")
 TRY_AGAIN_BUTTON = _('Try again')
 UNKNOWN_ERROR = _('There was an error when trying to complete the ' \

=== added directory 'ubuntu_sso/utils/webclient'
=== added file 'ubuntu_sso/utils/webclient/__init__.py'
--- ubuntu_sso/utils/webclient/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/__init__.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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 common webclient that can use a QtNetwork or libsoup backend."""
+
+import sys
+
+# pylint: disable=W0611
+from ubuntu_sso.utils.webclient.common import (
+    UnauthorizedError,
+    WebClientError,
+)
+
+
+def is_qt4reactor_installed():
+    """Check if the qt4reactor is installed."""
+    reactor = sys.modules.get("twisted.internet.reactor")
+    return reactor and getattr(reactor, "qApp", None)
+
+
+def webclient_module():
+    """Choose the module of the web client."""
+    if is_qt4reactor_installed():
+        from ubuntu_sso.utils.webclient import qtnetwork as web_module
+    else:
+        # the libsoup backend depends on the twisted + GI bug
+        # meanwhile, use the txweb sample client
+        #from ubuntu_sso.utils.webclient import libsoup as web_module
+        from ubuntu_sso.utils.webclient import txweb as web_module
+    return web_module
+
+
+def webclient_factory(*args, **kwargs):
+    """Choose the type of the web client dynamically."""
+    web_module = webclient_module()
+    return web_module.WebClient(*args, **kwargs)

=== added file 'ubuntu_sso/utils/webclient/common.py'
--- ubuntu_sso/utils/webclient/common.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/common.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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/>.
+"""The common bits of a webclient."""
+
+import time
+
+from oauth import oauth
+from twisted.internet import defer
+
+
+class WebClientError(Exception):
+    """An http error happened while calling the webservice."""
+
+
+class UnauthorizedError(WebClientError):
+    """The request ended with bad_request, unauthorized or forbidden."""
+
+
+class Response(object):
+    """A reponse object."""
+
+    def __init__(self, content, headers=None):
+        """Initialize this instance."""
+        self.content = content
+        self.headers = headers
+
+
+class BaseWebClient(object):
+    """The webclient base class, to be extended by backends."""
+
+    def __init__(self, username=None, password=None):
+        """Initialize this instance."""
+        self.username = username
+        self.password = password
+
+    def request(self, url, method="GET", extra_headers=None,
+                oauth_credentials=None):
+        """Return a deferred that will be fired with a Response object."""
+        raise NotImplementedError
+
+    def get_timestamp(self):
+        """Get a timestamp synchronized with the server."""
+        # pylint: disable=W0511
+        # TODO: get the synchronized timestamp
+        return defer.succeed(time.time())
+
+    @staticmethod
+    def build_oauth_headers(method, url, credentials, timestamp):
+        """Build an oauth request given some credentials."""
+        consumer = oauth.OAuthConsumer(credentials["consumer_key"],
+                                       credentials["consumer_secret"])
+        token = oauth.OAuthToken(credentials["token"],
+                                 credentials["token_secret"])
+        parameters = {}
+        if timestamp:
+            parameters["oauth_timestamp"] = timestamp
+        request = oauth.OAuthRequest.from_consumer_and_token(
+                                            http_url=url,
+                                            http_method=method,
+                                            parameters=parameters,
+                                            oauth_consumer=consumer,
+                                            token=token)
+        sig_method = oauth.OAuthSignatureMethod_HMAC_SHA1()
+        request.sign_request(sig_method, consumer, token)
+        return request.to_header()
+
+    def shutdown(self):
+        """Shut down all pending requests (if possible)."""

=== added file 'ubuntu_sso/utils/webclient/libsoup.py'
--- ubuntu_sso/utils/webclient/libsoup.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/libsoup.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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 webclient backend that uses libsoup."""
+
+import httplib
+
+from twisted.internet import defer
+
+from ubuntu_sso.utils.webclient.common import (
+    BaseWebClient,
+    Response,
+    UnauthorizedError,
+    WebClientError,
+)
+
+
+class WebClient(BaseWebClient):
+    """A webclient with a libsoup backend."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize this instance."""
+        super(WebClient, self).__init__(*args, **kwargs)
+        # pylint: disable=E0611
+        from gi.repository import Soup, SoupGNOME
+        self.soup = Soup
+        self.session = Soup.SessionAsync()
+        self.session.add_feature_by_type(SoupGNOME.ProxyResolverGNOME)
+        self.session.connect("authenticate", self._on_authenticate)
+
+    def _on_message(self, session, message, d):
+        """Handle the result of an http message."""
+        if message.status_code == httplib.OK:
+            response = Response(message.response_body.data)
+            d.callback(response)
+        elif message.status_code == httplib.UNAUTHORIZED:
+            e = UnauthorizedError(message.reason_phrase)
+            d.errback(e)
+        else:
+            e = WebClientError(message.reason_phrase)
+            d.errback(e)
+
+    def _on_authenticate(self, sesion, message, auth, retrying, data=None):
+        """Handle the "authenticate" signal."""
+        if not retrying and self.username and self.password:
+            auth.authenticate(self.username, self.password)
+
+    @defer.inlineCallbacks
+    def request(self, url, method="GET", extra_headers=None,
+                oauth_credentials=None):
+        """Return a deferred that will be fired with a Response object."""
+        if extra_headers:
+            headers = dict(extra_headers)
+        else:
+            headers = {}
+
+        if oauth_credentials:
+            timestamp = yield self.get_timestamp()
+            oauth_headers = self.build_oauth_headers(method, url,
+                                                oauth_credentials, timestamp)
+            headers.update(oauth_headers)
+
+        d = defer.Deferred()
+        message = self.soup.Message.new(method, url)
+
+        for key, value in headers.iteritems():
+            message.request_headers.append(key, value)
+
+        self.session.queue_message(message, self._on_message, d)
+        response = yield d
+        defer.returnValue(response)
+
+    def shutdown(self):
+        """End the soup session for this webclient."""
+        self.session.abort()

=== added file 'ubuntu_sso/utils/webclient/qtnetwork.py'
--- ubuntu_sso/utils/webclient/qtnetwork.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/qtnetwork.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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 webclient backend that uses QtNetwork."""
+
+from PyQt4.QtCore import (
+    QCoreApplication,
+    QUrl,
+)
+from PyQt4.QtNetwork import (
+    QNetworkAccessManager,
+    QNetworkReply,
+    QNetworkRequest,
+)
+from twisted.internet import defer
+
+from ubuntu_sso.utils.webclient.common import (
+    BaseWebClient,
+    Response,
+    UnauthorizedError,
+    WebClientError,
+)
+
+
+class WebClient(BaseWebClient):
+    """A webclient with a qtnetwork backend."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize this instance."""
+        super(WebClient, self).__init__(*args, **kwargs)
+        self.nam = QNetworkAccessManager(QCoreApplication.instance())
+        self.nam.finished.connect(self._handle_finished)
+        self.nam.authenticationRequired.connect(self._handle_authentication)
+        self.replies = {}
+
+    @defer.inlineCallbacks
+    def request(self, url, method="GET", extra_headers=None,
+                oauth_credentials=None):
+        """Return a deferred that will be fired with a Response object."""
+        request = QNetworkRequest(QUrl(url))
+
+        if extra_headers:
+            headers = dict(extra_headers)
+        else:
+            headers = {}
+
+        if oauth_credentials:
+            timestamp = yield self.get_timestamp()
+            oauth_headers = self.build_oauth_headers(method, url,
+                                                oauth_credentials, timestamp)
+            headers.update(oauth_headers)
+
+        for key, value in headers.iteritems():
+            request.setRawHeader(key, value)
+
+        d = defer.Deferred()
+        if method == "GET":
+            reply = self.nam.get(request)
+        elif method == "HEAD":
+            reply = self.nam.head(request)
+        else:
+            reply = self.nam.sendCustomRequest(request, method)
+        self.replies[reply] = d
+        result = yield d
+        defer.returnValue(result)
+
+    def _handle_authentication(self, reply, authenticator):
+        """The reply needs authentication."""
+        authenticator.setUser(self.username)
+        authenticator.setPassword(self.password)
+
+    def _handle_finished(self, reply):
+        """The reply has finished processing."""
+        assert reply in self.replies
+        d = self.replies.pop(reply)
+        error = reply.error()
+        if not error:
+            response = Response(reply.readAll())
+            d.callback(response)
+        else:
+            if error == QNetworkReply.AuthenticationRequiredError:
+                exception = UnauthorizedError(reply.errorString())
+            else:
+                exception = WebClientError(reply.errorString())
+            d.errback(exception)
+
+    def shutdown(self):
+        """Shut down all pending requests (if possible)."""
+        self.nam.deleteLater()

=== added directory 'ubuntu_sso/utils/webclient/tests'
=== added file 'ubuntu_sso/utils/webclient/tests/__init__.py'
--- ubuntu_sso/utils/webclient/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/tests/__init__.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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 proxy-aware webclient."""

=== added file 'ubuntu_sso/utils/webclient/tests/test_webclient.py'
--- ubuntu_sso/utils/webclient/tests/test_webclient.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/tests/test_webclient.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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 AN 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/>.
+"""Integration tests for the proxy-enabled webclient."""
+
+import os
+import sys
+import urllib
+
+from twisted.application import internet, service
+from twisted.cred import checkers, portal
+from twisted.internet import defer
+from twisted.web import http, resource, server, guard
+
+from ubuntuone.devtools.testcases import TestCase
+
+from ubuntu_sso.utils import webclient
+
+ANY_VALUE = object()
+SAMPLE_KEY = "result"
+SAMPLE_VALUE = "sample result"
+SAMPLE_RESOURCE = '{"%s": "%s"}' % (SAMPLE_KEY, SAMPLE_VALUE)
+SAMPLE_USERNAME = "peddro"
+SAMPLE_PASSWORD = "cantropus"
+SAMPLE_CREDENTIALS = dict(
+    consumer_key="consumer key",
+    consumer_secret="consumer secret",
+    token="the real token",
+    token_secret="the token secret",
+)
+SAMPLE_HEADERS = {SAMPLE_KEY: SAMPLE_VALUE}
+
+SIMPLERESOURCE = "simpleresource"
+THROWERROR = "throwerror"
+UNAUTHORIZED = "unauthorized"
+HEADONLY = "headonly"
+VERIFYHEADERS = "verifyheaders"
+GUARDED = "guarded"
+OAUTHRESOURCE = "oauthresource"
+
+
+def sample_get_credentials():
+    """Will return the sample credentials right now."""
+    return defer.succeed(SAMPLE_CREDENTIALS)
+
+
+# pylint: disable=C0103
+# t.w.resource methods have freeform cased names
+
+class SimpleResource(resource.Resource):
+    """A simple web resource."""
+
+    def render_GET(self, request):
+        """Make a bit of html out of these resource's content."""
+        return SAMPLE_RESOURCE
+
+
+class HeadOnlyResource(resource.Resource):
+    """A resource that fails if called with a method other than HEAD."""
+
+    def render_HEAD(self, request):
+        """Return a bit of html."""
+        return "OK"
+
+
+class VerifyHeadersResource(resource.Resource):
+    """A resource that verifies the headers received."""
+
+    def render_GET(self, request):
+        """Make a bit of html out of these resource's content."""
+        headers = request.requestHeaders.getRawHeaders(SAMPLE_KEY)
+        if headers != [SAMPLE_VALUE]:
+            request.setResponseCode(http.BAD_REQUEST)
+            return "ERROR: Expected header not present."
+        return SAMPLE_RESOURCE
+
+
+class SimpleRealm(object):
+    """The same simple resource for all users."""
+
+    def requestAvatar(self, avatarId, mind, *interfaces):
+        """The avatar for this user."""
+        if resource.IResource in interfaces:
+            return (resource.IResource, SimpleResource(), lambda: None)
+        raise NotImplementedError()
+
+
+class OAuthCheckerResource(resource.Resource):
+    """A resource that verifies the request was oauth signed."""
+
+    def render_GET(self, request):
+        """Make a bit of html out of these resource's content."""
+        header = request.requestHeaders.getRawHeaders("Authorization")[0]
+        if header.startswith("OAuth "):
+            return SAMPLE_RESOURCE
+        request.setResponseCode(http.BAD_REQUEST)
+        return "ERROR: Expected OAuth header not present."
+
+
+class MockWebServer(object):
+    """A mock webserver for testing"""
+
+    def __init__(self):
+        """Start up this instance."""
+        root = resource.Resource()
+        root.putChild(SIMPLERESOURCE, SimpleResource())
+
+        root.putChild(THROWERROR, resource.NoResource())
+
+        unauthorized_resource = resource.ErrorPage(resource.http.UNAUTHORIZED,
+                                                "Unauthorized", "Unauthorized")
+        root.putChild(UNAUTHORIZED, unauthorized_resource)
+        root.putChild(HEADONLY, HeadOnlyResource())
+        root.putChild(VERIFYHEADERS, VerifyHeadersResource())
+        root.putChild(OAUTHRESOURCE, OAuthCheckerResource())
+
+        db = checkers.InMemoryUsernamePasswordDatabaseDontUse()
+        db.addUser(SAMPLE_USERNAME, SAMPLE_PASSWORD)
+        test_portal = portal.Portal(SimpleRealm(), [db])
+        cred_factory = guard.BasicCredentialFactory("example.org")
+        guarded_resource = guard.HTTPAuthSessionWrapper(test_portal,
+                                                        [cred_factory])
+        root.putChild(GUARDED, guarded_resource)
+
+        site = server.Site(root)
+        application = service.Application('web')
+        self.service_collection = service.IServiceCollection(application)
+        #pylint: disable=E1101
+        self.tcpserver = internet.TCPServer(0, site)
+        self.tcpserver.setServiceParent(self.service_collection)
+        self.service_collection.startService()
+
+    def get_url(self):
+        """Build the url for this mock server."""
+        #pylint: disable=W0212
+        port_num = self.tcpserver._port.getHost().port
+        return "http://localhost:%d/" % port_num
+
+    def stop(self):
+        """Shut it down."""
+        #pylint: disable=E1101
+        return self.service_collection.stopService()
+
+
+class FakeReactor(object):
+    """A fake reactor object."""
+    qApp = "Sample qapp"
+
+
+class ModuleSelectionTestCase(TestCase):
+    """Test the functions to choose the qtnet or libsoup backend."""
+
+    def test_is_qt4reactor_installed_not_installed(self):
+        """When the qt4reactor is not installed, it returns false."""
+        self.patch(sys, "modules", {})
+        self.assertFalse(webclient.is_qt4reactor_installed())
+
+    def test_is_qt4reactor_installed_installed(self):
+        """When the qt4reactor is installed, it returns true."""
+        fake_sysmodules = {"twisted.internet.reactor": FakeReactor()}
+        self.patch(sys, "modules", fake_sysmodules)
+        self.assertTrue(webclient.is_qt4reactor_installed())
+
+    def assert_module_name(self, module, expected_name):
+        """Check the name of a given module."""
+        module_filename = os.path.basename(module.__file__)
+        module_name = os.path.splitext(module_filename)[0]
+        self.assertEqual(module_name, expected_name)
+
+    def test_webclient_module_qtnetwork(self):
+        """Test the module name for the qtnetwork case."""
+        self.patch(webclient, "is_qt4reactor_installed", lambda: True)
+        module = webclient.webclient_module()
+        self.assert_module_name(module, "qtnetwork")
+
+    def test_webclient_module_libsoup(self):
+        """Test the module name for the libsoup case."""
+        self.patch(webclient, "is_qt4reactor_installed", lambda: False)
+        module = webclient.webclient_module()
+        # pylint: disable=W0511
+        # TODO: the libsoup backend depends on the twisted + GI bug
+        # meanwhile, use the test txweb client
+        #self.assert_module_name(module, "libsoup")
+        self.assert_module_name(module, "txweb")
+
+
+class WebClientTestCase(TestCase):
+    """Test for the webclient."""
+
+    timeout = 8
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(WebClientTestCase, self).setUp()
+        self.ws = MockWebServer()
+        self.addCleanup(self.ws.stop)
+        self.base_url = self.ws.get_url()
+        self.wc = webclient.webclient_factory()
+        self.addCleanup(self.wc.shutdown)
+        # pylint: disable=W0511
+        # TODO: skewed timestamp correction
+
+    @defer.inlineCallbacks
+    def test_get_url(self):
+        """A url is successfully retrieved from the mock webserver."""
+        result = yield self.wc.request(self.base_url + SIMPLERESOURCE)
+        self.assertEqual(SAMPLE_RESOURCE, result.content)
+
+    @defer.inlineCallbacks
+    def test_get_url_error(self):
+        """The errback is called when there's some error."""
+        yield self.assertFailure(self.wc.request(self.base_url + THROWERROR),
+                                 webclient.WebClientError)
+
+    @defer.inlineCallbacks
+    def test_unauthorized(self):
+        """Detect when a request failed with the UNAUTHORIZED http code."""
+        yield self.assertFailure(self.wc.request(self.base_url + UNAUTHORIZED),
+                                 webclient.UnauthorizedError)
+
+    @defer.inlineCallbacks
+    def test_method_head(self):
+        """The HTTP method is used."""
+        result = yield self.wc.request(self.base_url + HEADONLY, method="HEAD")
+        self.assertEqual("", result.content)
+
+    @defer.inlineCallbacks
+    def test_send_extra_headers(self):
+        """The extra_headers are sent to the server."""
+        result = yield self.wc.request(self.base_url + VERIFYHEADERS,
+                                       extra_headers=SAMPLE_HEADERS)
+        self.assertEqual(SAMPLE_RESOURCE, result.content)
+
+    @defer.inlineCallbacks
+    def test_send_basic_auth(self):
+        """The basic authentication headers are sent."""
+        other_wc = webclient.webclient_factory(username=SAMPLE_USERNAME,
+                                               password=SAMPLE_PASSWORD)
+        self.addCleanup(other_wc.shutdown)
+        result = yield other_wc.request(self.base_url + GUARDED)
+        self.assertEqual(SAMPLE_RESOURCE, result.content)
+
+    @defer.inlineCallbacks
+    def test_request_is_oauth_signed(self):
+        """The request is oauth signed."""
+        result = yield self.wc.request(self.base_url + OAUTHRESOURCE,
+                                       oauth_credentials=SAMPLE_CREDENTIALS)
+        self.assertEqual(SAMPLE_RESOURCE, result.content)
+
+
+class OAuthTestCase(TestCase):
+    """Test for the oauth signing code."""
+
+    def parse_oauth_header(self, header):
+        """Parse an oauth header into a tuple of (method, params_dict)."""
+        params = {}
+
+        method, params_string = header.split(" ", 1)
+        for p in params_string.split(","):
+            k, v = p.strip().split("=")
+            params[k] = urllib.unquote(v[1:-1])
+
+        return method, params
+
+    def test_build_oauth_headers(self):
+        """Build the oauth headers for a sample request."""
+
+        sample_method = "GET"
+        sample_url = "http://one.ubuntu.com/"
+        timestamp = 1
+        expected_params = {
+            "oauth_timestamp": str(timestamp),
+            "oauth_consumer_key": SAMPLE_CREDENTIALS["consumer_key"],
+            "oauth_signature_method": "HMAC-SHA1",
+            "oauth_token": SAMPLE_CREDENTIALS["token"],
+            "oauth_nonce": ANY_VALUE,
+            "oauth_signature": ANY_VALUE,
+        }
+
+        module = webclient.webclient_module()
+        headers = module.BaseWebClient.build_oauth_headers(sample_method,
+                                    sample_url, SAMPLE_CREDENTIALS, timestamp)
+
+        method, params = self.parse_oauth_header(headers["Authorization"])
+
+        self.assertEqual(method, "OAuth")
+
+        for k, expected_value in expected_params.iteritems():
+            self.assertIn(k, params)
+            if expected_value is not ANY_VALUE:
+                self.assertEqual(params[k], expected_value)

=== added file 'ubuntu_sso/utils/webclient/txweb.py'
--- ubuntu_sso/utils/webclient/txweb.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/txweb.py	2011-12-19 19:46:24 +0000
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 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 webclient backend that uses twisted.web.client."""
+
+import base64
+
+from twisted.web import client, error, http
+from twisted.internet import defer
+
+from ubuntu_sso.utils.webclient.common import (
+    BaseWebClient,
+    Response,
+    UnauthorizedError,
+    WebClientError,
+)
+
+
+class WebClient(BaseWebClient):
+    """A simple web client that does not support proxies, yet."""
+
+    @defer.inlineCallbacks
+    def request(self, url, method="GET", extra_headers=None,
+                oauth_credentials=None):
+        """Get the page, or fail trying."""
+        if extra_headers:
+            headers = dict(extra_headers)
+        else:
+            headers = {}
+
+        if oauth_credentials:
+            timestamp = yield self.get_timestamp()
+            oauth_headers = self.build_oauth_headers(method, url,
+                                                oauth_credentials, timestamp)
+            headers.update(oauth_headers)
+
+        if self.username and self.password:
+            auth = base64.b64encode(self.username + ":" + self.password)
+            headers["Authorization"] = "Basic " + auth
+
+        try:
+            result = yield client.getPage(url, method=method, headers=headers)
+            response = Response(result)
+            defer.returnValue(response)
+        except error.Error as e:
+            if int(e.status) == http.UNAUTHORIZED:
+                raise UnauthorizedError(e.message)
+            raise WebClientError(e.message)