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