Merge lp:~nataliabidart/magicicada-gui/set-initial-state into lp:magicicada-gui

[Natalia Bidart]

GUI updates the initial state based on syncdaemon.current_state.
Also fixed some glitches on buttons sensitivity and visibility.

=== modified file 'magicicada/__init__.py'
--- magicicada/__init__.py	2010-05-22 03:19:12 +0000
+++ magicicada/__init__.py	2010-05-23 10:42:26 +0000
@@ -29,7 +29,7 @@
 gtk2reactor.install()
 
 from magicicada import syncdaemon
-from magicicada.helpers import get_data_file, get_builder, NO_OP
+from magicicada.helpers import get_data_file, get_builder, NO_OP, print_debug
 
 CONTENT_QUEUE = 'content'
 META_QUEUE = 'meta'
@@ -39,7 +39,6 @@
     STATUS = {
         'started': _('Service started, click Connect to continue.'),
         'connected': _('Service connected. Doing internal synchronization...'),
-        'online': _('Service reached Nirvana.'),
     }
 
     def __init__(self, launchpad_available=False, on_destroy=NO_OP,
@@ -96,6 +95,8 @@
         self.widget_enabled = lambda w: \
                               w.get_property('visible') and w.is_sensitive()
 
+        self.update()
+
     # GTK callbacks
 
     def on_main_window_destroy(self, widget, data=None):
@@ -118,10 +119,8 @@
     def on_start_clicked(self, widget, data=None):
         """Start syncdaemon."""
         self.sd.start()
-        self.start.hide()
-        self.stop.set_sensitive(False)
-        self.stop.show()
-        self.start_loading(self.is_started)
+        self.start.set_sensitive(False)
+        self._start_loading(self.is_started)
 
     def on_stop_clicked(self, widget, data=None):
         """Stop syncdaemon."""
@@ -129,28 +128,21 @@
             self.on_disconnect_clicked(self.disconnect)
         self.connect.set_sensitive(False)
 
-        self.start.show()
-        self.start.set_sensitive(False)
-        self.stop.hide()
-
+        self.stop.set_sensitive(False)
         self.sd.quit()
 
     def on_connect_clicked(self, widget, data=None):
         """Connect syncdaemon."""
         self.sd.connect()
-        self.connect.hide()
-        self.disconnect.set_sensitive(False)
-        self.disconnect.show()
-        self.start_loading(self.is_connected)
+        self.connect.set_sensitive(False)
+        self._start_loading(self.is_connected)
 
     def on_disconnect_clicked(self, widget, data=None):
         """Disconnect syncdaemon."""
-        self.connect.show()
-        self.connect.set_sensitive(False)
-        self.disconnect.hide()
-
+        self.disconnect.set_sensitive(False)
         self.sd.disconnect()
 
+    @print_debug
     def on_status_icon_activate(self, widget, data=None):
         """Systray icon was clicked."""
         if self.main_window.get_property('visible'):
@@ -158,48 +150,60 @@
         else:
             self.main_window.show()
 
-    # DBus callbacks
+    # SyncDaemon callbacks
 
     def on_started(self, *args, **kwargs):
         """Callback'ed when syncadaemon is started."""
+        self.start.hide()
+        self.stop.show()
         self.stop.set_sensitive(True)
-        self.activate_indicator(self.is_started)
+        self._activate_indicator(self.is_started)
         self.connect.set_sensitive(True)
 
     def on_stopped(self, *args, **kwargs):
         """Callback'ed when syncadaemon is stopped."""
+        self.stop.hide()
+        self.start.show()
         self.start.set_sensitive(True)
+        self.connect.set_sensitive(False)
 
-        self.activate_indicator(self.is_started, sensitive=False)
-        self.activate_indicator(self.is_connected, sensitive=False)
-        self.activate_indicator(self.is_online, sensitive=False)
+        self._activate_indicator(self.is_started, sensitive=False)
+        self._activate_indicator(self.is_connected, sensitive=False)
+        self._activate_indicator(self.is_online, sensitive=False)
 
     def on_connected(self, *args, **kwargs):
         """Callback'ed when syncadaemon is connected."""
+        self.connect.hide()
+        self.disconnect.show()
         self.disconnect.set_sensitive(True)
-        self.activate_indicator(self.is_connected)
-        self.start_loading(self.is_online)
-        self.start_loading(self.is_online)
+        self._activate_indicator(self.is_connected)
+        self._start_loading(self.is_online)
+        self._start_loading(self.is_online)
 
     def on_disconnected(self, *args, **kwargs):
         """Callback'ed when syncadaemon is disconnected."""
+        self.disconnect.hide()
+        self.connect.show()
         self.connect.set_sensitive(True)
 
-        self.activate_indicator(self.is_connected, sensitive=False)
-        self.activate_indicator(self.is_online, sensitive=False)
+        self._activate_indicator(self.is_connected, sensitive=False)
+        self._activate_indicator(self.is_online, sensitive=False)
 
     def on_online(self, *args, **kwargs):
         """Callback'ed when syncadaemon is online."""
         self.is_online.set_sensitive(True)
-        self.activate_indicator(self.is_online)
+        self._activate_indicator(self.is_online)
 
     def on_offline(self, *args, **kwargs):
         """Callback'ed when syncadaemon is offline."""
-        self.activate_indicator(self.is_online, sensitive=False)
+        self._activate_indicator(self.is_online, sensitive=False)
 
-    def on_status_changed(self, name, description, is_error, is_connected,
-                          is_online, queues, connection):
+    def on_status_changed(self, name=None, description=None,
+                          is_error=False, is_connected=True,
+                          is_online=True, queues=None, connection=None):
         """Callback'ed when the SD status changed."""
+        if description is None:
+            description = ''
         self.status_label.set_text(description)
 
     def _on_queue_changed(self, queue_name, items, *args, **kwargs):
@@ -211,7 +215,7 @@
             row = (item.operation, item.path, item.node, item.share)
             queue_store.append(row)
 
-        if not queue_view.is_sensitive():
+        if not queue_view.is_sensitive() and len(items) > 0:
             queue_view.set_sensitive(True)
 
     def on_content_queue_changed(self, items, *args, **kwargs):
@@ -224,12 +228,33 @@
 
     # custom
 
-    def start_loading(self, what):
+    def _start_loading(self, what):
         """Set a loader animation on 'what'."""
         what.set_sensitive(True)
         what.set_from_animation(self.loading_animation)
 
-    def activate_indicator(self, what, sensitive=True):
+    def _activate_indicator(self, what, sensitive=True):
         """Set ready pixbuf on 'what' and make it 'sensitive'."""
         what.set_sensitive(sensitive)
         what.set_from_pixbuf(self.active_indicator)
+
+    def update(self):
+        """Update UI based on SD current state."""
+        current_state = self.sd.current_state
+
+        self._activate_indicator(self.is_online,
+                                 sensitive=current_state.is_online)
+
+        if current_state.is_started:
+            self.on_started()
+            if current_state.is_connected:
+                self.on_connected()
+            else:
+                self.on_disconnected()
+        else:
+            self.on_disconnected()
+            self.on_stopped()
+
+        self.on_meta_queue_changed(self.sd.meta_queue)
+        self.on_content_queue_changed(self.sd.content_queue)
+        self.on_status_changed(description=current_state.description)

=== modified file 'magicicada/syncdaemon.py'
--- magicicada/syncdaemon.py	2010-05-22 20:27:11 +0000
+++ magicicada/syncdaemon.py	2010-05-23 10:42:26 +0000
@@ -85,6 +85,13 @@
                 raise AttributeError("Name not in _attrs: %r" % name)
             self.__dict__[name] = value
 
+    def __str__(self):
+        """String representation."""
+        result = []
+        for attr in self._attrs:
+            result.append("%s=%s" % (attr, getattr(self, attr)))
+        return "<%s>" % ", ".join(result)
+
 
 class SyncDaemon(object):
     """Interface to Ubuntu One's SyncDaemon."""

=== modified file 'magicicada/tests/test_magicicada.py'
--- magicicada/tests/test_magicicada.py	2010-05-22 03:19:12 +0000
+++ magicicada/tests/test_magicicada.py	2010-05-23 10:42:26 +0000
@@ -18,28 +18,10 @@
 
 """Tests for magicicada."""
 
-import gobject
-import gtk
-import unittest
-
-from functools import wraps
-
 from twisted.trial.unittest import TestCase
 
 from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, syncdaemon
-from magicicada.helpers import get_builder, NO_OP
-
-DEFAULT_TIMEOUT = 200
-
-def close_window_after(a_test):
-    """Decorator to close the main window after executing f."""
-    @wraps(a_test)
-    def inner(*args, **kwargs):
-        """Inner function."""
-        #gobject.timeout_add(DEFAULT_TIMEOUT, a_test)
-        #self.ui.run()
-
-    return inner
+from magicicada.helpers import NO_OP
 
 
 class FakedSyncdaemon(object):
@@ -61,13 +43,16 @@
         self.connect = NO_OP
         self.disconnect = NO_OP
 
+        self.current_state = syncdaemon.State()
+        self.meta_queue = []
+        self.content_queue = []
+
 
 class MagicicadaUITestCase(TestCase):
     """UI test cases for Magicicada UI."""
 
     def setUp(self):
         """Init."""
-        self.builder = get_builder('gui.glade')
         self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon)
         self._called = False
         self.set_called = lambda *_: setattr(self, '_called', True)
