Merge lp:~mandel/ubuntuone-control-panel/auto-update-looping-call into lp:ubuntuone-control-panel

[Manuel de la Peña]

Provides the code so that there is a looping call in the control panel that will check for update of the application.

Provides the code so that there is a looping call in the control panel that will check for update of the application.

[Alejandro J. Cura (alecu)]

This style of coding tests is very ugly and error prone:

534 + def _clean_fake_window_class(self):
535 + """Clean the fake window class."""
536 + FakeMainWindow.called = []
537 + FakeMainWindow.close_callback = None
538 +
539 + def _clean_fake_icon_class(self):
540 + """Clean the fake icon class."""
541 + FakeTrayIcon.window = None
542 + FakeTrayIcon.auto_update = None
543 +
544 + def _clean_fake_looping_call_class(self):
545 + """Clean the fake looping call class."""
546 + FakeLoopingCall.function = None
547 + FakeLoopingCall.args = None
548 + FakeLoopingCall.kwargs = None
549 + FakeLoopingCall.called = []

Instead of patching with a class that gets its attributes overwritten, please patch with an instance that gets thrown away, so there's no need to reset the class attributes like in the code above.

For instance:
"self.patch(gui, 'LoopingCall', FakeLoopingCall)" ->
"self.patch(gui, 'LoopingCall', FakeLoopingCallClass())"

This is present a few times in this branch, so make sure all occurrences end up fixed.

---

Also, to test code that uses LoopingCalls (and reactor.callLaters, too) remember that you can use twisted.internet.task.Clock, by patching the LoopingCall.clock attribute. Then you will be able to fake the reactor moving forward in time by calling clock.advance.

This gives you a lot of flexibility to test this kind of code, and the tests end up a lot faster and reliable than if they were using a small value for the LoopingCall or callLater time.

review: Needs Fixing

[Manuel de la Peña (mandel)]

> This style of coding tests is very ugly and error prone:
>
> 534 + def _clean_fake_window_class(self):
> 535 + """Clean the fake window class."""
> 536 + FakeMainWindow.called = []
> 537 + FakeMainWindow.close_callback = None
> 538 +
> 539 + def _clean_fake_icon_class(self):
> 540 + """Clean the fake icon class."""
> 541 + FakeTrayIcon.window = None
> 542 + FakeTrayIcon.auto_update = None
> 543 +
> 544 + def _clean_fake_looping_call_class(self):
> 545 + """Clean the fake looping call class."""
> 546 + FakeLoopingCall.function = None
> 547 + FakeLoopingCall.args = None
> 548 + FakeLoopingCall.kwargs = None
> 549 + FakeLoopingCall.called = []
>
> Instead of patching with a class that gets its attributes overwritten, please
> patch with an instance that gets thrown away, so there's no need to reset the
> class attributes like in the code above.
>
> For instance:
> "self.patch(gui, 'LoopingCall', FakeLoopingCall)" ->
> "self.patch(gui, 'LoopingCall', FakeLoopingCallClass())"
>
> This is present a few times in this branch, so make sure all occurrences end
> up fixed.
>

Fixed them on ubuntuone/controlpanel/gui/qt/tests/test_gui.py since that are the only tests where the class level and did indeed look ugly.

> ---
>
> Also, to test code that uses LoopingCalls (and reactor.callLaters, too)
> remember that you can use twisted.internet.task.Clock, by patching the
> LoopingCall.clock attribute. Then you will be able to fake the reactor moving
> forward in time by calling clock.advance.
>
> This gives you a lot of flexibility to test this kind of code, and the tests
> end up a lot faster and reliable than if they were using a small value for the
> LoopingCall or callLater time.

In my tests I'm asserting that the Looping call was indeed instantiated and started and I trust that the twisted implementation will be correct. I don't think I really need to move the clock to assert that the function was indeed called since the branch this branch depends on already tests that function.

I prefer not to force looping calls to be called since I find those types of tests to be integration tests. I'll leave the tests as they are so we can have a conversation later.

[lp:~mandel/ubuntuone-control-panel/auto-update-looping-call]

251. By Manuel de la Peña on 2011-11-14

Merged with parent.

252. By Manuel de la Peña on 2011-11-14

Fixed tests.

253. By Manuel de la Peña on 2011-11-14

Ensure __call__ returns self.

254. By Manuel de la Peña on 2011-11-16

Merged with parent and fixed conflicts.

255. By Manuel de la Peña on 2011-11-16

Resolve conflicts.

256. By Manuel de la Peña on 2011-11-16

Fixed lint issues.

257. By Manuel de la Peña on 2011-11-16

Removed all unecesary tests.

[Natalia Bidart (nataliabidart)]

This import code:

from ubuntuone.controlpanel.utils import (autoupdate,
    AUTOUPDATE_INTERVAL,
)

should be:

from ubuntuone.controlpanel.utils import (
    autoupdate,
    AUTOUPDATE_INTERVAL,
)

