Merge lp:~nataliabidart/ubuntuone-windows-installer/stable-3-0-update-2.99.3 into lp:ubuntuone-windows-installer/stable-3-0

[Natalia Bidart]

[ Diego Sarmentero <email address hidden> ]
  - Added the missing page: No network detected (LP: #804610).
  - Update setup.py script to create the bundle.

[lp:~nataliabidart/ubuntuone-windows-installer/stable-3-0-update-2.99.3]

98. By Natalia Bidart on 2012-02-01

Attaching bug number.

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'scripts/setup.py'
--- scripts/setup.py	2012-01-09 14:36:13 +0000
+++ scripts/setup.py	2012-02-01 19:46:19 +0000
@@ -207,13 +207,14 @@
 
         # Build UI files, copy packages.
         dest_dir = os.path.join(
-            "..", "..", "installed", "Lib", "site-packages", "ubuntu_sso")
+            "..", "..", "installed", "Lib", "site-packages")
+        dest_sso = os.path.join(dest_dir, "ubuntu_sso")
         start_dir = os.getcwd()
         os.chdir(os.path.join("sources", "ubuntu-sso-client"))
         os.system("python setup.py build")
         os.system("python setup.py install --prefix=%s" %
             os.path.join("..", "..", "installed"))
-        shutil.copytree("ubuntu_sso", dest_dir)
+        shutil.copytree("ubuntu_sso", dest_sso)
         sso_revno = subprocess.Popen(
             ["bzr", "revno", "."],
             stdout=subprocess.PIPE).communicate()[0]
@@ -222,7 +223,8 @@
         os.chdir(os.path.join("sources", "ubuntuone-client"))
         shutil.copy(os.path.join("windows", "clientdefs.py"),
             os.path.join("ubuntuone", "clientdefs.py"))
-        shutil.copytree("ubuntuone", dest_dir)
+        dest_client = os.path.join(dest_dir, "ubuntuone")
+        shutil.copytree("ubuntuone", dest_client)
         u1client_revno = subprocess.Popen(
             ["bzr", "revno", "."],
             stdout=subprocess.PIPE).communicate()[0]
@@ -231,8 +233,9 @@
         os.chdir(os.path.join("sources", "ubuntuone-control-panel"))
         os.system("python setup.py build")
         # Copying by hand because the install is borked
+        dest_cp = os.path.join(dest_dir, "ubuntuone", "controlpanel")
         shutil.copytree(os.path.join("ubuntuone", "controlpanel"),
-            dest_dir)
+            dest_cp)
         u1cp_revno = subprocess.Popen(
             ["bzr", "revno", "."],
             stdout=subprocess.PIPE).communicate()[0]
@@ -241,7 +244,8 @@
         os.chdir(os.path.join("sources", "ubuntuone-windows-installer"))
         os.system("python setup.py build")
         # Copying by hand because the install is borked
-        shutil.copytree("ubuntuone_installer", dest_dir)
+        dest_installer = os.path.join(dest_dir, "ubuntuone_installer")
+        shutil.copytree("ubuntuone_installer", dest_installer)
         u1inst_revno = subprocess.Popen(
             ["bzr", "revno", "."],
             stdout=subprocess.PIPE).communicate()[0]
@@ -346,9 +350,9 @@
                     'configglue',
                     'configglue.app',
                     'configglue.inischema',
-                    'configglue.pyschema.glue',
                     'configglue.inischema.glue',
                     'configglue.inischema.parsers',