@@ -76,7 +61,6 @@
         """Cleanup."""
         self.ui.on_main_window_destroy(self.ui.main_window)
         self._called = False
-        self.builder = None
 
     def assert_indicator_disabled(self, indicator):
         """Test that 'indicator' is not sensitive."""
@@ -136,8 +120,11 @@
         self.assertFalse(self.ui.is_online.is_sensitive())
 
     def test_update_is_correct(self):
-        """Update updates."""
-		# XXX: TODO
+        """Update is called at startup."""
+        self.patch(MagicicadaUI, 'update', self.set_called)
+        self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon)
+        self.assertTrue(self._called,
+                        'update was called at startup.')
 
 
 class MagicicadaUIClickedTestCase(MagicicadaUITestCase):
@@ -147,9 +134,9 @@
         """Test on_start_clicked."""
         self.ui.on_start_clicked(self.ui.start)
 
-        self.assertFalse(self.ui.start.get_property('visible'))
-        self.assertTrue(self.ui.stop.get_property('visible'))
-        self.assertFalse(self.ui.stop.is_sensitive())
+        self.assertTrue(self.ui.start.get_property('visible'))
+        self.assertFalse(self.ui.start.is_sensitive())
+        self.assertFalse(self.ui.stop.get_property('visible'))
 
         self.assert_indicator_loading(self.ui.is_started)
         self.assert_indicator_disabled(self.ui.is_connected)