Also, in ubuntuone/controlpanel/gui/qt/gui.py, seems like this change is unrelated and may not be the desired one?

47 - if with_icon or minimized:
48 + if with_icon:

review: Needs Fixing

[Manuel de la Peña (mandel)]

Looking at the code you will see that we had:

46 if not minimized:
47 - if with_icon or minimized:

so if minimized = False we go through the if at line 46 we have that an x or False == x, right?

[lp:~mandel/ubuntuone-control-panel/auto-update-looping-call]

258. By Manuel de la Peña on 2011-12-01

Merged with trunk.

259. By Manuel de la Peña on 2011-12-01

Fix the order of the import.

[Alejandro J. Cura (alecu)]

The TrayIcon constructor takes a LoopingCall as a parameter, but it's never used in production code.
It should be either removed or used.

---

Both FakeMainWindow and FakeTrayIcon are modifying the class attributes.
For instance:
   FakeMainWindow.close_callback = close_callback

The tests should be operating on object instances instead of classes, since modifying classes is bad form and causes maintenance issues.

review: Needs Fixing

[lp:~mandel/ubuntuone-control-panel/auto-update-looping-call]

260. By Manuel de la Peña on 2011-12-01

Create an assign in the same statement.

261. By Manuel de la Peña on 2011-12-14

Reviews changes:Improved the tests not to use the class attrs.
Removed unused __init__ parameter.

262. By Manuel de la Peña on 2011-12-14

Fixed bug qhen calling the lc.

263. By Manuel de la Peña on 2011-12-14

Fixed qt tray tests.

264. By Manuel de la Peña on 2011-12-14

Fixed broken test after changes in FakeWindow.

[Alejandro J. Cura (alecu)]

Code looks good, all tests pass.
Approving.

review: Approve

[lp:~mandel/ubuntuone-control-panel/auto-update-looping-call]

265. By Manuel de la Peña on 2012-01-23

Merged with trunk and fixed conflicts.

266. By Manuel de la Peña on 2012-01-23

Fixed tests so that they work when using the FakeSdTool.

267. By Manuel de la Peña on 2012-01-23

Fixed some small lint issues.

[Alejandro J. Cura (alecu)]

I've just been warned by nessita that if we land this branch it will mean that the qt control panel on linux will need the qt4reactor, and we are trying to move away from it.
Nessita will add more details to this bug.

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

* The file ubuntuone/controlpanel/gui/qt/tests/test_systray.py submitted in this branch is changing the EOLs to windows style, and we should have unix EOLs in all the files.

* Also, like alecu mentioned, we are working on having the QT control panel running only a Qt main loop in Linux, since we need to drop the dependency on the qt4reactor in that OS because we can't file a MIR for it (at least for now). So, since the autoupdate code is only relevant to windows, we'd need to move all that (included the LoopingCall, which brings in the need of a twisted reactor) to a windows-specific location, for example, main/windows.py.

I'd suggest to move the 'start' method to the 'main/' python package, and have all the autoupdate code moved to main/windows.py.

Sorry if I was not explicit about this before, but the goal of dropping the qt4reactor in Linux is a rather new objective.

Let me know if you need further assistance!
Thanks.

review: Needs Fixing

[Manuel de la Peña (mandel)]

> * The file ubuntuone/controlpanel/gui/qt/tests/test_systray.py submitted in
> this branch is changing the EOLs to windows style, and we should have unix
> EOLs in all the files.
>

Hm.. strange I used vim on linux to edit that.. let me double check and make sure its ok.

> * Also, like alecu mentioned, we are working on having the QT control panel
> running only a Qt main loop in Linux, since we need to drop the dependency on
> the qt4reactor in that OS because we can't file a MIR for it (at least for
> now). So, since the autoupdate code is only relevant to windows, we'd need to
> move all that (included the LoopingCall, which brings in the need of a twisted
> reactor) to a windows-specific location, for example, main/windows.py.
>
> I'd suggest to move the 'start' method to the 'main/' python package, and have
> all the autoupdate code moved to main/windows.py.
>
> Sorry if I was not explicit about this before, but the goal of dropping the
> qt4reactor in Linux is a rather new objective.
>
> Let me know if you need further assistance!
> Thanks.

Sure, no problem, its a rather old branch so moving qt to linux is a new thing. I'll get it fix for today.

[lp:~mandel/ubuntuone-control-panel/auto-update-looping-call]

268. By Manuel de la Peña on 2012-01-24

Removed the need to import the reactor from the systray.

269. By Manuel de la Peña on 2012-01-24

Fixed the start tests that failed due to changes in the API.

270. By Manuel de la Peña on 2012-01-24

Added a looping call for the linux implementation based on QTimer.

271. By Manuel de la Peña on 2012-01-24

Face palm.

272. By Manuel de la Peña on 2012-01-24

Added tests for the linux LoopingCall.

273. By Manuel de la Peña on 2012-01-24

Face palm.

274. By Manuel de la Peña on 2012-01-24