+                    'comtypes',
                     ],
                 'excludes': ['fsm'],
                 "dll_excludes": [

=== modified file 'ubuntuone_installer/gui/qt/gui.py'
--- ubuntuone_installer/gui/qt/gui.py	2012-01-09 21:50:40 +0000
+++ ubuntuone_installer/gui/qt/gui.py	2012-02-01 19:46:19 +0000
@@ -18,8 +18,10 @@
 
 import gettext
 
+from twisted.internet import defer
 from PyQt4 import QtGui, QtCore
 
+from ubuntu_sso import networkstate
 from ubuntu_sso.qt.gui import (
     SSOWizardPage,
     EmailVerificationPage,
@@ -74,6 +76,7 @@
 from ubuntuone_installer.gui.qt.folders import FoldersPage
 from ubuntuone_installer.gui.qt.forgotten import ForgottenPasswordController
 from ubuntuone_installer.gui.qt.local_folders import LocalFoldersPage
+from ubuntuone_installer.gui.qt.network_detection import NetworkDetectionPage
 from ubuntuone_installer.gui.qt.preferences import PreferencesPage
 from ubuntuone_installer.gui.qt.sync_now_or_later import SyncNowOrLaterPage
 from ubuntuone_installer.gui.qt.setup_account import SetupAccountPage
@@ -151,7 +154,6 @@
     """Wizard Page that displays the license info and links to the GPL."""
 
     def __init__(self, parent=None):
-        self._next_id = None
         super(LicensePage, self).__init__(license_ui.Ui_Form(), None, parent)
         self.header.setVisible(False)
         self.ui.textBrowser.setHtml(qt.LICENSE_CONTENT)
@@ -163,7 +165,7 @@
     def initializePage(self):
         """Setup UI details."""
         # Set the right texts and connections for buttons
-        self.setButtonText(QtGui.QWizard.NextButton, _("Agree && continue"))
+        self.setButtonText(QtGui.QWizard.CustomButton1, _("Agree && continue"))
         self.setButtonText(QtGui.QWizard.CancelButton,
             _("Disagree && uninstall"))
 
@@ -179,19 +181,30 @@
             QtGui.QWizard.CancelButton,
             QtGui.QWizard.BackButton,
             QtGui.QWizard.Stretch,
-            QtGui.QWizard.NextButton,
-            QtGui.QWizard.FinishButton])
+            QtGui.QWizard.CustomButton1])
 
-        self.agree_button = self.wizard().button(QtGui.QWizard.NextButton)
+        self.agree_button = self.wizard().button(QtGui.QWizard.CustomButton1)
         self.agree_button.setDefault(True)
         self.agree_button.style().unpolish(self.agree_button)
         self.agree_button.style().polish(self.agree_button)
+        self.wizard().customButtonClicked.connect(self.check_connection)
+
+    # pylint: disable=W0212
+    @defer.inlineCallbacks
+    def check_connection(self, button_id):
+        """Decide next ID based on network detection."""
+        if button_id == QtGui.QWizard.CustomButton1:
+            connected = yield self.wizard().check_connection()
+            if connected:
+                self.next = self.wizard().SIGN_IN_PAGE_ID
+            else:
+                self.next = self.wizard()._next_id
+            self.wizard().next()
+    # pylint: enable=W0212
 
     def nextId(self):
-        """Return next page's ID."""
-        if self._next_id is None:
-            return self.wizard().SIGNIN_PAGE
-        return self._next_id
+        """Return the next page ID."""
+        return self.next
 
 
 class SignInPage(SSOWizardPage):
@@ -394,6 +407,7 @@
         # pylint: disable=C0103
         self.license_page = LicensePage()
         self.LICENSE_PAGE = self.addPage(self.license_page)
+        self.network_page = NetworkDetectionPage()
 
         #SSO Pages
         title_page = TITLE_STYLE % SIGN_IN
@@ -450,7 +464,8 @@
         self.reset_password.ui.reset_password_button.clicked.connect(
             self.overlay.show)
 
-        self.SIGNIN_PAGE = self.addPage(self.sign_in_page)
+        self.SIGN_IN_PAGE_ID = self.addPage(self.sign_in_page)
+        self.NETWORK_DETECTION_PAGE_ID = self.addPage(self.network_page)
         self.setup_account_page_id = self.addPage(self.setup_account)
         self.email_verification_page_id = self.addPage(self.email_verification)
         self.current_user_page_id = self.addPage(self.current_user)
@@ -478,15 +493,23 @@
         # Set Wizard buttons style
         self.button(QtGui.QWizard.NextButton).setDefault(True)
 
+        self.set_start_page(installing)
+
+    # Invalid name "closeEvent"
+    # pylint: disable=C0103
+
+    @defer.inlineCallbacks
+    def set_start_page(self, installing):
+        """Set the Wizard start page based in some conditions."""
+        connected = yield self.check_connection()
         if installing:
             self.setStartId(self.LICENSE_PAGE)
-        else:
+        elif connected:
             self.setStartId(self.SIGNIN_PAGE)
+        else:
+            self.setStartId(self._next_id)
         self.restart()
 
-    # Invalid name "closeEvent"
-    # pylint: disable=C0103
-
     def critical(self, message, page=None):
         """Show a message at the bottom of the page on form errors."""
         self.overlay.hide()
@@ -513,6 +536,16 @@
         else:
             return QtGui.QWizard.nextId(self)
 
