Merge lp:~nataliabidart/magicicada-gui/bind-more-signals into lp:magicicada-gui

[Natalia Bidart]

Binding callbacks for started/stopped, connected/disconnected, online/offline. Binding methods start/quit and connect/disconnect.

[lp:~nataliabidart/magicicada-gui/bind-more-signals]

24. By Natalia Bidart on 2010-05-22

Tweaks.

[Facundo Batista (facundo)]

Go forward!

review: Approve

=== added file 'data/media/active-016.png'
Binary files data/media/active-016.png	1970-01-01 00:00:00 +0000 and data/media/active-016.png	2010-05-22 03:21:24 +0000 differ
=== added file 'data/media/active.svg'
--- data/media/active.svg	1970-01-01 00:00:00 +0000
+++ data/media/active.svg	2010-05-22 03:21:24 +0000
@@ -0,0 +1,203 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="425.71429"
+   height="461.42856"
+   id="svg2"
+   sodipodi:version="0.32"
+   inkscape:version="0.47 r22583"
+   version="1.0"
+   sodipodi:docname="active.svg"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape">
+  <defs
+     id="defs4">
+    <linearGradient
+       id="linearGradient3250">
+      <stop
+         style="stop-color:#b8b8b8;stop-opacity:0;"
+         offset="0"
+         id="stop3252" />
+      <stop
+         id="stop3258"
+         offset="0.40588239"
+         style="stop-color:#b8b8b8;stop-opacity:1;" />
+      <stop
+         style="stop-color:#b8b8b8;stop-opacity:0;"
+         offset="1"
+         id="stop3254" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient3224">
+      <stop
+         style="stop-color:#ffffff;stop-opacity:1;"
+         offset="0"
+         id="stop3226" />
+      <stop
+         style="stop-color:#c8c8c8;stop-opacity:1;"
+         offset="1"
+         id="stop3228" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient3214">
+      <stop
+         style="stop-color:#3b3b3b;stop-opacity:1;"
+         offset="0"
+         id="stop3216" />
+      <stop
+         style="stop-color:#afafaf;stop-opacity:1;"
+         offset="1"
+         id="stop3218" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient3176">
+      <stop
+         style="stop-color:#c1ffb6;stop-opacity:1;"
+         offset="0"
+         id="stop3178" />
+      <stop
+         id="stop3184"
+         offset="0.40630153"
+         style="stop-color:#00e632;stop-opacity:1;" />
+      <stop
+         style="stop-color:#1c3a4f;stop-opacity:1"
+         offset="1"
+         id="stop3180" />
+    </linearGradient>
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="744.09448 : 526.18109 : 1"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       id="perspective10" />
+    <inkscape:perspective
+       id="perspective2390"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       inkscape:vp_z="744.09448 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       sodipodi:type="inkscape:persp3d" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3176"
+       id="radialGradient3182"
+       cx="346.42856"
+       cy="338.07645"
+       fx="346.42856"
+       fy="338.07645"
+       r="165.71428"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(-1.2831103,0.3438084,-0.3438084,-1.2831103,907.16815,652.76078)" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3214"
+       id="radialGradient3220"
+       cx="317.60519"
+       cy="539.41315"
+       fx="317.60519"
+       fy="539.41315"
+       r="165.53342"
+       gradientTransform="matrix(1,0,0,0.2054734,0,428.57808)"
+       gradientUnits="userSpaceOnUse" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3224"
+       id="radialGradient3230"
+       cx="317.60394"
+       cy="220.94547"
+       fx="317.60394"
+       fy="220.94547"
+       r="164.06058"
+       gradientTransform="matrix(1.0076229,0,0,0.1968921,-2.4553843,177.59098)"
+       gradientUnits="userSpaceOnUse" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3250"
+       id="linearGradient3256"
+       x1="318.47412"
+       y1="651.00037"
+       x2="309.90268"
+       y2="413.85742"
+       gradientUnits="userSpaceOnUse"
+       spreadMethod="pad" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3214"
+       id="radialGradient3274"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1,0,0,0.2054734,11.428571,428.57808)"
+       cx="317.60519"
+       cy="539.41315"
+       fx="317.60519"
+       fy="539.41315"
+       r="165.53342" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3224"
+       id="radialGradient3276"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0076229,0,0,0.1922742,8.9731871,177.85367)"
+       cx="317.60394"
+       cy="220.94547"
+       fx="317.60394"
+       fy="220.94547"
+       r="164.06058" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     gridtolerance="10000"
+     guidetolerance="10"
+     objecttolerance="10"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.70710678"
+     inkscape:cx="577.43933"
+     inkscape:cy="433.43027"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1250"
+     inkscape:window-height="775"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-105.61697,-158.14316)">
+    <path
+       sodipodi:type="arc"
+       style="opacity:1;fill:url(#radialGradient3182);fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       id="path2396"
+       sodipodi:cx="323.57144"
+       sodipodi:cy="389.50504"
+       sodipodi:rx="165.71428"
+       sodipodi:ry="165.71428"
+       d="m 489.28572,389.50504 c 0,91.52146 -74.19281,165.71427 -165.71428,165.71427 -91.52147,0 -165.71428,-74.19281 -165.71428,-165.71427 0,-91.52147 74.19281,-165.71428 165.71428,-165.71428 91.52147,0 165.71428,74.19281 165.71428,165.71428 z"
+       transform="translate(5.643371,-11.272676)" />
+  </g>
+</svg>

