Merge lp:~mandel/ubuntu-sso-client/implement_windows_main_1 into lp:ubuntu-sso-client

[Manuel de la Peña]

First step of implementing the code in main on windows.

First step of implementing the code in main on windows.

[lp:~mandel/ubuntu-sso-client/implement_windows_main_1]

689. By Manuel de la Peña on 2011-03-09

Merged implement_windows_networkstatus into implement_windows_main_1.

690. By Manuel de la Peña on 2011-03-10

Merged implement_windows_networkstatus into implement_windows_main_1.

691. By Manuel de la Peña on 2011-03-10

Merged implement_windows_networkstatus into implement_windows_main_1.

692. By Manuel de la Peña on 2011-03-16

Renamed test files so they are correctly ignored.

693. By Manuel de la Peña on 2011-03-16

Renamed test files so they are correctly ignored.

[Roberto Alsina (ralsina)]

+1 on windows

review: Approve

[Alejandro J. Cura (alecu)]

When running the tests on natty:

alecu@breetai:~/canonical/ubuntu-sso-client/review_implement_windows_main_1$ ./run-tests
Running test suite for ubuntu_sso
Xlib: extension "RANDR" missing on display ":99".
Traceback (most recent call last):
  File "/usr/bin/u1trial", line 246, in <module>
    main()
  File "/usr/bin/u1trial", line 243, in main
    TestRunner(force_gc=options.force_gc).run(testpath, options)
  File "/usr/bin/u1trial", line 181, in run
    options.ignored_modules, options.ignored_paths)
  File "/usr/bin/u1trial", line 160, in _collect_tests
    module_suite = self._load_unittest(filepath)
  File "/usr/bin/u1trial", line 88, in _load_unittest
    module = __import__(modpath, None, None, [""])
  File "/home/alecu/canonical/ubuntu-sso-client/review_implement_windows_main_1/ubuntu_sso/tests/networkstate/test_windows.py", line 20, in <module>
    from ubuntu_sso.networkstate.windows import (
  File "/home/alecu/canonical/ubuntu-sso-client/review_implement_windows_main_1/ubuntu_sso/networkstate/windows.py", line 23, in <module>
    import pythoncom
ImportError: No module named pythoncom

review: Needs Fixing

[lp:~mandel/ubuntu-sso-client/implement_windows_main_1]

694. By Manuel de la Peña on 2011-03-16

Added the correct ignore to the runt-test script.

695. By Manuel de la Peña on 2011-03-16

Fixed style issues.

[Alejandro J. Cura (alecu)]

Great branch!

A couple of minor nitpicks:

 * a small typo: "Object object"
 * and a weird name for a test method: CredentialsManagementMockedTestCase.login (looks like it should be named test_login)

review: Approve

[Manuel de la Peña (mandel)]

Alecu,

Thanks for the comments, I'll fix those two thing you mentioned, better now than never :)

[lp:~mandel/ubuntu-sso-client/implement_windows_main_1]

696. By Manuel de la Peña on 2011-03-16

Fixed test name and small typo.

=== modified file 'run-tests'
--- run-tests	2011-02-24 02:46:19 +0000
+++ run-tests	2011-03-17 08:43:34 +0000
@@ -33,5 +33,5 @@
 }
 
 echo "Running test suite for ""$MODULE"
-`which xvfb-run` u1trial "$MODULE" -i "test_windows_networkstate.py" && style_check
+`which xvfb-run` u1trial "$MODULE" -i "test_windows.py" && style_check
 rm -rf _trial_temp
 
=== modified file 'run-tests.bat'
--- run-tests.bat	2011-03-15 08:27:10 +0000
+++ run-tests.bat	2011-03-17 08:43:34 +0000
@@ -51,7 +51,7 @@
 :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_keyring.py, test_linux_network_state.py"
+"%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"
 
=== added directory 'ubuntu_sso/main'
=== 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-17 08:43:34 +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, 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,
+                                                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
 
=== renamed file 'ubuntu_sso/main.py' => 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main.py	2011-01-28 13:45:09 +0000
+++ ubuntu_sso/main/linux.py	2011-03-17 08:43:34 +0000
@@ -27,21 +27,17 @@
 
 """
 
-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.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
@@ -49,39 +45,9 @@
 
 
 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():
@@ -107,9 +73,7 @@
         """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)
