Merge lp:~nataliabidart/magicicada-client/no-sso-client into lp:magicicada-client

[Natalia Bidart]

- Decouple client code from ubuntu-sso-client code. Copied and made an initial cleanup on the networkstate, utils and keyring modules.
- Removed completely dependencies with oauthlibs.
- Moved tests/ folder to inside ubuntuone/ proper folders.

Test run OK at: http://linkode.org/IHPqxlohoqyyzjD20htu11

[lp:~nataliabidart/magicicada-client/no-sso-client]

1429. By Natalia Bidart on 2016-05-28

Removed debug print.

1430. By Natalia Bidart on 2016-05-28

Fixed copyright notices.

1431. By Natalia Bidart on 2016-05-29

Removed almost every mention of Magicicada.

1432. By Natalia Bidart on 2016-05-29

Fixed missing imports.

1433. By Natalia Bidart on 2016-05-29

More tests fixed.

1434. By Natalia Bidart on 2016-05-29

Moved tests inside ubuntuone folder.

1435. By Natalia Bidart on 2016-05-29

Proper tests paths in run-tests.

1436. By Natalia Bidart on 2016-05-29

No need for multiple support for keyring. No need for runner.

1437. By Natalia Bidart on 2016-05-29

All tests passing.

1438. By Natalia Bidart on 2016-05-29

Revert changes to run-tests.

1439. By Natalia Bidart on 2016-05-30

Add chicharreros copyright, fixed typo.

[Facundo Batista (facundo)]

Go go

review: Approve

=== modified file '.travis.yml'
--- .travis.yml	2015-09-19 20:49:35 +0000
+++ .travis.yml	2016-05-30 13:04:07 +0000
@@ -1,5 +1,6 @@
 before_install:
     - sudo apt-get update
+    - sudo apt-get dist-upgrade -y
     - make clean
     - make bootstrap
 

=== removed file 'bin/ubuntuone-login'
--- bin/ubuntuone-login	2015-09-29 21:05:26 +0000
+++ bin/ubuntuone-login	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""The script tu run the Login D-Bus service."""
-
-# Invalid name "ubuntuone-login"
-
-import logging
-import os
-import sys
-
-import dbus.mainloop.glib
-import dbus.service
-
-from gi.repository import GLib
-from ubuntuone.logger import basic_formatter
-from ubuntuone.platform.credentials import logger
-from ubuntuone.platform.credentials.dbus_service import (
-    DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
-    CredentialsManagement,
-)
-
-dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-
-
-if __name__ == "__main__":
-    # Register DBus service for making sure we run only one instance
-    try:
-        bus = dbus.SessionBus()
-        name = bus.request_name(DBUS_BUS_NAME,
-                                dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-        if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-            logger.error(Login manager already running, quitting.")
-            sys.exit(0)
-    except dbus.DBusException:
-        pass
-    else:
-        if os.environ.get('U1_DEBUG'):
-            debug_handler = logging.StreamHandler(sys.stderr)
-            debug_handler.setFormatter(basic_formatter)
-            debug_handler.setLevel(logging.DEBUG)
-            logger.setLevel(logging.DEBUG)
-            logger.addHandler(debug_handler)
-
-        logger.info("Starting login manager for bus %r.",
-                    DBUS_BUS_NAME)
-        bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=bus)
-        mainloop = GLib.MainLoop()
-        CredentialsManagement(timeout_func=GLib.timeout_add,
-                              shutdown_func=mainloop.quit,
-                              bus_name=bus_name,
-                              object_path=DBUS_CREDENTIALS_PATH)
-
-        mainloop.run()

=== modified file 'contrib/check-reactor-import'
--- contrib/check-reactor-import	2013-06-10 21:21:11 +0000
+++ contrib/check-reactor-import	2016-05-30 13:04:07 +0000
@@ -31,10 +31,9 @@
 # NOTE: the goal of this script is to avoid a bug that affects
 # ubuntuone-control-panel on windows and darwin. Those platforms use
 # the qt4reactor, and will break if the default reactor is installed
-# first. This can happen if a module used by control-panel (such as
-# ubuntuone.platform.credentials), imports reactor.  Only sub-modules
-# that are not used by ubuntuone-control-panel can safely import
-# reactor at module-level.
+# first. This can happen if a module used by control-panel imports reactor.
+# Only sub-modules that are not used by ubuntuone-control-panel can safely
+# import reactor at module-level.
 
 from __future__ import (unicode_literals, print_function)
 
@@ -72,6 +71,6 @@
     real_import = __builtin__.__import__
     __builtin__.__import__ = fake_import
 
-    subs = ["", ".tools", ".logger", ".credentials"]
+    subs = ["", ".tools", ".logger"]
     for module in ["ubuntuone.platform" + p for p in subs]:
         m = __import__(module)

=== modified file 'contrib/draw-fsm'
--- contrib/draw-fsm	2013-06-07 15:22:31 +0000
+++ contrib/draw-fsm	2016-05-30 13:04:07 +0000
@@ -35,7 +35,6 @@
 import time
 import sys
 
-# pylint: disable-msg=F0401
 from gi.repository import Gtk as gtk
 
 import xdot

=== removed file 'contrib/login_email_password.py'
--- contrib/login_email_password.py	2013-01-28 18:10:43 +0000
+++ contrib/login_email_password.py	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2013 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Script that shows the qt gui."""
-
-import sys
-
-if sys.platform != 'win32':
-    from twisted.internet import gireactor
-    gireactor.install()
-
-from twisted.internet import reactor
-from twisted.internet.defer import inlineCallbacks
-from ubuntuone.platform.credentials import CredentialsManagementTool
-
-
-@inlineCallbacks
-def main(email='[e-mail]', password='whatever'):
-    """Perform a client request to be logged in."""
-    credtool = CredentialsManagementTool()
-    print 'Trying to get credentials for email:', email
-    try:
-        creds = yield credtool.login_email_password(email=email,
-                                                    password=password)
-        print "creds found!", creds
-    except Exception, e:
-        print "creds error!", e
-    reactor.stop()
-
-
-if __name__ == '__main__':
-    print 'Enter email:'
-    email = raw_input()
-    print 'Enter password:'
-    password = raw_input()
-    main(email=email, password=password)
-    reactor.run()

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2015-05-18 21:20:05 +0000
+++ contrib/testing/testcase.py	2016-05-30 13:04:07 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright 2009-2015 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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
@@ -679,7 +680,7 @@
 
     def __init__(self, main, send_events=False, interface=None):
         super(FakedService, self).__init__(main, send_events, interface)
-        self.oauth_credentials = ('foo', 'bar')
+        self.auth_credentials = ('foo', 'bar')
 
     def _create_children(self):
         """Override parent's method to have fakes for children."""

=== removed file 'data/com.ubuntuone.Credentials.service.in'
--- data/com.ubuntuone.Credentials.service.in	2011-01-04 13:09:01 +0000
+++ data/com.ubuntuone.Credentials.service.in	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-[D-BUS Service]
-Name=com.ubuntuone.Credentials
-Exec=@libexecdir@/ubuntuone-login
-

=== modified file 'dependencies-devel.txt'
--- dependencies-devel.txt	2015-09-19 21:11:52 +0000
+++ dependencies-devel.txt	2016-05-30 13:04:07 +0000
@@ -1,6 +1,7 @@
 bzr
 make
 python-distutils-extra
+python-flake8
 python-mocker
 python-virtualenv
 ubuntuone-dev-tools

=== modified file 'dependencies.txt'
--- dependencies.txt	2015-09-20 00:21:25 +0000
+++ dependencies.txt	2016-05-30 13:04:07 +0000
@@ -1,10 +1,11 @@
 gir1.2-notify
+gir1.2-soup-2.4
 protobuf-compiler
 python-configglue
 python-gi
+python-httplib2
 python-protobuf
 python-pyinotify
 python-qt4-dbus
 python-qt4reactor
 python-twisted
-python-ubuntu-sso-client

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2013-06-05 20:09:11 +0000
+++ po/POTFILES.in	2016-05-30 13:04:07 +0000
@@ -1,4 +1,3 @@
 ubuntuone/clientdefs.py.in
 ubuntuone/status/aggregator.py
-ubuntuone/platform/credentials/__init__.py
 ubuntuone/platform/sync_menu/linux.py

=== modified file 'run-tests'
--- run-tests	2015-09-20 19:24:59 +0000
+++ run-tests	2016-05-30 13:04:07 +0000
@@ -27,7 +27,7 @@
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
 
-PROXY_TESTS_PATH="tests/proxy"
+PROXY_TESTS_PATH="ubuntuone/proxy/tests"
 
 # Allow alternative python executable via environment variable.  This is
 # useful for virtualenv testing.
@@ -39,19 +39,19 @@
     MODULE="$@"
 else
     # run all tests, useful for tarmac and reviews
-    MODULE="tests"
+    MODULE="ubuntuone"
 fi
 
 SYSNAME=`uname -s`
 
 if [ "$SYSNAME" == "Darwin" ]; then
     IGNORE_FILES="test_linux.py,test_windows.py"
-    IGNORE_PATHS="tests/platform/linux"
+    IGNORE_PATHS="ubuntuone/platform/tests/linux"
     REACTOR=qt4
 else
     # Linux
     IGNORE_FILES="test_darwin.py,test_fsevents_daemon.py,test_windows.py"
-    IGNORE_PATHS="tests/platform/windows"
+    IGNORE_PATHS="ubuntuone/platform/tests/windows"
     REACTOR=gi
 fi
 

=== modified file 'setup.py'
--- setup.py	2015-09-17 02:20:40 +0000
+++ setup.py	2016-05-30 13:04:07 +0000
@@ -170,13 +170,9 @@
 def set_py2exe_paths():
     """Set the path so that py2exe finds the required modules."""
     # Pylint does not understand same spaced imports
-    # pylint: disable=F0401
     import win32com
-    # pylint: enable=F0401
     try:
-        # pylint: disable=F0401
         import py2exe.mf as modulefinder
-        # pylint: enable=F0401
     except ImportError:
         import modulefinder
 
@@ -194,8 +190,6 @@
             modulefinder.AddPackagePath(extra_mod, module_path)
 
 
-# pylint: disable=C0103
-
 cmdclass = {
     'install': Install,
     'build': Build,
@@ -209,7 +203,6 @@
 ]
 
 libexec_scripts = [
-    'bin/ubuntuone-login',
     'bin/ubuntuone-proxy-tunnel',
     'bin/ubuntuone-syncdaemon',
 ]

=== removed directory 'tests/api'
=== removed directory 'tests/platform/credentials'
=== removed file 'tests/platform/credentials/__init__.py'
--- tests/platform/credentials/__init__.py	2015-09-19 23:15:50 +0000
+++ tests/platform/credentials/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,28 +0,0 @@
-# Copyright 2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Credentials test code."""

=== removed file 'tests/platform/credentials/test_ipc_service.py'
--- tests/platform/credentials/test_ipc_service.py	2015-09-17 02:20:40 +0000
+++ tests/platform/credentials/test_ipc_service.py	1970-01-01 00:00:00 +0000
@@ -1,328 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2011-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Tests for the Magicicada credentials management IPC service."""
-
-import logging
-
-from twisted.internet import defer
-from twisted.trial.unittest import TestCase
-
-from contrib.testing.testcase import FAKED_CREDENTIALS
-from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.platform.credentials import APP_NAME
-from ubuntuone.platform.credentials.ipc_service import (
-    CredentialsManagement,
-    RemovableSignal,
-    logger,
-)
-
-TEST_APP_NAME = "test application"
-TEST_ERROR_DICT = {}
-TEST_CREDENTIALS = FAKED_CREDENTIALS
-
-
-class FakeSSOProxy(object):
-    """A fake SSOProxy."""
-
-    def __init__(self):
-        """Initialize this fake."""
-        signals = [
-            "credentials_stored",
-            "credentials_cleared",
-            "credentials_found",
-            "credentials_not_found",
-            "authorization_denied",
-            "credentials_error",
-        ]
-        for s in signals:
-            handler_name = "on_%s" % s
-            callback_name = "on_%s_cb" % s
-
-            def make_handler(callback_name):
-                """Create a handler for a given callback_name."""
-
-                def handler(*args):
-                    """A signal was called."""
-                    callback = getattr(self, callback_name, None)
-                    if callback is not None:
-                        callback(*args)
-
-                return handler
-
-            setattr(self, handler_name, make_handler(callback_name))
-            setattr(self, callback_name, None)
-
-
-    def find_credentials(self, app_name, options):
-        """Ask the U1 credentials."""
-        return defer.succeed(TEST_CREDENTIALS)
-
-    def clear_credentials(self, app_name, options):
-        """Clear the U1 credentials."""
-        return defer.succeed(None)
-
-    def store_credentials(self, app_name, options):
-        """Store the U1 credentials."""
-        return defer.succeed(None)
-
-    def register(self, app_name, options):
-        """Register."""
-        return defer.succeed(None)
-
-    def login(self, app_name, options):
-        """Login."""
-        return defer.succeed(None)
-
-    def login_email_password(self, app_name, options):
-        """Login using email and password."""
-        return defer.succeed(None)
-
-
-class RemovableSignalTestCase(TestCase):
-    """Tests for RemovableSignal."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(RemovableSignalTestCase, self).setUp()
-        self.proxy = FakeSSOProxy()
-
-    def test_creation(self):
-        """When creating, bind properly to self.proxy."""
-        rs = RemovableSignal(self.proxy, "test", lambda *a: None)
-        self.assertIs(self.proxy.test, rs)
-
-    def test_dunder_callable(self):
-        """__call__ works as expected."""
-        sample_store = []
-        expected = object()
-        test_cb = lambda res: sample_store.append(res)
-        rs = RemovableSignal(self.proxy, "on_credentials_found_cb", test_cb)
-        rs(APP_NAME, expected)
-        self.assertEqual(sample_store, [expected])
-
-    def test_callable_does_not_log_args(self):
-        """__call__ does not log its arguments."""
-        self.handler = MementoHandler()
-        self.handler.setLevel(logging.DEBUG)
-        logger.addHandler(self.handler)
-        self.addCleanup(logger.removeHandler, self.handler)
-
-        secret_token = "secret token!"
-        test_cb = lambda _: None
-        rs = RemovableSignal(self.proxy, "on_credentials_found_cb", test_cb)
-
-        rs(APP_NAME, {"secret": secret_token})
-        for record in self.handler.records:
-            self.assertNotIn(secret_token, record.message)
-
-    def test_dunder_filters_other_apps(self):
-        """__call__ filters by app_name."""
-        sample_store = []
-        test_cb = lambda res: sample_store.append(res)
-        rs = RemovableSignal(self.proxy, "on_credentials_found_cb", test_cb)
-        rs('other app name', object())
-        self.assertEqual(sample_store, [])
-
-    def test_remove(self):
-        """The signal has a .remove that removes the callback."""
-        sample_store = []
-        test_cb = lambda app_name, creds: sample_store.append(creds)
-        rs = RemovableSignal(self.proxy, "on_credentials_found_cb", test_cb)
-        rs.remove()
-        rs(TEST_APP_NAME, TEST_CREDENTIALS)
-        self.assertEqual(len(sample_store), 0)
-
-
-class CredentialsManagementTestCase(TestCase):
-    """Tests for CredentialsManagement."""
-
-    timeout = 5
-    app_name = APP_NAME
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsManagementTestCase, self).setUp()
-        self._called = False
-        self.proxy = FakeSSOProxy()
-        self.cm = CredentialsManagement(self.proxy)
-
-    def _set_called(self, *args, **kwargs):
-        """Helper to keep track calls."""
-        self._called = (args, kwargs)
-
-    def assert_callback_called(self, expected):
-        """Test that _called helper holds 'expected'."""
-        self.assertEqual(self._called, expected)
-
-    def test_find_credentials(self):
-        """Test the find_credentials method."""
-        d = defer.Deferred()
-        ok = lambda: d.callback("ok")
-        error = lambda *args: d.errback(args)
-        self.cm.find_credentials(reply_handler=ok, error_handler=error)
-        return d
-
-    def test_clear_credentials(self):
-        """Test the clear_credentials method."""
-        d = defer.Deferred()
-        ok = lambda: d.callback("ok")
-        error = lambda *args: d.errback(args)
-        self.cm.clear_credentials(reply_handler=ok, error_handler=error)
-        return d
-
-    def test_store_credentials(self):
-        """Test the store_credentials method."""
-        d = defer.Deferred()
-        ok = lambda: d.callback("ok")
-        error = lambda *args: d.errback(args)
-        self.cm.store_credentials(TEST_CREDENTIALS, reply_handler=ok,
-                                  error_handler=error)
-        return d
-
-    def test_register(self):
-        """Test the register method."""
-        d = defer.Deferred()
-        ok = lambda: d.callback("ok")
-        error = lambda *args: d.errback(args)
-        self.cm.register({}, reply_handler=ok, error_handler=error)
-        return d
-
-    def test_login(self):
-        """Test the login method."""
-        d = defer.Deferred()
-        ok = lambda: d.callback("ok")
-        error = lambda *args: d.errback(args)
-        self.cm.login({}, reply_handler=ok, error_handler=error)
-        return d
-
-    def test_login_email_password(self):
-        """Test the login_email_password method."""
-        d = defer.Deferred()
-        ok = lambda: d.callback("ok")
-        error = lambda *args: d.errback(args)
-        self.cm.login_email_password({'email': 'foo', 'password': 'bar'},
-                                     reply_handler=ok, error_handler=error)
-        return d
-
-    def test_register_to_credentials_found(self):
-        """Test the register_to_credentials_found method."""
-        signal = self.cm.register_to_credentials_found(self._set_called)
-        signal(self.app_name, TEST_CREDENTIALS)
-        self.assert_callback_called(((TEST_CREDENTIALS,), {}))
-
-    def test_register_to_credentials_not_found(self):
-        """Test the register_to_credentials_not_found method."""
-        signal = self.cm.register_to_credentials_not_found(self._set_called)
-        signal(self.app_name)
-        self.assert_callback_called(((), {}))
-
-    def test_register_to_credentials_stored(self):
-        """Test the register_to_credentials_stored method."""
-        signal = self.cm.register_to_credentials_stored(self._set_called)
-        signal(self.app_name)
-        self.assert_callback_called(((), {}))
-
-    def test_register_to_credentials_cleared(self):
-        """Test the register_to_credentials_cleared method."""
-        signal = self.cm.register_to_credentials_cleared(self._set_called)
-        signal(self.app_name)
-        self.assert_callback_called(((), {}))
-
-    def test_register_to_credentials_error(self):
-        """Test the register_to_credentials_error method."""
-        signal = self.cm.register_to_credentials_error(self._set_called)
-        signal(self.app_name)
-        self.assert_callback_called(((), {}))
-
-    def test_register_to_authorization_denied(self):
-        """Test the register_to_authorization_denied method."""
-        signal = self.cm.register_to_authorization_denied(self._set_called)
-        signal(self.app_name, TEST_ERROR_DICT)
-        self.assert_callback_called(((TEST_ERROR_DICT,), {}))
-
-    def _verify_not_called_twice(self, signal_name, *args):
-        """Test that the callback is not called twice."""
-        d = defer.Deferred()
-
-        def signal_handler(*args):
-            """Fake the behaviour of CredentialsManagementTool."""
-            d.callback(args[0] if len(args) > 0 else None)
-
-        register = getattr(self.cm, "register_to_" + signal_name)
-        signal = register(signal_handler)
-        proxy_cb = getattr(self.proxy, "on_" + signal_name)
-        proxy_cb(*args)
-        if getattr(signal, "remove", False):
-            signal.remove()
-        proxy_cb(*args)
-
-    def test_not_called_twice_credentials_stored(self):
-        """Test that on_credentials_stored is not called twice."""
-        self._verify_not_called_twice("credentials_stored")
-
-    def test_not_called_twice_credentials_cleared(self):
-        """Test that on_credentials_cleared is not called twice."""
-        self._verify_not_called_twice("credentials_cleared")
-
-    def test_not_called_twice_credentials_found(self):
-        """Test that on_credentials_found is not called twice."""
-        self._verify_not_called_twice("credentials_found", self.app_name,
-                                      TEST_CREDENTIALS)
-
-    def test_not_called_twice_credentials_not_found(self):
-        """Test that on_credentials_not_found is not called twice."""
-        self._verify_not_called_twice("credentials_not_found")
-
-    def test_not_called_twice_authorization_denied(self):
-        """Test that on_authorization_denied is not called twice."""
-        self._verify_not_called_twice("authorization_denied")
-
-    def test_not_called_twice_credentials_error(self):
-        """Test that on_credentials_error is not called twice."""
-        self._verify_not_called_twice("credentials_error", TEST_ERROR_DICT)
-
-    def test_connect_to_signal(self):
-        """The connect_to_signal method is correct."""
-        for signal_name in self.cm._SIGNAL_TO_CALLBACK_MAPPING:
-            match = self.cm.connect_to_signal(signal_name, self._set_called)
-            expected = object()
-            match(APP_NAME, expected)
-            self.assertEqual(self._called, ((expected,), {}))
-
-
-class CredentialsManagementOtherAppNameTestCase(CredentialsManagementTestCase):
-    """Tests for CredentialsManagement when the app name differs."""
-
-    app_name = 'other app name'
-
-    def assert_callback_called(self, expected):
-        """Test that _called helper does not hold 'expected'."""
-        self.assertEqual(self._called, False)