=== modified file 'magicicada/__init__.py'
--- magicicada/__init__.py	2010-05-17 16:10:28 +0000
+++ magicicada/__init__.py	2010-05-22 03:21:24 +0000
@@ -28,8 +28,8 @@
 from twisted.internet import gtk2reactor # for gtk-2.0
 gtk2reactor.install()
 
+from magicicada import syncdaemon
 from magicicada.helpers import get_data_file, get_builder, NO_OP
-from magicicada.syncdaemon import SyncDaemon
 
 CONTENT_QUEUE = 'content'
 META_QUEUE = 'meta'
@@ -42,7 +42,8 @@
         'online': _('Service reached Nirvana.'),
     }
 
-    def __init__(self, launchpad_available=False, on_destroy=NO_OP):
+    def __init__(self, launchpad_available=False, on_destroy=NO_OP,
+                 syncdaemon_class=syncdaemon.SyncDaemon):
         """Init."""
         self.builder = get_builder('gui.glade')
         self.builder.connect_signals(self)
@@ -59,8 +60,8 @@
 
         animation_filename = get_data_file('media', 'loader-ball.gif')
         self.loading_animation = gtk.gdk.PixbufAnimation(animation_filename)
-
-        self.started = self.connected = self.online = False
+        active_filename = get_data_file('media', 'active-016.png')
+        self.active_indicator = gtk.gdk.pixbuf_new_from_file(active_filename)
 
         widgets = (
             'start', 'stop', 'connect', 'disconnect', # toolbar buttons
@@ -81,16 +82,26 @@
 
         self.main_window.show()
 
-        self.sd = SyncDaemon()
+        self.sd = syncdaemon_class()
+        self.sd.on_started_callback = self.on_started
+        self.sd.on_stopped_callback = self.on_stopped
+        self.sd.on_connected_callback = self.on_connected
+        self.sd.on_disconnected_callback = self.on_disconnected
+        self.sd.on_online_callback = self.on_online
+        self.sd.on_offline_callback = self.on_offline
+        self.sd.status_changed_callback = self.on_status_changed
         self.sd.content_queue_changed_callback = self.on_content_queue_changed
         self.sd.meta_queue_changed_callback = self.on_meta_queue_changed
 
+        self.widget_enabled = lambda w: \
+                              w.get_property('visible') and w.is_sensitive()
+
     # GTK callbacks
 
     def on_main_window_destroy(self, widget, data=None):
         """Called when the MagicicadaWindow is closed."""
         # Clean up code for saving application state should be added here.
-        if self.started:
+        if self.widget_enabled(self.stop):
             self.on_stop_clicked(self.stop)
         self.sd.shutdown()
         self.on_destroy()
@@ -106,46 +117,39 @@
 
     def on_start_clicked(self, widget, data=None):
         """Start syncdaemon."""
-        self.started = True
-        self.connect.set_sensitive(True)
+        self.sd.start()
         self.start.hide()
+        self.stop.set_sensitive(False)
         self.stop.show()
-
-        self.doing_something(self.is_started)
+        self.start_loading(self.is_started)
 
     def on_stop_clicked(self, widget, data=None):
         """Stop syncdaemon."""
-        assert self.started
-
-        if self.connected:
+        if self.widget_enabled(self.disconnect):
             self.on_disconnect_clicked(self.disconnect)
         self.connect.set_sensitive(False)
 
-        self.started = False
         self.start.show()
+        self.start.set_sensitive(False)
         self.stop.hide()
 
-        self.on_stopped()
+        self.sd.quit()
 
     def on_connect_clicked(self, widget, data=None):
         """Connect syncdaemon."""
-        assert self.started
-        self.connected = True
+        self.sd.connect()
         self.connect.hide()
+        self.disconnect.set_sensitive(False)
         self.disconnect.show()
-
-        self.on_started()
-        self.doing_something(self.is_connected)
+        self.start_loading(self.is_connected)
 
     def on_disconnect_clicked(self, widget, data=None):
         """Disconnect syncdaemon."""
-        assert self.started
-        assert self.connected
-        self.connected = False
         self.connect.show()
+        self.connect.set_sensitive(False)
         self.disconnect.hide()
 
-        self.on_disconnected()
+        self.sd.disconnect()
 
     def on_status_icon_activate(self, widget, data=None):
         """Systray icon was clicked."""
@@ -158,43 +162,45 @@
 
     def on_started(self, *args, **kwargs):
         """Callback'ed when syncadaemon is started."""
-        self.stop_doing_something(self.is_started)
-        self.status_label.set_text(self.STATUS['started'])
+        self.stop.set_sensitive(True)
+        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_doing_something(self.is_started, sensitive=False)
-
-        self.is_started.set_sensitive(False)
-        self.is_connected.set_sensitive(False)
-        self.is_online.set_sensitive(False)
+        self.start.set_sensitive(True)
+
+        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.is_connected.set_sensitive(True)
-        self.doing_something(self.is_online)
-        self.status_label.set_text(self.STATUS['connected'])
+        self.disconnect.set_sensitive(True)
+        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.stop_doing_something(self.is_connected, sensitive=False)
-
-        self.is_connected.set_sensitive(False)
-        self.is_online.set_sensitive(False)
+        self.connect.set_sensitive(True)
+
+        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_onlined.set_sensitive(True)
-        self.status_label.set_text(self.STATUS['online'])
+        self.is_online.set_sensitive(True)
+        self.activate_indicator(self.is_online)
 
     def on_offline(self, *args, **kwargs):
         """Callback'ed when syncadaemon is offline."""
-
-        self.stop_doing_something(self.is_online, sensitive=False)
-
-        self.is_online.set_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):
+        """Callback'ed when the SD status changed."""
+        self.status_label.set_text(description)
 
     def _on_queue_changed(self, queue_name, items, *args, **kwargs):
         """Callback'ed when a queue changed."""
