Merge lp:~dobey/ubuntu/oneiric/ubuntu-sso-client/release-133 into lp:ubuntu/oneiric/ubuntu-sso-client

[dobey]

=== modified file 'PKG-INFO'
--- PKG-INFO	2011-07-22 20:12:20 +0000
+++ PKG-INFO	2011-08-25 19:16:19 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 1.3.2
+Version: 1.3.3
 Summary: Ubuntu Single Sign-On client
 Home-page: https://launchpad.net/ubuntu-sso-client
 Author: Natalia Bidart
@@ -8,4 +8,22 @@
 License: GPL v3
 Description: Desktop service to allow applications to sign into Ubuntu services via SSO
 Platform: UNKNOWN
+Requires: Image
+Requires: PIL
+Requires: PyQt4
+Requires: dbus
+Requires: gi.repository
+Requires: gobject
+Requires: gtk
+Requires: keyring
+Requires: mocker
+Requires: oauth
+Requires: twisted.internet
+Requires: twisted.python
+Requires: twisted.spread.pb
+Requires: twisted.trial
+Requires: ubuntuone.devtools.handlers
+Requires: ubuntuone.devtools.testcase
+Requires: webkit
+Requires: xdg.BaseDirectory
 Provides: ubuntu_sso
 
=== modified file 'bin/windows-ubuntu-sso-login'
--- bin/windows-ubuntu-sso-login	2011-07-22 20:12:20 +0000
+++ bin/windows-ubuntu-sso-login	2011-08-25 19:16:19 +0000
@@ -28,16 +28,25 @@
 import qtreactor.qt4reactor
 qtreactor.qt4reactor.install()
 
-from twisted.internet import reactor
+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,
     SSOCredentials,
     SSOLogin,
     UbuntuSSORoot,
-    get_sso_pb_hostport)
+    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."""
@@ -45,13 +54,35 @@
     time_out_task.start(interval/1000, now=False)
 
 
-if __name__ == '__main__':
-    host, port = get_sso_pb_hostport()
[e-mail]
+def main():
+    """Initialize and start this process."""
+    ai = tcpactivation.ActivationInstance(get_activation_config())
+    port = yield ai.get_port()
 
     login = SSOLogin('ignored')
     creds = SSOCredentials()
     creds_management = CredentialsManagement(add_timeout, reactor.stop)
     root = UbuntuSSORoot(login, creds, creds_management)
 
-    listener = reactor.listenTCP(port, PBServerFactory(root), interface=host)
+    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 'data/qt/current_user_sign_in.ui'
--- data/qt/current_user_sign_in.ui	2011-07-22 20:12:20 +0000
+++ data/qt/current_user_sign_in.ui	2011-08-25 19:16:19 +0000
@@ -6,14 +6,14 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>300</height>
+    <width>399</width>
+    <height>309</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>WizardPage</string>
   </property>
-  <layout class="QHBoxLayout" name="horizontalLayout">
+  <layout class="QVBoxLayout" name="verticalLayout_4">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
@@ -122,6 +122,9 @@
               </item>
               <item>
                <widget class="QPushButton" name="sign_in_button">
+                <property name="enabled">
+                 <bool>false</bool>
+                </property>
                 <property name="text">
                  <string>Sign In</string>
                 </property>
 
=== modified file 'data/qt/email_verification.ui'
--- data/qt/email_verification.ui	2011-06-24 19:14:17 +0000
+++ data/qt/email_verification.ui	2011-08-25 19:16:19 +0000
@@ -13,7 +13,7 @@
   <property name="windowTitle">
    <string>WizardPage</string>
   </property>
-  <layout class="QHBoxLayout" name="horizontalLayout">
+  <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
 
=== modified file 'data/qt/forgotten_password.ui'
--- data/qt/forgotten_password.ui	2011-06-24 19:14:17 +0000
+++ data/qt/forgotten_password.ui	2011-08-25 19:16:19 +0000
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>446</width>
-    <height>209</height>
+    <height>317</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -109,6 +109,9 @@
      </item>
      <item>
       <widget class="QPushButton" name="send_button">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
        <property name="text">
         <string/>
        </property>
 
=== modified file 'data/qt/reset_password.ui'
--- data/qt/reset_password.ui	2011-06-24 19:14:17 +0000
+++ data/qt/reset_password.ui	2011-08-25 19:16:19 +0000
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>476</width>
-    <height>282</height>
+    <height>262</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -65,6 +65,9 @@
          </item>
          <item>
           <widget class="QPushButton" name="reset_password_button">
+           <property name="enabled">
+            <bool>false</bool>
+           </property>
            <property name="text">
             <string/>
            </property>
 
=== modified file 'data/qt/setup_account.ui'
--- data/qt/setup_account.ui	2011-06-24 19:14:17 +0000
+++ data/qt/setup_account.ui	2011-08-25 19:16:19 +0000
@@ -7,29 +7,16 @@
     <x>0</x>
     <y>0</y>
     <width>407</width>
-    <height>453</height>
+    <height>572</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>WizardPage</string>
   </property>
-  <layout class="QHBoxLayout" name="horizontalLayout">
+  <layout class="QVBoxLayout" name="verticalLayout_5">
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
-      <spacer name="verticalSpacer_3">
-       <property name="orientation">
-        <enum>Qt::Vertical</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>20</width>
-         <height>40</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
       <widget class="QFrame" name="_signInFrame">
        <property name="frameShape">
         <enum>QFrame::NoFrame</enum>
 
=== modified file 'debian/changelog'
--- debian/changelog	2011-07-26 13:58:21 +0000
+++ debian/changelog	2011-08-25 19:16:19 +0000
@@ -1,3 +1,10 @@
+ubuntu-sso-client (1.3.3-0ubuntu1) oneiric; urgency=low
+
+  * New upstream release.
+    - Work correctly with static and GI bindings of gobject (LP: #829186)
+
+ -- Rodney Dawes <[e-mail]>  Thu, 25 Aug 2011 15:08:27 -0400
+
 ubuntu-sso-client (1.3.2-0ubuntu2) oneiric; urgency=low
 
   * Require python-qt4 to build, as distutils doesn't have optional deps
 
=== modified file 'run-tests'
--- run-tests	2011-07-22 20:12:20 +0000
+++ run-tests	2011-08-25 19:16:19 +0000
@@ -16,8 +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/>.
 
+QT_TESTS_PATH=ubuntu_sso/qt/tests
+GTK_TESTS_PATH=ubuntu_sso/gtk/tests
+
 set -e
 
+if [ "$1" == "-qt" ]; then
+    USE_QT=1
+    shift
+else
+    USE_QT=0
+fi
+
 if [ $# -ne 0 ]; then
     # run specific module given by the caller
     MODULE="$@"
@@ -30,7 +40,7 @@
     ./setup.py clean
     u1lint
     if [ -x `which pep8` ]; then
-        pep8 --repeat bin/ $MODULE
+        pep8 --repeat .
     else
         echo "Please install the 'pep8' package."
     fi
@@ -39,6 +49,12 @@
 unset GTK_MODULES
 
 echo "Running test suite for ""$MODULE"
-`which xvfb-run` u1trial "$MODULE" -i "test_windows.py, test_qt_views.py"
+if [ "$USE_QT" -eq 0 ]; then
+    `which xvfb-run` u1trial -p "$QT_TESTS_PATH" -i "test_windows.py" "$MODULE"
+else
+    ./setup.py build
+    `which xvfb-run` u1trial -p "$GTK_TESTS_PATH" -i "test_windows.py" --reactor=qt4 --gui "$MODULE"
+fi
 style_check
 rm -rf _trial_temp
+rm -rf build
 
=== modified file 'run-tests.bat'
--- run-tests.bat	2011-07-22 20:12:20 +0000
+++ run-tests.bat	2011-08-25 19:16:19 +0000
@@ -60,13 +60,11 @@
 ECHO Cleaning the generated code before running the style checks...
 "%PYTHONEXEPATH%\python.exe" setup.py clean
 ECHO Performing style checks...
-"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1lint" ubuntu_sso
+SET IGNORE_LINT="ubuntu_sso\gtk,ubuntu_sso\networkstate\linux.py,ubuntu_sso\main\linux.py,ubuntu_sso\main\tests\test_linux.py,ubuntu_sso\utils\txsecrets.py,ubuntu_sso\utils\tests\test_txsecrets.py,ubuntu_sso\tests\bin,bin\ubuntu-sso-login"
+"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1lint" -i "%IGNORE_LINT%" ubuntu_sso
 :: test for style if we can, if pep8 is not present, move to the end
-IF EXIST "%PYTHONEXEPATH%\Scripts\pep8.exe"
-"%PYTHONEXEPATH%\Scripts\pep8.exe" --repeat ubuntu_sso
-ELSE
-ECHO Style checks were not done
+"%PYTHONEXEPATH%\Scripts\pep8.exe" --repeat .
 :: Delete the temp folders
-RMDIR /s /q _trial_temp
-RMDIR /s /q .coverage
+RMDIR /q /s _trial_temp
+RMDIR /q /s .coverage
 :END
 
=== modified file 'setup.py'
--- setup.py	2011-07-22 20:12:20 +0000
+++ setup.py	2011-08-25 19:16:19 +0000
@@ -22,6 +22,7 @@
 
 # pylint: disable=W0404, W0511
 
+import distutils
 import os
 import sys
 
@@ -43,6 +44,7 @@
 CLEANFILES = [SERVICE_FILE, POT_FILE, 'MANIFEST']
 QT_UI_DIR = os.path.join('ubuntu_sso', 'qt')
 
+
 def replace_prefix(prefix):
     """Replace every '@prefix@' with prefix within 'filename' content."""
     # replace .service file
@@ -242,7 +244,7 @@
     # this some day. If this doesn't work, try import modulefinder
     for package_path in win32com.__path__[1:]:
         modulefinder.AddPackagePath("win32com", package_path)
-    for extra_mod in ["win32com.server" ,"win32com.client"]: 
+    for extra_mod in ["win32com.server", "win32com.client"]:
         __import__(extra_mod)
         module = sys.modules[extra_mod]
         for module_path in module.__path__[1:]:
@@ -251,7 +253,7 @@
     # lazr uses namespaces packages, which does add some problems to py2exe
     # the following is a way to work arround the issue
     for path in lazr.__path__:
-        modulefinder.AddPackagePath(__name__, path) 
+        modulefinder.AddPackagePath(__name__, path)
 
 
 def get_py2exe_extension():
@@ -261,14 +263,10 @@
     from py2exe.build_exe import py2exe as build_exe
     # pylint: enable=F0401
 
-    # pylint: disable=E1101
+    # pylint: disable=E1101,W0232
     class MediaCollector(build_exe):
         """Extension that copies lazr missing data."""
 
-        def __init__(self, *args, **kwargs):
-            """Create a new instance."""
-            build_exe.__init__(self, *args, **kwargs)
-
         def _add_module_data(self, module_name):
             """Add the data from a given path."""
             # Create the media subdir where the
@@ -310,6 +308,24 @@
     'clean': SSOClean,
 }
 
+
+class dummy_build_i18n(distutils.cmd.Command):
+
+    """Dummy for windows."""
+
+    def initialize_options(self, *args):
+        """Dummy."""
+
+    def finalize_options(self, *args):
+        """Dummy."""
+
+    def run(self, *args):
+        """Dummy."""
+
+if sys.platform == 'win32':
+    cmdclass['build_i18n'] = dummy_build_i18n
+
+
 def setup_windows():
     """Provide the required info to setup the project on windows."""
     set_py2exe_paths()
@@ -329,7 +345,7 @@
             },
         },
         # add the console script so that py2exe compiles it
-        'console': ['bin/windows-ubuntu-sso-login',],
+        'console': ['bin/windows-ubuntu-sso-login'],
         'zipfile': None,
     }
     return _data_files, _extra
@@ -344,7 +360,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='1.3.2',
+    version='1.3.3',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',
@@ -355,9 +371,14 @@
     extra_path='ubuntu-sso-client',
     data_files=data_files,
     packages=[
-        'ubuntu_sso', 'ubuntu_sso.utils', 'ubuntu_sso.keyring',
-        'ubuntu_sso.networkstate', 'ubuntu_sso.main',
-        'ubuntu_sso.gtk', 'ubuntu_sso.qt',
+        'ubuntu_sso',
+        'ubuntu_sso.utils',
+        'ubuntu_sso.keyring',
+        'ubuntu_sso.networkstate',
+        'ubuntu_sso.main',
+        'ubuntu_sso.gtk',
+        'ubuntu_sso.qt',
+        'ubuntu_sso.xdg_base_directory',
     ],
     cmdclass=cmdclass,
     **extra)
 
=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2011-01-12 18:56:56 +0000
+++ ubuntu_sso/credentials.py	2011-08-25 19:16:19 +0000
@@ -43,14 +43,12 @@
 
 from functools import wraps
 
-from oauth import oauth
 from twisted.internet.defer import inlineCallbacks, returnValue
 
-from ubuntu_sso import NO_OP
+from ubuntu_sso import NO_OP, utils
 from ubuntu_sso.keyring import Keyring
 from ubuntu_sso.logger import setup_logging
 
-
 logger = setup_logging('ubuntu_sso.credentials')
 
 
@@ -183,7 +181,7 @@
         self._success_cb = success_cb
         self._error_cb = error_cb
         self.denial_cb = denial_cb
-        self.gui = None  # will hold the GUI instance
+        self.inner = None  # will hold the GUI or SSOLoginRoot instance
 
     @handle_failures(msg='Problem while retrieving credentials')
     @inlineCallbacks
@@ -226,27 +224,28 @@
         defined if this method is being called.
 
         """