+    @defer.inlineCallbacks
+    def check_connection(self):
+        """Return is machine is connected, False set Network Page as next."""
+        # pylint: disable=W0703
+        connected = yield networkstate.is_machine_connected()
+        if not connected:
+            self._next_id = self.NETWORK_DETECTION_PAGE_ID
+        defer.returnValue(connected)
+        # pylint: enable=W0703
+
     def login_success_slot(self):
         """Called on successful login."""
         self._next_id = self.SUCCESS_PAGE

=== added file 'ubuntuone_installer/gui/qt/network_detection.py'
--- ubuntuone_installer/gui/qt/network_detection.py	1970-01-01 00:00:00 +0000
+++ ubuntuone_installer/gui/qt/network_detection.py	2012-02-01 19:46:19 +0000
@@ -0,0 +1,76 @@
+# -*- 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 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/>.
+
+"""Widget to show if we don't detect a network connection."""
+
+import gettext
+
+from twisted.internet import defer
+from PyQt4 import QtGui
+
+from ubuntu_sso import networkstate
+
+from ubuntuone_installer.gui.qt.ui import network_detection_ui
+
+_ = gettext.gettext
+
+
+class NetworkDetectionPage(QtGui.QWizardPage):
+
+    """Widget to show if we don't detect a network connection."""
+
+    def __init__(self, parent=None):
+        super(NetworkDetectionPage, self).__init__(parent)
+        self.setTitle(_("Installing Ubuntu One"))
+        self.ui = network_detection_ui.Ui_Form()
+        self.ui.setupUi(self)
+        self.btn_try_again = None
+
+    # pylint: disable=C0103
+    def initializePage(self):
+        """Set UI details."""
+        self.wizard()._next_id = None
+
+        self.setButtonText(QtGui.QWizard.CustomButton1, _("Try again"))
+        self.setButtonText(QtGui.QWizard.CancelButton,
+            _("Close window and set up later"))
+        self.wizard().setButtonLayout([
+            QtGui.QWizard.Stretch,
+            QtGui.QWizard.CustomButton1,
+            QtGui.QWizard.CancelButton,
+            ])
+
+        try:
+            self.wizard().customButtonClicked.disconnect()
+        except TypeError:
+            pass
+
+        self.btn_try_again = self.wizard().button(QtGui.QWizard.CustomButton1)
+        self.btn_try_again.setDefault(True)
+        self.btn_try_again.style().unpolish(self.btn_try_again)
+        self.btn_try_again.style().polish(self.btn_try_again)
+        self.wizard().customButtonClicked.connect(self.try_again)
+    # pylint: enable=C0103
+
+    @defer.inlineCallbacks
+    def try_again(self, button_id=QtGui.QWizard.CustomButton1):
+        """Test the connection again."""
+        if button_id == QtGui.QWizard.CustomButton1:
+            d = yield networkstate.is_machine_connected()
+            if d:
+                self.wizard()._next_id = self.wizard().SIGN_IN_PAGE_ID
+                self.wizard().next()
+                self.wizard()._next_id = None

=== modified file 'ubuntuone_installer/gui/qt/tests/__init__.py'
--- ubuntuone_installer/gui/qt/tests/__init__.py	2012-01-03 15:00:57 +0000
+++ ubuntuone_installer/gui/qt/tests/__init__.py	2012-02-01 19:46:19 +0000
@@ -156,6 +156,7 @@
         self.overlay = FakeOverlay()
         self.called = []
         self.buttons = {}
+        self._next_id = -1
 
     # Invalid name "setButtonLayout", "setOption"
     # pylint: disable=C0103
@@ -177,11 +178,16 @@
 
 class FakeWizardButtonStyle(FakeWizard):
 
+    """Fake Wizard with button style implementation."""
+
+    SIGN_IN_PAGE_ID = 1
+
+    # pylint: disable=C0103
     def __init__(self):
         super(FakeWizardButtonStyle, self).__init__()
         self.data = {}
+        self.customButtonClicked = self
 
-    # pylint: disable=C0103
     def setDefault(self, value):
         """Fake setDefault for button."""
         self.data['default'] = value
@@ -191,6 +197,14 @@
         return self.data['default']
     # pylint: enable=C0103
 
+    def connect(self, func):
+        """Fake customButtonClicked connect."""
+        self.data['connect'] = func
+
+    def disconnect(self, func):
+        """Fake customButtonClicked disconnect."""
+        self.data['disconnect'] = func
+
     def button(self, button_id):
         """Fake the functionality of button on QWizard class."""
         return self
@@ -207,6 +221,10 @@
         """Fake unpolish."""
         self.data['unpolish'] = button
 
+    def next(self):
+        """Fake next for wizard."""
+        self.data['next'] = True
+
 
 class FakeWizardPage(object):
 