+        self.root = SSOLoginRoot(sso_login_processor_class, sso_service_class)
 
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -128,11 +92,9 @@
                          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)
+        self.root.generate_captcha(app_name, filename, blocking,
+                                   self.CaptchaGenerated,
+                                   self.CaptchaGenerationError)
 
     # register_user signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -152,11 +114,10 @@
     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)
+        self.root.register_user(app_name, email, password, captcha_id,
+                                captcha_solution, blocking,
+                                self.UserRegistered,
+                                self.UserRegistrationError)
 
     # login signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -181,30 +142,8 @@
                          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)
+        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")
@@ -223,23 +162,9 @@
                          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)
+        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")
@@ -258,11 +183,9 @@
                          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)
+        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")
@@ -281,11 +204,9 @@
                          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)
+        self.root.set_new_password(app_name, email, token, new_password,
+                                   blocking, self.PasswordChanged,
+                                   self.PasswordChangeError)
 
 
 class SSOCredentials(dbus.service.Object):
@@ -296,7 +217,7 @@
 
     def __init__(self, *args, **kwargs):
         dbus.service.Object.__init__(self, *args, **kwargs)
-        self.ping_url = os.environ.get('USSOC_PING_URL', U1_PING_URL)
+        self.root = SSOCredentialsRoot()
 
     def _process_error(self, app_name, error_dict):
         """Process the 'error_dict' and emit CredentialsError."""
@@ -327,17 +248,7 @@
                          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)
+        self.root.find_credentials(app_name, callback, errback)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
                          in_signature="sssx", out_signature="")
@@ -354,14 +265,12 @@
          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()
+        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="")
@@ -375,13 +284,10 @@
          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()
+        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='',
@@ -391,9 +297,7 @@
 
         'app_name' is the name of the application.
         """
-        d = Credentials(app_name=app_name).clear_credentials()
-        # pylint: disable=E1101
-        d.addCallbacks(lambda _: callback(), errback)
+        self.root.clear_token(app_name, callback, errback)
 
 
 class CredentialsManagement(dbus.service.Object):
@@ -427,22 +331,13 @@
         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
 
-    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))
@@ -539,11 +434,8 @@
             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)
+        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='')
@@ -557,12 +449,9 @@
 
         """
         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)
+        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='')
@@ -578,27 +467,20 @@
 
         """
         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)
+        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
-
-        obj = Credentials(app_name, **self._parse_args(args))
-        obj.register()
+        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
-
-        obj = Credentials(app_name, **self._parse_args(args))
-        obj.login()
+        self.root.login(app_name, args)
 
=== 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-17 08:43:34 +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."""
 
=== renamed file 'ubuntu_sso/tests/keyring/test_linux_keyring.py' => 'ubuntu_sso/tests/keyring/test_linux.py'
=== renamed file 'ubuntu_sso/tests/keyring/test_windows_keyring.py' => 'ubuntu_sso/tests/keyring/test_windows.py'
=== added directory 'ubuntu_sso/tests/main'
=== added file 'ubuntu_sso/tests/main/__init__.py'
--- ubuntu_sso/tests/main/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/main/__init__.py	2011-03-17 08:43:34 +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/tests/main/test_common.py'
--- ubuntu_sso/tests/main/test_common.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/main/test_common.py	2011-03-17 08:43:34 +0000
@@ -0,0 +1,244 @@
+# -*- 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'
+        captcha_id = 'id'
+        captcha_solution = 'hello'
+        self.root.register_user(app_name, email, password, captcha_id,
+                                captcha_solution, MATCH(callable),
+                                MATCH(callable), MATCH(callable))
+        self.mocker.replay()
+        self.login.register_user(app_name, email, password, 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)
 
=== renamed file 'ubuntu_sso/tests/test_main.py' => 'ubuntu_sso/tests/main/test_linux.py'
--- ubuntu_sso/tests/test_main.py	2011-01-28 13:45:09 +0000
+++ ubuntu_sso/tests/main/test_linux.py	2011-03-17 08:43:34 +0000
@@ -31,12 +31,13 @@
 
 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, TIMEOUT_INTERVAL,
