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

[Natalia Bidart]

- Updating from trunk up to revno 940:

[ Alejandro J. Cura <email address hidden> ]
  - Make windows Keyring no longer depend on twisted (LP: #969159).
  - Daemonize the network state thread under windows (LP: #963404).

[ Diego Sarmentero <email address hidden> ]
  - Setting the style directly to the widget to remove the one
    from the application (LP: #969455).

[ Manuel de la Pena <email address hidden> ]
  - Fixed the issue where we use an empty proxy url when the proxy
    was not set in gsettings (LP: #969280).
  - Changed the way in which the proxy settings are retrieved on
    windows to ensure that proxy() returns the correct one and not a
    null initialized one. This fixes the creds retrieval issue
    because the hostName is not longer '' (LP: #958938).

[Alejandro J. Cura (alecu)]

+1

review: Approve

=== modified file 'data/qt/stylesheet.qss'
--- data/qt/stylesheet.qss	2012-03-21 17:57:49 +0000
+++ data/qt/stylesheet.qss	2012-04-03 12:14:21 +0000
@@ -81,7 +81,6 @@
 }
 
 QFrame#frm_box {
-    background: #ffffff;
     border-radius: 5px;
     border-style: solid;
     border-color: #939389;
@@ -90,6 +89,10 @@
     min-height: 100px;
 }
 
+LoadingOverlay {
+    background: transparent;
+}
+
 WizardHeader {
     padding-top: 1px;
     padding-bottom: 1px;

=== modified file 'ubuntu_sso/keyring/windows.py'
--- ubuntu_sso/keyring/windows.py	2011-03-30 22:57:37 +0000
+++ ubuntu_sso/keyring/windows.py	2012-04-03 12:14:21 +0000
@@ -18,7 +18,7 @@
 
 from json import loads, dumps
 
-from twisted.internet.threads import deferToThread
+from ubuntu_sso.utils.windows import qtDeferToThread as deferToThread
 
 USERNAME = 'ubuntu_sso'
 

=== modified file 'ubuntu_sso/networkstate/tests/test_windows.py'
--- ubuntu_sso/networkstate/tests/test_windows.py	2011-11-11 19:20:59 +0000
+++ ubuntu_sso/networkstate/tests/test_windows.py	2012-04-03 12:14:21 +0000
@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Author: Manuel de la Pena<[e-mail]>
-#
-# Copyright 2011 Canonical Ltd.
+# 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
@@ -80,7 +78,7 @@
 
 
 class TestNetworkManagerState(MockerTestCase):
-    """Test he Network Manager State."""
+    """Test the Network Manager State."""
 
     def setUp(self):
         super(TestNetworkManagerState, self).setUp()
@@ -109,6 +107,7 @@
         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,
@@ -120,6 +119,7 @@
         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,
@@ -127,7 +127,6 @@
 
 
 class FakeWininet(object):
-
     """Fake wininet for windll."""
 
     connection_state = -1
@@ -140,7 +139,6 @@
 
 
 class FakeWininetException(object):
-
     """Fake wininet for windll."""
 
     connection_state = -1
@@ -153,7 +151,6 @@
 
 
 class TestConnection(TestCase):
-
     """Test the state of the connection."""
 
     @inlineCallbacks

=== modified file 'ubuntu_sso/networkstate/windows.py'
--- ubuntu_sso/networkstate/windows.py	2012-01-04 16:49:43 +0000
+++ ubuntu_sso/networkstate/windows.py	2012-04-03 12:14:21 +0000
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
-# Author: Manuel de la Pena <[e-mail]>
 #
-# Copyright 2011 Canonical Ltd.
+# 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
@@ -207,4 +206,5 @@
         if listener_thread is None:
             listener_thread = Thread(target=listener.register,
                                      name='Ubuntu SSO NetworkManager')
+        listener_thread.daemon = True
         listener_thread.start()

=== modified file 'ubuntu_sso/utils/runner/qt.py'
--- ubuntu_sso/utils/runner/qt.py	2012-02-10 15:44:28 +0000
+++ ubuntu_sso/utils/runner/qt.py	2012-04-03 12:14:21 +0000
@@ -16,7 +16,10 @@
 
 """Utility to spawn another program from a plain Qt mainloop."""
 
+import sys
+
 from PyQt4 import QtCore
+from twisted.python import procutils
 
 from ubuntu_sso.logger import setup_logging
 
@@ -66,6 +69,10 @@
     process.error.connect(handle_error)
 
     args = list(args)
+    if sys.platform.startswith("win") and not args[0].endswith("exe"):
+        python_exe = procutils.which("python.exe")
+        if python_exe:
+            args.insert(0, python_exe[0])
     program = args[0]
     argv = args[1:]
     process.start(program, argv)

=== modified file 'ubuntu_sso/utils/runner/tests/test_qt.py'
--- ubuntu_sso/utils/runner/tests/test_qt.py	2012-02-23 13:17:46 +0000
+++ ubuntu_sso/utils/runner/tests/test_qt.py	2012-04-03 12:14:21 +0000
@@ -141,3 +141,22 @@
         yield d
 
         self.assertNotIn(self.process, qt._processes)
+
+    @defer.inlineCallbacks
+    def test_start_process_win_devel(self):
+        """Test the windows devel case."""
+        calls = []
+        fake_python = r"c:\python99\python.exe"
+        self.patch(runner.qt.sys, "platform", "win98")
+        self.patch(runner.qt.procutils, "which", lambda _: [fake_python])
+        self.patch(subprocess, "call", calls.append)
+        self.patch(self, "args", ["bin/program", "arg1", "arg2"])
+
+        d = defer.Deferred()
+        runner.qt.spawn_program(self.args,
+            reply_handler=d.callback, error_handler=lambda **kw: d.errback(kw))
+        yield d
+
+        cmdline = calls[0]
+        self.assertEqual(cmdline[0], fake_python,
+                        "python.exe is added to the command line.")

=== added file 'ubuntu_sso/utils/tests/test_windows.py'
--- ubuntu_sso/utils/tests/test_windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/tests/test_windows.py	2012-04-03 12:14:21 +0000
@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+#
+# 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/>.
+
+"""Tests for the platform specific functions (for Windows)."""
+
+import thread
+
+from twisted.internet import defer
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso.utils.windows import qtDeferToThread
+
+
+class FakeException(Exception):
+    """A Fake exception."""
+
+
+class QtDeferToThreadTestCase(TestCase):
+    """A Qt-based implementation of deferToThread."""
+
+    @defer.inlineCallbacks
+    def test_executes_function_returns_result(self):
+        """The passed function is executed and returns the result."""
+
+        def fake_operation(first, second="world!"):
+            """Testing positional and keyword arguments."""
+            return first + " " + second
+
+        result = yield qtDeferToThread(fake_operation, "hola", second="mundo!")
+        self.assertEqual(result, "hola mundo!")
+
+    @defer.inlineCallbacks
+    def test_exceptions_become_failures(self):
+        """Any exception while running the function becomes a failure."""
+
+        def fake_raise():
+            """Throw the fake exception."""
+            raise FakeException
+
+        yield self.assertFailure(qtDeferToThread(fake_raise), FakeException)
+
+    @defer.inlineCallbacks
+    def test_function_runs_in_new_thread(self):
+        """The concerned function is run in a different thread."""
+
+        def inner_function():
+            """This should be run in a different thread."""
+            return thread.get_ident()
+
+        other_thread_id = yield qtDeferToThread(inner_function)
+        this_thread_id = thread.get_ident()
+        self.assertNotEqual(this_thread_id, other_thread_id)

=== modified file 'ubuntu_sso/utils/webclient/gsettings.py'
--- ubuntu_sso/utils/webclient/gsettings.py	2012-03-07 15:12:39 +0000
+++ ubuntu_sso/utils/webclient/gsettings.py	2012-04-03 12:14:21 +0000
@@ -34,6 +34,11 @@
 def parse_manual_proxy_settings(scheme, gsettings):
     """Parse the settings for a given scheme."""
     host, username, pwd = parse_proxy_host(gsettings[scheme + ".host"])
+    # if the user did not set a proxy for a type (http/https/ftp) we should
+    # return None to ensure that it is not used
+    if host == '':
+        return None
+
     settings = {
         "host": host,
         "port": gsettings[scheme + ".port"],
@@ -76,7 +81,9 @@
     elif mode == "manual":
         settings = {}
         for scheme in ["http", "https"]:
-            settings[scheme] = parse_manual_proxy_settings(scheme, gsettings)
+            scheme_settings = parse_manual_proxy_settings(scheme, gsettings)
+            if scheme_settings is not None:
+                settings[scheme] = scheme_settings
     else:
         # If mode is automatic the PAC javascript should be interpreted
         # on each request. That is out of scope so it's ignored for now

=== modified file 'ubuntu_sso/utils/webclient/qtnetwork.py'
--- ubuntu_sso/utils/webclient/qtnetwork.py	2012-03-23 20:15:44 +0000
+++ ubuntu_sso/utils/webclient/qtnetwork.py	2012-04-03 12:14:21 +0000
@@ -28,6 +28,7 @@
     QNetworkAccessManager,
     QNetworkProxy,
     QNetworkProxyFactory,
+    QNetworkProxyQuery,
     QNetworkReply,
     QNetworkRequest,
     QSslCertificate,
@@ -46,6 +47,7 @@
 from ubuntu_sso.utils.webclient import gsettings
 
 logger = setup_logging("ubuntu_sso.utils.webclient.qtnetwork")
+PROXY_REQUEST = 'https://one.ubuntu.com'
 
 
 def build_proxy(settings_groups):
@@ -102,7 +104,12 @@
             else:
                 logger.info("Proxy is disabled.")
         else:
-            QNetworkProxyFactory.setUseSystemConfiguration(True)
+            if WebClient.proxy_instance is None:
+                logger.info("Querying OS for proxy.")
+                query = QNetworkProxyQuery(QUrl(PROXY_REQUEST))
+                proxies = QNetworkProxyFactory.systemProxyForQuery(query)
+                QNetworkProxy.setApplicationProxy(proxies[0])
+                WebClient.proxy_instance = proxies[0]
 
     def handle_proxy_auth(self, proxy, authenticator):
         """Proxy authentication is required."""

=== modified file 'ubuntu_sso/utils/webclient/tests/test_gsettings.py'
--- ubuntu_sso/utils/webclient/tests/test_gsettings.py	2012-03-09 12:04:31 +0000
+++ ubuntu_sso/utils/webclient/tests/test_gsettings.py	2012-04-03 12:14:21 +0000
@@ -169,6 +169,29 @@
         ps = gsettings.get_proxy_settings()
         self.assertEqual(ps["http"], http_expected)
 
+    def _assert_parser_empty_url(self, scheme):
+        """Assert the parsing of an empty url."""
+        template_values = dict(BASE_GSETTINGS_VALUES)
+        template_values.update({
+            "mode": "manual",
+            scheme + "_host": '',
+            scheme + "_port": 0,
+            "http_use_auth": "false",
+        })
+        fake_output = TEMPLATE_GSETTINGS_OUTPUT.format(**template_values)
+        self.patch(gsettings.subprocess, "check_output",
+                   lambda _: fake_output)
+        ps = gsettings.get_proxy_settings()
+        self.assertNotIn(scheme, ps)
+
+    def test_gsettings_parser_empty_http_url(self):
+        """Test when there is no http proxy set."""
+        self._assert_parser_empty_url('http')
+
+    def test_gsettings_parser_empty_https_url(self):
+        """Test when there is no https proxy set."""
+        self._assert_parser_empty_url('https')
+
 
 class ParseProxyHostTestCase(TestCase):
     """Test the parsing of the domain."""

=== added file 'ubuntu_sso/utils/webclient/tests/test_qtnetwork.py'
--- ubuntu_sso/utils/webclient/tests/test_qtnetwork.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/webclient/tests/test_qtnetwork.py	2012-04-03 12:14:21 +0000
@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT AN WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Specific tests for the qt implementation."""
+
+from twisted.internet import defer
+from ubuntuone.devtools.testcases import TestCase
+
+from ubuntu_sso.utils.webclient import qtnetwork
+
+
+class FakeQNetworkProxy(object):
+    """A fake network proxy class."""
+
+    def __init__(self, called):
+        """Create a new instance."""
+        self.called = called
+
+    def __call__(self, *args, **kwargs):
+        """Fake construnctor."""
+        return self
+
+    # pylint: disable=C0103
+    def setApplicationProxy(self, proxy):
+        """Set the application proxy."""
+        self.called.append(('setApplicationProxy', proxy))
+    # pylint: enable=C0103
+
+
+class FakeNetworkProxyFactory(object):
+    """A fake network proxy factory."""
+
+    def __init__(self, called, proxy):
+        """Create a new instance."""
+        self.called = called
+        self.proxy = proxy
+
+    def __call__(self, *args, **kwargs):
+        """Fake construnctor."""
+        return self
+
+    # pylint: disable=C0103
+    def systemProxyForQuery(self, query):
+        """Get the system proxy."""
+        self.called.append(('systemProxyForQuery', query))
+        return [self.proxy]
+    # pylint: enable=C0103
+
+
+class SetupProxyTestCase(TestCase):
+    """Test the proxy setup."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the different tests."""
+        yield super(SetupProxyTestCase, self).setUp()
+        self.called = []
+        self.proxy = 'fake_proxy'
+
+        self.network_proxy = FakeQNetworkProxy(self.called)
+        self.patch(qtnetwork, 'QNetworkProxy', self.network_proxy)
+
+        self.network_proxy_factory = FakeNetworkProxyFactory(self.called,
+                                                              self.proxy)
+        self.patch(qtnetwork, 'QNetworkProxyFactory',
+                                              self.network_proxy_factory)
+
+        self.settings = dict(https=dict(username='user', password='pasword'))
+        self.patch(qtnetwork.gsettings, 'get_proxy_settings',
+                lambda: self.settings)
+
+        def fake_build_proxy(settings):
+            """Fake build proxy."""
+            self.called.append(('build_proxy', settings))
+            return self.proxy
+
+        self.patch(qtnetwork, 'build_proxy', fake_build_proxy)
+        qtnetwork.WebClient.proxy_instance = None
+        self.addCleanup(self._clean_webclient_instance)
+
+    def _set_old_platform(self, platform):
+        """Set back the platform."""
+        qtnetwork.sys.platform = platform
+
+    def _clean_webclient_instance(self):
+        """Set the webclient not to have a proxy."""
+        qtnetwork.WebClient.proxy_instance = None
+
+
+class SetupLinuxProxyTestCase(SetupProxyTestCase):
+    """Test setting up the proxy."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the different tests."""
+        yield super(SetupLinuxProxyTestCase, self).setUp()
+        old_platform = qtnetwork.sys.platform
+        qtnetwork.sys.platform = 'linux'
+        self.addCleanup(self._set_old_platform, old_platform)
+
+    def test_setup_proxy(self):
+        """Test setting the proxy."""
+        qtnetwork.WebClient()
+        self.assertEqual(self.proxy, qtnetwork.WebClient.proxy_instance)
+        self.assertIn(('setApplicationProxy', self.proxy), self.called)
+        self.assertIn(('build_proxy', self.settings), self.called)
+
+    def test_setup_instance_present(self):
+        """Test when the instanc is present."""
+        # set the instance and assert we did not reset it
+        qtnetwork.WebClient.proxy_instance = 'other_proxy'
+        qtnetwork.WebClient()
+        self.assertNotEqual(self.proxy, qtnetwork.WebClient.proxy_instance)
+        self.assertNotIn(('setApplicationProxy', self.proxy), self.called)
+        self.assertNotIn(('build_proxy', self.settings), self.called)
+
+
+class SetupWindowsProxyTestCase(SetupProxyTestCase):
+    """Test setting up the proxy."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the different tests."""
+        yield super(SetupWindowsProxyTestCase, self).setUp()
+        old_platform = qtnetwork.sys.platform
+        qtnetwork.sys.platform = 'win32'
+        self.addCleanup(self._set_old_platform, old_platform)
+        self.query = 'query'
+
+        self.patch(qtnetwork, 'QNetworkProxyQuery', lambda _: self.query)
+
+    def test_setup_proxy(self):
+        """Test setting the proxy."""
+        qtnetwork.WebClient()
+        self.assertEqual(self.proxy, qtnetwork.WebClient.proxy_instance)
+        self.assertIn(('systemProxyForQuery', self.query), self.called)
+        self.assertIn(('setApplicationProxy', self.proxy), self.called)
+
+    def test_setup_instance_present(self):
+        """Test when the instanc is present."""
+        qtnetwork.WebClient.proxy_instance = 'other_proxy'
+        qtnetwork.WebClient()
+        self.assertNotEqual(self.proxy, qtnetwork.WebClient.proxy_instance)
+        self.assertNotIn(('systemProxyForQuery', self.query), self.called)
+        self.assertNotIn(('setApplicationProxy', self.proxy), self.called)

=== modified file 'ubuntu_sso/utils/windows.py'
--- ubuntu_sso/utils/windows.py	2012-03-16 22:33:29 +0000
+++ ubuntu_sso/utils/windows.py	2012-04-03 12:14:21 +0000
@@ -17,3 +17,46 @@
 """Platform specific constants and functions (for Windows)."""
 
 PLATFORM_QSS = ":/windows.qss"
+
+from twisted.internet import defer
+from PyQt4.QtCore import QThread, QCoreApplication
+
+
+class DeferredThread(QThread):
+    """A thread that runs a given function."""
+
+    def __init__(self, f, *args, **kwargs):
+        """Initialize this thread."""
+        app = QCoreApplication.instance()
+        super(DeferredThread, self).__init__(app)
+        self.deferred = defer.Deferred()
+        self.f = f
+        self.args = args
+        self.kwargs = kwargs
+        self.succeeded = True
+        self.result = None
+        self.finished.connect(self.on_finished)
+
+    def run(self):
+        """This code runs inside the thread."""
+        try:
+            self.result = self.f(*self.args, **self.kwargs)
+        # pylint: disable=W0703
+        except Exception as e:
+            self.succeeded = False
+            self.result = e
+
+    def on_finished(self):
+        """The thread has completed."""
+        if self.succeeded:
+            self.deferred.callback(self.result)
+        else:
+            self.deferred.errback(self.result)
+
+
+# pylint: disable=C0103
+def qtDeferToThread(f, *args, **kwargs):
+    """A Qt-based implementation of deferToThread."""
+    thread = DeferredThread(f, *args, **kwargs)
+    thread.start()
+    return thread.deferred