=== modified file 'ubuntuone_installer/gui/qt/tests/test_gui.py'
--- ubuntuone_installer/gui/qt/tests/test_gui.py	2012-01-03 15:00:57 +0000
+++ ubuntuone_installer/gui/qt/tests/test_gui.py	2012-02-01 19:46:19 +0000
@@ -129,10 +129,21 @@
         self.patch(qt.folders, "FoldersPanel", FakeFoldersPanel)
         self.patch(gui.qt.utils, "add_syncdaemon_to_autostart", NO_OP)
         self.patch(gui.backend, "ControlBackend", FakeBackend)
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(True))
         yield super(MainWindowTestCase, self).setUp()
         setup_page = self.ui.page(self.ui.setup_account_page_id)
         setup_page.initializePage()
 
+    def test_check_network_id(self):
+        """Check that the Network Detect page is not the first one."""
+        win = gui.MainWindow()
+        # Check that NETWORK_DETECTION_PAGE_ID is greater than 1,
+        # this means that is not the first or second page, which should be
+        # LICENSE and SIGN_IN.
+        # (SIGN_IN will be the first running without --install)
+        self.assertTrue(win.NETWORK_DETECTION_PAGE_ID > 1)
+
     # pylint: disable=E1101
     def test_setup_account_controller_params(self):
         """Test with SetupAccountController params."""
@@ -141,6 +152,93 @@
         self.assertEqual(val, win)
         self.assertEqual(win.setup_controller.args[0], ())
 
+    def test_network_detection_connection_enabled(self):
+        """Test the flow of the pages without connection."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(True))
+        license_page = self.ui.page(self.ui.LICENSE_PAGE)
+        self.ui.setStartId(self.ui.LICENSE_PAGE)
+        self.ui.restart()
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        license_page.check_connection(QtGui.QWizard.CustomButton1)
+        page_id = license_page.next
+        self.assertEqual(page_id, self.ui.SIGN_IN_PAGE_ID)
+
+    def test_network_detection_connection_disabled(self):
+        """Test the flow of the pages with connection."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(False))
+        license_page = self.ui.page(self.ui.LICENSE_PAGE)
+        self.ui.setStartId(self.ui.LICENSE_PAGE)
+        self.ui.restart()
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        license_page.check_connection(QtGui.QWizard.CustomButton1)
+        page_id = license_page.next
+        self.assertEqual(page_id, self.ui.NETWORK_DETECTION_PAGE_ID)
+
+    def test_license_page_check_connection_no_button(self):
+        """Check the state of next when another button is pressed."""
+        license_page = self.ui.page(self.ui.LICENSE_PAGE)
+        self.ui.setStartId(self.ui.LICENSE_PAGE)
+        self.ui.restart()
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        license_page.next = -1
+        license_page.check_connection(QtGui.QWizard.NextButton)
+        page_id = license_page.next
+        self.assertEqual(page_id, -1)
+
+    def test_network_detection_retry_fail(self):
+        """Test the flow of the pages when the retry button is pressed."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(False))
+        network_page = self.ui.page(self.ui.NETWORK_DETECTION_PAGE_ID)
+        self.ui.setStartId(self.ui.NETWORK_DETECTION_PAGE_ID)
+        self.ui.restart()
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        network_page.try_again()
+        self.assertEqual(self.ui.currentId(),
+            self.ui.NETWORK_DETECTION_PAGE_ID)
+
+    # pylint: disable=W0212
+    @defer.inlineCallbacks
+    def test_check_connection_with_connection(self):
+        """Test the check_connection function with connection = True."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(True))
+        self.ui._next_id = -1
+        connected = yield self.ui.check_connection()
+        self.assertNotEqual(self.ui._next_id,
+            self.ui.NETWORK_DETECTION_PAGE_ID)
+        self.assertTrue(connected)
+
+    @defer.inlineCallbacks
+    def test_check_connection_with_no_connection(self):
+        """Test the check_connection function with connection = False."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(False))
+        connected = yield self.ui.check_connection()
+        self.assertEqual(self.ui._next_id, self.ui.NETWORK_DETECTION_PAGE_ID)
+        self.assertFalse(connected)
+        self.assertFalse(False)
+    # pylint: enable=W0212
+
+    def test_network_detection_retry_works(self):
+        """Test the flow of the pages when the retry button is pressed."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(True))
+        network_page = self.ui.page(self.ui.NETWORK_DETECTION_PAGE_ID)
+        self.ui.setStartId(self.ui.NETWORK_DETECTION_PAGE_ID)
+        self.ui.restart()
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        network_page.try_again()
+        self.assertNotEqual(self.ui.currentId(),
+            self.ui.NETWORK_DETECTION_PAGE_ID)
+
     def test_current_user_controller_params(self):
         """Test with CurrentUserController params."""
         win = gui.MainWindow()
