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

[Natalia Bidart]

[ Diego Sarmentero <email address hidden> ]
  - Converting to unicode some data returned by webclient in
    QByteArray format (LP: #961315).
  - Adding ubuntu_sso.qt.main module to the setup script (LP: #965377).
  - Fixed the backend getting stuck installing the qtreactor before
    the qt process is executed and running the application in the
    twisted process (This fix affects only Windows OS) (LP: #961511).

[ Roberto Alsina <email address hidden> ]
   - Forced white background (LP: #961346).

[ Manuel de la Pena <email address hidden> ]
  - Fixed dialog on window by using show so that the QEventLoop does
    not block the execution of the main loop of the reactor which did
    not allow the deferreds to be fired (LP: #960481).

[Roberto Alsina (ralsina)]

+1

review: Approve

[Manuel de la Peña (mandel)]

review: Approve

=== modified file 'bin/ubuntu-sso-login-qt'
--- bin/ubuntu-sso-login-qt	2012-03-15 20:16:16 +0000
+++ bin/ubuntu-sso-login-qt	2012-03-27 15:37:32 +0000
@@ -21,14 +21,13 @@
 # Access to a protected member, pylint: disable=W0212
 
 import sys
+if sys.platform == 'win32':
+    import qt4reactor
+    qt4reactor.install()
 
 from ubuntu_sso.qt.main import main
 from ubuntu_sso.utils.ui import parse_args
 
-if sys.platform.startswith('linux'):
-    from dbus.mainloop.qt import DBusQtMainLoop
-    DBusQtMainLoop(set_as_default=True)
-
 
 if __name__ == "__main__":
     args = parse_args()

=== modified file 'data/qt/stylesheet.qss'
--- data/qt/stylesheet.qss	2012-03-16 21:24:05 +0000
+++ data/qt/stylesheet.qss	2012-03-27 15:37:32 +0000
@@ -1,5 +1,6 @@
 QWidget {
     color: #333333;
+    background-color: white;
 }
 
 QFrame#ubuntussoframe {

=== modified file 'run-tests'
--- run-tests	2012-03-13 03:10:00 +0000
+++ run-tests	2012-03-27 15:37:32 +0000
@@ -16,7 +16,7 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-QT_TESTS_PATH=ubuntu_sso/qt/tests
+QT_TESTS_PATH="ubuntu_sso/qt/tests, ubuntu_sso/qt/main/tests"
 GTK_TESTS_PATH=ubuntu_sso/gtk/tests
 WINDOWS_TESTS=test_windows.py
 

=== modified file 'setup.py'
--- setup.py	2012-03-21 13:43:30 +0000
+++ setup.py	2012-03-27 15:37:32 +0000
@@ -355,6 +355,7 @@
         'ubuntu_sso.networkstate',
         'ubuntu_sso.networkstate.tests',
         'ubuntu_sso.qt',
+        'ubuntu_sso.qt.main',
         'ubuntu_sso.qt.ui',
         'ubuntu_sso.utils',
         'ubuntu_sso.utils.tests',

=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2012-02-17 18:43:17 +0000
+++ ubuntu_sso/main/tests/test_common.py	2012-03-27 15:37:32 +0000
@@ -118,6 +118,18 @@
         self.assertEqual(result["errtype"], e.__class__.__name__)
         self.assertEqual(result["message"], sample_string)
 
+    def test_first_arg_is_exception(self):
+        """If the first arg is an Exception, use it's message attribute'."""
+
+        class MyException(Exception):
+            """Custom Exception."""
+
+        message = u'My custom error for ♥ Ubuntu'
+        my_exc = MyException(message)
+        result = except_to_errdict(my_exc)
+        self.assertEqual(result["errtype"], my_exc.__class__.__name__)
+        self.assertEqual(result["message"], message)
+
     def test_first_arg_is_unicode(self):
         """If the first arg is a unicode, use it as the message."""
         sample_string = u"a sample string"

=== added directory 'ubuntu_sso/qt/main'
=== renamed file 'ubuntu_sso/qt/main.py' => 'ubuntu_sso/qt/main/__init__.py'
--- ubuntu_sso/qt/main.py	2012-03-19 20:10:32 +0000
+++ ubuntu_sso/qt/main/__init__.py	2012-03-27 15:37:32 +0000
@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-"""Main module to open the GTK UI."""
+"""Main module to open the QT UI."""
 
 import sys
 
@@ -28,12 +28,21 @@
 from ubuntu_sso.utils import PLATFORM_QSS
 
 
+# Invalid name "source", pylint: disable=C0103
+if sys.platform == 'win32':
+    from ubuntu_sso.qt.main import windows
+    source = windows
+else:
+    from ubuntu_sso.qt.main import linux
+    source = linux
+# pylint: enable=C0103
+
+
 def main(**kwargs):
     """Start the QT mainloop and open the main window."""
     app = QtGui.QApplication(sys.argv)
 
-    QtGui.QFontDatabase.addApplicationFont(':/Ubuntu-R.ttf')
-    QtGui.QFontDatabase.addApplicationFont(':/Ubuntu-B.ttf')
+    source.main(app)
 
     data = []
     for qss_name in (PLATFORM_QSS, ":/stylesheet.qss"):
@@ -48,10 +57,12 @@
             kwargs[key] = value.decode('utf-8')
 
     # Unused variable 'ui', pylint: disable=W0612
-    ui = UbuntuSSOClientGUI(close_callback=app.exit, **kwargs)
+    close_callback = lambda: source.main_quit(app)
+    ui = UbuntuSSOClientGUI(close_callback=close_callback, **kwargs)
     style = QtGui.QStyle.alignedRect(
                     QtCore.Qt.LeftToRight, QtCore.Qt.AlignCenter,
                     ui.size(), app.desktop().availableGeometry())
     ui.setGeometry(style)
     ui.show()
-    app.exec_()
+
+    source.main_start(app)

=== added file 'ubuntu_sso/qt/main/linux.py'
--- ubuntu_sso/qt/main/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/main/linux.py	2012-03-27 15:37:32 +0000
@@ -0,0 +1,35 @@
+# -*- 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/>.
+
+"""Main method to be used on linux."""
+
+
+def main(app):
+    """Apply style sheet."""
+    from dbus.mainloop.qt import DBusQtMainLoop
+    DBusQtMainLoop(set_as_default=True)
+
+
+def main_start(app):
+    """Start the mainloop."""
+    app.exec_()
+
+
+def main_quit(app):
+    """Stop the mainloop."""
+    app.exit()
+
+PLATFORM_QSS = ":/linux.qss"

=== added directory 'ubuntu_sso/qt/main/tests'
=== added file 'ubuntu_sso/qt/main/tests/__init__.py'
--- ubuntu_sso/qt/main/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/main/tests/__init__.py	2012-03-27 15:37:32 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+
+"""The test suite for the Qt UI for SSO."""

=== renamed file 'ubuntu_sso/qt/tests/test_main.py' => 'ubuntu_sso/qt/main/tests/test_main.py'
--- ubuntu_sso/qt/tests/test_main.py	2012-03-19 20:17:49 +0000
+++ ubuntu_sso/qt/main/tests/test_main.py	2012-03-27 15:37:32 +0000
@@ -91,13 +91,22 @@
     def setUp(self):
         yield super(BasicTestCase, self).setUp()
         self.called = []
+        self._close_callback = None
+        self._app = None
 
-        def called_ui(**kw):
+        def called_ui(method, *args, **kw):
             """record ui call."""
-            self.called.append(('GUI', kw))
+            if 'close_callback' in kw:
+                self._close_callback = kw.pop('close_callback')
+            self.called.append((method, args, kw))
             return FakeUi()
 
-        self.patch(main, 'UbuntuSSOClientGUI', called_ui)
+        self.patch(main, 'UbuntuSSOClientGUI',
+            lambda *arg, **kw: called_ui('GUI', *arg, **kw))
+        self.patch(main.source, 'main',
+            lambda *arg, **kw: called_ui('main', *arg, **kw))
+        self.patch(main.source, 'main_start',
+            lambda *arg, **kw: called_ui('main_start', *arg, **kw))
         self.patch(main.QtGui, 'QApplication', FakeApplication)
 
     def test_main(self):
@@ -106,8 +115,30 @@
             baz='yadda', yadda=0)
         main.main(**kwargs)
 
-        kwargs['close_callback'] = main.QtGui.QApplication.instance().exit
-        self.assertEqual(self.called, [('GUI', kwargs)])
+        expected = [('main', (FakeApplication.instance(),), {}),
+            ('GUI', (), kwargs),
+            ('main_start', (FakeApplication.instance(),), {})]
+        self.assertEqual(self.called, expected)
+
+    def test_check_close_callback(self):
+        """Check that the close callback is main_quit."""
+
+        def called_quit(app):
+            """Record the call to quit."""
+            self._app = app
+
+        self.patch(main.source, 'main_quit', called_quit)
+
+        kwargs = dict(app_name='APP_NAME', foo='foo', bar='bar',
+            baz='yadda', yadda=0)
+        main.main(**kwargs)
+
+        expected = [('main', (FakeApplication.instance(),), {}),
+            ('GUI', (), kwargs),
+            ('main_start', (FakeApplication.instance(),), {})]
+        self._close_callback()
+        self.assertEqual(self.called, expected)
+        self.assertEqual(self._app, FakeApplication.instance())
 
     def test_main_args(self):
         """Calling main.main() a UI instance is created."""
@@ -119,11 +150,12 @@
             baz=arg_list[3].encode('utf-8'))
         main.main(**kwargs)
 
-        kwargs['close_callback'] = main.QtGui.QApplication.instance().exit
-        expected = dict(app_name=arg_list[0], foo=arg_list[1],
-            bar=arg_list[2], baz=arg_list[3],
-            close_callback=main.QtGui.QApplication.instance().exit)
-        self.assertEqual(self.called, [('GUI', expected)])
+        args_unicode = dict(app_name=arg_list[0], foo=arg_list[1],
+            bar=arg_list[2], baz=arg_list[3])
+        expected = [('main', (FakeApplication.instance(),), {}),
+            ('GUI', (), args_unicode),
+            ('main_start', (FakeApplication.instance(),), {})]
+        self.assertEqual(self.called, expected)
 
     def test_styles_load(self):
         """Test that all stylesheets load."""

=== added file 'ubuntu_sso/qt/main/windows.py'
--- ubuntu_sso/qt/main/windows.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/qt/main/windows.py	2012-03-27 15:37:32 +0000
@@ -0,0 +1,46 @@
+# -*- 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/>.
+
+"""Main method to be used on windows."""
+
+from PyQt4 import QtGui
+
+
+def main(app):
+    """Apply style sheet and fonts."""
+    # Apply font to the entire application
+    QtGui.QFontDatabase.addApplicationFont(':/Ubuntu-R.ttf')
+    QtGui.QFontDatabase.addApplicationFont(':/Ubuntu-B.ttf')
+
+
+# Module 'reactor' has no 'run'/'stop' member, pylint: disable=E1101
+
+
+def main_start(app):
+    """Start the mainloop."""
+    from twisted.internet import reactor
+    reactor.run()
+
+
+def main_quit(app):
+    """Stop the mainloop."""
+    from twisted.internet import reactor
+    reactor.stop()
+
+
+# pylint: enable=E1101
+
+PLATFORM_QSS = ":/windows.qss"

=== modified file 'ubuntu_sso/qt/proxy_dialog.py'
--- ubuntu_sso/qt/proxy_dialog.py	2012-03-08 12:35:25 +0000
+++ ubuntu_sso/qt/proxy_dialog.py	2012-03-27 15:37:32 +0000
@@ -106,6 +106,7 @@
         except Exception, e:
             logger.exception('Could not set credentials:')
             self.done(EXCEPTION_RAISED)
+        logger.debug('Stored creds')
         # pylint: disable=W0703, W0612
         self.done(USER_SUCCESS)
 
@@ -140,13 +141,41 @@
     return parser.parse_args()
 
 
+def exit_code(return_code):
+    """Use the window result code and the sys.exit."""
+    logger.debug('exit %s', return_code)
+    QApplication.instance().exit(return_code)
+    if sys.platform == 'win32':
+        logger.debug('Stop qt reactor')
+        from twisted.internet import reactor
+        reactor.stop()
+
+
 def main():
     """Main method used to show the creds dialog."""
     # Keep ref to avoid core dump, pylint: disable=W0612
+
+    if sys.platform == 'win32':
+        import qt4reactor
+        qt4reactor.install()
+        logger.debug('Qt reactor installed.')
+
     app = QApplication(sys.argv)
     # pylint: enable=W0612
     args = parse_args()
     win = ProxyCredsDialog(domain=args.domain,
                            retry=args.retry)
-    return_code = win.exec_()
-    sys.exit(return_code)
+
+    if sys.platform == 'win32':
+        win.show()
+        win.finished.connect(exit_code)
+
+        logger.debug('Starting reactor')
+        # pylint: disable=E1101
+        from twisted.internet import reactor
+        logger.debug('QApp is %s', reactor.qApp)
+        reactor.run()
+        # pylint: enable=E1101
+    else:
+        return_code = win.exec_()
+        sys.exit(return_code)

=== modified file 'ubuntu_sso/qt/tests/test_proxy_dialog.py'
--- ubuntu_sso/qt/tests/test_proxy_dialog.py	2012-03-07 18:13:04 +0000
+++ ubuntu_sso/qt/tests/test_proxy_dialog.py	2012-03-27 15:37:32 +0000
@@ -15,7 +15,10 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Test the proxy UI."""
 
-from twisted.internet import defer
+import qt4reactor
+
+from PyQt4.QtCore import QObject, pyqtSignal
+from twisted.internet import defer, reactor
 from twisted.trial.unittest import TestCase
 
 from ubuntu_sso.qt import proxy_dialog
@@ -301,6 +304,62 @@
         self.retry = retry
 
 
+class FakeCredsDialog(QObject):
+    """A fake dialog."""
+
+    finished = pyqtSignal(int)
+
+    def __init__(self, called, code):
+        """Create a new instance."""
+        super(FakeCredsDialog, self).__init__()
+        self.domain = None
+        self.retry = None
+        self.called = called
+        self.return_code = code
+
+    def __call__(self, domain, retry):
+        """Fake init."""
+        self.domain = domain
+        self.retry = retry
+        return self
+
+    def show(self):
+        """Show the dialog."""
+        self.called.append(('show',))
+
+    def exec_(self):
+        """Show the dialog."""
+        self.called.append(('exec_',))
+        return self.return_code
+
+
+class FakeQApplication(object):
+    """A fake QApplication."""
+
+    test_instance = None
+
+    def __init__(self, called):
+        """Create a new instance."""
+        self.called = called
+        self.args = None
+        self.code = None
+        FakeQApplication.test_instance = self
+
+    def __call__(self, args):
+        """Fake construntor."""
+        self.args = args
+
+    @classmethod
+    def instance(cls):
+        """Return the instance."""
+        return FakeQApplication.test_instance
+
+    def exit(self, code):
+        """Exit the app."""
+        self.called.append(('exit', code))
+        self.code = code
+
+
 class MainTest(TestCase):
     """Test the main method."""
 
@@ -310,29 +369,91 @@
         yield super(MainTest, self).setUp()
         self.called = []
 
+        self.return_code = 0
+        self.dialog = FakeCredsDialog(self.called, self.return_code)
+        self.patch(proxy_dialog, 'ProxyCredsDialog', self.dialog)
+
         self.args = FakeArgs(domain='domain', retry=False)
         self.patch(proxy_dialog, 'parse_args', lambda: self.args)
 
-        self.return_code = 0
-        self.patch(proxy_dialog.ProxyCredsDialog, 'exec_', lambda x:
-                self.return_code)
         self.exit_code = None
 
+        self.app = FakeQApplication(self.called)
+
+        self.patch(proxy_dialog, 'QApplication', self.app)
+
+    def _set_old_platform(self, platform):
+        """Set back the platform."""
+        proxy_dialog.sys.platform = platform
+
+    def _assert_basic_start(self):
+        """Assert the common code is actually ran."""
+        self.assertEqual(self.args.domain, self.dialog.domain)
+        self.assertEqual(self.args.retry, self.dialog.retry)
+
+    def test_linux_main(self):
+        """Test the main method on linux."""
+        old_platform = proxy_dialog.sys.platform
+        proxy_dialog.sys.platform = 'linux'
+        self.addCleanup(self._set_old_platform, old_platform)
+
         def fake_exit(code):
-            """Fake the sys.exit."""
+            """Fake sys exit."""
             self.called.append(('exit', code))
-            self.exit_code = code
 
         self.patch(proxy_dialog.sys, 'exit', fake_exit)
 
-        def fake_application(args):
-            """Fake a QApplication."""
-            self.called.append(('QApplication', args))
-
-        self.patch(proxy_dialog, 'QApplication', fake_application)
-
-    def test_main(self):
-        """Test the main method."""
-        proxy_dialog.main()
-        self.assertIn('QApplication', self.called[0])
+        proxy_dialog.main()
+
+        self._assert_basic_start()
+        self.assertIn(('exec_',), self.called)
+        self.assertIn(('exit', self.return_code), self.called)
+
+    def test_windows_main(self):
+        """Test the main method on windows."""
+        old_platform = proxy_dialog.sys.platform
+        proxy_dialog.sys.platform = 'win32'
+        self.addCleanup(self._set_old_platform, old_platform)
+
+        def fake_install():
+            """Fake the reactor installation."""
+            self.called.append(('install',))
+
+        self.patch(qt4reactor, 'install', fake_install)
+
+        def fake_start():
+            """Fake reactor.start."""
+            self.called.append(('run',))
+
+        self.patch(reactor, 'run', fake_start)
+
+        def fake_exit(code):
+            """Fake the exit method."""
+            self.called.append(('exit_code', code))
+
+        self.patch(proxy_dialog, 'exit_code', fake_exit)
+
+        proxy_dialog.main()
+
+        self._assert_basic_start()
+        self.assertIn(('show',), self.called)
+        self.assertIn(('run',), self.called)
+
+        self.dialog.finished.emit(self.return_code)
+        self.assertIn(('exit_code', self.return_code), self.called)
+
+    def test_exit_code_windows(self):
+        """"Test the exit code function."""
+        old_platform = proxy_dialog.sys.platform
+        proxy_dialog.sys.platform = 'win32'
+        self.addCleanup(self._set_old_platform, old_platform)
+
+        def fake_stop():
+            """Fake reactor.start."""
+            self.called.append(('stop',))
+
+        self.patch(reactor, 'stop', fake_stop)
+
+        proxy_dialog.exit_code(self.return_code)
+        self.assertIn(('stop',), self.called)
         self.assertIn(('exit', self.return_code), self.called)

=== modified file 'ubuntu_sso/utils/webclient/qtnetwork.py'
--- ubuntu_sso/utils/webclient/qtnetwork.py	2012-03-19 23:53:06 +0000
+++ ubuntu_sso/utils/webclient/qtnetwork.py	2012-03-27 15:37:32 +0000
@@ -188,7 +188,8 @@
             response = Response(bytes(content), headers)
             d.callback(response)
         else:
-            error_string = reply.errorString()
+            content = unicode(content)
+            error_string = unicode(reply.errorString())
             logger.debug('_handle_finished error (%s,%s).', error,
                          error_string)
             if error == QNetworkReply.AuthenticationRequiredError:

=== modified file 'ubuntu_sso/utils/webclient/tests/test_webclient.py'
--- ubuntu_sso/utils/webclient/tests/test_webclient.py	2012-03-19 23:43:56 +0000
+++ ubuntu_sso/utils/webclient/tests/test_webclient.py	2012-03-27 15:37:32 +0000
@@ -373,6 +373,14 @@
         self.assertTrue(isinstance(result.content, bytes),
                         "The type of %r must be bytes" % result.content)
 
+    @defer.inlineCallbacks
+    def test_webclienterror_not_string(self):
+        """The returned exception contains unicode data."""
+        deferred = self.wc.request(self.base_iri + THROWERROR)
+        failure = yield self.assertFailure(deferred, webclient.WebClientError)
+        for error in failure.args:
+            self.assertTrue(isinstance(error, basestring))
+
 
 class FakeSavingReactor(object):
     """A fake reactor that saves connection attempts."""