@@ -167,9 +154,9 @@
         self.ui.on_started()
         self.ui.on_connect_clicked(self.ui.connect)
 
-        self.assertFalse(self.ui.connect.get_property('visible'))
-        self.assertTrue(self.ui.disconnect.get_property('visible'))
-        self.assertFalse(self.ui.disconnect.is_sensitive())
+        self.assertTrue(self.ui.connect.get_property('visible'))
+        self.assertFalse(self.ui.connect.is_sensitive())
+        self.assertFalse(self.ui.disconnect.get_property('visible'))
 
         self.assert_indicator_ready(self.ui.is_started)
         self.assert_indicator_loading(self.ui.is_connected)
@@ -191,9 +178,9 @@
 
         self.assertFalse(self._called, 'on_disconnect_clicked was not called.')
 
-        self.assertTrue(self.ui.start.get_property('visible'))
-        self.assertFalse(self.ui.start.is_sensitive())
-        self.assertFalse(self.ui.stop.get_property('visible'))
+        self.assertFalse(self.ui.start.get_property('visible'))
+        self.assertTrue(self.ui.stop.get_property('visible'))
+        self.assertFalse(self.ui.stop.is_sensitive())
 
         self.assertTrue(self.ui.connect.get_property('visible'))
         self.assertFalse(self.ui.connect.is_sensitive())