_execute required to have self passed.

275. By Manuel de la Peña on 2012-01-24

Fixed tests.

276. By Manuel de la Peña on 2012-01-24

Got all tests working correctly.

[Manuel de la Peña (mandel)]

I have applied changes to the code to simplify the move away from the qt4reactor, please let me know if they are goo enough:

* Removed the import of stop in the systray (present in trunk). Because we pass the stop function to main lets just foward that to systray.
* Added a LoopingCall object that uses QTimer for linux since we won't be using the reactor. Added tests to ensure if works as a LoopingCall (including same assert exceptions.)
* dos2unix used in the files with windows EOL.

[lp:~mandel/ubuntuone-control-panel/auto-update-looping-call]

277. By Manuel de la Peña on 2012-01-24

Moved start to a diff location so that we do not drag the qt reactor with us.

278. By Manuel de la Peña on 2012-01-24

Merged with parent.

279. By Manuel de la Peña on 2012-01-24

Added tests for start.

280. By Manuel de la Peña on 2012-01-24

Fixed tests on windows.

281. By Manuel de la Peña on 2012-01-25

Always perform the auto update looping call.

282. By Manuel de la Peña on 2012-01-25

Fixed lint issues.

283. By Manuel de la Peña on 2012-01-25

Updated copyrighs.

284. By Manuel de la Peña on 2012-01-25

Removed the pep8 issue.

285. By Manuel de la Peña on 2012-03-29

Merged with trunk and fixed all the conflicts.

286. By Manuel de la Peña on 2012-03-30

Moved looping call to a task package.

287. By Manuel de la Peña on 2012-03-30

Merged and resolve conflicts with the unsintall branch.

288. By Manuel de la Peña on 2012-03-30

Added the tests to the correct location. Updated setup.py

289. By Manuel de la Peña on 2012-03-30

Set the value of the looping call.

Unmerged revisions

289. By Manuel de la Peña on 2012-03-30

Set the value of the looping call.

288. By Manuel de la Peña on 2012-03-30

Added the tests to the correct location. Updated setup.py

287. By Manuel de la Peña on 2012-03-30

Merged and resolve conflicts with the unsintall branch.

286. By Manuel de la Peña on 2012-03-30

Moved looping call to a task package.

285. By Manuel de la Peña on 2012-03-29

Merged with trunk and fixed all the conflicts.

284. By Manuel de la Peña on 2012-01-25

Removed the pep8 issue.

283. By Manuel de la Peña on 2012-01-25

Updated copyrighs.

282. By Manuel de la Peña on 2012-01-25

Fixed lint issues.

281. By Manuel de la Peña on 2012-01-25

Always perform the auto update looping call.

280. By Manuel de la Peña on 2012-01-24

Fixed tests on windows.

=== modified file 'setup.py'
--- setup.py	2012-03-07 14:24:40 +0000
+++ setup.py	2012-03-30 18:41:34 +0000
@@ -207,6 +207,7 @@
         'ubuntuone.controlpanel.gui',
         'ubuntuone.controlpanel.gui.qt',
         'ubuntuone.controlpanel.gui.qt.main',
+        'ubuntuone.controlpanel.gui.qt.task',
         'ubuntuone.controlpanel.gui.qt.ui',
         'ubuntuone.controlpanel.gui.qt.uniqueapp',
         'ubuntuone.controlpanel.sd_client',

=== modified file 'ubuntuone/controlpanel/gui/__init__.py'
--- ubuntuone/controlpanel/gui/__init__.py	2012-03-20 15:11:56 +0000
+++ ubuntuone/controlpanel/gui/__init__.py	2012-03-30 18:41:34 +0000
@@ -246,6 +246,8 @@
 TALK_TO_US = _('Talk to us')
 VALUE_ERROR = _('Value could not be retrieved.')
 UNKNOWN_ERROR = _('Unknown error')
+UPDATES_TITLE = _('Updates')
+UPDATES_MESSAGE = _('There is a new update available')
 USAGE_LABEL = _('%(used)s of %(total)s')
 QUIT_LABEL = _('Quit Ubuntu One')
 

=== modified file 'ubuntuone/controlpanel/gui/qt/gui.py'
--- ubuntuone/controlpanel/gui/qt/gui.py	2012-03-29 19:05:02 +0000
+++ ubuntuone/controlpanel/gui/qt/gui.py	2012-03-30 18:41:34 +0000
@@ -18,8 +18,15 @@
 
 from PyQt4 import QtGui, QtCore
 
+from ubuntuone.controlpanel.utils import (
+    autoupdate,
+    AUTOUPDATE_INTERVAL,
+)
+from ubuntuone.controlpanel.gui import UPDATES_TITLE, UPDATES_MESSAGE
 from ubuntuone.controlpanel.gui.qt.systray import TrayIcon
+from ubuntuone.controlpanel.gui.qt.task import LoopingCall
 from ubuntuone.controlpanel.gui.qt.ui import mainwindow_ui