@@ -218,12 +224,12 @@
 
     # custom
 
-    def doing_something(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 stop_doing_something(self, what, sensitive=True):
-        """Set a loader animation on 'what'."""
-        what.set_from_stock(gtk.STOCK_YES, gtk.ICON_SIZE_BUTTON)
+    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)

=== modified file 'magicicada/tests/test_magicicada.py'
--- magicicada/tests/test_magicicada.py	2010-05-17 16:10:28 +0000
+++ magicicada/tests/test_magicicada.py	2010-05-22 03:21:24 +0000
@@ -26,9 +26,8 @@
 
 from twisted.trial.unittest import TestCase
 
-from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE
+from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, syncdaemon
 from magicicada.helpers import get_builder, NO_OP
-from magicicada.syncdaemon import SyncDaemon, QueueData
 
 DEFAULT_TIMEOUT = 200
 
@@ -47,8 +46,20 @@
     """A faked syncdaemon."""
 
     def __init__(self):
+        self.on_started_callback = NO_OP
+        self.on_stopped_callback = NO_OP
+        self.on_connected_callback = NO_OP
+        self.on_disconnected_callback = NO_OP
+        self.on_online_callback = NO_OP
+        self.on_offline_callback = NO_OP
+        self.status_changed_callback = NO_OP
         self.content_queue_changed_callback = NO_OP
         self.meta_queue_changed_callback = NO_OP