@@ -224,9 +211,9 @@
         self.ui.on_connected()
         self.ui.on_disconnect_clicked(self.ui.disconnect)
 
-        self.assertTrue(self.ui.connect.get_property('visible'))
-        self.assertFalse(self.ui.connect.is_sensitive())
-        self.assertFalse(self.ui.disconnect.get_property('visible'))
+        self.assertFalse(self.ui.connect.get_property('visible'))
+        self.assertTrue(self.ui.disconnect.get_property('visible'))
+        self.assertFalse(self.ui.disconnect.is_sensitive())
 
     def test_on_disconnect_clicked_disconnects_syncdaemon(self):
         """Test on_disconnect_clicked."""
@@ -268,7 +255,7 @@
         self.queue_view = getattr(self.ui, '%sq_view' % self.queue)
 
     def build_some_data(self, limit=5):
-        """Build some data to pass to queue changed callback."""
+        """Build some data to pass to queue changed callback and related."""
         items = []
         for i in xrange(limit):
             cq = syncdaemon.QueueData(operation='operation %i' % i,
@@ -277,6 +264,25 @@
             items.append(cq)
         return items
 
+    def assert_queue_store_correct(self, queue_store, items):
+        """Test that 'queue_store' has 'items' as content."""
+        msg = 'amount of rows for %s must be %s (got %s).'
+        self.assertEqual(len(queue_store), len(items),
+                         msg % (queue_store, len(items), len(queue_store)))
+        # assert rows content equal to items content
+        tree_iter = queue_store.get_iter_root()
+        tmp = list(reversed(items))
+        while tree_iter is not None:
+            expected = tmp.pop()
+
+            op, path, node, share = queue_store.get(tree_iter, 0, 1, 2, 3)
+            self.assertEqual(expected.operation, op)
+            self.assertEqual(expected.path, path)
+            self.assertEqual(expected.node, node)
+            self.assertEqual(expected.share, share)
+
+            tree_iter = queue_store.iter_next(tree_iter)
+
     def test_callback_is_connected(self):
         """Queue changed callback is connected."""
         self.assertEqual(self.sd_changed, self.ui_changed,
@@ -293,22 +299,7 @@
         """On queue changed the view is updated."""
         items = self.build_some_data()
         self.sd_changed(items)
-
-        self.assertEqual(len(self.queue_store), len(items))
-
-        # assert rows content equal to items content
-        tree_iter = self.queue_store.get_iter_root()
-        tmp = list(reversed(items))
-        while tree_iter is not None:
-            expected = tmp.pop()
-
-            op, path, node, share = self.queue_store.get(tree_iter, 0, 1, 2, 3)
-            self.assertEqual(expected.operation, op)
-            self.assertEqual(expected.path, path)
-            self.assertEqual(expected.node, node)
-            self.assertEqual(expected.share, share)
-
-            tree_iter = self.queue_store.iter_next(tree_iter)
+        self.assert_queue_store_correct(self.queue_store, items)
 
     def test_model_is_cleared_before_updating(self):
         """The model is cleared before upadting with a new set of data."""
@@ -329,6 +320,15 @@
         self.assertTrue(self.queue_view.is_sensitive(),
                         'Tree view must be enabled on changed.')
 
+    def test_update_is_correct_for_queue(self):
+        """Correctly updates the queue state."""
+        data = self.build_some_data()
+        setattr(self.ui.sd, '%s_queue' % self.queue, data)
+
+        self.ui.update()
+
+        self.assert_queue_store_correct(self.queue_store, data)
+
 
 class MagicicadaUIContentQueueTestCase(_MagicicadaUIQueueTestCase):
     """UI test cases for content queue view."""
@@ -345,10 +345,6 @@
 class MagicicadaUIStatusTestCase(MagicicadaUITestCase):
     """UI test cases for the status label."""
 
-    def setUp(self):
-        """Init."""
-        super(MagicicadaUIStatusTestCase, self).setUp()
-
     def test_callback_is_connected(self):
         """Status callback is connected."""
         self.assertEqual(self.ui.sd.status_changed_callback,
@@ -363,13 +359,53 @@
         self.ui.on_status_changed(**kwargs)
         self.assertEqual(self.ui.status_label.get_text(), kwargs['description'])
 
+    def test_update_is_correct_for_status_label(self):
+        """Correctly updates the status label."""
+        expected = 'dummy test'
+        self.ui.sd.current_state._set(description=expected)
+
+        self.ui.update()
+
+        self.assertEqual(expected, self.ui.status_label.get_text())
+
 
 class MagicicadaUIConnectionTestCase(MagicicadaUITestCase):
     """UI test cases for."""
 
-    def setUp(self):
-        """Init."""
-        super(MagicicadaUIConnectionTestCase, self).setUp()
+    def assert_indicator_is_updated_correctly(self, indicator):
+        """Test that correctly updates the 'indicator'."""
+        cs = self.ui.sd.current_state
+        for expected in (True, False):
+            cs._set(**{indicator: expected})
+
+            self.ui.update()
+
+            self.assertEqual(self.ui.widget_enabled(self.ui.start),
+                             not cs.is_started,
+                             'start must be enabled if not started.')
+            self.assertEqual(self.ui.widget_enabled(self.ui.stop),
+                             cs.is_started,
+                             'stop must be enabled if started.')
+
+            if cs.is_started:
+                actual = self.ui.widget_enabled(getattr(self.ui, indicator))
+                self.assertEqual(expected, actual,
+                                 '%s must be %s' % (indicator, expected))
+
+                self.assertEqual(self.ui.widget_enabled(self.ui.connect),
+                                 not cs.is_connected,
+                                 'connect must be enabled if not connected.')
+                self.assertEqual(self.ui.widget_enabled(self.ui.disconnect),
+                                 cs.is_connected,
+                                 'disconnect must be enabled if connected.')
+            else:
+                self.assertFalse(self.ui.connect.is_sensitive(),
+                                 'connect must be disabled when %s' % cs)
+                self.assertTrue(self.ui.connect.get_property('visible'),
+                                 'connect must be visible when %s' % cs)
+                actual = self.ui.widget_enabled(getattr(self.ui, indicator))
+                self.assertFalse(actual,
+                                 '%s must be disabled' % (indicator,))
 
     def test_all_disabled_at_startup(self):
         """Indicators are all disabled at startup."""
@@ -391,13 +427,11 @@
         """On SD started, the UI enables connect and indicator."""
         # must have click start first
         self.ui.on_start_clicked(self.ui.start)
-        assert not self.ui.stop.is_sensitive()
-        assert not self.ui.connect.is_sensitive()
 
         self.ui.on_started()
 
-        self.assertTrue(self.ui.stop.is_sensitive())
-        self.assertTrue(self.ui.connect.is_sensitive())
+        self.assertTrue(self.ui.widget_enabled(self.ui.stop))
+        self.assertTrue(self.ui.widget_enabled(self.ui.connect))
         self.assert_indicator_ready(self.ui.is_started)
         self.assert_indicator_disabled(self.ui.is_connected)
         self.assert_indicator_disabled(self.ui.is_online)
@@ -407,11 +441,10 @@
         self.ui.on_start_clicked(self.ui.start)
         self.ui.on_started()
         self.ui.on_connect_clicked(self.ui.start)
-        assert not self.ui.disconnect.is_sensitive()
 
         self.ui.on_connected()
 
-        self.assertTrue(self.ui.disconnect.is_sensitive())
+        self.assertTrue(self.ui.widget_enabled(self.ui.disconnect))
         self.assert_indicator_ready(self.ui.is_started)
         self.assert_indicator_ready(self.ui.is_connected)
         self.assert_indicator_loading(self.ui.is_online)
@@ -471,3 +504,7 @@
         self.assert_indicator_ready(self.ui.is_connected)
         self.assert_indicator_disabled(self.ui.is_online)
 
+    def test_update_is_correct_for_indicators_and_buttons(self):
+        """Correctly updates the indicators and buttons state."""
+        for i in ('is_started', 'is_connected', 'is_online'):
+            self.assert_indicator_is_updated_correctly(i)