=== removed file 'tests/platform/credentials/test_linux.py'
--- tests/platform/credentials/test_linux.py	2015-09-20 20:52:48 +0000
+++ tests/platform/credentials/test_linux.py	1970-01-01 00:00:00 +0000
@@ -1,1119 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Author: Natalia B. Bidart <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Tests for the Magicicada credentials management dbus service."""
-
-import logging
-
-from functools import wraps
-
-import dbus.service
-
-from twisted.internet.defer import Deferred, inlineCallbacks
-from ubuntuone.devtools.handlers import MementoHandler
-try:
-    from ubuntuone.devtools.testcases import skipTest
-    from ubuntuone.devtools.testcases.dbus import DBusTestCase
-except ImportError:
-    from ubuntuone.devtools.testcase import DBusTestCase, skipTest
-
-from ubuntuone.platform.credentials import (
-    CredentialsError,
-    CredentialsManagementTool,
-    logger,
-    UI_PARAMS,
-)
-from ubuntuone.platform.credentials.dbus_service import (
-    APP_NAME,
-    CredentialsManagement,
-    dbus,
-    DBUS_BUS_NAME,
-    DBUS_CREDENTIALS_IFACE,
-    DBUS_CREDENTIALS_PATH,
-    TIMEOUT_INTERVAL,
-    ubuntu_sso,
-)
-
-FAKED_CREDENTIALS = {
-    'consumer_key': 'faked_consumer_key',
-    'consumer_secret': 'faked_consumer_secret',
-    'token': 'faked_token',
-    'token_secret': 'faked_token_secret',
-    'token_name': 'Woohoo test',
-}
-
-
-class FakedSSOService(dbus.service.Object):
-    """Faked DBus object that manages credentials."""
-
-    error_dict = None
-    app_name = None
-
-    def __init__(self, *args, **kwargs):
-        super(FakedSSOService, self).__init__(*args, **kwargs)
-        self._credentials = {}
-        self._args = None
-        self._kwargs = None
-
-    def maybe_emit_error(f):
-        """Decorator to fake a CredentialsError signal."""
-
-        @wraps(f)
-        def inner(self, *args, **kwargs):
-            """Fake a CredentialsError signal."""
-            if FakedSSOService.error_dict is not None:
-                if 'error_handler' in kwargs:
-                    error_handler = kwargs['error_handler']
-                    exc = dbus.service.DBusException(FakedSSOService.error_dict)
-                    error_handler(exc)
-                else:
-                    self.CredentialsError(FakedSSOService.app_name,
-                                          FakedSSOService.error_dict)
-            else:
-                return f(self, *args, **kwargs)
-
-        return inner
-
-    def store_args(f):
-        """Decorator to store arguments to check correct calls."""
-
-        @wraps(f)
-        def inner(self, app_name, args, **kwargs):
-            """Store arguments to check correct calls."""
-            self._app_name = app_name
-            self._args = args
-            self._kwargs = kwargs
-            return f(self, app_name, args, **kwargs)
-
-        return inner
-
-    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
-    def AuthorizationDenied(self, app_name):
-        """Signal thrown when the user denies the authorization."""
-
-    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
-    def CredentialsFound(self, app_name, credentials):
-        """Signal thrown when the credentials are found."""
-
-    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
-    def CredentialsNotFound(self, app_name):
-        """Signal thrown when the credentials are not found."""
-
-    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
-    def CredentialsCleared(self, app_name):
-        """Signal thrown when the credentials were cleared."""
-
-    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
-    def CredentialsStored(self, app_name):
-        """Signal thrown when the credentials were cleared."""
-
-    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
-    def CredentialsError(self, app_name, error_dict):
-        """Signal thrown when there is a problem getting the credentials."""
-
-    @store_args
-    @maybe_emit_error
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def find_credentials(self, app_name, args):
-        """Look for the credentials for an application."""
-        creds = self._credentials.get(FakedSSOService.app_name, None)
-        if creds is not None:
-            self.CredentialsFound(FakedSSOService.app_name, creds)
-        else:
-            self.CredentialsNotFound(FakedSSOService.app_name)
-
-    @store_args
-    @maybe_emit_error
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='a{ss}',
-                         async_callbacks=('reply_handler', 'error_handler'))
-    def find_credentials_sync(self, app_name, args,
-                              reply_handler=None, error_handler=None):
-        """Look for the credentials for an application."""
-        creds = self._credentials.get(FakedSSOService.app_name, None)
-        if creds is None:
-            creds = {}
-        if reply_handler is not None:
-            reply_handler(creds)
-        else:
-            return creds
-
-    @store_args
-    @maybe_emit_error
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def clear_credentials(self, app_name, args):
-        """Clear the credentials for an application."""
-        self._credentials.pop(FakedSSOService.app_name, None)
-        self.CredentialsCleared(FakedSSOService.app_name)
-
-    @store_args
-    @maybe_emit_error
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def store_credentials(self, app_name, args):
-        """Store the token for an application."""
-        self._credentials[FakedSSOService.app_name] = args
-        self.CredentialsStored(FakedSSOService.app_name)
-
-    @store_args
-    @maybe_emit_error
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
-                         in_signature='sa{ss}', out_signature='')
-    def register(self, app_name, args):
-        """Get credentials if found else prompt GUI to register."""
-        creds = self._credentials.get(FakedSSOService.app_name, None)
-        if creds is not None and len(creds) > 0:
-            self.CredentialsFound(FakedSSOService.app_name, creds)
-        elif creds == {}:
-            # fake an AuthorizationDenied
-            self.AuthorizationDenied(FakedSSOService.app_name)
-        elif creds is None:
-            # fake the adding of the credentials, in reality this will bring
-            # a GUI that the user will interact with.
-            self._credentials[FakedSSOService.app_name] = FAKED_CREDENTIALS
-            self.CredentialsFound(FakedSSOService.app_name, FAKED_CREDENTIALS)
-
-    @store_args
-    @maybe_emit_error
-    @dbus.service.method(dbus_interface=ubuntu_sso.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.register(app_name, args)
-
-
-class BaseTestCase(DBusTestCase):
-    """Base test case."""
-
-    timeout = 8
-    app_name = APP_NAME
-    error_dict = None
-
-    @inlineCallbacks
-    def setUp(self):
-        yield super(BaseTestCase, self).setUp()
-        FakedSSOService.app_name = self.app_name
-        FakedSSOService.error_dict = self.error_dict
-
-        self.memento = MementoHandler()
-        self.memento.setLevel(logging.DEBUG)
-        logger.addHandler(self.memento)
-
-        self.sso_server = self.register_server(ubuntu_sso.DBUS_BUS_NAME,
-                                ubuntu_sso.DBUS_CREDENTIALS_PATH,
-                                FakedSSOService)  # faked SSO server
-        self.args = {'window_id': '803'}
-
-    def register_server(self, bus_name, object_path, service_class):
-        """Register a service on the session bus."""
-        name = self.bus.request_name(bus_name, dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-        self.assertNotEqual(name, dbus.bus.REQUEST_NAME_REPLY_EXISTS,
-                            'Service %s should not be running.' % bus_name)
-        mock = service_class(object_path=object_path, conn=self.bus)
-        self.addCleanup(mock.remove_from_connection)
-        self.addCleanup(self.bus.release_name, bus_name)
-
-        return mock
-
-    def get_proxy(self, bus_name, object_path, dbus_interface):
-        obj = self.bus.get_object(bus_name=bus_name, object_path=object_path,
-                                  follow_name_owner_changes=True)
-        proxy = dbus.Interface(object=obj, dbus_interface=dbus_interface)
-        return proxy
-
-    def get_sso_proxy(self):
-        return self.get_proxy(bus_name=ubuntu_sso.DBUS_BUS_NAME,
-                              object_path=ubuntu_sso.DBUS_CREDENTIALS_PATH,
-                              dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
-
-
-class CredentialsManagementTestCase(BaseTestCase):
-    """Test case for the DBus object that manages Magicicada credentials."""
-
-    signals = ('CredentialsFound', 'CredentialsNotFound', 'CredentialsCleared',
-               'CredentialsStored', 'CredentialsError', 'AuthorizationDenied')
-
-    @inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsManagementTestCase, self).setUp()
-        self.creds_server = self.register_server(DBUS_BUS_NAME,
-                                DBUS_CREDENTIALS_PATH,
-                                CredentialsManagement)  # real service
-
-        self.deferred = Deferred()
-        self.proxy = self.get_creds_proxy()
-
-    def get_creds_proxy(self):
-        return self.get_proxy(bus_name=DBUS_BUS_NAME,
-                              object_path=DBUS_CREDENTIALS_PATH,
-                              dbus_interface=DBUS_CREDENTIALS_IFACE)
-
-    def connect_signals(self, callback=None):
-        """Connect every signal accordingly to fire self.deferred.
-
-        If 'callback' is not None, it will be used as a tuple (sig_name,
-        function) and 'sig_name' will be connected to 'function', which should
-        fire self.deferred properly.
-
-        """
-        success_sig_name, success_function = None, None
-        if callback is not None:
-            success_sig_name, success_function = callback
-
-        def fail(sig_name):
-            """Decorator to fire self.deferred."""
-            def inner(*args, **kwargs):
-                """Fire self.deferred."""
-                msg = 'Received an unexpected signal (%r).' % sig_name
-                self.deferred.errback(TypeError(msg))
-            return inner
-
-        for sig_name in self.signals:
-            if sig_name == success_sig_name:
-                sig = self.proxy.connect_to_signal(sig_name, success_function)
-            else:
-                sig = self.proxy.connect_to_signal(sig_name, fail(sig_name))
-            self.addCleanup(sig.remove)
-
-    @inlineCallbacks
-    def add_credentials(self, creds=FAKED_CREDENTIALS):
-        """Add some fake credentials for 'self.app_name'."""
-        d = Deferred()
-        sso_proxy = self.get_sso_proxy()
-        sso_proxy.store_credentials(self.app_name, creds,
-                                    reply_handler=lambda: d.callback(None),
-                                    error_handler=d.errback)
-        yield d
-
-    @inlineCallbacks
-    def do_test(self):
-        """Perform the test itself."""
-        yield self.deferred
-
-    def test_get_sso_proxy(self):
-        """The SSO dbus proxy is properly retrieved."""
-        sso_proxy = CredentialsManagement().sso_proxy
-        self.assertEqual(sso_proxy.bus_name, ubuntu_sso.DBUS_BUS_NAME)
-        self.assertEqual(sso_proxy.object_path,
-                         ubuntu_sso.DBUS_CREDENTIALS_PATH)
-        self.assertEqual(sso_proxy.dbus_interface,
-                         ubuntu_sso.DBUS_CREDENTIALS_IFACE)
-
-
-class ArgsTestCase(CredentialsManagementTestCase):
-    """Test case to check that proper arguments are passed to SSO backend."""
-
-    @inlineCallbacks
-    def test_find_credentials(self):
-        """The find_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-        self.proxy.find_credentials(reply_handler=lambda: d.callback(None),
-                                    error_handler=d.errback)
-        yield d
-
-        self.assertEqual(self.sso_server._app_name, APP_NAME)
-        self.assertEqual(self.sso_server._args, {})
-
-    @inlineCallbacks
-    def test_find_credentials_sync(self):
-        """The find_credentials_sync method calls ubuntu_sso's method."""
-        d = Deferred()
-        self.proxy.find_credentials_sync(reply_handler=d.callback,
-                                         error_handler=lambda *a: d.errback(a))
-        yield d
-
-        self.assertEqual(self.sso_server._app_name, APP_NAME)
-        self.assertEqual(self.sso_server._args, {})
-        self.assertTrue('reply_handler' in self.sso_server._kwargs)
-        self.assertTrue('error_handler' in self.sso_server._kwargs)
-
-    @inlineCallbacks
-    def test_clear_credentials(self):
-        """The clear_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-        self.proxy.clear_credentials(reply_handler=lambda: d.callback(None),
-                                     error_handler=d.errback)
-        yield d
-
-        self.assertEqual(self.sso_server._app_name, APP_NAME)
-        self.assertEqual(self.sso_server._args, {})
-
-    @inlineCallbacks
-    def test_store_credentials(self):
-        """The store_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-        self.proxy.store_credentials(FAKED_CREDENTIALS,
-                                     reply_handler=lambda: d.callback(None),
-                                     error_handler=d.errback)
-        yield d
-
-        self.assertEqual(self.sso_server._app_name, APP_NAME)
-        self.assertEqual(self.sso_server._args, FAKED_CREDENTIALS)
-
-    @inlineCallbacks
-    def test_register(self):
-        """The register method calls ubuntu_sso's method."""
-        d = Deferred()
-        self.proxy.register(self.args, reply_handler=lambda: d.callback(None),
-                            error_handler=d.errback)
-        yield d
-
-        self.assertEqual(self.sso_server._app_name, APP_NAME)
-        # convert to unicode for the comparison, as the message is arriving
-        # here as bytes (bad gettext usage!)
-        params = dict((x, y.decode("utf8") if isinstance(y, str) else y)
-                      for x, y in UI_PARAMS.items())
-        params.update(self.args)
-        self.assertEqual(self.sso_server._args, params)
-
-    @inlineCallbacks
-    def test_login(self):
-        """The login method calls ubuntu_sso's method."""
-        d = Deferred()
-        self.proxy.login(self.args, reply_handler=lambda: d.callback(None),
-                         error_handler=d.errback)
-        yield d
-
-        self.assertEqual(self.sso_server._app_name, APP_NAME)
-        # convert to unicode for the comparison, as the message is arriving
-        # here as bytes (bad gettext usage!)
-        params = dict((x, y.decode("utf8") if isinstance(y, str) else y)
-                      for x, y in UI_PARAMS.items())
-        params.update(self.args)
-        self.assertEqual(self.sso_server._args, params)
-
-
-class DictSignatureTestCase(DBusTestCase):
-    """Test the errors with dict signatures."""
-
-    def verify(self, app_name, options_dict, reply_handler, error_handler):
-        """Verify that the options_dict is a dbus.Dictionary."""
-        self.assertIsInstance(options_dict, dbus.Dictionary)
-
-    def test_find_credentials_dict_signature(self):
-        """Test for find_credentials."""
-        creds_man = CredentialsManagement()
-        self.patch(creds_man.sso_proxy, "find_credentials", self.verify)
-        creds_man.find_credentials()
-
-    def test_find_credentials_sync_dict_signature(self):
-        """Test for find_credentials_sync."""
-        creds_man = CredentialsManagement()
-        self.patch(creds_man.sso_proxy, "find_credentials_sync", self.verify)
-        creds_man.find_credentials_sync()
-
-    def test_clear_credentials_dict_signature(self):
-        """Test for clear_credentials."""
-        creds_man = CredentialsManagement()
-        self.patch(creds_man.sso_proxy, "clear_credentials", self.verify)
-        creds_man.clear_credentials()
-
-
-class SameAppNoErrorTestCase(CredentialsManagementTestCase):
-    """Test case when the app_name matches APP_NAME and there was no error."""
-
-    @inlineCallbacks
-    def test_find_credentials(self):
-        """The find_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-        yield self.add_credentials()
-
-        def verify(credentials):
-            """Do the check."""
-            self.assertEqual(credentials, FAKED_CREDENTIALS)
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsFound', verify))
-
-        self.proxy.find_credentials(reply_handler=lambda: d.callback(None),
-                                    error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_find_credentials_sync(self):
-        """The find_credentials_sync method calls ubuntu_sso's method."""
-        yield self.add_credentials()
-
-        def verify(credentials):
-            """Do the check."""
-            self.assertEqual(credentials, FAKED_CREDENTIALS)
-            self.deferred.callback(None)
-
-        error_handler = lambda a: self.deferred.errback(a)
-        self.proxy.find_credentials_sync(reply_handler=verify,
-                                         error_handler=error_handler)
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_find_credentials_without_credentials(self):
-        """The find_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-
-        def verify():
-            """Do the check."""
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsNotFound', verify))
-
-        self.proxy.find_credentials(reply_handler=lambda: d.callback(None),
-                                    error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_clear_credentials(self):
-        """The clear_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-        yield self.add_credentials()
-
-        def verify():
-            """Do the check."""
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsCleared', verify))
-
-        self.proxy.clear_credentials(reply_handler=lambda: d.callback(None),
-                                     error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_clear_credentials_without_credentials(self):
-        """The clear_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-
-        def verify():
-            """Do the check."""
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsCleared', verify))
-
-        self.proxy.clear_credentials(reply_handler=lambda: d.callback(None),
-                                     error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_store_credentials(self):
-        """The store_credentials method calls ubuntu_sso's method."""
-        d = Deferred()
-
-        def verify():
-            """Do the check."""
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsStored', verify))
-
-        self.proxy.store_credentials(FAKED_CREDENTIALS,
-                                     reply_handler=lambda: d.callback(None),
-                                     error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_register_with_credentials(self):
-        """The register method calls ubuntu_sso's method."""
-        d = Deferred()
-        yield self.add_credentials()
-
-        def verify(credentials):
-            """Do the check."""
-            self.assertEqual(credentials, FAKED_CREDENTIALS)
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsFound', verify))
-
-        self.proxy.register(self.args, reply_handler=lambda: d.callback(None),
-                            error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_register_without_credentials(self):
-        """The register method calls ubuntu_sso's method."""
-        d = Deferred()
-
-        def verify(credentials):
-            """Do the check."""
-            self.assertEqual(credentials, FAKED_CREDENTIALS)
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsFound', verify))
-
-        self.proxy.register(self.args, reply_handler=lambda: d.callback(None),
-                            error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_register_authorization_denied(self):
-        """The register method calls ubuntu_sso's method."""
-        d = Deferred()
-        yield self.add_credentials(creds={})
-
-        def verify():
-            """Do the check."""
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('AuthorizationDenied', verify))
-
-        self.proxy.register(self.args, reply_handler=lambda: d.callback(None),
-                            error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_login_with_credentials(self):
-        """The login method calls ubuntu_sso's method."""
-        d = Deferred()
-        yield self.add_credentials()
-
-        def verify(credentials):
-            """Do the check."""
-            self.assertEqual(credentials, FAKED_CREDENTIALS)
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsFound', verify))
-
-        self.proxy.login(self.args, reply_handler=lambda: d.callback(None),
-                         error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_login_without_credentials(self):
-        """The login method calls ubuntu_sso's method."""
-        d = Deferred()
-
-        def verify(credentials):
-            """Do the check."""
-            self.assertEqual(credentials, FAKED_CREDENTIALS)
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('CredentialsFound', verify))
-
-        self.proxy.login(self.args, reply_handler=lambda: d.callback(None),
-                         error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-    @inlineCallbacks
-    def test_login_authorization_denied(self):
-        """The login method calls ubuntu_sso's method."""
-        d = Deferred()
-        yield self.add_credentials(creds={})
-
-        def verify():
-            """Do the check."""
-            self.deferred.callback(None)
-
-        self.connect_signals(callback=('AuthorizationDenied', verify))
-
-        self.proxy.login(self.args, reply_handler=lambda: d.callback(None),
-                         error_handler=d.errback)
-        yield d
-        yield self.do_test()
-
-
-class SameAppWithErrorTestCase(SameAppNoErrorTestCase):
-    """Test case when the app_name matches APP_NAME and there was an error."""
-
-    error_dict = {'error_type': 'Test'}
-
-    def connect_signals(self, callback=None):
-        """CredentialsError is the success signals in this suite."""
-
-        def verify(error_dict):
-            """Do the check."""
-            self.assertEqual(error_dict, self.error_dict)
-            self.deferred.callback(error_dict)
-
-        args = ('CredentialsError', verify)
-        super(SameAppWithErrorTestCase, self).connect_signals(callback=args)
-
-    @skipTest('Failing on Ubuntu 13.04 - bug #1085204')
-    @inlineCallbacks
-    def test_find_credentials_sync(self):
-        """The find_credentials_sync method calls ubuntu_sso's method."""
-
-        def verify(error):
-            """Do the check."""
-            try:
-                self.assertEqual(error.args[0], str(self.error_dict))
-            except Exception, e:
-                self.deferred.errback(e)
-            else:
-                self.deferred.callback(None)
-
-        self.proxy.find_credentials_sync(reply_handler=self.deferred.errback,
-                                         error_handler=verify)
-        yield self.do_test()
-
-
-class OtherAppNoErrorTestCase(SameAppNoErrorTestCase):
-    """Test case when the app_name is not APP_NAME and there was no error."""
-
-    app_name = APP_NAME * 2
-
-    def connect_signals(self, callback=None):
-        """No signal should be received in this suite."""
-        # ignore all success connection, self.deferred should always errback
-        super(OtherAppNoErrorTestCase, self).connect_signals(callback=None)
-
-    @inlineCallbacks
-    def do_test(self):
-        """Perform the test itself."""
-        if not self.deferred.called:
-            msg = 'does not match %r, exiting.' % APP_NAME
-            if self.memento.check_info(self.app_name, msg):
-                self.deferred.callback(None)
-            else:
-                self.deferred.errback('Log should be present.')
-
-        yield self.deferred
-
-
-class OtherAppWithErrorTestCase(OtherAppNoErrorTestCase):
-    """Test case when the app_name is not APP_NAME and there was an error."""
-
-    app_name = APP_NAME * 2
-    error_dict = {'error_type': 'Test'}
-
-    def test_find_credentials_sync(self):
-        """This test has no sense for a synchronous method."""
-
-
-class RefCountingTestCase(BaseTestCase):
-    """Tests for the CredentialsManagement ref counting."""
-
-    @inlineCallbacks
-    def setUp(self):
-        yield super(RefCountingTestCase, self).setUp()
-        self._called = False
-        self.client = CredentialsManagement()
-
-    def _set_called(self, *args, **kwargs):
-        """Keep track of method calls."""
-        self._called = (args, kwargs)
-
-    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, 'CredentialsNotFound', verify)
-        self.client.find_credentials()
-
-        return d
-
-    def test_find_credentials_sync(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.client.find_credentials_sync(reply_handler=verify,
-                                          error_handler=d.errback)
-        return d
-
-    def test_find_credentials_sync_error(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(FakedSSOService, 'error_dict', 'foo')
-        self.client.find_credentials_sync(reply_handler=d.errback,
-                                          error_handler=verify)
-
-        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()
-
-        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(self.args)
-
-        return d
-
-    def test_register(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.register(self.args)
-
-        return d
-
-    def test_login(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.login(self.args)
-
-        return d
-
-    def test_several_requests(self):
-        """Requests can be nested."""
-        d = Deferred()
-
-        self.ref_count = 0
-
-        def parallel_counter(*args):
-            """Make the check."""
-            self.ref_count += 1
-            if self.ref_count == 5:
-                self.assertEqual(self.client.ref_count, self.ref_count)
-                d.callback(True)
-
-        self.patch(self.client, 'CredentialsFound', parallel_counter)
-
-        self.client.login(self.args)
-        self.client.register(self.args)
-        self.client.login(self.args)
-        self.client.register(self.args)
-        self.client.register(self.args)
-
-        return d
-
-    def test_credentials_found(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.ref_count = 3
-        self.client.CredentialsFound(FAKED_CREDENTIALS)
-
-        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()
-
-        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()
-
-        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()
-
-        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({'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()
-
-        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(FAKED_CREDENTIALS)
-
-        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()
-
-        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()
-
-        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()
-
-        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({'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()
-
-        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(self.args)
-        self.client.CredentialsFound(FAKED_CREDENTIALS)
-
-        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(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._ref_count = 1
-            assert self.client.ref_count > 0
-            func()
-
-        self.client.timeout_func = fake_timeout_func
-        self.client.shutdown_func = self._set_called
-
-        self.client.ref_count = 0  # trigger timer and possible shutdown
-
-        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.ref_count = 0  # trigger timer and possible shutdown
-
-        self.assertEqual(self._called, ((), {}), 'shutdown_func was called')
-
-
-class CredentialsTestCase(BaseTestCase):
-    """Test suite for the Credentials class."""
-
-    @inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsTestCase, self).setUp()
-        FakedSSOService.error_dict = None
-        self.creds_server = self.register_server(DBUS_BUS_NAME,
-                                DBUS_CREDENTIALS_PATH,
-                                CredentialsManagement)  # real service
-        self.client = CredentialsManagementTool()
-
-    @inlineCallbacks
-    def test_find_credentials_no_credentials(self):
-        """Find credentials when credentials does not exist."""
-        result = yield self.client.find_credentials()
-
-        self.assertEqual(result, {})
-
-    @inlineCallbacks
-    def test_find_credentials_with_credentials(self):
-        """Find credentials when credentials exists."""
-        yield self.client.store_credentials(FAKED_CREDENTIALS)
-
-        result = yield self.client.find_credentials()
-
-        self.assertEqual(result, FAKED_CREDENTIALS)
-
-    @inlineCallbacks
-    def test_find_credentials_error(self):
-        """Find credentials and error."""
-        FakedSSOService.error_dict = {'failure': 'really'}
-
-        e = yield self.assertFailure(self.client.find_credentials(),
-                                     CredentialsError)
-        self.assertEqual(e[0], FakedSSOService.error_dict)
-
-    @inlineCallbacks
-    def test_clear_credentials(self):
-        """Clear credentials."""
-        yield self.client.store_credentials({'test': 'me'})
-        yield self.client.clear_credentials()
-
-        result = yield self.client.find_credentials()
-
-        self.assertEqual(result, {})
-
-    @inlineCallbacks
-    def test_clear_credentials_error(self):
-        """Clear credentials and error."""
-        FakedSSOService.error_dict = {'failure': 'really'}
-
-        e = yield self.assertFailure(self.client.clear_credentials(),
-                                     CredentialsError)
-        self.assertEqual(e[0], FakedSSOService.error_dict)
-
-    @inlineCallbacks
-    def test_store_credentials(self):
-        """Store credentials."""
-        token = {'test': 'me'}
-        yield self.client.store_credentials(token)
-
-        result = yield self.client.find_credentials()
-
-        self.assertEqual(result, token)
-
-    @inlineCallbacks
-    def test_store_credentials_error(self):
-        """Store credentials and error."""
-        FakedSSOService.error_dict = {'failure': 'really'}
-
-        e = yield self.assertFailure(self.client.store_credentials({'0': '1'}),
-                                     CredentialsError)
-        self.assertEqual(e[0], FakedSSOService.error_dict)
-
-    @inlineCallbacks
-    def test_register(self):
-        """Register."""
-        result = yield self.client.register()
-
-        self.assertEqual(result, FAKED_CREDENTIALS)
-
-    @inlineCallbacks
-    def test_register_auth_denied(self):
-        """Register and auth_denied."""
-        yield self.client.store_credentials({})  # trigger AuthorizationDenied
-        result = yield self.client.register()
-
-        self.assertEqual(result, None)
-
-    @inlineCallbacks
-    def test_register_error(self):
-        """Register and error."""
-        FakedSSOService.error_dict = {'failure': 'really'}
-
-        e = yield self.assertFailure(self.client.register(),
-                                     CredentialsError)
-        self.assertEqual(e[0], FakedSSOService.error_dict)
-
-    @inlineCallbacks
-    def test_login(self):
-        """Login."""
-        result = yield self.client.login()
-
-        self.assertEqual(result, FAKED_CREDENTIALS)
-
-    @inlineCallbacks
-    def test_login_auth_denied(self):
-        """Login and auth denied."""
-        yield self.client.store_credentials({})  # trigger AuthorizationDenied
-        result = yield self.client.login()
-
-        self.assertEqual(result, None)
-
-    @inlineCallbacks
-    def test_login_error(self):
-        """Login and error."""
-        FakedSSOService.error_dict = {'failure': 'really'}
-
-        e = yield self.assertFailure(self.client.login(),
-                                     CredentialsError)
-        self.assertEqual(e[0], FakedSSOService.error_dict)

=== removed file 'tests/platform/test_credentials.py'
--- tests/platform/test_credentials.py	2015-09-29 21:05:26 +0000
+++ tests/platform/test_credentials.py	1970-01-01 00:00:00 +0000
@@ -1,502 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Authors: Manuel de la Pena <[e-mail]>
-#          Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2011-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Platform independent tests for the credentials management."""
-
-import platform
-import urllib
-import urlparse
-
-from collections import defaultdict
-from functools import wraps
-
-from twisted.internet import defer
-from twisted.trial.unittest import TestCase
-
-from contrib.testing.testcase import FAKED_CREDENTIALS
-from ubuntuone import clientdefs
-from ubuntuone.platform.credentials import (
-    BASE_PING_URL,
-    CredentialsError,
-    CredentialsManagementTool,
-    NO_OP,
-    PING_URL,
-    PING_URL_KEY,
-    platform_data,
-    POLICY_URL,
-    POLICY_URL_KEY,
-    TC_URL,
-    TC_URL_KEY,
-    UI_EXECUTABLE_KEY,
-    UI_EXECUTABLE_QT,
-    UI_PARAMS,
-)
-
-
-class FakedSignal(object):
-    """A faked signal."""
-
-    def __init__(self, name, callback):
-        self.name = name
-        self.callback = callback
-        self.removed = False
-        self.remove = lambda: setattr(self, 'removed', True)
-
-
-class FakedProxy(object):
-    """Fake a CredentialsManagement proxy."""
-
-    error_dict = None
-    error_handler = None
-
-    def __init__(self, *args, **kwargs):
-        self._credentials = None
-        self._args = None
-        self._kwargs = None
-        self._signals = []
-        self._receivers = defaultdict(list)
-        self._called = defaultdict(list)
-
-    def connect_to_signal(self, signal_name, callback):
-        """Keep track of connected signals."""
-        self._receivers[signal_name].append(callback)
-        result = FakedSignal(signal_name, callback)
-        self._signals.append(result)
-        return result
-
-    def maybe_emit_error(f):
-        """Decorator to fake a CredentialsError signal."""
-
-        @wraps(f)
-        def inner(self, *args, **kwargs):
-            """Fake a CredentialsError signal."""
-            if self.error_dict is None and self.error_handler is None:
-                f(self, *args, **kwargs)
-
-            reply_handler = kwargs.pop('reply_handler', NO_OP)
-            error_handler = kwargs.pop('error_handler', NO_OP)
-            if self.error_handler is not None:
-                error_handler(self.error_handler)
-            else:
-                reply_handler()
-
-            if self.error_dict is not None:
-                self.CredentialsError(self.error_dict)
-
-        return inner
-
-    def record_call(f):
-        """Decorator to record calls to 'f'."""
-
-        @wraps(f)
-        def inner(self, *a, **kw):
-            """Record the call to 'f' and call it."""
-            self._called[f.__name__].append((a, kw))
-            return f(self, *a, **kw)
-
-        return inner
-
-    def emit_signal(f):
-        """Decorator to emit a signal."""
-
-        @wraps(f)
-        def inner(self, *args, **kwargs):
-            """Emit the signal."""
-            for cb in self._receivers[f.__name__]:
-                cb(*args, **kwargs)
-
-        return inner
-
-    @emit_signal
-    def AuthorizationDenied(self):
-        """Signal thrown when the user denies the authorization."""
-
-    @emit_signal
-    def CredentialsFound(self, credentials):
-        """Signal thrown when the credentials are found."""
-
-    @emit_signal
-    def CredentialsNotFound(self):
-        """Signal thrown when the credentials are not found."""
-
-    @emit_signal
-    def CredentialsCleared(self):
-        """Signal thrown when the credentials were cleared."""
-
-    @emit_signal
-    def CredentialsStored(self):
-        """Signal thrown when the credentials were stored."""
-
-    @emit_signal
-    def CredentialsError(self, error_dict):
-        """Signal thrown when there is a problem getting the credentials."""
-
-    @record_call
-    @maybe_emit_error
-    def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Look for the credentials for an application."""
-        if self._credentials is not None:
-            self.CredentialsFound(self._credentials)
-        else:
-            self.CredentialsNotFound()
-
-    @record_call
-    @maybe_emit_error
-    def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Clear the credentials for an application."""
-        self._credentials = None
-        self.CredentialsCleared()
-
-    @record_call
-    @maybe_emit_error
-    def store_credentials(self, credentials,
-                          reply_handler=NO_OP, error_handler=NO_OP):
-        """Store the token for an application."""
-        self._credentials = credentials
-        self.CredentialsStored()
-
-    @record_call
-    @maybe_emit_error
-    def register(self, dict_arg,
-                 reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt GUI to register."""
-        creds = self._credentials
-        if creds is not None and len(creds) > 0:
-            self.CredentialsFound(creds)
-        elif creds == {}:
-            # fake an AuthorizationDenied
-            self.AuthorizationDenied()
-        elif creds is None:
-            # fake the adding of the credentials
-            self._credentials = FAKED_CREDENTIALS
-            self.CredentialsFound(FAKED_CREDENTIALS)
-
-    @record_call
-    @maybe_emit_error
-    def login(self, dict_arg,
-              reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt GUI to login."""
-        self.register(dict_arg, reply_handler, error_handler)
-
-    @record_call
-    @maybe_emit_error
-    def login_email_password(self, dict_arg,
-                             reply_handler=NO_OP, error_handler=NO_OP):
-        """Fake login_email_password."""
-        self.register(dict_arg, reply_handler, error_handler)
-
-
-class FakedPlatformSource(object):
-    """Faked the platform source."""
-
-    def get_creds_proxy(self):
-        """Return a new faked proxy every time, so we can test proxy caching."""
-        return FakedProxy()
-
-
-class CredentialsManagementToolTestCase(TestCase):
-    """Test case for the object that manages Magicicada credentials."""
-
-    timeout = 3
-    error_dict = None
-    error_handler = None
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsManagementToolTestCase, self).setUp()
-        self.cred_tool = CredentialsManagementTool()
-        self.patch(self.cred_tool, 'get_platform_source', FakedPlatformSource)
-        self.proxy = yield self.cred_tool.get_creds_proxy()
-        self.proxy.error_dict = self.error_dict
-        self.proxy.error_handler = self.error_handler
-
-        self.window_id_arg = {'window_id': '803'}
-        self.email_password_arg = {'email': '[e-mail]', 'password': 'yadda'}
-
-    @defer.inlineCallbacks
-    def test_proxy_is_reused(self):
-        """The inner proxy is re-used."""
-        proxy1 = yield self.cred_tool.get_creds_proxy()
-        proxy2 = yield self.cred_tool.get_creds_proxy()
-        self.assertTrue(proxy1 is proxy2)
-
-    def test_ui_params(self):
-        """The UI_PARAMS dict is correct."""
-        expected = {
-            PING_URL_KEY: PING_URL,
-            POLICY_URL_KEY: POLICY_URL,
-            TC_URL_KEY: TC_URL,
-            UI_EXECUTABLE_KEY: UI_EXECUTABLE_QT,
-        }
-        self.assertEqual(expected, UI_PARAMS)
-
-
-class ArgsTestCase(CredentialsManagementToolTestCase):
-    """Test case to check that proper arguments are passed to SSO backend."""
-
-    @defer.inlineCallbacks
-    def assert_method_called(self, method_name, *args, **kwargs):
-        """Test that 'method_name' was called once with 'args' and 'kwargs."""
-        self.assertIn(method_name, self.proxy._called)
-
-        calls = self.proxy._called[method_name]
-        msg = '%s must be called only once (got %s instead).'
-        self.assertEqual(len(calls), 1, msg % (method_name, len(calls)))
-
-        actual_args, actual_kwargs = calls[0]
-        self.assertEqual(args, actual_args)
-
-        reply_handler = actual_kwargs.pop('reply_handler', None)
-        self.assertFalse(reply_handler is None, 'Must provide a reply_handler')
-        d = defer.Deferred()
-        reply_handler(deferred=d)
-        yield d
-        self.assertTrue(d.called)
-
-        error_handler = actual_kwargs.pop('error_handler', None)
-        self.assertFalse(error_handler is None, 'Must provide a error_handler')
-        d = defer.Deferred()
-        error_handler(error='foo', deferred=d)
-        e = yield self.assertFailure(d, CredentialsError)
-        self.assertEqual(e.message, 'foo')
-
-        self.assertEqual(kwargs, actual_kwargs)
-
-    @defer.inlineCallbacks
-    def test_find_credentials(self):
-        """The find_credentials method calls proper method."""
-        yield self.cred_tool.find_credentials()
-
-        self.assert_method_called('find_credentials')
-
-    @defer.inlineCallbacks
-    def test_clear_credentials(self):
-        """The clear_credentials method calls proper method."""
-        yield self.cred_tool.clear_credentials()
-
-        self.assert_method_called('clear_credentials')
-
-    @defer.inlineCallbacks
-    def test_store_credentials(self):
-        """The store_credentials method calls proper method."""
-        yield self.cred_tool.store_credentials(FAKED_CREDENTIALS)
-
-        self.assert_method_called('store_credentials', FAKED_CREDENTIALS)
-
-    @defer.inlineCallbacks
-    def test_register(self):
-        """The register method calls proper method."""
-        yield self.cred_tool.register(**self.window_id_arg)
-
-        self.assert_method_called('register', self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login(self):
-        """The login method calls proper method."""
-        yield self.cred_tool.login(**self.window_id_arg)
-
-        self.assert_method_called('login', self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login_email_password(self):
-        """The login method calls proper method."""
-        yield self.cred_tool.login_email_password(**self.email_password_arg)
-
-        self.assert_method_called('login_email_password',
-                                  self.email_password_arg)
-
-
-class NoErrorWithCredsTestCase(CredentialsManagementToolTestCase):
-    """Test case when there was no error, and credentials are present."""
-
-    token = {'test': 'me'}
-
-    @defer.inlineCallbacks
-    def do_test(self, method, expected=None, **kwargs):
-        """Perform the test itself."""
-        if self.token is not None:
-            self.proxy.store_credentials(self.token)
-        else:
-            yield self.proxy.clear_credentials()
-        actual = yield method(**kwargs)
-        self.assertEqual(expected, actual)
-
-    @defer.inlineCallbacks
-    def test_find_credentials(self):
-        """The find_credentials method calls proper method."""
-        yield self.do_test(self.cred_tool.find_credentials, self.token)
-
-    @defer.inlineCallbacks
-    def test_clear_credentials(self):
-        """The clear_credentials method calls proper method."""
-        yield self.do_test(self.cred_tool.clear_credentials, None)
-
-    @defer.inlineCallbacks
-    def test_store_credentials(self):
-        """The store_credentials method calls proper method."""
-        yield self.do_test(self.cred_tool.store_credentials, None,
-                           token=FAKED_CREDENTIALS)
-
-    @defer.inlineCallbacks
-    def test_register(self):
-        """The register method calls proper method."""
-        yield self.do_test(self.cred_tool.register, self.token,
-                           **self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login(self):
-        """The login method calls proper method."""
-        yield self.do_test(self.cred_tool.login, self.token,
-                           **self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login_email_password(self):
-        """The login_email_password method calls proper method."""
-        yield self.do_test(self.cred_tool.login_email_password, self.token,
-                           **self.email_password_arg)
-
-
-class NoErrorNoCredsTestCase(NoErrorWithCredsTestCase):
-    """Test case when there was no error, and credentials are not present."""
-
-    token = None
-
-    @defer.inlineCallbacks
-    def test_find_credentials(self):
-        """The find_credentials method calls proper method."""
-        yield self.do_test(self.cred_tool.find_credentials, {})
-
-    @defer.inlineCallbacks
-    def test_register(self):
-        """The register method calls proper method."""
-        yield self.do_test(self.cred_tool.register, FAKED_CREDENTIALS,
-                           **self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_register_authorization_denied(self):
-        """The register method calls proper method."""
-        self.token = {}
-        yield self.do_test(self.cred_tool.register, None,
-                           **self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login(self):
-        """The login method calls proper method."""
-        yield self.do_test(self.cred_tool.login, FAKED_CREDENTIALS,
-                           **self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login_authorization_denied(self):
-        """The login method calls proper method."""
-        self.token = {}
-        yield self.do_test(self.cred_tool.login, None, **self.window_id_arg)
-
-    @defer.inlineCallbacks
-    def test_login_email_password(self):
-        """The login_email_password method calls proper method."""
-        yield self.do_test(self.cred_tool.login_email_password,
-                           FAKED_CREDENTIALS, **self.email_password_arg)
-
-
-class WithCredentialsErrorTestCase(NoErrorNoCredsTestCase):
-    """Test case when there was a CredentialsError sent from the proxy."""
-
-    error_dict = expected = {'error_type': 'Test'}
-
-    @defer.inlineCallbacks
-    def do_test(self, method, expected=None, **kwargs):
-        """Perform the test itself."""
-        exc = yield self.assertFailure(method(**kwargs), Exception)
-        self.assertIsInstance(exc, CredentialsError)
-        self.assertEqual(self.expected, exc.args[0])
-
-
-class WithErrorHandlerCalledTestCase(WithCredentialsErrorTestCase):
-    """Test case when the error handler was called."""
-
-    error_dict = None
-    error_handler = expected = {'error_type': 'Another Test'}
-
-
-class SignalsRemovedTestCase(NoErrorWithCredsTestCase):
-
-    @defer.inlineCallbacks
-    def do_test(self, method, expected=None, **kwargs):
-        """Perform the test itself."""
-        yield method(**kwargs)
-        for signal in self.proxy._signals:
-            self.assertTrue(signal.removed)
-
-
-class PingURLPlatformDetails(TestCase):
-
-    def test_ping_url(self):
-        """The PING_URL is BASE_PING_URL plus urlencoded platform data."""
-        result = urlparse.urlparse(PING_URL)
-
-        expected_base = urlparse.urljoin(result.scheme + '://' + result.netloc,
-                                         result.path)
-        self.assertEqual(expected_base, BASE_PING_URL)
-
-        expected_query = dict(urlparse.parse_qsl(result.query))
-        expected_query = urllib.urlencode(expected_query)
-        self.assertEqual(expected_query, platform_data())
-
-    def test_ping_url_is_unicode(self):
-        """The PING_URL is unicode."""
-        self.assertIsInstance(PING_URL, unicode)
-
-    def test_platform_data(self):
-        """The platform data is correct."""
-        expected = {"platform": platform.system(),
-                    "platform_version": platform.release(),
-                    "platform_arch": platform.machine(),
-                    "client_version": clientdefs.VERSION}
-        self.assertEqual(urllib.urlencode(expected), platform_data())
-
-    def test_platform_data_non_ascii(self):
-        """The platform data is correct for non ascii values."""
-        system = u'Ñandú'
-        release = u'ñoño'
-        machine = u'rápida'
-        version = u'1.2.3-ubuntu♥'
-
-        self.patch(platform, 'system', lambda: system.encode('utf8'))
-        self.patch(platform, 'release', lambda: release.encode('utf8'))
-        self.patch(platform, 'machine', lambda: machine.encode('utf8'))
-        self.patch(clientdefs, 'VERSION', version.encode('utf8'))
-
-        expected = {"platform": system.encode('utf8'),
-                    "platform_version": release.encode('utf8'),
-                    "platform_arch": machine.encode('utf8'),
-                    "client_version": version.encode('utf8')}
-        expected = urllib.urlencode(expected)
-        self.assertEqual(expected, platform_data())

=== modified file 'ubuntuone/__init__.py'
--- ubuntuone/__init__.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/__init__.py	2016-05-30 13:04:07 +0000
@@ -1,4 +1,7 @@
+# -*- coding: utf-8 -*-
+#
 # Copyright 2009-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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
@@ -24,5 +27,7 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
-"""ubuntuone package"""
+
+"""Main package."""
+
 __import__('pkg_resources').declare_namespace(__name__)

=== modified file 'ubuntuone/clientdefs.py.in'
--- ubuntuone/clientdefs.py.in	2015-09-29 21:05:26 +0000
+++ ubuntuone/clientdefs.py.in	2016-05-30 13:04:07 +0000
@@ -31,10 +31,28 @@
 """Configure-time definitions for the client."""
 
 import gettext
+import os
+import platform
+import urllib
 
 Q_ = lambda string: gettext.dgettext(GETTEXT_PACKAGE, string)
 
+NAME = 'Magicicada'
+
 VERSION = "@VERSION@"
 LOCALEDIR = "@localedir@"
 LIBEXECDIR = "@libexecdir@"
 GETTEXT_PACKAGE = "@GETTEXT_PACKAGE@"
+PROJECT_NAME = "@GETTEXT_PACKAGE@"
+PROJECT_DIR = os.path.join('@prefix@', 'share', PROJECT_NAME)
+BIN_DIR = os.path.join('@prefix@', 'lib', PROJECT_NAME)
+
+
+def platform_data():
+    result = {'platform': platform.system(),
+              'platform_version': platform.release(),
+              'platform_arch': platform.machine(),
+              'client_version': VERSION}
+    # urlencode will not encode unicode, only bytes
+    result = urllib.urlencode(result)
+    return result

=== added file 'ubuntuone/keyring.py'
--- ubuntuone/keyring.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/keyring.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Handle keys in the local kerying."""
+
+from __future__ import unicode_literals
+
+import logging
+import socket
+import sys
+
+try:
+    from urllib.parse import parse_qsl, quote, urlencode
+except ImportError:
+    from urllib import quote, urlencode
+    from urlparse import parse_qsl
+
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from ubuntuone.clientdefs import NAME
+from ubuntuone.utils import compat
+from ubuntuone.utils.txsecrets import SecretService
+
+
+logger = logging.getLogger(__name__)
+
+TOKEN_SEPARATOR = ' @ '
+SEPARATOR_REPLACEMENT = ' AT '
+
+
+def gethostname():
+    """Get the hostname, return the name as unicode."""
+    sys_encoding = sys.getfilesystemencoding()
+    hostname = socket.gethostname()
+    if isinstance(hostname, compat.binary_type):
+        return hostname.decode(sys_encoding)
+    return hostname
+
+
+def get_token_name(app_name):
+    """Build the token name.. Return an unicode."""
+    computer_name = gethostname()
+    computer_name = computer_name.replace(TOKEN_SEPARATOR,
+                                          SEPARATOR_REPLACEMENT)
+
+    assert isinstance(computer_name, compat.text_type)
+    assert isinstance(computer_name, compat.text_type)
+
+    return TOKEN_SEPARATOR.join((app_name, computer_name))
+
+
+class Keyring(object):
+    """A Keyring for a given application name."""
+
+    def __init__(self):
+        """Initialize this instance."""
+        self.service = SecretService()
+
+    def _get_keyring_attr(self, app_name):
+        """Build the keyring attributes for this credentials."""
+        attr = {"key-type": "%s credentials" % NAME,
+                "token-name": get_token_name(app_name)}
+        return attr
+
+    @inlineCallbacks
+    def _find_keyring_item(self, app_name, attr=None):
+        """Return the keyring item or None if not found."""
+        if attr is None:
+            attr = self._get_keyring_attr(app_name)
+        logger.debug("Finding all items for app_name %r.", app_name)
+        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])
+
+    @inlineCallbacks
+    def set_credentials(self, app_name, cred):
+        """Set the credentials."""
+        # Creates the secret from the credentials
+        secret = urlencode(cred)
+
+        attr = self._get_keyring_attr(app_name)
+        # Add our 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 get_credentials(self, app_name):
+        """A deferred with the secret in a dictionary."""
+        # If we have no attributes, return None
+        logger.debug("Getting credentials for %r.", app_name)
+        yield self.service.open_session()
+        item = yield self._find_keyring_item(app_name)
+        if item is not None:
+            logger.debug("Parsing secret.")
+            secret = yield item.get_value()
+            returnValue(dict(parse_qsl(secret)))
+
+        # 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 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 'ubuntuone/networkstate'
=== added file 'ubuntuone/networkstate/__init__.py'
--- ubuntuone/networkstate/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/__init__.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Platform specific network status."""
+
+import sys
+
+
+NetworkManagerState = None
+
+
+class NetworkFailException(Exception):
+
+    """Exception for when the network detect process fails."""
+
+
+if sys.platform == 'win32':
+    from ubuntuone.networkstate import windows
+    networksource = windows
+elif sys.platform == 'darwin':
+    from ubuntuone.networkstate import darwin
+    networksource = darwin
+else:
+    from ubuntuone.networkstate import linux
+    networksource = linux
+
+NetworkManagerState = networksource.NetworkManagerState
+is_machine_connected = networksource.is_machine_connected

=== added file 'ubuntuone/networkstate/darwin.py'
--- ubuntuone/networkstate/darwin.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/darwin.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,305 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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 state detection on OS X.
+
+is_machine_connected(): (deferred) returns connected state as bool
+NetworkManagerState: class with listening thread, calls back with state changes
+
+"""
+
+import logging
+
+from threading import Thread
+
+from twisted.internet import defer
+
+from ubuntuone.networkstate import NetworkFailException
+from ubuntuone.networkstate.networkstates import (ONLINE, OFFLINE, UNKNOWN)
+
+logger = logging.getLogger(__name__)
+
+HOSTNAME_TO_CHECK = 'login.ubuntu.com'
+
+from ctypes import (
+    CDLL,
+    POINTER,
+    CFUNCTYPE,
+    Structure,
+    pointer,
+    c_bool,
+    c_long,
+    c_void_p,
+    c_uint32)
+
+from ctypes.util import find_library
+
+
+# Functions and constants below are from
+# /System/Library/CoreFoundation.framework/
+CoreFoundationPath = find_library("CoreFoundation")
+CoreFoundation = CDLL(CoreFoundationPath)
+
+# CFRunLoopRef CFRunLoopGetCurrent()
+CFRunLoopGetCurrent = CoreFoundation.CFRunLoopGetCurrent
+CFRunLoopGetCurrent.restype = c_void_p
+CFRunLoopGetCurrent.argtypes = []
+
+# void CFRelease(CFTypeRef)
+CFRelease = CoreFoundation.CFRelease
+CFRelease.restype = None
+CFRelease.argtypes = [c_void_p]
+
+# void CFRunLoopRun()
+CFRunLoopRun = CoreFoundation.CFRunLoopRun
+
+# const CFStringRef kCFRunLoopDefaultMode
+kCFRunLoopDefaultMode = c_void_p.in_dll(CoreFoundation,
+                                        "kCFRunLoopDefaultMode")
+
+
+# Functions and constants below are from
+# /System/Library/SystemConfiguration.framework/
+SystemConfigurationPath = find_library("SystemConfiguration")
+
+# SystemConfiguration abbreviated as "SC" below:
+SC = CDLL(SystemConfigurationPath)
+
+# "SCNetworkReachability" functions abbreviated to "SCNR*" here.
+
+# SCNetworkReachabilityRef
+# SCNetworkReachabilityCreateWithName(CFAllocatorRef, const char *)
+SCNRCreateWithName = SC.SCNetworkReachabilityCreateWithName
+SCNRCreateWithName.restype = c_void_p
+
+# Boolean SCNetworkReachabilityGetFlags(SCNetworkReachabilityRef,
+#                                       SCNetworkReachabilityFlags)
+SCNRGetFlags = SC.SCNetworkReachabilityGetFlags
+SCNRGetFlags.restype = c_bool
+SCNRGetFlags.argtypes = [c_void_p,
+                         POINTER(c_uint32)]
+
+SCNRScheduleWithRunLoop = SC.SCNetworkReachabilityScheduleWithRunLoop
+SCNRScheduleWithRunLoop.restype = c_bool
+SCNRScheduleWithRunLoop.argtypes = [c_void_p,
+                                    c_void_p,
+                                    c_void_p]
+
+# ctypes callback type to match SCNetworkReachabilityCallback
+# void (*SCNetworkReachabilityCallback) (SCNetworkReachabilityRef,
+#                                        SCNetworkReachabilityFlags,
+#                                        void *)
+SCNRCallbackType = CFUNCTYPE(None, c_void_p, c_uint32, c_void_p)
+# NOTE: need to keep this reference alive as long as a callback might occur.
+
+# Boolean SCNetworkReachabilitySetCallback(SCNetworkReachabilityRef,
+#                                          SCNetworkReachabilityCallback,
+#                                          SCNetworkReachabilityContext)
+SCNRSetCallback = SC.SCNetworkReachabilitySetCallback
+SCNRSetCallback.restype = c_bool
+SCNRSetCallback.argtypes = [c_void_p,
+                            SCNRCallbackType,
+                            c_void_p]
+
+
+def check_connected_state():
+    """Calls Synchronous SCNR API, returns bool."""
+    target = SCNRCreateWithName(None, HOSTNAME_TO_CHECK)
+    if target is None:
+        logger.error("Error creating network reachability reference.")
+        raise NetworkFailException()
+
+    flags = c_uint32(0)
+    ok = SCNRGetFlags(target, pointer(flags))
+    CFRelease(target)
+
+    if not ok:
+        logger.error("Error getting reachability status of '%s'" %
+                     HOSTNAME_TO_CHECK)
+        raise NetworkFailException()
+
+    return flags_say_reachable(flags.value)
+
+
+def flags_say_reachable(flags):
+    """Check flags returned from SCNetworkReachability API. Returns bool.
+
+    Requires some logic:
+    reachable_flag isn't enough on its own.
+
+    A down wifi will return flags = 7, or reachable_flag and
+    connection_required_flag, meaning that the host *would be*
+    reachable, but you need a connection first.  (And then you'd
+    presumably be best off checking again.)
+    """
+    # values from SCNetworkReachability.h
+    reachable_flag = 1 << 1
+    connection_required_flag = 1 << 2
+
+    if flags & connection_required_flag:
+        return False
+    elif flags & reachable_flag:
+        return True
+    else:
+        return False
+
+
+class SCNRContext(Structure):
+
+    """A struct to send as SCNetworkReachabilityContext to SCNRSetCallback.
+
+    We don't use the fields currently.
+    """
+
+    _fields_ = [("version", c_long),
+                ("info", c_void_p),
+                ("retain", c_void_p),           # func ptr
+                ("release", c_void_p),          # func ptr
+                ("copyDescription", c_void_p)]  # func ptr
+
+
+class NetworkManagerState(object):
+
+    """Probe Network State and receive callbacks on changes.
+
+    This class uses both synchronous and async API from the
+    SystemConfiguration framework.
+
+    To use: Initialize with a callback function, then call
+    find_online_state. The callback will be called once immediately
+    with the current state and then only on state changes.
+
+    Any exceptions in checking state will result in the callback being
+    called with UNKNOWN. At this point the listening thread is no
+    longer runing, and a new NetworkManagerState should be created.
+
+    NOTE: the callback will be called from the separate listening
+    thread, except for the first call.
+    """
+
+    def __init__(self, result_cb):
+        """Initialize and save result callback function.
+
+        result_cb should take one argument, a networkstate object.
+
+        The callback will be called with one of ONLINE, OFFLINE, or
+        UNKNOWN, as defined in networkstates.py.
+        """
+        self.result_cb = result_cb
+        self.listener_thread = None
+
+    def _state_changed(self, flags):
+        """Testable callback called by reachability_state_changed_cb.
+
+        Used because reachability_state_changed_cb has to have a
+        particular method signature.
+
+        Clients should not call this method.
+        """
+        if flags_say_reachable(flags):
+            self.result_cb(ONLINE)
+        else:
+            self.result_cb(OFFLINE)
+
+    def _listen_on_separate_thread(self):
+        """In separate thread, setup callback and listen for changes.
+
+        On error, calls result_cb(UNKNOWN) and returns.
+        """
+
+        def reachability_state_changed_cb(targetref, flags, info):
+            """Callback for SCNetworkReachability API
+
+            This callback is passed to the SCNetworkReachability API,
+            so its method signature has to be exactly this. Therefore,
+            we declare it here and just call _state_changed with
+            flags."""
+            self._state_changed(flags)
+
+        c_callback = SCNRCallbackType(reachability_state_changed_cb)
+        context = SCNRContext(0, None, None, None, None)
+
+        target = SCNRCreateWithName(None, HOSTNAME_TO_CHECK)
+        if target is None:
+            logger.error("Error creating SCNetworkReachability target")
+            self.result_cb(UNKNOWN)
+            return
+
+        ok = SCNRSetCallback(target, c_callback, pointer(context))
+        if not ok:
+            logger.error("error setting SCNetworkReachability callback")
+            CFRelease(target)
+            self.result_cb(UNKNOWN)
+            return
+
+        ok = SCNRScheduleWithRunLoop(target,
+                                     CFRunLoopGetCurrent(),
+                                     kCFRunLoopDefaultMode)
+        if not ok:
+            logger.error("error scheduling on runloop: SCNetworkReachability")
+            CFRelease(target)
+            self.result_cb(UNKNOWN)
+            return
+
+        CFRunLoopRun()
+
+        CFRelease(target)               # won't happen
+
+    def _start_listening_thread(self):
+        """Start the separate listener thread.
+
+        Currently will not start one more than once.
+        Should be OK because we don't expect errors the listen method.
+
+        To add more error handling support, you could either add a
+        call to join and re-start, or client could just create a new
+        NetworkManagerState.
+        """
+
+        if self.listener_thread is None:
+            self.listener_thread = Thread(
+                target=self._listen_on_separate_thread,
+                name="Network Connection Monitor")
+            self.listener_thread.daemon = True
+            self.listener_thread.start()
+
+    def find_online_state(self):
+        """Calls callback with current state. Starts listening thread."""
+        try:
+            if check_connected_state():
+                self.result_cb(ONLINE)
+            else:
+                self.result_cb(OFFLINE)
+
+        except Exception:
+            logger.exception("Getting state from SCNetworkReachability")
+            self.result_cb(UNKNOWN)
+            return                      # don't start thread on error
+
+        self._start_listening_thread()
+
+
+def is_machine_connected():
+    """Return a deferred that when fired, returns online state as a bool.
+
+    Raises NetworkFailException for errors.
+    """
+    try:
+        return defer.succeed(check_connected_state())
+    except Exception as e:
+        logger.exception("Exception calling check_connected_state:")
+        return defer.fail(NetworkFailException(e))

=== added file 'ubuntuone/networkstate/linux.py'
--- ubuntuone/networkstate/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/linux.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2010-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Implementation of network state detection."""
+
+import dbus
+import logging
+
+from twisted.internet import defer
+
+from ubuntuone.networkstate import NetworkFailException
+from ubuntuone.networkstate.networkstates import (
+    ONLINE, OFFLINE,
+    NM_STATE_CONNECTING_LIST,
+    NM_STATE_CONNECTED_LIST,
+    NM_STATE_DISCONNECTED_LIST,
+)
+
+
+logger = logging.getLogger(__name__)
+
+NM_DBUS_INTERFACE = "org.freedesktop.NetworkManager"
+NM_DBUS_OBJECTPATH = "/org/freedesktop/NetworkManager"
+
+
+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."""
+        self.result_cb(state)
+
+    def got_state(self, state):
+        """Called by DBus when the state is retrieved from NM."""
+        if state in NM_STATE_CONNECTED_LIST:
+            self.call_result_cb(ONLINE)
+        elif state in NM_STATE_CONNECTING_LIST:
+            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."""
+        # Assuming since Network Manager is not running,
+        # the user has connected in some other way
+        logger.error("Error contacting NetworkManager: %s" %
+                         str(error))
+        self.call_result_cb(ONLINE)
+
+    def state_changed(self, state):
+        """Called when a signal is emmited by Network Manager."""
+        if int(state) in NM_STATE_CONNECTED_LIST:
+            self.call_result_cb(ONLINE)
+        elif int(state) in NM_STATE_DISCONNECTED_LIST:
+            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 as e:
+            self.got_error(e)
+
+
+def is_machine_connected():
+    """Return a deferred that when fired, returns if the machine is online."""
+    d = defer.Deferred()
+
+    def got_state(state):
+        """The state was retrieved from the Network Manager."""
+        if type(state) is not type(ONLINE):
+            logger.exception("bad callback argument in is_machine_connected")
+            raise NetworkFailException()
+        result = (state == ONLINE)
+        d.callback(result)
+
+    try:
+        network = NetworkManagerState(got_state)
+        network.find_online_state()
+    except Exception as e:
+        logger.exception('is_machine_connected failed with:')
+        d.errback(NetworkFailException(e))
+
+    return d

=== added file 'ubuntuone/networkstate/networkstates.py'
--- ubuntuone/networkstate/networkstates.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/networkstates.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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 states."""
+
+
+class NetworkState(object):
+    """ A simple class to add a label and make debugging easier. """
+
+    def __init__(self, label="unlabeled"):
+        self.label = label
+
+    def __repr__(self):
+        return "Network state (%s)" % self.label
+
+# Values returned by the callback
+(ONLINE, OFFLINE, UNKNOWN) = (NetworkState("online"),
+                              NetworkState("offline"),
+                              NetworkState("unknown"))
+
+# Internal NetworkManager State constants
+NM_STATE_UNKNOWN = 0
+NM_STATE_UNKNOWN_LIST = [NM_STATE_UNKNOWN]
+NM_STATE_ASLEEP_OLD = 1
+NM_STATE_ASLEEP = 10
+NM_STATE_ASLEEP_LIST = [NM_STATE_ASLEEP_OLD,
+                        NM_STATE_ASLEEP]
+NM_STATE_CONNECTING_OLD = 2
+NM_STATE_CONNECTING = 40
+NM_STATE_CONNECTING_LIST = [NM_STATE_CONNECTING_OLD,
+                            NM_STATE_CONNECTING]
+NM_STATE_CONNECTED_OLD = 3
+NM_STATE_CONNECTED_LOCAL = 50
+NM_STATE_CONNECTED_SITE = 60
+NM_STATE_CONNECTED_GLOBAL = 70
+# Specifically don't include local and site, as they won't let us get to server
+NM_STATE_CONNECTED_LIST = [NM_STATE_CONNECTED_OLD,
+                           NM_STATE_CONNECTED_GLOBAL]
+NM_STATE_DISCONNECTED_OLD = 4
+NM_STATE_DISCONNECTED = 20
+# For us, local and site connections are the same as diconnected
+NM_STATE_DISCONNECTED_LIST = [NM_STATE_DISCONNECTED_OLD,
+                              NM_STATE_DISCONNECTED,
+                              NM_STATE_CONNECTED_LOCAL,
+                              NM_STATE_CONNECTED_SITE]

=== added directory 'ubuntuone/networkstate/tests'
=== added file 'ubuntuone/networkstate/tests/__init__.py'
--- ubuntuone/networkstate/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/tests/__init__.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Test the different networkstatus implementations."""

=== added file 'ubuntuone/networkstate/tests/test_darwin.py'
--- ubuntuone/networkstate/tests/test_darwin.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/tests/test_darwin.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2010-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Tests for the network state detection code."""
+
+from twisted.internet.defer import inlineCallbacks
+
+from ubuntuone.networkstate import (
+    darwin,
+    NetworkFailException,
+)
+from ubuntuone.networkstate.darwin import (
+    NetworkManagerState,
+    flags_say_reachable,
+    is_machine_connected,
+)
+from ubuntuone.networkstate.networkstates import (
+    ONLINE, OFFLINE, UNKNOWN,
+)
+from ubuntuone.tests import TestCase
+
+
+REACHABLE_FLAG = 1 << 1
+CONNECTION_REQUIRED_FLAG = 1 << 2
+
+
+class TestSCNRFailingInDirect(TestCase):
+
+    """Test that we handle a problem getting status in a direct call
+    to check_connected_state (used by is_machine_connected) by
+    raising an exception.
+    """
+
+    def test_cant_create_target(self):
+        """SCNRCreateWithName returning None should cause an exception."""
+        self.patch(darwin, "SCNRCreateWithName",
+                   lambda _1, _2: None)
+        self.assertRaises(NetworkFailException,
+                          darwin.check_connected_state)
+
+    def test_cant_get_flags(self):
+        """SCNRGetFlags returning False should cause an exception."""
+        self.patch(darwin, "SCNRGetFlags",
+                   lambda _1, _2: False)
+        self.assertRaises(NetworkFailException,
+                          darwin.check_connected_state)
+
+
+class TestFailingSCNRInCallbacks(TestCase):
+
+    """Test that we handle a problem getting status in the separate
+    listening thread by updating the status to UNKNOWN.
+    """
+
+    def expect_unknown(self, state):
+        """A convenience callback that fails unless it sees UNKNOWN."""
+        self.assertEquals(state, UNKNOWN)
+
+    def test_exc_in_find_online_state(self):
+        """Expect UNKNOWN from find_online_state in case of exception."""
+        def fake_check_connected_state():
+            "fake a broken check_connected_state"
+            raise NetworkFailException()
+
+        self.patch(darwin, "check_connected_state",
+                   fake_check_connected_state)
+        NetworkManagerState(self.expect_unknown)
+
+    def test_cant_create_target(self):
+        """SCNRCreateWithName returning None -> callback gets UNKNOWN."""
+        self.patch(darwin, "SCNRCreateWithName", lambda _1, _2: None)
+        nms = NetworkManagerState(self.expect_unknown)
+        nms._listen_on_separate_thread()
+
+    def test_cant_set_callback(self):
+        """SCNRSetCallback returning false -> callback gets UNKNOWN."""
+        self.patch(darwin, "SCNRSetCallback", lambda _1, _2, _3: False)
+        nms = NetworkManagerState(self.expect_unknown)
+        nms._listen_on_separate_thread()
+
+    def test_cant_schedule_with_runloop(self):
+        """SCNRScheduleWithRunLoop returning false -> callback gets UNKNOWN."""
+        self.patch(darwin, "SCNRScheduleWithRunLoop",
+                   lambda _1, _2, _3: False)
+        nms = NetworkManagerState(self.expect_unknown)
+        nms._listen_on_separate_thread()
+
+
+class TestReadingFlags(TestCase):
+    """Test interpretation of flags returned from SCNR API"""
+
+    def test_flag_reachable(self):
+        """Reachable by itself is OK."""
+        flag = REACHABLE_FLAG
+        self.assertTrue(flags_say_reachable(flag))
+
+    def test_flag_reachable_and_flag_connection_required(self):
+        """Reachable and connection-required is NOT OK"""
+        flag = REACHABLE_FLAG | CONNECTION_REQUIRED_FLAG
+        self.assertFalse(flags_say_reachable(flag))
+
+    def test_other_flagvals(self):
+        """All other flag configurations are false for our purposes.
+
+        They either indicate an iOS device, which we won't run this
+        code on, or that the server we're testing for is on this
+        machine or wired directly to it. These cases won't happen.
+        """
+        for flag in range(0, 17) + [1 << 16, 1 << 17, 1 << 18]:
+            # only test cases without the reachable bit set:
+            flag = flag & ~ 2
+            self.assertEqual(False, flags_say_reachable(flag))
+
+
+class TestNMSListeningForNWStateChanges(TestCase):
+    """
+    Test that the NetworkManagerState class calls the callback with
+    ONLINE/OFFLINE when the state changes appropriately
+    """
+
+    @inlineCallbacks
+    def setUp(self):
+        """Setup array to hold state changes."""
+        yield super(TestNMSListeningForNWStateChanges, self).setUp()
+        self.network_changes = []
+
+    def _listen_network_changes(self, state):
+        """Fake callback function, records state changes."""
+        self.network_changes.append(state)
+
+    def test_network_state_change(self):
+        """Test the changes in the network connection."""
+        nms = NetworkManagerState(self._listen_network_changes)
+        nms._state_changed(2)
+        nms._state_changed(0)            # 0 or anything other than 2.
+        nms._state_changed(2)
+
+        self.assertEqual(self.network_changes,
+            [ONLINE, OFFLINE, ONLINE])
+
+
+class TestIsMachineConnectedFunc(TestCase):
+    """Simple test of is_machine_connected."""
+
+    @inlineCallbacks
+    def test_not_connected_returns_false(self):
+        """test that False comes back False"""
+        self.patch(darwin, "check_connected_state",
+                   lambda: False)
+        con = yield is_machine_connected()
+        self.assertEqual(con, False)
+
+    @inlineCallbacks
+    def test_connected_returns_true(self):
+        """check that True comes back True"""
+        self.patch(darwin, "check_connected_state",
+                   lambda: True)
+        con = yield is_machine_connected()
+        self.assertEqual(con, True)

=== added file 'ubuntuone/networkstate/tests/test_linux.py'
--- ubuntuone/networkstate/tests/test_linux.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/tests/test_linux.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,366 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2010-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Tests for the network state detection code."""
+
+from collections import defaultdict
+
+from twisted.internet.defer import inlineCallbacks
+from mocker import ARGS, KWARGS, ANY, MockerTestCase
+
+from ubuntuone.networkstate import (
+    linux,
+    NetworkFailException,
+    NetworkManagerState,
+)
+from ubuntuone.networkstate.linux import (
+    is_machine_connected,
+    NM_DBUS_INTERFACE,
+    NM_DBUS_OBJECTPATH,
+)
+from ubuntuone.networkstate.networkstates import (
+    ONLINE, OFFLINE, UNKNOWN,
+    NM_STATE_ASLEEP,
+    NM_STATE_ASLEEP_OLD,
+    NM_STATE_CONNECTING,
+    NM_STATE_CONNECTING_OLD,
+    NM_STATE_CONNECTED_OLD,
+    NM_STATE_CONNECTED_LOCAL,
+    NM_STATE_CONNECTED_SITE,
+    NM_STATE_CONNECTED_GLOBAL,
+    NM_STATE_DISCONNECTED,
+    NM_STATE_DISCONNECTED_OLD,
+    NM_STATE_UNKNOWN,
+)
+from ubuntuone.tests import TestCase
+
+
+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 FakeNetworkManagerState(object):
+
+    """Fake Network Manager State."""
+
+    connection_state = None
+
+    def __init__(self, function):
+        """Initialize Fake class."""
+        self.call_function = function
+
+    def find_online_state(self):
+        """Fake find_online_state for linux module."""
+        self.call_function(self.connection_state)
+
+
+class FakeDBusMatch(object):
+
+    """Fake a DBus match."""
+
+    def __init__(self, name, callback, interface):
+        self.name = name
+        self.callback = callback
+        self.interface = interface
+        self.removed = False
+
+    def remove(self):
+        """Stop calling the handler function on remove."""
+        self.removed = True
+
+
+class FakeDBusInterface(object):
+
+    """Fake DBus Interface."""
+
+    def __init__(self):
+        self._signals = defaultdict(list)
+
+    def Get(self, *args, **kwargs):
+        """Fake Get."""
+
+    def connect_to_signal(self, signal_name, handler_function, dbus_interface):
+        """Fake connect_to_signal."""
+        match = FakeDBusMatch(signal_name, handler_function, dbus_interface)
+        self._signals[signal_name].append(match)
+        return match
+
+    def emit_signal(self, signal_name, state):
+        """Emit signal for network state change."""
+        for match in self._signals[signal_name]:
+            match.callback(state)
+
+
+class FakeSystemBus(object):
+
+    """Fake SystemBus."""
+
+    objects = {(NM_DBUS_INTERFACE, NM_DBUS_OBJECTPATH, True): object()}
+
+    def get_object(self, interface, object_path, follow_name_owner_changes):
+        """Fake get_object."""
+        key = (interface, object_path, follow_name_owner_changes)
+        return self.objects[key]
+
+
+class TestConnection(TestCase):
+
+    """Test the state of the connection.
+
+    This TestCase tests over all the connection states possible.
+
+    """
+
+    @inlineCallbacks
+    def setUp(self):
+        """Setup the mocker dbus object tree."""
+        yield super(TestConnection, self).setUp()
+        self.patch(linux, "NetworkManagerState", FakeNetworkManagerState)
+        self.patch(linux.dbus, 'SystemBus', FakeSystemBus)
+        self.nm_interface = FakeDBusInterface()
+        self.patch(linux.dbus, 'Interface', lambda *a: self.nm_interface)
+        self.network_changes = []
+
+    def _listen_network_changes(self, state):
+        """Fake callback function."""
+        self.network_changes.append(state)
+
+    def test_network_state_change(self):
+        """Test the changes in the network connection."""
+        nms = NetworkManagerState(self._listen_network_changes)
+
+        nms.find_online_state()
+
+        self.nm_interface.emit_signal('StateChanged',
+            NM_STATE_CONNECTED_GLOBAL)
+        self.nm_interface.emit_signal('StateChanged', NM_STATE_DISCONNECTED)
+        self.nm_interface.emit_signal('StateChanged',
+            NM_STATE_CONNECTED_GLOBAL)
+
+        self.assertEqual(nms.state_signal.name, "StateChanged")
+        self.assertEqual(nms.state_signal.callback, nms.state_changed)
+        self.assertEqual(nms.state_signal.interface,
+            "org.freedesktop.NetworkManager")
+        self.assertEqual(self.network_changes,
+            [ONLINE, ONLINE, OFFLINE, ONLINE])
+        self.assertFalse(nms.state_signal.removed)
+
+    @inlineCallbacks
+    def test_is_machine_connected_nm_state_online(self):
+        """Callback given ONLINE should mean we are online"""
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   ONLINE)
+        d = yield is_machine_connected()
+        self.assertTrue(d)
+
+    @inlineCallbacks
+    def test_is_machine_connected_nm_state_offline(self):
+        """Callback given OFFLINE should mean we are offline"""
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   OFFLINE)
+        d = yield is_machine_connected()
+        self.assertFalse(d)
+
+    @inlineCallbacks
+    def test_is_machine_connected_nm_state_unknown(self):
+        """Callback given ONLINE should mean we are not online"""
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   UNKNOWN)
+        d = yield is_machine_connected()
+        self.assertFalse(d)
+
+    @inlineCallbacks
+    def test_is_machine_connected_callback_error(self):
+        """Test bad argument to is_machine_connected's internal callback.
+
+        Passing anything other than ONLINE/OFFLINE/UNKNOWN should
+        cause an exception.
+        """
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   NM_STATE_CONNECTED_GLOBAL)
+        yield self.assertFailure(is_machine_connected(), NetworkFailException)
+
+
+class NetworkManagerBaseTestCase(MockerTestCase):
+    """Base test case for NM state tests."""
+
+    def setUp(self):
+        """Setup the dbus object tree."""
+        super(NetworkManagerBaseTestCase, self).setUp()
+
+        self.dbusmock = self.mocker.mock()
+        self.dbusmock.SystemBus()
+        sysbusmock = self.mocker.mock()
+        self.mocker.result(sysbusmock)
+
+        sysbusmock.get_object(ARGS, KWARGS)
+
+    def connect_proxy(self, exc=None):
+        """Get a proxy mock object, and allow failing with specified exc."""
+        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)
+        if exc is not None:
+            self.mocker.result(exc)
+        self.mocker.replay()
+
+    def assertOnline(self, state):
+        """Check that the state given is ONLINE."""
+        self.assertEquals(state, ONLINE)
+
+    def assertOffline(self, state):
+        """Check that the state given is OFFLINE."""
+        self.assertEquals(state, OFFLINE)
+
+    def assertUnknown(self, state):
+        """Check that the state was UNKNOWN."""
+        self.assertEquals(state, UNKNOWN)
+
+    def get_nms(self, callback):
+        """Get the NetworkManagerState object."""
+        nms = NetworkManagerState(callback, self.dbusmock)
+        nms.find_online_state()
+        return nms
+
+    def check_nm_error(self, callback, error):
+        """Check that the error handling is correct."""
+        nms = self.get_nms(callback)
+        nms.got_error(error)
+
+    def check_nm_state(self, callback, state):
+        """Check the state handling is correct."""
+        nms = self.get_nms(callback)
+        nms.got_state(state)
+
+    def check_nm_state_change(self, callback, fmstate, tostate):
+        """Check the state change handling is correct."""
+        nms = self.get_nms(callback)
+        nms.got_state(fmstate)
+        nms.state_changed(tostate)
+
+
+class NetworkManagerStateTestCase(NetworkManagerBaseTestCase):
+    """Test NetworkManager state retrieval code."""
+
+    def setUp(self):
+        """Setup the dbus object tree."""
+        super(NetworkManagerStateTestCase, self).setUp()
+        self.connect_proxy()
+
+    def test_nm_asleep(self):
+        """Asleep status should mean offline."""
+        self.check_nm_state(self.assertOffline, NM_STATE_ASLEEP)
+
+    def test_nm_asleep_old(self):
+        """Asleep, old status, should mean offline."""
+        self.check_nm_state(self.assertOffline, NM_STATE_ASLEEP_OLD)
+
+    def test_nm_unknown(self):
+        """Unknown status should be treated the same as OFFLINE."""
+        self.check_nm_state(self.assertOffline, NM_STATE_UNKNOWN)
+
+    def test_nm_online_old(self):
+        """Check the connected, old status, case."""
+        self.check_nm_state(self.assertOnline, NM_STATE_CONNECTED_OLD)
+
+    def test_nm_offline_local(self):
+        """Check the connected, local status, case."""
+        self.check_nm_state(self.assertOffline, NM_STATE_CONNECTED_LOCAL)
+
+    def test_nm_offline_site(self):
+        """Check the connected, site status, case."""
+        self.check_nm_state(self.assertOffline, NM_STATE_CONNECTED_SITE)
+
+    def test_nm_online_global(self):
+        """Check the connected, global status, case."""
+        self.check_nm_state(self.assertOnline, NM_STATE_CONNECTED_GLOBAL)
+
+    def test_nm_offline_old(self):
+        """Check the disconnected, old status, case."""
+        self.check_nm_state(self.assertOffline, NM_STATE_DISCONNECTED_OLD)
+
+    def test_nm_offline(self):
+        """Check the disconnected case."""
+        self.check_nm_state(self.assertOffline, NM_STATE_DISCONNECTED)
+
+    def test_nm_connecting_then_online_old(self):
+        """Check the waiting for connection, old status, case."""
+        self.check_nm_state_change(self.assertOnline,
+                                   NM_STATE_CONNECTING_OLD,
+                                   NM_STATE_CONNECTED_OLD)
+
+    def test_nm_connecting_then_online(self):
+        """Check the waiting for connection case."""
+        self.check_nm_state_change(self.assertOnline,
+                                   NM_STATE_CONNECTING,
+                                   NM_STATE_CONNECTED_GLOBAL)
+
+    def test_nm_connecting_then_offline_old(self):
+        """Check the waiting but fail, old status, case."""
+        self.check_nm_state_change(self.assertOffline,
+                                   NM_STATE_CONNECTING_OLD,
+                                   NM_STATE_DISCONNECTED_OLD)
+
+    def test_nm_connecting_then_offline(self):
+        """Check the waiting but fail case."""
+        self.check_nm_state_change(self.assertOffline,
+                                   NM_STATE_CONNECTING, NM_STATE_DISCONNECTED)
+
+
+class NetworkManagerStateErrorsTestCase(NetworkManagerBaseTestCase):
+    """Test NetworkManager state retrieval code."""
+
+    def mock_except_while_getting_proxy(self, exc):
+        """Simulate an exception while getting the DBus proxy object."""
+        self.mocker.throw(exc)
+        self.mocker.result(exc)
+        self.mocker.replay()
+
+    def test_nm_check_errors(self):
+        """Trying to reach NM fails with some error."""
+        self.connect_proxy(Exception)
+        self.check_nm_error(self.assertOnline, Exception())
+
+    def test_dbus_problem(self):
+        """Check the case when DBus throws some other exception."""
+        self.mock_except_while_getting_proxy(TestException)
+        self.get_nms(self.assertOnline)

=== added file 'ubuntuone/networkstate/tests/test_windows.py'
--- ubuntuone/networkstate/tests/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/tests/test_windows.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Tests for the network manager."""
+
+from ctypes import windll
+from mocker import MockerTestCase
+from twisted.internet.defer import inlineCallbacks
+
+from ubuntuone.networkstate import NetworkFailException
+from ubuntuone.networkstate.windows import (
+    is_machine_connected,
+    NetworkManager,
+    NetworkManagerState,
+    ONLINE,
+    OFFLINE)
+from ubuntuone.tests import TestCase
+
+
+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 the Network Manager State."""
+
+    def setUp(self):
+        super(TestNetworkManagerState, self).setUp()
+        self.network_manager = self.mocker.mock()
+        self.is_connected = self.mocker.replace(
+            'ubuntuone.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.daemon = True
+        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.daemon = True
+        self.thread.start()
+        self.mocker.replay()
+        self.state.find_online_state(listener=self.network_manager,
+                                     listener_thread=self.thread)
+
+
+class FakeWininet(object):
+    """Fake wininet for windll."""
+
+    connection_state = -1
+
+    def InternetGetConnectedState(self, *args, **kwargs):
+        """Fake InternetGetConnectedState function from wininet."""
+        return self.connection_state
+
+
+class FakeWininetException(object):
+    """Fake wininet for windll."""
+
+    connection_state = -1
+
+    def InternetGetConnectedState(self, *args, **kwargs):
+        """Fake InternetGetConnectedState function from wininet."""
+        raise Exception()
+
+
+class TestConnection(TestCase):
+    """Test the state of the connection."""
+
+    @inlineCallbacks
+    def setUp(self):
+        """Setup the mocker dbus object tree."""
+        yield super(TestConnection, self).setUp()
+        self.patch(windll, "wininet", FakeWininet())
+
+    @inlineCallbacks
+    def test_is_machine_connected_connected(self):
+        """Fake the NetworkManagerState."""
+        self.patch(FakeWininet, "connection_state", 1)
+        result = yield is_machine_connected()
+        self.assertTrue(result)
+
+    @inlineCallbacks
+    def test_is_machine_connected_disconnected(self):
+        """Fake the NetworkManagerState."""
+        self.patch(FakeWininet, "connection_state", 0)
+        result = yield is_machine_connected()
+        self.assertFalse(result)
+
+    @inlineCallbacks
+    def test_is_machine_connected_error(self):
+        """Fake the NetworkManagerState."""
+        self.patch(windll, "wininet", FakeWininetException())
+        yield self.assertFailure(is_machine_connected(), NetworkFailException)

=== added file 'ubuntuone/networkstate/windows.py'
--- ubuntuone/networkstate/windows.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/networkstate/windows.py	2016-05-30 13:04:07 +0000
@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Network status implementation on Windows."""
+
+
+import logging
+import pythoncom
+
+from ctypes import windll, byref
+from ctypes.wintypes import DWORD
+from threading import Thread
+
+from twisted.internet import defer
+from win32com.server.policy import DesignatedWrapPolicy
+from win32com.client import Dispatch
+
+from ubuntuone.networkstate import NetworkFailException
+from ubuntuone.networkstate.networkstates import ONLINE, OFFLINE
+
+
+logger = logging.getLogger(__name__)
+
+# naming errors are deliberated because we are following the COM naming to make
+# it clear for later developers.
+
+# 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):
+        self._wrap_(self)
+        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 a deferred that when fired, returns if the machine is online."""
+    try:
+        wininet = windll.wininet
+        flags = DWORD()
+        connected = wininet.InternetGetConnectedState(byref(flags), None)
+        return defer.succeed(connected == 1)
+    except Exception as e:
+        logger.exception('is_machine_connected failed with:')
+        return defer.fail(NetworkFailException(e))
+
+
+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)
+
+    def find_online_state(self, listener=None, listener_thread=None):
+        """Get the network state and return it thru the set callback."""
+        # check the current status right now
+        if is_machine_connected():
+            self.result_cb(ONLINE)
+        else:
+            self.result_cb(OFFLINE)
+        if listener is None:
+            # start listening for network changes
+            listener = NetworkManager(connected_cb=self.connection_made,
+                                      disconnected_cb=self.connection_lost)
+        if listener_thread is None:
+            listener_thread = Thread(target=listener.register,
+                                     name="Network Connection Monitor")
+        listener_thread.daemon = True
+        listener_thread.start()

=== removed directory 'ubuntuone/platform/credentials'
=== removed file 'ubuntuone/platform/credentials/__init__.py'
--- ubuntuone/platform/credentials/__init__.py	2015-09-29 21:05:26 +0000
+++ ubuntuone/platform/credentials/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,404 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-
-"""Common code for the credentials management."""
-
-import gettext
-import logging
-import os
-import platform
-import urllib
-import sys
-
-from functools import partial
-
-from twisted.internet import defer
-
-from ubuntu_sso import UI_EXECUTABLE_QT
-from ubuntu_sso.credentials import (
-    PING_URL_KEY,
-    POLICY_URL_KEY,
-    UI_EXECUTABLE_KEY,
-    TC_URL_KEY,
-)
-
-from ubuntuone import clientdefs
-from ubuntuone.logger import (
-    basic_formatter,
-    CustomRotatingFileHandler,
-    log_call,
-)
-from ubuntuone.platform.logger import ubuntuone_log_dir
-
-LOG_LEVEL = logging.DEBUG
-path = os.path.join(ubuntuone_log_dir, 'credentials.log')
-MAIN_HANDLER = CustomRotatingFileHandler(path)
-MAIN_HANDLER.setFormatter(basic_formatter)
-MAIN_HANDLER.setLevel(LOG_LEVEL)
-
-logger = logging.getLogger("ubuntuone.credentials")
-logger.setLevel(LOG_LEVEL)
-logger.addHandler(MAIN_HANDLER)
-
-NO_OP = lambda *args, **kwargs: None
-Q_ = lambda string: gettext.dgettext(clientdefs.GETTEXT_PACKAGE, string)
-APP_NAME = u"Magicicada"
-TC_URL = u"https://one.ubuntu.com/terms/"
-POLICY_URL = u"https://one.ubuntu.com/privacy/"
-
-
-def platform_data():
-    result = {'platform': platform.system(),
-              'platform_version': platform.release(),
-              'platform_arch': platform.machine(),
-              'client_version': clientdefs.VERSION}
-    # urlencode will not encode unicode, only bytes
-    result = urllib.urlencode(result)
-    return result
-
-
-BASE_PING_URL = \
-    u"https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/{email}"
-# the result of platform_data is given by urlencode, encoded with ascii
-PING_URL = BASE_PING_URL + u"?" + platform_data().decode('ascii')
-UI_PARAMS = {
-    PING_URL_KEY: PING_URL,
-    POLICY_URL_KEY: POLICY_URL,
-    TC_URL_KEY: TC_URL,
-    UI_EXECUTABLE_KEY: UI_EXECUTABLE_QT,
-}
-
-
-class CredentialsError(Exception):
-    """A general exception when hadling credentilas."""
-
-
-class CredentialsManagementTool(object):
-    """Wrapper to CredentialsManagement.
-
-    The goal of this class is to abstract the caller from calling the IPC
-    service implemented in the class CredentialsManagement.
-
-    """
-
-    def __init__(self):
-        self._cleanup_signals = []
-        self._proxy = None
-
-    def callback(self, result, deferred):
-        """Fire 'deferred' with success, sending 'result' as result."""
-        deferred.callback(result)
-
-    def errback(self, error, deferred):
-        """Fire 'deferred' with error sending a CredentialsError."""
-        deferred.errback(CredentialsError(error))
-
-    def cleanup(self, _):
-        """Disconnect all the DBus signals."""
-        for sig in self._cleanup_signals:
-            logger.debug('cleanup: removing signal match %r', sig)
-            remove = getattr(sig, "remove", None)
-            if remove:
-                remove()
-
-        return _
-
-    def get_platform_source(self):
-        """Platform-specific source."""
-        if sys.platform in ('win32', 'darwin'):
-            from ubuntuone.platform.credentials import ipc_service
-            source = ipc_service
-        else:
-            from ubuntuone.platform.credentials import dbus_service
-            source = dbus_service
-        return source
-
-    @defer.inlineCallbacks
-    def get_creds_proxy(self):
-        """Call the platform-dependent get_creds_proxy caching the result."""
-        if self._proxy is None:
-            source = self.get_platform_source()
-            self._proxy = yield source.get_creds_proxy()
-        defer.returnValue(self._proxy)
-
-    # do not log returned credentials
-    @log_call(logger.debug, with_result=False)
-    @defer.inlineCallbacks
-    def find_credentials(self):
-        """Find credentials for Magicicada.
-
-        Return a deferred that, when fired, will return the credentials for
-        Magicicada for the current logged in user.
-
-        The credentials is a dictionary with both string keys and values. The
-        dictionary may be either empty if there are no credentials for the
-        user, or will hold five items as follow:
-
-        - "name"
-        - "token"
-        - "token_secret"
-        - "consumer_key"
-        - "consumer_secret"
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = yield self.get_creds_proxy()
-
-        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsNotFound',
-            partial(self.callback, result={}, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsError', partial(self.errback, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.find_credentials(
-            reply_handler=partial(self.callback, result=None, deferred=done),
-            error_handler=partial(self.errback, deferred=done))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)
-
-    @log_call(logger.debug)
-    @defer.inlineCallbacks
-    def clear_credentials(self):
-        """Clear credentials for Magicicada.
-
-        Return a deferred that, when fired, will return no result but will
-        indicate that the Magicicada credentials for the current user were
-        removed from the local keyring.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = yield self.get_creds_proxy()
-
-        sig = proxy.connect_to_signal(
-            'CredentialsCleared',
-            partial(self.callback, result=None, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsError', partial(self.errback, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.clear_credentials(
-            reply_handler=partial(self.callback, result=None, deferred=done),
-            error_handler=partial(self.errback, deferred=done))
-
-        yield done
-
-        yield d
-
-    # do not log token
-    @log_call(logger.debug, with_args=False)
-    @defer.inlineCallbacks
-    def store_credentials(self, token):
-        """Store credentials for Magicicada.
-
-        The parameter 'token' should be a dictionary that matches the
-        description of the result of 'find_credentials'.
-
-        Return a deferred that, when fired, will return no result but will
-        indicate that 'token' was stored in the local keyring as the new Ubuntu
-        One credentials for the current user.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = yield self.get_creds_proxy()
-
-        sig = proxy.connect_to_signal(
-            'CredentialsStored',
-            partial(self.callback, result=None, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsError', partial(self.errback, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.store_credentials(
-            token,
-            reply_handler=partial(self.callback, result=None, deferred=done),
-            error_handler=partial(self.errback, deferred=done))
-
-        yield done
-
-        yield d
-
-    # do not log returned credentials
-    @log_call(logger.debug, with_result=False)
-    @defer.inlineCallbacks
-    def register(self, window_id=0):
-        """Register to Magicicada.
-
-        Return a deferred that, when fired, will return the credentials for
-        Magicicada for the current logged in user.
-
-        If there are no credentials for the current user, a GTK UI will be
-        opened to invite the user to register to Magicicada. This UI provides
-        options to either register (main screen) or login (secondary screen).
-
-        You can pass an optional 'window_id' parameter that will be used by the
-        GTK UI to be set transient for it.
-
-        The returned credentials will be either a non-empty dictionary like the
-        one described in 'find_credentials', or None. The latter indicates that
-        there were no credentials for the user in the local keyring and that
-        the user refused to register to Magicicada.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = yield self.get_creds_proxy()
-
-        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'AuthorizationDenied',
-            partial(self.callback, result=None, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsError', partial(self.errback, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.register(
-            {'window_id': str(window_id)},
-            reply_handler=partial(self.callback, result=None, deferred=done),
-            error_handler=partial(self.errback, deferred=done))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)
-
-    # do not log returned credentials
-    @log_call(logger.debug, with_result=False)
-    @defer.inlineCallbacks
-    def login(self, window_id=0):
-        """Login to Magicicada.
-
-        Return a deferred that, when fired, will return the credentials for
-        Magicicada for the current logged in user.
-
-        If there are no credentials for the current user, a GTK UI will be
-        opened to invite the user to login to Magicicada. This UI provides
-        options to either login (main screen) or retrieve password (secondary
-        screen).
-
-        You can pass an optional 'window_id' parameter that will be used by the
-        GTK UI to be set transient for it.
-
-        The returned credentials will be either a non-empty dictionary like the
-        one described in 'find_credentials', or None. The latter indicates that
-        there were no credentials for the user in the local keyring and that
-        the user refused to login to Magicicada.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = yield self.get_creds_proxy()
-
-        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'AuthorizationDenied',
-            partial(self.callback, result=None, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsError', partial(self.errback, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.login(
-            {'window_id': str(window_id)},
-            reply_handler=partial(self.callback, result=None, deferred=done),
-            error_handler=partial(self.errback, deferred=done))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)
-
-    # do not log password nor returned credentials
-    @log_call(logger.debug, with_args=False, with_result=False)
-    @defer.inlineCallbacks
-    def login_email_password(self, email, password):
-        """Login to Magicicada.
-
-        Return a deferred that, when fired, will return the credentials for
-        Magicicada for the given email and password.
-
-        The returned credentials will be either a non-empty dictionary like the
-        one described in 'find_credentials', or None. The latter indicates
-        invalid or wrong user/password.
-
-        """
-        d = defer.Deferred()
-        d.addBoth(self.cleanup)
-
-        proxy = yield self.get_creds_proxy()
-
-        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
-        self._cleanup_signals.append(sig)
-
-        sig = proxy.connect_to_signal(
-            'CredentialsError', partial(self.errback, deferred=d))
-        self._cleanup_signals.append(sig)
-
-        done = defer.Deferred()
-        proxy.login_email_password(
-            {'email': email, 'password': password},
-            reply_handler=partial(self.callback, result=None, deferred=done),
-            error_handler=partial(self.errback, deferred=done))
-
-        yield done
-
-        result = yield d
-        defer.returnValue(result)

=== removed file 'ubuntuone/platform/credentials/dbus_service.py'
--- ubuntuone/platform/credentials/dbus_service.py	2015-09-19 23:15:50 +0000
+++ ubuntuone/platform/credentials/dbus_service.py	1970-01-01 00:00:00 +0000
@@ -1,285 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Author: Natalia B. Bidart <[e-mail]>
-#
-# Copyright 2010-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Magicicada credentials management dbus service."""
-
-import dbus
-import dbus.service
-import ubuntu_sso
-
-from ubuntuone.platform.credentials import (
-    APP_NAME,
-    logger,
-    NO_OP,
-    UI_PARAMS,
-)
-
-
-TIMEOUT_INTERVAL = 10000  # 10 seconds
-
-# constants
-DBUS_BUS_NAME = "com.ubuntuone.Credentials"
-DBUS_CREDENTIALS_PATH = "/credentials"
-DBUS_CREDENTIALS_IFACE = "com.ubuntuone.CredentialsManagement"
-
-
-class CredentialsManagement(dbus.service.Object):
-    """DBus object that manages Magicicada credentials."""
-
-    def __init__(self, timeout_func=lambda *a: None,
-                 shutdown_func=lambda *a: None, *args, **kwargs):
-        super(CredentialsManagement, self).__init__(*args, **kwargs)
-        self._ref_count = 0
-        self.timeout_func = timeout_func
-        self.shutdown_func = shutdown_func
-
-        self.sso_match = None
-        self.sso_proxy = self._get_sso_proxy()
-
-    def _signal_handler(self, *args, **kwargs):
-        """Generic signal handler."""
-        member = kwargs.get('member', None)
-        app_name = args[0] if len(args) > 0 else None
-        logger.debug('Handling DBus signal for member: %r, app_name: %r.',
-                     member, app_name)
-
-        if app_name != APP_NAME:
-            logger.info('Received %r but app_name %r does not match %r, '
-                        'exiting.', member, app_name, APP_NAME)
-            return
-
-        sig = getattr(self, member)
-
-        if member in ('CredentialsFound', 'CredentialsError'):
-            # this are the only signals that will forward the parameter
-            logger.info('%r', member)
-            arg = args[1]
-            sig(arg)
-        else:
-            sig()
-
-    def _get_sso_proxy(self):
-        """Get the SSO dbus proxy."""
-        bus = dbus.SessionBus()
-        # register signal handlers for each kind of error
-        self.sso_match = bus.add_signal_receiver(
-            self._signal_handler, member_keyword='member',
-            dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
-        try:
-            obj = bus.get_object(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CREDENTIALS_PATH,
-                                 follow_name_owner_changes=True)
-            proxy = dbus.Interface(obj, ubuntu_sso.DBUS_CREDENTIALS_IFACE)
-        except:
-            logger.exception('get_sso_proxy:')
-            raise
-
-        return proxy
-
-    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()
-
-    # Operator not preceded by a space (fails with dbus decorators)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
-    def AuthorizationDenied(self):
-        """Signal thrown when the user denies the authorization."""
-        self.ref_count -= 1
-        logger.info('%s: emitting AuthorizationDenied.',
-                    self.__class__.__name__)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='a{ss}')
-    def CredentialsFound(self, credentials):
-        """Signal thrown when the credentials are found."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsFound.',
-                    self.__class__.__name__)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
-    def CredentialsNotFound(self):
-        """Signal thrown when the credentials are not found."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsNotFound.',
-                    self.__class__.__name__)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
-    def CredentialsCleared(self):
-        """Signal thrown when the credentials were cleared."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsCleared.',
-                    self.__class__.__name__)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
-    def CredentialsStored(self):
-        """Signal thrown when the credentials were cleared."""
-        self.ref_count -= 1
-        logger.info('%s: emitting CredentialsStored.',
-                    self.__class__.__name__)
-
-    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='a{ss}')
-    def CredentialsError(self, error_dict):
-        """Signal thrown when there is a problem getting the credentials."""
-        self.ref_count -= 1
-        logger.error('%s: emitting CredentialsError with error_dict %r.',
-                     self.__class__.__name__, error_dict)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         async_callbacks=("reply_handler", "error_handler"))
-    def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Ask the Magicicada credentials."""
-        self.ref_count += 1
-        self.sso_proxy.find_credentials(
-            APP_NAME, dbus.Dictionary({}, signature='ss'),
-            reply_handler=reply_handler, error_handler=error_handler)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         out_signature="a{ss}",
-                         async_callbacks=("reply_handler", "error_handler"))
-    def find_credentials_sync(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Ask the Magicicada credentials synchronously.
-
-        This method SHOULD NOT be used, is here only for compatibilty issues.
-
-        """
-
-        def decrease_counter_success(credentials):
-            """Call 'callback' and decrease the root ref counter."""
-            reply_handler(credentials)
-            self.ref_count -= 1
-
-        def decrease_counter_error(error):
-            """Call 'errback' and decrease the root ref counter."""
-            error_handler(error)
-            self.ref_count -= 1
-
-        self.ref_count += 1
-        self.sso_proxy.find_credentials_sync(
-            APP_NAME,
-            dbus.Dictionary({}, signature='ss'),
-            reply_handler=decrease_counter_success,
-            error_handler=decrease_counter_error)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         async_callbacks=("reply_handler", "error_handler"))
-    def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Clear the Magicicada credentials."""
-        self.ref_count += 1
-        self.sso_proxy.clear_credentials(
-            APP_NAME, dbus.Dictionary({}, signature='ss'),
-            reply_handler=reply_handler, error_handler=error_handler)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='a{ss}',
-                         async_callbacks=("reply_handler", "error_handler"))
-    def store_credentials(self, credentials,
-                          reply_handler=NO_OP, error_handler=NO_OP):
-        """Store the token for Magicicada application."""
-        self.ref_count += 1
-        self.sso_proxy.store_credentials(
-            APP_NAME, credentials,
-            reply_handler=reply_handler, error_handler=error_handler)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='a{ss}',
-                         async_callbacks=("reply_handler", "error_handler"))
-    def register(self, args, reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt to register to Magicicada."""
-        self.ref_count += 1
-        params = dict(UI_PARAMS)
-        params.update(args)
-        self.sso_proxy.register(
-            APP_NAME, params,
-            reply_handler=reply_handler, error_handler=error_handler)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='a{ss}',
-                         async_callbacks=("reply_handler", "error_handler"))
-    def login(self, args, reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt to login to Magicicada."""
-        self.ref_count += 1
-        params = dict(UI_PARAMS)
-        params.update(args)
-        self.sso_proxy.login(
-            APP_NAME, params,
-            reply_handler=reply_handler, error_handler=error_handler)
-
-    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
-                         in_signature='a{ss}',
-                         async_callbacks=("reply_handler", "error_handler"))
-    def login_email_password(self, args, reply_handler=NO_OP,
-                             error_handler=NO_OP):
-        """Get credentials if found else prompt to login to Magicicada."""
-        self.ref_count += 1
-        params = dict(UI_PARAMS)
-        params.update(args)
-        self.sso_proxy.login_email_password(
-            APP_NAME, params,
-            reply_handler=reply_handler, error_handler=error_handler)
-
-
-def get_creds_proxy():
-    """Get the CredentialsManagement proxy."""
-    bus = dbus.SessionBus()
-    try:
-        obj = bus.get_object(DBUS_BUS_NAME,
-                             DBUS_CREDENTIALS_PATH,
-                             follow_name_owner_changes=True)
-        proxy = dbus.Interface(obj, DBUS_CREDENTIALS_IFACE)
-    except:
-        logger.exception('get_creds_proxy:')
-        raise
-
-    return proxy

=== removed file 'ubuntuone/platform/credentials/ipc_service.py'
--- ubuntuone/platform/credentials/ipc_service.py	2015-09-19 23:15:50 +0000
+++ ubuntuone/platform/credentials/ipc_service.py	1970-01-01 00:00:00 +0000
@@ -1,174 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2011-2012 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/>.
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the
-# OpenSSL library under certain conditions as described in each
-# individual source file, and distribute linked combinations
-# including the two.
-# You must obey the GNU General Public License in all respects
-# for all of the code used other than OpenSSL.  If you modify
-# file(s) with this exception, you may extend this exception to your
-# version of the file(s), but you are not obligated to do so.  If you
-# do not wish to do so, delete this exception statement from your
-# version.  If you delete this exception statement from all source
-# files in the program, then also delete it here.
-"""Magicicada credentials management IPC service."""
-
-
-from ubuntu_sso.main import get_sso_client
-from twisted.internet import defer
-
-from ubuntuone.platform.credentials import (
-    APP_NAME,
-    logger,
-    NO_OP,
-    UI_PARAMS,
-)
-
-
-class RemovableSignal(object):
-    """A signal that can be removed."""
-
-    def __init__(self, proxy, signal_name, callback):
-        """Initialize this instance."""
-        self.proxy = proxy
-        self.signal_name = signal_name
-        self.callback = callback
-        setattr(self.proxy, signal_name, self)
-
-    def __call__(self, *args, **kwargs):
-        """Call this instance."""
-        app_name = args[0] if len(args) > 0 else None
-        logger.debug('Handling signal_name: %r, app_name: %r.',
-                     self.signal_name, app_name)
-
-        if app_name != APP_NAME:
-            # This fixed bug #818190: filter signals not related to APP_NAME
-            logger.info('Received %r but app_name %r does not match %r, '
-                        'exiting.', self.signal_name, app_name, APP_NAME)
-            return
-
-        if self.callback is not None:
-            # drop the app name, callers do not care about it
-            args = args[1:]
-            logger.debug('Calling %r with %d args and %d kwargs.',
-                         self.callback, len(args), len(kwargs))
-            return self.callback(*args, **kwargs)
-
-    def remove(self):
-        """Remove this signal."""
-        if getattr(self.proxy, self.signal_name, False):
-            setattr(self.proxy, self.signal_name, None)
-
-
-class CredentialsManagement(object):
-    """Object that manages Magicicada credentials."""
-
-    _SIGNAL_TO_CALLBACK_MAPPING = {
-        'AuthorizationDenied': 'on_authorization_denied_cb',
-        'CredentialsCleared': 'on_credentials_cleared_cb',
-        'CredentialsError': 'on_credentials_error_cb',
-        'CredentialsFound': 'on_credentials_found_cb',
-        'CredentialsNotFound': 'on_credentials_not_found_cb',
-        'CredentialsStored': 'on_credentials_stored_cb',
-    }
-
-    def __init__(self, proxy, *args, **kwargs):
-        super(CredentialsManagement, self).__init__(*args, **kwargs)
-        self.sso_proxy = proxy
-
-    def connect_to_signal(self, signal_name, callback):
-        """Register 'callback' to be called when 'signal_name' is emitted."""
-        cb_name = self._SIGNAL_TO_CALLBACK_MAPPING[signal_name]
-        match = RemovableSignal(self.sso_proxy, cb_name, callback)
-        return match
-
-    def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Ask the Magicicada credentials."""
-        d = self.sso_proxy.find_credentials(APP_NAME, {})
-        d.addCallbacks(lambda _: reply_handler(), error_handler)
-
-    def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
-        """Clear the Magicicada credentials."""
-        d = self.sso_proxy.clear_credentials(APP_NAME, {})
-        d.addCallbacks(lambda _: reply_handler(), error_handler)
-
-    def store_credentials(self, credentials,
-                          reply_handler=NO_OP, error_handler=NO_OP):
-        """Store the token for Magicicada application."""
-        d = self.sso_proxy.store_credentials(APP_NAME, credentials)
-        d.addCallbacks(lambda _: reply_handler(), error_handler)
-
-    def register(self, args, reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt to register to Magicicada."""
-        params = dict(UI_PARAMS)
-        params.update(args)
-        d = self.sso_proxy.register(APP_NAME, params)
-        d.addCallbacks(lambda _: reply_handler(), error_handler)
-
-    def login(self, args, reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else prompt to login to Magicicada."""
-        params = dict(UI_PARAMS)
-        params.update(args)
-        d = self.sso_proxy.login(APP_NAME, params)
-        d.addCallbacks(lambda _: reply_handler(), error_handler)
-
-    def login_email_password(self, args,
-                             reply_handler=NO_OP, error_handler=NO_OP):
-        """Get credentials if found else login to Magicicada."""
-        params = dict(UI_PARAMS)
-        params.update(args)
-        d = self.sso_proxy.login_email_password(APP_NAME, params)
-        d.addCallbacks(lambda _: reply_handler(), error_handler)
-
-    def register_to_credentials_stored(self, callback):
-        """Register to the CredentialsStored dbus signal."""
-        return RemovableSignal(self.sso_proxy, "on_credentials_stored_cb",
-                               callback)
-
-    def register_to_credentials_cleared(self, callback):
-        """Register to the CredentialsCleared dbus signal."""
-        return RemovableSignal(self.sso_proxy, "on_credentials_cleared_cb",
-                               callback)
-
-    def register_to_credentials_found(self, callback):
-        """Register to the CredentialsFound dbus signal."""
-        return RemovableSignal(self.sso_proxy, "on_credentials_found_cb",
-                               callback)
-
-    def register_to_credentials_not_found(self, callback):
-        """Register to the CredentialsFound dbus signal."""
-        return RemovableSignal(self.sso_proxy, "on_credentials_not_found_cb",
-                               callback)
-
-    def register_to_authorization_denied(self, callback):
-        """Register to the AuthorizationDenied dbus signal."""
-        return RemovableSignal(self.sso_proxy, "on_authorization_denied_cb",
-                               callback)
-
-    def register_to_credentials_error(self, callback):
-        """Register to the CredentialsError dbus signal."""
-        return RemovableSignal(self.sso_proxy, "on_credentials_error_cb",
-                               callback)
-
-
[e-mail]
-def get_creds_proxy():
-    """Get the CredentialsManagement proxy."""