Merge lp:~nataliabidart/ubuntuone-client/run-upload-run-stable-2-0 into lp:ubuntuone-client
- run-upload-run-stable-2-0
- Merge into trunk
Proposed by
Natalia Bidart
Status: | Superseded | ||||||||
---|---|---|---|---|---|---|---|---|---|
Proposed branch: | lp:~nataliabidart/ubuntuone-client/run-upload-run-stable-2-0 | ||||||||
Merge into: | lp:ubuntuone-client | ||||||||
Diff against target: |
2080 lines (+1928/-0) (has conflicts) 4 files modified
tests/platform/linux/test_dbus.py (+1685/-0) tests/platform/linux/test_notification.py (+7/-0) tests/status/test_aggregator.py (+5/-0) tests/syncdaemon/test_interaction_interfaces.py (+231/-0) Text conflict in tests/platform/linux/test_dbus.py Text conflict in tests/platform/linux/test_notification.py Text conflict in tests/status/test_aggregator.py Text conflict in tests/syncdaemon/test_interaction_interfaces.py |
||||||||
To merge this branch: | bzr merge lp:~nataliabidart/ubuntuone-client/run-upload-run-stable-2-0 | ||||||||
Related bugs: |
|
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
Ubuntu One hackers | Pending | ||
Review via email: mp+81472@code.launchpad.net |
Description of the change
To post a comment you must log in.
- 1144. By Natalia Bidart
-
All tests green, now for sure.
Unmerged revisions
- 1144. By Natalia Bidart
-
All tests green, now for sure.
- 1143. By Natalia Bidart
-
All tests are green now.
- 1142. By Natalia Bidart
-
- Make the Upload process do not close the tempfile until is finished
(LP: #872924).
- Reset the tempfile on every Upload _run() (LP: #884959). - 1141. By Facundo Batista
-
Fix filter by share and path (LP: #807737).
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === modified file 'tests/platform/linux/test_dbus.py' |
2 | --- tests/platform/linux/test_dbus.py 2011-10-28 15:30:54 +0000 |
3 | +++ tests/platform/linux/test_dbus.py 2011-11-07 17:17:24 +0000 |
4 | @@ -341,3 +341,1688 @@ |
5 | pass |
6 | return d |
7 | test_restart.skip = "leaves dbus stuff around, need to cleanup" |
8 | +<<<<<<< TREE |
9 | +======= |
10 | + |
11 | + |
12 | +class ConfigTests(DBusTwistedTestCase): |
13 | + """Basic tests to the Config object exposed via D-Bus.""" |
14 | + |
15 | + def get_client(self): |
16 | + """Return a Config DBusClient.""" |
17 | + return DBusClient(self.bus, '/config', DBUS_IFACE_CONFIG_NAME) |
18 | + |
19 | + def test_get_throttling_limits(self): |
20 | + """Test get_throttling_limits exposed method.""" |
21 | + client = self.get_client() |
22 | + d = defer.Deferred() |
23 | + aq = self.main.action_q |
24 | + def reply_handler(result): |
25 | + """Handle the reply.""" |
26 | + self.assertEquals(aq.readLimit, result['download']) |
27 | + self.assertEquals(aq.writeLimit, result['upload']) |
28 | + self.assertEquals(100, result['download']) |
29 | + self.assertEquals(200, result['upload']) |
30 | + d.callback(True) |
31 | + def reply_handler_None(result): |
32 | + """Handle the reply.""" |
33 | + self.assertEquals(-1, result['download']) |
34 | + self.assertEquals(-1, result['upload']) |
35 | + aq.readLimit = 100 |
36 | + aq.writeLimit = 200 |
37 | + client.call_method('get_throttling_limits', |
38 | + reply_handler=reply_handler, |
39 | + error_handler=self.error_handler) |
40 | + client.call_method('get_throttling_limits', |
41 | + reply_handler=reply_handler_None, |
42 | + error_handler=self.error_handler) |
43 | + return d |
44 | + |
45 | + |
46 | + def test_set_throttling_limits(self): |
47 | + """Test set_throttling_limits exposed method.""" |
48 | + client = self.get_client() |
49 | + d = defer.Deferred() |
50 | + def reply_handler(_): |
51 | + """Handle the reply.""" |
52 | + aq = self.main.action_q |
53 | + self.assertEquals(aq.readLimit, 100) |
54 | + self.assertEquals(aq.writeLimit, 500) |
55 | + d.callback(True) |
56 | + client.call_method('set_throttling_limits', 100, 500, |
57 | + reply_handler=reply_handler, |
58 | + error_handler=self.error_handler) |
59 | + return d |
60 | + |
61 | + def test_enable_bandwidth_throttling(self): |
62 | + """Test enable_bandwidth_throttling exposed method.""" |
63 | + client = self.get_client() |
64 | + d = defer.Deferred() |
65 | + aq = self.main.action_q |
66 | + aq.throttling = False |
67 | + def reply_handler(_): |
68 | + """Handle the reply.""" |
69 | + self.assertTrue(aq.throttling_enabled) |
70 | + d.callback(True) |
71 | + client.call_method('enable_bandwidth_throttling', |
72 | + reply_handler=reply_handler, |
73 | + error_handler=self.error_handler) |
74 | + return d |
75 | + |
76 | + def test_disable_bandwidth_throttling(self): |
77 | + """Test disable_bandwidth_throttling exposed method.""" |
78 | + client = self.get_client() |
79 | + d = defer.Deferred() |
80 | + aq = self.main.action_q |
81 | + aq.throttling = True |
82 | + def reply_handler(_): |
83 | + """Handle the reply.""" |
84 | + self.assertFalse(aq.throttling_enabled) |
85 | + d.callback(True) |
86 | + client.call_method('disable_bandwidth_throttling', |
87 | + reply_handler=reply_handler, |
88 | + error_handler=self.error_handler) |
89 | + return d |
90 | + |
91 | + def test_bandwidth_throttling_enabled(self): |
92 | + """Test bandwidth_throttling_enabled exposed method.""" |
93 | + client = self.get_client() |
94 | + d = defer.Deferred() |
95 | + def reply_handler_enabled(result): |
96 | + """Handle the reply.""" |
97 | + self.assertEquals(1, result) |
98 | + d.callback(True) |
99 | + |
100 | + def reply_handler_disabled(result): |
101 | + """Handle the reply.""" |
102 | + self.assertEquals(0, result) |
103 | + self.main.action_q.throttling_enabled = True |
104 | + client.call_method('bandwidth_throttling_enabled', |
105 | + reply_handler=reply_handler_enabled, |
106 | + error_handler=self.error_handler) |
107 | + client.call_method('bandwidth_throttling_enabled', |
108 | + reply_handler=reply_handler_disabled, |
109 | + error_handler=self.error_handler) |
110 | + return d |
111 | + |
112 | + def test_udf_autosubscribe_enabled(self): |
113 | + """Test for Config.udf_autosubscribe_enabled.""" |
114 | + client = self.get_client() |
115 | + d = defer.Deferred() |
116 | + |
117 | + def reply_handler_disabled(result): |
118 | + """Handle the reply.""" |
119 | + self.assertFalse(result) |
120 | + config.get_user_config().set_udf_autosubscribe(not result) |
121 | + client.call_method('udf_autosubscribe_enabled', |
122 | + reply_handler=reply_handler_enabled, |
123 | + error_handler=self.error_handler) |
124 | + |
125 | + def reply_handler_enabled(result): |
126 | + """Handle the reply.""" |
127 | + self.assertTrue(result) |
128 | + d.callback(True) |
129 | + |
130 | + client.call_method('udf_autosubscribe_enabled', |
131 | + reply_handler=reply_handler_disabled, |
132 | + error_handler=self.error_handler) |
133 | + return d |
134 | + |
135 | + def test_enable_udf_autosubscribe(self): |
136 | + """Test for Config.enable_udf_autosubscribe.""" |
137 | + client = self.get_client() |
138 | + d = defer.Deferred() |
139 | + def reply_handler(_): |
140 | + """Handle the reply.""" |
141 | + self.assertTrue(config.get_user_config().get_udf_autosubscribe()) |
142 | + d.callback(True) |
143 | + client.call_method('enable_udf_autosubscribe', |
144 | + reply_handler=reply_handler, |
145 | + error_handler=self.error_handler) |
146 | + return d |
147 | + |
148 | + def test_disable_udf_autosubscribe(self): |
149 | + """Test for Config.disable_udf_autosubscribe.""" |
150 | + client = self.get_client() |
151 | + d = defer.Deferred() |
152 | + def reply_handler(_): |
153 | + """Handle the reply.""" |
154 | + self.assertFalse(config.get_user_config().get_udf_autosubscribe()) |
155 | + d.callback(True) |
156 | + client.call_method('disable_udf_autosubscribe', |
157 | + reply_handler=reply_handler, |
158 | + error_handler=self.error_handler) |
159 | + return d |
160 | + |
161 | + def test_share_autosubscribe_enabled(self): |
162 | + """Test for Config.share_autosubscribe_enabled.""" |
163 | + client = self.get_client() |
164 | + d = defer.Deferred() |
165 | + |
166 | + def reply_handler_disabled(result): |
167 | + """Handle the reply.""" |
168 | + self.assertFalse(result) |
169 | + config.get_user_config().set_share_autosubscribe(not result) |
170 | + client.call_method('share_autosubscribe_enabled', |
171 | + reply_handler=reply_handler_enabled, |
172 | + error_handler=self.error_handler) |
173 | + |
174 | + def reply_handler_enabled(result): |
175 | + """Handle the reply.""" |
176 | + self.assertTrue(result) |
177 | + d.callback(True) |
178 | + |
179 | + client.call_method('share_autosubscribe_enabled', |
180 | + reply_handler=reply_handler_disabled, |
181 | + error_handler=self.error_handler) |
182 | + return d |
183 | + |
184 | + def test_enable_share_autosubscribe(self): |
185 | + """Test for Config.enable_share_autosubscribe.""" |
186 | + client = self.get_client() |
187 | + d = defer.Deferred() |
188 | + def reply_handler(_): |
189 | + """Handle the reply.""" |
190 | + self.assertTrue(config.get_user_config().get_share_autosubscribe()) |
191 | + d.callback(True) |
192 | + client.call_method('enable_share_autosubscribe', |
193 | + reply_handler=reply_handler, |
194 | + error_handler=self.error_handler) |
195 | + return d |
196 | + |
197 | + def test_disable_share_autosubscribe(self): |
198 | + """Test for Config.disable_share_autosubscribe.""" |
199 | + client = self.get_client() |
200 | + d = defer.Deferred() |
201 | + def reply_handler(_): |
202 | + """Handle the reply.""" |
203 | + self.assertFalse(config.get_user_config().get_share_autosubscribe()) |
204 | + d.callback(True) |
205 | + client.call_method('disable_share_autosubscribe', |
206 | + reply_handler=reply_handler, |
207 | + error_handler=self.error_handler) |
208 | + return d |
209 | + |
210 | + def test_autoconnect_enabled(self): |
211 | + """Test for Config.autoconnect_enabled.""" |
212 | + client = self.get_client() |
213 | + d = defer.Deferred() |
214 | + |
215 | + def reply_handler_disabled(result): |
216 | + """Handle the reply.""" |
217 | + self.assertFalse(result) |
218 | + config.get_user_config().set_autoconnect(not result) |
219 | + d.callback(True) |
220 | + |
221 | + def reply_handler_enabled(result): |
222 | + """Handle the reply.""" |
223 | + self.assertTrue(result) |
224 | + config.get_user_config().set_autoconnect(not result) |
225 | + client.call_method('autoconnect_enabled', |
226 | + reply_handler=reply_handler_disabled, |
227 | + error_handler=self.error_handler) |
228 | + |
229 | + client.call_method('autoconnect_enabled', |
230 | + reply_handler=reply_handler_enabled, |
231 | + error_handler=self.error_handler) |
232 | + return d |
233 | + |
234 | + def test_enable_autoconnect(self): |
235 | + """Test for Config.enable_autoconnect.""" |
236 | + client = self.get_client() |
237 | + d = defer.Deferred() |
238 | + orig = config.get_user_config().get_autoconnect() |
239 | + # restore autoconnect to original value |
240 | + self.addCleanup(config.get_user_config().set_autoconnect, orig) |
241 | + |
242 | + def reply_handler(_): |
243 | + """Handle the reply.""" |
244 | + self.assertTrue(config.get_user_config().get_autoconnect()) |
245 | + d.callback(True) |
246 | + |
247 | + client.call_method('enable_autoconnect', |
248 | + reply_handler=reply_handler, |
249 | + error_handler=self.error_handler) |
250 | + return d |
251 | + |
252 | + def test_disable_autoconnect(self): |
253 | + """Test for Config.disable_autoconnect.""" |
254 | + client = self.get_client() |
255 | + d = defer.Deferred() |
256 | + orig = config.get_user_config().get_autoconnect() |
257 | + # restore autoconnect to original value |
258 | + self.addCleanup(config.get_user_config().set_autoconnect, orig) |
259 | + |
260 | + def reply_handler(_): |
261 | + """Handle the reply.""" |
262 | + self.assertFalse(config.get_user_config().get_autoconnect()) |
263 | + d.callback(True) |
264 | + |
265 | + client.call_method('disable_autoconnect', |
266 | + reply_handler=reply_handler, |
267 | + error_handler=self.error_handler) |
268 | + return d |
269 | + |
270 | + def test_set_autoconnect_enabled(self): |
271 | + """Test for Config.set_autoconnect_enabled. |
272 | + |
273 | + DEPRECATED. |
274 | + |
275 | + """ |
276 | + client = self.get_client() |
277 | + d = defer.Deferred() |
278 | + orig = config.get_user_config().get_autoconnect() |
279 | + # restore autoconnect to original value |
280 | + self.addCleanup(config.get_user_config().set_autoconnect, orig) |
281 | + |
282 | + def reply_handler(_): |
283 | + """Handle the reply.""" |
284 | + self.assertEqual(config.get_user_config().get_autoconnect(), |
285 | + not orig) |
286 | + d.callback(True) |
287 | + |
288 | + client.call_method('set_autoconnect_enabled', not orig, |
289 | + reply_handler=reply_handler, |
290 | + error_handler=self.error_handler) |
291 | + return d |
292 | + |
293 | + def test_show_all_notifications_enabled(self): |
294 | + """Test for Config.show_all_notifications_enabled.""" |
295 | + client = self.get_client() |
296 | + d = defer.Deferred() |
297 | + |
298 | + def reply_handler_disabled(result): |
299 | + """Handle the reply.""" |
300 | + self.assertTrue(result) |
301 | + config.get_user_config().set_show_all_notifications(not result) |
302 | + client.call_method('show_all_notifications_enabled', |
303 | + reply_handler=reply_handler_enabled, |
304 | + error_handler=self.error_handler) |
305 | + |
306 | + def reply_handler_enabled(result): |
307 | + """Handle the reply.""" |
308 | + self.assertFalse(result) |
309 | + d.callback(True) |
310 | + |
311 | + client.call_method('show_all_notifications_enabled', |
312 | + reply_handler=reply_handler_disabled, |
313 | + error_handler=self.error_handler) |
314 | + return d |
315 | + |
316 | + def test_enable_show_all_notifications(self): |
317 | + """Test for Config.enable_show_all_notifications.""" |
318 | + client = self.get_client() |
319 | + d = defer.Deferred() |
320 | + self.main.status_listener.show_all_notifications = False |
321 | + def reply_handler(_): |
322 | + """Handle the reply.""" |
323 | + user_config = config.get_user_config() |
324 | + self.assertTrue(user_config.get_show_all_notifications()) |
325 | + self.assertTrue(self.main.status_listener.show_all_notifications) |
326 | + d.callback(True) |
327 | + client.call_method('enable_show_all_notifications', |
328 | + reply_handler=reply_handler, |
329 | + error_handler=self.error_handler) |
330 | + return d |
331 | + |
332 | + def test_disable_show_all_notifications(self): |
333 | + """Test for Config.disable_show_all_notifications.""" |
334 | + client = self.get_client() |
335 | + d = defer.Deferred() |
336 | + self.main.status_listener.show_all_notifications = True |
337 | + def reply_handler(_): |
338 | + """Handle the reply.""" |
339 | + user_config = config.get_user_config() |
340 | + self.assertFalse(user_config.get_show_all_notifications()) |
341 | + self.assertFalse(self.main.status_listener.show_all_notifications) |
342 | + d.callback(True) |
343 | + client.call_method('disable_show_all_notifications', |
344 | + reply_handler=reply_handler, |
345 | + error_handler=self.error_handler) |
346 | + return d |
347 | + |
348 | + |
349 | +class DBusOAuthTestCase(BaseTwistedTestCase): |
350 | + """Tests the interaction between dbus_interface and credentials. |
351 | + |
352 | + Check conditions when autconnecting is False. |
353 | + |
354 | + """ |
355 | + |
356 | + timeout = 2 |
357 | + method = 'register' |
358 | + autoconnecting = False |
359 | + |
360 | + @defer.inlineCallbacks |
361 | + def setUp(self): |
362 | + """Init.""" |
363 | + yield super(DBusOAuthTestCase, self).setUp() |
364 | + self.events = [] |
365 | + self.patch(DBusInterface, 'test', True) |
366 | + self.patch(dbus, 'Interface', FakedSSOBackend) |
367 | + self.patch(dbus.service, 'BusName', FakedBusName) |
368 | + self.bus = FakedSessionBus() |
369 | + |
370 | + self.data_dir = self.mktemp('data_dir') |
371 | + self.partials_dir = self.mktemp('partials') |
372 | + self.root_dir = self.mktemp('root_dir') |
373 | + self.shares_dir = self.mktemp('shares_dir') |
374 | + self.main = FakeMain(self.root_dir, self.shares_dir, |
375 | + self.data_dir, self.partials_dir) |
376 | + self.dbus_iface = DBusInterface(bus=self.bus, main=self.main, |
377 | + system_bus=None, send_events=False) |
378 | + self.dbus_iface.event_queue.push = lambda name, **kw: \ |
379 | + self.events.append((name, kw)) |
380 | + self.memento = MementoHandler() |
381 | + logger.addHandler(self.memento) |
382 | + self.addCleanup(logger.removeHandler, self.memento) |
383 | + |
384 | + @defer.inlineCallbacks |
385 | + def tearDown(self, *args): |
386 | + """Shutdown.""" |
387 | + self.main.shutdown() |
388 | + yield super(DBusOAuthTestCase, self).tearDown() |
389 | + |
390 | + @defer.inlineCallbacks |
391 | + def test_signals_are_connected(self): |
392 | + """Dbus signals have connected handlers.""" |
393 | + |
394 | + def f(*a, **kw): |
395 | + """Just succeed.""" |
396 | + self.assertIn((DBUS_CREDENTIALS_IFACE, None), self.bus.callbacks) |
397 | + cb = self.bus.callbacks[(DBUS_CREDENTIALS_IFACE, None)] |
398 | + self.assertEqual(self.dbus_iface._signal_handler, cb) |
399 | + self.dbus_iface._deferred.callback(None) |
400 | + |
401 | + self.patch(FakedSSOBackend, self.method, f) |
402 | + yield self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
403 | + |
404 | + @defer.inlineCallbacks |
405 | + def test_signals_are_removed_after_connection(self): |
406 | + """Dbus signals are removed after connection.""" |
407 | + |
408 | + def f(*a, **kw): |
409 | + """Just succeed.""" |
410 | + self.dbus_iface._deferred.callback(None) |
411 | + |
412 | + self.patch(FakedSSOBackend, self.method, f) |
413 | + yield self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
414 | + self.assertNotIn((DBUS_CREDENTIALS_IFACE, None), self.bus.callbacks) |
415 | + |
416 | + @defer.inlineCallbacks |
417 | + def test_connect_pushes_SYS_USER_CONNECT_with_the_token(self): |
418 | + """On connect, the event SYS_USER_CONNECT is pushed.""" |
419 | + |
420 | + def f(*a, **kw): |
421 | + """Receive credentials.""" |
422 | + self.dbus_iface._signal_handler(FAKED_CREDENTIALS, |
423 | + member='CredentialsFound') |
424 | + |
425 | + self.patch(FakedSSOBackend, self.method, f) |
426 | + yield self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
427 | + self.assertEqual(self.events, [('SYS_USER_CONNECT', |
428 | + {'access_token': FAKED_CREDENTIALS})]) |
429 | + |
430 | + @defer.inlineCallbacks |
431 | + def test_connect_raises_NoAccessToken_if_no_token(self): |
432 | + """If no credentials, NoAccessToken is raised.""" |
433 | + |
434 | + def f(*a, **kw): |
435 | + """Receive error signal.""" |
436 | + self.dbus_iface._signal_handler({'error_type': 'Error description', |
437 | + 'error_detail': 'Detailed error'}, |
438 | + member='CredentialsError') |
439 | + |
440 | + self.patch(FakedSSOBackend, self.method, f) |
441 | + d = self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
442 | + d.addErrback(lambda failure: self.assertEqual(NoAccessToken, |
443 | + failure.type)) |
444 | + yield d |
445 | + |
446 | + @defer.inlineCallbacks |
447 | + def test_connect_raises_NoAccessToken_if_auth_denied(self): |
448 | + """If no credentials, NoAccessToken if user denied auth.""" |
449 | + |
450 | + def f(*a, **kw): |
451 | + """Receive error signal.""" |
452 | + self.dbus_iface._signal_handler(member='AuthorizationDenied') |
453 | + |
454 | + self.patch(FakedSSOBackend, self.method, f) |
455 | + d = self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
456 | + d.addErrback(lambda failure: self.assertEqual(NoAccessToken, |
457 | + failure.type)) |
458 | + yield d |
459 | + |
460 | + @defer.inlineCallbacks |
461 | + def test_connect_raises_NoAccessToken_if_no_creds(self): |
462 | + """If no credentials, NoAccessToken if no credentials.""" |
463 | + |
464 | + def f(*a, **kw): |
465 | + """Receive error signal.""" |
466 | + self.dbus_iface._signal_handler(member='CredentialsNotFound') |
467 | + |
468 | + self.patch(FakedSSOBackend, self.method, f) |
469 | + d = self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
470 | + d.addErrback(lambda failure: self.assertEqual(NoAccessToken, |
471 | + failure.type)) |
472 | + yield d |
473 | + |
474 | + @defer.inlineCallbacks |
475 | + def test_dbus_exceptions_are_handled(self): |
476 | + """Every DbusException is handled.""" |
477 | + expected = exceptions.DBusException('test me') |
478 | + |
479 | + def f(*a, **kw): |
480 | + """Just fail.""" |
481 | + raise expected |
482 | + |
483 | + self.patch(FakedSSOBackend, self.method, f) |
484 | + d = self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
485 | + d.addErrback(lambda failure: self.assertEqual(expected, failure.value)) |
486 | + yield d |
487 | + |
488 | + @defer.inlineCallbacks |
489 | + def test_other_exceptions_are_logged_and_re_raised(self): |
490 | + """Every other Exception is logged and re raised.""" |
491 | + expected = TypeError('test me') |
492 | + |
493 | + def f(*a, **kw): |
494 | + """Just fail.""" |
495 | + raise expected |
496 | + |
497 | + self.patch(FakedSSOBackend, self.method, f) |
498 | + d = self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
499 | + d.addErrback(lambda failure: self.assertEqual(expected, failure.value)) |
500 | + yield d |
501 | + self.assertTrue(len(self.memento.records) > 0) |
502 | + record = self.memento.records[1] |
503 | + msg = record.message |
504 | + self.assertIn('connect failed while getting the token', msg) |
505 | + self.assertIn(expected, record.exc_info) |
506 | + |
507 | + def test_oauth_credentials_are_none_at_startup(self): |
508 | + """If the oauth_credentials are not passed as param, they are None.""" |
509 | + self.assertTrue(self.dbus_iface.oauth_credentials is None) |
510 | + |
511 | + @defer.inlineCallbacks |
512 | + def test_oauth_credentials_are_used_to_connect(self): |
513 | + """If present, the oauth_credentials are used to connect.""" |
514 | + expected = {'consumer_key': 'ubuntuone', |
515 | + 'consumer_secret': 'hammertime', |
516 | + 'token': 'faked_token', |
517 | + 'token_secret': 'faked_token_secret'} |
518 | + self.dbus_iface.oauth_credentials = (expected['token'], |
519 | + expected['token_secret']) |
520 | + yield self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
521 | + self.assertEqual(self.events, [('SYS_USER_CONNECT', |
522 | + {'access_token': expected})]) |
523 | + |
524 | + @defer.inlineCallbacks |
525 | + def test_oauth_credentials_can_be_a_four_uple(self): |
526 | + """If present, the oauth_credentials are used to connect.""" |
527 | + expected = {'consumer_key': 'faked_consumer_key', |
528 | + 'consumer_secret': 'faked_consumer_secret', |
529 | + 'token': 'faked_token', |
530 | + 'token_secret': 'faked_token_secret'} |
531 | + self.dbus_iface.oauth_credentials = (expected['consumer_key'], |
532 | + expected['consumer_secret'], |
533 | + expected['token'], |
534 | + expected['token_secret']) |
535 | + yield self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
536 | + self.assertEqual(self.events, [('SYS_USER_CONNECT', |
537 | + {'access_token': expected})]) |
538 | + |
539 | + @defer.inlineCallbacks |
540 | + def test_log_warning_if_oauth_credentials_len_is_useless(self): |
541 | + """Log a warning and return if the oauth_credentials are useless.""" |
542 | + self.dbus_iface.oauth_credentials = ('consumer_key', |
543 | + 'consumer_secret', |
544 | + 'token_secret') |
545 | + yield self.dbus_iface.connect(autoconnecting=self.autoconnecting) |
546 | + self.assertEqual(self.events, []) |
547 | + msgs = (str(self.dbus_iface.oauth_credentials), 'useless') |
548 | + self.assertTrue(self.memento.check_warning(*msgs)) |
549 | + |
550 | + def test_signal_handler_remains_generic(self): |
551 | + """The signal handler function should be generic.""" |
552 | + self.dbus_iface._signal_handler() |
553 | + # no failure |
554 | + self.assertTrue(self.memento.check_debug('member: None')) |
555 | + |
556 | + self.dbus_iface._signal_handler(no_member_kwarg='Test') |
557 | + # no failure |
558 | + self.assertTrue(self.memento.check_debug('member: None')) |
559 | + |
560 | + |
561 | +class DBusOAuthTestCaseRegister(DBusOAuthTestCase): |
562 | + """Tests the interaction between dbus_interface and credentials. |
563 | + |
564 | + Check conditions when autconnecting is True. |
565 | + |
566 | + """ |
567 | + |
568 | + method = 'find_credentials' |
569 | + autoconnecting = True |
570 | + |
571 | + |
572 | +class FolderTests(DBusTwistedTestCase): |
573 | + """Tests for the Folder object exposed via dbus.""" |
574 | + |
575 | + @defer.inlineCallbacks |
576 | + def setUp(self): |
577 | + """Setup the test.""" |
578 | + yield super(FolderTests, self).setUp() |
579 | + self.home_dir = self.mktemp('ubuntuonehacker') |
580 | + self.folders_client = DBusClient(self.bus, '/folders', |
581 | + DBUS_IFACE_FOLDERS_NAME) |
582 | + self._old_home = os.environ['HOME'] |
583 | + os.environ['HOME'] = self.home_dir |
584 | + |
585 | + @defer.inlineCallbacks |
586 | + def tearDown(self): |
587 | + os.environ['HOME'] = self._old_home |
588 | + yield super(FolderTests, self).tearDown() |
589 | + |
590 | + def _create_udf(self, id, node_id, suggested_path, subscribed=True): |
591 | + """Create an UDF and returns it and the volume.""" |
592 | + path = get_udf_path(suggested_path) |
593 | + # make sure suggested_path is unicode |
594 | + if isinstance(suggested_path, str): |
595 | + suggested_path = suggested_path.decode('utf-8') |
596 | + udf = UDF(str(id), str(node_id), suggested_path, path, subscribed) |
597 | + return udf |
598 | + |
599 | + def testget_udf_dict(self): |
600 | + """Test for Folders.get_udf_dict.""" |
601 | + suggested_path = u'~/ñoño' |
602 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path, |
603 | + subscribed=False) |
604 | + udf_dict = get_udf_dict(udf) |
605 | + # check the path it's unicode |
606 | + self.assertEquals(udf_dict['path'], udf.path.decode('utf-8')) |
607 | + self.assertEquals(udf_dict['volume_id'], udf.id) |
608 | + self.assertEquals(udf_dict['suggested_path'], udf.suggested_path) |
609 | + self.assertEquals(udf_dict['node_id'], udf.node_id) |
610 | + self.assertFalse(udf_dict['subscribed']) |
611 | + |
612 | + def testget_udf_dict_bad_encoding(self): |
613 | + """Test for Folders.get_udf_dict.""" |
614 | + suggested_path = u'~/Música' |
615 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path, |
616 | + subscribed=False) |
617 | + udf.suggested_path = udf.suggested_path.encode('utf-8') |
618 | + udf_dict = get_udf_dict(udf) |
619 | + # check the path it's unicode |
620 | + self.assertEquals(udf_dict['path'], udf.path.decode('utf-8')) |
621 | + self.assertEquals(udf_dict['volume_id'], udf.id) |
622 | + self.assertEquals(repr(udf_dict['suggested_path']), |
623 | + repr(udf.suggested_path.decode('utf-8'))) |
624 | + self.assertEquals(udf_dict['node_id'], udf.node_id) |
625 | + self.assertFalse(udf_dict['subscribed']) |
626 | + |
627 | + @defer.inlineCallbacks |
628 | + def test_get_folders(self): |
629 | + """Test for Folders.get_folders.""" |
630 | + suggested_path = u'~/ñoño' |
631 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path) |
632 | + d = defer.Deferred() |
633 | + self.folders_client.call_method('get_folders', |
634 | + reply_handler=d.callback, |
635 | + error_handler=self.error_handler) |
636 | + info = yield d |
637 | + self.assertEquals(len(info), 0) |
638 | + # add a udf |
639 | + yield self.main.vm.add_udf(udf) |
640 | + d2 = defer.Deferred() |
641 | + self.folders_client.call_method('get_folders', |
642 | + reply_handler=d2.callback, |
643 | + error_handler=self.error_handler) |
644 | + info = yield d2 |
645 | + udf_dict = get_udf_dict(self.main.vm.get_volume(udf.volume_id)) |
646 | + self.assertEquals(1, len(info)) |
647 | + for key, value in udf_dict.items(): |
648 | + self.assertEquals(info[0][key], value) |
649 | + |
650 | + def test_get_info(self): |
651 | + """Test for Folders.get_info.""" |
652 | + suggested_path = u'~/ñoño' |
653 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path) |
654 | + d = defer.Deferred() |
655 | + self.folders_client.call_method('get_info', udf.path, |
656 | + reply_handler=self.error_handler, |
657 | + error_handler=d.callback) |
658 | + def check_error(f): |
659 | + """Check we get an error.""" |
660 | + # check the error type |
661 | + self.assertEquals('org.freedesktop.DBus.Python.KeyError', |
662 | + f._dbus_error_name) |
663 | + # add a udf |
664 | + add_deferred = self.main.vm.add_udf(udf) |
665 | + def get_info(_): |
666 | + """Call get_info once we created the udf.""" |
667 | + d = defer.Deferred() |
668 | + self.folders_client.call_method('get_info', udf.path, |
669 | + reply_handler=d.callback, |
670 | + error_handler=self.error_handler) |
671 | + return d |
672 | + add_deferred.addCallback(get_info) |
673 | + return add_deferred |
674 | + def check(info): |
675 | + """Check we get the udf info.""" |
676 | + udf_dict = get_udf_dict(self.main.vm.get_volume(udf.volume_id)) |
677 | + self.assertEquals(info, udf_dict) |
678 | + d.addCallback(check_error) |
679 | + d.addCallback(check) |
680 | + return d |
681 | + |
682 | + def test_create(self): |
683 | + """Test for Folders.create.""" |
684 | + path = os.path.join(self.home_dir, u'ñoño/'.encode('utf-8')) |
685 | + id = uuid.uuid4() |
686 | + node_id = uuid.uuid4() |
687 | + d = defer.Deferred() |
688 | + # patch AQ.create_udf |
689 | + def create_udf(path, name, marker): |
690 | + """Fake create_udf.""" |
691 | + # check that the marker it's the full path to the udf |
692 | + udf_path = os.path.join(os.path.expanduser(path.encode('utf-8')), name.encode('utf-8')) |
693 | + if str(marker) != udf_path: |
694 | + d.errback(ValueError("marker != path - " |
695 | + "marker: %r path: %r" % (marker, udf_path))) |
696 | + self.main.event_q.push("AQ_CREATE_UDF_OK", volume_id=id, |
697 | + node_id=node_id, marker=marker) |
698 | + self.main.action_q.create_udf = create_udf |
699 | + def created_handler(info): |
700 | + """FolderCreated handler.""" |
701 | + d.callback(info) |
702 | + match = self.bus.add_signal_receiver(created_handler, |
703 | + signal_name='FolderCreated') |
704 | + self.signal_receivers.add(match) |
705 | + self.folders_client.call_method('create', path, |
706 | + reply_handler=lambda *agrs: None, |
707 | + error_handler=self.error_handler) |
708 | + def check(info): |
709 | + """Check the FolderCreated info.""" |
710 | + self.assertTrue(os.path.exists(info['path'].encode('utf-8')), |
711 | + info['path'].encode('utf-8')) |
712 | + self.assertEquals(info['path'].encode('utf-8'), |
713 | + os.path.normpath(path)) |
714 | + mdobj = self.main.fs.get_by_path(path) |
715 | + udf = self.main.vm.get_volume(mdobj.share_id) |
716 | + self.assertNotEqual(None, udf) |
717 | + self.assertEquals(udf.path, os.path.normpath(path)) |
718 | + udf_dict = get_udf_dict(udf) |
719 | + self.assertEquals(info, udf_dict) |
720 | + self.main.vm.udf_deleted(udf.volume_id) |
721 | + |
722 | + d.addCallback(check) |
723 | + d.addErrback(self.error_handler) |
724 | + return d |
725 | + |
726 | + def test_create_server_error(self): |
727 | + """Test for Folders.create.""" |
728 | + path = os.path.join(self.home_dir, u'ñoño') |
729 | + d = defer.Deferred() |
730 | + # patch AQ.create_udf |
731 | + def create_udf(path, name, marker): |
732 | + """Fake create_udf, that fails.""" |
733 | + self.main.event_q.push("AQ_CREATE_UDF_ERROR", |
734 | + marker=marker, error="Oops, error!") |
735 | + self.main.action_q.create_udf = create_udf |
736 | + def create_handler(info, error): |
737 | + """FolderCreateError handler.""" |
738 | + d.callback((info, error)) |
739 | + match = self.bus.add_signal_receiver(create_handler, |
740 | + signal_name='FolderCreateError') |
741 | + self.signal_receivers.add(match) |
742 | + self.folders_client.call_method('create', path, |
743 | + reply_handler=lambda *agrs: None, |
744 | + error_handler=self.error_handler) |
745 | + def check(result): |
746 | + """Check the result.""" |
747 | + info, error = result |
748 | + self.assertEquals(info['path'], path) |
749 | + self.assertEquals(error, 'Oops, error!') |
750 | + d.addCallback(check) |
751 | + return d |
752 | + |
753 | + def test_create_client_error(self): |
754 | + """Test for Folders.create.""" |
755 | + path = os.path.join(self.home_dir, u'ñoño') |
756 | + d = defer.Deferred() |
757 | + # patch AQ.create_udf |
758 | + def create_udf(path, name, marker): |
759 | + """Fake create_udf, that fails.""" |
760 | + raise ValueError("I'm broken.") |
761 | + self.main.action_q.create_udf = create_udf |
762 | + def create_handler(info, error): |
763 | + """FolderCreateError handler.""" |
764 | + d.callback((info, error)) |
765 | + match = self.bus.add_signal_receiver(create_handler, |
766 | + signal_name='FolderCreateError') |
767 | + self.signal_receivers.add(match) |
768 | + self.folders_client.call_method('create', path, |
769 | + reply_handler=lambda *agrs: None, |
770 | + error_handler=self.error_handler) |
771 | + def check(result): |
772 | + """Check the result.""" |
773 | + info, error = result |
774 | + self.assertEquals(info['path'], path) |
775 | + self.assertEquals(error, "UNKNOWN_ERROR: I'm broken.") |
776 | + d.addCallback(check) |
777 | + return d |
778 | + |
779 | + def test_create_error_signal(self): |
780 | + """Test for FolderCreateError.""" |
781 | + path = os.path.join(self.home_dir, u'ñoño'.encode('utf-8')) |
782 | + d = defer.Deferred() |
783 | + def create_error_handler(info, error): |
784 | + """FolderCreateError handler""" |
785 | + self.assertEquals(info['path'], path.decode('utf-8')) |
786 | + self.assertEquals(error, "I'm broken") |
787 | + d.callback(True) |
788 | + match = self.bus.add_signal_receiver(create_error_handler, |
789 | + signal_name='FolderCreateError') |
790 | + self.signal_receivers.add(match) |
791 | + # TODO: once create_udf is implemented remove this callLater |
792 | + reactor.callLater(0, self.main.event_q.push, |
793 | + 'VM_UDF_CREATE_ERROR', path=path, error="I'm broken") |
794 | + return d |
795 | + |
796 | + @defer.inlineCallbacks |
797 | + def test_delete(self): |
798 | + """Test for Folders.delete.""" |
799 | + suggested_path = u'~/ñoño' |
800 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path) |
801 | + yield self.main.vm.add_udf(udf) |
802 | + d = defer.Deferred() |
803 | + def delete_volume(volume_id, path): |
804 | + """Fake delete_volume.""" |
805 | + self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=udf.id) |
806 | + self.main.action_q.delete_volume = delete_volume |
807 | + def deleted_handler(info): |
808 | + """FolderDeleted handler.""" |
809 | + self.assertRaises(KeyError, self.main.fs.get_by_path, |
810 | + info['path'].encode('utf-8')) |
811 | + self.assertRaises(VolumeDoesNotExist, |
812 | + self.main.vm.get_volume, str(info['volume_id'])) |
813 | + d.callback(True) |
814 | + match = self.bus.add_signal_receiver(deleted_handler, |
815 | + signal_name='FolderDeleted') |
816 | + self.signal_receivers.add(match) |
817 | + def check_deleted(info): |
818 | + """The callback.""" |
819 | + self.assertNotIn(udf.volume_id, self.main.vm.udfs) |
820 | + self.assertRaises(KeyError, self.main.fs.get_by_path, udf.path) |
821 | + self.assertRaises(VolumeDoesNotExist, |
822 | + self.main.vm.get_volume, udf.volume_id) |
823 | + self.folders_client.call_method('delete', udf.volume_id, |
824 | + reply_handler=check_deleted, |
825 | + error_handler=self.error_handler) |
826 | + yield d |
827 | + |
828 | + @defer.inlineCallbacks |
829 | + def test_delete_error_signal(self): |
830 | + """Test for FolderDeleteError.""" |
831 | + suggested_path = u'~/ñoño' |
832 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path) |
833 | + yield self.main.vm.add_udf(udf) |
834 | + d = defer.Deferred() |
835 | + # patch delete_volume to fail |
836 | + def delete_volume(volume_id, path): |
837 | + """Fake delete_volume.""" |
838 | + self.main.event_q.push("AQ_DELETE_VOLUME_ERROR", |
839 | + volume_id=udf.volume_id, error="I'm broken") |
840 | + self.main.action_q.delete_volume = delete_volume |
841 | + def deleted_error_handler(info, error): |
842 | + """FolderDeleteError handler.""" |
843 | + self.assertEquals(info['volume_id'], udf.volume_id) |
844 | + self.assertEquals(error, "I'm broken") |
845 | + d.callback(True) |
846 | + match = self.bus.add_signal_receiver(deleted_error_handler, |
847 | + signal_name='FolderDeleteError') |
848 | + self.signal_receivers.add(match) |
849 | + self.folders_client.call_method('delete', udf.volume_id, |
850 | + reply_handler=lambda *args: None, |
851 | + error_handler=self.error_handler) |
852 | + yield d |
853 | + self.main.vm.udf_deleted(udf.volume_id) |
854 | + |
855 | + @defer.inlineCallbacks |
856 | + def test_delete_error_signal_folder_id(self): |
857 | + """Test for FolderDeleteError for a volume that doesn't exists.""" |
858 | + udf_id = 'foobar' |
859 | + d = defer.Deferred() |
860 | + def deleted_error_handler(info, error): |
861 | + """FolderDeleteError handler.""" |
862 | + d.callback((info, error)) |
863 | + match = self.bus.add_signal_receiver(deleted_error_handler, |
864 | + signal_name='FolderDeleteError') |
865 | + self.signal_receivers.add(match) |
866 | + self.folders_client.call_method('delete', udf_id, |
867 | + reply_handler=lambda *args: None, |
868 | + error_handler=d.errback) |
869 | + info, error = yield d |
870 | + self.assertEquals(info['volume_id'], udf_id) |
871 | + self.assertEquals(error, "DOES_NOT_EXIST") |
872 | + |
873 | + @defer.inlineCallbacks |
874 | + def test_subscribe(self): |
875 | + """Test for Folders.subscribe and that it fires a dbus signal.""" |
876 | + suggested_path = u'~/ñoño' |
877 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path, |
878 | + subscribed=False) |
879 | + yield self.main.vm.add_udf(udf) |
880 | + d = defer.Deferred() |
881 | + def subscribe_handler(info): |
882 | + """FolderSubscribed handler.""" |
883 | + d.callback(info) |
884 | + match = self.bus.add_signal_receiver(subscribe_handler, |
885 | + signal_name='FolderSubscribed') |
886 | + self.signal_receivers.add(match) |
887 | + self.folders_client.call_method('subscribe', udf.volume_id, |
888 | + reply_handler=lambda x: None, |
889 | + error_handler=self.error_handler) |
890 | + def check(info): |
891 | + """Check that the folder is subscribed.""" |
892 | + self.assertTrue(info['subscribed'], |
893 | + "UDF %s isn't subscribed" % udf.volume_id) |
894 | + d.addCallback(check) |
895 | + d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id)) |
896 | + yield d |
897 | + |
898 | + @defer.inlineCallbacks |
899 | + def test_unsubscribe(self): |
900 | + """Test for Folders.unsubscribe.""" |
901 | + suggested_path = u'~/ñoño' |
902 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path, |
903 | + subscribed=True) |
904 | + yield self.main.vm.add_udf(udf) |
905 | + d = defer.Deferred() |
906 | + self.folders_client.call_method('unsubscribe', udf.volume_id, |
907 | + reply_handler=d.callback, |
908 | + error_handler=self.error_handler) |
909 | + def check(r): |
910 | + """Check that the folder it's not subscribed.""" |
911 | + self.assertFalse(self.main.vm.udfs[udf.volume_id].subscribed, |
912 | + "UDF %s is subscribed" % udf.volume_id) |
913 | + d.addCallback(check) |
914 | + yield d |
915 | + |
916 | + @defer.inlineCallbacks |
917 | + def test_unsubscribe_signal(self): |
918 | + """Test for Folders.unsubscribe fired dbus signal.""" |
919 | + suggested_path = u'~/ñoño' |
920 | + udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path, |
921 | + subscribed=True) |
922 | + yield self.main.vm.add_udf(udf) |
923 | + signal_deferred = defer.Deferred() |
924 | + d = defer.Deferred() |
925 | + def unsubscribe_handler(info): |
926 | + """FolderUnSubscribed handler.""" |
927 | + self.assertFalse(info['subscribed'], |
928 | + "UDF %s is subscribed" % udf.volume_id) |
929 | + signal_deferred.callback(info) |
930 | + match = self.bus.add_signal_receiver(unsubscribe_handler, |
931 | + signal_name='FolderUnSubscribed') |
932 | + self.signal_receivers.add(match) |
933 | + self.folders_client.call_method('unsubscribe', udf.volume_id, |
934 | + reply_handler=d.callback, |
935 | + error_handler=self.error_handler) |
936 | + def check(r): |
937 | + """Check that the folder it's not subscribed.""" |
938 | + a_udf = self.main.vm.udfs[udf.volume_id] |
939 | + self.assertFalse(a_udf.subscribed, |
940 | + "UDF %s is subscribed" % a_udf.volume_id) |
941 | + return signal_deferred |
942 | + d.addCallback(check) |
943 | + d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id)) |
944 | + yield d |
945 | + |
946 | + @defer.inlineCallbacks |
947 | + def test_refresh_volumes(self): |
948 | + """Just check that refresh_volumes method works.""" |
949 | + client = DBusClient(self.bus, '/folders', DBUS_IFACE_FOLDERS_NAME) |
950 | + list_volumes_d = defer.Deferred() |
951 | + self.main.action_q.list_volumes = lambda: list_volumes_d.callback(True) |
952 | + |
953 | + d = defer.Deferred() |
954 | + client.call_method('refresh_volumes', |
955 | + reply_handler=d.callback, |
956 | + error_handler=self.error_handler) |
957 | + yield list_volumes_d |
958 | + yield d |
959 | + |
960 | + |
961 | +class LauncherTests(DBusTwistedTestCase, MockerTestCase): |
962 | + """Tests for the launcher Dbus Interface.""" |
963 | + |
964 | + @defer.inlineCallbacks |
965 | + def test_unset_urgency(self): |
966 | + """Calling remove_urgency removes the urgency hint.""" |
967 | + launcher = self.mocker.replace( |
968 | + "ubuntuone.platform.linux.launcher.UbuntuOneLauncher") |
969 | + launcher() |
970 | + launcher_instance = self.mocker.mock() |
971 | + self.mocker.result(launcher_instance) |
972 | + launcher_instance.set_urgent(False) |
973 | + self.mocker.replay() |
974 | + client = DBusClient(self.bus, '/launcher', DBUS_IFACE_LAUNCHER_NAME) |
975 | + d = defer.Deferred() |
976 | + client.call_method('unset_urgency', |
977 | + reply_handler=d.callback, |
978 | + error_handler=self.error_handler) |
979 | + yield d |
980 | + |
981 | + |
982 | +class ShareTests(DBusTwistedTestCase): |
983 | + """Share specific tests.""" |
984 | + |
985 | + @defer.inlineCallbacks |
986 | + def setUp(self): |
987 | + """Setup the test.""" |
988 | + yield super(ShareTests, self).setUp() |
989 | + self.client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME) |
990 | + |
991 | + def _create_share(self, volume_id=None, node_id=None, access_level='View', |
992 | + accepted=True, subscribed=False): |
993 | + """Create a Share and return it.""" |
994 | + share_path = os.path.join(self.main.shares_dir, 'share') |
995 | + if volume_id is None: |
996 | + volume_id = str(uuid.uuid4()) |
997 | + if node_id is None: |
998 | + node_id = str(uuid.uuid4()) |
999 | + share = Share(path=share_path, volume_id=volume_id, node_id=node_id, |
1000 | + accepted=accepted, access_level=access_level, |
1001 | + subscribed=subscribed) |
1002 | + return share |
1003 | + |
1004 | + @defer.inlineCallbacks |
1005 | + def test_delete_share(self): |
1006 | + """Test for Shares.delete_share.""" |
1007 | + share = self._create_share(accepted=True) |
1008 | + yield self.main.vm.add_share(share) |
1009 | + d = defer.Deferred() |
1010 | + def delete_volume(volume_id, path): |
1011 | + """Fake delete_volume.""" |
1012 | + self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=volume_id) |
1013 | + self.main.action_q.delete_volume = delete_volume |
1014 | + def deleted_handler(info): |
1015 | + """ShareDeleted handler.""" |
1016 | + self.assertRaises(KeyError, self.main.fs.get_by_path, |
1017 | + info['path'].decode('utf-8')) |
1018 | + self.assertRaises(VolumeDoesNotExist, |
1019 | + self.main.vm.get_volume, str(info['volume_id'])) |
1020 | + d.callback(True) |
1021 | + match = self.bus.add_signal_receiver(deleted_handler, |
1022 | + signal_name='ShareDeleted') |
1023 | + self.signal_receivers.add(match) |
1024 | + def check_deleted(info): |
1025 | + """The callback.""" |
1026 | + self.assertNotIn(share.volume_id, self.main.vm.shares) |
1027 | + self.assertRaises(KeyError, self.main.fs.get_by_path, share.path) |
1028 | + self.assertRaises(VolumeDoesNotExist, |
1029 | + self.main.vm.get_volume, share.volume_id) |
1030 | + self.client.call_method('delete_share', share.volume_id, |
1031 | + reply_handler=check_deleted, |
1032 | + error_handler=self.error_handler) |
1033 | + yield d |
1034 | + |
1035 | + @defer.inlineCallbacks |
1036 | + def test_delete_share_from_me(self): |
1037 | + """Test for Shares.delete_share with share from_me.""" |
1038 | + share = self._create_share(accepted=True) |
1039 | + yield self.main.vm.add_shared(share) |
1040 | + d = defer.Deferred() |
1041 | + def delete_share(volume_id): |
1042 | + """Fake delete_volume.""" |
1043 | + self.main.event_q.push("AQ_DELETE_SHARE_OK", share_id=volume_id) |
1044 | + self.patch(self.main.action_q, 'delete_share', delete_share) |
1045 | + def deleted_handler(info): |
1046 | + """ShareDeleted handler.""" |
1047 | + self.assertRaises(KeyError, |
1048 | + self.main.vm.shared.__getitem__, str(info['volume_id'])) |
1049 | + d.callback(True) |
1050 | + match = self.bus.add_signal_receiver(deleted_handler, |
1051 | + signal_name='ShareDeleted') |
1052 | + self.signal_receivers.add(match) |
1053 | + self.client.call_method('delete_share', share.volume_id, |
1054 | + reply_handler=lambda _: None, |
1055 | + error_handler=self.error_handler) |
1056 | + yield d |
1057 | + |
1058 | + @defer.inlineCallbacks |
1059 | + def test_delete_share_error_signal(self): |
1060 | + """Test for Shares.delete_share with an error.""" |
1061 | + share = self._create_share(accepted=True) |
1062 | + yield self.main.vm.add_share(share) |
1063 | + d = defer.Deferred() |
1064 | + # patch delete_volume to fail |
1065 | + def delete_volume(volume_id, path): |
1066 | + """Fake delete_volume.""" |
1067 | + self.main.event_q.push("AQ_DELETE_VOLUME_ERROR", |
1068 | + volume_id=volume_id, error="I'm broken") |
1069 | + self.main.action_q.delete_volume = delete_volume |
1070 | + def deleted_error_handler(info, error): |
1071 | + """ShareDeleteError handler.""" |
1072 | + self.assertEquals(info['volume_id'], share.volume_id) |
1073 | + self.assertEquals(error, "I'm broken") |
1074 | + d.callback(True) |
1075 | + match = self.bus.add_signal_receiver(deleted_error_handler, |
1076 | + signal_name='ShareDeleteError') |
1077 | + self.signal_receivers.add(match) |
1078 | + self.client.call_method('delete_share', share.volume_id, |
1079 | + reply_handler=lambda *args: None, |
1080 | + error_handler=self.error_handler) |
1081 | + yield d |
1082 | + |
1083 | + @defer.inlineCallbacks |
1084 | + def test_delete_share_from_me_error(self): |
1085 | + """Test failure of Shares.delete_share with a share from_me.""" |
1086 | + share = self._create_share(accepted=True) |
1087 | + yield self.main.vm.add_shared(share) |
1088 | + d = defer.Deferred() |
1089 | + # patch delete_share to fail |
1090 | + def delete_share(share_id): |
1091 | + """Fake delete_share.""" |
1092 | + self.main.event_q.push("AQ_DELETE_SHARE_ERROR", |
1093 | + share_id=share_id, error="I'm broken") |
1094 | + self.patch(self.main.action_q, 'delete_share', delete_share) |
1095 | + def deleted_error_handler(info, error): |
1096 | + """ShareDeleteError handler.""" |
1097 | + self.assertEquals(info['volume_id'], share.volume_id) |
1098 | + self.assertEquals(error, "I'm broken") |
1099 | + d.callback(True) |
1100 | + match = self.bus.add_signal_receiver(deleted_error_handler, |
1101 | + signal_name='ShareDeleteError') |
1102 | + self.signal_receivers.add(match) |
1103 | + self.client.call_method('delete_share', share.volume_id, |
1104 | + reply_handler=lambda *args: None, |
1105 | + error_handler=self.error_handler) |
1106 | + yield d |
1107 | + |
1108 | + def test_delete_share_from_me_doesnotexist(self): |
1109 | + """Test failure of Shares.delete_share with a share from_me.""" |
1110 | + d = defer.Deferred() |
1111 | + # patch delete_share to fail |
1112 | + def deleted_error_handler(info, error): |
1113 | + """ShareDeleteError handler.""" |
1114 | + self.assertEquals(info['volume_id'], 'missing_share_id') |
1115 | + self.assertEquals(error, "DOES_NOT_EXIST") |
1116 | + d.callback(True) |
1117 | + match = self.bus.add_signal_receiver(deleted_error_handler, |
1118 | + signal_name='ShareDeleteError') |
1119 | + self.signal_receivers.add(match) |
1120 | + self.client.call_method('delete_share', 'missing_share_id', |
1121 | + reply_handler=lambda *args: None, |
1122 | + error_handler=self.error_handler) |
1123 | + return d |
1124 | + |
1125 | + @defer.inlineCallbacks |
1126 | + def test_subscribe(self): |
1127 | + """Test for Shares.subscribe and that it fires a dbus signal.""" |
1128 | + share = self._create_share(accepted=True, subscribed=False) |
1129 | + yield self.main.vm.add_share(share) |
1130 | + |
1131 | + d = defer.Deferred() |
1132 | + match = self.bus.add_signal_receiver(d.callback, |
1133 | + signal_name='ShareSubscribed') |
1134 | + self.signal_receivers.add(match) |
1135 | + |
1136 | + match = self.bus.add_signal_receiver(lambda _, error: d.errback(error), |
1137 | + signal_name='ShareSubscribeError') |
1138 | + self.signal_receivers.add(match) |
1139 | + |
1140 | + self.client.call_method('subscribe', share.volume_id, |
1141 | + reply_handler=lambda x: None, |
1142 | + error_handler=self.error_handler) |
1143 | + info = yield d |
1144 | + self.assertTrue(bool(info['subscribed']), |
1145 | + "share %r should be subscribed" % share) |
1146 | + yield self.main.vm.share_deleted(share.volume_id) |
1147 | + |
1148 | + @defer.inlineCallbacks |
1149 | + def test_subscribe_error(self): |
1150 | + """Test for Shares.subscribe when there is an error.""" |
1151 | + # do not add a share to have an error |
1152 | + |
1153 | + d = defer.Deferred() |
1154 | + |
1155 | + match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid), |
1156 | + signal_name='ShareSubscribeError') |
1157 | + self.signal_receivers.add(match) |
1158 | + |
1159 | + match = self.bus.add_signal_receiver(d.errback, |
1160 | + signal_name='ShareSubscribed') |
1161 | + self.signal_receivers.add(match) |
1162 | + |
1163 | + self.client.call_method('subscribe', 'invalid_id', |
1164 | + reply_handler=lambda x: None, |
1165 | + error_handler=self.error_handler) |
1166 | + yield d |
1167 | + |
1168 | + @defer.inlineCallbacks |
1169 | + def test_unsubscribe(self): |
1170 | + """Test for Shares.unsubscribe.""" |
1171 | + share = self._create_share(accepted=True, subscribed=True) |
1172 | + yield self.main.vm.add_share(share) |
1173 | + |
1174 | + d = defer.Deferred() |
1175 | + match = self.bus.add_signal_receiver(d.callback, |
1176 | + signal_name='ShareUnSubscribed') |
1177 | + self.signal_receivers.add(match) |
1178 | + |
1179 | + match = self.bus.add_signal_receiver(lambda _, error: d.errback(error), |
1180 | + signal_name='ShareUnSubscribeError') |
1181 | + self.signal_receivers.add(match) |
1182 | + |
1183 | + self.client.call_method('unsubscribe', share.volume_id, |
1184 | + reply_handler=lambda x: None, |
1185 | + error_handler=self.error_handler) |
1186 | + info = yield d |
1187 | + |
1188 | + self.assertFalse(info['subscribed'], |
1189 | + "share %r should be subscribed" % share) |
1190 | + |
1191 | + self.main.vm.share_deleted(share.volume_id) |
1192 | + |
1193 | + @defer.inlineCallbacks |
1194 | + def test_unsubscribe_error(self): |
1195 | + """Test for Shares.unsubscribe when there is an error.""" |
1196 | + # do not add a share to have an error |
1197 | + |
1198 | + d = defer.Deferred() |
1199 | + match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid), |
1200 | + signal_name='ShareUnSubscribeError') |
1201 | + self.signal_receivers.add(match) |
1202 | + |
1203 | + match = self.bus.add_signal_receiver(d.errback, |
1204 | + signal_name='ShareUnSubscribed') |
1205 | + self.signal_receivers.add(match) |
1206 | + |
1207 | + self.client.call_method('unsubscribe', 'invalid_id', |
1208 | + reply_handler=lambda x: None, |
1209 | + error_handler=self.error_handler) |
1210 | + yield d |
1211 | + |
1212 | + |
1213 | +class TestStatusEmitSignals(DBusTwistedTestCase, MockerTestCase): |
1214 | + """Test that the emit method have been correctly implemented.""" |
1215 | + |
1216 | + @defer.inlineCallbacks |
1217 | + def setUp(self): |
1218 | + """Setup tests.""" |
1219 | + yield super(TestStatusEmitSignals, self).setUp() |
1220 | + self.signal_method = self.mocker.mock() |
1221 | + |
1222 | + def test_emit_content_queue_changed(self): |
1223 | + """Emit ContentQueueChanged.""" |
1224 | + self.status.ContentQueueChanged = self.signal_method |
1225 | + self.signal_method() |
1226 | + self.mocker.replay() |
1227 | + # will assert that the signal method was called |
1228 | + self.status.emit_content_queue_changed() |
1229 | + |
1230 | + def test_emit_requestqueue_removed(self): |
1231 | + """Emit RequestQueueRemoved.""" |
1232 | + self.status.RequestQueueRemoved = self.signal_method |
1233 | + self.signal_method('name', 'id', {}) |
1234 | + self.mocker.replay() |
1235 | + # will assert that the signal method was called |
1236 | + self.status.emit_requestqueue_removed('name', 'id', {}) |
1237 | + |
1238 | + def test_emit_requestqueue_added(self): |
1239 | + """Emit RequestQueueAdded.""" |
1240 | + self.status.RequestQueueAdded = self.signal_method |
1241 | + self.signal_method('name', 'id', {}) |
1242 | + self.mocker.replay() |
1243 | + # will assert that the signal method was called |
1244 | + self.status.emit_requestqueue_added('name', 'id', {}) |
1245 | + |
1246 | + def test_emit_invalid_name(self): |
1247 | + """Emit InvalidName.""" |
1248 | + dirname = 'dirname' |
1249 | + filename = 'filename' |
1250 | + self.status.InvalidName = self.signal_method |
1251 | + self.signal_method(unicode(dirname), str(filename)) |
1252 | + self.mocker.replay() |
1253 | + self.status.emit_invalid_name(dirname, filename) |
1254 | + |
1255 | + def test_emit_broken_node(self): |
1256 | + """Emit BrokenNode.""" |
1257 | + volume_id = 'volume_id' |
1258 | + node_id = 'node_id' |
1259 | + mdid = 'mdid' |
1260 | + path = 'path' |
1261 | + self.status.BrokenNode = self.signal_method |
1262 | + self.signal_method(volume_id, node_id, mdid, path.decode('utf8')) |
1263 | + self.mocker.replay() |
1264 | + self.status.emit_broken_node(volume_id, node_id, mdid, |
1265 | + path.decode('utf8')) |
1266 | + |
1267 | + def test_emit_status_changed(self): |
1268 | + """Emit StatusChanged.""" |
1269 | + status = 'status' |
1270 | + status_mock = self.mocker.mock() |
1271 | + self.status.syncdaemon_status = status_mock |
1272 | + status_mock.current_status() |
1273 | + self.mocker.result(status) |
1274 | + self.status.StatusChanged = self.signal_method |
1275 | + self.signal_method(status) |
1276 | + self.mocker.replay() |
1277 | + self.status.emit_status_changed(status) |
1278 | + |
1279 | + def test_emit_download_started(self): |
1280 | + """Emit DownloadStarted.""" |
1281 | + download = 'download' |
1282 | + self.status.DownloadStarted = self.signal_method |
1283 | + self.signal_method(download) |
1284 | + self.mocker.replay() |
1285 | + self.status.emit_download_started(download) |
1286 | + |
1287 | + def test_emit_download_file_progress(self): |
1288 | + """Emit DownloadFileProgress.""" |
1289 | + download = 'download' |
1290 | + string_info = {'blah':'3', 'do':'4'} |
1291 | + self.status.DownloadFileProgress = self.signal_method |
1292 | + self.signal_method(download, string_info) |
1293 | + self.mocker.replay() |
1294 | + self.status.emit_download_file_progress(download, blah=3, do=4) |
1295 | + |
1296 | + def test_emit_download_finished(self): |
1297 | + """Emit DownloadFinished.""" |
1298 | + download = 'download' |
1299 | + string_info = {'blah':'3', 'do':'4'} |
1300 | + self.status.DownloadFinished = self.signal_method |
1301 | + self.signal_method(download, string_info) |
1302 | + self.mocker.replay() |
1303 | + self.status.emit_download_finished(download, blah=3, do=4) |
1304 | + |
1305 | + def test_emit_upload_started(self): |
1306 | + """Emit UploadStarted.""" |
1307 | + upload = 'upload' |
1308 | + self.status.UploadStarted = self.signal_method |
1309 | + self.signal_method(upload) |
1310 | + self.mocker.replay() |
1311 | + self.status.emit_upload_started(upload) |
1312 | + |
1313 | + def test_emit_upload_file_progress(self): |
1314 | + """Emit UploadFileProgress.""" |
1315 | + upload = 'upload' |
1316 | + string_info = {'blah':'3', 'do':'4'} |
1317 | + self.status.UploadFileProgress = self.signal_method |
1318 | + self.signal_method(upload , string_info) |
1319 | + self.mocker.replay() |
1320 | + self.status.emit_upload_file_progress(upload , blah=3, do=4) |
1321 | + |
1322 | + def test_emit_upload_finished(self): |
1323 | + """Emit UploadFinished.""" |
1324 | + upload = 'upload' |
1325 | + string_info = {'blah':'3', 'do':'4'} |
1326 | + self.status.UploadFinished= self.signal_method |
1327 | + self.signal_method(upload , string_info) |
1328 | + self.mocker.replay() |
1329 | + self.status.emit_upload_finished(upload, blah=3, do=4) |
1330 | + |
1331 | + def test_emit_account_changed(self): |
1332 | + """Emit AccountChanged.""" |
1333 | + info_dict = {'purchased_bytes': unicode('34')} |
1334 | + account_info = self.mocker.mock() |
1335 | + account_info.purchased_bytes |
1336 | + self.mocker.result('34') |
1337 | + self.status.AccountChanged = self.signal_method |
1338 | + self.signal_method(info_dict) |
1339 | + self.mocker.replay() |
1340 | + self.status.emit_account_changed(account_info) |
1341 | + |
1342 | + def test_emit_metaqueue_changed(self): |
1343 | + """Emit MetaQueueChanged.""" |
1344 | + self.status.MetaQueueChanged = self.signal_method |
1345 | + self.signal_method() |
1346 | + self.mocker.replay() |
1347 | + self.status.emit_metaqueue_changed() |
1348 | + |
1349 | + |
1350 | +class TestEventsEmitSignals(DBusTwistedTestCase, MockerTestCase): |
1351 | + """Test that the emit method have been correctly implemented.""" |
1352 | + |
1353 | + @defer.inlineCallbacks |
1354 | + def setUp(self): |
1355 | + """Setup tests.""" |
1356 | + yield super(TestEventsEmitSignals, self).setUp() |
1357 | + self.signal_method = self.mocker.mock() |
1358 | + |
1359 | + def test_emit_event(self): |
1360 | + """Test the Event signal.""" |
1361 | + items = {1:2} |
1362 | + event = self.mocker.mock() |
1363 | + event.iteritems() |
1364 | + self.mocker.result(items.iteritems()) |
1365 | + self.events.Event = self.signal_method |
1366 | + self.signal_method({'1':'2'}) |
1367 | + self.mocker.replay() |
1368 | + self.events.emit_event(event) |
1369 | + |
1370 | + |
1371 | +class TestSyncDaemonEmitSignals(DBusTwistedTestCase, MockerTestCase): |
1372 | + """Test that the emit method have been correctly implemented.""" |
1373 | + |
1374 | + @defer.inlineCallbacks |
1375 | + def setUp(self): |
1376 | + """Setup tests.""" |
1377 | + yield super(TestSyncDaemonEmitSignals, self).setUp() |
1378 | + self.signal_method = self.mocker.mock() |
1379 | + |
1380 | + |
1381 | + def test_emit_root_mismatch(self): |
1382 | + """Emit RootMismatch signal.""" |
1383 | + root_id = 'root_id' |
1384 | + new_root_id = 'new_root_id' |
1385 | + self.sync.RootMismatch = self.signal_method |
1386 | + self.signal_method(root_id, new_root_id) |
1387 | + self.mocker.replay() |
1388 | + self.sync.emit_root_mismatch(root_id, new_root_id) |
1389 | + |
1390 | + def test_emit_quota_exceeded(self): |
1391 | + """Emit QuotaExceeded signal.""" |
1392 | + volume_dict = 'volume_dict' |
1393 | + self.sync.QuotaExceeded = self.signal_method |
1394 | + self.signal_method(volume_dict) |
1395 | + self.mocker.replay() |
1396 | + self.sync.emit_quota_exceeded(volume_dict) |
1397 | + |
1398 | + |
1399 | +class TestSharesEmitSignals(DBusTwistedTestCase, MockerTestCase): |
1400 | + """Test that the emit method have been correctly implemented.""" |
1401 | + |
1402 | + @defer.inlineCallbacks |
1403 | + def setUp(self): |
1404 | + """Setup tests.""" |
1405 | + yield super(TestSharesEmitSignals, self).setUp() |
1406 | + self.signal_method = self.mocker.mock() |
1407 | + self.shares.syncdaemon_shares = self.mocker.mock() |
1408 | + self.get_share_dict = self.mocker.replace( |
1409 | + 'ubuntuone.syncdaemon.interaction_interfaces.get_share_dict') |
1410 | + |
1411 | + def test_emit_share_changed_deleted(self): |
1412 | + share = 'share' |
1413 | + message = 'deleted' |
1414 | + share_dict = {'share':'id'} |
1415 | + self.get_share_dict(share) |
1416 | + self.mocker.result(share_dict) |
1417 | + self.shares.ShareDeleted = self.signal_method |
1418 | + self.signal_method(share_dict) |
1419 | + self.mocker.replay() |
1420 | + self.shares.emit_share_changed(message, share) |
1421 | + |
1422 | + def test_emit_share_changed_changed(self): |
1423 | + share = 'share' |
1424 | + message = 'changed' |
1425 | + share_dict = {'share':'id'} |
1426 | + self.get_share_dict(share) |
1427 | + self.mocker.result(share_dict) |
1428 | + self.shares.ShareChanged = self.signal_method |
1429 | + self.signal_method(share_dict) |
1430 | + self.mocker.replay() |
1431 | + self.shares.emit_share_changed(message, share) |
1432 | + |
1433 | + def test_emit_share_delete_error(self): |
1434 | + """Emit ShareDeleteError signal.""" |
1435 | + share = 'share' |
1436 | + error = 'error' |
1437 | + share_dict = {'share':'id'} |
1438 | + self.get_share_dict(share) |
1439 | + self.mocker.result(share_dict) |
1440 | + self.shares.ShareDeleteError = self.signal_method |
1441 | + self.signal_method(share_dict, error) |
1442 | + self.mocker.replay() |
1443 | + self.shares.emit_share_delete_error(share, error) |
1444 | + |
1445 | + def test_emit_free_space(self): |
1446 | + """Emit ShareChanged when free space changes """ |
1447 | + free_bytes = '0' |
1448 | + share_dict = shares = {'1': 'share', 'free_bytes':'0' } |
1449 | + share = 'share' |
1450 | + share_id = '1' |
1451 | + self.shares.syncdaemon_shares.shares |
1452 | + self.mocker.result(shares) |
1453 | + self.shares.syncdaemon_shares.shares |
1454 | + self.mocker.result(shares) |
1455 | + self.get_share_dict(share) |
1456 | + self.mocker.result(share_dict) |
1457 | + self.shares.ShareChanged = self.signal_method |
1458 | + self.signal_method(share_dict) |
1459 | + self.mocker.replay() |
1460 | + self.shares.emit_free_space(share_id, free_bytes) |
1461 | + |
1462 | + def test_emit_share_created(self): |
1463 | + """Emit ShareCreated signal """ |
1464 | + share_info = 'info' |
1465 | + self.shares.ShareCreated = self.signal_method |
1466 | + self.signal_method(share_info) |
1467 | + self.mocker.replay() |
1468 | + self.shares.emit_share_created(share_info) |
1469 | + |
1470 | + def test_emit_share_create_error(self): |
1471 | + """Emit ShareCreateError signal.""" |
1472 | + share_info = 'id' |
1473 | + error = 'error' |
1474 | + info = 'info' |
1475 | + self.shares.syncdaemon_shares.get_create_error_share_info(share_info) |
1476 | + self.mocker.result(info) |
1477 | + self.shares.ShareCreateError = self.signal_method |
1478 | + self.signal_method(info, error) |
1479 | + self.mocker.replay() |
1480 | + self.shares.emit_share_create_error(share_info, error) |
1481 | + |
1482 | + def test_emit_share_answer_response(self): |
1483 | + """Emits ShareAnswerResponse signal.""" |
1484 | + share_id = 'id' |
1485 | + answer = 'yes' |
1486 | + error = 'boom' |
1487 | + answer_info = dict(volume_id=share_id, answer=answer, error=error) |
1488 | + self.shares.ShareAnswerResponse = self.signal_method |
1489 | + self.signal_method(answer_info) |
1490 | + self.mocker.replay() |
1491 | + self.shares.emit_share_answer_response(share_id, answer, error) |
1492 | + |
1493 | + def test_emit_new_share(self): |
1494 | + """Emits NewShare signal.""" |
1495 | + share_id = 'id' |
1496 | + share = 'share' |
1497 | + share_dict = {'share':'id'} |
1498 | + self.shares.syncdaemon_shares.get_volume(share_id) |
1499 | + self.mocker.result(share) |
1500 | + self.get_share_dict(share) |
1501 | + self.mocker.result(share_dict) |
1502 | + self.shares.NewShare = self.signal_method |
1503 | + self.signal_method(share_dict) |
1504 | + self.mocker.replay() |
1505 | + self.shares.emit_new_share(share_id) |
1506 | + |
1507 | + def test_emit_share_subscribed(self): |
1508 | + """Emit the ShareSubscribed signal""" |
1509 | + share = 'share' |
1510 | + share_dict = {'share' : 'id'} |
1511 | + self.get_share_dict(share) |
1512 | + self.mocker.result(share_dict) |
1513 | + self.shares.ShareSubscribed = self.signal_method |
1514 | + self.signal_method(share_dict) |
1515 | + self.mocker.replay() |
1516 | + self.shares.emit_share_subscribed(share) |
1517 | + |
1518 | + def test_emit_share_subscribe_error(self): |
1519 | + """Emit the ShareSubscribeError signal""" |
1520 | + share_id = 'id' |
1521 | + error = 'error' |
1522 | + self.shares.ShareSubscribeError = self.signal_method |
1523 | + self.signal_method({'id': share_id}, str(error)) |
1524 | + self.mocker.replay() |
1525 | + self.shares.emit_share_subscribe_error(share_id, error) |
1526 | + |
1527 | + def test_emit_share_unsubscribed(self): |
1528 | + """Emit the ShareUnSubscribed signal""" |
1529 | + share = 'share' |
1530 | + share_dict = {'share':'id'} |
1531 | + self.get_share_dict(share) |
1532 | + self.mocker.result(share_dict) |
1533 | + self.shares.ShareUnSubscribed = self.signal_method |
1534 | + self.signal_method(share_dict) |
1535 | + self.mocker.replay() |
1536 | + self.shares.emit_share_unsubscribed(share) |
1537 | + |
1538 | + def test_emit_share_unsubscribe_error(self): |
1539 | + """Emit the ShareUnSubscribeError signal""" |
1540 | + share_id = 'id' |
1541 | + error = 'error' |
1542 | + self.shares.ShareUnSubscribeError = self.signal_method |
1543 | + self.signal_method({'id': share_id}, str(error)) |
1544 | + self.mocker.replay() |
1545 | + self.shares.emit_share_unsubscribe_error(share_id, error) |
1546 | + |
1547 | + |
1548 | +class TestFoldersEmitSignals(DBusTwistedTestCase, MockerTestCase): |
1549 | + """Test that the emit method have been correctly implemented.""" |
1550 | + |
1551 | + @defer.inlineCallbacks |
1552 | + def setUp(self): |
1553 | + """Setup tests.""" |
1554 | + yield super(TestFoldersEmitSignals, self).setUp() |
1555 | + self.signal_method = self.mocker.mock() |
1556 | + self.get_udf_dict = self.mocker.replace( |
1557 | + 'ubuntuone.syncdaemon.interaction_interfaces.get_udf_dict') |
1558 | + |
1559 | + def test_emit_folder_deleted(self): |
1560 | + """Emit the FolderCreated signal""" |
1561 | + folder = 'folder' |
1562 | + udf_dict = {'udf':'id'} |
1563 | + self.get_udf_dict(folder) |
1564 | + self.mocker.result(udf_dict) |
1565 | + self.folders.FolderDeleted = self.signal_method |
1566 | + self.signal_method(udf_dict) |
1567 | + self.mocker.replay() |
1568 | + self.folders.emit_folder_deleted(folder) |
1569 | + |
1570 | + def test_emit_folder_delete_error(self): |
1571 | + """Emit the FolderCreateError signal""" |
1572 | + folder = 'folder' |
1573 | + error = 'error' |
1574 | + udf_dict = {'udf':'id'} |
1575 | + self.get_udf_dict(folder) |
1576 | + self.mocker.result(udf_dict) |
1577 | + self.folders.FolderDeleteError = self.signal_method |
1578 | + self.signal_method(udf_dict, str(error)) |
1579 | + self.mocker.replay() |
1580 | + self.folders.emit_folder_delete_error(folder, error) |
1581 | + |
1582 | + def test_emit_folder_subscribed(self): |
1583 | + """Emit the FolderSubscribed signal""" |
1584 | + folder = 'folder' |
1585 | + udf_dict = {'udf':'id'} |
1586 | + self.get_udf_dict(folder) |
1587 | + self.mocker.result(udf_dict) |
1588 | + self.folders.FolderSubscribed = self.signal_method |
1589 | + self.signal_method(udf_dict) |
1590 | + self.mocker.replay() |
1591 | + self.folders.emit_folder_subscribed(folder) |
1592 | + |
1593 | + def test_emit_folder_subscribe_error(self): |
1594 | + """Emit the FolderSubscribeError signal""" |
1595 | + folder_id = 'id' |
1596 | + error = 'error' |
1597 | + self.folders.FolderSubscribeError = self.signal_method |
1598 | + self.signal_method({'id':folder_id}, str(error)) |
1599 | + self.mocker.replay() |
1600 | + self.folders.emit_folder_subscribe_error(folder_id, error) |
1601 | + |
1602 | + def test_emit_folder_unsubscribed(self): |
1603 | + """Emit the FolderUnSubscribed signal""" |
1604 | + folder = 'folder' |
1605 | + udf_dict = {'udf':'id'} |
1606 | + self.get_udf_dict(folder) |
1607 | + self.mocker.result(udf_dict) |
1608 | + self.folders.FolderUnSubscribed = self.signal_method |
1609 | + self.signal_method(udf_dict) |
1610 | + self.mocker.replay() |
1611 | + self.folders.emit_folder_unsubscribed(folder) |
1612 | + |
1613 | + def test_emit_folder_unsubscribe_error(self): |
1614 | + """Emit the FolderUnSubscribeError signal""" |
1615 | + folder_id = 'id' |
1616 | + error = 'error' |
1617 | + self.folders.FolderUnSubscribeError= self.signal_method |
1618 | + self.signal_method({'id':folder_id}, str(error)) |
1619 | + self.mocker.replay() |
1620 | + self.folders.emit_folder_unsubscribe_error(folder_id, error) |
1621 | + |
1622 | + |
1623 | +class TestPublicFilesEmitSignals(DBusTwistedTestCase, MockerTestCase): |
1624 | + """Test that the emit method have been correctly implemented.""" |
1625 | + |
1626 | + @defer.inlineCallbacks |
1627 | + def setUp(self): |
1628 | + """Setup tests.""" |
1629 | + yield super(TestPublicFilesEmitSignals, self).setUp() |
1630 | + self.signal_method = self.mocker.mock() |
1631 | + self.public_files.syncdaemon_public_files = self.mocker.mock() |
1632 | + self.bool_str = self.mocker.replace( |
1633 | + 'ubuntuone.syncdaemon.interaction_interfaces.bool_str') |
1634 | + |
1635 | + def test_emit_public_access_changed(self): |
1636 | + """Emit the PublicAccessChanged signal.""" |
1637 | + share_id = 'share_id' |
1638 | + node_id = 'node_id' |
1639 | + path = 'path' |
1640 | + is_public = True |
1641 | + public_url = 'url' |
1642 | + self.public_files.syncdaemon_public_files.get_path(share_id, node_id) |
1643 | + self.mocker.result(path) |
1644 | + self.bool_str(is_public) |
1645 | + self.mocker.result('True') |
1646 | + self.public_files.PublicAccessChanged = self.signal_method |
1647 | + self.signal_method(dict(share_id=share_id, node_id=node_id, |
1648 | + is_public='True', public_url=public_url, |
1649 | + path=path)) |
1650 | + self.mocker.replay() |
1651 | + self.public_files.emit_public_access_changed(share_id, node_id, |
1652 | + is_public, public_url) |
1653 | + |
1654 | + def test_emit_public_access_change_error(self): |
1655 | + """Emit the PublicAccessChangeError signal.""" |
1656 | + share_id = 'share_id' |
1657 | + node_id = 'node_id' |
1658 | + error = 'error' |
1659 | + path = 'path' |
1660 | + self.public_files.syncdaemon_public_files.get_path(share_id, node_id) |
1661 | + self.mocker.result(path) |
1662 | + self.public_files.PublicAccessChangeError = self.signal_method |
1663 | + self.signal_method(dict(share_id=share_id, node_id=node_id, path=path), |
1664 | + error) |
1665 | + self.mocker.replay() |
1666 | + self.public_files.emit_public_access_change_error(share_id, node_id, error) |
1667 | + |
1668 | + def test_emit_public_files_list(self): |
1669 | + """Emit the PublicFilesList signal.""" |
1670 | + volume_id = 'volume_id' |
1671 | + node_id = 'node_id' |
1672 | + public_url = 'url' |
1673 | + path = 'path' |
1674 | + public_files = [dict(volume_id=volume_id, node_id=node_id, |
1675 | + public_url=public_url)] |
1676 | + files = [dict(volume_id=volume_id, node_id=node_id, |
1677 | + public_url=public_url, path=path)] |
1678 | + self.public_files.syncdaemon_public_files.get_path(volume_id, node_id) |
1679 | + self.mocker.result(path) |
1680 | + self.public_files.PublicFilesList = self.signal_method |
1681 | + self.signal_method(files) |
1682 | + self.mocker.replay() |
1683 | + self.public_files.emit_public_files_list(public_files) |
1684 | + |
1685 | + def test_emit_public_files_list_error(self): |
1686 | + """Emit the PublicFilesListError signal.""" |
1687 | + error = 'error' |
1688 | + self.public_files.PublicFilesListError = self.signal_method |
1689 | + self.signal_method(error) |
1690 | + self.mocker.replay() |
1691 | + self.public_files.emit_public_files_list_error(error) |
1692 | +>>>>>>> MERGE-SOURCE |
1693 | |
1694 | === modified file 'tests/platform/linux/test_notification.py' |
1695 | --- tests/platform/linux/test_notification.py 2011-10-27 11:39:43 +0000 |
1696 | +++ tests/platform/linux/test_notification.py 2011-11-07 17:17:24 +0000 |
1697 | @@ -22,9 +22,13 @@ |
1698 | """ |
1699 | |
1700 | |
1701 | +<<<<<<< TREE |
1702 | from mocker import Mocker |
1703 | from twisted.internet import defer |
1704 | from twisted.trial.unittest import TestCase |
1705 | +======= |
1706 | +from mocker import MockerTestCase as TestCase |
1707 | +>>>>>>> MERGE-SOURCE |
1708 | |
1709 | from ubuntuone.platform.linux.notification import Notification, ICON_NAME |
1710 | |
1711 | @@ -46,6 +50,7 @@ |
1712 | class NotificationTestCase(TestCase): |
1713 | """Test the Messaging API.""" |
1714 | |
1715 | +<<<<<<< TREE |
1716 | @defer.inlineCallbacks |
1717 | def setUp(self): |
1718 | yield super(NotificationTestCase, self).setUp() |
1719 | @@ -57,6 +62,8 @@ |
1720 | self.mocker.restore() |
1721 | self.mocker.verify() |
1722 | |
1723 | +======= |
1724 | +>>>>>>> MERGE-SOURCE |
1725 | def test_send_notification(self): |
1726 | """On notification, pynotify receives the proper calls.""" |
1727 | mock_notify = self.mocker.replace("pynotify") |
1728 | |
1729 | === modified file 'tests/platform/linux/test_vm.py' |
1730 | === modified file 'tests/status/test_aggregator.py' |
1731 | --- tests/status/test_aggregator.py 2011-10-27 13:47:09 +0000 |
1732 | +++ tests/status/test_aggregator.py 2011-11-07 17:17:24 +0000 |
1733 | @@ -249,8 +249,13 @@ |
1734 | @defer.inlineCallbacks |
1735 | def setUp(self): |
1736 | """Initialize this test instance.""" |
1737 | +<<<<<<< TREE |
1738 | yield super(ToggleableNotificationTestCase, self).setUp() |
1739 | self.patch(aggregator.notification, "Notification", FakeNotification) |
1740 | +======= |
1741 | + yield super(ToggleableNotificationTestCase, self).setUp() |
1742 | + self.patch(aggregator, "Notification", FakeNotification) |
1743 | +>>>>>>> MERGE-SOURCE |
1744 | self.notification_switch = aggregator.NotificationSwitch() |
1745 | self.toggleable = self.notification_switch.get_notification() |
1746 | |
1747 | |
1748 | === modified file 'tests/syncdaemon/test_action_queue.py' |
1749 | === modified file 'tests/syncdaemon/test_fsm.py' |
1750 | === modified file 'tests/syncdaemon/test_interaction_interfaces.py' |
1751 | --- tests/syncdaemon/test_interaction_interfaces.py 2011-11-02 16:51:32 +0000 |
1752 | +++ tests/syncdaemon/test_interaction_interfaces.py 2011-11-07 17:17:24 +0000 |
1753 | @@ -13,6 +13,7 @@ |
1754 | # |
1755 | # You should have received a copy of the GNU General Public License along |
1756 | # with this program. If not, see <http://www.gnu.org/licenses/>. |
1757 | +<<<<<<< TREE |
1758 | |
1759 | """Test the interaction_interfaces module.""" |
1760 | |
1761 | @@ -124,7 +125,22 @@ |
1762 | kwargs = {} |
1763 | |
1764 | @defer.inlineCallbacks |
1765 | +======= |
1766 | +"""Test that the interaction_interfaces are correctly called.""" |
1767 | + |
1768 | +from mocker import MockerTestCase, MATCH |
1769 | +from twisted.internet import defer |
1770 | + |
1771 | +from tests.platform import IPCTestCase |
1772 | + |
1773 | + |
1774 | +class TestStatusIPC(MockerTestCase, IPCTestCase): |
1775 | + """Ensure that calls are correctly fowarded.""" |
1776 | + |
1777 | + @defer.inlineCallbacks |
1778 | +>>>>>>> MERGE-SOURCE |
1779 | def setUp(self): |
1780 | +<<<<<<< TREE |
1781 | self.patch(interaction_interfaces, 'ExternalInterface', |
1782 | FakedExternalInterface) |
1783 | yield super(BaseTestCase, self).setUp() |
1784 | @@ -185,6 +201,12 @@ |
1785 | """Test the SyncdaemonStatus class.""" |
1786 | |
1787 | sd_class = SyncdaemonStatus |
1788 | +======= |
1789 | + """Set up tests.""" |
1790 | + yield super(TestStatusIPC, self).setUp() |
1791 | + self.syncdaemon_status = self.mocker.mock() |
1792 | + self.status.syncdaemon_status = self.syncdaemon_status |
1793 | +>>>>>>> MERGE-SOURCE |
1794 | |
1795 | def test_current_status(self): |
1796 | """Test the current_status method.""" |
1797 | @@ -369,6 +391,7 @@ |
1798 | self.assertTrue(self.handler.check_warning('deprecated')) |
1799 | |
1800 | def test_waiting_content(self): |
1801 | +<<<<<<< TREE |
1802 | """Test the waiting_content method.""" |
1803 | self.action_q.queue.waiting.extend([ |
1804 | FakeUpload("share_id", "node_id_b"), |
1805 | @@ -397,6 +420,128 @@ |
1806 | sd_class = SyncdaemonFileSystem |
1807 | |
1808 | @defer.inlineCallbacks |
1809 | +======= |
1810 | + """Test if the method is relayed.""" |
1811 | + result = [] |
1812 | + self.syncdaemon_status.waiting_content() |
1813 | + self.mocker.result(result) |
1814 | + self.mocker.replay() |
1815 | + self.assertEqual(result, self.status.waiting_content()) |
1816 | + |
1817 | + def test_current_uploads(self): |
1818 | + """Test if the method is relayed.""" |
1819 | + result = 'uploading' |
1820 | + self.syncdaemon_status.current_uploads() |
1821 | + self.mocker.result(result) |
1822 | + self.mocker.replay() |
1823 | + self.assertEqual(result, self.status.current_uploads()) |
1824 | + |
1825 | + |
1826 | +class TestEventsIPC(MockerTestCase, IPCTestCase): |
1827 | + """Ensure that calls are correctly fowarded.""" |
1828 | + |
1829 | + @defer.inlineCallbacks |
1830 | + def setUp(self): |
1831 | + """Set up tests.""" |
1832 | + yield super(TestEventsIPC, self).setUp() |
1833 | + self.events_mock = self.mocker.mock() |
1834 | + self.events.events = self.events_mock |
1835 | + |
1836 | + def test_push_event(self): |
1837 | + """Test if the method is relayed.""" |
1838 | + event_name = 'name' |
1839 | + args = ('uno', 'dos') |
1840 | + self.events_mock.push_event(event_name, args) |
1841 | + self.mocker.replay() |
1842 | + self.events.push_event(event_name, args) |
1843 | + |
1844 | + |
1845 | +class TestSyncDaemonIPC(MockerTestCase, IPCTestCase): |
1846 | + """Ensure that calls are correctly fowarded.""" |
1847 | + |
1848 | + @defer.inlineCallbacks |
1849 | + def setUp(self): |
1850 | + """Set up tests.""" |
1851 | + yield super(TestSyncDaemonIPC, self).setUp() |
1852 | + self.service = self.mocker.mock() |
1853 | + self.sync.service = self.service |
1854 | + |
1855 | + def test_connect(self): |
1856 | + """Test if the method is relayed.""" |
1857 | + self.service.connect() |
1858 | + self.mocker.replay() |
1859 | + self.sync.connect() |
1860 | + |
1861 | + def test_disconnect(self): |
1862 | + """Test if the method is relayed.""" |
1863 | + self.service.disconnect() |
1864 | + self.mocker.replay() |
1865 | + self.sync.disconnect() |
1866 | + |
1867 | + def test_get_rootdir(self): |
1868 | + """Test if the method is relayed.""" |
1869 | + result = 'root' |
1870 | + self.service.get_rootdir() |
1871 | + self.mocker.result(result) |
1872 | + self.mocker.replay() |
1873 | + self.assertEqual(result, self.sync.get_rootdir()) |
1874 | + |
1875 | + def test_get_sharesdir(self): |
1876 | + """Test if the method is relayed.""" |
1877 | + result = 'shares' |
1878 | + self.service.get_sharesdir() |
1879 | + self.mocker.result(result) |
1880 | + self.mocker.replay() |
1881 | + self.assertEqual(result, self.sync.get_sharesdir()) |
1882 | + |
1883 | + def test_get_sharesdir_link(self): |
1884 | + """Test if the method is relayed.""" |
1885 | + result = 'shares' |
1886 | + self.service.get_sharesdir_link() |
1887 | + self.mocker.result(result) |
1888 | + self.mocker.replay() |
1889 | + self.assertEqual(result, self.sync.get_sharesdir_link()) |
1890 | + |
1891 | + def test_wait_for_nirvana(self): |
1892 | + """Test if the method is relayed.""" |
1893 | + result = 'nirvana' |
1894 | + last_event_interval = 'interval' |
1895 | + reply_handler = lambda: None |
1896 | + error_handler = lambda: None |
1897 | + self.service.wait_for_nirvana(last_event_interval, MATCH(callable), |
1898 | + MATCH(callable)) |
1899 | + self.mocker.result(result) |
1900 | + self.mocker.replay() |
1901 | + self.assertEqual(result, self.sync.wait_for_nirvana( |
1902 | + last_event_interval, reply_handler, error_handler)) |
1903 | + |
1904 | + def test_quit(self): |
1905 | + """Test if the method is relayed.""" |
1906 | + reply_handler = lambda: None |
1907 | + error_handler = lambda: None |
1908 | + self.service.quit(MATCH(callable), MATCH(callable)) |
1909 | + self.mocker.replay() |
1910 | + self.sync.quit(reply_handler, error_handler) |
1911 | + |
1912 | + def test_rescan_from_scratch(self): |
1913 | + """Test if the method is relayed.""" |
1914 | + volume_id = 'id' |
1915 | + self.service.rescan_from_scratch(volume_id) |
1916 | + self.mocker.replay() |
1917 | + self.sync.rescan_from_scratch(volume_id) |
1918 | + |
1919 | + |
1920 | +class TestFileSystemIPC(MockerTestCase, IPCTestCase): |
1921 | + """Ensure that calls are correctly fowarded.""" |
1922 | + |
1923 | + @defer.inlineCallbacks |
1924 | + def setUp(self): |
1925 | + """Set up tests.""" |
1926 | + yield super(TestFileSystemIPC, self).setUp() |
1927 | + self.syncdaemon_filesystem = self.mocker.mock() |
1928 | + self.fs.syncdaemon_filesystem = self.syncdaemon_filesystem |
1929 | + |
1930 | +>>>>>>> MERGE-SOURCE |
1931 | def test_get_metadata(self): |
1932 | """Test the get_metadata method.""" |
1933 | share = yield self._create_share() |
1934 | @@ -569,6 +714,7 @@ |
1935 | self.assertEqual('synced', result['quick_tree_synced']) |
1936 | |
1937 | def test_get_dirty_nodes(self): |
1938 | +<<<<<<< TREE |
1939 | """Test the get_dirty_nodes method.""" |
1940 | # create some nodes |
1941 | path1 = os.path.join(self.root_dir, u'ñoño-1'.encode('utf-8')) |
1942 | @@ -611,6 +757,25 @@ |
1943 | self.assertEqual(self._called, ((share_id,), {})) |
1944 | |
1945 | @defer.inlineCallbacks |
1946 | +======= |
1947 | + """Test if the method is relayed.""" |
1948 | + result = 'dirty' |
1949 | + self.syncdaemon_filesystem.get_dirty_nodes() |
1950 | + self.mocker.result(result) |
1951 | + self.mocker.replay() |
1952 | + self.assertEqual(result, self.fs.get_dirty_nodes()) |
1953 | + |
1954 | +class TestSharesIPC(MockerTestCase, IPCTestCase): |
1955 | + """Ensure that calls are correctly fowarded.""" |
1956 | + |
1957 | + @defer.inlineCallbacks |
1958 | + def setUp(self): |
1959 | + """Set up tests.""" |
1960 | + yield super(TestSharesIPC, self).setUp() |
1961 | + self.syncdaemon_shares = self.mocker.mock() |
1962 | + self.shares.syncdaemon_shares = self.syncdaemon_shares |
1963 | + |
1964 | +>>>>>>> MERGE-SOURCE |
1965 | def test_get_shares(self): |
1966 | """Test the get_shares method.""" |
1967 | share = self._create_share(accepted=False) |
1968 | @@ -753,6 +918,7 @@ |
1969 | self.assertEqual(self._called, ((), {})) |
1970 | |
1971 | def test_get_shared(self): |
1972 | +<<<<<<< TREE |
1973 | """Test the get_shared method.""" |
1974 | a_dir = os.path.join(self.root_dir, "a_dir") |
1975 | self.main.fs.create(a_dir, "", is_dir=True) |
1976 | @@ -877,6 +1043,34 @@ |
1977 | user_config = config.get_user_config() |
1978 | self.assertEqual(user_config.get_throttling_read_limit(), None) |
1979 | self.assertEqual(user_config.get_throttling_write_limit(), None) |
1980 | +======= |
1981 | + """Test if the method is relayed.""" |
1982 | + result = 'shared' |
1983 | + self.syncdaemon_shares.get_shared() |
1984 | + self.mocker.result(result) |
1985 | + self.mocker.replay() |
1986 | + self.assertEqual(result, self.shares.get_shared()) |
1987 | + |
1988 | + |
1989 | +class TestConfigIPC(MockerTestCase, IPCTestCase): |
1990 | + """Ensure that calls are correctly fowarded.""" |
1991 | + |
1992 | + @defer.inlineCallbacks |
1993 | + def setUp(self): |
1994 | + """Set up tests.""" |
1995 | + yield super(TestConfigIPC, self).setUp() |
1996 | + self.syncdaemon_config = self.mocker.mock() |
1997 | + self.config.syncdaemon_config = self.syncdaemon_config |
1998 | + |
1999 | + def test_get_throttling_limits(self): |
2000 | + """Test if the method is relayed.""" |
2001 | + reply_handler = lambda: None |
2002 | + error_handler = lambda: None |
2003 | + self.syncdaemon_config.get_throttling_limits(MATCH(callable), |
2004 | + MATCH(callable)) |
2005 | + self.mocker.replay() |
2006 | + self.config.get_throttling_limits(reply_handler, error_handler) |
2007 | +>>>>>>> MERGE-SOURCE |
2008 | |
2009 | def test_set_throttling_limits(self): |
2010 | """Test the set_throttling_limits method.""" |
2011 | @@ -1015,6 +1209,7 @@ |
2012 | self.assertTrue(config.get_user_config().get_show_all_notifications()) |
2013 | |
2014 | def test_disable_show_all_notifications(self): |
2015 | +<<<<<<< TREE |
2016 | """Test the disable_show_all_notifications method.""" |
2017 | self.sd_obj.disable_show_all_notifications() |
2018 | self.assertFalse(config.get_user_config().get_show_all_notifications()) |
2019 | @@ -1024,6 +1219,23 @@ |
2020 | """Test the SyncdaemonFolders class.""" |
2021 | |
2022 | sd_class = SyncdaemonFolders |
2023 | +======= |
2024 | + """Test if the method is relayed.""" |
2025 | + self.syncdaemon_config.disable_show_all_notifications() |
2026 | + self.mocker.replay() |
2027 | + self.config.disable_show_all_notifications() |
2028 | + |
2029 | + |
2030 | +class TestFoldersIPC(MockerTestCase, IPCTestCase): |
2031 | + """Ensure that calls are correctly fowarded.""" |
2032 | + |
2033 | + @defer.inlineCallbacks |
2034 | + def setUp(self): |
2035 | + """Set up tests.""" |
2036 | + yield super(TestFoldersIPC, self).setUp() |
2037 | + self.syncdaemon_folders = self.mocker.mock() |
2038 | + self.folders.syncdaemon_folders = self.syncdaemon_folders |
2039 | +>>>>>>> MERGE-SOURCE |
2040 | |
2041 | def test_create(self): |
2042 | """Test the create method.""" |
2043 | @@ -1116,6 +1328,7 @@ |
2044 | self.assertEqual(info, udf_dict) |
2045 | |
2046 | def test_refresh_volumes(self): |
2047 | +<<<<<<< TREE |
2048 | """Test the refresh_volumes method.""" |
2049 | self.patch(self.main.vm, 'refresh_volumes', self._set_called) |
2050 | self.sd_obj.refresh_volumes() |
2051 | @@ -1131,6 +1344,24 @@ |
2052 | # XXX: change public access is the only class that expects uuid's as |
2053 | # params this may indicate that we need to refactor that class to be |
2054 | # consistent with the rest of syncdaemon where ID's are always strings |
2055 | +======= |
2056 | + """Test if the method is relayed.""" |
2057 | + self.syncdaemon_folders.refresh_volumes() |
2058 | + self.mocker.replay() |
2059 | + self.folders.refresh_volumes() |
2060 | + |
2061 | + |
2062 | +class TestPublicFilesIPC(MockerTestCase, IPCTestCase): |
2063 | + """Ensure that calls are correctly fowarded.""" |
2064 | + |
2065 | + @defer.inlineCallbacks |
2066 | + def setUp(self): |
2067 | + """Set up tests.""" |
2068 | + yield super(TestPublicFilesIPC, self).setUp() |
2069 | + self.syncdaemon_public_files = self.mocker.mock() |
2070 | + self.public_files.syncdaemon_public_files =\ |
2071 | + self.syncdaemon_public_files |
2072 | +>>>>>>> MERGE-SOURCE |
2073 | |
2074 | def test_change_public_access(self): |
2075 | """Test the change_public_access method.""" |
2076 | |
2077 | === modified file 'tests/syncdaemon/test_localrescan.py' |
2078 | === modified file 'tests/syncdaemon/test_status_listener.py' |
2079 | === modified file 'ubuntuone/syncdaemon/action_queue.py' |
2080 | === modified file 'ubuntuone/syncdaemon/filesystem_manager.py' |