-    blocking, except_to_errdict,
+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)
@@ -120,7 +121,7 @@
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -143,7 +144,7 @@
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -166,7 +167,7 @@
         self.create_mock_processor().register_user(EMAIL, PASSWORD, CAPTCHA_ID,
                                                    CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -190,7 +191,7 @@
         self.create_mock_processor().register_user(EMAIL, PASSWORD, CAPTCHA_ID,
                                                    CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -215,7 +216,7 @@
         self.mocker.result(TOKEN)
         processor.is_validated(TOKEN)
         self.mocker.result(True)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -241,7 +242,7 @@
         self.mocker.result(TOKEN)
         processor.is_validated(TOKEN)
         self.mocker.result(False)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, email):
@@ -263,7 +264,7 @@
         """The login method fails as expected when get_token_name fails."""
         d = Deferred()
         self.create_mock_processor()
-        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
 
         def fake_gtn(*args):
             """A fake get_token_name that fails."""
@@ -296,7 +297,7 @@
         processor.is_validated(TOKEN)
         self.mocker.result(True)
 
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
 
         def fake_set_creds(*args):
             """A fake Keyring.set_credentials that fails."""
@@ -327,7 +328,7 @@
         self.create_mock_processor().validate_email(EMAIL, PASSWORD,
                                                     EMAIL_TOKEN, TOKEN_NAME)
         self.mocker.result(TOKEN)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -348,7 +349,7 @@
         """Test that the validate_email method fails as expected."""
         d = Deferred()
         self.create_mock_processor()
-        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
 
         def fake_gtn(*args):
             """A fake get_token_name that fails."""
@@ -376,7 +377,7 @@
         d = Deferred()
         processor = self.create_mock_processor()
         processor.request_password_reset_token(EMAIL)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.result(EMAIL)
         self.mocker.replay()
 
@@ -399,7 +400,7 @@
 
         self.create_mock_processor().request_password_reset_token(EMAIL)
         self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -421,7 +422,7 @@
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
                                                       PASSWORD)
         self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main, "blocking", fake_ok_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
         self.mocker.replay()
 
         def verify(app_name, result):
@@ -445,7 +446,7 @@
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
                                                       PASSWORD)
         self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", fake_err_blocking)
+        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
         self.mocker.replay()
 
         def verify(app_name, errdict):
@@ -687,7 +688,7 @@
         os.environ['USSOC_PING_URL'] = fake_url
         try:
             creds = SSOCredentials(None)
-            self.assertEqual(creds.ping_url, fake_url)
+            self.assertEqual(creds.root.ping_url, fake_url)
         finally:
             if old_url:
                 os.environ['USSOC_PING_URL'] = old_url
@@ -697,7 +698,7 @@
     def test_no_override_ping_url(self):
         """If the environ is unset, the default ping url is used."""
         creds = SSOCredentials(None)
-        self.assertEqual(creds.ping_url, U1_PING_URL)
+        self.assertEqual(creds.root.ping_url, U1_PING_URL)
 
 
 class CredentialsManagementTestCase(TestCase):
@@ -746,7 +747,8 @@
 
     def test_is_dbus_object(self):
         """CredentialsManagement is a Dbus object."""
-        self.assertIsInstance(self.client, ubuntu_sso.main.dbus.service.Object)
+        self.assertIsInstance(self.client,
+                              ubuntu_sso.main.linux.dbus.service.Object)
 
 
 class FakeCredentials(object):
 
=== added file 'ubuntu_sso/tests/main/test_windows.py'
--- ubuntu_sso/tests/main/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/tests/main/test_windows.py	2011-03-17 08:43:34 +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."""
 
=== renamed file 'ubuntu_sso/tests/networkstate/test_linux_networkstate.py' => 'ubuntu_sso/tests/networkstate/test_linux.py'
=== renamed file 'ubuntu_sso/tests/networkstate/test_windows_networkstate.py' => 'ubuntu_sso/tests/networkstate/test_windows.py'