+        self.shutdown = NO_OP
+        self.start = NO_OP
+        self.quit = NO_OP
+        self.connect = NO_OP
+        self.disconnect = NO_OP
 
 
 class MagicicadaUITestCase(TestCase):
@@ -57,31 +68,50 @@
     def setUp(self):
         """Init."""
         self.builder = get_builder('gui.glade')
-        self.ui = MagicicadaUI()
+        self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon)
         self._called = False
+        self.set_called = lambda *_: setattr(self, '_called', True)
 
     def tearDown(self):
-        """Clenaup."""
+        """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."""
+        self.assertFalse(indicator.is_sensitive(), 'indicator is not sensitive')
+
+    def assert_indicator_ready(self, indicator):
+        """Test that 'indicator' is sensitive and green."""
+        self.assertTrue(indicator.is_sensitive(), 'indicator is sensitive')
+        expected = indicator.get_pixbuf() # a test on its own
+        self.assertEqual(self.ui.active_indicator, expected,
+                         'indicator is the correct pixbuf')
+
+    def assert_indicator_loading(self, indicator):
+        """Test that 'indicator' is sensitive and loading."""
+        self.assertTrue(indicator.is_sensitive(), 'indicator is sensitive')
+        expected = indicator.get_animation() # a test on its own
+        self.assertEqual(self.ui.loading_animation, expected,
+                         'indicator is the correct animation')
+
+
+class MagicicadaUIBasicTestCase(MagicicadaUITestCase):
+    """UI test cases for basic state."""
+
     def test_init_creates_sd_instance(self):
         """SyncDaemon instance is created at creation time."""
-        self.assertTrue(isinstance(self.ui.sd, SyncDaemon))
+        self.assertTrue(self.ui.sd is not None)
+        self.assertTrue(isinstance(self.ui.sd, FakedSyncdaemon))
 
     def test_destroy_shutdowns_sd_instance(self):
         """SyncDaemon instance is shutdown at destroy time."""
-        self.patch(self.ui.sd, 'shutdown',
-                   lambda *_: setattr(self, '_called', True))
+        self.patch(self.ui.sd, 'shutdown', self.set_called)
         self.ui.on_main_window_destroy(self.ui.main_window)
         self.assertTrue(self._called,
                         'syncdaemon.shutdown must be called at destroy time.')
 
-
-class MagicicadaUIStartupTestCase(MagicicadaUITestCase):
-    """UI test cases for startup state."""
-
     def test_main_window_is_visible(self):
         """UI can be created."""
         self.assertTrue(self.ui.main_window.get_property('visible'))
@@ -99,52 +129,110 @@
         self.assertFalse(self.ui.stop.get_property('visible'))
         self.assertFalse(self.ui.disconnect.get_property('visible'))
 
-    def test_not_started_not_connected_not_online(self):
-        """Test default values for flags."""
-        self.assertFalse(self.ui.started)
-        self.assertFalse(self.ui.connected)
-        self.assertFalse(self.ui.online)
-
     def test_indicators_are_non_sensitive(self):
         """Test default sensitivity for indicators."""
-        #import pdb; pdb.set_trace()
         self.assertFalse(self.ui.is_started.is_sensitive())
         self.assertFalse(self.ui.is_connected.is_sensitive())
         self.assertFalse(self.ui.is_online.is_sensitive())
 
+    def test_update_is_correct(self):
+        """Update updates."""
+		# XXX: TODO
+
 
 class MagicicadaUIClickedTestCase(MagicicadaUITestCase):
     """UI test cases."""
 
-    def test_started_if_start_clicked(self):
-        """Test started if Start was clicked."""
+    def test_on_start_clicked(self):
+        """Test on_start_clicked."""
         self.ui.on_start_clicked(self.ui.start)
-        self.assertTrue(self.ui.started)
-        self.assertFalse(self.ui.connected)
-        self.assertFalse(self.ui.online)
 