+from ubuntuone.controlpanel.logger import setup_logging
 from ubuntuone.controlpanel.utils import add_to_autostart
 
 # pylint: disable=E0611
@@ -32,6 +39,8 @@
 
 U1_DOTDESKTOP = "ubuntuone-installer.desktop"
 
+logger = setup_logging('qt.gui')
+
 
 class MainWindow(QtGui.QMainWindow):
     """The Main Window of the Control Panel."""
@@ -108,6 +117,10 @@
     if with_icon or minimized:
         QtGui.QApplication.instance().setQuitOnLastWindowClosed(False)
         icon = TrayIcon(window=window, close_callback=close_callback)
+        if AUTOUPDATE_INTERVAL:
+            icon.auto_update_lc = LoopingCall(autoupdate, UPDATES_TITLE,
+                                              UPDATES_MESSAGE, icon, logger)
+            icon.auto_update_lc.start(AUTOUPDATE_INTERVAL, now=True)
     else:
         icon = None
     return icon, window

=== modified file 'ubuntuone/controlpanel/gui/qt/main/__init__.py'
--- ubuntuone/controlpanel/gui/qt/main/__init__.py	2012-03-29 17:20:14 +0000
+++ ubuntuone/controlpanel/gui/qt/main/__init__.py	2012-03-30 18:41:34 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2011 Canonical Ltd.
+# Copyright 2011-12 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

=== modified file 'ubuntuone/controlpanel/gui/qt/systray.py'
--- ubuntuone/controlpanel/gui/qt/systray.py	2012-03-02 13:53:24 +0000
+++ ubuntuone/controlpanel/gui/qt/systray.py	2012-03-30 18:41:34 +0000
@@ -34,6 +34,9 @@
         self.setIcon(QtGui.QIcon(":/icon.png"))
         self.setVisible(True)
         self.window = window