@@ -183,11 +281,20 @@
             unicode(self.ui.sign_in_page.ui.message_label.text()),
             u"")
 
-    def test_without_flag(self):
+    def test_without_flag_connected(self):
         """test with flag activated."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(True))
         win = gui.MainWindow()
         self.assertEqual(win.startId(), win.SIGNIN_PAGE)
 
+    def test_without_flag_disconnected(self):
+        """test with flag activated."""
+        self.patch(gui.networkstate, "is_machine_connected",
+            lambda: defer.succeed(False))
+        win = gui.MainWindow()
+        self.assertEqual(win.startId(), win.NETWORK_DETECTION_PAGE_ID)
+
     def test_initialize_page(self):
         """Check the initializePage to ensure proper widgets visibility."""
         setup_page = self.ui.page(self.ui.setup_account_page_id)

=== added file 'ubuntuone_installer/gui/qt/tests/test_network_detection.py'
--- ubuntuone_installer/gui/qt/tests/test_network_detection.py	1970-01-01 00:00:00 +0000
+++ ubuntuone_installer/gui/qt/tests/test_network_detection.py	2012-02-01 19:46:19 +0000
@@ -0,0 +1,95 @@
+# -*- 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 Network Detection UI."""
+
+from twisted.internet import defer
+
+from PyQt4 import QtGui
+
+from ubuntuone_installer.gui.qt import network_detection
+from ubuntuone_installer.gui.qt.tests import (
+    BaseTestCase,
+    FakeWizardButtonStyle,
+)
+
+
+class NetworkDetectionTestCase(BaseTestCase):
+
+    """Test the CurrentUserController."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize this test instance."""
+        yield super(NetworkDetectionTestCase, self).setUp()
+        self.wizard = FakeWizardButtonStyle()
+        self.network_detection_page = network_detection.NetworkDetectionPage()
+        self.patch(self.network_detection_page, 'wizard', self._get_wizard)
+
+    def _get_wizard(self):
+        """Fake wizard method for wizard page."""
+        return self.wizard
+
+    # pylint: disable=W0212
+    def test_initialize_page(self):
+        """Check Network detection initialize page."""
+        self.network_detection_page.initializePage()
+        self.assertEqual(self.wizard._next_id, None)
+        self.assertTrue(('setButtonLayout', ([
+            QtGui.QWizard.Stretch,
+            QtGui.QWizard.CustomButton1,
+            QtGui.QWizard.CancelButton], {})),
+            self.wizard.called)
+
+    def test_initialize_page_button_property(self):
+        """Test the Try Again button properties."""
+        self.patch(self.network_detection_page,
+            "wizard", FakeWizardButtonStyle)
+        self.network_detection_page.initializePage()
+        self.assertTrue(self.network_detection_page.btn_try_again.isDefault())
+        self.assertTrue(
+            'polish' in self.network_detection_page.btn_try_again.data)
+        self.assertTrue(
+            'unpolish' in self.network_detection_page.btn_try_again.data)
+        self.assertEqual(
+            self.network_detection_page.btn_try_again.data['polish'],
+            self.network_detection_page.btn_try_again)
+        self.assertEqual(
+            self.network_detection_page.btn_try_again.data['unpolish'],
+            self.network_detection_page.btn_try_again)
+
+    def test_try_again_with_connection(self):
+        """Check try again method with connection."""
+        self.patch(network_detection.networkstate, 'is_machine_connected',
+            lambda: True)
+        self.wizard._next_id = -1
+        if 'next' in self.wizard.data:
+            self.wizard.data.pop('next')
+        self.network_detection_page.try_again()
+        self.assertEqual(self.wizard._next_id, None)
+        self.assertTrue(self.wizard.data.get('next', False))
+
+    def test_try_again_without_connection(self):
+        """Check try again method without connection."""
+        self.patch(network_detection.networkstate, 'is_machine_connected',
+            lambda: False)
+        self.wizard._next_id = -1
+        if 'next' in self.wizard.data:
+            self.wizard.data.pop('next')
+        self.network_detection_page.try_again()
+        self.assertEqual(self.wizard._next_id, -1)
+        self.assertFalse(self.wizard.data.get('next', False))
+    # pylint: enable=W0212