-    def test_can_connect_can_stop_if_start_clicked(self):
-        """Test Connect and Stop are enabled if Start was 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.assertTrue(self.ui.connect.is_sensitive())
-
-    def test_connected_if_connect_clicked(self):
-        """Test connected if Connect was clicked."""
-        self.ui.on_start_clicked(self.ui.start) # need to be started
-        self.ui.on_connect_clicked(self.ui.connect)
-
-        self.assertTrue(self.ui.started)
-        self.assertTrue(self.ui.connected)
-        self.assertFalse(self.ui.online)
-
-    def test_can_disconnect_if_connect_clicked(self):
-        """Test Disconnect is enabled if Connect was clicked."""
-        self.ui.on_start_clicked(self.ui.start) # need to be started
-        self.ui.on_connect_clicked(self.ui.connect)
+        self.assertFalse(self.ui.stop.is_sensitive())
+
+        self.assert_indicator_loading(self.ui.is_started)
+        self.assert_indicator_disabled(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+
+    def test_on_start_clicked_starts_syncdaemon(self):
+        """Test on_start_clicked."""
+        self.patch(self.ui.sd, 'start', self.set_called)
+        self.ui.on_start_clicked(self.ui.start)
+        self.assertTrue(self._called, 'syncdaemon.start was called.')
+
+    def test_on_connect_clicked(self):
+        """Test on_connect_clicked."""
+        self.ui.on_start_clicked(self.ui.start) # need to be started
+        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.assert_indicator_ready(self.ui.is_started)
+        self.assert_indicator_loading(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+
+    def test_on_connect_clicked_connects_syncdaemon(self):
+        """Test on_connect_clicked."""
+        self.patch(self.ui.sd, 'connect', self.set_called)
+        self.ui.on_connect_clicked(self.ui.connect)
+        self.assertTrue(self._called, 'syncdaemon.connect was called.')
+
+    def test_on_stop_clicked(self):
+        """Test on_stop_clicked."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        assert not self.ui.widget_enabled(self.ui.disconnect)
+        self.patch(self.ui, 'on_disconnect_clicked', self.set_called)
+        self.ui.on_stop_clicked(self.ui.stop)
+
+        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.assertTrue(self.ui.connect.get_property('visible'))
+        self.assertFalse(self.ui.connect.is_sensitive())
+        self.assertFalse(self.ui.disconnect.get_property('visible'))
+
+    def test_on_stop_clicked_if_connected(self):
+        """Test on_stop_clicked."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        self.ui.on_connect_clicked(self.ui.connect)
+        self.ui.on_connected()
+        self.patch(self.ui, 'on_disconnect_clicked', self.set_called)
+        self.ui.on_stop_clicked(self.ui.stop)
+
+        self.assertTrue(self._called, 'on_disconnect_clicked was called.')
+
+    def test_on_stop_clicked_stops_syncdaemon(self):
+        """Test on_stop_clicked."""
+        self.patch(self.ui.sd, 'quit', self.set_called)
+        self.ui.on_stop_clicked(self.ui.stop)
+        self.assertTrue(self._called, 'syncdaemon.quit was called.')
+
+    def test_on_disconnect_clicked(self):
+        """Test on_disconnect_clicked."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        self.ui.on_connect_clicked(self.ui.connect)
+        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'))
+
+    def test_on_disconnect_clicked_disconnects_syncdaemon(self):
+        """Test on_disconnect_clicked."""
+        self.patch(self.ui.sd, 'disconnect', self.set_called)
+        self.ui.on_disconnect_clicked(self.ui.disconnect)
+        self.assertTrue(self._called, 'syncdaemon.disconnect was called.')
 
 
 class MagicicadaUISystrayIconTestCase(MagicicadaUITestCase):
@@ -165,7 +253,7 @@
 
 
 class _MagicicadaUIQueueTestCase(MagicicadaUITestCase):
-    """Abstratc UI test cases for a queue views."""
+    """Abstratc UI test cases for queue tree views."""
 
     queue = None
 
@@ -183,8 +271,9 @@
         """Build some data to pass to queue changed callback."""
         items = []
         for i in xrange(limit):
-            cq = QueueData(operation='operation %i' % i, path='path %i' % i,
-                           node='node %i' % i, share='share %i' % i)
+            cq = syncdaemon.QueueData(operation='operation %i' % i,
+                     path='path %i' % i, node='node %i' % i,
+                     share='share %i' % i)
             items.append(cq)
         return items
 