+        self.auto_update_lc = None
+        self._message_cb = lambda: None
+        self.messageClicked.connect(self.on_message_clicked)
         self.activated.connect(self.on_activated)
         self.context_menu = QtGui.QMenu()
         self.restore = QtGui.QAction(RESTORE_LABEL, self,
@@ -52,6 +55,10 @@
         if reason == self.Trigger:  # Left-click
             self.restore_window()
 
+    def on_message_clicked(self):
+        """Execute the callback that was set."""
+        self._message_cb()
+
     def restore_window(self):
         """Show the main window."""
         if self.window is None:
@@ -79,4 +86,14 @@
         except:
             # Maybe it was not running?
             pass
+        if self.auto_update_lc is not None and\
+                self.auto_update_lc.running:
+            self.auto_update_lc.stop()
+
         self.close_callback()
+
+
+    def show_message(self, title, message, clicked_cb=lambda: None):
+        """Show a message and set the new callback to execute."""
+        self._message_cb = clicked_cb
+        self.showMessage(title, message)

=== added directory 'ubuntuone/controlpanel/gui/qt/task'
=== added file 'ubuntuone/controlpanel/gui/qt/task/__init__.py'
--- ubuntuone/controlpanel/gui/qt/task/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gui/qt/task/__init__.py	2012-03-30 18:41:34 +0000
@@ -0,0 +1,30 @@
+# -*- 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/>.
+
+"""Allow to perform tasks in the main loop."""
+
+import sys
+
+
+#pylint: disable=C0103
+if sys.platform == 'win32':
+    from twisted.internet import task
+    source = task
+else:
+    from ubuntuone.controlpanel.gui.qt.task import linux
+    source = linux
+
+LoopingCall = source.LoopingCall

=== added file 'ubuntuone/controlpanel/gui/qt/task/linux.py'
--- ubuntuone/controlpanel/gui/qt/task/linux.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gui/qt/task/linux.py	2012-03-30 18:41:34 +0000
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-12 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."""
+
+from PyQt4 import QtCore
+
+
+class LoopingCall(QtCore.QObject):
+    """A looping call executed every x seconds."""
+
+    def __init__(self, callback, *args, **kwargs):
+        """Create a new function to call."""
+        QtCore.QObject.__init__(self)
+        self.cb = callback
+        self.args = args
+        self.kwargs = kwargs
+        self.timer = QtCore.QTimer(self)
+        self.timer.timeout.connect(self._execute)
+        self.running = False
+
+    def _execute(self):
+        """Execute the function passed to the looping call."""
+        self.cb(*self.args, **self.kwargs)
+
+    def start(self, interval, now=True):
+        """Start the looping call."""
+        assert not self.running, ("Tried to start an already running "
+                                  "LoopingCall.")
+
+        self.running = True
+        if now:
+            self._execute()
+        self.timer.start(interval)
+
+    def stop(self):
+        """Stop the looping call."""
+        assert self.running, ("Tried to stop a LoopingCall that was "
+                              "not running.")
+        self.timer.stop()
+        self.running = False

=== added directory 'ubuntuone/controlpanel/gui/qt/task/tests'
=== added file 'ubuntuone/controlpanel/gui/qt/task/tests/__init__.py'
--- ubuntuone/controlpanel/gui/qt/task/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gui/qt/task/tests/__init__.py	2012-03-30 18:41:34 +0000
@@ -0,0 +1,17 @@
+# -*- 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/>.
+
+"""The test suite for the Qt task module."""

=== added file 'ubuntuone/controlpanel/gui/qt/task/tests/test_linux.py'
--- ubuntuone/controlpanel/gui/qt/task/tests/test_linux.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gui/qt/task/tests/test_linux.py	2012-03-30 18:41:34 +0000
@@ -0,0 +1,82 @@
+# -*- 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/>.
+
+"""Tests for the main module on linux."""
+
+from twisted.internet import defer
+
+from ubuntuone.controlpanel.gui.qt.task import linux
+from ubuntuone.controlpanel.tests import TestCase
+
+
+class FakeCallback(object):
+    """Fake callback."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.args = None
+        self.kwargs = None
+        self.deferred = defer.Deferred()
+
+    def __call__(self, *args, **kwargs):
+        """Call the cb."""
+        self.args = args
+        self.kwargs = kwargs
+        if not self.deferred.called:
+            self.deferred.callback(True)
+
+
+class TestLoopingCall(TestCase):
+    """Test the looping call implementation."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestLoopingCall, self).setUp()
+        self.cb = FakeCallback()
+        self.interval = 100
+
+    @defer.inlineCallbacks
+    def test_start(self):
+        """Test that the call is indeed done."""
+        lc = linux.LoopingCall(self.cb, 'test', other='test')
+        lc.start(self.interval)
+        self.addCleanup(lc.stop)
+        yield self.cb.deferred
+        self.assertTrue(lc.running)
+        self.assertEqual(('test',), self.cb.args)
+        self.assertEqual(dict(other='test'), self.cb.kwargs)
+
+    def test_start_twice(self):
+        """Test that we can't call start more than once."""
+        lc = linux.LoopingCall(self.cb, 'test', other='test')
+        lc.start(self.interval)
+        self.addCleanup(lc.stop)
+        self.assertRaises(AssertionError, lc.start, self.interval)
+
+    def test_stop(self):
+        """Test that we stop."""
+        lc = linux.LoopingCall(self.cb, 'test', other='test')
+        lc.start(self.interval)
+        lc.stop()
+        self.assertFalse(lc.running)
+
+    def test_stop_twice(self):
+        """Test that we can't call stop more than once."""
+        lc = linux.LoopingCall(self.cb, 'test', other='test')
+        lc.start(self.interval)
+        lc.stop()
+        self.assertRaises(AssertionError, lc.stop)

=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_gui.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_gui.py	2012-03-26 13:30:07 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_gui.py	2012-03-30 18:41:34 +0000
@@ -35,6 +35,70 @@
         self.called = (args, kwargs)
 
 
+class FakeMainWindow(object):
+    """Fake window."""
+
+    def __init__(self, close_callback=None):
+        """Create a new instance."""
+        self.called = []
+        self.close_callback = None
+
+    def __call__(self, *args, **kwargs):
+        """Make the object callable to fake a constructor."""
+        return self
+
+    def show(self):
+        """Fake show the window."""
+        self.called.append(('show',))
+
+
+class FakeTrayIcon(object):
+    """Fake tray icon."""
+
+    def __init__(self, window=None):
+        """Create a new instance."""
+        self.auto_update = None
+        self.window = None
+
+    def __call__(self, window, *args, **kwargs):
+        """Make the object callable to fake a cosntructor."""
+        self.window = window
+        return self
+
+    def get_auto_update_lc(self):
+        """Get the auto_update_lc."""
+        return self.auto_update
+
+    def set_auto_update_lc(self, value):
+        """Set the auto_update_lc."""
+        self.auto_update = value
+
+    auto_update_lc = property(get_auto_update_lc,
+                              set_auto_update_lc)
+
+
+class FakeLoopingCall(object):
+    """Fake a looping call."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.function = None
+        self.args = None
+        self.kwargs = None
+        self.called = []
+
+    def __call__(self, f, *args, **kwargs):
+        """Call looping call."""
+        self.function = f
+        self.args = args
+        self.kwargs = kwargs
+        return self
+
+    def start(self, interval, now=False):
+        """Fake the start."""
+        self.called.append(('start', interval, now))
+
+
 class MainWindowTestCase(BaseTestCase):
     """Test the qt main window."""
 
@@ -131,3 +195,71 @@
     def test_add_to_autostart(self):
         """Test that the add_to_autostart function is called when CP opens."""
         self.assertTrue(self._called)
+
+
+class StartTestCase(BaseTestCase):
+    """Test the start method."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the tests."""
+        yield super(StartTestCase, self).setUp()
+        self.called = []
+        self.auto_update_interval = 0.5
+        self.looping_call = FakeLoopingCall()
+
+        def stop():
+            """Fake stop function."""
+            self.called.append(('stop',))
+
+        def auto_update(title, message, icon, logger):
+            """Fake auto_update_cb."""
+            self.called.append(('auto_update_cb', title, message,
+                                icon, logger))
+
+        self.stop_cb = stop
+        self.auto_update_cb = auto_update
+        self.main_window = FakeMainWindow()
+        self.tray_icon = FakeTrayIcon()
+        old_time = gui.AUTOUPDATE_INTERVAL
+        self.addCleanup(self._set_time, old_time)
+        gui.AUTOUPDATE_INTERVAL = 1
+
+    def _set_time(self, time):
+        """Set the correct value back."""
+        gui.AUTOUPDATE_INTERVAL = time
+
+    def test_start_not_minimized_no_icon(self):
+        """Test the not minimized mode with no icon."""
+        icon, window = gui.start(self.stop_cb, minimized=False,
+                          with_icon=False)
+        self.assertEqual(1, len(self.main_window.called))
+        self.assertTrue('show' in self.main_window.called[0])
+        self.assertEqual(None, self.looping_call.function)
+        self.assertNotEqual(None, window)
+        self.assertEqual(None, icon)
+
+    def _assert_minimized_or_icon(self, icon, window):
+        """Assert the start of a minimized of icon mode."""
+        self.assertIsInstance(self.tray_icon.auto_update, FakeLoopingCall)
+        self.assertNotEqual(None, self.looping_call.function)
+        self.assertNotEqual(None, icon)
+
+    def test_start_with_icon(self):
+        """Test the with icon start."""
+        icon, window = gui.start(self.stop_cb, minimized=False,
+                          with_icon=True)
+        self._assert_minimized_or_icon(icon, window)
+        self.assertEqual(1, len(self.main_window.called))
+        self.assertTrue('show' in self.main_window.called[0])
+        self.assertNotEqual(None, window)
+        self.assertNotEqual(None, self.tray_icon.window)
+
+    def test_start_minimized(self):
+        """Test the minimized start."""
+        icon, window = gui.start(self.stop_cb, minimized=True,
+                          with_icon=False)
+        self._assert_minimized_or_icon(icon, window)
+        self.assertEqual(0, len(self.main_window.called))
+        self.assertEqual(None, window)
+        self.assertEqual(None, self.tray_icon.window)

=== removed file 'ubuntuone/controlpanel/gui/qt/tests/test_start.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_start.py	2012-03-20 19:13:28 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_start.py	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Author: Roberto Alsina <[e-mail]>
-#
-# Copyright 2011 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""Tests for the start function."""
-
-from twisted.internet import defer
-
-from ubuntuone.controlpanel.gui.qt import gui
-from ubuntuone.controlpanel.tests import TestCase
-
-
-class FakeThing(object):
-
-    """A fake thing."""
-
-    shown = False
-    size = lambda *a: gui.QtCore.QSize(123456, 654321)
-    style = None
-
-    def __init__(self):
-        self.args = []
-
-    def __call__(self, *args, **kwargs):
-        self.args.append((args, kwargs))
-        return self
-
-    def show(self):
-        """Show."""
-        self.shown = True
-
-    # Invalid name "setGeometry"
-    # pylint: disable=C0103
-
-    def setGeometry(self, style):
-        """Save the new geometry."""
-        self.style = style
-
-
-class StartTestCase(TestCase):
-    """Test the qt control panel."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(StartTestCase, self).setUp()
-        self.main_window = FakeThing()
-        self.tray_icon = FakeThing()
-        self.patch(gui, "MainWindow", self.main_window)
-        self.patch(gui, "TrayIcon", self.tray_icon)
-
-    def close_cb(self):
-        """A dummy close callback."""
-
-    def test_minimized(self):
-        """Test behaviour with minimized=True."""
-        gui.start(close_callback=self.close_cb,
-                  minimized=True, with_icon=True)
-        kwargs = {'close_callback': self.close_cb, 'window': None}
-        self.assertEqual(self.tray_icon.args, [((), kwargs)])
-        self.assertEqual(self.main_window.args, [])
-
-    def test_with_icon(self):
-        """Test behaviour with with_icon=True."""
-        gui.start(close_callback=self.close_cb,
-                  with_icon=True, minimized=False)
-        kwargs = {'close_callback': self.close_cb, 'window': self.main_window}
-        self.assertEqual(self.main_window.args, [((), {'installer': False})])
-        self.assertEqual(self.tray_icon.args, [((), kwargs)])
-
-    def test_both_false(self):
-        """Test behaviour when with_icon and minimized are False."""
-        gui.start(close_callback=self.close_cb,
-                  with_icon=False, minimized=False)
-        # Should be called
-        self.assertNotEqual(self.main_window.args, [])
-        # Should not be called
-        self.assertEqual(self.tray_icon.args, [])
-
-    def test_both_true(self):
-        """Test behaviour when with_icon and minimized are True."""
-        gui.start(close_callback=self.close_cb,
-                  with_icon=True, minimized=True)
-        kwargs = {'close_callback': self.close_cb, 'window': None}
-        self.assertEqual(self.tray_icon.args, [((), kwargs)])
-        self.assertEqual(self.main_window.args, [])
-
-    def test_center_window(self):
-        """The main window should be centered."""
-        gui.start(close_callback=self.close_cb)
-        app = gui.QtGui.QApplication.instance()
-        expected = gui.QtGui.QStyle.alignedRect(gui.QtCore.Qt.LeftToRight,
-                        gui.QtCore.Qt.AlignCenter, self.main_window.size(),
-                        app.desktop().availableGeometry())
-        self.assertEqual(self.main_window.style, expected)

=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_systray.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_systray.py	2012-02-06 21:10:10 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_systray.py	2012-03-30 18:41:34 +0000
@@ -19,7 +19,7 @@
 """Tests for the notification area icon."""
 
 from PyQt4 import QtGui
-from twisted.internet.defer import inlineCallbacks
+from twisted.internet import defer
 
 from ubuntuone.controlpanel.gui.qt import systray
 from ubuntuone.controlpanel.tests import TestCase
@@ -46,12 +46,37 @@
         super(FakeMainWindow, self).__init__()
 
 
+class FakeLoopingCall(object):
+    """Fake a twisted looping call."""
+
+    def __init__(self, is_running=False):
+        """Create a new instance."""
+        self.called = []
+        self.running = is_running
+
+    def start(self, interval, now=False):
+        """Fake starting the call."""
+        self.called.append(('start', interval, now))
+        self.running = True
+
+    def stop(self):
+        """Fake stopping the call."""
+        self.called.append(('stop',))
+        self.running = False
+
+
 class SystrayTestCase(TestCase):
 
     """Test the notification area icon."""
 
-    def test_quit(self):
-        """Test the quit option in the menu."""
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the different tests."""
+        yield super(SystrayTestCase, self).setUp()
+        self.looping_call = FakeLoopingCall()
+
+    def test_quit_no_lc(self):
+        """Test the quit option with no looping call."""
         # Not done on setup, because if I patch stop
         # after instantiation, it doesn't get called.
         self.patch(systray.TrayIcon, "stop", self._set_called)
@@ -59,12 +84,36 @@
         tray.quit.trigger()
         self.assertEqual(self._called, ((False,), {}))
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
+    def test_quit_lc_not_running(self):
+        """Test the quit option with a stopped looping call."""
+        st = FakeSDTool()
+        self.patch(systray, "SyncDaemonTool", lambda: st)
+        tray = systray.TrayIcon(close_callback=self._set_called)
+        tray.auto_update_lc = self.looping_call
+        yield tray.stop()
+        self.assertEqual(self._called, ((), {}))
+        self.assertEqual(0, len(self.looping_call.called))
+
+    @defer.inlineCallbacks
+    def test_quit_lc_running(self):
+        """Test the quit option with a running looping call."""
+        st = FakeSDTool()
+        self.patch(systray, "SyncDaemonTool", lambda: st)
+        self.looping_call.running = True
+        tray = systray.TrayIcon(close_callback=self._set_called)
+        tray.auto_update_lc = self.looping_call
+        yield tray.stop()
+        self.assertEqual(self._called, ((), {}))
+        self.assertEqual(1, len(self.looping_call.called))
+        self.assertTrue('stop' in self.looping_call.called[0])
+
+    @defer.inlineCallbacks
     def test_stop_sd(self):
         """Quit should call SyncDaemonTool.quit()."""
         st = FakeSDTool()
         self.patch(systray, "SyncDaemonTool", lambda: st)
-        tray = systray.TrayIcon()
+        tray = systray.TrayIcon(close_callback=lambda: None)
         yield tray.stop()
         self.assertTrue(st.called)
 
@@ -122,3 +171,26 @@
         self.assertEqual(tray.window, None)
         self.assertIsInstance(tray.context_menu, QtGui.QMenu)
         self.assertFalse(tray.icon() == None)
+
+    def test_show_message(self):
+        """Test the method that shows a message."""
+        called = []
+        title = 'updates'
+        message = 'you want to update!'
+
+        def fake_qt_show_message(instance, title, message):
+            """A fake qt show message."""
+            called.extend([instance, title, message])
+
+        def fake_clicked_message_cb():
+            """A fake clicked cb."""
+
+        self.patch(systray.TrayIcon, 'showMessage', fake_qt_show_message)
+        tray = systray.TrayIcon()
+        tray.show_message(title, message, fake_clicked_message_cb)
+        self.assertTrue(tray in called)
+        self.assertTrue(title in called)
+        self.assertTrue(message in called)
+        # pylint: disable=W0212
+        self.assertEqual(fake_clicked_message_cb, tray._message_cb)
+        # pylint: enable=W0212

=== modified file 'ubuntuone/controlpanel/utils/__init__.py'
--- ubuntuone/controlpanel/utils/__init__.py	2012-03-29 17:58:28 +0000
+++ ubuntuone/controlpanel/utils/__init__.py	2012-03-30 18:41:34 +0000
@@ -39,16 +39,20 @@
     from ubuntuone.controlpanel.utils import windows
     add_to_autostart = windows.add_to_autostart
     are_updates_present = windows.are_updates_present
+    autoupdate = windows.autoupdate
     default_folders = windows.default_folders
     perform_update = windows.perform_update
     uninstall_application = windows.uninstall_application
+    AUTOUPDATE_INTERVAL = windows.AUTOUPDATE_INTERVAL
 else:
     from ubuntuone.controlpanel.utils import linux
     add_to_autostart = no_op
     are_updates_present = no_op
+    autoupdate = no_op
     default_folders = linux.default_folders
     perform_update = no_op
     uninstall_application = no_op
+    AUTOUPDATE_INTERVAL = None
 
 # pylint: enable=C0103
 

=== modified file 'ubuntuone/controlpanel/utils/tests/test_windows.py'
--- ubuntuone/controlpanel/utils/tests/test_windows.py	2012-03-30 17:34:33 +0000
+++ ubuntuone/controlpanel/utils/tests/test_windows.py	2012-03-30 18:41:34 +0000
@@ -21,7 +21,7 @@
 
 from twisted.internet import defer
 
-from ubuntuone.controlpanel import utils
+from ubuntuone.controlpanel import gui, utils
 from ubuntuone.controlpanel.tests import TestCase
 
 # let me use protected methods
@@ -56,6 +56,19 @@
                 self.addCleanup(setattr, utils.windows.sys, attr_name, value)
 
 
+class FakeSysTray(object):
+    """A Fake systray object."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self.called = []
+
+    def show_message(self, title, message, callback):
+        """Fake show message."""
+        self.called.append(('show_message', title, message,
+                            callback))
+
+
 class AutoupdaterTestCase(TestCase):
     """Test the code that is used for the auto update process."""
 
@@ -69,6 +82,7 @@
         self.return_from_call = 0
         self.command = None
         self.args = []
+        self.systray = FakeSysTray()
 
         def fake_execute_process(command, args=None, path=None):
             """Fake async process execution."""
@@ -114,6 +128,37 @@
                 '--unattendedmodeui none', '', 0)
         self.assertEqual(self._called, (args, {}))
 
+    @defer.inlineCallbacks
+    def test_autoupdate_no_updates(self):
+        """Test the autoupdate method with no updates."""
+
+        def fake_are_updates_present():
+            """Fake are_updates_present."""
+            return defer.succeed(False)
+
+        self.patch(utils.windows, 'are_updates_present',
+                   fake_are_updates_present)
+        yield utils.autoupdate(gui.UPDATES_TITLE, gui.UPDATES_MESSAGE,
+                               self.systray)
+        self.assertEqual(0, len(self.systray.called))
+
+    @defer.inlineCallbacks
+    def test_autoupdate_systray(self):
+        """Test the autoupdate method with the systray integration."""
+
+        def fake_are_updates_present():
+            """Fake are_updates_present."""
+            return defer.succeed(True)
+
+        self.patch(utils.windows, 'are_updates_present',
+                   fake_are_updates_present)
+        yield utils.autoupdate(gui.UPDATES_TITLE, gui.UPDATES_MESSAGE,
+                               self.systray)
+        self.assertEqual(1, len(self.systray.called))
+        self.assertTrue(gui.UPDATES_TITLE in self.systray.called[0])
+        self.assertTrue(gui.UPDATES_MESSAGE in self.systray.called[0])
+        self.assertTrue(utils.windows.perform_update in self.systray.called[0])
+
 
 class FakeOpenKey(object):
 

=== modified file 'ubuntuone/controlpanel/utils/windows.py'
--- ubuntuone/controlpanel/utils/windows.py	2012-03-30 17:34:33 +0000
+++ ubuntuone/controlpanel/utils/windows.py	2012-03-30 18:41:34 +0000
@@ -33,6 +33,7 @@
 
 logger = setup_logging('utils.windows')
 AUTOUPDATE_EXE_NAME = 'autoupdate-windows.exe'
+AUTOUPDATE_INTERVAL = 60 * 24  # 60s * 24 hours
 AUTORUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
 UNINSTALL_EXE_NAME = 'uninstall.exe'
 
@@ -87,6 +88,17 @@
     defer.returnValue(result)
 
 
[e-mail]
+def autoupdate(title, message, tray_icon):
+    """Perform the full process of autoupdating the app."""
+    # Check fo updates and pop a message to the user when
+    # and update is present
+    are_present = yield are_updates_present()
+    if are_present:
+        tray_icon.show_message(title, message,
+                               perform_update)
+
+
 def default_folders(user_home=None):
     """Return a list of the folders to add by default."""
     # as per http://msdn.microsoft.com/en-us/library/windows/desktop/bb762181,