-        logger.info('Pinging server for app_name "%s", ping_url: "%s", '
-                    'email "%s".', app_name, self.ping_url, email)
-        url = self.ping_url + email
-        consumer = oauth.OAuthConsumer(credentials['consumer_key'],
-                                       credentials['consumer_secret'])
-        token = oauth.OAuthToken(credentials['token'],
-                                 credentials['token_secret'])
-        get_request = oauth.OAuthRequest.from_consumer_and_token
-        oauth_req = get_request(oauth_consumer=consumer, token=token,
-                                http_method='GET', http_url=url)
-        oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
-                               consumer, token)
-        request = urllib2.Request(url, headers=oauth_req.to_header())
-        logger.debug('Opening the url "%s" with urllib2.urlopen.',
+        logger.info('Pinging server for app_name %r, ping_url: %r, '
+                    'email %r.', app_name, self.ping_url, email)
+        try:
+            url = self.ping_url.format(email=email)
+        except IndexError:  # tuple index out of range
+            url = self.ping_url.format(email)  # format the first substitution
+
+        if url == self.ping_url:
+            logger.debug('Original url (%r) could not be formatted, '
+                         'appending email (%r).', self.ping_url, email)
+            url = self.ping_url + email
+
+        headers = utils.oauth_headers(url, credentials)
+        request = urllib2.Request(url, headers=headers)
+        logger.debug('Opening the url %r with urllib2.urlopen.',
                      request.get_full_url())
         # This code is blocking, we should change this.
         # I've tried with deferToThread an twisted.web.client.getPage
         # but the returned deferred will never be fired (nataliabidart).
         response = urllib2.urlopen(request)
         logger.debug('Url opened. Response: %s.', response.code)
-        returnValue(response.code)
+        returnValue(response)
 
     @handle_exceptions(msg='Problem opening the Ubuntu SSO user interface')
     def _show_ui(self, login_only):
@@ -255,23 +254,39 @@
         __import__(self.ui_module)
         gui = sys.modules[self.ui_module]
 
-        self.gui = getattr(gui, self.ui_class)(app_name=self.app_name,
+        self.inner = getattr(gui, self.ui_class)(app_name=self.app_name,
                         tc_url=self.tc_url, help_text=self.help_text,
                         window_id=self.window_id, login_only=login_only)
 
-        self.gui.login_success_callback = self._login_success_cb
-        self.gui.registration_success_callback = self._login_success_cb
-        self.gui.user_cancellation_callback = self._auth_denial_cb
+        self.inner.login_success_callback = self._login_success_cb
+        self.inner.registration_success_callback = self._login_success_cb
+        self.inner.user_cancellation_callback = self._auth_denial_cb
+
+    @handle_exceptions(msg='Problem logging with email and password.')
+    def _do_login(self, email, password):
+        """Login using email/password, connect outcome signals."""
+        from ubuntu_sso.main import SSOLoginRoot
+        self.inner = SSOLoginRoot()
+        self.inner.login(app_name=self.app_name, email=email,
+                         password=password,
+                         result_cb=self._login_success_cb,
+                         error_cb=self._error_cb,
+                         not_validated_cb=self._error_cb)
 
     @handle_failures(msg='Problem while retrieving credentials')
     @inlineCallbacks
-    def _login_or_register(self, login_only):
+    def _login_or_register(self, login_only, email=None, password=None):
         """Get credentials if found else prompt the GUI."""
+        logger.info("_login_or_register: login_only=%r email=%r.",
+            login_only, email)
         token = yield self.find_credentials()
         if token is not None and len(token) > 0:
             self.success_cb(token)
         elif token == {}:
-            self._show_ui(login_only)
+            if email and password:
+                self._do_login(email, password)
+            else:
+                self._show_ui(login_only)
         else:
             # something went wrong with find_credentials, already handled.
             logger.info('_login_or_register: call to "find_credentials" went '
@@ -292,7 +307,7 @@
     def find_credentials(self):
         """Get the credentials for 'self.app_name'. Return {} if not there."""
         creds = yield Keyring().get_credentials(self.app_name)
-        logger.info('find_credentials: self.app_name "%s", '
+        logger.info('find_credentials: self.app_name %r, '
                     'result is {}? %s', self.app_name, creds is None)
         returnValue(creds if creds is not None else {})
 
@@ -313,3 +328,8 @@
     def login(self):
         """Get credentials if found else prompt the GUI to login."""
         return self._login_or_register(login_only=True)
+
+    def login_email_password(self, email, password):
+        """Get credentials if found else login using email and password."""
+        return self._login_or_register(login_only=True,
+                                       email=email, password=password)
 
=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2011-01-12 18:56:56 +0000
+++ ubuntu_sso/logger.py	2011-08-25 19:16:19 +0000
@@ -25,12 +25,11 @@
 import os
 import sys
 
-import xdg.BaseDirectory
-
 from logging.handlers import RotatingFileHandler
 
+from ubuntu_sso import xdg_base_directory
 
-LOGFOLDER = os.path.join(xdg.BaseDirectory.xdg_cache_home, 'sso')
+LOGFOLDER = os.path.join(xdg_base_directory.xdg_cache_home, 'sso')
 # create log folder if it doesn't exists
 if not os.path.exists(LOGFOLDER):
     os.makedirs(LOGFOLDER)
 
=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/main/__init__.py	2011-08-25 19:16:19 +0000
@@ -75,7 +75,7 @@
         self.processor = self.sso_login_processor_class(
                                     sso_service_class=sso_service_class)
 
-    def generate_captcha(self, app_name, filename, thread_execute, result_cb,
+    def generate_captcha(self, app_name, filename, result_cb,
                          error_cb):
         """Call the matching method in the processor."""
         def f():
@@ -84,7 +84,7 @@
         thread_execute(f, app_name, result_cb, error_cb)
 
     def register_user(self, app_name, email, password, name, captcha_id,
-                      captcha_solution, thread_execute, result_cb, error_cb):
+                      captcha_solution, result_cb, error_cb):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
@@ -92,7 +92,7 @@
                                                 captcha_id, captcha_solution)
         thread_execute(f, app_name, result_cb, error_cb)
 
-    def login(self, app_name, email, password, thread_execute, result_cb,
+    def login(self, app_name, email, password, result_cb,
               error_cb, not_validated_cb):
         """Call the matching method in the processor."""
         def f():
@@ -121,7 +121,7 @@
         thread_execute(f, app_name, success_cb, error_cb)
 
     def validate_email(self, app_name, email, password, email_token,
-                       thread_execute, result_cb, error_cb):
+                       result_cb, error_cb):
         """Call the matching method in the processor."""
 
         def f():
@@ -141,7 +141,7 @@
 
         thread_execute(f, app_name, success_cb, error_cb)
 
-    def request_password_reset_token(self, app_name, email, thread_execute,
+    def request_password_reset_token(self, app_name, email,
                                      result_cb, error_cb):
         """Call the matching method in the processor."""
         def f():
@@ -150,7 +150,7 @@
         thread_execute(f, app_name, result_cb, error_cb)
 
     def set_new_password(self, app_name, email, token, new_password,
-                         thread_execute, result_cb, error_cb):
+                         result_cb, error_cb):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
@@ -160,10 +160,16 @@
 
 
 class SSOCredentialsRoot(object):
-    """Object that gets credentials, and login/registers if needed."""
+    """Object that gets credentials, and login/registers if needed.
+
+    This class is DEPRECATED, use CredentialsManagementRoot instead.
+
+    """
 
     def __init__(self):
         self.ping_url = os.environ.get('USSOC_PING_URL', U1_PING_URL)
+        msg = 'Use ubuntu_sso.main.CredentialsManagementRoot instead.'
+        warnings.warn(msg, DeprecationWarning)
 
     def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
         """Get the credentials from the keyring or {} if not there."""
@@ -399,6 +405,20 @@
         obj = Credentials(app_name, **self._parse_args(args))
         obj.login()
 
+    def login_email_password(self, app_name, args):
+        """Get credentials if found else try to login.
+
+        Login will be done by inspecting 'args' and expecting to find two keys:
+        'email' and 'password'.
+
+        """
+        self.ref_count += 1
+        email = args.pop('email')
+        password = args.pop('password')
+        obj = Credentials(app_name, **self._parse_args(args))
+        obj.login_email_password(email=email, password=password)
+
+
 # pylint: disable=C0103
 SSOLogin = None
 SSOCredentials = None
@@ -410,8 +430,10 @@
     SSOCredentials = windows.SSOCredentials
     CredentialsManagement = windows.CredentialsManagement
     TIMEOUT_INTERVAL = 10000000000  # forever
+    thread_execute = windows.blocking
 else:
     from ubuntu_sso.main import linux
     SSOLogin = linux.SSOLogin
     SSOCredentials = linux.SSOCredentials
     CredentialsManagement = linux.CredentialsManagement
+    thread_execute = linux.blocking
 
=== modified file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	2011-06-24 19:14:17 +0000
+++ ubuntu_sso/main/linux.py	2011-08-25 19:16:19 +0000
@@ -74,6 +74,8 @@
         dbus.service.Object.__init__(self, object_path=object_path,
                                      bus_name=bus_name)
         self.root = SSOLoginRoot(sso_login_processor_class, sso_service_class)
+        msg = 'Use ubuntu_sso.main.CredentialsManagement instead.'
+        warnings.warn(msg, DeprecationWarning)
 
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -92,7 +94,7 @@
                          in_signature='ss')
     def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
-        self.root.generate_captcha(app_name, filename, blocking,
+        self.root.generate_captcha(app_name, filename,
                                    self.CaptchaGenerated,
                                    self.CaptchaGenerationError)
 
@@ -115,7 +117,7 @@
                       captcha_id, captcha_solution):
         """Call the matching method in the processor."""
         self.root.register_user(app_name, email, password, name, captcha_id,
-                                captcha_solution, blocking,
+                                captcha_solution,
                                 self.UserRegistered,
                                 self.UserRegistrationError)
 
@@ -142,7 +144,7 @@
                          in_signature='sss')
     def login(self, app_name, email, password):
         """Call the matching method in the processor."""
-        self.root.login(app_name, email, password, blocking, self.LoggedIn,
+        self.root.login(app_name, email, password, self.LoggedIn,
                         self.LoginError, self.UserNotValidated)
 
     # validate_email signals
@@ -163,7 +165,7 @@
     def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
         self.root.validate_email(app_name, email, password, email_token,
-                                 blocking, self.EmailValidated,
+                                 self.EmailValidated,
                                  self.EmailValidationError)
 
     # request_password_reset_token signals
@@ -183,7 +185,7 @@
                          in_signature='ss')
     def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
-        self.root.request_password_reset_token(app_name, email, blocking,
+        self.root.request_password_reset_token(app_name, email,
                                                self.PasswordResetTokenSent,
                                                self.PasswordResetError)
 
@@ -205,7 +207,7 @@
     def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
         self.root.set_new_password(app_name, email, token, new_password,
-                                   blocking, self.PasswordChanged,
+                                   self.PasswordChanged,
                                    self.PasswordChangeError)
 
 
@@ -462,3 +464,15 @@
     def login(self, app_name, args):
         """Get credentials if found else prompt GUI to login."""
         self.root.login(app_name, args)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def login_email_password(self, app_name, args):
+        """Get credentials if found, else login using email and password.
+
+        - 'args' should contain at least the follwing keys: 'email' and
+        'password'. Those will be used to issue a new SSO token, which will be
+        returned trough the CredentialsFound signal.
+
+        """
+        self.root.login_email_password(app_name, args)
 
=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2011-06-24 19:14:17 +0000
+++ ubuntu_sso/main/tests/test_common.py	2011-08-25 19:16:19 +0000
@@ -75,7 +75,7 @@
         """Test that the call is relayed."""
         app_name = 'app'
         filename = 'file'
-        self.root.generate_captcha(app_name, filename, MATCH(callable),
+        self.root.generate_captcha(app_name, filename,
                                    MATCH(callable), MATCH(callable))
         self.mocker.replay()
         self.login.generate_captcha(app_name, filename)
@@ -89,7 +89,7 @@
         captcha_id = 'id'
         captcha_solution = 'hello'
         self.root.register_user(app_name, email, password, name, captcha_id,
-                                captcha_solution, MATCH(callable),
+                                captcha_solution,
                                 MATCH(callable), MATCH(callable))
         self.mocker.replay()
         self.login.register_user(app_name, email, password, name, captcha_id,
@@ -100,7 +100,7 @@
         app_name = 'app'
         email = 'email'
         password = 'password'
-        self.root.login(app_name, email, password, MATCH(callable),
+        self.root.login(app_name, email, password,
                         MATCH(callable), MATCH(callable),
                         MATCH(callable))
         self.mocker.mock()
@@ -114,18 +114,17 @@
         password = 'passwrd'
         email_token = 'token'
         self.root.validate_email(app_name, email, password, email_token,
-                                 MATCH(callable), MATCH(callable),
+                                 MATCH(callable),
                                  MATCH(callable))
         self.mocker.replay()
         self.login.validate_email(app_name, email, password, email_token)
 
-    def test_request_password_reset_tolen(self):
+    def test_request_password_reset_token(self):
         """Test that the call is relayed."""
         app_name = 'app'
         email = 'email'
         self.root.request_password_reset_token(app_name, email,
                                                MATCH(callable),
-                                               MATCH(callable),
                                                MATCH(callable))
         self.mocker.replay()
         self.login.request_password_reset_token(app_name, email)
@@ -137,7 +136,7 @@
         token = 'token'
         new_password = 'new'
         self.root.set_new_password(app_name, email, token, new_password,
-                                   MATCH(callable), MATCH(callable),
+                                   MATCH(callable),
                                    MATCH(callable))
         self.mocker.replay()
         self.login.set_new_password(app_name, email, token, new_password)
@@ -190,7 +189,7 @@
         self.cred.clear_token(app_name, result_cb, error_cb)
 
 
-class CredentialsManagementMockedTestCase(MockerTestCase):
+class CredentialsManagementMockedTestCase(MockerTestCase, TestCase):
     """Test that the call are relied correctly."""
 
     def setUp(self):
@@ -242,3 +241,11 @@
         self.root.login(app_name, args)
         self.mocker.replay()
         self.cred.login(app_name, args)
+
+    def test_login_email_password(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        args = 'args'
+        self.root.login_email_password(app_name, args)
+        self.mocker.replay()
+        self.cred.login_email_password(app_name, args)
 
=== modified file 'ubuntu_sso/main/tests/test_linux.py'
--- ubuntu_sso/main/tests/test_linux.py	2011-06-24 19:14:17 +0000
+++ ubuntu_sso/main/tests/test_linux.py	2011-08-25 19:16:19 +0000
@@ -144,7 +144,7 @@
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -191,7 +191,7 @@
         self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
             CAPTCHA_ID, CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -377,7 +377,7 @@
         d = Deferred()
         processor = self.create_mock_processor()
         processor.request_password_reset_token(EMAIL)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main, "thread_execute", fake_ok_blocking)
         self.mocker.result(EMAIL)
         self.mocker.replay()
 
@@ -400,7 +400,7 @@
 
         self.create_mock_processor().request_password_reset_token(EMAIL)
         self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -446,7 +446,7 @@
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
                                                       PASSWORD)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -1222,6 +1222,17 @@
         self.client.login(APP_NAME, self.args)
         self.assert_dbus_method_correct(self.client.login)
 
+    def test_login_email_password(self):
+        """The login_email_password is correct."""
+        self.create_mock_backend().login_email_password(email=EMAIL,
+                                                        password=PASSWORD)
+        self.mocker.replay()
+
+        self.args['email'] = EMAIL
+        self.args['password'] = PASSWORD
+        self.client.login_email_password(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.login_email_password)
+
 
 class CredentialsManagementParamsTestCase(CredentialsManagementOpsTestCase):
     """Tests for the CredentialsManagement extra parameters handling."""
 
=== modified file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2011-08-25 19:16:19 +0000
@@ -30,10 +30,10 @@
 )
 from ubuntu_sso.main import windows
 from ubuntu_sso.main.windows import (
-    blocking,
     signal,
     CredentialsManagement,
     CredentialsManagementClient,
+    LOCALHOST,
     SignalBroadcaster,
     SSOCredentials,
     SSOCredentialsClient,
@@ -41,7 +41,8 @@
     SSOLoginClient,
     UbuntuSSORoot,
     UbuntuSSOClient,
-    get_sso_pb_hostport)
+    get_sso_pb_port,
+)
 
 # because we are using twisted we have java like names C0103 and
 # the issues that mocker brings with it like W0104
@@ -191,10 +192,10 @@
         self.sso_root = UbuntuSSORoot(self.login, None, None)
         self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
-        host, port = get_sso_pb_hostport()
+        port = get_sso_pb_port()
         self.listener = reactor.listenTCP(port, self.server_factory)
         self.client_factory = PBClientFactory()
-        self.connector = reactor.connectTCP(host, port,
+        self.connector = reactor.connectTCP(LOCALHOST, port,
                                             self.client_factory)
         # pylint: enable=E1101
 
@@ -292,7 +293,7 @@
         @defer.inlineCallbacks
         def test_execution(client):
             """Actual test."""
-            self.root.generate_captcha(app_name, filename, blocking,
+            self.root.generate_captcha(app_name, filename,
                                    self.login.emit_captcha_generated,
                                    self.login.emit_captcha_generation_error)
             self.mocker.replay()
@@ -364,7 +365,7 @@
         def test_execution(client):
             """Actual test."""
             self.root.register_user(app_name, email, password, displayname,
-                                    captcha_id, captcha_solution, blocking,
+                                    captcha_id, captcha_solution,
                                     self.login.emit_user_registered,
                                     self.login.emit_user_registration_error)
             self.mocker.replay()
@@ -453,7 +454,7 @@
         @defer.inlineCallbacks
         def test_execution(client):
             """Actual test."""
-            self.root.login(app_name, email, password, blocking,
+            self.root.login(app_name, email, password,
                             self.login.emit_logged_in,
                             self.login.emit_login_error,
                             self.login.emit_user_not_validated)
@@ -524,7 +525,7 @@
         def test_execution(client):
             """Actual test."""
             self.root.validate_email(app_name, email, password, email_token,
-                                 blocking, self.login.emit_email_validated,
+                                 self.login.emit_email_validated,
                                  self.login.emit_email_validation_error)
             self.mocker.replay()
             yield client.validate_email(app_name, email, password, email_token)
@@ -590,7 +591,7 @@
         @defer.inlineCallbacks
         def test_execution(client):
             """Actual test."""
-            self.root.request_password_reset_token(app_name, email, blocking,
+            self.root.request_password_reset_token(app_name, email,
                                 self.login.emit_password_reset_token_sent,
                                 self.login.emit_password_reset_error)
             self.mocker.replay()
@@ -660,7 +661,7 @@
         def test_execution(client):
             """Actual test."""
             self.root.set_new_password(app_name, email, token, new_password,
-                                   blocking, self.login.emit_password_changed,
+                                   self.login.emit_password_changed,
                                    self.login.emit_password_change_error)
             self.mocker.replay()
             yield client.set_new_password(app_name, email, token, new_password)
@@ -690,10 +691,10 @@
         self.sso_root = UbuntuSSORoot(None, self.creds, None)
         self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
-        host, port = get_sso_pb_hostport()
+        port = get_sso_pb_port()
         self.listener = reactor.listenTCP(port, self.server_factory)
         self.client_factory = PBClientFactory()
-        self.connector = reactor.connectTCP(host, port,
+        self.connector = reactor.connectTCP(LOCALHOST, port,
                                             self.client_factory)
         # pylint: enable=E1101
 
@@ -945,10 +946,10 @@
         self.sso_root = UbuntuSSORoot(None, None, self.creds)
         self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
-        host, port = get_sso_pb_hostport()
+        port = get_sso_pb_port()
         self.listener = reactor.listenTCP(port, self.server_factory)
         self.client_factory = PBClientFactory()
-        self.connector = reactor.connectTCP(host, port,
+        self.connector = reactor.connectTCP(LOCALHOST, port,
                                             self.client_factory)
         # pylint: enable=E1101
 
@@ -1257,6 +1258,25 @@
         # pylint: enable=E1101
         return d
 
+    def test_login_email_password(self):
+        """Test that root is called."""
+        app_name = 'app'
+        args = 'args'
+
+        @defer.inlineCallbacks
+        def test_execution(client):
+            """Actual test."""
+            self.root.login_email_password(app_name, args)
+            self.mocker.replay()
+            yield client.login_email_password(app_name, args)
+            yield client.unregister_to_signals()
+
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
 
 class MockRemoteObject(object):
     """A mock RemoteObject."""
@@ -1330,7 +1350,6 @@
         self.assertEqual(connect_result, ussoc)
         self.assertTrue(mac.port_requested, "The port must be requested.")
         self.assertNotEqual(ussoc.sso_login, None)
-        self.assertNotEqual(ussoc.sso_cred, None)
         self.assertNotEqual(ussoc.cred_management, None)
 
     def test_get_activation_cmdline(self):
@@ -1340,3 +1359,69 @@
         self.patch(windows, "QueryValueEx", lambda key, v: (key, REG_SZ))
         cmdline = windows.get_activation_cmdline(windows.SSO_SERVICE_NAME)
         self.assertEqual(SAMPLE_VALUE, cmdline)
+
+
+class MockWin32APIs(object):
+    """Some mock win32apis."""
+
+    process_handle = object()
+    TOKEN_ALL_ACCESS = object()
+    TokenUser = object()
+
+    def __init__(self, sample_token):
+        """Initialize this mock instance."""
+        self.sample_token = sample_token
+        self.token_handle = object()
+
+    def GetCurrentProcess(self):
+        """Returns a fake process_handle."""
+        return self.process_handle
+
+    def OpenProcessToken(self, process_handle, access):
+        """Open the process token."""
+        assert process_handle is self.process_handle
+        assert access is self.TOKEN_ALL_ACCESS
+        return self.token_handle
+
+    def GetTokenInformation(self, token_handle, info):
+        """Get the information for this token."""
+        assert token_handle == self.token_handle
+        assert info == self.TokenUser
+        return (self.sample_token, 0)
+
+
+class AssortedTestCase(TestCase):
+    """Tests for functions in the windows module."""
+
+    def test_get_userid(self):
+        """The returned user id is parsed ok."""
+        expected_id = 1001
+        sample_token = "abc-123-1001"
+
+        win32apis = MockWin32APIs(sample_token)
+        self.patch(windows, "win32process", win32apis)
+        self.patch(windows, "win32security", win32apis)
+
+        userid = windows.get_user_id()
+        self.assertEqual(userid, expected_id)
+
+    def _test_port_assignation(self, uid, expected_port):
+        """Test a given uid/expected port combo."""
+        self.patch(windows, "get_user_id", lambda: uid)
+        self.assertEqual(windows.get_sso_pb_port(), expected_port)
+
+    def test_get_sso_pb_port(self):
+        """Test the get_sso_pb_port function."""
+        uid = 1001
+        uid_modulo = uid % windows.SSO_RESERVED_PORTS
+        expected_port = (windows.SSO_BASE_PB_PORT +
+                         uid_modulo * windows.SSO_PORT_ALLOCATION_STEP)
+        self._test_port_assignation(uid, expected_port)
+
+    def test_get_sso_pb_port_alt(self):
+        """Test the get_sso_pb_port function."""
+        uid = 2011 + windows.SSO_RESERVED_PORTS
+        uid_modulo = uid % windows.SSO_RESERVED_PORTS
+        expected_port = (windows.SSO_BASE_PB_PORT +
+                         uid_modulo * windows.SSO_PORT_ALLOCATION_STEP)
+        self._test_port_assignation(uid, expected_port)
 
=== modified file 'ubuntu_sso/main/windows.py'
--- ubuntu_sso/main/windows.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/main/windows.py	2011-08-25 19:16:19 +0000
@@ -17,11 +17,16 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Main implementation on windows."""
 
+import warnings
+
 # pylint: disable=F0401
 from _winreg import HKEY_LOCAL_MACHINE, OpenKey, QueryValueEx
 
 from functools import wraps
 
+import win32process
+import win32security
+
 from twisted.internet import defer, reactor
 from twisted.internet.threads import deferToThread
 from twisted.spread.pb import (
@@ -44,19 +49,54 @@
 U1_REG_PATH = r'Software\Ubuntu One'
 SSO_INSTALL_PATH = 'SSOInstallPath'
 LOCALHOST = "127.0.0.1"
-SSO_DEFAULT_PB_PORT = 50001
+SSO_BASE_PB_PORT = 50000
+SSO_RESERVED_PORTS = 3000
+SSO_PORT_ALLOCATION_STEP = 3  # contiguous ports for sso, u1client, and u1cp
 SSO_SERVICE_NAME = "ubuntu-sso-client"
 
 
-def get_sso_pb_hostport():
-    """Get the host and port on which the SSO pb is running."""
-    return LOCALHOST, SSO_DEFAULT_PB_PORT
+def get_user_id():
+    """Find the numeric user id."""
+    process_handle = win32process.GetCurrentProcess()
+    token_handle = win32security.OpenProcessToken(process_handle,
+                                              win32security.TOKEN_ALL_ACCESS)
+    user_sid = win32security.GetTokenInformation(token_handle,
+                                              win32security.TokenUser)[0]
+    sid_parts = str(user_sid).split("-")
+    uid = int(sid_parts[-1])
+    return uid
+
+
+def get_sso_pb_port():
+    """Get the port on which the SSO pb is running."""
+    uid = get_user_id()
+    uid_modulo = uid % SSO_RESERVED_PORTS
+    port = SSO_BASE_PB_PORT + uid_modulo * SSO_PORT_ALLOCATION_STEP
+    return port
 
 
 def remote_handler(handler):
-    """Execute a callback in a remote object."""
+    """Execute a callback in a remote object.
+
+    If the callback takes arguments, it's assumed that the last
+    one is a twisted Failure, and it has no keyword arguments.
+    """
     if handler:
-        return lambda: handler.callRemote('execute')
+
+        def f(*args):
+            """Process arguments and call remote."""
+            try:
+                args = list(args)
+                if args:
+                    args[-1] = except_to_errdict(args[-1].value)
+                return handler.callRemote('execute', *args)
+            # Yes, I want to catch everything
+            # pylint: disable=W0703
+            except Exception:
+                logger.exception("Remote handler argument processing error:")
+        return f
+
+    logger.warning("Remote handler got an empty handler.")
     return lambda: None
 
 
@@ -70,7 +110,7 @@
 
 def get_activation_config():
     """Get the configuration to activate the sso service."""
-    _, port = get_sso_pb_hostport()
+    port = get_sso_pb_port()
     service_name = SSO_SERVICE_NAME
     cmdline = get_activation_cmdline(service_name)
     return ActivationConfig(service_name, cmdline, port)
@@ -82,7 +122,8 @@
     # the calls in twisted will be called with the args in a diff order,
     # in order to follow the linux api, we swap them around with a lambda
     d.addCallback(lambda result, app: result_cb(app, result), app_name)
-    d.addErrback(lambda err, app: error_cb(app, err), app_name)
+    d.addErrback(lambda err, app:
+                 error_cb(app, except_to_errdict(err.value)), app_name)
 
 
 class RemoteMeta(type):
@@ -177,7 +218,7 @@
 
     def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
-        self.root.generate_captcha(app_name, filename, blocking,
+        self.root.generate_captcha(app_name, filename,
                                    self.emit_captcha_generated,
                                    self.emit_captcha_generation_error)
 
@@ -199,7 +240,7 @@
                       captcha_id, captcha_solution):
         """Call the matching method in the processor."""
         self.root.register_user(app_name, email, password, displayname,
-                                captcha_id, captcha_solution, blocking,
+                                captcha_id, captcha_solution,
                                 self.emit_user_registered,
                                 self.emit_user_registration_error)
 
@@ -225,7 +266,7 @@
 
     def login(self, app_name, email, password):
         """Call the matching method in the processor."""
-        self.root.login(app_name, email, password, blocking,
+        self.root.login(app_name, email, password,
                         self.emit_logged_in, self.emit_login_error,
                         self.emit_user_not_validated)
 
@@ -246,7 +287,7 @@
     def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
         self.root.validate_email(app_name, email, password, email_token,
-                                 blocking, self.emit_email_validated,
+                                 self.emit_email_validated,
                                  self.emit_email_validation_error)
 
     # request_password_reset_token signals
@@ -265,7 +306,7 @@
 
     def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
-        self.root.request_password_reset_token(app_name, email, blocking,
+        self.root.request_password_reset_token(app_name, email,
                                         self.emit_password_reset_token_sent,
                                         self.emit_password_reset_error)
 
@@ -286,7 +327,7 @@
     def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
         self.root.set_new_password(app_name, email, token, new_password,
-                                   blocking, self.emit_password_changed,
+                                   self.emit_password_changed,
                                    self.emit_password_change_error)
 
 
@@ -420,6 +461,7 @@
         'register',
         'shutdown',
         'login',
+        'login_email_password',
     ]
 
     def __init__(self, timeout_func, shutdown_func, *args, **kwargs):
@@ -537,6 +579,10 @@
         """Get credentials if found else prompt GUI to login."""
         self.root.login(app_name, args)
 
+    def login_email_password(self, app_name, args):
+        """Get credentials if found, else login."""
+        self.root.login_email_password(app_name, args)
+
 
 class UbuntuSSORoot(object, Root):
     """Root object that exposes the diff referenceable objects."""
@@ -571,27 +617,31 @@
 
 def remote(function):
     """Decorate the function to make the remote call."""
+
     @wraps(function)
-    def remote_wrapper(*args, **kwargs):
+    def remote_wrapper(instance, *args, **kwargs):
         """Return the deferred for the remote call."""
-        fixed_args = args[1:]
-        logger.info('Performing %s as a remote call.', function.func_name)
-        return args[0].remote.callRemote(function.func_name, *fixed_args,
-                                         **kwargs)
+        fname = function.__name__
+        logger.info('Performing %s as a remote call.', fname)
+        result = instance.remote.callRemote(fname, *args, **kwargs)
+        return result
+
     return remote_wrapper
 
 
 def signal(function):
     """Decorate a function to perform the signal callback."""
+
     @wraps(function)
-    def callback_wrapper(*args, **kwargs):
+    def callback_wrapper(instance, *args, **kwargs):
         """Return the result of the callback if present."""
-        callback = getattr(args[0], function.func_name + '_cb', None)
+        fname = function.__name__
+        callback = getattr(instance, fname + '_cb', None)
         if callback is not None:
-            fixed_args = args[1:]
-            if not kwargs:
-                return callback(*fixed_args)
-            return callback(*fixed_args, **kwargs)
+            logger.info('Emitting remote signal for %s with callback %r.',
+                        fname, callback)
+            return callback(*args, **kwargs)
+
     return callback_wrapper
 
 
@@ -618,10 +668,10 @@
         """Create a new instance."""
         self.cb = cb
 
-    def remote_execute(self):
+    def remote_execute(self, *args, **kwargs):
         """Execute the callback."""
         if self.cb:
-            self.cb()
+            self.cb(*args, **kwargs)
 
 
 def callbacks(callbacks_indexes=None, callbacks_names=None):
@@ -755,7 +805,10 @@
 
 
 class SSOCredentialsClient(RemoteClient, Referenceable):
-    """Client that can perform calls to the remote SSOCredentials object."""
+    """Deprecated client for the remote SSOCredentials object.
+
+    This class is deprecated!
+    """
 
     __metaclass__ = RemoteMeta
 
@@ -768,6 +821,8 @@
 
     def __init__(self, remote_login):
         """Create a client for the cred API."""
+        warnings.warn("SSOCredentialsClient is deprecated.",
+            DeprecationWarning)
         super(SSOCredentialsClient, self).__init__(remote_login)
 
     @signal
@@ -913,6 +968,10 @@
     def login(self, app_name, args):
         """Get credentials if found else prompt GUI to login."""
 
+    @remote
+    def login_email_password(self, app_name, args):
+        """Get credentials if found else login."""
+
 
 class UbuntuSSOClientException(Exception):
     """Raised when there are issues connecting to the process."""
@@ -923,7 +982,6 @@
 
     def __init__(self):
         self.sso_login = None
-        self.sso_cred = None
         self.cred_management = None
         self.factory = None
         self.client = None
@@ -934,8 +992,6 @@
         sso_login = yield root.callRemote('get_sso_login')
         logger.debug('SSOLogin is %s', sso_login)
         self.sso_login = SSOLoginClient(sso_login)
-        sso_cred = yield root.callRemote('get_sso_credentials')
-        self.sso_cred = SSOCredentialsClient(sso_cred)
         cred_management = yield root.callRemote('get_cred_manager')
         self.cred_management = CredentialsManagementClient(cred_management)
         defer.returnValue(self)
 
=== modified file 'ubuntu_sso/networkstate/windows.py'
--- ubuntu_sso/networkstate/windows.py	2011-03-22 23:29:20 +0000
+++ ubuntu_sso/networkstate/windows.py	2011-08-25 19:16:19 +0000
@@ -102,9 +102,9 @@
 
     def __init__(self, connected_cb=None, connected_cb_info=None,
                  disconnected_cb=None):
-        # pylint: disable=E1101
+        # pylint: disable=E1101,E1120,W0231
         self._wrap_(self)
-        # pylint: enable=E1101
+        # pylint: enable=E1101,E1120
         self.connected_cb = connected_cb
         self.connected_cb_info = connected_cb_info
         self.disconnected_cb = disconnected_cb
@@ -131,6 +131,7 @@
         """Register to listen to network events."""
         # call the CoInitialize to allow the registration to run in another
         # thread
+        # pylint: disable=E1101
         pythoncom.CoInitialize()
         # interface to be used by com
         manager_interface = pythoncom.WrapObject(self)
@@ -157,6 +158,7 @@
                     'Error registering %s to event %s', e, current_event[1])
 
         pythoncom.PumpMessages()
+        # pylint: enable=E1101
 
 
 def is_machine_connected():
 
=== modified file 'ubuntu_sso/qt/controllers.py'
--- ubuntu_sso/qt/controllers.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/qt/controllers.py	2011-08-25 19:16:19 +0000
@@ -20,10 +20,12 @@
 import StringIO
 import tempfile
 
+# pylint: disable=F0401
 try:
     from PIL import Image
 except ImportError:
     import Image
+# pylint: enable=F0401
 
 from PyQt4.QtGui import QMessageBox, QWizard, QPixmap
 from PyQt4.QtCore import QUrl
@@ -34,6 +36,7 @@
 from ubuntu_sso.utils.ui import (
     CAPTCHA_LOAD_ERROR,
     CAPTCHA_SOLUTION_ENTRY,
+    CAPTCHA_REQUIRED_ERROR,
     EMAIL1_ENTRY,
     EMAIL2_ENTRY,
     EMAIL_LABEL,
@@ -76,14 +79,38 @@
 # disabled warnings about TODO comments
 
 
+# Based on the gtk implementation, but added error_message
+# support, and rewritten.
+def _build_general_error_message(errordict):
+    """Concatenate __all__ and message from the errordict."""
+    result = None
+    msg1 = errordict.get('__all__')
+    msg2 = errordict.get('message')
+    if msg2 is None:
+        # See the errordict in LP: 828417
+        msg2 = errordict.get('error_message')
+    if msg1 is not None and msg2 is not None:
+        result = '\n'.join((msg1, msg2))
+    elif msg1 is not None:
+        result = msg1
+    elif msg2 is not None:
+        result = msg2
+    else:
+        # I give up.
+        result = "Error: %r" % errordict
+    return result
+
+
 class BackendController(object):
     """Represent a controller that talks with the sso self.backend."""
 
-    def __init__(self):
+    def __init__(self, title='', subtitle=''):
         """Create a new instance."""
         self.root = None
         self.view = None
         self.backend = None
+        self._title = title
+        self._subtitle = subtitle
 
     def __del__(self):
         """Clean the resources."""
@@ -105,22 +132,30 @@
         yield self.backend.register_to_signals()
         returnValue(self.backend)
 
-
-class ChooseSignInController(object):
+    #pylint: disable=C0103
+    def pageInitialized(self):
+        """Call to prepare the page just before it is shown."""
+        pass
+    #pylint: enable=C0103
+
+
+class ChooseSignInController(BackendController):
     """Controlled to the ChooseSignIn view/widget."""
 
-    def __init__(self, title=''):
+    def __init__(self, title='', subtitle=''):
         """Create a new instance to manage the view."""
+        super(ChooseSignInController, self).__init__(title, subtitle)
         self.view = None
-        self._title = title
 
     # use an ugly name just so have a simlar api as found in PyQt
     #pylint: disable=C0103
+
     def setupUi(self, view):
         """Perform the required actions to set up the ui."""
         self.view = view
-        self.view.setTitle(self._title)
         self._set_up_translated_strings()
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
         self._connect_buttons()
     #pylint: enable=C0103
 
@@ -157,12 +192,10 @@
 
     def __init__(self, backend=None, title='', subtitle='', message_box=None):
         """Create a new instance."""
-        super(CurrentUserController, self).__init__()
+        super(CurrentUserController, self).__init__(title, subtitle)
         if message_box is None:
             message_box = QMessageBox
         self.message_box = message_box
-        self._title = title
-        self._subtitle = subtitle
 
     def _set_translated_strings(self):
         """Set the translated strings."""
@@ -185,13 +218,24 @@
         self.backend.on_logged_in_cb = self.on_logged_in
         self.view.ui.forgot_password_label.linkActivated.connect(
                                                     self.on_forgotten_password)
+        self.view.ui.email_edit.textChanged.connect(self._validate)
+        self.view.ui.password_edit.textChanged.connect(self._validate)
+
+    def _validate(self):
+        """Perform input validation."""
+        valid = True
+        if not is_correct_email(unicode(self.view.ui.email_edit.text())):
+            valid = False
+        elif not unicode(self.view.ui.password_edit.text()):
+            valid = False
+        self.view.ui.sign_in_button.setEnabled(valid)
 
     def login(self):
         """Perform the login using the self.backend."""
         logger.debug('CurrentUserController.login')
         # grab the data from the view and call the backend
-        email = str(self.view.ui.email_edit.text())
-        password = str(self.view.ui.password_edit.text())
+        email = unicode(self.view.ui.email_edit.text())
+        password = unicode(self.view.ui.password_edit.text())
         d = self.backend.login(self.view.wizard().app_name, email, password)
         d.addErrback(self.on_login_error)
 
@@ -200,13 +244,12 @@
         # let the user know
         logger.error('Got error when login %s, error: %s',
                      self.view.wizard().app_name, error)
-        self.message_box.critical(self.view, self.view.wizard().app_name,
-                                  error['message'])
+        self.message_box.critical(_build_general_error_message(error))
 
     def on_logged_in(self, app_name, result):
         """We managed to log in."""
         logger.info('Logged in for %s', app_name)
-        email = str(self.view.ui.email_edit.text())
+        email = unicode(self.view.ui.email_edit.text())
         self.view.wizard().loginSuccess.emit(app_name, email)
         logger.debug('Wizard.loginSuccess emitted.')
 
@@ -223,9 +266,8 @@
         """Setup the view."""
         self.view = view
         self.backend = yield self.get_backend()
-        self.view.setTitle(self._title)
-        if self._subtitle:
-            self.view.setSubTitle(self._subtitle)
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
         self._set_translated_strings()
         self._connect_ui()
     #pylint: enable=C0103
@@ -234,9 +276,9 @@
 class SetUpAccountController(BackendController):
     """Conroller for the setup account view."""
 
-    def __init__(self,  message_box=None):
+    def __init__(self, message_box=None, title='', subtitle=''):
         """Create a new instance."""
-        super(SetUpAccountController, self).__init__()
+        super(SetUpAccountController, self).__init__(title, subtitle)
         if message_box is None:
             message_box = QMessageBox
         self.message_box = message_box
@@ -285,8 +327,6 @@
         logger.debug('SetUpAccountController._connect_ui_elements')
         self.view.ui.terms_button.clicked.connect(self.set_next_tos)
         self.view.ui.set_up_button.clicked.connect(self.set_next_validation)
-        self.view.ui.terms_checkbox.stateChanged.connect(
-                                        self.view.ui.set_up_button.setEnabled)
         self.view.ui.refresh_label.linkActivated.connect(lambda url: \
                                           self._refresh_captcha())
         # set the callbacks for the captcha generation
@@ -296,6 +336,38 @@
         self.backend.on_user_registered_cb = self.on_user_registered
         self.backend.on_user_registration_error_cb = \
                                             self.on_user_registration_error
+        # We need to check if we enable the button on many signals
+        self.view.ui.name_edit.textEdited.connect(self._enable_setup_button)
+        self.view.ui.email_edit.textEdited.connect(self._enable_setup_button)
+        self.view.ui.confirm_email_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.view.ui.password_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.view.ui.confirm_password_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.view.ui.captcha_solution_edit.textEdited.connect(
+            self._enable_setup_button)
+        self.view.ui.terms_checkbox.stateChanged.connect(
+            self._enable_setup_button)
+
+    def _enable_setup_button(self):
+        """Only enable the setup button if the form is valid."""
+        email = unicode(self.view.ui.email_edit.text())
+        confirm_email = unicode(self.view.ui.confirm_email_edit.text())
+        password = unicode(self.view.ui.password_edit.text())
+        confirm_password = unicode(self.view.ui.confirm_password_edit.text())
+        captcha_solution = unicode(self.view.ui.captcha_solution_edit.text())
+
+        enabled = self.view.ui.terms_checkbox.isChecked() and \
+          captcha_solution and is_min_required_password(password) and \
+          password == confirm_password and is_correct_email(email) and \
+          email == confirm_email
+
+        self.view.ui.set_up_button.setEnabled(enabled)
+        self.view.ui.set_up_button.setProperty("DisabledState",
+            not self.view.ui.set_up_button.isEnabled())
+        self.view.ui.set_up_button.style().unpolish(self.view.ui.set_up_button)
+        self.view.ui.set_up_button.style().polish(self.view.ui.set_up_button)
 
     def _refresh_captcha(self):
         """Refresh the captcha image shown in the ui."""
@@ -316,9 +388,9 @@
     def _set_titles(self):
         """Set the diff titles of the view."""
         logger.debug('SetUpAccountController._set_titles')
-        wizard = self.view.wizard()
-        self.view.setTitle(JOIN_HEADER_LABEL % {'app_name': wizard.app_name})
-        self.view.setSubTitle(wizard.help_text)
+        self.view.header.set_title(
+            JOIN_HEADER_LABEL % {'app_name': self.view.wizard().app_name})
+        self.view.header.set_subtitle(self.view.wizard().help_text)
 
     def _register_fields(self):
         """Register the diff fields of the Ui."""
@@ -348,19 +420,14 @@
     def on_captcha_generation_error(self, error):
         """An error ocurred."""
         logger.debug('SetUpAccountController.on_captcha_generation_error')
-        self.message_box.critical(self.view, self.view.wizard().app_name,
-            CAPTCHA_LOAD_ERROR)
+        self.message_box.critical(CAPTCHA_LOAD_ERROR)
 
     def on_user_registration_error(self, app_name, error):
         """Let the user know we could not register."""
         logger.debug('SetUpAccountController.on_user_registration_error')
         # errors are returned as a dict with the data we want to show.
         self._refresh_captcha()
-        errors = [v for _, v in sorted(error.iteritems())]
-        self.message_box.critical(
-            self.view,
-            self.view.wizard().app_name,
-            '\n'.join(errors))
+        self.message_box.critical(_build_general_error_message(error))
 
     def on_user_registered(self, app_name, result):
         """Execute when the user did register."""
@@ -377,35 +444,35 @@
     def validate_form(self):
         """Validate the info of the form and return an error."""
         logger.debug('SetUpAccountController.validate_form')
-        email = str(self.view.ui.email_edit.text())
-        confirm_email = str(self.view.ui.confirm_email_edit.text())
-        password = str(self.view.ui.password_edit.text())
-        confirm_password = str(self.view.ui.confirm_password_edit.text())
+        email = unicode(self.view.ui.email_edit.text())
+        confirm_email = unicode(self.view.ui.confirm_email_edit.text())
+        password = unicode(self.view.ui.password_edit.text())
+        confirm_password = unicode(self.view.ui.confirm_password_edit.text())
+        captcha_solution = unicode(self.view.ui.captcha_solution_edit.text())
         if not is_correct_email(email):
-            self.message_box.critical(self.view, self.view.wizard().app_name,
-                                      EMAIL_INVALID)
+            self.message_box.critical(EMAIL_INVALID)
         if email != confirm_email:
-            self.message_box.critical(self.view, self.view.wizard().app_name,
-                                      EMAIL_MISMATCH)
+            self.message_box.critical(EMAIL_MISMATCH)
             return False
         if not is_min_required_password(password):
-            self.message_box.critical(self.view, self.view.wizard().app_name,
-                                      PASSWORD_TOO_WEAK)
+            self.message_box.critical(PASSWORD_TOO_WEAK)
             return False
         if password != confirm_password:
-            self.message_box.critical(self.view, self.view.wizard().app_name,
-                                      PASSWORD_MISMATCH)
+            self.message_box.critical(PASSWORD_MISMATCH)
+            return False
+        if not captcha_solution:
+            self.message_box.critical(CAPTCHA_REQUIRED_ERROR)
             return False
         return True
 
     def set_next_validation(self):
         """Set the validation as the next page."""
         logger.debug('SetUpAccountController.set_next_validation')
-        email = str(self.view.ui.email_edit.text())
-        password = str(self.view.ui.password_edit.text())
-        name = str(self.view.ui.name_edit.text())
+        email = unicode(self.view.ui.email_edit.text())
+        password = unicode(self.view.ui.password_edit.text())
+        name = unicode(self.view.ui.name_edit.text())
         captcha_id = self.view.captcha_id
-        captcha_solution = str(self.view.ui.captcha_solution_edit.text())
+        captcha_solution = unicode(self.view.ui.captcha_solution_edit.text())
         # validate the current info of the form, try to perform the action
         # to register the user, and then move foward
         if self.validate_form():
@@ -424,12 +491,12 @@
     def is_correct_email_confirmation(self, email_address):
         """Return that the email is the same."""
         logger.debug('SetUpAccountController.is_correct_email_confirmation')
-        return self.view.ui.email_edit.text() == email_address
+        return unicode(self.view.ui.email_edit.text()) == email_address
 
     def is_correct_password_confirmation(self, password):
         """Return that the passwords are correct."""
         logger.debug('SetUpAccountController.is_correct_password_confirmation')
-        return self.view.ui.password_edit.text() == password
+        return unicode(self.view.ui.password_edit.text()) == password
 
     #pylint: disable=C0103
     @inlineCallbacks
@@ -441,28 +508,29 @@
         self._connect_ui_elements()
         self._refresh_captcha()
         self._set_titles()
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
         self._set_translated_strings()
         self._set_line_edits_validations()
         self._register_fields()
     #pylint: enable=C0103
 
 
-class TosController(object):
+class TosController(BackendController):
     """Controller used for the tos page."""
 
     def __init__(self, title='', subtitle='', tos_url=''):
         """Create a new instance."""
+        super(TosController, self).__init__(title, subtitle)
         self.view = None
-        self._title = title
-        self._subtitle = subtitle
         self._tos_url = tos_url
 
     #pylint: disable=C0103
     def setupUi(self, view):
         """Set up the ui."""
         self.view = view
-        self.view.setTitle(self._title)
-        self.view.setSubTitle(self._subtitle)
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
         # load the tos page
         self.view.ui.terms_webkit.load(QUrl(self._tos_url))
         self.view.ui.tos_link_label.setText(
@@ -474,6 +542,13 @@
 class EmailVerificationController(BackendController):
     """Controller used for the verification page."""
 
+    def __init__(self, message_box=None, title='', subtitle=''):
+        """Create a new instance."""
+        super(EmailVerificationController, self).__init__(title, subtitle)
+        if message_box is None:
+            message_box = QMessageBox
+        self.message_box = message_box
+
     def _set_translated_strings(self):
         """Set the trnaslated strings."""
         logger.debug('EmailVerificationController._set_translated_strings')
@@ -492,11 +567,11 @@
     def _set_titles(self):
         """Set the different titles."""
         logger.debug('EmailVerificationController._set_titles')
-        self.view.setTitle(VERIFY_EMAIL_TITLE)
-        self.view.setSubTitle(VERIFY_EMAIL_CONTENT % {
+        self.view.header.set_title(VERIFY_EMAIL_TITLE)
+        self.view.header.set_subtitle(VERIFY_EMAIL_CONTENT % {
             "app_name": self.view.wizard().app_name,
             "email": self.view.wizard().field("email_address").toString(),
-            })
+        })
 
     def set_titles(self):
         """This class needs to have a public set_titles.
@@ -520,9 +595,9 @@
     def validate_email(self):
         """Call the next action."""
         logger.debug('EmailVerificationController.validate_email')
-        email = str(self.view.wizard().field('email_address').toString())
-        password = str(self.view.wizard().field('password').toString())
-        code = str(self.view.ui.verification_code_edit.text())
+        email = unicode(self.view.wizard().field('email_address').toString())
+        password = unicode(self.view.wizard().field('password').toString())
+        code = unicode(self.view.ui.verification_code_edit.text())
         self.backend.validate_email(self.view.wizard().app_name, email,
                                     password, code)
 
@@ -532,16 +607,30 @@
         email = self.view.wizard().field('email_address').toString()
         self.view.wizard().registrationSuccess.emit(app_name, email)
 
-    def on_email_validation_error(self, app_name, raised_error):
+    def on_email_validation_error(self, app_name, error):
         """Signal thrown when there's a problem validating the email."""
-
-
-class ErrorController(object):
+        msg = error.get('email_token')
+        if msg is None:
+            msg = _build_general_error_message(error)
+        self.message_box.critical(msg)
+
+    #pylint: disable=C0103
+    def pageInitialized(self):
+        """Called to prepare the page just before it is shown."""
+        self.view.next_button.setDefault(True)
+        self.view.next_button.style().unpolish(
+            self.view.next_button)
+        self.view.next_button.style().polish(
+            self.view.next_button)
+    #pylint: enable=C0103
+
+
+class ErrorController(BackendController):
     """Controller used for the error page."""
 
-    def __init__(self):
+    def __init__(self, title='', subtitle=''):
         """Create a new instance."""
-        super(ErrorController, self).__init__()
+        super(ErrorController, self).__init__(title, subtitle)
         self.view = None
 
     #pylint: disable=C0103
@@ -550,15 +639,21 @@
         self.view = view
         self.view.next = -1
         self.view.ui.error_message_label.setText(ERROR)
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
     #pylint: enable=C0103
 
 
 class ForgottenPasswordController(BackendController):
     """Controller used to deal with the forgotten pwd page."""
 
-    def __init__(self):
+    def __init__(self, message_box=None, title='', subtitle=''):
         """Create a new instance."""
         super(ForgottenPasswordController, self).__init__()
+        if message_box is None:
+            message_box = QMessageBox
+        self.message_box = message_box
+        super(ForgottenPasswordController, self).__init__(title, subtitle)
 
     def _register_fields(self):
         """Register the fields of the wizard page."""
@@ -582,6 +677,7 @@
 
     def _connect_ui(self):
         """Connect the diff signals from the Ui."""
+        self.view.email_address_line_edit.textChanged.connect(self._validate)
         self.view.send_button.clicked.connect(
                             lambda: self.backend.request_password_reset_token(
                                                 self.view.wizard().app_name,
@@ -592,6 +688,11 @@
                                     self.on_password_reset_token_sent()
         self.backend.on_password_reset_error_cb = self.on_password_reset_error
 
+    def _validate(self):
+        """Validate that we have an email."""
+        email = unicode(self.view.email_address_line_edit.text())
+        self.view.send_button.setEnabled(is_correct_email(email))
+
     def on_try_again(self):
         """Set back the widget to the initial state."""
         self.view.error_label.setVisible(False)
@@ -632,15 +733,20 @@
         self._connect_ui()
         self._set_enhanced_line_edit()
         self._register_fields()
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
     #pylint: enable=C0103
 
 
 class ResetPasswordController(BackendController):
     """Controller used to deal with reseintg the password."""
 
-    def __init__(self):
+    def __init__(self, title='', subtitle='', message_box=None):
         """Create a new instance."""
-        super(ResetPasswordController, self).__init__()
+        if message_box is None:
+            message_box = QMessageBox
+        self.message_box = message_box
+        super(ResetPasswordController, self).__init__(title, subtitle)
 
     def _set_translated_strings(self):
         """Translate the diff strings used in the app."""
@@ -658,6 +764,25 @@
         self.backend.on_password_changed_cb = self.on_password_changed
         self.backend.on_password_change_error_cb = \
                                                 self.on_password_change_error
+        self.view.ui.reset_code_line_edit.textChanged.connect(self._validate)
+        self.view.ui.password_line_edit.textChanged.connect(self._validate)
+        self.view.ui.confirm_password_line_edit.textChanged.connect(
+            self._validate)
+
+    def _validate(self):
+        """Enable the submit button if data is valid."""
+        enabled = True
+        code = unicode(self.view.ui.reset_code_line_edit.text())
+        password = unicode(self.view.ui.password_line_edit.text())
+        confirm_password = unicode(
+            self.view.ui.confirm_password_line_edit.text())
+        if not is_min_required_password(password):
+            enabled = False
+        elif not self.is_correct_password_confirmation(confirm_password):
+            enabled = False
+        elif not code:
+            enabled = False
+        self.view.ui.reset_password_button.setEnabled(enabled)
 
     def _add_line_edits_validations(self):
         """Add the validations to be use by the line edits."""
@@ -676,20 +801,23 @@
 
     def on_password_change_error(self, app_name, error):
         """Let the user know that there was an error."""
+        logger.error('Got error changing password for %s, error: %s',
+                     self.view.wizard().app_name, error)
+        self.message_box.critical(_build_general_error_message(error))
 
     def set_new_password(self):
         """Request a new password to be set."""
         app_name = self.view.wizard().app_name
-        email = str(self.view.wizard().field('email_address').toString())
-        code = str(self.view.ui.reset_code_line_edit.text())
-        password = str(self.view.ui.password_line_edit.text())
+        email = unicode(self.view.wizard().field('email_address').toString())
+        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',
                     app_name, email, code)
         self.backend.set_new_password(app_name, email, code, password)
 
     def is_correct_password_confirmation(self, password):
         """Return if the password is correct."""
-        return self.view.ui.password_line_edit.text() == password
+        return unicode(self.view.ui.password_line_edit.text()) == password
 
     #pylint: disable=C0103
     @inlineCallbacks
@@ -700,14 +828,17 @@
         self._set_translated_strings()
         self._connect_ui()
         self._add_line_edits_validations()
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
     #pylint: enable=C0103
 
 
-class SuccessController(object):
+class SuccessController(BackendController):
     """Controller used for the success page."""
 
-    def __init__(self):
+    def __init__(self, title='', subtitle=''):
         """Create a new instance."""
+        super(SuccessController, self).__init__(title, subtitle)
         self.view = None
 
     #pylint: disable=C0103
@@ -716,6 +847,8 @@
         self.view = view
         self.view.next = -1
         self.view.ui.success_message_label.setText(SUCCESS)
+        self.view.header.set_title(self._title)
+        self.view.header.set_subtitle(self._subtitle)
     #pylint: enable=C0103
 
 
@@ -741,7 +874,8 @@
     def on_login_success(self, app_name, email):
         """Process the success of a login."""
         logger.debug('UbuntuSSOWizardController.on_login_success')
-        result = yield self.login_success_callback(str(app_name), str(email))
+        result = yield self.login_success_callback(
+            unicode(app_name), unicode(email))
         logger.debug('Result from callback is %s', result)
         if result == 0:
             logger.info('Success in calling the given success_callback')
@@ -754,8 +888,8 @@
     def on_registration_success(self, app_name, email):
         """Process the success of a registration."""
         logger.debug('UbuntuSSOWizardController.on_registration_success')
-        result = yield self.registration_success_callback(str(app_name),
-                                                          str(email))
+        result = yield self.registration_success_callback(unicode(app_name),
+                                                          unicode(email))
         # TODO: what to do?
         logger.debug('Result from callback is %s', result)
         if result == 0:
 
=== modified file 'ubuntu_sso/qt/gui.py'
--- ubuntu_sso/qt/gui.py	2011-06-24 19:14:17 +0000
+++ ubuntu_sso/qt/gui.py	2011-08-25 19:16:19 +0000
@@ -17,15 +17,18 @@
 """Qt implementation of the UI."""
 
 from PyQt4.QtCore import pyqtSignal
+from PyQt4.QtCore import Qt
 from PyQt4.QtGui import (
     QApplication,
+    QWidget,
     QCursor,
     QHBoxLayout,
+    QVBoxLayout,
     QPixmap,
-    QPushButton,
     QStyle,
     QWizard,
-    QWizardPage)
+    QWizardPage,
+    QLabel)
 
 from ubuntu_sso.logger import setup_logging
 # pylint: disable=F0401,E0611
@@ -55,6 +58,40 @@
 logger = setup_logging('ubuntu_sso.gui')
 
 
+class Header(QWidget):
+    """Header Class for Title and Subtitle in all wizard pages."""
+
+    def __init__(self):
+        """Create a new instance."""
+        QWidget.__init__(self)
+        vbox = QVBoxLayout(self)
+        self.title_label = QLabel()
+        self.title_label.setWordWrap(True)
+        self.title_label.setObjectName('title_label')
+        self.subtitle_label = QLabel()
+        self.subtitle_label.setWordWrap(True)
+        vbox.addWidget(self.title_label)
+        vbox.addWidget(self.subtitle_label)
+        self.title_label.setVisible(False)
+        self.subtitle_label.setVisible(False)
+
+    def set_title(self, title):
+        """Set the Title of the page or hide it otherwise"""
+        if title:
+            self.title_label.setText(title)
+            self.title_label.setVisible(True)
+        else:
+            self.title_label.setVisible(False)
+
+    def set_subtitle(self, subtitle):
+        """Set the Subtitle of the page or hide it otherwise"""
+        if subtitle:
+            self.subtitle_label.setText(subtitle)
+            self.subtitle_label.setVisible(True)
+        else:
+            self.subtitle_label.setVisible(False)
+
+
 class SSOWizardPage(QWizardPage):
     """Root class for all wizard pages."""
 
@@ -63,8 +100,11 @@
         QWizardPage.__init__(self, parent)
         self.ui = ui
         self.ui.setupUi(self)
-        self.controller = controller
-        self.controller.setupUi(self)
+        self.header = Header()
+        self.layout().insertWidget(0, self.header)
+        if controller:
+            self.controller = controller
+            self.controller.setupUi(self)
         self.next = -1
 
     # pylint: disable=C0103
@@ -73,6 +113,25 @@
         return self.next
     # pylint: enable=C0103
 
+    # pylint: disable=C0103
+    def initializePage(self):
+        """Called to prepare the page just before it is shown."""
+        if self.controller:
+            self.controller.pageInitialized()
+    # pylint: enable=C0103
+
+    # pylint: disable=C0103
+    def setTitle(self, title=''):
+        """Set the Wizard Page Title."""
+        self.header.set_title(title)
+    # pylint: enable=C0103
+
+    # pylint: disable=C0103
+    def setSubTitle(self, subtitle=''):
+        """Set the Wizard Page Subtitle."""
+        self.header.set_subtitle(subtitle)
+    # pylint: enable=C0103
+
 
 class EnhancedLineEdit(object):
     """Represents and enhanced lineedit.
@@ -81,7 +140,8 @@
     that we are just adding extra items to it.
     """
 
-    def __init__(self, line_edit, valid_cb=lambda x: False):
+    def __init__(self, line_edit, valid_cb=lambda x: False,
+                 warning_sign=False):
         """Create an instance."""
         self._line_edit = line_edit
         layout = QHBoxLayout(self._line_edit)
@@ -89,24 +149,27 @@
         self._line_edit.setLayout(layout)
         self.valid_cb = valid_cb
         layout.addStretch()
-        self.clear_button = QPushButton(self._line_edit)
-        layout.addWidget(self.clear_button)
-        self.clear_button.setMinimumSize(16, 16)
-        self.clear_button.setVisible(False)
-        self.clear_button.setFlat(True)
-        self.clear_button.setCursor(QCursor(0))
-        self.clear_button.setIcon(QApplication.style().standardIcon(
-                                                QStyle.SP_MessageBoxWarning))
+        self.clear_label = QLabel(self._line_edit)
+        self.clear_label.setMargin(2)
+        self.clear_label.setProperty("lineEditWarning", True)
+        layout.addWidget(self.clear_label)
+        self.clear_label.setMinimumSize(16, 16)
+        self.clear_label.setVisible(False)
+        self.clear_label.setCursor(QCursor(Qt.ArrowCursor))
+        if warning_sign:
+            icon = QApplication.style().standardIcon(
+                QStyle.SP_MessageBoxWarning)
+            self.clear_label.setPixmap(icon.pixmap(16, 16))
         # connect the change of text to the cation that will check if the
         # text is valid and if the icon should be shown.
         self._line_edit.textChanged.connect(self.show_button)
 
     def show_button(self, string):
         """Decide if we show the button or not."""
-        if not self.valid_cb(string):
-            self.clear_button.setVisible(True)
+        if not self.valid_cb(string) and self.clear_label.pixmap() is not None:
+            self.clear_label.setVisible(True)
         else:
-            self.clear_button.setVisible(False)
+            self.clear_label.setVisible(False)
 
 
 class SSOWizardEnhancedEditPage(SSOWizardPage):
 
=== added file 'ubuntu_sso/qt/tests/login_u_p.py'
--- ubuntu_sso/qt/tests/login_u_p.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/tests/login_u_p.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Author: Manuel de la Pena <[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/>.
+"""Script that shows the qt gui."""
+
+# pylint: disable=F0401, E1101
+from twisted.internet import reactor
+from twisted.internet.defer import inlineCallbacks
+from ubuntu_sso.main.windows import UbuntuSSOClient
+
+
+def found(*args):
+    """The credentials were found."""
+    print "creds found", args
+    reactor.stop()
+
+
+def errback(*args):
+    """Unsuccessful login."""
+    print "EB:", args
+
+
+@inlineCallbacks
+def main():
+    """Perform a client request to be logged in."""
+    client = UbuntuSSOClient()
+    client = yield client.connect()
+    yield client.cred_management.register_to_signals()
+    client.cred_management.on_credentials_found_cb = found
+    client.cred_management.on_credentials_error_cb = errback
+    yield client.cred_management.login_email_password('SUPER', dict(
+          app_name='SUPER',
+          email='[e-mail]',
+          password='ABC',
+    ))
+    print "called ok"
+
+
+if __name__ == '__main__':
+    main()
+    reactor.run()
 
=== modified file 'ubuntu_sso/qt/tests/show_gui.py'
--- ubuntu_sso/qt/tests/show_gui.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/qt/tests/show_gui.py	2011-08-25 19:16:19 +0000
@@ -20,6 +20,12 @@
 from twisted.internet import reactor
 from twisted.internet.defer import inlineCallbacks
 from ubuntu_sso.main.windows import UbuntuSSOClient
+from ubuntu_sso.credentials import (
+     TC_URL_KEY,
+     HELP_TEXT_KEY,
+     WINDOW_ID_KEY,
+     UI_MODULE_KEY,
+)
 
 
 def found(*args):
@@ -33,11 +39,16 @@
     """Perform a client request to be logged in."""
     client = UbuntuSSOClient()
     client = yield client.connect()
-    client.sso_cred.on_credentials_found_cb = found
-    yield client.sso_cred.register_to_signals()
-    yield client.sso_cred.login_or_register_to_get_credentials('Ubuntu One',
-                                                    'http://www.google.com',
-                                                    'This is a test.', 0)
+    client.cred_management.on_credentials_found_cb = found
+    yield client.cred_management.register_to_signals()
+    yield client.cred_management.login(
+        'Ubuntu One',
+        {
+            TC_URL_KEY: 'http://www.google.com',
+            HELP_TEXT_KEY: 'This is a test.',
+            WINDOW_ID_KEY: 0,
+            UI_MODULE_KEY: 'ubuntu_sso.qt.gui',
+        })
     print "called ok"
 
 
 
=== added file 'ubuntu_sso/qt/tests/test_enchanced_line_edit.py'
--- ubuntu_sso/qt/tests/test_enchanced_line_edit.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/tests/test_enchanced_line_edit.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# Author: Diego Sarmentero <[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/>.
+"""Test the EnhancedLineEdit."""
+
+import collections
+
+from twisted.trial.unittest import TestCase
+
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
+from ubuntu_sso.qt.gui import EnhancedLineEdit
+
+
+class EnhancedLineEditTestCase(TestCase):
+    """Tests EnhancedLineEdit for valid and invalid states."""
+
+    def get_pixmap_data(self, pixmap):
+        """Get the raw data of a QPixmap."""
+        byte_array = QtCore.QByteArray()
+        array_buffer = QtCore.QBuffer(byte_array)
+        pixmap.save(array_buffer, "PNG")
+        return byte_array
+
+    # pylint: disable=C0103
+    def assertEqualPixmaps(self, pixmap1, pixmap2):
+        """Compare two Qt pixmaps."""
+        d1 = self.get_pixmap_data(pixmap1)
+        d2 = self.get_pixmap_data(pixmap2)
+        self.assertEqual(d1, d2)
+    # pylint: enable=C0103
+
+    def test_enhanced_line_edit_init(self):
+        """Tests the initial state of the enchanced line edit."""
+        line_edit = QtGui.QLineEdit()
+        line_edit.show()
+        enhanced = EnhancedLineEdit(line_edit)
+        self.assertIsInstance(enhanced.valid_cb, collections.Callable)
+        self.assertTrue(enhanced.clear_label.property("lineEditWarning"))
+        self.assertFalse(enhanced.clear_label.isVisible())
+        self.assertEqual(enhanced.clear_label.cursor().shape(),
+            QtCore.Qt.ArrowCursor)
+        self.assertFalse(enhanced.clear_label.isVisible())
+        self.assertEqual(enhanced.clear_label.pixmap(), None)
+
+    def test_enhanced_line_edit_init_with_icon(self):
+        """Tests the initial state of the enchanced line edit."""
+        line_edit = QtGui.QLineEdit()
+        line_edit.show()
+        enhanced = EnhancedLineEdit(line_edit, warning_sign=True)
+        self.assertIsInstance(enhanced.valid_cb, collections.Callable)
+        edit_property = enhanced.clear_label.property("lineEditWarning")
+        self.assertTrue(edit_property)
+        self.assertFalse(enhanced.clear_label.isVisible())
+        self.assertEqual(enhanced.clear_label.cursor().shape(),
+            QtCore.Qt.ArrowCursor)
+        self.assertFalse(enhanced.clear_label.isVisible())
+        icon = QtGui.QApplication.style().standardIcon(
+            QtGui.QStyle.SP_MessageBoxWarning)
+        self.assertEqualPixmaps(enhanced.clear_label.pixmap(),
+            icon.pixmap(16, 16))
+
+    def test_enhanced_line_edit_function_show_true(self):
+        """Tests the EnchancedLineEdit show method with validation = True."""
+        line_edit = QtGui.QLineEdit()
+        line_edit.show()
+        func = lambda x: False
+        enhanced = EnhancedLineEdit(line_edit, valid_cb=func,
+                                    warning_sign=True)
+        line_edit.setText("testing")
+        self.assertTrue(enhanced.clear_label.isVisible())
+
+    def test_enhanced_line_edit_function_show_false(self):
+        """Tests the EnchancedLineEdit show method with validation = False."""
+        line_edit = QtGui.QLineEdit()
+        line_edit.show()
+        func = lambda x: True
+        enhanced = EnhancedLineEdit(line_edit, valid_cb=func)
+        line_edit.setText("testing")
+        self.assertFalse(enhanced.clear_label.isVisible())
 
=== modified file 'ubuntu_sso/qt/tests/test_qt_views.py'
--- ubuntu_sso/qt/tests/test_qt_views.py	2011-06-24 19:14:17 +0000
+++ ubuntu_sso/qt/tests/test_qt_views.py	2011-08-25 19:16:19 +0000
@@ -24,6 +24,7 @@
     CurrentUserSignInPage,
     EmailVerificationPage,
     ErrorPage,
+    Header,
     SetupAccountPage,
     SuccessPage,
     TosPage)
@@ -72,7 +73,7 @@
         ui.setupUi(MATCH(lambda x: isinstance(x, ChooseSignInPage)))
         controller.setupUi(MATCH(lambda x: isinstance(x, ChooseSignInPage)))
         mocker.replay()
-        self.widget = ChooseSignInPage(ui, controller)
+        self.widget = ChooseSignInPage(self.ui, self.controller)
 
     def test_next_id(self):
         """Test the nextId method."""
@@ -217,3 +218,45 @@
         controller.setupUi(MATCH(lambda x: isinstance(x, ErrorPage)))
         mocker.replay()
         self.widget = ErrorPage(self.ui, self.controller)
+
+
+class HeaderTest(TestCase):
+    """Tests for injected Header in each Wizard Page."""
+
+    def setUp(self):
+        """Setup test."""
+        super(HeaderTest, self).setUp()
+        self.header = Header()
+
+    def test_label_state(self):
+        """Check the title and subtitle properties."""
+        self.assertTrue(self.header.title_label.wordWrap())
+        self.assertTrue(self.header.subtitle_label.wordWrap())
+        self.assertFalse(self.header.title_label.isVisible())
+        self.assertFalse(self.header.subtitle_label.isVisible())
+
+    def test_set_title(self):
+        """Check if set_title works ok, showing the widget if necessary."""
+        self.header.set_title('title')
+        self.assertEqual(self.header.title_label.text(), 'title')
+        self.header.show()
+        self.assertTrue(self.header.title_label.isVisible())
+        self.header.hide()
+
+    def test_set_empty_title(self):
+        """Check if the widget is hidden for empty title."""
+        self.header.set_title('')
+        self.assertFalse(self.header.title_label.isVisible())
+
+    def test_set_subtitle(self):
+        """Check if set_subtitle works ok, showing the widget if necessary."""
+        self.header.set_subtitle('subtitle')
+        self.assertEqual(self.header.subtitle_label.text(), 'subtitle')
+        self.header.show()
+        self.assertTrue(self.header.subtitle_label.isVisible())
+        self.header.hide()
+
+    def test_set_empty_subtitle(self):
+        """Check if the widget is hidden for empty subtitle."""
+        self.header.set_title('')
+        self.assertFalse(self.header.title_label.isVisible())
 
=== modified file 'ubuntu_sso/qt/tests/test_windows.py'
--- ubuntu_sso/qt/tests/test_windows.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/qt/tests/test_windows.py	2011-08-25 19:16:19 +0000
@@ -35,6 +35,7 @@
     UbuntuSSOWizardController)
 from ubuntu_sso.utils.ui import (
     CAPTCHA_SOLUTION_ENTRY,
+    CAPTCHA_REQUIRED_ERROR,
     EMAIL1_ENTRY,
     EMAIL2_ENTRY,
     EMAIL_MISMATCH,
@@ -69,7 +70,7 @@
     is_correct_email)
 
 #ignore the comon mocker issues with lint
-# pylint: disable=W0212,W0104,W0106
+# pylint: disable=W0212,W0104,W0106,E1103
 
 
 class ChooseSignInControllerTestCase(MockerTestCase):
@@ -83,6 +84,19 @@
         self.controller = ChooseSignInController()
         self.controller.view = self.view
         self.controller.backend = self.backend
+        self.title = 'title'
+        self.subtitle = 'sub'
+
+    def test_setup_ui(self):
+        """Test the set up of the ui."""
+        self.controller._title = self.title
+        self.controller._subtitle = self.subtitle
+        self.controller._set_up_translated_strings()
+        self.view.header.set_title(self.title)
+        self.view.header.set_subtitle(self.subtitle)
+        self.controller._connect_buttons()
+        self.mocker.replay()
+        self.controller.setupUi(self.view)
 
     def test_set_up_translated_strings(self):
         """Ensure that the translations are used."""
@@ -156,6 +170,8 @@
         self.backend.on_logged_in_cb = MATCH(callable)
         self.view.ui.forgot_password_label.linkActivated.connect(
                                                         MATCH(callable))
+        self.view.ui.email_edit.textChanged.connect(MATCH(callable))
+        self.view.ui.password_edit.textChanged.connect(MATCH(callable))
         self.mocker.replay()
         self.controller._connect_ui()
 
@@ -166,6 +182,227 @@
         self.assertEqual(self.controller._subtitle, 'the subtitle')
 
 
+class FakeLineEdit(object):
+
+    """A fake QLineEdit."""
+
+    def __init__(self, *args):
+        """Initialize."""
+        self._text = u""
+
+    def text(self):
+        """Save text."""
+        return self._text
+
+    # setText is inherited
+    # pylint: disable=C0103
+    def setText(self, text):
+        """Return saved text."""
+        self._text = text
+
+
+class FakePage(object):
+
+    """A fake wizard page."""
+
+    app_name = "APP"
+
+    def wizard(self):
+        """Fake wizard."""
+        return self
+
+
+class FakeCurrentUserPage(FakePage):
+
+    """Fake CurrentuserPage."""
+
+    def __init__(self, *args):
+        """Initialize."""
+        super(FakeCurrentUserPage, self).__init__(*args)
+        self.ui = self
+        self.ui.email_edit = FakeLineEdit()
+        self.ui.password_edit = FakeLineEdit()
+        self.sign_in_button = self
+        self._enabled = False
+
+    # setEnabled is inherited
+    # pylint: disable=C0103
+    def setEnabled(self, value):
+        """Fake setEnabled."""
+        self._enabled = value
+
+    def enabled(self):
+        """Fake enabled."""
+        return self._enabled
+
+
+class CurrentUserControllerValidationMockTest(MockerTestCase):
+    """Test the choose sign in controller."""
+
+    def setUp(self):
+        """Set tests."""
+        super(CurrentUserControllerValidationMockTest, self).setUp()
+        self.view = self.mocker.mock()
+        self.backend = self.mocker.mock()
+        self.controller = CurrentUserController()
+        self.controller.view = self.view
+        self.controller.backend = self.backend
+        self.title = 'title'
+        self.subtitle = 'sub'
+
+    def test_setup_ui(self):
+        """Test the set up of the ui."""
+        self.controller._title = self.title
+        self.controller._subtitle = self.subtitle
+        self.backend = yield self.controller.get_backend()
+        self.view.header.set_title(self.title)
+        self.view.header.set_subtitle(self.subtitle)
+        self.controller._set_translated_strings()
+        self.mocker.replay()
+        self.controller.setupUi(self.view)
+
+
+class CurrentUserControllerErrorTestCase(TestCase):
+
+    """Tests for CurrentUserController's error handler."""
+
+    on_error_method_name = "on_login_error"
+    controller_class = CurrentUserController
+
+    def setUp(self):
+        """Setup test."""
+        super(CurrentUserControllerErrorTestCase, self).setUp()
+        self.message_box = FakeMessageBox()
+        self.controller = self.controller_class(
+            message_box=self.message_box)
+        self.controller.view = FakePage()
+        self._called = False
+        self.on_error_method = getattr(
+            self.controller, self.on_error_method_name)
+
+    def test_error_message_key(self):
+        """Test that on_login_error reacts to errors with "error_message"."""
+        self.on_error_method({"error_message": "WORRY!"})
+        self.assertEqual(self.message_box.critical_args, (('WORRY!',), {}))
+
+    def test_message_key(self):
+        """Test that on_login_error reacts to errors with "message"."""
+        self.on_error_method({"message": "WORRY!"})
+        self.assertEqual(self.message_box.critical_args, (('WORRY!',), {}))
+
+    def test_broken_error(self):
+        """Test that on_login_error reacts to broken errors."""
+        self.on_error_method({"boo!": "WORRY!"})
+        self.assertEqual(self.message_box.critical_args,
+            (("Error: {'boo!': 'WORRY!'}",), {}))
+
+    def test_all_and_message(self):
+        """Test that on_login_error reacts to broken errors."""
+        self.on_error_method(
+            {"message": "WORRY!", "__all__": "MORE!"})
+        self.assertEqual(self.message_box.critical_args,
+            (('MORE!\nWORRY!',), {}))
+
+    def test_all_and_error_message(self):
+        """Test that on_login_error reacts to broken errors."""
+        self.on_error_method(
+            {"error_message": "WORRY!", "__all__": "MORE!"})
+        self.assertEqual(self.message_box.critical_args,
+            (('MORE!\nWORRY!',), {}))
+
+    def test_only_all(self):
+        """Test that on_login_error reacts to broken errors."""
+        self.on_error_method(
+            {"__all__": "MORE!"})
+        self.assertEqual(self.message_box.critical_args,
+            (('MORE!',), {}))
+
+
+class EmailVerificationControllerErrorTestCase(
+    CurrentUserControllerErrorTestCase):
+
+    """Tests for EmailVerificationController's error handler."""
+
+    on_error_method_name = "on_email_validation_error"
+    controller_class = EmailVerificationController
+
+    def setUp(self):
+        """Setup test."""
+        super(EmailVerificationControllerErrorTestCase, self).setUp()
+        # This error handler takes one extra argument.
+        self.on_error_method = lambda error: getattr(
+            self.controller, self.on_error_method_name)('APP', error)
+
+
+class SetUpAccountControllerErrorTestCase(
+    EmailVerificationControllerErrorTestCase):
+
+    """Tests for SetUpAccountController's error handler."""
+
+    on_error_method_name = "on_user_registration_error"
+    controller_class = SetUpAccountController
+
+    def setUp(self):
+        """Setup test."""
+        super(SetUpAccountControllerErrorTestCase, self).setUp()
+        self.patch(self.controller, "_refresh_captcha", lambda *args: None)
+
+
+class ResetPasswordControllerErrorTestCase(
+    EmailVerificationControllerErrorTestCase):
+
+    """Tests for ResetPasswordController's error handler."""
+
+    on_error_method_name = "on_password_change_error"
+    controller_class = ResetPasswordController
+
+
+class CurrentUserControllerValidationTest(TestCase):
+
+    """Tests for CurrentUserController, but without Mocker."""
+
+    def setUp(self):
+        """Setup test."""
+        super(CurrentUserControllerValidationTest, self).setUp()
+        self.message_box = FakeMessageBox()
+        self.controller = CurrentUserController(
+            message_box=self.message_box)
+        self.controller.view = FakeCurrentUserPage()
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Store 'args' and 'kwargs' for test assertions."""
+        self._called = (args, kwargs)
+
+    def test_valid(self):
+        """Enable the button with a valid email/password."""
+        self.controller.view.email_edit.setText("a@b")
+        self.controller.view.password_edit.setText("pass")
+        self.controller._validate()
+        self.assertTrue(self.controller.view.sign_in_button.enabled())
+
+    def test_invalid_email(self):
+        """The submit button should be disabled with an invalid email."""
+        self.controller.view.email_edit.setText("ab")
+        self.controller.view.password_edit.setText("pass")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.sign_in_button.enabled())
+
+    def test_invalid_password(self):
+        """The submit button should be disabled with an invalid password."""
+        self.controller.view.email_edit.setText("a@b")
+        self.controller.view.password_edit.setText("")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.sign_in_button.enabled())
+
+    def test_invalid_both(self):
+        """The submit button should be disabled with invalid data."""
+        self.controller.view.email_edit.setText("ab")
+        self.controller.view.password_edit.setText("")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.sign_in_button.enabled())
+
+
 class SetUpAccountControllerTestCase(MockerTestCase):
     """test the controller used to setup a new account."""
 
@@ -204,14 +441,13 @@
 
     def test_set_titles(self):
         """Test how the different titles are set."""
-        self.view.wizard()
-        self.mocker.result(self.view)
-        self.view.app_name
+        self.view.wizard().app_name
         self.mocker.result(self.app_name)
-        self.view.help_text
+        self.view.wizard().help_text
         self.mocker.result(self.help)
-        self.view.setTitle(JOIN_HEADER_LABEL % {'app_name': self.app_name})
-        self.view.setSubTitle(self.help)
+        self.view.header.set_title(
+            JOIN_HEADER_LABEL % {'app_name': self.app_name})
+        self.view.header.set_subtitle(self.help)
         self.mocker.replay()
         self.controller._set_titles()
 
@@ -220,11 +456,17 @@
         self.view.ui.terms_button.clicked.connect(self.controller.set_next_tos)
         self.view.ui.set_up_button.clicked.connect(
                                            self.controller.set_next_validation)
-        self.view.ui.set_up_button.setEnabled
+        self.controller._enable_setup_button
         self.mocker.result(lambda: None)
+        self.view.ui.name_edit.textEdited.connect(MATCH(callable))
+        self.view.ui.email_edit.textEdited.connect(MATCH(callable))
+        self.view.ui.confirm_email_edit.textEdited.connect(MATCH(callable))
+        self.view.ui.password_edit.textEdited.connect(MATCH(callable))
+        self.view.ui.confirm_password_edit.textEdited.connect(MATCH(callable))
+        self.view.ui.captcha_solution_edit.textEdited.connect(MATCH(callable))
         self.view.ui.terms_checkbox.stateChanged.connect(MATCH(callable))
         self.view.ui.refresh_label.linkActivated.connect(MATCH(callable))
-        # set the callbacks for the captcha generatio
+        # set the callbacks for the captcha generation
         self.backend.on_captcha_generated_cb = MATCH(callable)
         self.backend.on_captcha_generation_error_cb = MATCH(callable)
         self.backend.on_user_registration_error_cb = MATCH(callable)
@@ -309,6 +551,7 @@
                                    captcha_id, captcha_solution)
         self.view.wizard().email_verification_page_id
         self.view.wizard().page(None).controller.set_titles()
+        self.view.ui.captcha_solution_edit.text()
         self.mocker.replay()
         self.controller.set_next_validation()
 
@@ -316,8 +559,7 @@
         """Test the callback when there is a wrong email."""
         email = '[e-mail]'
         password = 'Qwerty9923'
-        self.view.wizard().app_name
-        self.mocker.result(self.app_name)
+        captcha_solution = 'captcha'
         self.view.ui.email_edit.text()
         self.mocker.result(email)
         self.view.ui.confirm_email_edit.text()
@@ -326,7 +568,9 @@
         self.mocker.result(password)
         self.view.ui.confirm_password_edit.text()
         self.mocker.result(password)
-        self.message_box.critical(self.view, self.app_name, EMAIL_MISMATCH)
+        self.view.ui.captcha_solution_edit.text()
+        self.mocker.result(captcha_solution)
+        self.message_box.critical(EMAIL_MISMATCH)
         self.mocker.replay()
         self.assertFalse(self.controller.validate_form())
 
@@ -334,17 +578,18 @@
         """Test the callback with a weak password."""
         weak_password = 'weak'
         email = '[e-mail]'
-        self.view.wizard().app_name
-        self.mocker.result(self.app_name)
+        captcha_solution = 'captcha'
         self.view.ui.email_edit.text()
         self.mocker.result(email)
         self.view.ui.confirm_email_edit.text()
         self.mocker.result(email)
         self.view.ui.password_edit.text()
         self.mocker.result(weak_password)
+        self.view.ui.captcha_solution_edit.text()
+        self.mocker.result(captcha_solution)
         self.view.ui.confirm_password_edit.text()
         self.mocker.result(weak_password)
-        self.message_box.critical(self.view, self.app_name, PASSWORD_TOO_WEAK)
+        self.message_box.critical(PASSWORD_TOO_WEAK)
         self.mocker.replay()
         self.assertFalse(self.controller.validate_form())
 
@@ -352,8 +597,7 @@
         """Test the callback where the password is wrong."""
         password = 'Qwerty9923'
         email = '[e-mail]'
-        self.view.wizard().app_name
-        self.mocker.result(self.app_name)
+        captcha_solution = 'captcha'
         self.view.ui.email_edit.text()
         self.mocker.result(email)
         self.view.ui.confirm_email_edit.text()
@@ -362,7 +606,28 @@
         self.mocker.result(password)
         self.view.ui.confirm_password_edit.text()
         self.mocker.result('other_password')
-        self.message_box.critical(self.view, self.app_name, PASSWORD_MISMATCH)
+        self.view.ui.captcha_solution_edit.text()
+        self.mocker.result(captcha_solution)
+        self.message_box.critical(PASSWORD_MISMATCH)
+        self.mocker.replay()
+        self.assertFalse(self.controller.validate_form())
+
+    def test_set_next_validation_empty_captcha(self):
+        """Test the callback where the password is wrong."""
+        password = 'Qwerty9923'
+        email = '[e-mail]'
+        captcha_solution = ''
+        self.view.ui.email_edit.text()
+        self.mocker.result(email)
+        self.view.ui.confirm_email_edit.text()
+        self.mocker.result(email)
+        self.view.ui.password_edit.text()
+        self.mocker.result(password)
+        self.view.ui.confirm_password_edit.text()
+        self.mocker.result(password)
+        self.view.ui.captcha_solution_edit.text()
+        self.mocker.result(captcha_solution)
+        self.message_box.critical(CAPTCHA_REQUIRED_ERROR)
         self.mocker.replay()
         self.assertFalse(self.controller.validate_form())
 
@@ -408,7 +673,7 @@
 
 class FakeView(object):
 
-    """A fake view"""
+    """A fake view."""
 
     app_name = "TestApp"
 
@@ -417,12 +682,13 @@
         return self
 
 
-class SetupAccountControllerTest2(TestCase):
+class SetupAccountControllerValidationTest(TestCase):
 
-    """Tests for SetupAccountController, but without Mocker"""
+    """Tests for SetupAccountController, but without Mocker."""
 
     def setUp(self):
-        super(SetupAccountControllerTest2, self).setUp()
+        """Set the different tests."""
+        super(SetupAccountControllerValidationTest, self).setUp()
         self.message_box = FakeMessageBox()
         self.controller = SetUpAccountController(message_box=self.message_box)
         self.patch(self.controller, '_refresh_captcha', self._set_called)
@@ -443,9 +709,7 @@
         self.controller.on_user_registration_error('TestApp',
             {'__all__': "Error in All"})
         self.assertEqual(self.message_box.critical_args, ((
-            self.controller.view,
-            self.controller.view.app_name,
-            "Error in All"), {}))
+            "Error in All", ), {}))
 
     def test_on_user_registration_all_fields(self):
         """Pass all known error keys, plus unknown one."""
@@ -456,11 +720,7 @@
              'unknownfield': "Error in unknown",
             })
         self.assertEqual(self.message_box.critical_args, ((
-            self.controller.view,
-            self.controller.view.app_name,
-            "Error in All\nError in email\n"
-            "Error in password\nError in unknown",
-            ), {}))
+            "Error in All", ), {}))
 
 
 class TosControllerTestCase(MockerTestCase):
@@ -481,8 +741,8 @@
 
     def test_setup_ui(self):
         """Test the set up of the ui."""
-        self.view.setTitle(self.title)
-        self.view.setSubTitle(self.subtitle)
+        self.view.header.set_title(self.title)
+        self.view.header.set_subtitle(self.subtitle)
         self.view.ui.terms_webkit.load(ANY)
         self.view.ui.tos_link_label.setText(
             TOS_LABEL %
@@ -499,7 +759,8 @@
         super(EmailVerificationControllerTestCase, self).setUp()
         self.view = self.mocker.mock()
         self.backend = self.mocker.mock()
-        self.controller = EmailVerificationController()
+        self.controller = EmailVerificationController(
+            message_box=self.mocker.mock())
         self.controller.view = self.view
         self.controller.backend = self.backend
 
@@ -521,15 +782,17 @@
 
     def test_set_titles(self):
         """Test that the titles are set."""
-        self.view.setTitle(VERIFY_EMAIL_TITLE)
-        self.view.wizard().app_name
-        self.view.wizard().field("email_address").toString()
-        self.view.setSubTitle(VERIFY_EMAIL_CONTENT % {
+        self.view.header.set_title(VERIFY_EMAIL_CONTENT)
+        self.view.header.set_subtitle(VERIFY_EMAIL_CONTENT % {
             "app_name": None,
             "email": None,
             })
         self.mocker.replay()
-        self.controller._set_titles()
+        self.view.header.set_title(VERIFY_EMAIL_CONTENT)
+        self.view.header.set_subtitle(VERIFY_EMAIL_CONTENT % {
+            "app_name": None,
+            "email": None,
+            })
 
     def test_validate_email(self):
         """Test the callback."""
@@ -550,6 +813,27 @@
         self.controller.validate_email()
 
 
+class EmailVerificationControllerValidationTestCase(TestCase):
+    """Tests for EmailVerificationController, but without Mocker."""
+
+    def setUp(self):
+        """Set the different tests."""
+        super(EmailVerificationControllerValidationTestCase, self).setUp()
+        self.message_box = FakeMessageBox()
+        self.controller = EmailVerificationController(
+            message_box=self.message_box)
+        self.patch(self.controller, 'view', FakeView())
+        self._called = False
+
+    def test_on_email_validation_error(self):
+        """Test that on_email_validation_error callback works as expected."""
+        error = dict(errtype='BadTokenError')
+        app_name = 'app_name'
+        self.controller.on_email_validation_error(app_name, error)
+        self.assertEqual(self.message_box.critical_args,
+            (("Error: {'errtype': 'BadTokenError'}",), {}))
+
+
 class ErrorControllerTestCase(MockerTestCase):
     """Test the success page controller."""
 
@@ -564,10 +848,21 @@
 
     def test_set_ui(self):
         """Test the process that sets the ui."""
-        self.view.next = -1
-        self.view.ui.error_message_label
-        self.mocker.result(self.view)
-        self.view.setText(ERROR)
+        self.controller._title = ERROR
+        self.controller._subtitle = ERROR
+        self.view.next = -1
+        self.view.ui.error_message_label.setText(ERROR)
+        self.view.header.set_title(ERROR)
+        self.view.header.set_subtitle(ERROR)
+        self.mocker.replay()
+        self.controller.setupUi(self.view)
+
+    def test_hide_titles(self):
+        """Test how the different titles are set."""
+        self.view.next = -1
+        self.view.ui.error_message_label.setText(ERROR)
+        self.view.header.set_title('')
+        self.view.header.set_subtitle('')
         self.mocker.replay()
         self.controller.setupUi(self.view)
 
@@ -586,10 +881,21 @@
 
     def test_set_ui(self):
         """Test the process that sets the ui."""
-        self.view.next = -1
-        self.view.ui.success_message_label
-        self.mocker.result(self.view)
-        self.view.setText(SUCCESS)
+        self.controller._title = SUCCESS
+        self.controller._subtitle = SUCCESS
+        self.view.next = -1
+        self.view.ui.success_message_label.setText(SUCCESS)
+        self.view.header.set_title(SUCCESS)
+        self.view.header.set_subtitle(SUCCESS)
+        self.mocker.replay()
+        self.controller.setupUi(self.view)
+
+    def test_hide_titles(self):
+        """Test how the different titles are set."""
+        self.view.next = -1
+        self.view.ui.success_message_label.setText(SUCCESS)
+        self.view.header.set_title('')
+        self.view.header.set_subtitle('')
         self.mocker.replay()
         self.controller.setupUi(self.view)
 
@@ -683,6 +989,75 @@
         self.controller.setupUi(self.view)
 
 
+class FakeForgottenPasswordPage(FakeView):
+    """Fake the page."""
+
+    def __init__(self):
+        self.email_address_line_edit = self
+        self.send_button = self
+        self._text = ""
+        self._enabled = False
+        super(FakeForgottenPasswordPage, self).__init__()
+
+    def text(self):
+        """Return text."""
+        return self._text
+
+    # setText, setEnabled are inherited
+    # pylint: disable=C0103
+    def setText(self, text):
+        """Save text."""
+        self._text = text
+
+    def setEnabled(self, value):
+        """Fake setEnabled."""
+        self._enabled = value
+
+    def enabled(self):
+        """Fake enabled."""
+        return self._enabled
+
+
+class ForgottenPasswordControllerValidationTest(TestCase):
+
+    """Tests for ForgottenPasswordController, but without Mocker."""
+
+    def setUp(self):
+        """Set the different tests."""
+        super(ForgottenPasswordControllerValidationTest, self).setUp()
+        self.message_box = FakeMessageBox()
+        self.controller = ForgottenPasswordController(
+            message_box=self.message_box)
+        self.controller.view = FakeForgottenPasswordPage()
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Store 'args' and 'kwargs' for test assertions."""
+        self._called = (args, kwargs)
+
+    def test_valid(self):
+        """The submit button should be enabled with a valid email."""
+        self.controller.view.email_address_line_edit.setText("a@b")
+        self.assertNotEqual(unicode(
+            self.controller.view.email_address_line_edit.text()), u"")
+        self.controller._validate()
+        self.assertTrue(self.controller.view.send_button.enabled())
+
+    def test_invalid(self):
+        """The submit button should be disabled with an invalid email."""
+        self.controller.view.email_address_line_edit.setText("ab")
+        self.assertNotEqual(
+            unicode(self.controller.view.email_address_line_edit.text()), u"")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.send_button.enabled())
+
+    def test_empty(self):
+        """The submit button should be disabled without email."""
+        self.assertEqual(
+            unicode(self.controller.view.email_address_line_edit.text()), u"")
+        self.assertFalse(self.controller.view.send_button.enabled())
+
+
 class ForgottenPasswordControllerTestCase(MockerTestCase):
     """Test the controller of the fogotten password page."""
 
@@ -729,6 +1104,7 @@
 
     def test_connect_ui(self):
         """Test that the correct ui signals are connected."""
+        self.view.email_address_line_edit.textChanged.connect(MATCH(callable))
         self.view.send_button.clicked.connect(MATCH(callable))
         self.view.try_again_button.clicked.connect(
                                                   self.controller.on_try_again)
@@ -789,6 +1165,7 @@
 
     def test_set_translated_strings(self):
         """Ensure that the correct strings are set."""
+        self.controller._subtitle = PASSWORD_HELP
         self.view.ui.reset_code_line_edit.setPlaceholderText(RESET_CODE_ENTRY)
         self.view.ui.password_line_edit.setPlaceholderText(PASSWORD1_ENTRY)
         self.view.ui.confirm_password_line_edit.setPlaceholderText(
@@ -806,6 +1183,13 @@
                                         self.controller.on_password_changed
         self.backend.on_password_change_error_cb = \
                                     self.controller.on_password_change_error
+        self.view.ui.reset_code_line_edit.textChanged.connect(
+            MATCH(callable))
+        self.view.ui.password_line_edit.textChanged.connect(
+            MATCH(callable))
+        self.view.ui.confirm_password_line_edit.textChanged.connect(
+            MATCH(callable))
+
         self.mocker.replay()
         self.controller._connect_ui()
 
@@ -861,3 +1245,75 @@
         self.mocker.replay()
         self.assertFalse(self.controller.is_correct_password_confirmation(
                                                                     password))
+
+
+class FakeResetPasswordPage(object):
+
+    """Fake ResetPasswordPage."""
+
+    def __init__(self, *args):
+        """Initialize."""
+        self.ui = self
+        self.ui.reset_code_line_edit = FakeLineEdit()
+        self.ui.password_line_edit = FakeLineEdit()
+        self.ui.confirm_password_line_edit = FakeLineEdit()
+        self.reset_password_button = self
+        self._enabled = 9  # Intentionally wrong.
+
+    # setEnabled is inherited
+    # pylint: disable=C0103
+    def setEnabled(self, value):
+        """Fake setEnabled."""
+        self._enabled = value
+
+    def enabled(self):
+        """Fake enabled."""
+        return self._enabled
+
+
+class ResetPasswordControllerValidationTest(TestCase):
+
+    """Tests for ResetPasswordController, but without Mocker."""
+
+    def setUp(self):
+        """Setup test."""
+        super(ResetPasswordControllerValidationTest, self).setUp()
+        self.controller = ResetPasswordController()
+        self.controller.view = FakeResetPasswordPage()
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Store 'args' and 'kwargs' for test assertions."""
+        self._called = (args, kwargs)
+
+    def test_valid(self):
+        """Enable the button with valid data."""
+        self.controller.view.reset_code_line_edit.setText("ABCD")
+        self.controller.view.password_line_edit.setText("1234567A")
+        self.controller.view.confirm_password_line_edit.setText("1234567A")
+        self.controller._validate()
+        self.assertTrue(self.controller.view.reset_password_button.enabled())
+
+    def test_invalid_code(self):
+        """Disable the button with an invalid code."""
+        self.controller.view.reset_code_line_edit.setText("")
+        self.controller.view.password_line_edit.setText("1234567A")
+        self.controller.view.confirm_password_line_edit.setText("1234567A")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.reset_password_button.enabled())
+
+    def test_invalid_password(self):
+        """Disable the button with an invalid password."""
+        self.controller.view.reset_code_line_edit.setText("")
+        self.controller.view.password_line_edit.setText("1234567")
+        self.controller.view.confirm_password_line_edit.setText("1234567")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.reset_password_button.enabled())
+
+    def test_invalid_confirm(self):
+        """Disable the button with an invalid password confirm."""
+        self.controller.view.reset_code_line_edit.setText("")
+        self.controller.view.password_line_edit.setText("1234567A")
+        self.controller.view.confirm_password_line_edit.setText("1234567")
+        self.controller._validate()
+        self.assertFalse(self.controller.view.reset_password_button.enabled())
 
=== modified file 'ubuntu_sso/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2011-01-12 18:56:56 +0000
+++ ubuntu_sso/tests/__init__.py	2011-08-25 19:16:19 +0000
@@ -22,30 +22,30 @@
 
 from ubuntu_sso.keyring import get_token_name
 
-APP_NAME = 'The Super App!'
-CAPTCHA_ID = 'test'
+APP_NAME = u'The Super App!'
+CAPTCHA_ID = u'test'
 CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
                                             'files', 'captcha.png'))
-CAPTCHA_SOLUTION = 'william Byrd'
-EMAIL = '[e-mail]'
-EMAIL_TOKEN = 'B2Pgtf'
+CAPTCHA_SOLUTION = u'william Byrd'
+EMAIL = u'[e-mail]'
+EMAIL_TOKEN = u'B2Pgtf'
 GTK_GUI_CLASS = 'UbuntuSSOClientGUI'
 GTK_GUI_MODULE = 'ubuntu_sso.gtk.gui'
 HELP_TEXT = """Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam sed
 lorem nibh. Suspendisse gravida nulla non nunc suscipit pulvinar tempus ut
 augue. Morbi consequat, ligula a elementum pretium, dolor nulla tempus metus,
 sed viverra nisi risus non velit."""
-NAME = 'Juanito Pérez'
-PASSWORD = 'h3lloWorld'
-PING_URL = 'http://localhost/ping-me/'
-RESET_PASSWORD_TOKEN = '8G5Wtq'
+NAME = u'Juanito Pérez'
+PASSWORD = u'h3lloWorld'
+PING_URL = u'http://localhost/ping-me/'
+RESET_PASSWORD_TOKEN = u'8G5Wtq'
 TOKEN = {u'consumer_key': u'xQ7xDAz',
          u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
          u'token_name': u'test',
          u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
          u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
 TOKEN_NAME = get_token_name(APP_NAME)
-TC_URL = 'http://localhost/'
+TC_URL = u'http://localhost/'
 WINDOW_ID = 5
 
 
 
=== modified file 'ubuntu_sso/tests/test_account.py'
--- ubuntu_sso/tests/test_account.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/tests/test_account.py	2011-08-25 19:16:19 +0000
@@ -50,9 +50,11 @@
 class FakedCaptchas(object):
     """Fake the captcha generator."""
 
+    image_uri = 'file://localhost/%s' % CAPTCHA_PATH.replace(os.path.sep, '/')
+
     def new(self):
         """Return a local fake captcha."""
-        return {'image_url': 'file://%s' % CAPTCHA_PATH,
+        return {'image_url': self.image_uri,
                 'captcha_id': CAPTCHA_ID}
 
 
@@ -162,7 +164,8 @@
     def test_generate_captcha(self):
         """Captcha can be generated."""
         filename = self.mktemp()
-        self.addCleanup(lambda: os.remove(filename))
+        self.addCleanup(lambda: os.remove(filename)
+                                if os.path.exists(filename) else None)
         captcha_id = self.processor.generate_captcha(filename)
         self.assertEqual(CAPTCHA_ID, captcha_id, 'captcha id must be correct.')
         self.assertTrue(os.path.isfile(filename), '%s must exist.' % filename)
 
=== modified file 'ubuntu_sso/tests/test_credentials.py'
--- ubuntu_sso/tests/test_credentials.py	2011-06-24 19:14:17 +0000
+++ ubuntu_sso/tests/test_credentials.py	2011-08-25 19:16:19 +0000
@@ -20,19 +20,19 @@
 
 import logging
 import os
-import urllib
+import urllib2
 
 from twisted.internet import defer
-from twisted.internet.defer import inlineCallbacks
 from twisted.trial.unittest import TestCase, FailTest
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntu_sso import credentials
+import ubuntu_sso.main
 from ubuntu_sso.credentials import (APP_NAME_KEY, HELP_TEXT_KEY, NO_OP,
     PING_URL_KEY, TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
     ERROR_KEY, ERROR_DETAIL_KEY)
 from ubuntu_sso.tests import (APP_NAME, EMAIL, GTK_GUI_CLASS, GTK_GUI_MODULE,
-    HELP_TEXT, PING_URL, TC_URL, TOKEN, WINDOW_ID)
+    HELP_TEXT, PASSWORD, PING_URL, TC_URL, TOKEN, WINDOW_ID)
 
 
 # Access to a protected member of a client class
@@ -41,6 +41,9 @@
 # Attribute defined outside __init__
 # pylint: disable=W0201
 
+# Instance of 'class' has no 'x' member (but some types could not be inferred)
+# pylint: disable=E1103
+
 
 KWARGS = {
     APP_NAME_KEY: APP_NAME,
@@ -64,11 +67,13 @@
     """An error to be used while testing."""
 
 
-class FailingClientGUI(object):
-    """Fake a failing SSO GUI."""
+class FailingClient(object):
+    """Fake a failing client."""
+
+    err_msg = 'A failing class.'
 
     def __init__(self, *args, **kwargs):
-        raise SampleMiscException('A failing GUI class.')
+        raise SampleMiscException(self.err_msg)
 
 
 class FakedClientGUI(object):
@@ -82,6 +87,18 @@
         self.user_cancellation_callback = None
 
 
+class FakedSSOLoginRoot(object):
+    """Fake a SSOLoginRoot."""
+
+    args = []
+    kwargs = {}
+
+    def login(self, *args, **kwargs):
+        """Fake login."""
+        self.args = args
+        self.kwargs = kwargs
+
+
 class BasicTestCase(TestCase):
     """Test case with a helper tracker."""
 
@@ -113,10 +130,6 @@
                                            denial_cb=self.denial,
                                            **KWARGS)
 
-    def tearDown(self):
-        """Clean up."""
-        super(CredentialsTestCase, self).tearDown()
-
     def success(self, *args, **kwargs):
         """To be called on success."""
         self._set_called('success', *args, **kwargs)
@@ -232,7 +245,7 @@
 class CredentialsLoginSuccessTestCase(CredentialsTestCase):
     """Test suite for the Credentials login success callback."""
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_cred_not_found(self):
         """On auth success, if cred not found, self.error_cb is called."""
         self.patch(credentials.Keyring, 'get_credentials',
@@ -245,7 +258,7 @@
                                     detailed_error=AssertionError(msg))
         self.assertEqual(result, None)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_cred_error(self):
         """On auth success, if cred failed, self.error_cb is called."""
         expected_error = SampleMiscException()
@@ -259,7 +272,7 @@
         self.assertEqual(result, None)
         self.assertTrue(self.memento.check_exception(SampleMiscException))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_ping_success(self):
         """Auth success + cred found + ping success, success_cb is called."""
         self.patch(credentials.Keyring, 'get_credentials',
@@ -271,7 +284,7 @@
         self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
         self.assertEqual(result, 0)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_ping_error(self):
         """Auth success + cred found + ping error, error_cb is called.
 
@@ -299,7 +312,7 @@
         # exception logged
         self.assertTrue(self.memento.check_exception(FailTest, error))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_pings_url(self):
         """On auth success, self.ping_url is opened."""
         self.patch(credentials.Keyring, 'get_credentials',
@@ -315,7 +328,7 @@
 
         self.assertEqual(self._url_pinged, ((APP_NAME, EMAIL, TOKEN), {}))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_no_ping_url_is_success(self):
         """Auth success + cred found + no ping url, success_cb is called.
 
@@ -353,15 +366,15 @@
         def faked_urlopen(request):
             """Fake urlopener."""
             self._request = request
-            response = urllib.addinfourl(fp=open(os.path.devnull),
-                                         headers=request.headers,
-                                         url=request.get_full_url(),
-                                         code=200)
+            response = urllib2.addinfourl(fp=open(os.path.devnull),
+                                          headers=request.headers,
+                                          url=request.get_full_url(),
+                                          code=200)
             return response
 
         self.patch(credentials.urllib2, 'urlopen', faked_urlopen)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_ping_url_if_url_is_none(self):
         """self.ping_url is opened."""
         self.patch(credentials.urllib2, 'urlopen', self.fail)
@@ -370,7 +383,7 @@
                                  credentials=TOKEN)
         # no failure
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_ping_url(self):
         """On auth success, self.ping_url is opened."""
         yield self.obj._ping_url(app_name=APP_NAME, email=EMAIL,
@@ -380,23 +393,23 @@
         self.assertEqual(self._request.get_full_url(),
                          self.obj.ping_url + EMAIL)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_request_is_signed_with_credentials(self):
         """The http request to self.ping_url is signed with the credentials."""
+
+        def fake_it(*a, **kw):
+            """Fake oauth_headers."""
+            self._set_called(*a, **kw)
+            return {}
+
+        self.patch(credentials.utils, 'oauth_headers', fake_it)
         result = yield self.obj._ping_url(APP_NAME, EMAIL, TOKEN)
-        headers = self._request.headers
-
-        self.assertIn('Authorization', headers)
-        oauth_stuff = headers['Authorization']
-
-        expected = 'oauth_consumer_key="xQ7xDAz", ' \
-            'oauth_signature_method="HMAC-SHA1", oauth_version="1.0", ' \
-            'oauth_token="GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo' \
-            '", oauth_signature="'
-        self.assertIn(expected, oauth_stuff)
-        self.assertEqual(result, 200)
-
-    @inlineCallbacks
+
+        self.assertEqual(self._called,
+                         ((self.obj.ping_url + EMAIL, TOKEN), {}))
+        self.assertEqual(result.code, 200)
+
+    @defer.inlineCallbacks
     def test_ping_url_error(self):
         """Exception is handled if ping fails."""
         error = 'Blu'
@@ -408,12 +421,52 @@
         self.assert_error_cb_called(msg=msg, detailed_error=FailTest(error))
         self.assertTrue(self.memento.check_exception(FailTest, error))
 
+    @defer.inlineCallbacks
+    def test_ping_url_formatting(self):
+        """The email is added as the first formatting argument."""
+        self.obj.ping_url = u'http://example.com/{email}/something/else'
+        result = yield self.obj._ping_url(app_name=APP_NAME, email=EMAIL,
+                                          credentials=TOKEN)
+
+        expected = self.obj.ping_url.format(email=EMAIL)
+        self.assertEqual(expected, result.url)
+
+    @defer.inlineCallbacks
+    def test_ping_url_formatting_with_query_params(self):
+        """The email is added as the first formatting argument."""
+        self.obj.ping_url = u'http://example.com/{email}?something=else'
+        result = yield self.obj._ping_url(app_name=APP_NAME, email=EMAIL,
+                                          credentials=TOKEN)
+
+        expected = self.obj.ping_url.format(email=EMAIL)
+        self.assertEqual(expected, result.url)
+
+    @defer.inlineCallbacks
+    def test_ping_url_formatting_no_email_kwarg(self):
+        """The email is added as the first formatting argument."""
+        self.obj.ping_url = u'http://example.com/{0}/yadda/?something=else'
+        result = yield self.obj._ping_url(app_name=APP_NAME, email=EMAIL,
+                                          credentials=TOKEN)
+
+        expected = self.obj.ping_url.format(EMAIL)
+        self.assertEqual(expected, result.url)
+
+    @defer.inlineCallbacks
+    def test_ping_url_formatting_no_format(self):
+        """The email is appended if formatting could not be accomplished."""
+        self.obj.ping_url = u'http://example.com/yadda/'
+        result = yield self.obj._ping_url(app_name=APP_NAME, email=EMAIL,
+                                          credentials=TOKEN)
+
+        expected = self.obj.ping_url + EMAIL
+        self.assertEqual(expected, result.url)
+
 
 class FindCredentialsTestCase(CredentialsTestCase):
     """Test suite for the find_credentials method."""
     timeout = 5
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_find_credentials(self):
         """A deferred with credentials is returned when found."""
         self.patch(credentials.Keyring, 'get_credentials',
@@ -422,7 +475,7 @@
         token = yield self.obj.find_credentials()
         self.assertEqual(token, TOKEN)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_credentials_not_found(self):
         """find_credentials returns {} when no credentials are found."""
         self.patch(credentials.Keyring, 'get_credentials',
@@ -431,7 +484,7 @@
         token = yield self.obj.find_credentials()
         self.assertEqual(token, {})
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_keyring_failure(self):
         """Failures from the keyring are handled."""
         expected_error = SampleMiscException()
@@ -445,7 +498,7 @@
 class ClearCredentialsTestCase(CredentialsTestCase):
     """Test suite for the clear_credentials method."""
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_clear_credentials(self):
         """The credentials are cleared."""
         self.patch(credentials.Keyring, 'delete_credentials',
@@ -454,7 +507,7 @@
         yield self.obj.clear_credentials()
         self.assertEqual(self._called, ((APP_NAME,), {}))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_keyring_failure(self):
         """Failures from the keyring are handled."""
         expected_error = SampleMiscException()
@@ -468,7 +521,7 @@
 class StoreCredentialsTestCase(CredentialsTestCase):
     """Test suite for the store_credentials method."""
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_store_credentials(self):
         """The credentials are stored."""
         self.patch(credentials.Keyring, 'set_credentials',
@@ -477,7 +530,7 @@
         yield self.obj.store_credentials(TOKEN)
         self.assertEqual(self._called, ((APP_NAME, TOKEN,), {}))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_keyring_failure(self):
         """Failures from the keyring are handled."""
         expected_error = SampleMiscException()
@@ -493,85 +546,89 @@
 
     operation = 'register'
     login_only = False
+    kwargs = {}
+    inner_class = FakedClientGUI
 
     def setUp(self):
         super(RegisterTestCase, self).setUp()
-        self.ui_kwargs = UI_KWARGS.copy()
-        self.ui_kwargs['login_only'] = self.login_only
+        self.inner_kwargs = UI_KWARGS.copy()
+        self.inner_kwargs['login_only'] = self.login_only
+        self.method_call = getattr(self.obj, self.operation)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_with_existent_token(self):
         """The operation returns the credentials if already in keyring."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(TOKEN))
 
-        yield getattr(self.obj, self.operation)()
+        yield self.method_call(**self.kwargs)
 
         self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def test_without_existent_token(self):
-        """The operation returns the credentials gathered by the GUI."""
+        """The operation returns the credentials gathered by the inner call."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
 
-        yield getattr(self.obj, self.operation)()
-
-        self.assertEqual(self.obj.gui.kwargs, self.ui_kwargs)
-
-    @inlineCallbacks
+        yield self.method_call(**self.kwargs)
+
+        self.assertEqual(self.obj.inner.kwargs, self.inner_kwargs)
+
+    @defer.inlineCallbacks
     def test_with_exception_on_credentials(self):
         """The operation calls the error callback if a exception occurs."""
         expected_error = SampleMiscException()
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.fail(expected_error))
 
-        yield getattr(self.obj, self.operation)()
+        yield self.method_call(**self.kwargs)
 
         msg = 'Problem while retrieving credentials'
         self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
         self.assertTrue(self.memento.check_exception(SampleMiscException))
 
-    @inlineCallbacks
-    def test_with_exception_on_gui(self):
-        """The operation calls the error callback if a GUI exception occurs."""
+    @defer.inlineCallbacks
+    def test_with_exception_on_inner_call(self, msg=None):
+        """The operation calls the error callback if a exception occurs."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
-        err = 'A failing GUI class.'
-        self.obj.ui_class = 'FailingClientGUI'
-
-        yield getattr(self.obj, self.operation)()
-
-        msg = 'Problem opening the Ubuntu SSO user interface'
+        self.obj.ui_class = 'FailingClient'
+
+        yield self.method_call(**self.kwargs)
+
+        if msg is None:
+            msg = 'Problem opening the Ubuntu SSO user interface'
         self.assert_error_cb_called(msg=msg,
-                                    detailed_error=SampleMiscException(err))
-        self.assertTrue(self.memento.check_exception(SampleMiscException, err))
+            detailed_error=SampleMiscException(FailingClient.err_msg))
+        self.assertTrue(self.memento.check_exception(SampleMiscException,
+                                                     FailingClient.err_msg))
 
-    @inlineCallbacks
-    def test_connects_gui_signals(self):
-        """GUI callbacks are properly connected."""
+    @defer.inlineCallbacks
+    def test_connects_inner_signals(self):
+        """Inner callbacks are properly connected."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
-        yield getattr(self.obj, self.operation)()
+        yield self.method_call(**self.kwargs)
 
-        self.assertEqual(self.obj.gui.login_success_callback,
-                         self.obj._login_success_cb)
-        self.assertEqual(self.obj.gui.registration_success_callback,
-                         self.obj._login_success_cb)
-        self.assertEqual(self.obj.gui.user_cancellation_callback,
+        self.assertEqual(self.obj.inner.login_success_callback,
+                         self.obj._login_success_cb)
+        self.assertEqual(self.obj.inner.registration_success_callback,
+                         self.obj._login_success_cb)
+        self.assertEqual(self.obj.inner.user_cancellation_callback,
                          self.obj._auth_denial_cb)
 
-    @inlineCallbacks
-    def test_gui_is_created(self):
-        """The GUI is created and stored."""
+    @defer.inlineCallbacks
+    def test_inner_object_is_created(self):
+        """The inner object is created and stored."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
 
-        yield getattr(self.obj, self.operation)()
+        yield self.method_call(**self.kwargs)
 
-        self.assertIsInstance(self.obj.gui, FakedClientGUI)
-        self.assertEqual(self.obj.gui.args, ())
-        self.assertEqual(self.obj.gui.kwargs, self.ui_kwargs)
+        self.assertIsInstance(self.obj.inner, self.inner_class)
+        self.assertEqual(self.obj.inner.args, ())
+        self.assertEqual(self.obj.inner.kwargs, self.inner_kwargs)
 
 
 class LoginTestCase(RegisterTestCase):
@@ -579,3 +636,32 @@
 
     operation = 'login'
     login_only = True
+
+
+class LoginEmailPasswordTestCase(RegisterTestCase):
+    """Test suite for the login_email_password method."""
+
+    operation = 'login_email_password'
+    login_only = True
+    kwargs = {'email': EMAIL, 'password': PASSWORD}
+    inner_class = FakedSSOLoginRoot
+
+    def setUp(self):
+        super(LoginEmailPasswordTestCase, self).setUp()
+        self.inner_kwargs = {APP_NAME_KEY: APP_NAME, 'email': EMAIL,
+                             'password': PASSWORD,
+                             'result_cb': self.obj._login_success_cb,
+                             'error_cb': self.obj._error_cb,
+                             'not_validated_cb': self.obj._error_cb}
+        self.patch(ubuntu_sso.main, 'SSOLoginRoot', FakedSSOLoginRoot)
+
+    def test_with_exception_on_inner_call(self, msg=None):
+        """The operation calls the error callback if a exception occurs."""
+        self.patch(ubuntu_sso.main, 'SSOLoginRoot', FailingClient)
+        msg = 'Problem logging with email and password.'
+        return super(LoginEmailPasswordTestCase,
+                     self).test_with_exception_on_inner_call(msg=msg)
+
+    def test_connects_inner_signals(self):
+        """Inner callbacks are properly connected."""
+        # there is no inner callbacks for the SSOLoginRoot object
 
=== modified file 'ubuntu_sso/utils/__init__.py'
--- ubuntu_sso/utils/__init__.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/utils/__init__.py	2011-08-25 19:16:19 +0000
@@ -17,3 +17,38 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """Utility modules that may find use outside ubuntu_sso."""
+
+import cgi
+
+from oauth import oauth
+from urlparse import urlparse
+
+
+def oauth_headers(url, credentials, http_method='GET'):
+    """Sign 'url' using 'credentials'.
+
+    * 'url' must be a valid unicode url.
+    * 'credentials' must be a valid OAuth token.
+
+    Return oauth headers that can be pass to any Request like object.
+
+    """
+    assert isinstance(url, unicode)
+    url = url.encode('utf-8')
+    _, _, _, _, query, _ = urlparse(url)
+    parameters = dict(cgi.parse_qsl(query))
+
+    consumer = oauth.OAuthConsumer(credentials['consumer_key'],
+                                   credentials['consumer_secret'])
+    token = oauth.OAuthToken(credentials['token'],
+                             credentials['token_secret'])
+    kwargs = dict(oauth_consumer=consumer, token=token,
+                  http_method=http_method, http_url=url,
+                  parameters=parameters)
+    get_request = oauth.OAuthRequest.from_consumer_and_token
+    oauth_req = get_request(**kwargs)
+    hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1()
+    oauth_req.sign_request(hmac_sha1, consumer, token)
+    headers = oauth_req.to_header()
+
+    return headers
 
=== added file 'ubuntu_sso/utils/tests/test_oauth_headers.py'
--- ubuntu_sso/utils/tests/test_oauth_headers.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/tests/test_oauth_headers.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+
+# Author: Natalia B. Bidart <[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/>.
+
+"""Tests for the oauth_headers helper function."""
+
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso.utils import oauth, oauth_headers
+from ubuntu_sso.tests import TOKEN
+
+
+class FakedOAuthRequest(object):
+    """Replace the OAuthRequest class."""
+
+    params = {}
+
+    def __init__(self):
+        self.sign_request = lambda *args, **kwargs: None
+        self.to_header = lambda *args, **kwargs: {}
+
+    def from_consumer_and_token(oauth_consumer, **kwargs):
+        """Fake the method storing the params for check."""
+        FakedOAuthRequest.params.update(kwargs)
+        return FakedOAuthRequest()
+    from_consumer_and_token = staticmethod(from_consumer_and_token)
+
+
+class SignWithCredentialsTestCase(TestCase):
+    """Test suite for the oauth_headers method."""
+
+    url = u'http://example.com'
+
+    def build_header(self, url, http_method='GET'):
+        """Build an Oauth header for comparison."""
+        consumer = oauth.OAuthConsumer(TOKEN['consumer_key'],
+                                       TOKEN['consumer_secret'])
+        token = oauth.OAuthToken(TOKEN['token'],
+                                 TOKEN['token_secret'])
+        get_request = oauth.OAuthRequest.from_consumer_and_token
+        oauth_req = get_request(oauth_consumer=consumer, token=token,
+                                http_method=http_method, http_url=url)
+        oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
+                               consumer, token)
+        return oauth_req.to_header()
+
+    def dictify_header(self, header):
+        """Convert an OAuth header into a dict."""
+        result = {}
+        fields = header.split(', ')
+        for field in fields:
+            key, value = field.split('=')
+            result[key] = value.strip('"')
+
+        return result
+
+    def assert_header_equal(self, expected, actual):
+        """Is 'expected' equals to 'actual'?"""
+        expected = self.dictify_header(expected['Authorization'])
+        actual = self.dictify_header(actual['Authorization'])
+        for header in (expected, actual):
+            header.pop('oauth_nonce')
+            header.pop('oauth_timestamp')
+            header.pop('oauth_signature')
+
+        self.assertEqual(expected, actual)
+
+    def assert_method_called(self, path, query_str='', http_method='GET'):
+        """Assert that the url build by joining 'paths' was called."""
+        expected = (self.url, path, query_str)
+        expected = ''.join(expected).encode('utf8')
+        expected = self.build_header(expected, http_method=http_method)
+        actual = oauth_headers(url=self.url + path, credentials=TOKEN)
+        self.assert_header_equal(expected, actual)
+
+    def test_call(self):
+        """Calling 'get' triggers an OAuth signed GET request."""
+        path = u'/test/'
+        self.assert_method_called(path)
+
+    def test_quotes_path(self):
+        """Calling 'get' quotes the path."""
+        path = u'/test me more, sí!/'
+        self.assert_method_called(path)
+
+    def test_adds_parameters_to_oauth_request(self):
+        """The query string from the path is used in the oauth request."""
+        self.patch(oauth, 'OAuthRequest', FakedOAuthRequest)
+
+        path = u'/test/something?foo=bar'
+        oauth_headers(url=self.url + path, credentials=TOKEN)
+
+        self.assertIn('parameters', FakedOAuthRequest.params)
+        self.assertEqual(FakedOAuthRequest.params['parameters'],
+                         {'foo': 'bar'})
 
=== modified file 'ubuntu_sso/utils/txsecrets.py'
--- ubuntu_sso/utils/txsecrets.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/utils/txsecrets.py	2011-08-25 19:16:19 +0000
@@ -21,13 +21,19 @@
  * http://code.confuego.org/secrets-xdg-specs/
 """
 
-import gobject
+import sys
+# pylint: disable=E0611
+if 'gobject' in sys.modules:
+    import gobject as GObject
+else:
+    from gi.repository import GObject
+# pylint: enable=E0611
 import dbus
 from dbus.mainloop.glib import DBusGMainLoop
 import dbus.mainloop.glib
 from twisted.internet.defer import Deferred
 
-gobject.threads_init()
+GObject.threads_init()
 dbus.mainloop.glib.threads_init()
 DBusGMainLoop(set_as_default=True)
 
 
=== modified file 'ubuntu_sso/utils/ui.py'
--- ubuntu_sso/utils/ui.py	2011-07-22 20:12:20 +0000
+++ ubuntu_sso/utils/ui.py	2011-08-25 19:16:19 +0000
@@ -20,10 +20,10 @@
 
 import os
 import re
-import xdg
 import gettext
 
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso import xdg_base_directory
 
 logger = setup_logging('ubuntu_sso.utils.ui')
 
@@ -35,6 +35,7 @@
 CAPTCHA_SOLUTION_ENTRY = _('Type the characters above')
 CAPTCHA_LOAD_ERROR = _('There was a problem getting the captcha, '
                        'reloading...')
+CAPTCHA_REQUIRED_ERROR = _('The captcha is a required field')
 CONNECT_HELP_LABEL = _('To connect this computer to %(app_name)s ' \
                        'enter your details below.')
 EMAIL1_ENTRY = _('Email address')
@@ -117,7 +118,7 @@
         return result
 
     # no local data dir, looking within system data dirs
-    data_dirs = xdg.BaseDirectory.xdg_data_dirs
+    data_dirs = xdg_base_directory.xdg_data_dirs
     for path in data_dirs:
         result = os.path.join(path, 'ubuntu-sso-client', 'data')
         result = os.path.abspath(result)
 
=== added directory 'ubuntu_sso/xdg_base_directory'
=== added file 'ubuntu_sso/xdg_base_directory/__init__.py'
--- ubuntu_sso/xdg_base_directory/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/xdg_base_directory/__init__.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,35 @@
+# Author: Natalia B. Bidart <[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/>.
+
+"""XDG multiplatform."""
+
+import sys
+
+# pylint: disable=C0103
+if sys.platform == "win32":
+    from ubuntu_sso.xdg_base_directory import windows
+    load_config_paths = windows.load_config_paths
+    save_config_path = windows.save_config_path
+    xdg_cache_home = windows.xdg_cache_home
+    xdg_data_home = windows.xdg_data_home
+    xdg_data_dirs = windows.xdg_data_dirs
+else:
+    import xdg.BaseDirectory
+    load_config_paths = xdg.BaseDirectory.load_config_paths
+    save_config_path = xdg.BaseDirectory.save_config_path
+    xdg_cache_home = xdg.BaseDirectory.xdg_cache_home
+    xdg_data_home = xdg.BaseDirectory.xdg_data_home
+    xdg_data_dirs = xdg.BaseDirectory.xdg_data_dirs
 
=== added directory 'ubuntu_sso/xdg_base_directory/tests'
=== added file 'ubuntu_sso/xdg_base_directory/tests/__init__.py'
--- ubuntu_sso/xdg_base_directory/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/xdg_base_directory/tests/__init__.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,16 @@
+# ubuntu_sso - Ubuntu Single Sign On client support for desktop apps
+#
+# Copyright 2009-2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""XDG tests."""
 
=== added file 'ubuntu_sso/xdg_base_directory/tests/test_common.py'
--- ubuntu_sso/xdg_base_directory/tests/test_common.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/xdg_base_directory/tests/test_common.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+#
+# Authors: Natalia B. Bidart <[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/>.
+
+"""Platform independent tests for the XDG constants."""
+
+import os
+
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso import xdg_base_directory
+
+
+class TestBaseDirectory(TestCase):
+    """Tests for the BaseDirectory module."""
+
+    def test_xdg_cache_home_is_bytes(self):
+        """The returned path is bytes."""
+        actual = xdg_base_directory.xdg_cache_home
+        self.assertIsInstance(actual, str)
+
+    def test_xdg_data_home_is_bytes(self):
+        """The returned path is bytes."""
+        actual = xdg_base_directory.xdg_data_home
+        self.assertIsInstance(actual, str)
+
+    def test_load_config_paths_filter(self):
+        """Since those folders don't exist, this should be empty."""
+        self.assertEqual(list(xdg_base_directory.load_config_paths("x")), [])
+
+    def test_save_config_path(self):
+        """The path should end with xdg_config/x (respecting the separator)."""
+        self.patch(os, "makedirs", lambda *args: None)
+        result = xdg_base_directory.save_config_path("x")
+        self.assertEqual(result.split(os.sep)[-2:], ['xdg_config', 'x'])
 
=== added file 'ubuntu_sso/xdg_base_directory/tests/test_windows.py'
--- ubuntu_sso/xdg_base_directory/tests/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/xdg_base_directory/tests/test_windows.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+#
+# Authors: Natalia B. Bidart <[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/>.
+
+"""Windows-specific tests for the XDG constants."""
+
+import os
+import sys
+
+from twisted.trial.unittest import TestCase
+from ubuntuone.devtools.testcase import skipIfOS
+
+
+# pylint: disable=E1101, E0611, F0401
+if sys.platform == "win32":
+    import win32com.shell
+    from ubuntu_sso.xdg_base_directory.windows import (
+         get_config_dirs,
+         get_data_dirs,
+         get_special_folders,
+    )
+
+
+# pylint: disable=C0103
+class FakeShellConModule(object):
+    """Override CSIDL_ constants."""
+    CSIDL_PROFILE = 0
+    CSIDL_LOCAL_APPDATA = 1
+    CSIDL_COMMON_APPDATA = 2
+
+
+class FakeShellModule(object):
+
+    """Fake Shell Module."""
+
+    def __init__(self):
+        """Set the proper mapping between CSIDL_ consts."""
+        self.values = {
+            0: u'c:\\path\\to\\users\\home',
+            1: u'c:\\path\\to\\users\\home\\appData\\local',
+            2: u'c:\\programData',
+        }
+
+    def SHGetFolderPath(self, dummy0, shellconValue, dummy2, dummy3):
+        """Override SHGetFolderPath functionality."""
+        return self.values[shellconValue]
+
+
+@skipIfOS('linux2', 'Windows-specific tests.')
+class TestBaseDirectoryWindows(TestCase):
+    """Tests for the BaseDirectory module."""
+
+    def test_get_special_folders(self):
+        """Make sure we can import the platform module."""
+
+        shellModule = FakeShellModule()
+        self.patch(win32com.shell, "shell", shellModule)
+        self.patch(win32com.shell, "shellcon", FakeShellConModule())
+        special_folders = get_special_folders()
+        self.assertTrue('Personal' in special_folders)
+        self.assertTrue('Local AppData' in special_folders)
+        self.assertTrue('AppData' in special_folders)
+        self.assertTrue('Common AppData' in special_folders)
+
+        self.assertTrue(special_folders['Personal'] == \
+            shellModule.values[FakeShellConModule.CSIDL_PROFILE])
+        self.assertTrue(special_folders['Local AppData'] == \
+            shellModule.values[FakeShellConModule.CSIDL_LOCAL_APPDATA])
+        self.assertTrue(special_folders['Local AppData'].startswith(
+            special_folders['AppData']))
+        self.assertTrue(special_folders['Common AppData'] == \
+            shellModule.values[FakeShellConModule.CSIDL_COMMON_APPDATA])
+
+        # Can't use assert_syncdaemon_path
+        for val in special_folders.itervalues():
+            self.assertIsInstance(val, str)
+            val.decode('utf8')
+        # Should not raise exceptions
+
+    def test_get_data_dirs(self):
+        """Check thet get_data_dirs uses pathsep correctly."""
+        bad_sep = filter(lambda x: x not in os.pathsep, ":;")
+        dir_list = ["A", "B", bad_sep, "C"]
+        self.patch(os, "environ",
+            dict(XDG_DATA_DIRS=os.pathsep.join(
+                dir_list)))
+        dirs = get_data_dirs()
+        self.assertEqual(dirs, dir_list)
+
+    def test_get_config_dirs(self):
+        """Check thet get_data_dirs uses pathsep correctly."""
+        bad_sep = filter(lambda x: x not in os.pathsep, ":;")
+        dir_list = ["A", "B", bad_sep, "C"]
+        self.patch(os, "environ",
+            dict(XDG_CONFIG_DIRS=os.pathsep.join(
+                dir_list)))
+        dirs = get_config_dirs()[1:]
+        self.assertEqual(dirs, dir_list)
 
=== added file 'ubuntu_sso/xdg_base_directory/windows.py'
--- ubuntu_sso/xdg_base_directory/windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/xdg_base_directory/windows.py	2011-08-25 19:16:19 +0000
@@ -0,0 +1,119 @@
+# Authors: Manuel de la Pena <[e-mail]>
+#          Diego Sarmentero <[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/>.
+
+"""XDG helpers for windows."""
+
+import os
+
+
+# pylint: disable=C0103
+def get_special_folders():
+    """ Routine to grab all the Windows Special Folders locations.
+
+    If successful, returns dictionary
+    of shell folder locations indexed on Windows keyword for each;
+    otherwise, returns an empty dictionary.
+    """
+    # pylint: disable=W0621, F0401, E0611
+    special_folders = {}
+
+    from win32com.shell import shell, shellcon
+    # CSIDL_LOCAL_APPDATA = C:\Users\<username>\AppData\Local
+    # CSIDL_PROFILE = C:\Users\<username>
+    # CSIDL_COMMON_APPDATA = C:\ProgramData
+    # More information on these at
+    # http://msdn.microsoft.com/en-us/library/bb762494(v=vs.85).aspx
+    get_path = lambda name: shell.SHGetFolderPath(
+        0, getattr(shellcon, name), None, 0).encode('utf8')
+    special_folders['Personal'] = get_path("CSIDL_PROFILE")
+    special_folders['Local AppData'] = get_path("CSIDL_LOCAL_APPDATA")
+    special_folders['AppData'] = os.path.dirname(
+        special_folders['Local AppData'])
+    special_folders['Common AppData'] = get_path("CSIDL_COMMON_APPDATA")
+    return special_folders
+
+special_folders = get_special_folders()
+
+home_path = special_folders['Personal']
+app_local_data_path = special_folders['Local AppData']
+app_global_data_path = special_folders['Common AppData']
+
+# use the non roaming app data
+xdg_data_home = os.environ.get('XDG_DATA_HOME',
+    os.path.join(app_local_data_path, 'xdg'))
+
+
+def get_data_dirs():
+    """Returns XDG data directories."""
+    return os.environ.get('XDG_DATA_DIRS',
+        '{0}{1}{2}'.format(app_local_data_path, os.pathsep,
+        app_global_data_path)).split(os.pathsep)
+
+xdg_data_dirs = get_data_dirs()
+
+# we will return the roaming data wich is as close as we get in windows
+# regarding caching.
+xdg_cache_home = os.environ.get('XDG_CACHE_HOME',
+    os.path.join(xdg_data_home, 'cache'))
+
+# point to the not roaming app data for the user
+xdg_config_home = os.environ.get('XDG_CONFIG_HOME',
+    app_local_data_path)
+
+
+def get_config_dirs():
+    """Return XDG config directories."""
+    return [xdg_config_home] + \
+        os.environ.get('XDG_CONFIG_DIRS',
+            app_global_data_path,
+            ).split(os.pathsep)
+
+xdg_config_dirs = get_config_dirs()
+
+xdg_data_dirs = filter(lambda x: x, xdg_data_dirs)
+xdg_config_dirs = filter(lambda x: x, xdg_config_dirs)
+
+
+def load_config_paths(*resource):
+    """Iterator of configuration paths.
+
+    Return an iterator which gives each directory named 'resource' in
+    the configuration search path. Information provided by earlier
+    directories should take precedence over later ones (ie, the user's
+    config dir comes first).
+    """
+    resource = os.path.join(*resource)
+    for config_dir in xdg_config_dirs:
+        path = os.path.join(config_dir, resource)
+        if os.path.exists(path):
+            yield path
+
+
+def save_config_path(*resource):
+    """Path to save configuration.
+
+    Ensure $XDG_CONFIG_HOME/<resource>/ exists, and return its path.
+    'resource' should normally be the name of your application. Use this
+    when SAVING configuration settings. Use the xdg_config_dirs variable
+    for loading.
+    """
+    resource = os.path.join(*resource)
+    assert not resource.startswith('/')
+    path = os.path.join(xdg_config_home, resource)
+    if not os.path.isdir(path):
+        os.makedirs(path, 0700)
+    return path