Merge lp:~nataliabidart/magicicada-gui/set-initial-state into lp:magicicada-gui
- set-initial-state
- Merge into trunk
Proposed by
Natalia Bidart
Status: | Merged | ||||||||
---|---|---|---|---|---|---|---|---|---|
Approved by: | Facundo Batista | ||||||||
Approved revision: | 26 | ||||||||
Merged at revision: | 23 | ||||||||
Proposed branch: | lp:~nataliabidart/magicicada-gui/set-initial-state | ||||||||
Merge into: | lp:magicicada-gui | ||||||||
Diff against target: |
520 lines (+169/-100) 3 files modified
magicicada/__init__.py (+60/-35) magicicada/syncdaemon.py (+7/-0) magicicada/tests/test_magicicada.py (+102/-65) |
||||||||
To merge this branch: | bzr merge lp:~nataliabidart/magicicada-gui/set-initial-state | ||||||||
Related bugs: |
|
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
chicharreros | Pending | ||
Review via email: mp+25834@code.launchpad.net |
Commit message
Description of the change
GUI updates the initial state based on syncdaemon.
Also fixed some glitches on buttons sensitivity and visibility.
To post a comment you must log in.
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === modified file 'magicicada/__init__.py' | |||
2 | --- magicicada/__init__.py 2010-05-22 03:19:12 +0000 | |||
3 | +++ magicicada/__init__.py 2010-05-23 10:42:26 +0000 | |||
4 | @@ -29,7 +29,7 @@ | |||
5 | 29 | gtk2reactor.install() | 29 | gtk2reactor.install() |
6 | 30 | 30 | ||
7 | 31 | from magicicada import syncdaemon | 31 | from magicicada import syncdaemon |
9 | 32 | from magicicada.helpers import get_data_file, get_builder, NO_OP | 32 | from magicicada.helpers import get_data_file, get_builder, NO_OP, print_debug |
10 | 33 | 33 | ||
11 | 34 | CONTENT_QUEUE = 'content' | 34 | CONTENT_QUEUE = 'content' |
12 | 35 | META_QUEUE = 'meta' | 35 | META_QUEUE = 'meta' |
13 | @@ -39,7 +39,6 @@ | |||
14 | 39 | STATUS = { | 39 | STATUS = { |
15 | 40 | 'started': _('Service started, click Connect to continue.'), | 40 | 'started': _('Service started, click Connect to continue.'), |
16 | 41 | 'connected': _('Service connected. Doing internal synchronization...'), | 41 | 'connected': _('Service connected. Doing internal synchronization...'), |
17 | 42 | 'online': _('Service reached Nirvana.'), | ||
18 | 43 | } | 42 | } |
19 | 44 | 43 | ||
20 | 45 | def __init__(self, launchpad_available=False, on_destroy=NO_OP, | 44 | def __init__(self, launchpad_available=False, on_destroy=NO_OP, |
21 | @@ -96,6 +95,8 @@ | |||
22 | 96 | self.widget_enabled = lambda w: \ | 95 | self.widget_enabled = lambda w: \ |
23 | 97 | w.get_property('visible') and w.is_sensitive() | 96 | w.get_property('visible') and w.is_sensitive() |
24 | 98 | 97 | ||
25 | 98 | self.update() | ||
26 | 99 | |||
27 | 99 | # GTK callbacks | 100 | # GTK callbacks |
28 | 100 | 101 | ||
29 | 101 | def on_main_window_destroy(self, widget, data=None): | 102 | def on_main_window_destroy(self, widget, data=None): |
30 | @@ -118,10 +119,8 @@ | |||
31 | 118 | def on_start_clicked(self, widget, data=None): | 119 | def on_start_clicked(self, widget, data=None): |
32 | 119 | """Start syncdaemon.""" | 120 | """Start syncdaemon.""" |
33 | 120 | self.sd.start() | 121 | self.sd.start() |
38 | 121 | self.start.hide() | 122 | self.start.set_sensitive(False) |
39 | 122 | self.stop.set_sensitive(False) | 123 | self._start_loading(self.is_started) |
36 | 123 | self.stop.show() | ||
37 | 124 | self.start_loading(self.is_started) | ||
40 | 125 | 124 | ||
41 | 126 | def on_stop_clicked(self, widget, data=None): | 125 | def on_stop_clicked(self, widget, data=None): |
42 | 127 | """Stop syncdaemon.""" | 126 | """Stop syncdaemon.""" |
43 | @@ -129,28 +128,21 @@ | |||
44 | 129 | self.on_disconnect_clicked(self.disconnect) | 128 | self.on_disconnect_clicked(self.disconnect) |
45 | 130 | self.connect.set_sensitive(False) | 129 | self.connect.set_sensitive(False) |
46 | 131 | 130 | ||
51 | 132 | self.start.show() | 131 | self.stop.set_sensitive(False) |
48 | 133 | self.start.set_sensitive(False) | ||
49 | 134 | self.stop.hide() | ||
50 | 135 | |||
52 | 136 | self.sd.quit() | 132 | self.sd.quit() |
53 | 137 | 133 | ||
54 | 138 | def on_connect_clicked(self, widget, data=None): | 134 | def on_connect_clicked(self, widget, data=None): |
55 | 139 | """Connect syncdaemon.""" | 135 | """Connect syncdaemon.""" |
56 | 140 | self.sd.connect() | 136 | self.sd.connect() |
61 | 141 | self.connect.hide() | 137 | self.connect.set_sensitive(False) |
62 | 142 | self.disconnect.set_sensitive(False) | 138 | self._start_loading(self.is_connected) |
59 | 143 | self.disconnect.show() | ||
60 | 144 | self.start_loading(self.is_connected) | ||
63 | 145 | 139 | ||
64 | 146 | def on_disconnect_clicked(self, widget, data=None): | 140 | def on_disconnect_clicked(self, widget, data=None): |
65 | 147 | """Disconnect syncdaemon.""" | 141 | """Disconnect syncdaemon.""" |
70 | 148 | self.connect.show() | 142 | self.disconnect.set_sensitive(False) |
67 | 149 | self.connect.set_sensitive(False) | ||
68 | 150 | self.disconnect.hide() | ||
69 | 151 | |||
71 | 152 | self.sd.disconnect() | 143 | self.sd.disconnect() |
72 | 153 | 144 | ||
73 | 145 | @print_debug | ||
74 | 154 | def on_status_icon_activate(self, widget, data=None): | 146 | def on_status_icon_activate(self, widget, data=None): |
75 | 155 | """Systray icon was clicked.""" | 147 | """Systray icon was clicked.""" |
76 | 156 | if self.main_window.get_property('visible'): | 148 | if self.main_window.get_property('visible'): |
77 | @@ -158,48 +150,60 @@ | |||
78 | 158 | else: | 150 | else: |
79 | 159 | self.main_window.show() | 151 | self.main_window.show() |
80 | 160 | 152 | ||
82 | 161 | # DBus callbacks | 153 | # SyncDaemon callbacks |
83 | 162 | 154 | ||
84 | 163 | def on_started(self, *args, **kwargs): | 155 | def on_started(self, *args, **kwargs): |
85 | 164 | """Callback'ed when syncadaemon is started.""" | 156 | """Callback'ed when syncadaemon is started.""" |
86 | 157 | self.start.hide() | ||
87 | 158 | self.stop.show() | ||
88 | 165 | self.stop.set_sensitive(True) | 159 | self.stop.set_sensitive(True) |
90 | 166 | self.activate_indicator(self.is_started) | 160 | self._activate_indicator(self.is_started) |
91 | 167 | self.connect.set_sensitive(True) | 161 | self.connect.set_sensitive(True) |
92 | 168 | 162 | ||
93 | 169 | def on_stopped(self, *args, **kwargs): | 163 | def on_stopped(self, *args, **kwargs): |
94 | 170 | """Callback'ed when syncadaemon is stopped.""" | 164 | """Callback'ed when syncadaemon is stopped.""" |
95 | 165 | self.stop.hide() | ||
96 | 166 | self.start.show() | ||
97 | 171 | self.start.set_sensitive(True) | 167 | self.start.set_sensitive(True) |
98 | 168 | self.connect.set_sensitive(False) | ||
99 | 172 | 169 | ||
103 | 173 | self.activate_indicator(self.is_started, sensitive=False) | 170 | self._activate_indicator(self.is_started, sensitive=False) |
104 | 174 | self.activate_indicator(self.is_connected, sensitive=False) | 171 | self._activate_indicator(self.is_connected, sensitive=False) |
105 | 175 | self.activate_indicator(self.is_online, sensitive=False) | 172 | self._activate_indicator(self.is_online, sensitive=False) |
106 | 176 | 173 | ||
107 | 177 | def on_connected(self, *args, **kwargs): | 174 | def on_connected(self, *args, **kwargs): |
108 | 178 | """Callback'ed when syncadaemon is connected.""" | 175 | """Callback'ed when syncadaemon is connected.""" |
109 | 176 | self.connect.hide() | ||
110 | 177 | self.disconnect.show() | ||
111 | 179 | self.disconnect.set_sensitive(True) | 178 | self.disconnect.set_sensitive(True) |
115 | 180 | self.activate_indicator(self.is_connected) | 179 | self._activate_indicator(self.is_connected) |
116 | 181 | self.start_loading(self.is_online) | 180 | self._start_loading(self.is_online) |
117 | 182 | self.start_loading(self.is_online) | 181 | self._start_loading(self.is_online) |
118 | 183 | 182 | ||
119 | 184 | def on_disconnected(self, *args, **kwargs): | 183 | def on_disconnected(self, *args, **kwargs): |
120 | 185 | """Callback'ed when syncadaemon is disconnected.""" | 184 | """Callback'ed when syncadaemon is disconnected.""" |
121 | 185 | self.disconnect.hide() | ||
122 | 186 | self.connect.show() | ||
123 | 186 | self.connect.set_sensitive(True) | 187 | self.connect.set_sensitive(True) |
124 | 187 | 188 | ||
127 | 188 | self.activate_indicator(self.is_connected, sensitive=False) | 189 | self._activate_indicator(self.is_connected, sensitive=False) |
128 | 189 | self.activate_indicator(self.is_online, sensitive=False) | 190 | self._activate_indicator(self.is_online, sensitive=False) |
129 | 190 | 191 | ||
130 | 191 | def on_online(self, *args, **kwargs): | 192 | def on_online(self, *args, **kwargs): |
131 | 192 | """Callback'ed when syncadaemon is online.""" | 193 | """Callback'ed when syncadaemon is online.""" |
132 | 193 | self.is_online.set_sensitive(True) | 194 | self.is_online.set_sensitive(True) |
134 | 194 | self.activate_indicator(self.is_online) | 195 | self._activate_indicator(self.is_online) |
135 | 195 | 196 | ||
136 | 196 | def on_offline(self, *args, **kwargs): | 197 | def on_offline(self, *args, **kwargs): |
137 | 197 | """Callback'ed when syncadaemon is offline.""" | 198 | """Callback'ed when syncadaemon is offline.""" |
139 | 198 | self.activate_indicator(self.is_online, sensitive=False) | 199 | self._activate_indicator(self.is_online, sensitive=False) |
140 | 199 | 200 | ||
143 | 200 | def on_status_changed(self, name, description, is_error, is_connected, | 201 | def on_status_changed(self, name=None, description=None, |
144 | 201 | is_online, queues, connection): | 202 | is_error=False, is_connected=True, |
145 | 203 | is_online=True, queues=None, connection=None): | ||
146 | 202 | """Callback'ed when the SD status changed.""" | 204 | """Callback'ed when the SD status changed.""" |
147 | 205 | if description is None: | ||
148 | 206 | description = '' | ||
149 | 203 | self.status_label.set_text(description) | 207 | self.status_label.set_text(description) |
150 | 204 | 208 | ||
151 | 205 | def _on_queue_changed(self, queue_name, items, *args, **kwargs): | 209 | def _on_queue_changed(self, queue_name, items, *args, **kwargs): |
152 | @@ -211,7 +215,7 @@ | |||
153 | 211 | row = (item.operation, item.path, item.node, item.share) | 215 | row = (item.operation, item.path, item.node, item.share) |
154 | 212 | queue_store.append(row) | 216 | queue_store.append(row) |
155 | 213 | 217 | ||
157 | 214 | if not queue_view.is_sensitive(): | 218 | if not queue_view.is_sensitive() and len(items) > 0: |
158 | 215 | queue_view.set_sensitive(True) | 219 | queue_view.set_sensitive(True) |
159 | 216 | 220 | ||
160 | 217 | def on_content_queue_changed(self, items, *args, **kwargs): | 221 | def on_content_queue_changed(self, items, *args, **kwargs): |
161 | @@ -224,12 +228,33 @@ | |||
162 | 224 | 228 | ||
163 | 225 | # custom | 229 | # custom |
164 | 226 | 230 | ||
166 | 227 | def start_loading(self, what): | 231 | def _start_loading(self, what): |
167 | 228 | """Set a loader animation on 'what'.""" | 232 | """Set a loader animation on 'what'.""" |
168 | 229 | what.set_sensitive(True) | 233 | what.set_sensitive(True) |
169 | 230 | what.set_from_animation(self.loading_animation) | 234 | what.set_from_animation(self.loading_animation) |
170 | 231 | 235 | ||
172 | 232 | def activate_indicator(self, what, sensitive=True): | 236 | def _activate_indicator(self, what, sensitive=True): |
173 | 233 | """Set ready pixbuf on 'what' and make it 'sensitive'.""" | 237 | """Set ready pixbuf on 'what' and make it 'sensitive'.""" |
174 | 234 | what.set_sensitive(sensitive) | 238 | what.set_sensitive(sensitive) |
175 | 235 | what.set_from_pixbuf(self.active_indicator) | 239 | what.set_from_pixbuf(self.active_indicator) |
176 | 240 | |||
177 | 241 | def update(self): | ||
178 | 242 | """Update UI based on SD current state.""" | ||
179 | 243 | current_state = self.sd.current_state | ||
180 | 244 | |||
181 | 245 | self._activate_indicator(self.is_online, | ||
182 | 246 | sensitive=current_state.is_online) | ||
183 | 247 | |||
184 | 248 | if current_state.is_started: | ||
185 | 249 | self.on_started() | ||
186 | 250 | if current_state.is_connected: | ||
187 | 251 | self.on_connected() | ||
188 | 252 | else: | ||
189 | 253 | self.on_disconnected() | ||
190 | 254 | else: | ||
191 | 255 | self.on_disconnected() | ||
192 | 256 | self.on_stopped() | ||
193 | 257 | |||
194 | 258 | self.on_meta_queue_changed(self.sd.meta_queue) | ||
195 | 259 | self.on_content_queue_changed(self.sd.content_queue) | ||
196 | 260 | self.on_status_changed(description=current_state.description) | ||
197 | 236 | 261 | ||
198 | === modified file 'magicicada/syncdaemon.py' | |||
199 | --- magicicada/syncdaemon.py 2010-05-22 20:27:11 +0000 | |||
200 | +++ magicicada/syncdaemon.py 2010-05-23 10:42:26 +0000 | |||
201 | @@ -85,6 +85,13 @@ | |||
202 | 85 | raise AttributeError("Name not in _attrs: %r" % name) | 85 | raise AttributeError("Name not in _attrs: %r" % name) |
203 | 86 | self.__dict__[name] = value | 86 | self.__dict__[name] = value |
204 | 87 | 87 | ||
205 | 88 | def __str__(self): | ||
206 | 89 | """String representation.""" | ||
207 | 90 | result = [] | ||
208 | 91 | for attr in self._attrs: | ||
209 | 92 | result.append("%s=%s" % (attr, getattr(self, attr))) | ||
210 | 93 | return "<%s>" % ", ".join(result) | ||
211 | 94 | |||
212 | 88 | 95 | ||
213 | 89 | class SyncDaemon(object): | 96 | class SyncDaemon(object): |
214 | 90 | """Interface to Ubuntu One's SyncDaemon.""" | 97 | """Interface to Ubuntu One's SyncDaemon.""" |
215 | 91 | 98 | ||
216 | === modified file 'magicicada/tests/test_magicicada.py' | |||
217 | --- magicicada/tests/test_magicicada.py 2010-05-22 03:19:12 +0000 | |||
218 | +++ magicicada/tests/test_magicicada.py 2010-05-23 10:42:26 +0000 | |||
219 | @@ -18,28 +18,10 @@ | |||
220 | 18 | 18 | ||
221 | 19 | """Tests for magicicada.""" | 19 | """Tests for magicicada.""" |
222 | 20 | 20 | ||
223 | 21 | import gobject | ||
224 | 22 | import gtk | ||
225 | 23 | import unittest | ||
226 | 24 | |||
227 | 25 | from functools import wraps | ||
228 | 26 | |||
229 | 27 | from twisted.trial.unittest import TestCase | 21 | from twisted.trial.unittest import TestCase |
230 | 28 | 22 | ||
231 | 29 | from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, syncdaemon | 23 | from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, syncdaemon |
245 | 30 | from magicicada.helpers import get_builder, NO_OP | 24 | from magicicada.helpers import NO_OP |
233 | 31 | |||
234 | 32 | DEFAULT_TIMEOUT = 200 | ||
235 | 33 | |||
236 | 34 | def close_window_after(a_test): | ||
237 | 35 | """Decorator to close the main window after executing f.""" | ||
238 | 36 | @wraps(a_test) | ||
239 | 37 | def inner(*args, **kwargs): | ||
240 | 38 | """Inner function.""" | ||
241 | 39 | #gobject.timeout_add(DEFAULT_TIMEOUT, a_test) | ||
242 | 40 | #self.ui.run() | ||
243 | 41 | |||
244 | 42 | return inner | ||
246 | 43 | 25 | ||
247 | 44 | 26 | ||
248 | 45 | class FakedSyncdaemon(object): | 27 | class FakedSyncdaemon(object): |
249 | @@ -61,13 +43,16 @@ | |||
250 | 61 | self.connect = NO_OP | 43 | self.connect = NO_OP |
251 | 62 | self.disconnect = NO_OP | 44 | self.disconnect = NO_OP |
252 | 63 | 45 | ||
253 | 46 | self.current_state = syncdaemon.State() | ||
254 | 47 | self.meta_queue = [] | ||
255 | 48 | self.content_queue = [] | ||
256 | 49 | |||
257 | 64 | 50 | ||
258 | 65 | class MagicicadaUITestCase(TestCase): | 51 | class MagicicadaUITestCase(TestCase): |
259 | 66 | """UI test cases for Magicicada UI.""" | 52 | """UI test cases for Magicicada UI.""" |
260 | 67 | 53 | ||
261 | 68 | def setUp(self): | 54 | def setUp(self): |
262 | 69 | """Init.""" | 55 | """Init.""" |
263 | 70 | self.builder = get_builder('gui.glade') | ||
264 | 71 | self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon) | 56 | self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon) |
265 | 72 | self._called = False | 57 | self._called = False |
266 | 73 | self.set_called = lambda *_: setattr(self, '_called', True) | 58 | self.set_called = lambda *_: setattr(self, '_called', True) |
267 | @@ -76,7 +61,6 @@ | |||
268 | 76 | """Cleanup.""" | 61 | """Cleanup.""" |
269 | 77 | self.ui.on_main_window_destroy(self.ui.main_window) | 62 | self.ui.on_main_window_destroy(self.ui.main_window) |
270 | 78 | self._called = False | 63 | self._called = False |
271 | 79 | self.builder = None | ||
272 | 80 | 64 | ||
273 | 81 | def assert_indicator_disabled(self, indicator): | 65 | def assert_indicator_disabled(self, indicator): |
274 | 82 | """Test that 'indicator' is not sensitive.""" | 66 | """Test that 'indicator' is not sensitive.""" |
275 | @@ -136,8 +120,11 @@ | |||
276 | 136 | self.assertFalse(self.ui.is_online.is_sensitive()) | 120 | self.assertFalse(self.ui.is_online.is_sensitive()) |
277 | 137 | 121 | ||
278 | 138 | def test_update_is_correct(self): | 122 | def test_update_is_correct(self): |
281 | 139 | """Update updates.""" | 123 | """Update is called at startup.""" |
282 | 140 | # XXX: TODO | 124 | self.patch(MagicicadaUI, 'update', self.set_called) |
283 | 125 | self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon) | ||
284 | 126 | self.assertTrue(self._called, | ||
285 | 127 | 'update was called at startup.') | ||
286 | 141 | 128 | ||
287 | 142 | 129 | ||
288 | 143 | class MagicicadaUIClickedTestCase(MagicicadaUITestCase): | 130 | class MagicicadaUIClickedTestCase(MagicicadaUITestCase): |
289 | @@ -147,9 +134,9 @@ | |||
290 | 147 | """Test on_start_clicked.""" | 134 | """Test on_start_clicked.""" |
291 | 148 | self.ui.on_start_clicked(self.ui.start) | 135 | self.ui.on_start_clicked(self.ui.start) |
292 | 149 | 136 | ||
296 | 150 | self.assertFalse(self.ui.start.get_property('visible')) | 137 | self.assertTrue(self.ui.start.get_property('visible')) |
297 | 151 | self.assertTrue(self.ui.stop.get_property('visible')) | 138 | self.assertFalse(self.ui.start.is_sensitive()) |
298 | 152 | self.assertFalse(self.ui.stop.is_sensitive()) | 139 | self.assertFalse(self.ui.stop.get_property('visible')) |
299 | 153 | 140 | ||
300 | 154 | self.assert_indicator_loading(self.ui.is_started) | 141 | self.assert_indicator_loading(self.ui.is_started) |
301 | 155 | self.assert_indicator_disabled(self.ui.is_connected) | 142 | self.assert_indicator_disabled(self.ui.is_connected) |
302 | @@ -167,9 +154,9 @@ | |||
303 | 167 | self.ui.on_started() | 154 | self.ui.on_started() |
304 | 168 | self.ui.on_connect_clicked(self.ui.connect) | 155 | self.ui.on_connect_clicked(self.ui.connect) |
305 | 169 | 156 | ||
309 | 170 | self.assertFalse(self.ui.connect.get_property('visible')) | 157 | self.assertTrue(self.ui.connect.get_property('visible')) |
310 | 171 | self.assertTrue(self.ui.disconnect.get_property('visible')) | 158 | self.assertFalse(self.ui.connect.is_sensitive()) |
311 | 172 | self.assertFalse(self.ui.disconnect.is_sensitive()) | 159 | self.assertFalse(self.ui.disconnect.get_property('visible')) |
312 | 173 | 160 | ||
313 | 174 | self.assert_indicator_ready(self.ui.is_started) | 161 | self.assert_indicator_ready(self.ui.is_started) |
314 | 175 | self.assert_indicator_loading(self.ui.is_connected) | 162 | self.assert_indicator_loading(self.ui.is_connected) |
315 | @@ -191,9 +178,9 @@ | |||
316 | 191 | 178 | ||
317 | 192 | self.assertFalse(self._called, 'on_disconnect_clicked was not called.') | 179 | self.assertFalse(self._called, 'on_disconnect_clicked was not called.') |
318 | 193 | 180 | ||
322 | 194 | self.assertTrue(self.ui.start.get_property('visible')) | 181 | self.assertFalse(self.ui.start.get_property('visible')) |
323 | 195 | self.assertFalse(self.ui.start.is_sensitive()) | 182 | self.assertTrue(self.ui.stop.get_property('visible')) |
324 | 196 | self.assertFalse(self.ui.stop.get_property('visible')) | 183 | self.assertFalse(self.ui.stop.is_sensitive()) |
325 | 197 | 184 | ||
326 | 198 | self.assertTrue(self.ui.connect.get_property('visible')) | 185 | self.assertTrue(self.ui.connect.get_property('visible')) |
327 | 199 | self.assertFalse(self.ui.connect.is_sensitive()) | 186 | self.assertFalse(self.ui.connect.is_sensitive()) |
328 | @@ -224,9 +211,9 @@ | |||
329 | 224 | self.ui.on_connected() | 211 | self.ui.on_connected() |
330 | 225 | self.ui.on_disconnect_clicked(self.ui.disconnect) | 212 | self.ui.on_disconnect_clicked(self.ui.disconnect) |
331 | 226 | 213 | ||
335 | 227 | self.assertTrue(self.ui.connect.get_property('visible')) | 214 | self.assertFalse(self.ui.connect.get_property('visible')) |
336 | 228 | self.assertFalse(self.ui.connect.is_sensitive()) | 215 | self.assertTrue(self.ui.disconnect.get_property('visible')) |
337 | 229 | self.assertFalse(self.ui.disconnect.get_property('visible')) | 216 | self.assertFalse(self.ui.disconnect.is_sensitive()) |
338 | 230 | 217 | ||
339 | 231 | def test_on_disconnect_clicked_disconnects_syncdaemon(self): | 218 | def test_on_disconnect_clicked_disconnects_syncdaemon(self): |
340 | 232 | """Test on_disconnect_clicked.""" | 219 | """Test on_disconnect_clicked.""" |
341 | @@ -268,7 +255,7 @@ | |||
342 | 268 | self.queue_view = getattr(self.ui, '%sq_view' % self.queue) | 255 | self.queue_view = getattr(self.ui, '%sq_view' % self.queue) |
343 | 269 | 256 | ||
344 | 270 | def build_some_data(self, limit=5): | 257 | def build_some_data(self, limit=5): |
346 | 271 | """Build some data to pass to queue changed callback.""" | 258 | """Build some data to pass to queue changed callback and related.""" |
347 | 272 | items = [] | 259 | items = [] |
348 | 273 | for i in xrange(limit): | 260 | for i in xrange(limit): |
349 | 274 | cq = syncdaemon.QueueData(operation='operation %i' % i, | 261 | cq = syncdaemon.QueueData(operation='operation %i' % i, |
350 | @@ -277,6 +264,25 @@ | |||
351 | 277 | items.append(cq) | 264 | items.append(cq) |
352 | 278 | return items | 265 | return items |
353 | 279 | 266 | ||
354 | 267 | def assert_queue_store_correct(self, queue_store, items): | ||
355 | 268 | """Test that 'queue_store' has 'items' as content.""" | ||
356 | 269 | msg = 'amount of rows for %s must be %s (got %s).' | ||
357 | 270 | self.assertEqual(len(queue_store), len(items), | ||
358 | 271 | msg % (queue_store, len(items), len(queue_store))) | ||
359 | 272 | # assert rows content equal to items content | ||
360 | 273 | tree_iter = queue_store.get_iter_root() | ||
361 | 274 | tmp = list(reversed(items)) | ||
362 | 275 | while tree_iter is not None: | ||
363 | 276 | expected = tmp.pop() | ||
364 | 277 | |||
365 | 278 | op, path, node, share = queue_store.get(tree_iter, 0, 1, 2, 3) | ||
366 | 279 | self.assertEqual(expected.operation, op) | ||
367 | 280 | self.assertEqual(expected.path, path) | ||
368 | 281 | self.assertEqual(expected.node, node) | ||
369 | 282 | self.assertEqual(expected.share, share) | ||
370 | 283 | |||
371 | 284 | tree_iter = queue_store.iter_next(tree_iter) | ||
372 | 285 | |||
373 | 280 | def test_callback_is_connected(self): | 286 | def test_callback_is_connected(self): |
374 | 281 | """Queue changed callback is connected.""" | 287 | """Queue changed callback is connected.""" |
375 | 282 | self.assertEqual(self.sd_changed, self.ui_changed, | 288 | self.assertEqual(self.sd_changed, self.ui_changed, |
376 | @@ -293,22 +299,7 @@ | |||
377 | 293 | """On queue changed the view is updated.""" | 299 | """On queue changed the view is updated.""" |
378 | 294 | items = self.build_some_data() | 300 | items = self.build_some_data() |
379 | 295 | self.sd_changed(items) | 301 | self.sd_changed(items) |
396 | 296 | 302 | self.assert_queue_store_correct(self.queue_store, items) | |
381 | 297 | self.assertEqual(len(self.queue_store), len(items)) | ||
382 | 298 | |||
383 | 299 | # assert rows content equal to items content | ||
384 | 300 | tree_iter = self.queue_store.get_iter_root() | ||
385 | 301 | tmp = list(reversed(items)) | ||
386 | 302 | while tree_iter is not None: | ||
387 | 303 | expected = tmp.pop() | ||
388 | 304 | |||
389 | 305 | op, path, node, share = self.queue_store.get(tree_iter, 0, 1, 2, 3) | ||
390 | 306 | self.assertEqual(expected.operation, op) | ||
391 | 307 | self.assertEqual(expected.path, path) | ||
392 | 308 | self.assertEqual(expected.node, node) | ||
393 | 309 | self.assertEqual(expected.share, share) | ||
394 | 310 | |||
395 | 311 | tree_iter = self.queue_store.iter_next(tree_iter) | ||
397 | 312 | 303 | ||
398 | 313 | def test_model_is_cleared_before_updating(self): | 304 | def test_model_is_cleared_before_updating(self): |
399 | 314 | """The model is cleared before upadting with a new set of data.""" | 305 | """The model is cleared before upadting with a new set of data.""" |
400 | @@ -329,6 +320,15 @@ | |||
401 | 329 | self.assertTrue(self.queue_view.is_sensitive(), | 320 | self.assertTrue(self.queue_view.is_sensitive(), |
402 | 330 | 'Tree view must be enabled on changed.') | 321 | 'Tree view must be enabled on changed.') |
403 | 331 | 322 | ||
404 | 323 | def test_update_is_correct_for_queue(self): | ||
405 | 324 | """Correctly updates the queue state.""" | ||
406 | 325 | data = self.build_some_data() | ||
407 | 326 | setattr(self.ui.sd, '%s_queue' % self.queue, data) | ||
408 | 327 | |||
409 | 328 | self.ui.update() | ||
410 | 329 | |||
411 | 330 | self.assert_queue_store_correct(self.queue_store, data) | ||
412 | 331 | |||
413 | 332 | 332 | ||
414 | 333 | class MagicicadaUIContentQueueTestCase(_MagicicadaUIQueueTestCase): | 333 | class MagicicadaUIContentQueueTestCase(_MagicicadaUIQueueTestCase): |
415 | 334 | """UI test cases for content queue view.""" | 334 | """UI test cases for content queue view.""" |
416 | @@ -345,10 +345,6 @@ | |||
417 | 345 | class MagicicadaUIStatusTestCase(MagicicadaUITestCase): | 345 | class MagicicadaUIStatusTestCase(MagicicadaUITestCase): |
418 | 346 | """UI test cases for the status label.""" | 346 | """UI test cases for the status label.""" |
419 | 347 | 347 | ||
420 | 348 | def setUp(self): | ||
421 | 349 | """Init.""" | ||
422 | 350 | super(MagicicadaUIStatusTestCase, self).setUp() | ||
423 | 351 | |||
424 | 352 | def test_callback_is_connected(self): | 348 | def test_callback_is_connected(self): |
425 | 353 | """Status callback is connected.""" | 349 | """Status callback is connected.""" |
426 | 354 | self.assertEqual(self.ui.sd.status_changed_callback, | 350 | self.assertEqual(self.ui.sd.status_changed_callback, |
427 | @@ -363,13 +359,53 @@ | |||
428 | 363 | self.ui.on_status_changed(**kwargs) | 359 | self.ui.on_status_changed(**kwargs) |
429 | 364 | self.assertEqual(self.ui.status_label.get_text(), kwargs['description']) | 360 | self.assertEqual(self.ui.status_label.get_text(), kwargs['description']) |
430 | 365 | 361 | ||
431 | 362 | def test_update_is_correct_for_status_label(self): | ||
432 | 363 | """Correctly updates the status label.""" | ||
433 | 364 | expected = 'dummy test' | ||
434 | 365 | self.ui.sd.current_state._set(description=expected) | ||
435 | 366 | |||
436 | 367 | self.ui.update() | ||
437 | 368 | |||
438 | 369 | self.assertEqual(expected, self.ui.status_label.get_text()) | ||
439 | 370 | |||
440 | 366 | 371 | ||
441 | 367 | class MagicicadaUIConnectionTestCase(MagicicadaUITestCase): | 372 | class MagicicadaUIConnectionTestCase(MagicicadaUITestCase): |
442 | 368 | """UI test cases for.""" | 373 | """UI test cases for.""" |
443 | 369 | 374 | ||
447 | 370 | def setUp(self): | 375 | def assert_indicator_is_updated_correctly(self, indicator): |
448 | 371 | """Init.""" | 376 | """Test that correctly updates the 'indicator'.""" |
449 | 372 | super(MagicicadaUIConnectionTestCase, self).setUp() | 377 | cs = self.ui.sd.current_state |
450 | 378 | for expected in (True, False): | ||
451 | 379 | cs._set(**{indicator: expected}) | ||
452 | 380 | |||
453 | 381 | self.ui.update() | ||
454 | 382 | |||
455 | 383 | self.assertEqual(self.ui.widget_enabled(self.ui.start), | ||
456 | 384 | not cs.is_started, | ||
457 | 385 | 'start must be enabled if not started.') | ||
458 | 386 | self.assertEqual(self.ui.widget_enabled(self.ui.stop), | ||
459 | 387 | cs.is_started, | ||
460 | 388 | 'stop must be enabled if started.') | ||
461 | 389 | |||
462 | 390 | if cs.is_started: | ||
463 | 391 | actual = self.ui.widget_enabled(getattr(self.ui, indicator)) | ||
464 | 392 | self.assertEqual(expected, actual, | ||
465 | 393 | '%s must be %s' % (indicator, expected)) | ||
466 | 394 | |||
467 | 395 | self.assertEqual(self.ui.widget_enabled(self.ui.connect), | ||
468 | 396 | not cs.is_connected, | ||
469 | 397 | 'connect must be enabled if not connected.') | ||
470 | 398 | self.assertEqual(self.ui.widget_enabled(self.ui.disconnect), | ||
471 | 399 | cs.is_connected, | ||
472 | 400 | 'disconnect must be enabled if connected.') | ||
473 | 401 | else: | ||
474 | 402 | self.assertFalse(self.ui.connect.is_sensitive(), | ||
475 | 403 | 'connect must be disabled when %s' % cs) | ||
476 | 404 | self.assertTrue(self.ui.connect.get_property('visible'), | ||
477 | 405 | 'connect must be visible when %s' % cs) | ||
478 | 406 | actual = self.ui.widget_enabled(getattr(self.ui, indicator)) | ||
479 | 407 | self.assertFalse(actual, | ||
480 | 408 | '%s must be disabled' % (indicator,)) | ||
481 | 373 | 409 | ||
482 | 374 | def test_all_disabled_at_startup(self): | 410 | def test_all_disabled_at_startup(self): |
483 | 375 | """Indicators are all disabled at startup.""" | 411 | """Indicators are all disabled at startup.""" |
484 | @@ -391,13 +427,11 @@ | |||
485 | 391 | """On SD started, the UI enables connect and indicator.""" | 427 | """On SD started, the UI enables connect and indicator.""" |
486 | 392 | # must have click start first | 428 | # must have click start first |
487 | 393 | self.ui.on_start_clicked(self.ui.start) | 429 | self.ui.on_start_clicked(self.ui.start) |
488 | 394 | assert not self.ui.stop.is_sensitive() | ||
489 | 395 | assert not self.ui.connect.is_sensitive() | ||
490 | 396 | 430 | ||
491 | 397 | self.ui.on_started() | 431 | self.ui.on_started() |
492 | 398 | 432 | ||
495 | 399 | self.assertTrue(self.ui.stop.is_sensitive()) | 433 | self.assertTrue(self.ui.widget_enabled(self.ui.stop)) |
496 | 400 | self.assertTrue(self.ui.connect.is_sensitive()) | 434 | self.assertTrue(self.ui.widget_enabled(self.ui.connect)) |
497 | 401 | self.assert_indicator_ready(self.ui.is_started) | 435 | self.assert_indicator_ready(self.ui.is_started) |
498 | 402 | self.assert_indicator_disabled(self.ui.is_connected) | 436 | self.assert_indicator_disabled(self.ui.is_connected) |
499 | 403 | self.assert_indicator_disabled(self.ui.is_online) | 437 | self.assert_indicator_disabled(self.ui.is_online) |
500 | @@ -407,11 +441,10 @@ | |||
501 | 407 | self.ui.on_start_clicked(self.ui.start) | 441 | self.ui.on_start_clicked(self.ui.start) |
502 | 408 | self.ui.on_started() | 442 | self.ui.on_started() |
503 | 409 | self.ui.on_connect_clicked(self.ui.start) | 443 | self.ui.on_connect_clicked(self.ui.start) |
504 | 410 | assert not self.ui.disconnect.is_sensitive() | ||
505 | 411 | 444 | ||
506 | 412 | self.ui.on_connected() | 445 | self.ui.on_connected() |
507 | 413 | 446 | ||
509 | 414 | self.assertTrue(self.ui.disconnect.is_sensitive()) | 447 | self.assertTrue(self.ui.widget_enabled(self.ui.disconnect)) |
510 | 415 | self.assert_indicator_ready(self.ui.is_started) | 448 | self.assert_indicator_ready(self.ui.is_started) |
511 | 416 | self.assert_indicator_ready(self.ui.is_connected) | 449 | self.assert_indicator_ready(self.ui.is_connected) |
512 | 417 | self.assert_indicator_loading(self.ui.is_online) | 450 | self.assert_indicator_loading(self.ui.is_online) |
513 | @@ -471,3 +504,7 @@ | |||
514 | 471 | self.assert_indicator_ready(self.ui.is_connected) | 504 | self.assert_indicator_ready(self.ui.is_connected) |
515 | 472 | self.assert_indicator_disabled(self.ui.is_online) | 505 | self.assert_indicator_disabled(self.ui.is_online) |
516 | 473 | 506 | ||
517 | 507 | def test_update_is_correct_for_indicators_and_buttons(self): | ||
518 | 508 | """Correctly updates the indicators and buttons state.""" | ||
519 | 509 | for i in ('is_started', 'is_connected', 'is_online'): | ||
520 | 510 | self.assert_indicator_is_updated_correctly(i) |