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

[Natalia Bidart]

  * New upstream release:
    [ Natalia B. Bidart <email address hidden> ]
      - Tests for a particular package are now inside that package.
      - Register now uses the 'displayname' field to pass it on to SSO as
        display name (LP: #709494).
    [ Manuel de la Pena <email address hidden> ]
      - Fix main issues.
      - First step of implementing the code in main on windows.
      - Fixed setup.py issues so that we can build .debs (LP: #735383).
      - Added the network status implementation for windows (LP: #727680).
      - Added an implementation of the keyring on windows (LP: #684967).
      - Added script to run tests on windows using u1trial (LP: #684988).
      - Added bat to run tests on windows (LP: #684988).

=== modified file 'PKG-INFO'
--- PKG-INFO	2011-02-03 15:46:51 +0000
+++ PKG-INFO	2011-03-23 14:22:30 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntu-sso-client
-Version: 1.1.11
+Version: 1.1.12
 Summary: Ubuntu Single Sign-On client
 Home-page: https://launchpad.net/ubuntu-sso-client
 Author: Natalia Bidart

=== modified file 'debian/changelog'
--- debian/changelog	2011-02-04 08:41:02 +0000
+++ debian/changelog	2011-03-23 14:22:30 +0000
@@ -1,3 +1,22 @@
+ubuntu-sso-client (1.1.12-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release:
+
+    [ Natalia B. Bidart <[e-mail]> ]
+      - Tests for a particular package are now inside that package.
+      - Register now uses the 'displayname' field to pass it on to SSO as
+        display name (LP: #709494).
+    [ Manuel de la Pena <[e-mail]> ]
+      - Fix main issues.
+      - First step of implementing the code in main on windows.
+      - Fixed setup.py issues so that we can build .debs (LP: #735383).
+      - Added the network status implementation for windows (LP: #727680).
+      - Added an implementation of the keyring on windows (LP: #684967).
+      - Added script to run tests on windows using u1trial (LP: #684988).
+      - Added bat to run tests on windows (LP: #684988).
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Tue, 22 Mar 2011 23:31:22 -0300
+
 ubuntu-sso-client (1.1.11-0ubuntu1) natty; urgency=low
 
   * New upstream release:

=== modified file 'run-tests'
--- run-tests	2011-01-12 18:56:56 +0000
+++ run-tests	2011-03-23 14:22:30 +0000
@@ -33,5 +33,5 @@
 }
 
 echo "Running test suite for ""$MODULE"
-`which xvfb-run` u1trial "$MODULE" && style_check
+`which xvfb-run` u1trial "$MODULE" -i "test_windows.py" && style_check
 rm -rf _trial_temp

=== added file 'run-tests.bat'
--- run-tests.bat	1970-01-01 00:00:00 +0000
+++ run-tests.bat	2011-03-23 14:22:30 +0000
@@ -0,0 +1,64 @@
+:: Author: Manuel de la Pena <[e-mail]>
+::
+:: Copyright 2010 Canonical Ltd.
+::
+:: This program is free software: you can redistribute it and/or modify it
+:: under the terms of the GNU General Public License version 3, as published
+:: by the Free Software Foundation.
+::
+:: This program is distributed in the hope that it will be useful, but
+:: WITHOUT ANY WARRANTY; without even the implied warranties of
+:: MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+:: PURPOSE.  See the GNU General Public License for more details.
+::
+:: You should have received a copy of the GNU General Public License along
+:: with this program.  If not, see <http://www.gnu.org/licenses/>.
+@ECHO off
+:: We could have Python 2.6 or 2.7 on Windows. In order to check availability,
+:: we should first check for 2.7, and run the tests, otherwise fall back to 2.6.
+SET PYTHONPATH=""
+:: This is very annoying; FOR /F will work differently depending on the output
+:: of reg which is not consistent between OS versions (XP, 7). We must choose
+:: the tokens according to OS version.
+SET PYTHONPATHTOKENS=3
+VER | FIND "XP" > nul
+IF %ERRORLEVEL% == 0 SET PYTHONPATHTOKENS=4
+ECHO Checking if python 2.7 is in the system
+:: Look for python 2.7
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Python\PythonCore\2.7\InstallPath /ve') DO @SET PYTHONPATH=%%A
+IF NOT %PYTHONPATH% == "" GOTO :PYTHONPRESENT
+ECHO Checking if python 2.6 is in the system
+:: we do not have python 2.7 in the system, try to find 2.6
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Python\PythonCore\2.6\InstallPath /ve') DO @SET PYTHONPATH=%%A
+IF NOT %PYTHONPATH% == "" GOTO :PYTHONPRESENT
+
+:: we do not have python (2.6 or 2.7) this could hapen in the case  that the
+:: user installed the 32version in a 64 machine, let check if the software was installed in the wow key
+
+:: Look for python 2.7 in WoW64
+ECHO Checking if python 2.7 32 is in the system
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Wow6432Node\Python\PythonCore\2.7\InstallPath /ve') DO @SET PYTHONPATH=%%A
+IF NOT %PYTHONPATH% == "" GOTO :PYTHONPRESENT
+ECHO Checking if python 2.6 32 is in the system
+:: we do not have python 2.7 in the system, try to find 2.6
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Wow6432Node\Python\PythonCore\2.6\InstallPath /ve') DO @SET PYTHONPATH=%%A
+IF NOT %PYTHONPATH% == "" GOTO :PYTHONPRESENT
+
+ECHO Please ensure you have python installed
+GOTO :END
+
+
+:PYTHONPRESENT
+ECHO Python found, executing the tests...
+:: execute the tests with a number of ignored linux only modules
+"%PYTHONPATH%\python.exe" "%PYTHONPATH%\Scripts\u1trial" -c ubuntu_sso -i "test_gui.py, test_linux.py, test_txsecrets.py"
+"%PYTHONPATH%\python.exe" "%PYTHONPATH%\Scripts\u1lint" ubuntu_sso
+:: test for style if we can, if pep8 is not present, move to the end
+IF EXIST "%PYTHONPATH%Scripts\pep8.exe"
+"%PYTHONPATH%\Scripts\pep8.exe" --repeat ubuntu_sso
+ELSE
+ECHO Style checks were not done
+:: Delete the temp folders
+RMDIR /s /q _trial_temp
+RMDIR /s /q .coverage
+:END
\ No newline at end of file

=== modified file 'setup.py'
--- setup.py	2011-02-03 15:46:51 +0000
+++ setup.py	2011-03-23 14:22:30 +0000
@@ -86,7 +86,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='1.1.11',
+    version='1.1.12',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',
@@ -94,7 +94,9 @@
     long_description='Desktop service to allow applications to sign in' \
         'to Ubuntu services via SSO',
     url='https://launchpad.net/ubuntu-sso-client',
-    packages=['ubuntu_sso', 'ubuntu_sso.gtk', 'ubuntu_sso.utils'],
+    packages=['ubuntu_sso', 'ubuntu_sso.gtk', 'ubuntu_sso.utils',
+              'ubuntu_sso.keyring', 'ubuntu_sso.networkstate',
+              'ubuntu_sso.main'],
     data_files=[
         ('share/dbus-1/services', ['data/com.ubuntu.sso.service']),
         ('lib/ubuntu-sso-client', ['bin/ubuntu-sso-login']),

=== modified file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	2010-12-16 16:31:34 +0000
+++ ubuntu_sso/account.py	2011-03-23 14:22:30 +0000
@@ -127,11 +127,12 @@
 
         return captcha['captcha_id']
 
-    def register_user(self, email, password, captcha_id, captcha_solution):
+    def register_user(self, email, password, displayname,
+                      captcha_id, captcha_solution):
         """Register a new user with 'email' and 'password'."""
         logger.debug('register_user: email: %r password: <hidden>, '
-                     'captcha_id: %r, captcha_solution: %r',
-                     email, captcha_id, captcha_solution)
+                     'displayname: %r, captcha_id: %r, captcha_solution: %r',
+                     email, displayname, captcha_id, captcha_solution)
         sso_service = self.sso_service_class(None, self.service_url)
         if not self._valid_email(email):
             logger.error('register_user: InvalidEmailError for email: %r',
@@ -142,7 +143,9 @@
             raise InvalidPasswordError()
 
         result = sso_service.registrations.register(
-                    email=email, password=password, captcha_id=captcha_id,
+                    email=email, password=password,
+                    displayname=displayname,
+                    captcha_id=captcha_id,
                     captcha_solution=captcha_solution)
         logger.info('register_user: email: %r result: %r', email, result)
 

=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2011-01-12 18:56:56 +0000
+++ ubuntu_sso/gtk/gui.py	2011-03-23 14:22:30 +0000
@@ -371,8 +371,6 @@
                 msg = 'UbuntuSSOClientGUI: failed set_transient_for win id %r'
                 logger.exception(msg, window_id)
 
-        # Hidding unused widgets to save some space (LP #627440).
-        self.name_entry.hide()
         self.yes_to_updates_checkbutton.hide()
 
         self.window.show()
@@ -777,11 +775,10 @@
 
         error = False
 
-        # Hidding unused widgets to save some space (LP #627440).
-        #name = self.name_entry.get_text()
-        #if not name:
-        #    self.name_entry.set_warning(self.FIELD_REQUIRED)
-        #    error = True
+        name = self.name_entry.get_text()
+        if not name:
+            self.name_entry.set_warning(self.FIELD_REQUIRED)
+            error = True
 
         # check email
         email1 = self.email1_entry.get_text()
@@ -820,10 +817,11 @@
         self.user_password = password1
 
         logger.info('Calling register_user with email %r, password <hidden>,' \
-                    ' captcha_id %r and captcha_solution %r.', email1,
-                    self._captcha_id, captcha_solution)
+                    ' name %r, captcha_id %r and captcha_solution %r.', email1,
+                    name, self._captcha_id, captcha_solution)
         f = self.backend.register_user
-        f(self.app_name, email1, password1, self._captcha_id, captcha_solution,
+        f(self.app_name, email1, password1, name,
+          self._captcha_id, captcha_solution,
           reply_handler=NO_OP, error_handler=NO_OP)
 
     def on_verify_token_button_clicked(self, *args, **kwargs):

=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2011-01-12 18:56:56 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2011-03-23 14:22:30 +0000
@@ -713,7 +713,7 @@
         expected = 'register_user'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
+                         ((APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
                            CAPTCHA_SOLUTION),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
@@ -1314,11 +1314,6 @@
                                           self.ui.FIELD_REQUIRED)
         self.assertNotIn('register_user', self.ui.backend._called)
 
-    # Unused variable 'skip'
-    # pylint: disable=W0612
-    test_warning_is_shown_if_name_empty.skip = \
-        'Unused for now, will be hidden to save space (LP: #627440).'
-
     def test_warning_is_shown_if_empty_email(self):
         """A warning message is shown if emails are empty."""
         self.ui.email1_entry.set_text('')

=== added directory 'ubuntu_sso/keyring'
=== removed file 'ubuntu_sso/keyring.py'
--- ubuntu_sso/keyring.py	2010-11-30 13:21:17 +0000
+++ ubuntu_sso/keyring.py	1970-01-01 00:00:00 +0000
@@ -1,188 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Andrew Higginson
-#  Alejandro J. Cura <[e-mail]>
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; version 3.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
-# details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-"""Handle keys in the local kerying."""
-
-import socket
-import urllib
-import urlparse
-
-from twisted.internet.defer import inlineCallbacks, returnValue
-
-from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.utils.txsecrets import SecretService
-
-
-logger = setup_logging("ubuntu_sso.keyring")
-TOKEN_SEPARATOR = ' @ '
-SEPARATOR_REPLACEMENT = ' AT '
-
-U1_APP_NAME = "Ubuntu One"
-U1_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
-U1_KEY_ATTR = {
-    "oauth-consumer-key": "ubuntuone",
-    "ubuntuone-realm": "https://ubuntuone.com",
-}
-
-
-def get_old_token_name(app_name):
-    """Build the token name (old style)."""
-    quoted_app_name = urllib.quote(app_name)
-    computer_name = socket.gethostname()
-    quoted_computer_name = urllib.quote(computer_name)
-    return "%s - %s" % (quoted_app_name, quoted_computer_name)
-
-
-def get_token_name(app_name):
-    """Build the token name."""
-    computer_name = socket.gethostname()
-    computer_name = computer_name.replace(TOKEN_SEPARATOR,
-                                          SEPARATOR_REPLACEMENT)
-    return TOKEN_SEPARATOR.join((app_name, computer_name)).encode('utf-8')
-
-
-class Keyring(object):
-    """A Keyring for a given application name."""
-
-    def __init__(self):
-        """Initialize this instance."""
-        self.service = SecretService()
-
-    @inlineCallbacks
-    def _find_keyring_item(self, app_name, attr=None):
-        """Return the keyring item or None if not found."""
-        if attr is None:
-            logger.debug("getting attr")
-            attr = self._get_keyring_attr(app_name)
-        logger.debug("finding all items")
-        items = yield self.service.search_items(attr)
-        if len(items) == 0:
-            # if no items found, return None
-            logger.debug("No items found")
-            returnValue(None)
-
-        logger.debug("Returning first item found")
-        returnValue(items[0])
-
-    def _get_keyring_attr(self, app_name):
-        """Build the keyring attributes for this credentials."""
-        attr = {"key-type": "Ubuntu SSO credentials",
-                "token-name": get_token_name(app_name)}
-        return attr
-
-    @inlineCallbacks
-    def set_credentials(self, app_name, cred):
-        """Set the credentials of the Ubuntu SSO item."""
-        # Creates the secret from the credentials
-        secret = urllib.urlencode(cred)
-
-        attr = self._get_keyring_attr(app_name)
-        # Add our SSO credentials to the keyring
-        yield self.service.open_session()
-        collection = yield self.service.get_default_collection()
-        yield collection.create_item(app_name, attr, secret, True)
-
-    @inlineCallbacks
-    def _migrate_old_token_name(self, app_name):
-        """Migrate credentials with old name, store them with new name."""
-        logger.debug("getting keyring attr")
-        attr = self._get_keyring_attr(app_name)
-        logger.debug("getting old token name")
-        attr['token-name'] = get_old_token_name(app_name)
-        logger.debug("finding keyring item")
-        item = yield self._find_keyring_item(app_name, attr=attr)
-        if item is not None:
-            logger.debug("setting credentials")
-            yield self.set_credentials(app_name,
-                                       dict(urlparse.parse_qsl(item.secret)))
-            logger.debug("deleting old item")
-            yield item.delete()
-
-        logger.debug("finding keyring item")
-        result = yield self._find_keyring_item(app_name)
-        logger.debug("returning result value")
-        returnValue(result)
-
-    @inlineCallbacks
-    def get_credentials(self, app_name):
-        """A deferred with the secret of the SSO item in a dictionary."""
-        # If we have no attributes, return None
-        logger.debug("getting credentials")
-        yield self.service.open_session()
-        logger.debug("calling find item")
-        item = yield self._find_keyring_item(app_name)
-        if item is None:
-            logger.debug("migrating token")
-            item = yield self._migrate_old_token_name(app_name)
-
-        if item is not None:
-            logger.debug("parsing secret")
-            secret = yield item.get_value()
-            returnValue(dict(urlparse.parse_qsl(secret)))
-        else:
-            # if no item found, try getting the old credentials
-            if app_name == U1_APP_NAME:
-                logger.debug("trying old credentials")
-                old_creds = yield try_old_credentials(app_name)
-                returnValue(old_creds)
-        # nothing was found
-        returnValue(None)
-
-    @inlineCallbacks
-    def delete_credentials(self, app_name):
-        """Delete a set of credentials from the keyring."""
-        attr = self._get_keyring_attr(app_name)
-        # Add our SSO credentials to the keyring
-        yield self.service.open_session()
-        collection = yield self.service.get_default_collection()
-        yield collection.create_item(app_name, attr, "secret!", True)
-
-        item = yield self._find_keyring_item(app_name)
-        if item is not None:
-            yield item.delete()
-
-
-class UbuntuOneOAuthKeyring(Keyring):
-    """A particular Keyring for Ubuntu One."""
-
-    def _get_keyring_attr(self, app_name):
-        """Build the keyring attributes for this credentials."""
-        return U1_KEY_ATTR
-
-
-@inlineCallbacks
-def try_old_credentials(app_name):
-    """Try to get old U1 credentials and format them as new."""
-    logger.debug('trying to get old credentials.')
-    old_creds = yield UbuntuOneOAuthKeyring().get_credentials(U1_KEY_NAME)
-    if old_creds is not None:
-        # Old creds found, build a new credentials dict with them
-        creds = {
-            'consumer_key': "ubuntuone",
-            'consumer_secret': "hammertime",
-            'name': U1_KEY_NAME,
-            'token': old_creds["oauth_token"],
-            'token_secret': old_creds["oauth_token_secret"],
-        }
-        logger.debug('found old credentials')
-        returnValue(creds)
-    logger.debug('try_old_credentials: No old credentials for this app.')
-    returnValue(None)

=== added file 'ubuntu_sso/keyring/__init__.py'
--- ubuntu_sso/keyring/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring/__init__.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Authors:
+#  Andrew Higginson
+#  Alejandro J. Cura <[e-mail]>
+#  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/>.
+"""Implementations of different keyrings."""
+
+import socket
+import sys
+import urllib
+
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from ubuntu_sso.logger import setup_logging
+
+logger = setup_logging("ubuntu_sso.keyring")
+
+TOKEN_SEPARATOR = ' @ '
+SEPARATOR_REPLACEMENT = ' AT '
+
+U1_APP_NAME = "Ubuntu One"
+U1_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
+U1_KEY_ATTR = {
+    "oauth-consumer-key": "ubuntuone",
+    "ubuntuone-realm": "https://ubuntuone.com",
+}
+
+
+def get_old_token_name(app_name):
+    """Build the token name (old style)."""
+    quoted_app_name = urllib.quote(app_name)
+    computer_name = socket.gethostname()
+    quoted_computer_name = urllib.quote(computer_name)
+    return "%s - %s" % (quoted_app_name, quoted_computer_name)
+
+
+def get_token_name(app_name):
+    """Build the token name."""
+    computer_name = socket.gethostname()
+    computer_name = computer_name.replace(TOKEN_SEPARATOR,
+                                          SEPARATOR_REPLACEMENT)
+    return TOKEN_SEPARATOR.join((app_name, computer_name)).encode('utf-8')
+
+
+@inlineCallbacks
+def try_old_credentials(app_name):
+    """Try to get old U1 credentials and format them as new."""
+    logger.debug('trying to get old credentials.')
+    old_creds = yield UbuntuOneOAuthKeyring().get_credentials(U1_KEY_NAME)
+    if old_creds is not None:
+        # Old creds found, build a new credentials dict with them
+        creds = {
+            'consumer_key': "ubuntuone",
+            'consumer_secret': "hammertime",
+            'name': U1_KEY_NAME,
+            'token': old_creds["oauth_token"],
+            'token_secret': old_creds["oauth_token_secret"],
+        }
+        logger.debug('found old credentials')
+        returnValue(creds)
+    logger.debug('try_old_credentials: No old credentials for this app.')
+    returnValue(None)
+
+
+if sys.platform == 'win32':
+    from ubuntu_sso.keyring.windows import Keyring
+else:
+    from ubuntu_sso.keyring.linux import Keyring
+
+
+class UbuntuOneOAuthKeyring(Keyring):
+    """A particular Keyring for Ubuntu One."""
+
+    def _get_keyring_attr(self, app_name):
+        """Build the keyring attributes for this credentials."""
+        return U1_KEY_ATTR

=== added file 'ubuntu_sso/keyring/linux.py'
--- ubuntu_sso/keyring/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring/linux.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2010 Canonical
+#
+# Authors:
+#  Andrew Higginson
+#  Alejandro J. Cura <[e-mail]>
+#  Natalia B. Bidart <[e-mail]>
+#  Manuel de la Pena <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Handle keys in the local kerying."""
+
+import urllib
+import urlparse
+
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils.txsecrets import SecretService
+from ubuntu_sso.keyring import (
+    get_token_name,
+    get_old_token_name,
+    U1_APP_NAME,
+    try_old_credentials)
+
+
+logger = setup_logging("ubuntu_sso.keyring")
+
+
+class Keyring(object):
+    """A Keyring for a given application name."""
+
+    def __init__(self):
+        """Initialize this instance."""
+        self.service = SecretService()
+
+    @inlineCallbacks
+    def _find_keyring_item(self, app_name, attr=None):
+        """Return the keyring item or None if not found."""
+        if attr is None:
+            logger.debug("getting attr")
+            attr = self._get_keyring_attr(app_name)
+        logger.debug("finding all items")
+        items = yield self.service.search_items(attr)
+        if len(items) == 0:
+            # if no items found, return None
+            logger.debug("No items found")
+            returnValue(None)
+
+        logger.debug("Returning first item found")
+        returnValue(items[0])
+
+    def _get_keyring_attr(self, app_name):
+        """Build the keyring attributes for this credentials."""
+        attr = {"key-type": "Ubuntu SSO credentials",
+                "token-name": get_token_name(app_name)}
+        return attr
+
+    @inlineCallbacks
+    def set_credentials(self, app_name, cred):
+        """Set the credentials of the Ubuntu SSO item."""
+        # Creates the secret from the credentials
+        secret = urllib.urlencode(cred)
+
+        attr = self._get_keyring_attr(app_name)
+        # Add our SSO credentials to the keyring
+        yield self.service.open_session()
+        collection = yield self.service.get_default_collection()
+        yield collection.create_item(app_name, attr, secret, True)
+
+    @inlineCallbacks
+    def _migrate_old_token_name(self, app_name):
+        """Migrate credentials with old name, store them with new name."""
+        logger.debug("getting keyring attr")
+        attr = self._get_keyring_attr(app_name)
+        logger.debug("getting old token name")
+        attr['token-name'] = get_old_token_name(app_name)
+        logger.debug("finding keyring item")
+        item = yield self._find_keyring_item(app_name, attr=attr)
+        if item is not None:
+            logger.debug("setting credentials")
+            yield self.set_credentials(app_name,
+                                       dict(urlparse.parse_qsl(item.secret)))
+            logger.debug("deleting old item")
+            yield item.delete()
+
+        logger.debug("finding keyring item")
+        result = yield self._find_keyring_item(app_name)
+        logger.debug("returning result value")
+        returnValue(result)
+
+    @inlineCallbacks
+    def get_credentials(self, app_name):
+        """A deferred with the secret of the SSO item in a dictionary."""
+        # If we have no attributes, return None
+        logger.debug("getting credentials")
+        yield self.service.open_session()
+        logger.debug("calling find item")
+        item = yield self._find_keyring_item(app_name)
+        if item is None:
+            logger.debug("migrating token")
+            item = yield self._migrate_old_token_name(app_name)
+
+        if item is not None:
+            logger.debug("parsing secret")
+            secret = yield item.get_value()
+            returnValue(dict(urlparse.parse_qsl(secret)))
+        else:
+            # if no item found, try getting the old credentials
+            if app_name == U1_APP_NAME:
+                logger.debug("trying old credentials")
+                old_creds = yield try_old_credentials(app_name)
+                returnValue(old_creds)
+        # nothing was found
+        returnValue(None)
+
+    @inlineCallbacks
+    def delete_credentials(self, app_name):
+        """Delete a set of credentials from the keyring."""
+        attr = self._get_keyring_attr(app_name)
+        # Add our SSO credentials to the keyring
+        yield self.service.open_session()
+        collection = yield self.service.get_default_collection()
+        yield collection.create_item(app_name, attr, "secret!", True)
+
+        item = yield self._find_keyring_item(app_name)
+        if item is not None:
+            yield item.delete()

=== added directory 'ubuntu_sso/keyring/tests'
=== added file 'ubuntu_sso/keyring/tests/__init__.py'
--- ubuntu_sso/keyring/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring/tests/__init__.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+"""Keyring tests."""

=== added file 'ubuntu_sso/keyring/tests/test_linux.py'
--- ubuntu_sso/keyring/tests/test_linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring/tests/test_linux.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,259 @@
+# -*- coding: utf-8 -*-
+#
+# test_keyring - tests for ubuntu_sso.keyring
+#
+# Author: Alejandro J. Cura <[e-mail]>
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the keyring.py module."""
+
+import socket
+
+from twisted.internet import defer
+from twisted.internet.defer import inlineCallbacks
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso import keyring as common_keyring
+from ubuntu_sso.keyring import linux as keyring
+from ubuntu_sso.tests import APP_NAME
+
+
+def build_fake_gethostname(fake_hostname):
+    """Return a fake hostname getter."""
+    return lambda *a: fake_hostname
+
+
+class MockItem(object):
+    """An item contains a secret, lookup attributes and has a label."""
+
+    def __init__(self, label, collection, attr, value):
+        """Initialize a new Item."""
+        self.label = label
+        self.collection = collection
+        self.attributes = attr
+        self.value = value
+
+    def get_value(self):
+        """Retrieve the secret for this item."""
+        return defer.succeed(self.value)
+
+    def delete(self):
+        """Delete this item."""
+        self.collection.items.remove(self)
+        return defer.succeed(None)
+
+    def matches(self, search_attr):
+        """See if this item matches a given search."""
+        for k, val in search_attr.items():
+            if k not in self.attributes:
+                return False
+            if self.attributes[k] != val:
+                return False
+        return True
+
+
+class MockCollection(object):
+    """A collection of items containing secrets."""
+
+    def __init__(self, label, service):
+        """Initialize a new collection."""
+        self.label = label
+        self.service = service
+        self.items = []
+
+    def create_item(self, label, attr, value, replace=True):
+        """Create an item with the given attributes, secret and label."""
+        item = MockItem(label, self, attr, value)
+        self.items.append(item)
+        return defer.succeed(item)
+
+
+class MockSecretService(object):
+    """A class that mocks txsecrets.SecretService."""
+
+    def __init__(self, *args, **kwargs):
+        super(MockSecretService, self).__init__(*args, **kwargs)
+        self.collections = {}
+
+    def open_session(self, window_id=0):
+        """Open a unique session for the caller application."""
+        return defer.succeed(self)
+
+    def search_items(self, attributes):
+        """Find items in any collection."""
+        results = []
+        for collection in self.collections.values():
+            for item in collection.items:
+                if item.matches(attributes):
+                    results.append(item)
+        return defer.succeed(results)
+
+    def create_collection(self, label):
+        """Create a new collection with the specified properties."""
+        collection = MockCollection(label, self)
+        self.collections[label] = collection
+        if "default" not in self.collections:
+            self.collections["default"] = collection
+        return defer.succeed(collection)
+
+    def get_default_collection(self):
+        """The collection were default items should be created."""
+        if len(self.collections) == 0:
+            self.create_collection("default")
+        return defer.succeed(self.collections["default"])
+
+
+class TestTokenNameBuilder(TestCase):
+    """Test the method that builds the token name."""
+
+    def test_get_simple_token_name(self):
+        """A simple token name is built right."""
+        sample_app_name = "UbuntuTwo"
+        sample_hostname = "Darkstar"
+        expected_result = "UbuntuTwo @ Darkstar"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+    def test_get_complex_token_name_for_app_name(self):
+        """A complex token name is built right too."""
+        sample_app_name = "Ubuntu @ Eleven"
+        sample_hostname = "Mate+Cocido"
+        expected_result = "Ubuntu @ Eleven @ Mate+Cocido"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+    def test_get_complex_token_name_for_hostname(self):
+        """A complex token name is built right too."""
+        sample_app_name = "Ubuntu Eleven"
+        sample_hostname = "Mate @ Cocido"
+        expected_result = "Ubuntu Eleven @ Mate AT Cocido"
+
+        fake_gethostname = build_fake_gethostname(sample_hostname)
+        self.patch(socket, "gethostname", fake_gethostname)
+        result = keyring.get_token_name(sample_app_name)
+        self.assertEqual(result, expected_result)
+
+
+class TestKeyring(TestCase):
+    """Test the keyring related functions."""
+
+    timeout = 5
+
+    def setUp(self):
+        """Initialize the mock used in these tests."""
+        self.mock_service = None
+        self.service = self.patch(keyring, "SecretService",
+                                  self.get_mock_service)
+        fake_gethostname = build_fake_gethostname("darkstar")
+        self.patch(socket, "gethostname", fake_gethostname)
+
+    def get_mock_service(self):
+        """Create only one instance of the mock service per test."""
+        if self.mock_service == None:
+            self.mock_service = MockSecretService()
+        return self.mock_service
+
+    @inlineCallbacks
+    def test_set_credentials(self):
+        """Test that the set method does not erase previous keys."""
+        sample_creds = {"name": "sample creds name"}
+        sample_creds2 = {"name": "sample creds name 2"}
+        kr = keyring.Keyring()
+        yield kr.set_credentials("appname", sample_creds)
+        yield kr.set_credentials("appname", sample_creds2)
+
+        # pylint: disable=E1101
+        self.assertEqual(len(kr.service.collections["default"].items), 2)
+
+    @inlineCallbacks
+    def test_delete_credentials(self):
+        """Test that a given key is deleted."""
+        sample_creds = {"name": "sample creds name"}
+        kr = keyring.Keyring()
+        yield kr.set_credentials("appname", sample_creds)
+        yield kr.delete_credentials("appname")
+
+        # pylint: disable=E1101
+        self.assertEqual(len(kr.service.collections["default"].items), 1)
+
+    @inlineCallbacks
+    def test_get_credentials(self):
+        """Test that credentials are properly retrieved."""
+        sample_creds = {"name": "sample creds name"}
+        kr = keyring.Keyring()
+        yield kr.set_credentials("appname", sample_creds)
+
+        result = yield kr.get_credentials("appname")
+        self.assertEqual(result, sample_creds)
+
+    @inlineCallbacks
+    def test_get_credentials_migrating_token(self):
+        """Test that credentials are properly retrieved and migrated."""
+        sample_creds = {"name": "sample creds name"}
+        kr = keyring.Keyring()
+        self.patch(keyring, "get_token_name", keyring.get_old_token_name)
+        yield kr.set_credentials(APP_NAME, sample_creds)
+
+        result = yield kr.get_credentials(APP_NAME)
+        self.assertEqual(result, sample_creds)
+
+    @inlineCallbacks
+    def test_get_old_cred_found(self):
+        """The method returns a new set of creds if old creds are found."""
+        sample_oauth_token = "sample oauth token"
+        sample_oauth_secret = "sample oauth secret"
+        old_creds = {
+            "oauth_token": sample_oauth_token,
+            "oauth_token_secret": sample_oauth_secret,
+        }
+        u1kr = common_keyring.UbuntuOneOAuthKeyring()
+        yield u1kr.set_credentials(keyring.U1_APP_NAME, old_creds)
+
+        kr = keyring.Keyring()
+        result = yield kr.get_credentials(keyring.U1_APP_NAME)
+        self.assertIn("token", result)
+        self.assertEqual(result["token"], sample_oauth_token)
+        self.assertIn("token_secret", result)
+        self.assertEqual(result["token_secret"], sample_oauth_secret)
+
+    @inlineCallbacks
+    def test_get_old_cred_found_but_not_asked_for(self):
+        """Returns None if old creds are present but the appname is not U1"""
+        sample_oauth_token = "sample oauth token"
+        sample_oauth_secret = "sample oauth secret"
+        old_creds = {
+            "oauth_token": sample_oauth_token,
+            "oauth_token_secret": sample_oauth_secret,
+        }
+        u1kr = common_keyring.UbuntuOneOAuthKeyring()
+        yield u1kr.set_credentials(keyring.U1_APP_NAME, old_creds)
+
+        kr = keyring.Keyring()
+        result = yield kr.get_credentials("Software Center")
+        self.assertEqual(result, None)
+
+    @inlineCallbacks
+    def test_get_old_cred_not_found(self):
+        """The method returns None if no old nor new credentials found."""
+        kr = keyring.Keyring()
+        result = yield kr.get_credentials(keyring.U1_APP_NAME)
+        self.assertEqual(result, None)

=== added file 'ubuntu_sso/keyring/tests/test_windows.py'
--- ubuntu_sso/keyring/tests/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring/tests/test_windows.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,62 @@
+# -*- 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/>.
+"""Test the windows keyring implementation."""
+
+from json import dumps
+from mocker import MockerTestCase
+from twisted.internet.defer import inlineCallbacks
+
+from ubuntu_sso.keyring.windows import Keyring, USERNAME
+
+
+class TestWindowsKeyring(MockerTestCase):
+    """Test the windows keyring implementation."""
+
+    def setUp(self):
+        """Setup  tests."""
+        super(TestWindowsKeyring, self).setUp()
+        self.keyring_lib = self.mocker.mock()
+        self.keyring = Keyring(self.keyring_lib)
+
+    @inlineCallbacks
+    def test_set_credentials(self):
+        """Test setting the credentials."""
+        app_name = 'name'
+        password = dict(password='password')
+        self.keyring_lib.set_password(app_name, USERNAME, dumps(password))
+        self.mocker.replay()
+        yield self.keyring.set_credentials(app_name, password)
+
+    @inlineCallbacks
+    def test_get_credentials(self):
+        """Test deleting the credentials."""
+        app_name = 'name'
+        password = dict(password='password')
+        self.keyring_lib.get_password(app_name, USERNAME)
+        self.mocker.result(dumps(password))
+        self.mocker.replay()
+        result = yield self.keyring.get_credentials(app_name)
+        self.assertEqual(password, result)
+
+    @inlineCallbacks
+    def test_delete_credentials(self):
+        """Test deleting the credentials."""
+        app_name = 'name'
+        self.keyring_lib.delete_password(app_name, USERNAME)
+        self.mocker.replay()
+        result = yield self.keyring.delete_credentials(app_name)
+        self.assertTrue(result is None)

=== added file 'ubuntu_sso/keyring/windows.py'
--- ubuntu_sso/keyring/windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/keyring/windows.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,60 @@
+# -*- 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/>.
+"""Keyring implementation on Windows."""
+
+from json import loads, dumps
+
+from twisted.internet.threads import deferToThread
+
+USERNAME = 'ubuntu_sso'
+
+
+class Keyring(object):
+    """A Keyring for a given application name."""
+
+    def __init__(self, keyring=None):
+        """Create a new instance."""
+        if keyring is None:
+            import keyring as pykeyring
+            keyring = pykeyring
+        self.keyring = keyring
+
+    def set_credentials(self, app_name, cred):
+        """Set the credentials of the Ubuntu SSO item."""
+        # the windows keyring can only store a pair username-password
+        # so we store the data using ubuntu_sso as the user name. Then
+        # the cred will be stored as the string representation of the dict.
+        return deferToThread(self.keyring.set_password, app_name, USERNAME,
+                             dumps(cred))
+
+    def _get_credentials_obj(self, app_name):
+        """A dict with the credentials."""
+        creds = self.keyring.get_password(app_name, USERNAME)
+        return loads(creds)
+
+    def get_credentials(self, app_name):
+        """A deferred with the secret of the SSO item in a dictionary."""
+        return deferToThread(self._get_credentials_obj, app_name)
+
+    def delete_credentials(self, app_name):
+        """Delete a set of credentials from the keyring."""
+        # this call depends on a patch I sent to pykeyring. The patch has
+        # not landed as of version 0.5.1. If you have that version you can
+        # clone my patch in the following way:
+        # hg clone https://bitbucket.org/mandel/pykeyring-delete-password
+        # pylint: disable=E1103
+        return deferToThread(self.keyring.delete_password, app_name, USERNAME)

=== added directory 'ubuntu_sso/main'
=== removed file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2011-01-28 16:38:26 +0000
+++ ubuntu_sso/main.py	1970-01-01 00:00:00 +0000
@@ -1,604 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ubuntu_sso.main - main login handling interface
-#
-# Author: Natalia Bidart <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2009 Canonical Ltd.
-#
-# 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/>.
-"""Single Sign On login handler.
-
-An utility which accepts requests for Ubuntu Single Sign On login over D-Bus.
-
-The OAuth process is handled, including adding the OAuth access token to the
-local keyring.
-
-"""
-
-import os
-import threading
-import warnings
-
-import dbus.service
-
-from ubuntu_sso import (DBUS_ACCOUNT_PATH, DBUS_IFACE_USER_NAME,
-    DBUS_IFACE_CRED_NAME, DBUS_CREDENTIALS_IFACE, NO_OP)
-from ubuntu_sso.account import Account
-from ubuntu_sso.credentials import (Credentials, HELP_TEXT_KEY, PING_URL_KEY,
-    TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
-    SUCCESS_CB_KEY, ERROR_CB_KEY, DENIAL_CB_KEY,
-    ERROR_KEY, ERROR_DETAIL_KEY)
-from ubuntu_sso.keyring import get_token_name, U1_APP_NAME, Keyring
-from ubuntu_sso.logger import setup_logging
-
-
-# Disable the invalid name warning, as we have a lot of DBus style names
-# pylint: disable=C0103
-
-
-logger = setup_logging("ubuntu_sso.main")
-U1_PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
-TIMEOUT_INTERVAL = 10000  # 10 seconds
-
-
-class SSOLoginProcessor(Account):
-    """Login and register users using the Ubuntu Single Sign On service.
-
-    Alias classname to maintain backwards compatibility. DO NOT USE, use
-    ubuntu_sso.account.Account instead.
-    """
-
-    def __init__(self, sso_service_class=None):
-        """Create a new SSO Account manager."""
-        msg = 'Use ubuntu_sso.account.Account instead.'
-        warnings.warn(msg, DeprecationWarning)
-        super(SSOLoginProcessor, self).__init__(sso_service_class)
-
-
-def except_to_errdict(e):
-    """Turn an exception into a dictionary to return thru DBus."""
-    result = {
-        "errtype": e.__class__.__name__,
-    }
-    if len(e.args) == 0:
-        result["message"] = e.__class__.__doc__
-    elif isinstance(e.args[0], dict):
-        result.update(e.args[0])
-    elif isinstance(e.args[0], basestring):
-        result["message"] = e.args[0]
-
-    return result
-
-
-def blocking(f, app_name, result_cb, error_cb):
-    """Run f in a thread; return or throw an exception thru the callbacks."""
-    def _in_thread():
-        """The part that runs inside the thread."""
-        try:
-            result_cb(app_name, f())
-        except Exception, e:  # pylint: disable=W0703
-            msg = "Exception while running DBus blocking code in a thread:"
-            logger.exception(msg)
-            error_cb(app_name, except_to_errdict(e))
-    threading.Thread(target=_in_thread).start()
-
-
-class SSOLogin(dbus.service.Object):
-    """Login thru the Single Sign On service."""
-
-    # Operator not preceded by a space (fails with dbus decorators)
-    # pylint: disable=C0322
-
-    def __init__(self, bus_name, object_path=DBUS_ACCOUNT_PATH,
-                 sso_login_processor_class=Account,
-                 sso_service_class=None):
-        """Initiate the Login object."""
-        dbus.service.Object.__init__(self, object_path=object_path,
-                                     bus_name=bus_name)
-        self.sso_login_processor_class = sso_login_processor_class
-        self.processor = self.sso_login_processor_class(
-                                    sso_service_class=sso_service_class)
-
-    # generate_capcha signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def CaptchaGenerated(self, app_name, result):
-        """Signal thrown after the captcha is generated."""
-        logger.debug('SSOLogin: emitting CaptchaGenerated with app_name "%s" '
-                     'and result %r', app_name, result)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
-    def CaptchaGenerationError(self, app_name, error):
-        """Signal thrown when there's a problem generating the captcha."""
-        logger.debug('SSOLogin: emitting CaptchaGenerationError with '
-                     'app_name "%s" and error %r', app_name, error)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='ss')
-    def generate_captcha(self, app_name, filename):
-        """Call the matching method in the processor."""
-        def f():
-            """Inner function that will be run in a thread."""
-            return self.processor.generate_captcha(filename)
-        blocking(f, app_name, self.CaptchaGenerated,
-                 self.CaptchaGenerationError)
-
-    # register_user signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def UserRegistered(self, app_name, result):
-        """Signal thrown when the user is registered."""
-        logger.debug('SSOLogin: emitting UserRegistered with app_name "%s" '
-                     'and result %r', app_name, result)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
-    def UserRegistrationError(self, app_name, error):
-        """Signal thrown when there's a problem registering the user."""
-        logger.debug('SSOLogin: emitting UserRegistrationError with '
-                     'app_name "%s" and error %r', app_name, error)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='sssss')
-    def register_user(self, app_name, email, password,
-                      captcha_id, captcha_solution):
-        """Call the matching method in the processor."""
-        def f():
-            """Inner function that will be run in a thread."""
-            return self.processor.register_user(email, password,
-                                                captcha_id, captcha_solution)
-        blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
-
-    # login signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def LoggedIn(self, app_name, result):
-        """Signal thrown when the user is logged in."""
-        logger.debug('SSOLogin: emitting LoggedIn with app_name "%s" '
-                     'and result %r', app_name, result)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
-    def LoginError(self, app_name, error):
-        """Signal thrown when there is a problem in the login."""
-        logger.debug('SSOLogin: emitting LoginError with '
-                     'app_name "%s" and error %r', app_name, error)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def UserNotValidated(self, app_name, result):
-        """Signal thrown when the user is not validated."""
-        logger.debug('SSOLogin: emitting UserNotValidated with app_name "%s" '
-                     'and result %r', app_name, result)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='sss')
-    def login(self, app_name, email, password):
-        """Call the matching method in the processor."""
-        def f():
-            """Inner function that will be run in a thread."""
-            token_name = get_token_name(app_name)
-            logger.debug('login: token_name %r, email %r, password <hidden>.',
-                         token_name, email)
-            credentials = self.processor.login(email, password, token_name)
-            logger.debug('login returned not None credentials? %r.',
-                         credentials is not None)
-            return credentials
-
-        def success_cb(app_name, credentials):
-            """Login finished successfull."""
-            is_validated = self.processor.is_validated(credentials)
-            logger.debug('user is validated? %r.', is_validated)
-            if is_validated:
-                # pylint: disable=E1101
-                d = Keyring().set_credentials(app_name, credentials)
-                d.addCallback(lambda _: self.LoggedIn(app_name, email))
-                d.addErrback(lambda failure: \
-                             self.LoginError(app_name,
-                                             except_to_errdict(failure.value)))
-            else:
-                self.UserNotValidated(app_name, email)
-        blocking(f, app_name, success_cb, self.LoginError)
-
-    # validate_email signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def EmailValidated(self, app_name, result):
-        """Signal thrown after the email is validated."""
-        logger.debug('SSOLogin: emitting EmailValidated with app_name "%s" '
-                     'and result %r', app_name, result)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
-    def EmailValidationError(self, app_name, error):
-        """Signal thrown when there's a problem validating the email."""
-        logger.debug('SSOLogin: emitting EmailValidationError with '
-                     'app_name "%s" and error %r', app_name, error)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='ssss')
-    def validate_email(self, app_name, email, password, email_token):
-        """Call the matching method in the processor."""
-
-        def f():
-            """Inner function that will be run in a thread."""
-            token_name = get_token_name(app_name)
-            credentials = self.processor.validate_email(email, password,
-                                                      email_token, token_name)
-            return credentials
-
-        def success_cb(app_name, credentials):
-            """Validation finished successfully."""
-            # pylint: disable=E1101
-            d = Keyring().set_credentials(app_name, credentials)
-            d.addCallback(lambda _: self.EmailValidated(app_name, email))
-            failure_cb = lambda f: self.EmailValidationError(app_name, f.value)
-            d.addErrback(failure_cb)
-
-        blocking(f, app_name, success_cb, self.EmailValidationError)
-
-    # request_password_reset_token signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def PasswordResetTokenSent(self, app_name, result):
-        """Signal thrown when the token is succesfully sent."""
-        logger.debug('SSOLogin: emitting PasswordResetTokenSent with app_name '
-                     '"%s" and result %r', app_name, result)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
-    def PasswordResetError(self, app_name, error):
-        """Signal thrown when there's a problem sending the token."""
-        logger.debug('SSOLogin: emitting PasswordResetError with '
-                     'app_name "%s" and error %r', app_name, error)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='ss')
-    def request_password_reset_token(self, app_name, email):
-        """Call the matching method in the processor."""
-        def f():
-            """Inner function that will be run in a thread."""
-            return self.processor.request_password_reset_token(email)
-        blocking(f, app_name, self.PasswordResetTokenSent,
-                 self.PasswordResetError)
-
-    # set_new_password signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
-    def PasswordChanged(self, app_name, result):
-        """Signal thrown when the token is succesfully sent."""
-        logger.debug('SSOLogin: emitting PasswordChanged with app_name "%s" '
-                     'and result %r', app_name, result)
-
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
-    def PasswordChangeError(self, app_name, error):
-        """Signal thrown when there's a problem sending the token."""
-        logger.debug('SSOLogin: emitting PasswordChangeError with '
-                     'app_name "%s" and error %r', app_name, error)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='ssss')
-    def set_new_password(self, app_name, email, token, new_password):
-        """Call the matching method in the processor."""
-        def f():
-            """Inner function that will be run in a thread."""
-            return self.processor.set_new_password(email, token,
-                                                   new_password)
-        blocking(f, app_name, self.PasswordChanged, self.PasswordChangeError)
-
-
-class SSOCredentials(dbus.service.Object):
-    """DBus object that gets credentials, and login/registers if needed."""
-
-    # Operator not preceded by a space (fails with dbus decorators)
-    # pylint: disable=C0322
-
-    def __init__(self, *args, **kwargs):
-        dbus.service.Object.__init__(self, *args, **kwargs)
-        self.ping_url = os.environ.get('USSOC_PING_URL', U1_PING_URL)
-
-    def _process_error(self, app_name, error_dict):
-        """Process the 'error_dict' and emit CredentialsError."""
-        msg = error_dict.get(ERROR_KEY, 'No error message given.')
-        detail = error_dict.get(ERROR_DETAIL_KEY, 'No detailed error given.')
-        self.CredentialsError(app_name, msg, detail)
-
-    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
-    def AuthorizationDenied(self, app_name):
-        """Signal thrown when the user denies the authorization."""
-        logger.info('SSOCredentials: emitting AuthorizationDenied with '
-                    'app_name "%s"', app_name)
-
-    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Signal thrown when the credentials are found."""
-        logger.info('SSOCredentials: emitting CredentialsFound with '
-                    'app_name "%s"', app_name)
-
-    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sss")
-    def CredentialsError(self, app_name, error_message, detailed_error):
-        """Signal thrown when there is a problem finding the credentials."""
-        logger.error('SSOCredentials: emitting CredentialsError with app_name '
-                     '"%s" and error_message %r', app_name, error_message)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="s", out_signature="a{ss}",
-                         async_callbacks=("callback", "errback"))
-    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Get the credentials from the keyring or {} if not there."""
-
-        def log_result(result):
-            """Log the result and continue."""
-            logger.info('find_credentials: app_name "%s", result is {}? %s',
-                        app_name, result == {})
-            return result
-
-        d = Credentials(app_name=app_name).find_credentials()
-        # pylint: disable=E1101
-        d.addCallback(log_result)
-        d.addCallbacks(callback, errback)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx", out_signature="")
-    def login_or_register_to_get_credentials(self, app_name,
-                                             terms_and_conditions_url,
-                                             help_text, window_id):
-        """Get credentials if found else prompt GUI to login or register.
-
-        'app_name' will be displayed in the GUI.
-        'terms_and_conditions_url' will be the URL pointing to T&C.
-        'help_text' is an explanatory text for the end-users, will be shown
-         below the headers.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        ping_url = self.ping_url if app_name == U1_APP_NAME else None
-        obj = Credentials(app_name=app_name, ping_url=ping_url,
-                          tc_url=terms_and_conditions_url,
-                          help_text=help_text, window_id=window_id,
-                          success_cb=self.CredentialsFound,
-                          error_cb=self._process_error,
-                          denial_cb=self.AuthorizationDenied)
-        obj.register()
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="ssx", out_signature="")
-    def login_to_get_credentials(self, app_name, help_text, window_id):
-        """Get credentials if found else prompt GUI just to login
-
-        'app_name' will be displayed in the GUI.
-        'help_text' is an explanatory text for the end-users, will be shown
-         before the login fields.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        ping_url = self.ping_url if app_name == U1_APP_NAME else None
-        obj = Credentials(app_name=app_name, ping_url=ping_url, tc_url=None,
-                          help_text=help_text, window_id=window_id,
-                          success_cb=self.CredentialsFound,
-                          error_cb=self._process_error,
-                          denial_cb=self.AuthorizationDenied)
-        obj.login()
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature='s', out_signature='',
-                         async_callbacks=("callback", "errback"))
-    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Clear the token for an application from the keyring.
-
-        'app_name' is the name of the application.
-        """
-        d = Credentials(app_name=app_name).clear_credentials()
-        # pylint: disable=E1101
-        d.addCallbacks(lambda _: callback(), errback)
-
-
-class CredentialsManagement(dbus.service.Object):
-    """DBus object that manages credentials.
-
-    Every exposed method in this class requires one mandatory argument:
-
-        - 'app_name': the name of the application. Will be displayed in the
-        GUI header, plus it will be used to find/build/clear tokens.
-
-    And accepts another parameter named 'args', which is a dictionary that
-    can contain the following:
-
-        - 'help_text': an explanatory text for the end-users, will be
-        shown below the header. This is an optional free text field.
-
-        - 'ping_url': the url to open after successful token retrieval. If
-        defined, the email will be attached to the url and will be pinged
-        with a OAuth-signed request.
-
-        - 'tc_url': the link to the Terms and Conditions page. If defined,
-        the checkbox to agree to the terms will link to it.
-
-        - 'window_id': the id of the window which will be set as a parent
-        of the GUI. If not defined, no parent will be set.
-
-    """
-
-    def __init__(self, timeout_func, shutdown_func, *args, **kwargs):
-        super(CredentialsManagement, self).__init__(*args, **kwargs)
-        self._ref_count = 0
-        self.timeout_func = timeout_func
-        self.shutdown_func = shutdown_func
-
-    # Operator not preceded by a space (fails with dbus decorators)
-    # pylint: disable=C0322
-
-    valid_keys = (HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY,
-                  UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY)
-
-    def _parse_args(self, args):
-        """Retrieve values from the generic param 'args'."""
-        result = dict(i for i in args.iteritems() if i[0] in self.valid_keys)
-        result[WINDOW_ID_KEY] = int(args.get(WINDOW_ID_KEY, 0))
-        result[SUCCESS_CB_KEY] = self.CredentialsFound
-        result[ERROR_CB_KEY] = self.CredentialsError
-        result[DENIAL_CB_KEY] = self.AuthorizationDenied
-        return result
-
-    def _process_failure(self, failure, app_name):
-        """Process the 'failure' and emit CredentialsError."""
-        self.CredentialsError(app_name, except_to_errdict(failure.value))
-
-    def _get_ref_count(self):
-        """Get value of ref_count."""
-        return self._ref_count
-
-    def _set_ref_count(self, new_value):
-        """Set a new value to ref_count."""
-        logger.debug('ref_count is %r, changing value to %r.',
-                     self._ref_count, new_value)
-        if new_value < 0:
-            self._ref_count = 0
-            msg = 'Attempting to decrease ref_count to a negative value (%r).'
-            logger.warning(msg, new_value)
-        else:
-            self._ref_count = new_value
-
-        if self._ref_count == 0:
-            logger.debug('Setting up timer with %r (%r, %r).',
-                         self.timeout_func, TIMEOUT_INTERVAL, self.shutdown)
-            self.timeout_func(TIMEOUT_INTERVAL, self.shutdown)
-
-    ref_count = property(fget=_get_ref_count, fset=_set_ref_count)
-
-    def shutdown(self):
-        """If no ongoing requests, call self.shutdown_func."""
-        logger.debug('shutdown!, ref_count is %r.', self._ref_count)
-        if self._ref_count == 0:
-            logger.info('Shutting down, calling %r.', self.shutdown_func)
-            self.shutdown_func()
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
-    def AuthorizationDenied(self, app_name):
-        """Signal thrown when the user denies the authorization."""
-        self.ref_count -= 1
-        logger.info('%s: emitting AuthorizationDenied with app_name "%s".',
-                    self.__class__.__name__, app_name)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
-    def CredentialsFound(self, app_name, credentials):
-        """Signal thrown when the credentials are found."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsFound with app_name "%s".',
-                    self.__class__.__name__, app_name)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
-    def CredentialsNotFound(self, app_name):
-        """Signal thrown when the credentials are not found."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsNotFound with app_name "%s".',
-                    self.__class__.__name__, app_name)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
-    def CredentialsCleared(self, app_name):
-        """Signal thrown when the credentials were cleared."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsCleared with app_name "%s".',
-                    self.__class__.__name__, app_name)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
-    def CredentialsStored(self, app_name):
-        """Signal thrown when the credentials were cleared."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsStored with app_name "%s".',
-                    self.__class__.__name__, app_name)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
-    def CredentialsError(self, app_name, error_dict):
-        """Signal thrown when there is a problem getting the credentials."""
-        self.ref_count -= 1
-        logger.error('%s: emitting CredentialsError with app_name "%s" and '
-                     'error_dict %r.', self.__class__.__name__, app_name,
-                     error_dict)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def find_credentials(self, app_name, args):
-        """Look for the credentials for an application.
-
-        - 'app_name': the name of the application which credentials are
-        going to be removed.
-
-        - 'args' is a dictionary, currently not used.
-
-        """
-        self.ref_count += 1
-
-        def success_cb(credentials):
-            """Find credentials and notify using signals."""
-            if credentials is not None and len(credentials) > 0:
-                self.CredentialsFound(app_name, credentials)
-            else:
-                self.CredentialsNotFound(app_name)
-
-        obj = Credentials(app_name)
-        d = obj.find_credentials()
-        # pylint: disable=E1101
-        d.addCallback(success_cb)
-        d.addErrback(self._process_failure, app_name)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def clear_credentials(self, app_name, args):
-        """Clear the credentials for an application.
-
-        - 'app_name': the name of the application which credentials are
-        going to be removed.
-
-        - 'args' is a dictionary, currently not used.
-
-        """
-        self.ref_count += 1
-
-        obj = Credentials(app_name)
-        d = obj.clear_credentials()
-        # pylint: disable=E1101
-        d.addCallback(lambda _: self.CredentialsCleared(app_name))
-        d.addErrback(self._process_failure, app_name)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def store_credentials(self, app_name, args):
-        """Store the token for an application.
-
-        - 'app_name': the name of the application which credentials are
-        going to be stored.
-
-        - 'args' is the dictionary holding the credentials. Needs to provide
-        the following mandatory keys: 'token', 'token_key', 'consumer_key',
-        'consumer_secret'.
-
-        """
-        self.ref_count += 1
-
-        obj = Credentials(app_name)
-        d = obj.store_credentials(args)
-        # pylint: disable=E1101
-        d.addCallback(lambda _: self.CredentialsStored(app_name))
-        d.addErrback(self._process_failure, app_name)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def register(self, app_name, args):
-        """Get credentials if found else prompt GUI to register."""
-        self.ref_count += 1
-
-        obj = Credentials(app_name, **self._parse_args(args))
-        obj.register()
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def login(self, app_name, args):
-        """Get credentials if found else prompt GUI to login."""
-        self.ref_count += 1
-
-        obj = Credentials(app_name, **self._parse_args(args))
-        obj.login()

=== added file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/__init__.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,375 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia Bidart <[e-mail]>
+# Author: Alejandro J. Cura <[e-mail]>
+# 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/>.
+"""Main object implementations."""
+
+import os
+import sys
+import warnings
+
+from ubuntu_sso import NO_OP
+from ubuntu_sso.account import Account
+from ubuntu_sso.credentials import (Credentials, HELP_TEXT_KEY, PING_URL_KEY,
+    TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
+    SUCCESS_CB_KEY, ERROR_CB_KEY, DENIAL_CB_KEY)
+from ubuntu_sso.keyring import get_token_name, U1_APP_NAME, Keyring
+from ubuntu_sso.logger import setup_logging
+
+logger = setup_logging("ubuntu_sso.main")
+U1_PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+
+
+class SSOLoginProcessor(Account):
+    """Login and register users using the Ubuntu Single Sign On service.
+
+    Alias classname to maintain backwards compatibility. DO NOT USE, use
+    ubuntu_sso.account.Account instead.
+    """
+
+    def __init__(self, sso_service_class=None):
+        """Create a new SSO Account manager."""
+        msg = 'Use ubuntu_sso.account.Account instead.'
+        warnings.warn(msg, DeprecationWarning)
+        super(SSOLoginProcessor, self).__init__(sso_service_class)
+
+
+def except_to_errdict(e):
+    """Turn an exception into a dictionary to return thru DBus."""
+    result = {
+        "errtype": e.__class__.__name__,
+    }
+    if len(e.args) == 0:
+        result["message"] = e.__class__.__doc__
+    elif isinstance(e.args[0], dict):
+        result.update(e.args[0])
+    elif isinstance(e.args[0], basestring):
+        result["message"] = e.args[0]
+
+    return result
+
+
+class SSOLoginRoot(object):
+    """Login thru the Single Sign On service."""
+
+    def __init__(self, sso_login_processor_class=Account,
+                 sso_service_class=None):
+        """Initiate the Login object."""
+        self.sso_login_processor_class = sso_login_processor_class
+        self.processor = self.sso_login_processor_class(
+                                    sso_service_class=sso_service_class)
+
+    def generate_captcha(self, app_name, filename, thread_execute, result_cb,
+                         error_cb):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.generate_captcha(filename)
+        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):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.register_user(email, password, name,
+                                                captcha_id, captcha_solution)
+        thread_execute(f, app_name, result_cb, error_cb)
+
+    def login(self, app_name, email, password, thread_execute, result_cb,
+              error_cb, not_validated_cb):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            token_name = get_token_name(app_name)
+            logger.debug('login: token_name %r, email %r, password <hidden>.',
+                         token_name, email)
+            credentials = self.processor.login(email, password, token_name)
+            logger.debug('login returned not None credentials? %r.',
+                         credentials is not None)
+            return credentials
+
+        def success_cb(app_name, credentials):
+            """Login finished successfull."""
+            is_validated = self.processor.is_validated(credentials)
+            logger.debug('user is validated? %r.', is_validated)
+            if is_validated:
+                # pylint: disable=E1101
+                d = Keyring().set_credentials(app_name, credentials)
+                d.addCallback(lambda _: result_cb(app_name, email))
+                d.addErrback(lambda failure: \
+                             error_cb(app_name,
+                                      except_to_errdict(failure.value)))
+            else:
+                not_validated_cb(app_name, email)
+        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):
+        """Call the matching method in the processor."""
+
+        def f():
+            """Inner function that will be run in a thread."""
+            token_name = get_token_name(app_name)
+            credentials = self.processor.validate_email(email, password,
+                                                      email_token, token_name)
+            return credentials
+
+        def success_cb(app_name, credentials):
+            """Validation finished successfully."""
+            # pylint: disable=E1101
+            d = Keyring().set_credentials(app_name, credentials)
+            d.addCallback(lambda _: result_cb(app_name, email))
+            failure_cb = lambda f: error_cb(app_name, f.value)
+            d.addErrback(failure_cb)
+
+        thread_execute(f, app_name, success_cb, error_cb)
+
+    def request_password_reset_token(self, app_name, email, thread_execute,
+                                     result_cb, error_cb):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.request_password_reset_token(email)
+        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):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.set_new_password(email, token,
+                                                   new_password)
+        thread_execute(f, app_name, result_cb, error_cb)
+
+
+class SSOCredentialsRoot(object):
+    """Object that gets credentials, and login/registers if needed."""
+
+    def __init__(self):
+        self.ping_url = os.environ.get('USSOC_PING_URL', U1_PING_URL)
+
+    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
+        """Get the credentials from the keyring or {} if not there."""
+
+        def log_result(result):
+            """Log the result and continue."""
+            logger.info('find_credentials: app_name "%s", result is {}? %s',
+                        app_name, result == {})
+            return result
+
+        d = Credentials(app_name=app_name).find_credentials()
+        # pylint: disable=E1101
+        d.addCallback(log_result)
+        d.addCallbacks(callback, errback)
+
+    def login_or_register_to_get_credentials(self, app_name,
+                                             terms_and_conditions_url,
+                                             help_text, window_id,
+                                             success_cb, error_cb, denial_cb):
+        """Get credentials if found else prompt GUI to login or register.
+
+        'app_name' will be displayed in the GUI.
+        'terms_and_conditions_url' will be the URL pointing to T&C.
+        'help_text' is an explanatory text for the end-users, will be shown
+         below the headers.
+        'window_id' is the id of the window which will be set as a parent of
+         the GUI. If 0, no parent will be set.
+
+        """
+        ping_url = self.ping_url if app_name == U1_APP_NAME else None
+        obj = Credentials(app_name=app_name, ping_url=ping_url,
+                          tc_url=terms_and_conditions_url,
+                          help_text=help_text, window_id=window_id,
+                          success_cb=success_cb, error_cb=error_cb,
+                          denial_cb=denial_cb)
+        obj.register()
+
+    def login_to_get_credentials(self, app_name, help_text, window_id,
+                                success_cb, error_cb, denial_cb):
+        """Get credentials if found else prompt GUI just to login
+
+        'app_name' will be displayed in the GUI.
+        'help_text' is an explanatory text for the end-users, will be shown
+         before the login fields.
+        'window_id' is the id of the window which will be set as a parent of
+         the GUI. If 0, no parent will be set.
+
+        """
+        ping_url = self.ping_url if app_name == U1_APP_NAME else None
+        obj = Credentials(app_name=app_name, ping_url=ping_url, tc_url=None,
+                          help_text=help_text, window_id=window_id,
+                          success_cb=success_cb, error_cb=error_cb,
+                          denial_cb=denial_cb)
+        obj.login()
+
+    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
+        """Clear the token for an application from the keyring.
+
+        'app_name' is the name of the application.
+        """
+        d = Credentials(app_name=app_name).clear_credentials()
+        # pylint: disable=E1101
+        d.addCallbacks(lambda _: callback(), errback)
+
+
+class CredentialsManagementRoot(object):
+    """Object that manages credentials.
+
+    Every exposed method in this class requires one mandatory argument:
+
+        - 'app_name': the name of the application. Will be displayed in the
+        GUI header, plus it will be used to find/build/clear tokens.
+
+    And accepts another parameter named 'args', which is a dictionary that
+    can contain the following:
+
+        - 'help_text': an explanatory text for the end-users, will be
+        shown below the header. This is an optional free text field.
+
+        - 'ping_url': the url to open after successful token retrieval. If
+        defined, the email will be attached to the url and will be pinged
+        with a OAuth-signed request.
+
+        - 'tc_url': the link to the Terms and Conditions page. If defined,
+        the checkbox to agree to the terms will link to it.
+
+        - 'window_id': the id of the window which will be set as a parent
+        of the GUI. If not defined, no parent will be set.
+
+    """
+
+    def __init__(self, found_cb, error_cb, denied_cb, *args, **kwargs):
+        """Create a new instance.
+
+        - 'found_cb' is a callback that will be executed when the credentials
+        were found.
+
+        - 'error_cb' is a callback that will be executed when there was an
+        error getting the credentials.
+
+        - 'denied_cb' is a callback that will be executed when the user denied
+        the use of the crendetials.
+
+        """
+        super(CredentialsManagementRoot, self).__init__(*args, **kwargs)
+        self.found_cb = found_cb
+        self.error_cb = error_cb
+        self.denied_cb = denied_cb
+
+    valid_keys = (HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY,
+                  UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY)
+
+    def _parse_args(self, args):
+        """Retrieve values from the generic param 'args'."""
+        result = dict(i for i in args.iteritems() if i[0] in self.valid_keys)
+        result[WINDOW_ID_KEY] = int(args.get(WINDOW_ID_KEY, 0))
+        result[SUCCESS_CB_KEY] = self.found_cb
+        result[ERROR_CB_KEY] = self.error_cb
+        result[DENIAL_CB_KEY] = self.denied_cb
+        return result
+
+    def find_credentials(self, app_name, args, success_cb, error_cb):
+        """Look for the credentials for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be removed.
+
+        - 'args' is a dictionary, currently not used.
+
+        - 'success_cb' is a callback that will be execute if the operation was
+        a success.
+
+        - 'error_cb' is a callback that will be executed if the operation had
+        an error.
+
+        """
+
+        obj = Credentials(app_name)
+        d = obj.find_credentials()
+        # pylint: disable=E1101
+        d.addCallback(success_cb)
+        d.addErrback(error_cb, app_name)
+
+    def clear_credentials(self, app_name, args, success_cb, error_cb):
+        """Clear the credentials for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be removed.
+
+        - 'args' is a dictionary, currently not used.
+
+        - 'success_cb' is a callback that will be execute if the operation was
+        a success.
+
+        - 'error_cb' is a callback that will be executed if the operation had
+        an error.
+
+        """
+
+        obj = Credentials(app_name)
+        d = obj.clear_credentials()
+        # pylint: disable=E1101
+        d.addCallback(success_cb)
+        d.addErrback(error_cb, app_name)
+
+    def store_credentials(self, app_name, args, success_cb, error_cb):
+        """Store the token for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be stored.
+
+        - 'args' is the dictionary holding the credentials. Needs to provide
+        the following mandatory keys: 'token', 'token_key', 'consumer_key',
+        'consumer_secret'.
+
+        - 'success_cb' is a callback that will be execute if the operation was
+        a success.
+
+        - 'error_cb' is a callback that will be executed if the operation had
+        an error.
+        """
+
+        obj = Credentials(app_name)
+        d = obj.store_credentials(args)
+        # pylint: disable=E1101
+        d.addCallback(success_cb)
+        d.addErrback(error_cb, app_name)
+
+    def register(self, app_name, args):
+        """Get credentials if found else prompt GUI to register."""
+        obj = Credentials(app_name, **self._parse_args(args))
+        obj.register()
+
+    def login(self, app_name, args):
+        """Get credentials if found else prompt GUI to login."""
+        obj = Credentials(app_name, **self._parse_args(args))
+        obj.login()
+
+# pylint: disable=C0103
+SSOLogin = None
+SSOCredentials = None
+CredentialsManagement = None
+
+if sys.platform == 'win32':
+    pass
+else:
+    from ubuntu_sso.main import linux
+    SSOLogin = linux.SSOLogin
+    SSOCredentials = linux.SSOCredentials
+    CredentialsManagement = linux.CredentialsManagement

=== added file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/linux.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,486 @@
+# -*- coding: utf-8 -*-
+#
+# ubuntu_sso.main - main login handling interface
+#
+# Author: Natalia Bidart <[e-mail]>
+# Author: Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2009 Canonical Ltd.
+#
+# 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/>.
+"""Single Sign On login handler.
+
+An utility which accepts requests for Ubuntu Single Sign On login over D-Bus.
+
+The OAuth process is handled, including adding the OAuth access token to the
+local keyring.
+
+"""
+
+import threading
+
+import dbus.service
+
+from ubuntu_sso import (DBUS_ACCOUNT_PATH, DBUS_IFACE_USER_NAME,
+    DBUS_IFACE_CRED_NAME, DBUS_CREDENTIALS_IFACE, NO_OP)
+from ubuntu_sso.account import Account
+from ubuntu_sso.credentials import ERROR_KEY, ERROR_DETAIL_KEY
+from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.main import (CredentialsManagementRoot, SSOLoginRoot,
+                             SSOCredentialsRoot, except_to_errdict)
+
+
+# Disable the invalid name warning, as we have a lot of DBus style names
+# pylint: disable=C0103
+
+
+logger = setup_logging("ubuntu_sso.main")
+TIMEOUT_INTERVAL = 10000  # 10 seconds
+
+
+def blocking(f, app_name, result_cb, error_cb):
+    """Run f in a thread; return or throw an exception thru the callbacks."""
+    def _in_thread():
+        """The part that runs inside the thread."""
+        try:
+            result_cb(app_name, f())
+        except Exception, e:  # pylint: disable=W0703
+            msg = "Exception while running DBus blocking code in a thread:"
+            logger.exception(msg)
+            error_cb(app_name, except_to_errdict(e))
+    threading.Thread(target=_in_thread).start()
+
+
+class SSOLogin(dbus.service.Object):
+    """Login thru the Single Sign On service."""
+
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
+    def __init__(self, bus_name, object_path=DBUS_ACCOUNT_PATH,
+                 sso_login_processor_class=Account,
+                 sso_service_class=None):
+        """Initiate the Login object."""
+        dbus.service.Object.__init__(self, object_path=object_path,
+                                     bus_name=bus_name)
+        self.root = SSOLoginRoot(sso_login_processor_class, sso_service_class)
+
+    # generate_capcha signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def CaptchaGenerated(self, app_name, result):
+        """Signal thrown after the captcha is generated."""
+        logger.debug('SSOLogin: emitting CaptchaGenerated with app_name "%s" '
+                     'and result %r', app_name, result)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def CaptchaGenerationError(self, app_name, error):
+        """Signal thrown when there's a problem generating the captcha."""
+        logger.debug('SSOLogin: emitting CaptchaGenerationError with '
+                     'app_name "%s" and error %r', app_name, error)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ss')
+    def generate_captcha(self, app_name, filename):
+        """Call the matching method in the processor."""
+        self.root.generate_captcha(app_name, filename, blocking,
+                                   self.CaptchaGenerated,
+                                   self.CaptchaGenerationError)
+
+    # register_user signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def UserRegistered(self, app_name, result):
+        """Signal thrown when the user is registered."""
+        logger.debug('SSOLogin: emitting UserRegistered with app_name "%s" '
+                     'and result %r', app_name, result)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def UserRegistrationError(self, app_name, error):
+        """Signal thrown when there's a problem registering the user."""
+        logger.debug('SSOLogin: emitting UserRegistrationError with '
+                     'app_name "%s" and error %r', app_name, error)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssssss')
+    def register_user(self, app_name, email, password, name,
+                      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,
+                                self.UserRegistered,
+                                self.UserRegistrationError)
+
+    # login signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def LoggedIn(self, app_name, result):
+        """Signal thrown when the user is logged in."""
+        logger.debug('SSOLogin: emitting LoggedIn with app_name "%s" '
+                     'and result %r', app_name, result)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def LoginError(self, app_name, error):
+        """Signal thrown when there is a problem in the login."""
+        logger.debug('SSOLogin: emitting LoginError with '
+                     'app_name "%s" and error %r', app_name, error)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def UserNotValidated(self, app_name, result):
+        """Signal thrown when the user is not validated."""
+        logger.debug('SSOLogin: emitting UserNotValidated with app_name "%s" '
+                     'and result %r', app_name, result)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         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.LoginError, self.UserNotValidated)
+
+    # validate_email signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def EmailValidated(self, app_name, result):
+        """Signal thrown after the email is validated."""
+        logger.debug('SSOLogin: emitting EmailValidated with app_name "%s" '
+                     'and result %r', app_name, result)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def EmailValidationError(self, app_name, error):
+        """Signal thrown when there's a problem validating the email."""
+        logger.debug('SSOLogin: emitting EmailValidationError with '
+                     'app_name "%s" and error %r', app_name, error)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssss')
+    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.EmailValidationError)
+
+    # request_password_reset_token signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def PasswordResetTokenSent(self, app_name, result):
+        """Signal thrown when the token is succesfully sent."""
+        logger.debug('SSOLogin: emitting PasswordResetTokenSent with app_name '
+                     '"%s" and result %r', app_name, result)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def PasswordResetError(self, app_name, error):
+        """Signal thrown when there's a problem sending the token."""
+        logger.debug('SSOLogin: emitting PasswordResetError with '
+                     'app_name "%s" and error %r', app_name, error)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ss')
+    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.PasswordResetTokenSent,
+                                               self.PasswordResetError)
+
+    # set_new_password signals
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def PasswordChanged(self, app_name, result):
+        """Signal thrown when the token is succesfully sent."""
+        logger.debug('SSOLogin: emitting PasswordChanged with app_name "%s" '
+                     'and result %r', app_name, result)
+
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def PasswordChangeError(self, app_name, error):
+        """Signal thrown when there's a problem sending the token."""
+        logger.debug('SSOLogin: emitting PasswordChangeError with '
+                     'app_name "%s" and error %r', app_name, error)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='ssss')
+    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.PasswordChangeError)
+
+
+class SSOCredentials(dbus.service.Object):
+    """DBus object that gets credentials, and login/registers if needed."""
+
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
+    def __init__(self, *args, **kwargs):
+        dbus.service.Object.__init__(self, *args, **kwargs)
+        self.root = SSOCredentialsRoot()
+
+    def _process_error(self, app_name, error_dict):
+        """Process the 'error_dict' and emit CredentialsError."""
+        msg = error_dict.get(ERROR_KEY, 'No error message given.')
+        detail = error_dict.get(ERROR_DETAIL_KEY, 'No detailed error given.')
+        self.CredentialsError(app_name, msg, detail)
+
+    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
+    def AuthorizationDenied(self, app_name):
+        """Signal thrown when the user denies the authorization."""
+        logger.info('SSOCredentials: emitting AuthorizationDenied with '
+                    'app_name "%s"', app_name)
+
+    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sa{ss}")
+    def CredentialsFound(self, app_name, credentials):
+        """Signal thrown when the credentials are found."""
+        logger.info('SSOCredentials: emitting CredentialsFound with '
+                    'app_name "%s"', app_name)
+
+    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sss")
+    def CredentialsError(self, app_name, error_message, detailed_error):
+        """Signal thrown when there is a problem finding the credentials."""
+        logger.error('SSOCredentials: emitting CredentialsError with app_name '
+                     '"%s" and error_message %r', app_name, error_message)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
+                         in_signature="s", out_signature="a{ss}",
+                         async_callbacks=("callback", "errback"))
+    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
+        """Get the credentials from the keyring or {} if not there."""
+        self.root.find_credentials(app_name, callback, errback)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
+                         in_signature="sssx", out_signature="")
+    def login_or_register_to_get_credentials(self, app_name,
+                                             terms_and_conditions_url,
+                                             help_text, window_id):
+        """Get credentials if found else prompt GUI to login or register.
+
+        'app_name' will be displayed in the GUI.
+        'terms_and_conditions_url' will be the URL pointing to T&C.
+        'help_text' is an explanatory text for the end-users, will be shown
+         below the headers.
+        'window_id' is the id of the window which will be set as a parent of
+         the GUI. If 0, no parent will be set.
+
+        """
+        self.root.login_or_register_to_get_credentials(app_name,
+                                                     terms_and_conditions_url,
+                                                     help_text, window_id,
+                                                     self.CredentialsFound,
+                                                     self._process_error,
+                                                     self.AuthorizationDenied)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
+                         in_signature="ssx", out_signature="")
+    def login_to_get_credentials(self, app_name, help_text, window_id):
+        """Get credentials if found else prompt GUI just to login
+
+        'app_name' will be displayed in the GUI.
+        'help_text' is an explanatory text for the end-users, will be shown
+         before the login fields.
+        'window_id' is the id of the window which will be set as a parent of
+         the GUI. If 0, no parent will be set.
+
+        """
+        self.root.login_to_get_credentials(app_name, help_text, window_id,
+                                           self.CredentialsFound,
+                                           self._process_error,
+                                           self.AuthorizationDenied)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
+                         in_signature='s', out_signature='',
+                         async_callbacks=("callback", "errback"))
+    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
+        """Clear the token for an application from the keyring.
+
+        'app_name' is the name of the application.
+        """
+        self.root.clear_token(app_name, callback, errback)
+
+
+class CredentialsManagement(dbus.service.Object):
+    """DBus object that manages credentials.
+
+    Every exposed method in this class requires one mandatory argument:
+
+        - 'app_name': the name of the application. Will be displayed in the
+        GUI header, plus it will be used to find/build/clear tokens.
+
+    And accepts another parameter named 'args', which is a dictionary that
+    can contain the following:
+
+        - 'help_text': an explanatory text for the end-users, will be
+        shown below the header. This is an optional free text field.
+
+        - 'ping_url': the url to open after successful token retrieval. If
+        defined, the email will be attached to the url and will be pinged
+        with a OAuth-signed request.
+
+        - 'tc_url': the link to the Terms and Conditions page. If defined,
+        the checkbox to agree to the terms will link to it.
+
+        - 'window_id': the id of the window which will be set as a parent
+        of the GUI. If not defined, no parent will be set.
+
+    """
+
+    def __init__(self, timeout_func, shutdown_func, *args, **kwargs):
+        super(CredentialsManagement, self).__init__(*args, **kwargs)
+        self._ref_count = 0
+        self.timeout_func = timeout_func
+        self.shutdown_func = shutdown_func
+        self.root = CredentialsManagementRoot(self.CredentialsFound,
+                                              self.CredentialsError,
+                                              self.AuthorizationDenied)
+
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
+    def _process_failure(self, failure, app_name):
+        """Process the 'failure' and emit CredentialsError."""
+        self.CredentialsError(app_name, except_to_errdict(failure.value))
+
+    def _get_ref_count(self):
+        """Get value of ref_count."""
+        return self._ref_count
+
+    def _set_ref_count(self, new_value):
+        """Set a new value to ref_count."""
+        logger.debug('ref_count is %r, changing value to %r.',
+                     self._ref_count, new_value)
+        if new_value < 0:
+            self._ref_count = 0
+            msg = 'Attempting to decrease ref_count to a negative value (%r).'
+            logger.warning(msg, new_value)
+        else:
+            self._ref_count = new_value
+
+        if self._ref_count == 0:
+            logger.debug('Setting up timer with %r (%r, %r).',
+                         self.timeout_func, TIMEOUT_INTERVAL, self.shutdown)
+            self.timeout_func(TIMEOUT_INTERVAL, self.shutdown)
+
+    ref_count = property(fget=_get_ref_count, fset=_set_ref_count)
+
+    def shutdown(self):
+        """If no ongoing requests, call self.shutdown_func."""
+        logger.debug('shutdown!, ref_count is %r.', self._ref_count)
+        if self._ref_count == 0:
+            logger.info('Shutting down, calling %r.', self.shutdown_func)
+            self.shutdown_func()
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def AuthorizationDenied(self, app_name):
+        """Signal thrown when the user denies the authorization."""
+        self.ref_count -= 1
+        logger.info('%s: emitting AuthorizationDenied with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsFound(self, app_name, credentials):
+        """Signal thrown when the credentials are found."""
+        self.ref_count -= 1
+        logger.info('%s: emitting CredentialsFound with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsNotFound(self, app_name):
+        """Signal thrown when the credentials are not found."""
+        self.ref_count -= 1
+        logger.info('%s: emitting CredentialsNotFound with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsCleared(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+        self.ref_count -= 1
+        logger.info('%s: emitting CredentialsCleared with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsStored(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+        self.ref_count -= 1
+        logger.info('%s: emitting CredentialsStored with app_name "%s".',
+                    self.__class__.__name__, app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsError(self, app_name, error_dict):
+        """Signal thrown when there is a problem getting the credentials."""
+        self.ref_count -= 1
+        logger.error('%s: emitting CredentialsError with app_name "%s" and '
+                     'error_dict %r.', self.__class__.__name__, app_name,
+                     error_dict)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def find_credentials(self, app_name, args):
+        """Look for the credentials for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be removed.
+
+        - 'args' is a dictionary, currently not used.
+
+        """
+        self.ref_count += 1
+
+        def success_cb(credentials):
+            """Find credentials and notify using signals."""
+            if credentials is not None and len(credentials) > 0:
+                self.CredentialsFound(app_name, credentials)
+            else:
+                self.CredentialsNotFound(app_name)
+
+        self.root.find_credentials(app_name, args, success_cb,
+                                   self._process_failure)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def clear_credentials(self, app_name, args):
+        """Clear the credentials for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be removed.
+
+        - 'args' is a dictionary, currently not used.
+
+        """
+        self.ref_count += 1
+        self.root.clear_credentials(app_name, args,
+                                lambda _: self.CredentialsCleared(app_name),
+                                self._process_failure)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def store_credentials(self, app_name, args):
+        """Store the token for an application.
+
+        - 'app_name': the name of the application which credentials are
+        going to be stored.
+
+        - 'args' is the dictionary holding the credentials. Needs to provide
+        the following mandatory keys: 'token', 'token_key', 'consumer_key',
+        'consumer_secret'.
+
+        """
+        self.ref_count += 1
+        self.root.store_credentials(app_name, args,
+                                lambda _: self.CredentialsStored(app_name),
+                                self._process_failure)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def register(self, app_name, args):
+        """Get credentials if found else prompt GUI to register."""
+        self.ref_count += 1
+        self.root.register(app_name, args)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def login(self, app_name, args):
+        """Get credentials if found else prompt GUI to login."""
+        self.ref_count += 1
+        self.root.login(app_name, args)

=== added directory 'ubuntu_sso/main/tests'
=== added file 'ubuntu_sso/main/tests/__init__.py'
--- ubuntu_sso/main/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/tests/__init__.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+"""Test the different main implementations."""

=== added file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/tests/test_common.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+#
+# test_main - tests for ubuntu_sso.main
+#
+# Author: Natalia Bidart <[e-mail]>
+# Author: Alejandro J. Cura <[e-mail]>
+# Author: Manuel de la Pena <[e-mail]>
+#
+# Copyright 2009-2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests share by diff platforms."""
+
+import os
+
+from unittest import TestCase
+from mocker import MockerTestCase, MATCH
+from ubuntu_sso.main import (
+    CredentialsManagement,
+    SSOCredentialsRoot,
+    SSOCredentials,
+    SSOLogin,
+    U1_PING_URL)
+
+
+class EnvironOverridesTestCase(TestCase):
+    """Some URLs can be set from the environment for testing/QA purposes."""
+
+    def test_override_ping_url(self):
+        """The ping url can be set from the environ via USSOC_PING_URL."""
+        fake_url = 'this is not really a URL'
+        old_url = os.environ.get('USSOC_PING_URL')
+        os.environ['USSOC_PING_URL'] = fake_url
+        try:
+            creds = SSOCredentialsRoot()
+            self.assertEqual(creds.ping_url, fake_url)
+        finally:
+            if old_url:
+                os.environ['USSOC_PING_URL'] = old_url
+            else:
+                del os.environ['USSOC_PING_URL']
+
+    def test_no_override_ping_url(self):
+        """If the environ is unset, the default ping url is used."""
+        creds = SSOCredentialsRoot()
+        self.assertEqual(creds.ping_url, U1_PING_URL)
+
+
+class SSOLoginMockedTestCase(MockerTestCase):
+    """Test that the call are relied correctly."""
+
+    def setUp(self):
+        """Setup tests."""
+        super(SSOLoginMockedTestCase, self).setUp()
+        self.root = self.mocker.mock()
+        mockbusname = self.mocker.mock()
+        mockbus = self.mocker.mock()
+        mockbusname.get_bus()
+        self.mocker.result(mockbus)
+        self.login = SSOLogin(mockbus)
+        self.login.root = self.root
+        self.mocker.reset()
+
+    def test_generate_captcha(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        filename = 'file'
+        self.root.generate_captcha(app_name, filename, MATCH(callable),
+                                   MATCH(callable), MATCH(callable))
+        self.mocker.replay()
+        self.login.generate_captcha(app_name, filename)
+
+    def test_register_user(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        email = 'email'
+        password = 'pwd'
+        name = 'display name'
+        captcha_id = 'id'
+        captcha_solution = 'hello'
+        self.root.register_user(app_name, email, password, name, captcha_id,
+                                captcha_solution, MATCH(callable),
+                                MATCH(callable), MATCH(callable))
+        self.mocker.replay()
+        self.login.register_user(app_name, email, password, name, captcha_id,
+                                 captcha_solution)
+
+    def test_login(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        email = 'email'
+        password = 'password'
+        self.root.login(app_name, email, password, MATCH(callable),
+                        MATCH(callable), MATCH(callable),
+                        MATCH(callable))
+        self.mocker.mock()
+        self.mocker.replay()
+        self.login.login(app_name, email, password)
+
+    def test_validate_email(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        email = 'email'
+        password = 'passwrd'
+        email_token = 'token'
+        self.root.validate_email(app_name, email, password, email_token,
+                                 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):
+        """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)
+
+    def test_set_new_password(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        email = 'email'
+        token = 'token'
+        new_password = 'new'
+        self.root.set_new_password(app_name, email, token, new_password,
+                                   MATCH(callable), MATCH(callable),
+                                   MATCH(callable))
+        self.mocker.replay()
+        self.login.set_new_password(app_name, email, token, new_password)
+
+
+class SSOCredentialsMockedTestCase(MockerTestCase):
+    """Test that the call are relied correctly."""
+
+    def setUp(self):
+        """Setup tests."""
+        super(SSOCredentialsMockedTestCase, self).setUp()
+        self.root = self.mocker.mock()
+        mockbusname = self.mocker.mock()
+        mockbus = self.mocker.mock()
+        mockbusname.get_bus()
+        self.mocker.result(mockbus)
+        self.cred = SSOCredentials(mockbus)
+        self.cred.root = self.root
+        self.mocker.reset()
+
+    def test_find_credentials(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        result_cb = error_cb = lambda: None
+        self.root.find_credentials(app_name, result_cb, error_cb)
+        self.mocker.mock()
+        self.mocker.replay()
+        self.cred.find_credentials(app_name, result_cb, error_cb)
+
+    def test_login_or_register_to_get_credentials(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        terms = 'terms'
+        help_text = 'help'
+        window_id = 'id'
+        self.root.login_or_register_to_get_credentials(app_name, terms,
+                                                       help_text, window_id,
+                                                       MATCH(callable),
+                                                       MATCH(callable),
+                                                       MATCH(callable))
+        self.mocker.replay()
+        self.cred.login_or_register_to_get_credentials(app_name, terms,
+                                                       help_text, window_id)
+
+    def test_clear_token(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        result_cb = error_cb = lambda: None
+        self.root.clear_token(app_name, result_cb, error_cb)
+        self.mocker.replay()
+        self.cred.clear_token(app_name, result_cb, error_cb)
+
+
+class CredentialsManagementMockedTestCase(MockerTestCase):
+    """Test that the call are relied correctly."""
+
+    def setUp(self):
+        """Setup tests."""
+        super(CredentialsManagementMockedTestCase, self).setUp()
+        self.root = self.mocker.mock()
+        self.cred = CredentialsManagement(None, None)
+        self.cred.root = self.root
+
+    def test_find_credentials(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        args = 'args'
+        self.root.find_credentials(app_name, args, MATCH(callable),
+                                   MATCH(callable))
+        self.mocker.replay()
+        self.cred.find_credentials(app_name, args)
+
+    def test_clear_credentials(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        args = 'args'
+        self.root.clear_credentials(app_name, args, MATCH(callable),
+                                    MATCH(callable))
+        self.mocker.replay()
+        self.cred.clear_credentials(app_name, args)
+
+    def test_store_credentials(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        args = 'args'
+        self.root.store_credentials(app_name, args, MATCH(callable),
+                                    MATCH(callable))
+        self.mocker.replay()
+        self.cred.store_credentials(app_name, args)
+
+    def test_register(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        args = 'args'
+        self.root.register(app_name, args)
+        self.mocker.replay()
+        self.cred.register(app_name, args)
+
+    def test_login(self):
+        """Test that the call is relayed."""
+        app_name = 'app'
+        args = 'args'
+        self.root.login(app_name, args)
+        self.mocker.replay()
+        self.cred.login(app_name, args)

=== added file 'ubuntu_sso/main/tests/test_linux.py'
--- ubuntu_sso/main/tests/test_linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/tests/test_linux.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,1306 @@
+# -*- coding: utf-8 -*-
+#
+# test_main - tests for ubuntu_sso.main
+#
+# Author: Natalia Bidart <[e-mail]>
+# Author: Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2009-2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the main SSO client code."""
+
+import logging
+import os
+
+from mocker import Mocker, MockerTestCase, ARGS, KWARGS
+from twisted.internet import defer
+from twisted.internet.defer import Deferred, inlineCallbacks
+from twisted.trial.unittest import TestCase
+from ubuntuone.devtools.handlers import MementoHandler
+
+import ubuntu_sso.keyring
+import ubuntu_sso.main
+import ubuntu_sso.main.linux
+
+from ubuntu_sso import DBUS_CREDENTIALS_IFACE
+from ubuntu_sso.keyring import U1_APP_NAME
+from ubuntu_sso.main import (U1_PING_URL, except_to_errdict,
+    CredentialsManagement, SSOCredentials, SSOLogin)
+from ubuntu_sso.main.linux import TIMEOUT_INTERVAL, blocking
+from ubuntu_sso.main import (HELP_TEXT_KEY, PING_URL_KEY,
+    TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
+    SUCCESS_CB_KEY, ERROR_CB_KEY, DENIAL_CB_KEY)
+from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, PING_URL, TOKEN,
+    TOKEN_NAME, WINDOW_ID, TestCase)
+
+
+# Access to a protected member 'yyy' of a client class
+# pylint: disable=W0212
+
+
+class BlockingSampleException(Exception):
+    """The exception that will be thrown by the fake blocking."""
+
+
+def fake_ok_blocking(f, app, cb, eb):
+    """A fake blocking function that succeeds."""
+    cb(app, f())
+
+
+def fake_err_blocking(f, app, cb, eb):
+    """A fake blocking function that fails."""
+    try:
+        f()
+    except Exception, e:  # pylint: disable=W0703
+        eb(app, except_to_errdict(e))
+    else:
+        eb(app, except_to_errdict(BlockingSampleException()))
+
+
+class SsoDbusTestCase(TestCase):
+    """Test the SSOLogin DBus interface."""
+
+    timeout = 2
+
+    def setUp(self):
+        """Create the mocking bus."""
+        self.mocker = Mocker()
+        self.mockbusname = self.mocker.mock()
+        mockbus = self.mocker.mock()
+        self.mockbusname.get_bus()
+        self.mocker.result(mockbus)
+        mockbus._register_object_path(ARGS)
+        self.mockprocessorclass = None
+
+        def ksc(keyring, k, val):
+            """Assert over token and app_name."""
+            self.assertEqual(k, APP_NAME)
+            self.assertEqual(val, TOKEN)
+            self.keyring_was_set = True
+            self.keyring_values = k, val
+            return defer.succeed(None)
+
+        self.patch(ubuntu_sso.main.Keyring, "set_credentials", ksc)
+        self.keyring_was_set = False
+        self.keyring_values = None
+
+    def tearDown(self):
+        """Verify the mocking bus and shut it down."""
+        self.mocker.verify()
+        self.mocker.restore()
+
+    def test_creation(self):
+        """Test that the object creation is successful."""
+        self.mocker.replay()
+        SSOLogin(self.mockbusname)
+
+    def create_mock_processor(self):
+        """Create a mock processor from a dummy processor class."""
+        self.mockprocessorclass = self.mocker.mock()
+        mockprocessor = self.mocker.mock()
+        self.mockprocessorclass(ARGS, KWARGS)
+        self.mocker.result(mockprocessor)
+        return mockprocessor
+
+    def test_generate_captcha(self):
+        """Test that the captcha method works ok."""
+        d = Deferred()
+        filename = "sample filename"
+        expected_result = "expected result"
+        self.create_mock_processor().generate_captcha(filename)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "CaptchaGenerated", verify)
+        self.patch(client, "CaptchaGenerationError", d.errback)
+        client.generate_captcha(APP_NAME, filename)
+        return d
+
+    def test_generate_captcha_error(self):
+        """Test that the captcha method fails as expected."""
+        d = Deferred()
+        filename = "sample filename"
+        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.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "CaptchaGenerated", d.errback)
+        self.patch(client, "CaptchaGenerationError", verify)
+        client.generate_captcha(APP_NAME, filename)
+        return d
+
+    def test_register_user(self):
+        """Test that the register_user method works ok."""
+        d = Deferred()
+        expected_result = "expected result"
+        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_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", verify)
+        self.patch(client, "UserRegistrationError", d.errback)
+        client.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
+    def test_register_user_error(self):
+        """Test that the register_user method fails as expected."""
+        d = Deferred()
+        expected_result = "expected result"
+        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.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", d.errback)
+        self.patch(client, "UserRegistrationError", verify)
+        client.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
+    def test_login(self):
+        """Test that the login method works ok."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        processor.is_validated(TOKEN)
+        self.mocker.result(True)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
+            self.assertTrue(self.keyring_was_set, "The keyring should be set")
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "LoggedIn", verify)
+        self.patch(client, "LoginError", d.errback)
+        self.patch(client, "UserNotValidated", d.errback)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_login_user_not_validated(self):
+        """Test that the login sends EmailNotValidated signal."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        processor.is_validated(TOKEN)
+        self.mocker.result(False)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, email):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(email, EMAIL)
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "LoggedIn", d.errback)
+        self.patch(client, "LoginError", d.errback)
+        self.patch(client, "UserNotValidated", verify)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_login_error_get_token_name(self):
+        """The login method fails as expected when get_token_name fails."""
+        d = Deferred()
+        self.create_mock_processor()
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+
+        def fake_gtn(*args):
+            """A fake get_token_name that fails."""
+            raise BlockingSampleException()
+
+        self.patch(ubuntu_sso.main, "get_token_name", fake_gtn)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "LoggedIn", d.errback)
+        self.patch(client, "LoginError", verify)
+        self.patch(client, "UserNotValidated", d.errback)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_login_error_set_credentials(self):
+        """The login method fails as expected when set_credentials fails."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        processor.is_validated(TOKEN)
+        self.mocker.result(True)
+
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+
+        def fake_set_creds(*args):
+            """A fake Keyring.set_credentials that fails."""
+            return defer.fail(BlockingSampleException())
+
+        self.patch(ubuntu_sso.main.Keyring, "set_credentials", fake_set_creds)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        fail = lambda app, res: d.errback((app, res))
+        self.patch(client, "LoggedIn", fail)
+        self.patch(client, "LoginError", verify)
+        self.patch(client, "UserNotValidated", fail)
+        client.login(APP_NAME, EMAIL, PASSWORD)
+        return d
+
+    def test_validate_email(self):
+        """Test that the validate_email method works ok."""
+        d = Deferred()
+        self.create_mock_processor().validate_email(EMAIL, PASSWORD,
+                                                    EMAIL_TOKEN, TOKEN_NAME)
+        self.mocker.result(TOKEN)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
+            self.assertTrue(self.keyring_was_set, "The keyring should be set")
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "EmailValidated", verify)
+        self.patch(client, "EmailValidationError", d.errback)
+        client.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
+        return d
+
+    def test_validate_email_error(self):
+        """Test that the validate_email method fails as expected."""
+        d = Deferred()
+        self.create_mock_processor()
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+
+        def fake_gtn(*args):
+            """A fake get_token_name that fails."""
+            raise BlockingSampleException()
+
+        self.patch(ubuntu_sso.main, "get_token_name", fake_gtn)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "EmailValidated", d.errback)
+        self.patch(client, "EmailValidationError", verify)
+        client.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
+        return d
+
+    def test_request_password_reset_token(self):
+        """Test that the request_password_reset_token method works ok."""
+        d = Deferred()
+        processor = self.create_mock_processor()
+        processor.request_password_reset_token(EMAIL)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.mocker.result(EMAIL)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "PasswordResetTokenSent", verify)
+        self.patch(client, "PasswordResetError", d.errback)
+        client.request_password_reset_token(APP_NAME, EMAIL)
+        return d
+
+    def test_request_password_reset_token_error(self):
+        """Test the request_password_reset_token method fails as expected."""
+        d = Deferred()
+
+        self.create_mock_processor().request_password_reset_token(EMAIL)
+        self.mocker.result(EMAIL)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "PasswordResetTokenSent", d.errback)
+        self.patch(client, "PasswordResetError", verify)
+        client.request_password_reset_token(APP_NAME, EMAIL)
+        return d
+
+    def test_set_new_password(self):
+        """Test that the set_new_password method works ok."""
+        d = Deferred()
+        self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
+                                                      PASSWORD)
+        self.mocker.result(EMAIL)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "PasswordChanged", verify)
+        self.patch(client, "PasswordChangeError", d.errback)
+        client.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
+        return d
+
+    def test_set_new_password_error(self):
+        """Test that the set_new_password method fails as expected."""
+        d = Deferred()
+        expected_result = "expected result"
+
+        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.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "PasswordChanged", d.errback)
+        self.patch(client, "PasswordChangeError", verify)
+        client.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
+        return d
+
+
+class BlockingFunctionTestCase(TestCase):
+    """Tests for the "blocking" function."""
+
+    timeout = 5
+
+    def test_blocking(self):
+        """Test the normal behaviour."""
+        d = Deferred()
+        expected_result = "expected result"
+
+        def f():
+            """No failure."""
+            return expected_result
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        blocking(f, APP_NAME, verify, d.errback)
+        return d
+
+    def test_blocking_error(self):
+        """Test the behaviour when an Exception is raised."""
+        d = Deferred()
+        expected_error_message = "expected error message"
+
+        def f():
+            """Failure."""
+            raise BlockingSampleException(expected_error_message)
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(app_name, APP_NAME)
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(errdict["message"], expected_error_message)
+            d.callback("Ok")
+
+        blocking(f, APP_NAME, d.errback, verify)
+        return d
+
+
+class TestExceptToErrdictException(Exception):
+    """A dummy exception for the following testcase."""
+
+
+class ExceptToErrdictTestCase(TestCase):
+    """Tests for the except_to_errdict function."""
+
+    def test_first_arg_is_dict(self):
+        """If the first arg is a dict, use it as the base dict."""
+        sample_dict = {
+            "errorcode1": "error message 1",
+            "errorcode2": "error message 2",
+            "errorcode3": "error message 3",
+        }
+        e = TestExceptToErrdictException(sample_dict)
+        result = except_to_errdict(e)
+
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        for k in sample_dict.keys():
+            self.assertIn(k, result)
+            self.assertEqual(result[k], sample_dict[k])
+
+    def test_first_arg_is_str(self):
+        """If the first arg is a str, use it as the message."""
+        sample_string = "a sample string"
+        e = TestExceptToErrdictException(sample_string)
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        self.assertEqual(result["message"], sample_string)
+
+    def test_first_arg_is_unicode(self):
+        """If the first arg is a unicode, use it as the message."""
+        sample_string = u"a sample string"
+        e = TestExceptToErrdictException(sample_string)
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        self.assertEqual(result["message"], sample_string)
+
+    def test_no_args_at_all(self):
+        """If there are no args, use the class docstring."""
+        e = TestExceptToErrdictException()
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        self.assertEqual(result["message"], e.__class__.__doc__)
+
+    def test_some_other_thing_as_first_arg(self):
+        """If first arg is not basestring nor dict, then repr all args."""
+        sample_args = (None, u"unicode2\ufffd", "errorcode3")
+        e = TestExceptToErrdictException(*sample_args)
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+
+
+class RegisterSampleException(Exception):
+    """A mock exception thrown just when testing."""
+
+
+class ApplicationCredentialsTestCase(TestCase, MockerTestCase):
+    """Tests for the ApplicationCredentials related DBus methods."""
+
+    timeout = 5
+
+    def setUp(self):
+        MockerTestCase.setUp(self)
+
+        self.client = SSOCredentials(self.mocker.mock())
+
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=APP_NAME)
+        self.creds_obj = self.mocker.mock()
+        self.mocker.result(self.creds_obj)
+
+    @inlineCallbacks
+    def test_find_credentials(self):
+        """find_credentials immediately returns the token when found."""
+        expected_creds = "expected creds"
+        self.creds_obj.find_credentials()
+        self.mocker.result(defer.succeed(expected_creds))
+        self.mocker.replay()
+
+        d = Deferred()
+        self.client.find_credentials(APP_NAME, d.callback, d.errback)
+        creds = yield d
+        self.assertEqual(creds, expected_creds)
+
+    @inlineCallbacks
+    def test_credentials_not_found(self):
+        """find_credentials immediately returns {} when no creds found."""
+        expected_creds = {}
+        self.creds_obj.find_credentials()
+        self.mocker.result(defer.succeed(expected_creds))
+        self.mocker.replay()
+
+        d = Deferred()
+        self.client.find_credentials(APP_NAME, d.callback, d.errback)
+        creds = yield d
+        self.assertEqual(creds, expected_creds)
+
+
+class ApplicationCredentialsGUITestCase(TestCase, MockerTestCase):
+    """Tests for the ApplicationCredentials register/login DBus method."""
+
+    app_name = APP_NAME
+    ping_url = None
+
+    def setUp(self):
+        MockerTestCase.setUp(self)
+        self.client = SSOCredentials(self.mocker.mock())
+        self.args = {PING_URL_KEY: self.ping_url,
+                     TC_URL_KEY: TC_URL, HELP_TEXT_KEY: HELP_TEXT,
+                     WINDOW_ID_KEY: WINDOW_ID,
+                     SUCCESS_CB_KEY: self.client.CredentialsFound,
+                     ERROR_CB_KEY: self.client._process_error,
+                     DENIAL_CB_KEY: self.client.AuthorizationDenied}
+
+    def test_login_or_register(self):
+        """login_or_register is correct."""
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=self.app_name, **self.args)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        creds_obj.register()
+        self.mocker.replay()
+
+        args = (self.app_name, TC_URL, HELP_TEXT, WINDOW_ID)
+        self.client.login_or_register_to_get_credentials(*args)
+
+    def test_login_only(self):
+        """login_or_register is correct."""
+        self.args[TC_URL_KEY] = None
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=self.app_name, **self.args)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        creds_obj.login()
+        self.mocker.replay()
+
+        args = (self.app_name, HELP_TEXT, WINDOW_ID)
+        self.client.login_to_get_credentials(*args)
+
+
+class ApplicationCredentialsU1TestCase(ApplicationCredentialsGUITestCase):
+    """Tests for the ApplicationCredentials register/login DBus method.
+
+    Specifically for APP_NAME == U1_APP_NAME.
+
+    """
+
+    app_name = U1_APP_NAME
+    ping_url = U1_PING_URL
+
+
+class ApplicationCredentialsClearTokenTestCase(TestCase, MockerTestCase):
+    """Tests for the ApplicationCredentials related DBus methods."""
+
+    def test_clear_token(self):
+        """Check that clear_token tries removing the correct token."""
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(app_name=APP_NAME)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        creds_obj.clear_credentials()
+        self.mocker.result(defer.succeed(None))
+        self.mocker.replay()
+
+        client = SSOCredentials(self.mocker.mock())
+        client.clear_token(APP_NAME)
+
+
+class EnvironOverridesTestCase(TestCase):
+    """Some URLs can be set from the environment for testing/QA purposes."""
+
+    def test_override_ping_url(self):
+        """The ping url can be set from the environ via USSOC_PING_URL."""
+        fake_url = 'this is not really a URL'
+        old_url = os.environ.get('USSOC_PING_URL')
+        os.environ['USSOC_PING_URL'] = fake_url
+        try:
+            creds = SSOCredentials(None)
+            self.assertEqual(creds.root.ping_url, fake_url)
+        finally:
+            if old_url:
+                os.environ['USSOC_PING_URL'] = old_url
+            else:
+                del os.environ['USSOC_PING_URL']
+
+    def test_no_override_ping_url(self):
+        """If the environ is unset, the default ping url is used."""
+        creds = SSOCredentials(None)
+        self.assertEqual(creds.root.ping_url, U1_PING_URL)
+
+
+class CredentialsManagementTestCase(TestCase):
+    """Tests for the CredentialsManagement DBus interface."""
+
+    timeout = 2
+    base_args = {HELP_TEXT_KEY: HELP_TEXT, PING_URL_KEY: PING_URL,
+                 TC_URL_KEY: TC_URL, WINDOW_ID_KEY: WINDOW_ID,
+                 UI_CLASS_KEY: 'SuperUI', UI_MODULE_KEY: 'foo.bar.baz',
+                }
+
+    def setUp(self):
+        super(CredentialsManagementTestCase, self).setUp()
+
+        self.mocker = Mocker()
+        self.client = CredentialsManagement(timeout_func=lambda *a: None,
+                                            shutdown_func=lambda *a: None)
+        self.args = {}
+        self.cred_args = {}
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        ubuntu_sso.main.logger.addHandler(self.memento)
+
+    def tearDown(self):
+        """Verify the mocking stuff and shut it down."""
+        self.mocker.verify()
+        self.mocker.restore()
+        super(CredentialsManagementTestCase, self).tearDown()
+
+    def assert_dbus_method_correct(self, method):
+        """Check that 'method' is a dbus method with proper signatures."""
+        self.assertTrue(method._dbus_is_method)
+        self.assertEqual(method._dbus_interface, DBUS_CREDENTIALS_IFACE)
+        self.assertEqual(method._dbus_in_signature, 'sa{ss}')
+        self.assertEqual(method._dbus_out_signature, '')
+
+    def create_mock_backend(self):
+        """Create a mock backend."""
+        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
+        mock_class(APP_NAME, **self.cred_args)
+        creds_obj = self.mocker.mock()
+        self.mocker.result(creds_obj)
+
+        return creds_obj
+
+    def test_is_dbus_object(self):
+        """CredentialsManagement is a Dbus object."""
+        self.assertIsInstance(self.client,
+                              ubuntu_sso.main.linux.dbus.service.Object)
+
+
+class FakeCredentials(object):
+    """A very dummy Credentials object."""
+
+    def __init__(self, *a, **kw):
+        self.find_credentials = lambda *a: defer.succeed(TOKEN)
+        self.clear_credentials = lambda *a: defer.succeed(None)
+        self.store_credentials = lambda *a: defer.succeed(None)
+        self.login = self.register = lambda *a: None
+
+
+class CredentialsManagementRefCountingTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement ref counting."""
+
+    def setUp(self):
+        super(CredentialsManagementRefCountingTestCase, self).setUp()
+        self.patch(ubuntu_sso.main, 'Credentials', FakeCredentials)
+
+    def test_ref_counting(self):
+        """Ref counting is in place."""
+        self.assertEqual(self.client.ref_count, 0)
+
+    def test_find_credentials(self):
+        """Keep proper track of on going requests."""
+        d = Deferred()
+
+        def verify(*args):
+            """Make the check."""
+            self.assertEqual(self.client.ref_count, 1)
+            d.callback(True)
+
+        self.patch(self.client, 'CredentialsFound', verify)
+        self.client.find_credentials(APP_NAME, self.args)
+
+        return d
+
+    def test_clear_credentials(self):
+        """Keep proper track of on going requests."""
+        d = Deferred()
+
+        def verify(*args):
+            """Make the check."""
+            self.assertEqual(self.client.ref_count, 1)
+            d.callback(True)
+
+        self.patch(self.client, 'CredentialsCleared', verify)
+        self.client.clear_credentials(APP_NAME, self.args)
+
+        return d
+
+    def test_store_credentials(self):
+        """Keep proper track of on going requests."""
+        d = Deferred()
+
+        def verify(*args):
+            """Make the check."""
+            self.assertEqual(self.client.ref_count, 1)
+            d.callback(True)
+
+        self.patch(self.client, 'CredentialsStored', verify)
+        self.client.store_credentials(APP_NAME, self.args)
+
+        return d
+
+    def test_register(self):
+        """Keep proper track of on going requests."""
+        self.client.register(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_login(self):
+        """Keep proper track of on going requests."""
+        self.client.login(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 1)
+
+    def test_several_requests(self):
+        """Requests can be nested."""
+        self.client.login(APP_NAME, self.args)
+        self.client.register(APP_NAME, self.args)
+        self.client.login(APP_NAME, self.args)
+        self.client.register(APP_NAME, self.args)
+        self.client.register(APP_NAME, self.args)
+
+        self.assertEqual(self.client.ref_count, 5)
+
+    def test_credentials_found(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_not_found(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsNotFound(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_cleared(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsCleared(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_stored(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsStored(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_error(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.CredentialsError(APP_NAME, {'error_type': 'test'})
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_authorization_denied(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client.ref_count = 3
+        self.client.AuthorizationDenied(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 2)
+
+    def test_credentials_found_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_not_found_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsNotFound(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_cleared_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsCleared(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_stored_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsStored(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_credentials_error_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.CredentialsError(APP_NAME, {'error_type': 'test'})
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_autorization_denied_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.client._ref_count = -3
+        self.client.AuthorizationDenied(APP_NAME)
+
+        self.assertEqual(self.client.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_on_zero_ref_count_shutdown(self):
+        """When ref count reaches 0, queue shutdown op."""
+        self.client.timeout_func = self._set_called
+        self.client.login(APP_NAME, self.args)
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+
+        self.assertEqual(self._called,
+                         ((TIMEOUT_INTERVAL, self.client.shutdown), {}))
+
+    def test_on_non_zero_ref_count_do_not_shutdown(self):
+        """If ref count is not 0, do not queue shutdown op."""
+        self.client.timeout_func = self._set_called
+        self.client.login(APP_NAME, self.args)
+
+        self.assertEqual(self._called, False)
+
+    def test_on_non_zero_ref_count_after_zero_do_not_shutdown(self):
+        """If the shutdown was queued, do not quit if counter is not zero."""
+
+        def fake_timeout_func(interval, func):
+            """Start a new request when the timer is started."""
+            self.client.register(APP_NAME, self.args)
+            assert self.client.ref_count > 0
+            func()
+
+        self.client.timeout_func = fake_timeout_func
+        self.client.shutdown_func = self._set_called
+
+        self.client.login(APP_NAME, self.args)
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+        # counter reached 0, timeout_func was called
+
+        self.assertEqual(self._called, False, 'shutdown_func was not called')
+
+    def test_zero_ref_count_after_zero_do_shutdown(self):
+        """If the shutdown was queued, do quit if counter is zero."""
+
+        def fake_timeout_func(interval, func):
+            """Start a new request when the timer is started."""
+            assert self.client.ref_count == 0
+            func()
+
+        self.client.timeout_func = fake_timeout_func
+        self.client.shutdown_func = self._set_called
+
+        self.client.login(APP_NAME, self.args)
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+        # counter reached 0, timeout_func was called
+
+        self.assertEqual(self._called, ((), {}), 'shutdown_func was called')
+
+
+class CredentialsManagementFindTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement find method."""
+
+    def test_find_credentials(self):
+        """The credentials are asked and returned in signals."""
+        self.create_mock_backend().find_credentials()
+        self.mocker.result(defer.succeed(None))
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.find_credentials)
+
+    def test_find_credentials_does_not_block_when_found(self):
+        """Calling find_credentials does not block but return thru signals.
+
+        If the creds are found, CredentialsFound is emitted.
+
+        """
+        d = Deferred()
+
+        def verify(app_name, creds):
+            """The actual test."""
+            try:
+                self.assertEqual(app_name, APP_NAME)
+                self.assertEqual(creds, TOKEN)
+            except Exception, e:  # pylint: disable=W0703
+                d.errback(e)
+            else:
+                d.callback(creds)
+
+        self.patch(self.client, 'CredentialsFound', verify)
+        self.patch(self.client, 'CredentialsNotFound', d.errback)
+
+        self.create_mock_backend().find_credentials()
+        self.mocker.result(defer.succeed(TOKEN))
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        return d
+
+    def test_find_credentials_does_not_block_when_not_found(self):
+        """Calling find_credentials does not block but return thru signals.
+
+        If the creds are not found, CredentialsNotFound is emitted.
+
+        """
+        d = Deferred()
+
+        def verify(app_name):
+            """The actual test."""
+            try:
+                self.assertEqual(app_name, APP_NAME)
+            except Exception, e:  # pylint: disable=W0703
+                d.errback(e)
+            else:
+                d.callback(app_name)
+
+        self.patch(self.client, 'CredentialsFound',
+                   lambda app, creds: d.errback(app))
+        self.patch(self.client, 'CredentialsNotFound', verify)
+
+        self.create_mock_backend().find_credentials()
+        self.mocker.result(defer.succeed({}))
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        return d
+
+    def test_find_credentials_error(self):
+        """If find_credentials fails, CredentialsError is sent."""
+        d = Deferred()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        self.patch(self.client, 'CredentialsFound',
+                   lambda app, creds: d.errback(app))
+        self.patch(self.client, 'CredentialsNotFound', d.errback)
+        self.patch(self.client, 'CredentialsError', verify)
+
+        self.create_mock_backend().find_credentials()
+        self.mocker.result(defer.fail(BlockingSampleException()))
+        self.mocker.replay()
+
+        self.client.find_credentials(APP_NAME, self.args)
+        return d
+
+
+class CredentialsManagementClearTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement clear method."""
+
+    def test_clear_credentials(self):
+        """The credentials are removed."""
+        self.create_mock_backend().clear_credentials()
+        self.mocker.result(defer.succeed(APP_NAME))
+        self.mocker.replay()
+
+        self.client.clear_credentials(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.clear_credentials)
+
+    def test_clear_credentials_does_not_block(self):
+        """Calling clear_credentials does not block but return thru signals."""
+        d = Deferred()
+
+        def verify(app_name):
+            """The actual test."""
+            try:
+                self.assertEqual(app_name, APP_NAME)
+            except Exception, e:  # pylint: disable=W0703
+                d.errback(e)
+            else:
+                d.callback(app_name)
+
+        self.patch(self.client, 'CredentialsCleared', verify)
+        self.patch(self.client, 'CredentialsError',
+                   lambda app, err: d.errback(app))
+
+        self.create_mock_backend().clear_credentials()
+        self.mocker.result(defer.succeed(APP_NAME))
+        self.mocker.replay()
+
+        self.client.clear_credentials(APP_NAME, self.args)
+        return d
+
+    def test_clear_credentials_error(self):
+        """If clear_credentials fails, CredentialsError is sent."""
+        d = Deferred()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        self.patch(self.client, 'CredentialsCleared', d.errback)
+        self.patch(self.client, 'CredentialsError', verify)
+
+        self.create_mock_backend().clear_credentials()
+        self.mocker.result(defer.fail(BlockingSampleException()))
+        self.mocker.replay()
+
+        self.client.clear_credentials(APP_NAME, self.args)
+        return d
+
+
+class CredentialsManagementStoreTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement store method."""
+
+    def test_store_credentials(self):
+        """The credentials are stored and the outcome is a signal."""
+        self.create_mock_backend().store_credentials(TOKEN)
+        self.mocker.result(defer.succeed(APP_NAME))
+        self.mocker.replay()
+
+        self.client.store_credentials(APP_NAME, TOKEN)
+        self.assert_dbus_method_correct(self.client.store_credentials)
+
+    def test_store_credentials_does_not_block(self):
+        """Calling store_credentials does not block but return thru signals.
+
+        If the creds are stored, CredentialsStored is emitted.
+
+        """
+        d = Deferred()
+
+        def verify(app_name):
+            """The actual test."""
+            try:
+                self.assertEqual(app_name, APP_NAME)
+            except Exception, e:  # pylint: disable=W0703
+                d.errback(e)
+            else:
+                d.callback(app_name)
+
+        self.patch(self.client, 'CredentialsStored', verify)
+        self.patch(self.client, 'CredentialsError',
+                   lambda app, err: d.errback(app))
+
+        self.create_mock_backend().store_credentials(TOKEN)
+        self.mocker.result(defer.succeed(APP_NAME))
+        self.mocker.replay()
+
+        self.client.store_credentials(APP_NAME, TOKEN)
+        return d
+
+    def test_store_credentials_error(self):
+        """If store_credentials fails, CredentialsError is sent."""
+        d = Deferred()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        self.patch(self.client, 'CredentialsStored', d.errback)
+        self.patch(self.client, 'CredentialsError', verify)
+
+        self.create_mock_backend().store_credentials(TOKEN)
+        self.mocker.result(defer.fail(BlockingSampleException()))
+        self.mocker.replay()
+
+        self.client.store_credentials(APP_NAME, TOKEN)
+        return d
+
+
+class CredentialsManagementOpsTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement login/register methods."""
+
+    def setUp(self):
+        super(CredentialsManagementOpsTestCase, self).setUp()
+        self.args = dict((k, str(v)) for k, v in self.base_args.iteritems())
+        self.cred_args = self.base_args.copy()
+        self.cred_args[SUCCESS_CB_KEY] = self.client.CredentialsFound
+        self.cred_args[ERROR_CB_KEY] = self.client.CredentialsError
+        self.cred_args[DENIAL_CB_KEY] = self.client.AuthorizationDenied
+
+    def test_register(self):
+        """The registration is correct."""
+        self.create_mock_backend().register()
+        self.mocker.replay()
+
+        self.client.register(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.register)
+
+    def test_login(self):
+        """The login is correct."""
+        self.create_mock_backend().login()
+        self.mocker.replay()
+
+        self.client.login(APP_NAME, self.args)
+        self.assert_dbus_method_correct(self.client.login)
+
+
+class CredentialsManagementParamsTestCase(CredentialsManagementOpsTestCase):
+    """Tests for the CredentialsManagement extra parameters handling."""
+
+    def setUp(self):
+        super(CredentialsManagementParamsTestCase, self).setUp()
+        self.args['dummy'] = 'nothing useful'
+
+
+class CredentialsManagementSignalsTestCase(TestCase):
+    """Tests for the CredentialsManagement DBus signals."""
+
+    def setUp(self):
+        self.client = CredentialsManagement(timeout_func=lambda *a: None,
+                                            shutdown_func=lambda *a: None)
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        ubuntu_sso.main.logger.addHandler(self.memento)
+
+    def assert_dbus_signal_correct(self, signal, signature):
+        """Check that 'signal' is a dbus signal with proper 'signature'."""
+        self.assertTrue(signal._dbus_is_signal)
+        self.assertEqual(signal._dbus_interface, DBUS_CREDENTIALS_IFACE)
+        self.assertEqual(signal._dbus_signature, signature)
+
+    def test_credentials_found(self):
+        """The CredentialsFound signal."""
+        self.client.CredentialsFound(APP_NAME, TOKEN)
+        msgs = (self.client.__class__.__name__,
+                self.client.CredentialsFound.__name__, APP_NAME)
+        self.assertTrue(self.memento.check_info(*msgs))
+
+        msg = 'credentials must not be logged (found %r in log).'
+        for val in TOKEN.itervalues():
+            self.assertFalse(self.memento.check_info(val), msg % val)
+
+        self.assert_dbus_signal_correct(self.client.CredentialsFound, 'sa{ss}')
+
+    def test_credentials_not_found(self):
+        """The CredentialsNotFound signal."""
+        self.client.CredentialsNotFound(APP_NAME)
+        msgs = (self.client.__class__.__name__,
+                self.client.CredentialsNotFound.__name__, APP_NAME)
+        self.assertTrue(self.memento.check_info(*msgs))
+        self.assert_dbus_signal_correct(self.client.CredentialsNotFound, 's')
+
+    def test_credentials_cleared(self):
+        """The CredentialsCleared signal."""
+        self.client.CredentialsCleared(APP_NAME)
+        msgs = (self.client.__class__.__name__,
+                self.client.CredentialsCleared.__name__, APP_NAME)
+        self.assertTrue(self.memento.check_info(*msgs))
+
+        self.assert_dbus_signal_correct(self.client.CredentialsCleared, 's')
+
+    def test_credentials_stored(self):
+        """The CredentialsStored signal."""
+        self.client.CredentialsStored(APP_NAME)
+        msgs = (self.client.__class__.__name__,
+                self.client.CredentialsStored.__name__, APP_NAME)
+        self.assertTrue(self.memento.check_info(*msgs))
+
+        self.assert_dbus_signal_correct(self.client.CredentialsStored, 's')
+
+    def test_credentials_error(self):
+        """The CredentialsError signal."""
+        error = {'error_message': 'failed!', 'detailed error': 'yadda yadda'}
+        self.client.CredentialsError(APP_NAME, error)
+        msgs = (self.client.__class__.__name__,
+                self.client.CredentialsError.__name__,
+                APP_NAME, str(error))
+        self.assertTrue(self.memento.check_error(*msgs))
+
+        self.assert_dbus_signal_correct(self.client.CredentialsError, 'sa{ss}')
+
+    def test_authorization_denied(self):
+        """The AuthorizationDenied signal."""
+        self.client.AuthorizationDenied(APP_NAME)
+        msgs = (self.client.__class__.__name__,
+                self.client.AuthorizationDenied.__name__, APP_NAME)
+        self.assertTrue(self.memento.check_info(*msgs))
+
+        self.assert_dbus_signal_correct(self.client.AuthorizationDenied, 's')

=== added file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+"""Windows tests."""

=== added file 'ubuntu_sso/main/windows.py'
--- ubuntu_sso/main/windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/windows.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+"""Main implementation on windows."""

=== added directory 'ubuntu_sso/networkstate'
=== removed file 'ubuntu_sso/networkstate.py'
--- ubuntu_sso/networkstate.py	2010-10-11 13:22:16 +0000
+++ ubuntu_sso/networkstate.py	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# networkstate - detect the current state of the network
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2010 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Implementation of network state detection."""
-
-import dbus
-
-from ubuntu_sso.logger import setup_logging
-logger = setup_logging("ubuntu_sso.networkstate")
-
-# Values returned by the callback
-ONLINE, OFFLINE, UNKNOWN = object(), object(), object()
-
-NM_STATE_NAMES = {
-    ONLINE: "online",
-    OFFLINE: "offline",
-    UNKNOWN: "unknown",
-}
-
-# Internal NetworkManager State constants
-NM_STATE_UNKNOWN = 0
-NM_STATE_ASLEEP = 1
-NM_STATE_CONNECTING = 2
-NM_STATE_CONNECTED = 3
-NM_STATE_DISCONNECTED = 4
-
-NM_DBUS_INTERFACE = "org.freedesktop.NetworkManager"
-NM_DBUS_OBJECTPATH = "/org/freedesktop/NetworkManager"
-DBUS_UNKNOWN_SERVICE = "org.freedesktop.DBus.Error.ServiceUnknown"
-
-
-class NetworkManagerState(object):
-    """Checks the state of NetworkManager thru DBus."""
-
-    def __init__(self, result_cb, dbus_module=dbus):
-        """Initialize this instance with a result and error callbacks."""
-        self.result_cb = result_cb
-        self.dbus = dbus_module
-        self.state_signal = None
-
-    def call_result_cb(self, state):
-        """Return the state thru the result callback."""
-        if self.state_signal:
-            self.state_signal.remove()
-        self.result_cb(state)
-
-    def got_state(self, state):
-        """Called by DBus when the state is retrieved from NM."""
-        if state == NM_STATE_CONNECTED:
-            self.call_result_cb(ONLINE)
-        elif state == NM_STATE_CONNECTING:
-            logger.debug("Currently connecting, waiting for signal")
-        else:
-            self.call_result_cb(OFFLINE)
-
-    def got_error(self, error):
-        """Called by DBus when the state is retrieved from NM."""
-        if isinstance(error, self.dbus.exceptions.DBusException) and \
-                error.get_dbus_name() == DBUS_UNKNOWN_SERVICE:
-            logger.debug("Network Manager not present")
-            self.call_result_cb(UNKNOWN)
-        else:
-            logger.error("Error contacting NetworkManager: %s" % \
-                             str(error))
-            self.call_result_cb(UNKNOWN)
-
-    def state_changed(self, state):
-        """Called when a signal is emmited by Network Manager."""
-        if int(state) == NM_STATE_CONNECTED:
-            self.call_result_cb(ONLINE)
-        elif int(state) == NM_STATE_DISCONNECTED:
-            self.call_result_cb(OFFLINE)
-        else:
-            logger.debug("Not yet connected: continuing to wait")
-
-    def find_online_state(self):
-        """Get the network state and return it thru the set callback."""
-        try:
-            sysbus = self.dbus.SystemBus()
-            nm_proxy = sysbus.get_object(NM_DBUS_INTERFACE,
-                                         NM_DBUS_OBJECTPATH,
-                                         follow_name_owner_changes=True)
-            nm_if = self.dbus.Interface(nm_proxy, NM_DBUS_INTERFACE)
-            self.state_signal = nm_if.connect_to_signal(
-                        signal_name="StateChanged",
-                        handler_function=self.state_changed,
-                        dbus_interface=NM_DBUS_INTERFACE)
-            nm_proxy.Get(NM_DBUS_INTERFACE, "State",
-                         reply_handler=self.got_state,
-                         error_handler=self.got_error)
-        except Exception, e:  # pylint: disable=W0703
-            self.got_error(e)

=== added file 'ubuntu_sso/networkstate/__init__.py'
--- ubuntu_sso/networkstate/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/__init__.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,40 @@
+# -*- 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/>.
+"""Platform specific network status."""
+
+import sys
+
+# ignore global naming issues.
+# pylint: disable=C0103
+
+NetworkManagerState = None
+ONLINE = None
+OFFLINE = None
+UNKNOWN = None
+
+if sys.platform == 'win32':
+    from ubuntu_sso.networkstate import windows
+    NetworkManagerState = windows.NetworkManagerState
+    ONLINE = windows.ONLINE
+    OFFLINE = windows.OFFLINE
+    UNKNOWN = windows.UNKNOWN
+else:
+    from ubuntu_sso.networkstate import linux
+    NetworkManagerState = linux.NetworkManagerState
+    ONLINE = linux.ONLINE
+    OFFLINE = linux.OFFLINE
+    UNKNOWN = linux.UNKNOWN

=== added file 'ubuntu_sso/networkstate/linux.py'
--- ubuntu_sso/networkstate/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/linux.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+#
+# networkstate - detect the current state of the network
+#
+# Author: Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Implementation of network state detection."""
+
+import dbus
+
+from ubuntu_sso.logger import setup_logging
+logger = setup_logging("ubuntu_sso.networkstate")
+
+# Values returned by the callback
+ONLINE, OFFLINE, UNKNOWN = object(), object(), object()
+
+NM_STATE_NAMES = {
+    ONLINE: "online",
+    OFFLINE: "offline",
+    UNKNOWN: "unknown",
+}
+
+# Internal NetworkManager State constants
+NM_STATE_UNKNOWN = 0
+NM_STATE_ASLEEP = 1
+NM_STATE_CONNECTING = 2
+NM_STATE_CONNECTED = 3
+NM_STATE_DISCONNECTED = 4
+
+NM_DBUS_INTERFACE = "org.freedesktop.NetworkManager"
+NM_DBUS_OBJECTPATH = "/org/freedesktop/NetworkManager"
+DBUS_UNKNOWN_SERVICE = "org.freedesktop.DBus.Error.ServiceUnknown"
+
+
+class NetworkManagerState(object):
+    """Checks the state of NetworkManager thru DBus."""
+
+    def __init__(self, result_cb, dbus_module=dbus):
+        """Initialize this instance with a result and error callbacks."""
+        self.result_cb = result_cb
+        self.dbus = dbus_module
+        self.state_signal = None
+
+    def call_result_cb(self, state):
+        """Return the state thru the result callback."""
+        if self.state_signal:
+            self.state_signal.remove()
+        self.result_cb(state)
+
+    def got_state(self, state):
+        """Called by DBus when the state is retrieved from NM."""
+        if state == NM_STATE_CONNECTED:
+            self.call_result_cb(ONLINE)
+        elif state == NM_STATE_CONNECTING:
+            logger.debug("Currently connecting, waiting for signal")
+        else:
+            self.call_result_cb(OFFLINE)
+
+    def got_error(self, error):
+        """Called by DBus when the state is retrieved from NM."""
+        if isinstance(error, self.dbus.exceptions.DBusException) and \
+                error.get_dbus_name() == DBUS_UNKNOWN_SERVICE:
+            logger.debug("Network Manager not present")
+            self.call_result_cb(UNKNOWN)
+        else:
+            logger.error("Error contacting NetworkManager: %s" % \
+                             str(error))
+            self.call_result_cb(UNKNOWN)
+
+    def state_changed(self, state):
+        """Called when a signal is emmited by Network Manager."""
+        if int(state) == NM_STATE_CONNECTED:
+            self.call_result_cb(ONLINE)
+        elif int(state) == NM_STATE_DISCONNECTED:
+            self.call_result_cb(OFFLINE)
+        else:
+            logger.debug("Not yet connected: continuing to wait")
+
+    def find_online_state(self):
+        """Get the network state and return it thru the set callback."""
+        try:
+            sysbus = self.dbus.SystemBus()
+            nm_proxy = sysbus.get_object(NM_DBUS_INTERFACE,
+                                         NM_DBUS_OBJECTPATH,
+                                         follow_name_owner_changes=True)
+            nm_if = self.dbus.Interface(nm_proxy, NM_DBUS_INTERFACE)
+            self.state_signal = nm_if.connect_to_signal(
+                        signal_name="StateChanged",
+                        handler_function=self.state_changed,
+                        dbus_interface=NM_DBUS_INTERFACE)
+            nm_proxy.Get(NM_DBUS_INTERFACE, "State",
+                         reply_handler=self.got_state,
+                         error_handler=self.got_error)
+        except Exception, e:  # pylint: disable=W0703
+            self.got_error(e)

=== added directory 'ubuntu_sso/networkstate/tests'
=== added file 'ubuntu_sso/networkstate/tests/__init__.py'
--- ubuntu_sso/networkstate/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/tests/__init__.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+"""Test the different networkstatus implementations."""

=== added file 'ubuntu_sso/networkstate/tests/test_linux.py'
--- ubuntu_sso/networkstate/tests/test_linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/tests/test_linux.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+#
+# test_networkstate - tests for ubuntu_sso.networkstate
+#
+# Author: Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the network state detection code."""
+
+from ubuntu_sso.networkstate import (NetworkManagerState,
+                                     ONLINE, OFFLINE, UNKNOWN)
+from ubuntu_sso.networkstate.linux import  (DBUS_UNKNOWN_SERVICE,
+                                            NM_STATE_DISCONNECTED,
+                                            NM_STATE_CONNECTING,
+                                            NM_STATE_CONNECTED)
+
+from mocker import ARGS, KWARGS, ANY, MockerTestCase
+
+
+class TestException(Exception):
+    """An exception to test error conditions."""
+    def get_dbus_name(self):
+        """A fake dbus name for this exception."""
+        return "Test Exception Message"
+
+
+class TestNmNotAvailableException(Exception):
+    """An exception to test unavailability conditions."""
+    def get_dbus_name(self):
+        """The real name of the dbus error when NM is not running."""
+        return DBUS_UNKNOWN_SERVICE
+
+
+class NetworkManagerStateTestCase(MockerTestCase):
+    """Test NetworkManager state retrieval code."""
+
+    def setUp(self):
+        """Setup the mocker dbus object tree."""
+        self.dbusmock = self.mocker.mock()
+        self.dbusmock.SystemBus()
+        sysbusmock = self.mocker.mock()
+        self.mocker.result(sysbusmock)
+
+        sysbusmock.get_object(ARGS, KWARGS)
+        proxymock = self.mocker.mock()
+        self.mocker.result(proxymock)
+
+        self.dbusmock.Interface(proxymock, ANY)
+        ifmock = self.mocker.mock()
+        self.mocker.result(ifmock)
+
+        ifmock.connect_to_signal(ARGS, KWARGS)
+        signalmock = self.mocker.mock()
+        self.mocker.result(signalmock)
+
+        proxymock.Get(ARGS, KWARGS)
+        signalmock.remove()
+
+        self.mocker.replay()
+
+    def test_nm_online(self):
+        """Check the connected case."""
+
+        def got_state_cb(state):
+            """State was given."""
+            self.assertEquals(state, ONLINE)
+
+        nms = NetworkManagerState(got_state_cb, self.dbusmock)
+        nms.find_online_state()
+        nms.got_state(NM_STATE_CONNECTED)
+
+    def test_nm_offline(self):
+        """Check the disconnected case."""
+
+        def got_state_cb(state):
+            """State was given."""
+            self.assertEquals(state, OFFLINE)
+
+        nms = NetworkManagerState(got_state_cb, self.dbusmock)
+        nms.find_online_state()
+        nms.got_state(NM_STATE_DISCONNECTED)
+
+    def test_nm_connecting_then_online(self):
+        """Check the waiting for connection case."""
+
+        def got_state_cb(state):
+            """State was given."""
+            self.assertEquals(state, ONLINE)
+
+        nms = NetworkManagerState(got_state_cb, self.dbusmock)
+        nms.find_online_state()
+        nms.got_state(NM_STATE_CONNECTING)
+        nms.state_changed(NM_STATE_CONNECTED)
+
+    def test_nm_connecting_then_offline(self):
+        """Check the waiting but fail case."""
+
+        def got_state_cb(state):
+            """State was given."""
+            self.assertEquals(state, OFFLINE)
+
+        nms = NetworkManagerState(got_state_cb, self.dbusmock)
+        nms.find_online_state()
+        nms.got_state(NM_STATE_CONNECTING)
+        nms.state_changed(NM_STATE_DISCONNECTED)
+
+
+class NetworkManagerStateErrorsTestCase(MockerTestCase):
+    """Test NetworkManager state retrieval code."""
+
+    # Statement seems to have no effect
+    # pylint: disable=W0104
+
+    def setUp(self):
+        """Setup the mocker dbus object tree."""
+        self.dbusmock = self.mocker.mock()
+        self.dbusmock.SystemBus()
+        self.sysbusmock = self.mocker.mock()
+        self.mocker.result(self.sysbusmock)
+        self.sysbusmock.get_object(ARGS, KWARGS)
+
+    def mock_except_while_getting_proxy(self, exc):
+        """Simulate an exception while getting the DBus proxy object."""
+        self.mocker.throw(exc)
+        self.dbusmock.exceptions.DBusException
+        self.mocker.result(exc)
+        self.mocker.replay()
+
+    def mock_dbus_error_while_getting_state(self, exc):
+        """Simulate an exception while getting the State."""
+        proxymock = self.mocker.mock()
+        self.mocker.result(proxymock)
+
+        self.dbusmock.Interface(proxymock, ANY)
+        ifmock = self.mocker.mock()
+        self.mocker.result(ifmock)
+
+        ifmock.connect_to_signal(ARGS, KWARGS)
+        signalmock = self.mocker.mock()
+        self.mocker.result(signalmock)
+
+        proxymock.Get(ARGS, KWARGS)
+        self.dbusmock.exceptions.DBusException
+        self.mocker.result(exc)
+        signalmock.remove()
+        self.mocker.replay()
+
+    def test_nm_not_running(self):
+        """Check the case when NM is not running."""
+
+        def got_state_cb(state):
+            """State was given."""
+            self.assertEquals(state, UNKNOWN)
+
+        self.mock_dbus_error_while_getting_state(TestNmNotAvailableException)
+        nms = NetworkManagerState(got_state_cb, self.dbusmock)
+        nms.find_online_state()
+        nms.got_error(TestNmNotAvailableException())
+
+    def test_dbus_problem(self):
+        """Check the case when DBus throws some other exception."""
+
+        def got_state_cb(state):
+            """State was given."""
+            self.assertEquals(state, UNKNOWN)
+
+        self.mock_except_while_getting_proxy(TestException)
+        nms = NetworkManagerState(got_state_cb, self.dbusmock)
+        nms.find_online_state()

=== added file 'ubuntu_sso/networkstate/tests/test_windows.py'
--- ubuntu_sso/networkstate/tests/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/tests/test_windows.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,119 @@
+# -*- 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/>.
+"""Tests for the network manager."""
+from mocker import MockerTestCase
+from ubuntu_sso.networkstate.windows import (
+    NetworkManager,
+    NetworkManagerState,
+    ONLINE,
+    OFFLINE)
+
+
+class TestNetworkManager(MockerTestCase):
+    """Test he Network Manager."""
+
+    def setUp(self):
+        super(TestNetworkManager, self).setUp()
+        self.connection_info = self.mocker.mock()
+        self.connection_no_info = self.mocker.mock()
+        self.disconnected = self.mocker.mock()
+        self.manager = NetworkManager(self.connection_no_info,
+                                      self.connection_info, self.disconnected)
+
+    def test_connection_made(self):
+        """Ensure db is called."""
+        self.connection_info()
+        self.mocker.replay()
+        self.manager.ConnectionMade()
+
+    def test_connection_made_no_cb(self):
+        """Ensure db is called."""
+        self.manager.connected_cb_info = None
+        self.mocker.replay()
+        self.manager.ConnectionMade()
+
+    def test_connection_made_no_info(self):
+        """Ensure db is called."""
+        self.connection_no_info()
+        self.mocker.replay()
+        self.manager.ConnectionMadeNoQOCInfo()
+
+    def test_connection_made_no_info_no_cb(self):
+        """Ensure db is called."""
+        self.manager.connected_cb = None
+        self.mocker.replay()
+        self.manager.ConnectionMadeNoQOCInfo()
+
+    def test_disconnection(self):
+        """Ensure db is called."""
+        self.disconnected()
+        self.mocker.replay()
+        self.manager.ConnectionLost()
+
+    def test_disconnection_no_cb(self):
+        """Ensure db is called."""
+        self.manager.disconnected_cb = None
+        self.mocker.replay()
+        self.manager.ConnectionLost()
+
+
+class TestNetworkManagerState(MockerTestCase):
+    """Test he Network Manager State."""
+
+    def setUp(self):
+        super(TestNetworkManagerState, self).setUp()
+        self.network_manager = self.mocker.mock()
+        self.is_connected = self.mocker.replace(
+            'ubuntu_sso.networkstate.windows.is_machine_connected')
+        self.thread = self.mocker.mock()
+        self.cb = self.mocker.mock()
+        self.state = NetworkManagerState(self.cb)
+
+    def test_connection_made(self):
+        """Test that the cb is actually called."""
+        self.cb(ONLINE)
+        self.mocker.replay()
+        self.state.connection_made()
+
+    def test_connection_lost(self):
+        """Test that the cb is actually called."""
+        self.cb(OFFLINE)
+        self.mocker.replay()
+        self.state.connection_lost()
+
+    def test_find_online_state_not_connected(self):
+        """Test that we do find the online state correctly."""
+        self.is_connected()
+        self.mocker.result(False)
+        self.cb(OFFLINE)
+        self.mocker.result(self.thread)
+        self.thread.start()
+        self.mocker.replay()
+        self.state.find_online_state(listener=self.network_manager,
+                                     listener_thread=self.thread)
+
+    def test_find_online_state_connected(self):
+        """Test that we do find the online state correctly."""
+        self.is_connected()
+        self.mocker.result(ONLINE)
+        self.cb(ONLINE)
+        self.mocker.result(self.thread)
+        self.thread.start()
+        self.mocker.replay()
+        self.state.find_online_state(listener=self.network_manager,
+                                     listener_thread=self.thread)

=== added file 'ubuntu_sso/networkstate/windows.py'
--- ubuntu_sso/networkstate/windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/windows.py	2011-03-23 14:22:30 +0000
@@ -0,0 +1,199 @@
+# -*- 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/>.
+"""Network status implementation on Windows."""
+
+
+# pylint: disable=F0401
+# distutils-extra: ignore-import=pythoncom,win32com.server.policy
+# distutils-extra: ignore-import=win32com.client
+import pythoncom
+# pylint: enable=F0401
+from ctypes import windll, byref
+from ctypes.wintypes import DWORD
+from threading import Thread
+# pylint: disable=F0401
+from win32com.server.policy import DesignatedWrapPolicy
+from win32com.client import Dispatch
+# pylint: enable=F0401
+
+from ubuntu_sso.logger import setup_logging
+
+logger = setup_logging("ubuntu_sso.networkstate")
+
+# naming errors are deliberated because we are following the COM naming to make
+# it clear for later developers.
+# pylint: disable=C0103
+
+# Values returned by the callback
+ONLINE, OFFLINE, UNKNOWN = object(), object(), object()
+
+## from EventSys.h
+PROGID_EventSystem = "EventSystem.EventSystem"
+PROGID_EventSubscription = "EventSystem.EventSubscription"
+
+# SENS (System Event Notification Service) values for the events,
+# this events contain the uuid of the event, the name of the event to be used
+# as well as the method name of the method in the ISesNetwork interface that
+# will be executed for the event.
+# For more info look at:
+# http://msdn.microsoft.com/en-us/library/aa377384(v=vs.85).aspx
+
+SUBSCRIPTION_NETALIVE = ('{cd1dcbd6-a14d-4823-a0d2-8473afde360f}',
+                         'UbuntuOne Network Alive',
+                         'ConnectionMade')
+
+SUBSCRIPTION_NETALIVE_NOQOC = ('{a82f0e80-1305-400c-ba56-375ae04264a1}',
+                               'UbuntuOne Net Alive No Info',
+                               'ConnectionMadeNoQOCInfo')
+
+SUBSCRIPTION_NETLOST = ('{45233130-b6c3-44fb-a6af-487c47cee611}',
+                        'UbuntuOne Network Lost',
+                        'ConnectionLost')
+
+SUBSCRIPTION_REACH = ('{4c6b2afa-3235-4185-8558-57a7a922ac7b}',
+                       'UbuntuOne Network Reach',
+                       'ConnectionMade')
+
+SUBSCRIPTION_REACH_NOQOC = ('{db62fa23-4c3e-47a3-aef2-b843016177cf}',
+                            'UbuntuOne Network Reach No Info',
+                            'ConnectionMadeNoQOCInfo')
+
+SUBSCRIPTION_REACH_NOQOC2 = ('{d4d8097a-60c6-440d-a6da-918b619ae4b7}',
+                             'UbuntuOne Network Reach No Info 2',
+                             'ConnectionMadeNoQOCInfo')
+
+SUBSCRIPTIONS = [SUBSCRIPTION_NETALIVE,
+                 SUBSCRIPTION_NETALIVE_NOQOC,
+                 SUBSCRIPTION_NETLOST,
+                 SUBSCRIPTION_REACH,
+                 SUBSCRIPTION_REACH_NOQOC,
+                 SUBSCRIPTION_REACH_NOQOC2]
+
+SENSGUID_EVENTCLASS_NETWORK = '{d5978620-5b9f-11d1-8dd2-00aa004abd5e}'
+SENSGUID_PUBLISHER = "{5fee1bd6-5b9b-11d1-8dd2-00aa004abd5e}"
+
+# uuid of the implemented com interface
+IID_ISesNetwork = '{d597bab1-5b9f-11d1-8dd2-00aa004abd5e}'
+
+
+class NetworkManager(DesignatedWrapPolicy):
+    """Implement ISesNetwork to know about the network status."""
+
+    _com_interfaces_ = [IID_ISesNetwork]
+    _public_methods_ = ['ConnectionMade',
+                        'ConnectionMadeNoQOCInfo',
+                        'ConnectionLost']
+    _reg_clsid_ = '{41B032DA-86B5-4907-A7F7-958E59333010}'
+    _reg_progid_ = "UbuntuOne.NetworkManager"
+
+    def __init__(self, connected_cb=None, connected_cb_info=None,
+                 disconnected_cb=None):
+        # pylint: disable=E1101
+        self._wrap_(self)
+        # pylint: enable=E1101
+        self.connected_cb = connected_cb
+        self.connected_cb_info = connected_cb_info
+        self.disconnected_cb = disconnected_cb
+
+    def ConnectionMade(self, *args):
+        """Tell that the connection is up again."""
+        logger.info('Connection was made.')
+        if self.connected_cb_info:
+            self.connected_cb_info()
+
+    def ConnectionMadeNoQOCInfo(self, *args):
+        """Tell that the connection is up again."""
+        logger.info('Connection was made no info.')
+        if self.connected_cb:
+            self.connected_cb()
+
+    def ConnectionLost(self, *args):
+        """Tell the connection was lost."""
+        logger.info('Connection was lost.')
+        if self.disconnected_cb:
+            self.disconnected_cb()
+
+    def register(self):
+        """Register to listen to network events."""
+        # call the CoInitialize to allow the registration to run in another
+        # thread
+        pythoncom.CoInitialize()
+        # interface to be used by com
+        manager_interface = pythoncom.WrapObject(self)
+        event_system = Dispatch(PROGID_EventSystem)
+        # register to listen to each of the events to make sure that
+        # the code will work on all platforms.
+        for current_event in SUBSCRIPTIONS:
+            # create an event subscription and add it to the event
+            # service
+            event_subscription = Dispatch(PROGID_EventSubscription)
+            event_subscription.EventClassId = SENSGUID_EVENTCLASS_NETWORK
+            event_subscription.PublisherID = SENSGUID_PUBLISHER
+            event_subscription.SubscriptionID = current_event[0]
+            event_subscription.SubscriptionName = current_event[1]
+            event_subscription.MethodName = current_event[2]
+            event_subscription.SubscriberInterface = manager_interface
+            event_subscription.PerUser = True
+            # store the event
+            try:
+                event_system.Store(PROGID_EventSubscription,
+                                   event_subscription)
+            except pythoncom.com_error as e:
+                logger.error(
+                    'Error registering %s to event %s', e, current_event[1])
+
+        pythoncom.PumpMessages()
+
+
+def is_machine_connected():
+    """Return if the machine is connected to the internet."""
+    wininet = windll.wininet
+    flags = DWORD()
+    connected = wininet.InternetGetConnectedState(byref(flags), None)
+    return connected == 1
+
+
+class NetworkManagerState(object):
+    """Check for status changed in the network on Windows."""
+
+    def __init__(self, result_cb, **kwargs):
+        """Initialize this instance with a result and error callbacks."""
+        self.result_cb = result_cb
+
+    def connection_made(self):
+        """Return the connection state over the call back."""
+        self.result_cb(ONLINE)
+
+    def connection_lost(self):
+        """Return the connection was lost over the call back."""
+        self.result_cb(OFFLINE)
+