@@ -242,12 +331,143 @@
 
 
 class MagicicadaUIContentQueueTestCase(_MagicicadaUIQueueTestCase):
-    """UI test cases for content queue views."""
+    """UI test cases for content queue view."""
 
     queue = CONTENT_QUEUE
 
 
 class MagicicadaUIMetaQueueTestCase(_MagicicadaUIQueueTestCase):
-    """UI test cases for meta queue views."""
+    """UI test cases for meta queue view."""
 
     queue = META_QUEUE
+
+
+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,
+                         self.ui.on_status_changed,
+                         'status_changed callback must be set')
+
+    def test_on_status_changed_updates_status_label(self):
+        """On status changed the status label is updated."""
+        kwargs = dict(name='test', description='the status for testing',
+                      is_error=False, is_connected=True, is_online=False,
+                      queues=None, connection=None)
+        self.ui.on_status_changed(**kwargs)
+        self.assertEqual(self.ui.status_label.get_text(), kwargs['description'])
+
+
+class MagicicadaUIConnectionTestCase(MagicicadaUITestCase):
+    """UI test cases for."""
+
+    def setUp(self):
+        """Init."""
+        super(MagicicadaUIConnectionTestCase, self).setUp()
+
+    def test_all_disabled_at_startup(self):
+        """Indicators are all disabled at startup."""
+        self.assert_indicator_disabled(self.ui.is_started)
+        self.assert_indicator_disabled(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+
+    def test_callback_are_connected(self):
+        """Connection callbacks are connected."""
+        for callback in ('on_started', 'on_stopped',
+                         'on_connected', 'on_disconnected',
+                         'on_online', 'on_offline'):
+            sd_cb = getattr(self.ui.sd, '%s_callback' % callback)
+            ui_cb = getattr(self.ui, callback)
+            self.assertEqual(sd_cb, ui_cb,
+                             '%s callback must be set' % callback)
+
+    def test_on_started_is_correct(self):
+        """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.assert_indicator_ready(self.ui.is_started)
+        self.assert_indicator_disabled(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+
+    def test_on_connected_is_correct(self):
+        """On SD connected, the UI enables indicator."""
+        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.assert_indicator_ready(self.ui.is_started)
+        self.assert_indicator_ready(self.ui.is_connected)
+        self.assert_indicator_loading(self.ui.is_online)
+
+    def test_on_online_is_correct(self):
+        """On SD online, the UI enables indicator."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        self.ui.on_connect_clicked(self.ui.connect)
+        self.ui.on_connected()
+
+        self.ui.on_online()
+
+        self.assert_indicator_ready(self.ui.is_started)
+        self.assert_indicator_ready(self.ui.is_connected)
+        self.assert_indicator_ready(self.ui.is_online)
+
+    def test_on_stopped_is_correct(self):
+        """On SD stopped, the UI disables stop and indicator."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        self.ui.on_stop_clicked(self.ui.stop)
+
+        self.ui.on_stopped()
+
+        self.assertTrue(self.ui.start.is_sensitive())
+        self.assertTrue(self.ui.start.get_property('visible'))
+        self.assert_indicator_disabled(self.ui.is_started)
+        self.assert_indicator_disabled(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+
+    def test_on_disconnected_is_correct(self):
+        """On SD disconnected, the UI disables connect and indicator."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        self.ui.on_connect_clicked(self.ui.connect)
+        self.ui.on_connected()
+        self.ui.on_disconnect_clicked(self.ui.disconnect)
+
+        self.ui.on_disconnected()
+
+        self.assertTrue(self.ui.connect.is_sensitive())
+        self.assert_indicator_ready(self.ui.is_started)
+        self.assert_indicator_disabled(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+
+    def test_on_offline_is_correct(self):
+        """On SD offline, the UI disables indicator."""
+        self.ui.on_start_clicked(self.ui.start)
+        self.ui.on_started()
+        self.ui.on_connect_clicked(self.ui.connect)
+        self.ui.on_connected()
+
+        self.ui.on_offline()
+
+        self.assert_indicator_ready(self.ui.is_started)
+        self.assert_indicator_ready(self.ui.is_connected)
+        self.assert_indicator_disabled(self.ui.is_online)
+