« back to all changes in this revision
Viewing changes to tests/platform/linux/test_dbus.py
- browse files at revision 1.1.44
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.44
- Committer: Bazaar Package Importer
- Author(s): Rodney Dawes
- Date: 2011-02-11 16:18:11 UTC
- mto: This revision was merged to the branch mainline in revision 67.
- Revision ID: james.westby@ubuntu.com-20110211161811-n18dj9lde7dxqjzr
Tags: upstream-1.5.4
Import upstream version 1.5.4
- files added:
- libsyncdaemon/libsyncdaemon-1.0.vapi
- tests/platform/linux/api
- tests/platform/linux/eventlog
- ubuntuone/platform/linux/api
- files removed:
- bin/u1sync
- tests/credentials
- tests/eventlog
- tests/u1sync
- ubuntuone/credentials
- ubuntuone/u1sync
- files modified:
- Makefile.am
added
removed
tests/platform/linux/test_dbus.py
62
62
from ubuntuone.syncdaemon.marker import MDMarker
63
63
64
64
from ubuntuone.devtools.handlers import MementoHandler
65
from ubuntuone.devtools.testcase import DBusTestCase
65
66
66
67
67
68
# OAuth stubs
110
111
return FAKED_CREDENTIALS
111
112
112
113
113
class DBusTwistedTestCase(BaseTwistedTestCase):
114
class DBusTwistedTestCase(DBusTestCase, BaseTwistedTestCase):
114
115
""" Test the DBus event handling """
115
116
116
117
def setUp(self):
117
118
""" Setup the infrastructure fo the test (dbus service). """
119
DBusTestCase.setUp(self)
118
120
BaseTwistedTestCase.setUp(self)
119
121
self.log = logging.getLogger("ubuntuone.SyncDaemon.TEST")
120
122
self.log.info("starting test %s.%s", self.__class__.__name__,
150
152
151
153
def tearDown(self):
152
154
""" Cleanup the test. """
153
d = self.cleanup_signal_receivers(self.signal_receivers)
155
d = DBusTestCase.tearDown(self)
154
156
d.addBoth(self._tearDown)
155
157
d.addBoth(lambda _: BaseTwistedTestCase.tearDown(self))
156
158
return d
176
178
else:
177
179
self.fail(str(error))
178
180
179
def cleanup_signal_receivers(self, signal_receivers):
180
""" cleanup self.signal_receivers and returns a deferred """
181
deferreds = []
182
for match in signal_receivers:
183
d = defer.Deferred()
184
def callback(*args):
185
""" callback that accepts *args. """
186
if not d.called:
187
d.callback(args)
188
self.bus.call_async(dbus.bus.BUS_DAEMON_NAME,
189
dbus.bus.BUS_DAEMON_PATH,
190
dbus.bus.BUS_DAEMON_IFACE, 'RemoveMatch', 's',
191
(str(match),), callback, self.error_handler)
192
deferreds.append(d)
193
if deferreds:
194
return defer.DeferredList(deferreds)
195
else:
196
return defer.succeed(True)
197
198
181
199
182
class FakeLogin(SSOCredentials):
200
183
"""Stub Object which listens for D-Bus OAuth requests"""
273
256
"""A fake command."""
274
257
275
258
uniqueness = None
259
running = True
276
260
277
261
def __init__(self, share_id, node_id, other=''):
278
262
self.share_id = share_id
286
270
def run(self):
287
271
"""Just succeed."""
288
272
return defer.succeed(None)
289
locked_run = run
290
273
291
274
def to_dict(self):
292
275
"""Just send both values."""
294
277
node_id=self.node_id, other=self.other)
295
278
296
279
280
class FakeUpload(FakeCommand, action_queue.Upload):
281
"""Fake command that inherits from Upload."""
282
def __init__(self, *args):
283
FakeCommand.__init__(self, *args)
284
285
286
class FakeDownload(FakeCommand, action_queue.Download):
287
"""Fake command that inherits from Download."""
288
def __init__(self, *args):
289
FakeCommand.__init__(self, *args)
290
291
297
292
class EmptyCommand(FakeCommand):
298
293
"""A command without any attributes."""
299
294
300
295
def __init__(self):
301
296
"""__init__ that doesn't set any attributes."""
302
pass
303
297
304
298
def to_dict(innerself):
305
299
"""We have no attributes, return an empty dict."""
441
435
442
436
return d
443
437
438
@defer.inlineCallbacks
444
439
def test_get_metadata_path(self):
445
440
"""Test the FileSystem Object, getting MD by path."""
446
441
share_path = os.path.join(self.shares_dir, 'share')
447
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
442
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
448
443
path = os.path.join(share_path, "foo")
449
444
self.fs_manager.create(path, "share")
450
445
self.fs_manager.set_node_id(path, "node_id")
463
458
client = DBusClient(self.bus, '/filesystem', DBUS_IFACE_FS_NAME)
464
459
client.call_method('get_metadata', path, reply_handler=handler,
465
460
error_handler=self.error_handler)
466
return d
461
yield d
467
462
463
@defer.inlineCallbacks
468
464
def test_get_metadata_path_symlink(self):
469
465
"""Test the FileSystem Object, getting MD by path in a symlink."""
470
466
share_path = os.path.join(self.shares_dir, 'share')
471
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
467
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
472
468
path = os.path.join(share_path, "foo")
473
469
symlink_path = os.path.join(self.shares_dir, "share_symlink")
474
470
share_context = self.main.fs._enable_share_write('share',
485
481
486
482
def callback(result):
487
483
"""Callback to check the result."""
488
self.assertEquals(os.path.join(symlink_path, 'foo'), str(result['path']))
484
self.assertEquals(os.path.join(symlink_path, 'foo'),
485
str(result['path']))
489
486
self.assertEquals('share', result['share_id'])
490
487
self.assertEquals('node_id', result['node_id'])
491
488
494
491
client.call_method('get_metadata', os.path.join(symlink_path, 'foo'),
495
492
reply_handler=handler,
496
493
error_handler=self.error_handler)
497
return d
494
yield d
498
495
496
@defer.inlineCallbacks
499
497
def test_get_metadata_share_node(self):
500
498
"""Test the FileSystem Object, getting MD by share and node."""
501
499
share_path = os.path.join(self.shares_dir, 'share')
502
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
500
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
503
501
path = os.path.join(share_path, "foo")
504
502
self.fs_manager.create(path, "share")
505
503
self.fs_manager.set_node_id(path, "node_id")
519
517
client.call_method('get_metadata_by_node', 'share', 'node_id',
520
518
reply_handler=handler,
521
519
error_handler=self.error_handler)
522
return d
520
yield d
523
521
524
522
def test_push_event(self):
525
523
"""Test the exposed method: push_event."""
557
555
self.event_q.add_empty_event_queue_callback(empty_queue_cb)
558
556
return push_deferred
559
557
558
@defer.inlineCallbacks
560
559
def test_waiting_content(self):
561
560
"""Test Status.waiting_content.
562
561
569
568
570
569
# prepare the VM so it lies for us
571
570
share_path = os.path.join(self.shares_dir, 'share')
572
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
571
share = Share(path=share_path, volume_id='share_id')
572
yield self.main.vm.add_share(share)
573
573
b_path = os.path.join(share_path, "path_b")
574
574
c_path = os.path.join(share_path, "path_c")
575
575
self.fs_manager.create(b_path, "share_id")
599
599
client.call_method('waiting_content',
600
600
reply_handler=waiting_handler,
601
601
error_handler=self.error_handler)
602
return d
602
yield d
603
603
604
@defer.inlineCallbacks
604
605
def test_waiting_metadata(self):
605
606
"""Test Status.waiting_metadata with fake data in the AQ."""
606
607
# prepare the VM so it lies for us
607
608
share_path = os.path.join(self.shares_dir, 'share')
608
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
609
share = Share(path=share_path, volume_id='share_id')
610
yield self.main.vm.add_share(share)
609
611
b_path = os.path.join(share_path, "path_b")
610
612
c_path = os.path.join(share_path, "path_c")
611
613
d_path = os.path.join(share_path, "path_d")
652
654
client.call_method('waiting_metadata',
653
655
reply_handler=waiting_handler,
654
656
error_handler=self.error_handler)
655
return d
657
yield d
656
658
659
@defer.inlineCallbacks
657
660
def test_get_metadata_and_quick_tree_not_synced(self):
658
661
"""Test Status.get_metadata_and_quick_tree_status.
659
662
660
663
Fake data in the AQ is used.
661
664
"""
662
665
share_path = os.path.join(self.shares_dir, 'share')
663
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
666
share = Share(path=share_path, volume_id='share')
667
yield self.main.vm.add_share(share)
664
668
path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
665
669
self.fs_manager.create(path, "share")
666
670
self.fs_manager.set_node_id(path, "node_id")
686
690
client.call_method('get_metadata_and_quick_tree_synced',
687
691
path, reply_handler=handler,
688
692
error_handler=self.error_handler)
689
return d
693
yield d
690
694
695
@defer.inlineCallbacks
691
696
def test_get_metadata_and_quick_tree_no_blow_up_kthxbye(self):
692
697
"""Test Status.get_metadata_and_quick_tree_status.
693
698
694
699
Fake data in the AQ is used.
695
700
"""
696
701
share_path = os.path.join(self.shares_dir, 'share')
697
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
702
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
698
703
path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
699
704
self.fs_manager.create(path, "share")
700
705
self.fs_manager.set_node_id(path, "node_id")
721
726
client.call_method('get_metadata_and_quick_tree_synced',
722
727
path, reply_handler=handler,
723
728
error_handler=self.error_handler)
724
return d
729
yield d
725
730
731
@defer.inlineCallbacks
726
732
def test_get_metadata_and_quick_tree_not_synced_2(self):
727
733
"""Test Status.get_metadata_and_quick_tree_status.
728
734
729
735
Fake data in the AQ is used.
730
736
"""
731
737
share_path = os.path.join(self.shares_dir, 'share')
732
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
738
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
733
739
path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
734
740
self.fs_manager.create(path, "share")
735
741
self.fs_manager.set_node_id(path, "node_id")
755
761
client.call_method('get_metadata_and_quick_tree_synced',
756
762
path, reply_handler=handler,
757
763
error_handler=self.error_handler)
758
return d
764
yield d
759
765
766
@defer.inlineCallbacks
760
767
def test_get_metadata_and_quick_tree_synced(self):
761
768
"""Test Status.get_metadata_and_quick_tree_status
762
769
without fake data in the AQ."""
763
770
share_path = os.path.join(self.shares_dir, 'share')
764
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
771
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
765
772
path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
766
773
self.fs_manager.create(path, "share")
767
774
self.fs_manager.set_node_id(path, "node_id")
783
790
client.call_method('get_metadata_and_quick_tree_synced',
784
791
path, reply_handler=handler,
785
792
error_handler=self.error_handler)
786
return d
793
yield d
787
794
795
@defer.inlineCallbacks
788
796
def test_get_metadata_and_quick_tree_synced_symlink(self):
789
797
"""Test Status.get_metadata_and_quick_tree_status
790
798
without fake data in the AQ."""
791
799
share_path = os.path.join(self.shares_dir, 'share')
792
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
800
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
793
801
path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
794
802
self.fs_manager.create(path, "share")
795
803
self.fs_manager.set_node_id(path, "node_id")
818
826
client.call_method('get_metadata_and_quick_tree_synced',
819
827
expected_path, reply_handler=handler,
820
828
error_handler=self.error_handler)
821
return d
829
yield d
822
830
823
831
def test_content_queue_added(self):
824
832
"""Test the signal because a command was added to the queue."""
831
839
receiver = self.bus.add_signal_receiver(lambda: d.callback(True),
832
840
signal_name='ContentQueueChanged')
833
841
self.signal_receivers.add(receiver)
834
self.main.event_q.push('SYS_QUEUE_ADDED', FakeCommand())
842
self.main.event_q.push('SYS_QUEUE_ADDED', command=FakeCommand())
835
843
return d
836
844
837
845
def test_content_queue_removed(self):
845
853
receiver = self.bus.add_signal_receiver(lambda: d.callback(True),
846
854
signal_name='ContentQueueChanged')
847
855
self.signal_receivers.add(receiver)
848
self.main.event_q.push('SYS_QUEUE_REMOVED', FakeCommand())
856
self.main.event_q.push('SYS_QUEUE_REMOVED', command=FakeCommand())
849
857
return d
850
858
859
@defer.inlineCallbacks
851
860
def test_current_downloads(self):
852
861
"""Test Status.current_downloads with fake data in the AQ."""
853
share_path = os.path.join(self.shares_dir, 'share')
854
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
855
down_path = os.path.join(share_path, "down_path")
856
self.fs_manager.create(down_path, "share_id")
857
self.fs_manager.set_node_id(down_path, "node_id")
858
self.action_q.downloading[('share_id', 'node_id')] = dict(
859
deflated_size=10, size=100, n_bytes_read=1)
862
fake_download = FakeDownload('share_id', 'down_node_id')
863
fake_download.deflated_size = 10
864
fake_download.n_bytes_read = 1
865
fake_download.path = "down_path"
866
self.action_q.queue.waiting.append(fake_download)
867
860
868
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
861
869
d = defer.Deferred()
862
870
def downloads_handler(result):
863
871
"""Reply handler."""
864
self.assertEquals(1, len(result))
865
self.assertEquals(down_path, str(result[0]['path']))
866
self.assertEquals('10', str(result[0]['deflated_size']))
867
self.assertEquals('1', str(result[0]['n_bytes_read']))
872
self.assertEqual(1, len(result))
873
self.assertEqual("down_path", str(result[0]['path']))
874
self.assertEqual('10', str(result[0]['deflated_size']))
875
self.assertEqual('1', str(result[0]['n_bytes_read']))
868
876
d.callback(True)
869
877
870
878
client.call_method('current_downloads',
871
879
reply_handler=downloads_handler,
872
880
error_handler=self.error_handler)
873
return d
881
yield d
874
882
883
@defer.inlineCallbacks
875
884
def test_current_uploads(self):
876
885
"""Test Status.current_uploads with fake data in the AQ."""
877
share_path = os.path.join(self.shares_dir, 'share')
878
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
879
up_path = os.path.join(share_path, "up_path")
880
self.fs_manager.create(up_path, "share_id")
881
self.fs_manager.set_node_id(up_path, "node_id")
882
self.action_q.uploading[('share_id', 'node_id')] = dict(
883
deflated_size=100, n_bytes_written=10)
884
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
885
d = defer.Deferred()
886
887
def uploads_handler(result):
888
"""Reply handler."""
889
self.assertEquals(1, len(result))
890
self.assertEquals(up_path, str(result[0]['path']))
891
self.assertEquals('100', str(result[0]['deflated_size']))
892
self.assertEquals('10', str(result[0]['n_bytes_written']))
893
d.callback(True)
894
895
client.call_method('current_uploads', reply_handler=uploads_handler,
896
error_handler=self.error_handler)
897
return d
898
899
def test_current_uploads_with_marker(self):
900
"""Test Status.current_uploads with fake data in the AQ."""
901
self.action_q.uploading[('', MDMarker('a_marker_uuid'))] = dict(
902
deflated_size=100, n_bytes_written=10)
903
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
904
d = defer.Deferred()
905
906
def uploads_handler(result):
907
"""Reply handler."""
908
self.assertEquals(0, len(result))
909
d.callback(True)
910
911
client.call_method('current_uploads', reply_handler=uploads_handler,
912
error_handler=self.error_handler)
913
return d
914
886
fake_upload = FakeUpload('share_id', 'node_id')
887
fake_upload.deflated_size = 100
888
fake_upload.n_bytes_written = 10
889
fake_upload.path = "up_path"
890
self.action_q.queue.waiting.append(fake_upload)
891
892
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
893
d = defer.Deferred()
894
895
def uploads_handler(result):
896
"""Reply handler."""
897
self.assertEqual(1, len(result))
898
self.assertEqual("up_path", str(result[0]['path']))
899
self.assertEqual('100', str(result[0]['deflated_size']))
900
self.assertEqual('10', str(result[0]['n_bytes_written']))
901
d.callback(True)
902
903
client.call_method('current_uploads', reply_handler=uploads_handler,
904
error_handler=self.error_handler)
905
yield d
906
907
@defer.inlineCallbacks
915
908
def test_two_current_downloads(self):
916
909
"""Test Status.current_downloads with fake data in the AQ."""
917
share_path = os.path.join(self.shares_dir, 'share')
918
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
919
down_path = os.path.join(share_path, "down_path")
920
self.fs_manager.create(down_path, "share_id")
921
self.fs_manager.set_node_id(down_path, "node_id")
922
self.action_q.downloading[('share_id', 'node_id')] = dict(
923
deflated_size=10, size=100, n_bytes_read=8)
924
share1_path = os.path.join(self.shares_dir, 'share1')
925
self.main.vm.add_share(Share(path=share1_path, volume_id='share_id_1'))
926
down_path_1 = os.path.join(share1_path, "down_path_1")
927
self.fs_manager.create(down_path_1, "share_id_1")
928
self.fs_manager.set_node_id(down_path_1, "node_id_1")
929
self.action_q.downloading[('share_id_1', 'node_id_1')] = dict(
930
deflated_size=10, size=100, n_bytes_read=5)
910
fake_download = FakeDownload('share_id', 'node_id')
911
fake_download.deflated_size = 10
912
fake_download.n_bytes_read = 8
913
fake_download.path = "down_path"
914
self.action_q.queue.waiting.append(fake_download)
915
916
fake_download = FakeDownload('share_id_1', 'node_id_1')
917
fake_download.deflated_size = 10
918
fake_download.n_bytes_read = 5
919
fake_download.path = "down_path_1"
920
self.action_q.queue.waiting.append(fake_download)
921
931
922
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
932
923
d = defer.Deferred()
933
924
def downloads_handler(result):
934
925
"""Reply handler."""
935
self.assertEquals(2, len(result))
936
self.assertEquals(down_path, str(result[0]['path']))
937
self.assertEquals('10', str(result[0]['deflated_size']))
938
self.assertEquals('8', str(result[0]['n_bytes_read']))
939
self.assertEquals(down_path_1, str(result[1]['path']))
940
self.assertEquals('10', str(result[1]['deflated_size']))
941
self.assertEquals('5', str(result[1]['n_bytes_read']))
926
self.assertEqual(2, len(result))
927
self.assertEqual('down_path', str(result[0]['path']))
928
self.assertEqual('10', str(result[0]['deflated_size']))
929
self.assertEqual('8', str(result[0]['n_bytes_read']))
930
self.assertEqual('down_path_1', str(result[1]['path']))
931
self.assertEqual('10', str(result[1]['deflated_size']))
932
self.assertEqual('5', str(result[1]['n_bytes_read']))
942
933
d.callback(True)
943
934
944
935
client.call_method('current_downloads',
945
936
reply_handler=downloads_handler,
946
937
error_handler=self.error_handler)
947
return d
938
yield d
948
939
940
@defer.inlineCallbacks
949
941
def test_two_current_uploads(self):
950
942
"""Test Status.current_uploads with fake data in the AQ."""
951
share_path = os.path.join(self.shares_dir, 'share')
952
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
953
up_path = os.path.join(share_path, "up_path")
954
self.fs_manager.create(up_path, "share_id")
955
self.fs_manager.set_node_id(up_path, "node_id")
956
self.action_q.uploading[('share_id', 'node_id')] = dict(
957
deflated_size=100, n_bytes_written=10)
958
share1_path = os.path.join(self.shares_dir, 'share1')
959
self.main.vm.add_share(Share(path=share1_path, volume_id='share_id_1'))
960
up_path_1 = os.path.join(share1_path, "up_path_1")
961
self.fs_manager.create(up_path_1, "share_id_1")
962
self.fs_manager.set_node_id(up_path_1, "node_id_1")
963
self.action_q.uploading[('share_id_1', 'node_id_1')] = dict(
964
deflated_size=80, n_bytes_written=20)
943
fake_upload = FakeUpload('share_id', 'node_id')
944
fake_upload.deflated_size = 100
945
fake_upload.n_bytes_written = 10
946
fake_upload.path = "up_path"
947
self.action_q.queue.waiting.append(fake_upload)
948
949
fake_upload = FakeUpload('share_id_1', 'node_id_1')
950
fake_upload.deflated_size = 80
951
fake_upload.n_bytes_written = 20
952
fake_upload.path = "up_path_1"
953
self.action_q.queue.waiting.append(fake_upload)
954
965
955
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
966
956
d = defer.Deferred()
967
957
968
958
def uploads_handler(result):
969
959
"""Reply handler."""
970
self.assertEquals(2, len(result))
971
self.assertEquals(up_path, str(result[0]['path']))
972
self.assertEquals('100', str(result[0]['deflated_size']))
973
self.assertEquals('10', str(result[0]['n_bytes_written']))
974
self.assertEquals(up_path_1, str(result[1]['path']))
975
self.assertEquals('80', str(result[1]['deflated_size']))
976
self.assertEquals('20', str(result[1]['n_bytes_written']))
960
self.assertEqual(2, len(result))
961
self.assertEqual('up_path', str(result[0]['path']))
962
self.assertEqual('100', str(result[0]['deflated_size']))
963
self.assertEqual('10', str(result[0]['n_bytes_written']))
964
self.assertEqual('up_path_1', str(result[1]['path']))
965
self.assertEqual('80', str(result[1]['deflated_size']))
966
self.assertEqual('20', str(result[1]['n_bytes_written']))
977
967
d.callback(True)
978
968
979
969
client.call_method('current_uploads', reply_handler=uploads_handler,
980
970
error_handler=self.error_handler)
981
return d
971
yield d
982
972
973
@defer.inlineCallbacks
983
974
def test_current_downloads_deflated_size_NA(self):
984
975
"""Test Status.current_downloads with fake data in the AQ."""
985
share_path = os.path.join(self.shares_dir, 'share')
986
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
987
down_path = os.path.join(share_path, "down_path")
988
self.fs_manager.create(down_path, "share_id")
989
self.fs_manager.set_node_id(down_path, "node_id")
990
self.action_q.downloading[('share_id', 'node_id')] = dict()
976
fake_download = FakeDownload('share_id', 'down_node_id')
977
fake_download.deflated_size = None
978
fake_download.n_bytes_read = 0
979
fake_download.path = "down_path"
980
self.action_q.queue.waiting.append(fake_download)
981
991
982
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
992
983
d = defer.Deferred()
993
984
def downloads_handler(result):
994
985
"""Reply handler."""
995
self.assertEquals(1, len(result))
996
self.assertEquals(down_path, str(result[0]['path']))
986
self.assertEqual(1, len(result))
987
self.assertEqual('down_path', str(result[0]['path']))
997
988
self.assertNotIn('deflated_size', result[0])
998
self.assertEquals('0', str(result[0]['n_bytes_read']))
989
self.assertEqual('0', str(result[0]['n_bytes_read']))
999
990
d.callback(True)
1000
991
1001
992
client.call_method('current_downloads',
1002
993
reply_handler=downloads_handler,
1003
994
error_handler=self.error_handler)
1004
return d
995
yield d
1005
996
997
@defer.inlineCallbacks
1006
998
def test_current_uploads_deflated_size_NA(self):
1007
999
"""Test Status.current_uploads with fake data in the AQ."""
1008
share_path = os.path.join(self.shares_dir, 'share')
1009
self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
1010
up_path = os.path.join(share_path, "up_path")
1011
self.fs_manager.create(up_path, "share_id")
1012
self.fs_manager.set_node_id(up_path, "node_id")
1013
self.action_q.uploading[('share_id', 'node_id')] = dict()
1000
fake_upload = FakeUpload('share_id', 'node_id')
1001
fake_upload.deflated_size = None
1002
fake_upload.n_bytes_written = 0
1003
fake_upload.path = "up_path"
1004
self.action_q.queue.waiting.append(fake_upload)
1005
1014
1006
client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
1015
1007
d = defer.Deferred()
1016
1008
1017
1009
def uploads_handler(result):
1018
1010
"""Reply handler."""
1019
1011
self.assertEquals(1, len(result))
1020
self.assertEquals(up_path, str(result[0]['path']))
1012
self.assertEquals("up_path", str(result[0]['path']))
1021
1013
self.assertNotIn('deflated_size', result[0])
1022
1014
self.assertEquals('0', str(result[0]['n_bytes_written']))
1023
1015
d.callback(True)
1024
1016
1025
1017
client.call_method('current_uploads', reply_handler=uploads_handler,
1026
1018
error_handler=self.error_handler)
1027
return d
1019
yield d
1028
1020
1029
1021
def test_nm_signals(self):
1030
1022
"""Test that NM signals are received and handled properly."""
1053
1045
self.event_q.add_empty_event_queue_callback(empty_queue_cb)
1054
1046
return d
1055
1047
1048
@defer.inlineCallbacks
1056
1049
def test_get_shares(self):
1057
1050
"""Test Shares.get_shares method."""
1058
1051
share_path = os.path.join(self.main.shares_dir, 'share')
1059
self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
1060
access_level='Read', accepted=False))
1052
share = Share(path=share_path, volume_id='share_id',
1053
access_level='Read', accepted=False)
1054
yield self.main.vm.add_share(share)
1061
1055
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
1062
1056
d = defer.Deferred()
1063
1057
def check(shares):
1073
1067
self.assertEquals('share_id', str(share['volume_id']))
1074
1068
self.assertEquals(share_path, str(share['path']))
1075
1069
self.assertEquals('Read', str(share['access_level']))
1076
self.assertEquals('False', str(share['accepted']))
1070
self.assertEquals('', str(share['accepted']))
1077
1071
1078
1072
def shares_handler(shares):
1079
1073
d.callback(shares)
1080
1074
1081
1075
client.call_method('get_shares', reply_handler=shares_handler,
1082
1076
error_handler=self.error_handler)
1083
return d
1077
d.addCallback(check)
1078
yield d
1084
1079
1080
@defer.inlineCallbacks
1085
1081
def test_accept_share(self):
1086
1082
"""Test the accept_share method in dbus_interface.Share."""
1087
1083
share_path = os.path.join(self.main.shares_dir, 'share')
1088
self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
1084
yield self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
1089
1085
access_level='Read', accepted=False,
1090
1086
node_id="node_id"))
1091
1087
self.assertEquals(False, self.main.vm.shares['share_id'].accepted)
1105
1101
self.assertEquals(True, self.main.vm.shares['share_id'].accepted)
1106
1102
1107
1103
d.addCallback(check)
1108
return d
1104
yield d
1109
1105
1106
@defer.inlineCallbacks
1110
1107
def test_reject_share(self):
1111
1108
"""Test the reject_share method in dbus_interface.Share."""
1112
1109
share_path = os.path.join(self.main.shares_dir, 'share')
1113
self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
1110
yield self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
1114
1111
access_level='Read', accepted=False))
1115
1112
self.assertEquals(False, self.main.vm.shares['share_id'].accepted)
1116
1113
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
1129
1126
self.assertEquals(False, self.main.vm.shares['share_id'].accepted)
1130
1127
1131
1128
d.addCallback(check)
1132
return d
1129
yield d
1133
1130
1134
def test_get_root(self):
1135
"""Check SycnDaemon.get_root exposed method."""
1131
def test_get_rootdir(self):
1132
"""Check SycnDaemon.get_rootdir exposed method."""
1136
1133
client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
1137
1134
d = defer.Deferred()
1138
1135
def reply_handler(result):
1145
1142
error_handler=self.error_handler)
1146
1143
return d
1147
1144
1145
def test_get_sharesdir(self):
1146
"""Check SycnDaemon.get_sharesdir exposed method."""
1147
client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
1148
d = defer.Deferred()
1149
1150
def reply_handler(result):
1151
"""Handle get_sharesdir reply."""
1152
result = self.main.get_sharesdir()
1153
self.assertEquals(result, str(result))
1154
d.callback(True)
1155
1156
client.call_method('get_sharesdir',
1157
reply_handler=reply_handler,
1158
error_handler=self.error_handler)
1159
return d
1160
1161
def test_get_sharesdir_link(self):
1162
"""Check SycnDaemon.get_sharesdir_link exposed method."""
1163
client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
1164
d = defer.Deferred()
1165
1166
def reply_handler(result):
1167
"""Handle get_sharesdir_link reply."""
1168
result = self.main.get_sharesdir_link()
1169
self.assertEquals(result, str(result))
1170
d.callback(True)
1171
1172
client.call_method('get_sharesdir_link',
1173
reply_handler=reply_handler,
1174
error_handler=self.error_handler)
1175
return d
1176
1148
1177
def test_create_share(self):
1149
1178
"""Test share offering."""
1150
1179
a_dir = os.path.join(self.root_dir, "a_dir")
1272
1301
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
1273
1302
d = defer.Deferred()
1274
1303
def reply_handler(result):
1275
"""Handle get_rootdir reply."""
1304
"""Handle refresh_shares reply."""
1276
1305
d.callback(True)
1277
1306
client.call_method('refresh_shares',
1278
1307
reply_handler=reply_handler,
1366
1395
share = Share(path=share_path, volume_id=str(uuid.uuid4()),
1367
1396
access_level='Modify', accepted=True,
1368
1397
node_id=str(uuid.uuid4()))
1369
self.main.vm.add_share(share)
1398
yield self.main.vm.add_share(share)
1370
1399
client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
1400
1401
rescan_d = defer.Deferred()
1402
self.main.action_q.rescan_from_scratch = rescan_d.callback
1403
1371
1404
d = defer.Deferred()
1372
def fake_rescan_from_scratch(volume_id):
1373
"""Stub method."""
1374
d.callback(volume_id)
1375
self.main.action_q.rescan_from_scratch = fake_rescan_from_scratch
1376
d.addCallback(self.assertTrue)
1377
1405
client.call_method('rescan_from_scratch', share.volume_id,
1378
reply_handler=lambda _: None,
1406
reply_handler=d.callback,
1379
1407
error_handler=d.errback)
1380
vol_id = yield d
1408
1409
yield d
1410
1411
vol_id = yield rescan_d
1381
1412
self.assertEqual(vol_id, share.volume_id)
1382
1413
1383
1414
@defer.inlineCallbacks
1439
1470
class DBusInterfaceUnicodeTests(DBusTwistedTestCase):
1440
1471
"""Unicode variant of basic tests to the objects exposed with D-Bus."""
1441
1472
1473
@defer.inlineCallbacks
1442
1474
def test_filesystem_unicode(self):
1443
1475
"""Test the FileSystem Object, registering it to the session bus.
1444
1476
1445
1477
Excercise the API.
1446
1478
"""
1447
1479
share_path = os.path.join(self.shares_dir, 'share')
1448
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
1480
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
1449
1481
path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
1450
1482
self.fs_manager.create(path, "share")
1451
1483
self.fs_manager.set_node_id(path, "node_id")
1464
1496
client = DBusClient(self.bus, '/filesystem', DBUS_IFACE_FS_NAME)
1465
1497
client.call_method('get_metadata', path, reply_handler=handler,
1466
1498
error_handler=self.error_handler)
1467
return d
1499
yield d
1468
1500
1469
1501
def test_create_share_unicode(self):
1470
1502
"""Test share offering."""
1497
1529
error_handler=self.error_handler)
1498
1530
return d
1499
1531
1532
@defer.inlineCallbacks
1500
1533
def test_get_shared_unicode(self):
1501
1534
"""Test that list_shared method behaves with unicode data."""
1502
1535
a_dir = os.path.join(self.root_dir, u'ñoño'.encode('utf-8'))
1505
1538
share = Shared(path=a_dir, volume_id='shared_id', name=u'ñoño_shared',
1506
1539
access_level='View', other_username=u'test_username',
1507
1540
node_id='node_id')
1508
self.main.vm.add_shared(share)
1541
yield self.main.vm.add_shared(share)
1509
1542
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
1510
1543
d = defer.Deferred()
1511
1544
1521
1554
d.addCallback(check)
1522
1555
client.call_method('get_shared',
1523
1556
reply_handler=d.callback, error_handler=d.errback)
1524
return d
1557
yield d
1525
1558
1526
1559
1527
1560
class DBusSignalTest(DBusTwistedTestCase):
1737
1770
signal_name='MetaQueueChanged')
1738
1771
self.signal_receivers.add(receiver)
1739
1772
cmd = action_queue.ListShares # any "meta" command
1740
self.main.event_q.push('SYS_QUEUE_ADDED', cmd)
1773
self.main.event_q.push('SYS_QUEUE_ADDED', command=cmd)
1741
1774
return d
1742
1775
1743
1776
def test_meta_queue_changed(self):
1747
1780
signal_name='MetaQueueChanged')
1748
1781
self.signal_receivers.add(receiver)
1749
1782
cmd = action_queue.ListShares # any "meta" command
1750
self.main.event_q.push('SYS_QUEUE_REMOVED', cmd)
1783
self.main.event_q.push('SYS_QUEUE_REMOVED', command=cmd)
1751
1784
return d
1752
1785
1753
1786
def test_status_changed(self):
1840
1873
node_id='node', path=None, mdid=None)
1841
1874
return d
1842
1875
1876
@defer.inlineCallbacks
1843
1877
def test_share_changed(self):
1844
1878
"""Test the ShareChanged signal."""
1845
1879
share_path = os.path.join(self.main.shares_dir, 'share')
1848
1882
u'test_username',
1849
1883
u'visible_name', 'Write')
1850
1884
1851
self.main.vm.add_share(Share(path=share_path,
1885
yield self.main.vm.add_share(Share(path=share_path,
1852
1886
volume_id=str(share_holder.share_id),
1853
1887
node_id=str(share_holder.subtree),
1854
1888
access_level='Read', accepted=False))
1867
1901
signal_name='ShareChanged')
1868
1902
self.signal_receivers.add(match)
1869
1903
self.main.event_q.push('SV_SHARE_CHANGED', info=share_holder)
1870
return d
1904
yield d
1871
1905
1906
@defer.inlineCallbacks
1872
1907
def test_share_deleted(self):
1873
1908
"""Test the ShareDeleted signal."""
1874
1909
share_path = os.path.join(self.main.shares_dir, 'share')
1876
1911
u'fake_share',
1877
1912
u'test_username',
1878
1913
u'visible_name', 'Read')
1879
1880
self.main.vm.add_share(Share.from_notify_holder(share_holder, share_path))
1914
share = Share.from_notify_holder(share_holder, share_path)
1915
yield self.main.vm.add_share(share)
1881
1916
d = defer.Deferred()
1882
def share_handler(share_dict):
1883
"""Handler for ShareDeletedsignal."""
1884
d.callback(share_dict)
1885
1886
match = self.bus.add_signal_receiver(share_handler,
1887
signal_name='ShareDeleted')
1917
match = self.bus.add_signal_receiver(d.callback,
1918
signal_name='ShareDeleted')
1888
1919
self.signal_receivers.add(match)
1889
1920
1890
1921
def check(share_dict):
1897
1928
free_bytes='',
1898
1929
path=share_path,
1899
1930
accepted='',
1931
subscribed='',
1900
1932
access_level='Read',
1901
1933
generation='')
1902
1934
expected_dict['type'] = 'Share'
1904
1936
self.assertEquals(expected_dict[str(k)], str(v))
1905
1937
d.addCallback(check)
1906
1938
1907
match = self.bus.add_signal_receiver(share_handler,
1908
signal_name='ShareDeleted')
1909
self.signal_receivers.add(match)
1910
1911
1939
self.main.event_q.push('SV_SHARE_DELETED',
1912
1940
share_id=share_holder.share_id)
1913
return d
1941
yield d
1914
1942
1915
1943
def test_share_created(self):
1916
1944
"""Test the ShareCreated signal."""
1976
2004
new_generation='new_generation')
1977
2005
return d
1978
2006
2007
@defer.inlineCallbacks
1979
2008
def test_new_share(self):
1980
2009
"""Test the NewShare signal."""
1981
2010
share_path = os.path.join(self.main.shares_dir, 'share')
2005
2034
free_bytes='',
2006
2035
path=share_path,
2007
2036
accepted='True',
2037
subscribed='',
2008
2038
access_level='Read',
2009
2039
generation='')
2010
2040
expected_dict['type'] = 'Share'
2011
2041
for k, v in share_dict.items():
2012
2042
self.assertEquals(expected_dict[str(k)], str(v))
2013
2043
d.addCallback(check)
2014
self.main.vm.add_share(share)
2015
return d
2044
yield self.main.vm.add_share(share)
2045
yield d
2016
2046
2047
@defer.inlineCallbacks
2017
2048
def test_public_access_changed(self):
2018
2049
"""Test the PublicAccessChanged signal."""
2019
2050
d = defer.Deferred()
2031
2062
public_url = 'http://example.com'
2032
2063
2033
2064
share_path = os.path.join(self.shares_dir, 'share')
2034
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
2065
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
2035
2066
path = os.path.join(share_path, "foo")
2036
2067
self.fs_manager.create(path, str(share_id))
2037
2068
self.fs_manager.set_node_id(path, str(node_id))
2048
2079
self.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_OK',
2049
2080
share_id=share_id, node_id=node_id,
2050
2081
is_public=is_public, public_url=public_url)
2051
return d
2082
yield d
2052
2083
2084
@defer.inlineCallbacks
2053
2085
def test_public_access_change_error(self):
2054
2086
"""Test the PublicAccessChangeError signal."""
2055
2087
d = defer.Deferred()
2066
2098
expected_error = 'error message'
2067
2099
2068
2100
share_path = os.path.join(self.shares_dir, 'share')
2069
self.main.vm.add_share(Share(path=share_path, volume_id='share'))
2101
yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
2070
2102
path = os.path.join(share_path, "foo")
2071
2103
self.fs_manager.create(path, str(share_id))
2072
2104
self.fs_manager.set_node_id(path, str(node_id))
2082
2114
self.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_ERROR',
2083
2115
share_id=share_id, node_id=node_id,
2084
2116
error=expected_error)
2085
return d
2117
yield d
2086
2118
2087
2119
def test_root_mismatch(self):
2088
2120
"""Test RootMismatch signal."""
2104
2136
self.main.vm._got_root('another_root_id')
2105
2137
return d
2106
2138
2139
@defer.inlineCallbacks
2107
2140
def test_public_files_list(self):
2108
2141
"""Test the PublicAccessChanged signal."""
2109
2142
d = defer.Deferred()
2120
2153
public_url = 'http://example.com'
2121
2154
2122
2155
share_path = os.path.join(self.shares_dir, 'share')
2123
self.main.vm.add_share(Share(path=share_path, volume_id=volume_id))
2156
share = Share(path=share_path, volume_id=volume_id)
2157
yield self.main.vm.add_share(share)
2124
2158
path = os.path.join(share_path, "foo")
2125
2159
self.fs_manager.create(path, str(volume_id))
2126
2160
self.fs_manager.set_node_id(path, str(node_id))
2135
2169
d.addCallback(check)
2136
2170
pf = dict(volume_id=volume_id, node_id=node_id, public_url=public_url)
2137
2171
self.event_q.push('AQ_PUBLIC_FILES_LIST_OK', public_files=[pf])
2138
return d
2172
yield d
2139
2173
2140
2174
def test_public_files_list_error(self):
2141
2175
"""Test the PublicFilesListError signal."""
2179
2213
volume_id=volume_id, free_bytes=123)
2180
2214
return d
2181
2215
2216
@defer.inlineCallbacks
2182
2217
def test_quota_exceeded_for_share(self):
2183
2218
"""Test QuotaExceeded signal for share."""
2184
2219
volume_id = 'test this please'
2185
2220
path = 'test/path/bla'
2186
2221
name = 'Beatiful Stranger'
2187
a_share = Share(volume_id=volume_id, node_id=None, path=path, name=name,
2188
other_username=None, other_visible_name=None,
2189
accepted=False, access_level='View', free_bytes=None)
2190
self.main.vm.add_share(a_share)
2191
return self.assert_quota_exceeded(volume_id, _get_share_dict(a_share))
2222
share = Share(volume_id=volume_id, node_id=None, path=path, name=name,
2223
other_username=None, other_visible_name=None,
2224
accepted=False, access_level='View', free_bytes=None)
2225
yield self.main.vm.add_share(share)
2226
yield self.assert_quota_exceeded(volume_id, _get_share_dict(share))
2192
2227
2193
2228
def test_quota_exceeded_for_udf(self):
2194
2229
"""Test QuotaExceeded signal for UDF."""
2394
2429
error_handler=self.error_handler)
2395
2430
return d
2396
2431
2397
def test_autosubscribe_enabled(self):
2432
def test_udf_autosubscribe_enabled(self):
2398
2433
"""Test for Config.udf_autosubscribe_enabled."""
2399
2434
client = self.get_client()
2400
2435
d = defer.Deferred()
2417
2452
error_handler=self.error_handler)
2418
2453
return d
2419
2454
2420
def test_enable_autosubscribe(self):
2455
def test_enable_udf_autosubscribe(self):
2421
2456
"""Test for Config.enable_udf_autosubscribe."""
2422
2457
client = self.get_client()
2423
2458
d = defer.Deferred()
2430
2465
error_handler=self.error_handler)
2431
2466
return d
2432
2467
2433
def test_disable_autosubscribe(self):
2468
def test_disable_udf_autosubscribe(self):
2434
2469
"""Test for Config.disable_udf_autosubscribe."""
2435
2470
client = self.get_client()
2436
2471
d = defer.Deferred()
2443
2478
error_handler=self.error_handler)
2444
2479
return d
2445
2480
2481
def test_share_autosubscribe_enabled(self):
2482
"""Test for Config.share_autosubscribe_enabled."""
2483
client = self.get_client()
2484
d = defer.Deferred()
2485
2486
def reply_handler_disabled(result):
2487
"""Handle the reply."""
2488
self.assertFalse(result)
2489
config.get_user_config().set_share_autosubscribe(not result)
2490
client.call_method('share_autosubscribe_enabled',
2491
reply_handler=reply_handler_enabled,
2492
error_handler=self.error_handler)
2493
2494
def reply_handler_enabled(result):
2495
"""Handle the reply."""
2496
self.assertTrue(result)
2497
d.callback(True)
2498
2499
client.call_method('share_autosubscribe_enabled',
2500
reply_handler=reply_handler_disabled,
2501
error_handler=self.error_handler)
2502
return d
2503
2504
def test_enable_share_autosubscribe(self):
2505
"""Test for Config.enable_share_autosubscribe."""
2506
client = self.get_client()
2507
d = defer.Deferred()
2508
def reply_handler(_):
2509
"""Handle the reply."""
2510
self.assertTrue(config.get_user_config().get_share_autosubscribe())
2511
d.callback(True)
2512
client.call_method('enable_share_autosubscribe',
2513
reply_handler=reply_handler,
2514
error_handler=self.error_handler)
2515
return d
2516
2517
def test_disable_share_autosubscribe(self):
2518
"""Test for Config.disable_share_autosubscribe."""
2519
client = self.get_client()
2520
d = defer.Deferred()
2521
def reply_handler(_):
2522
"""Handle the reply."""
2523
self.assertFalse(config.get_user_config().get_share_autosubscribe())
2524
d.callback(True)
2525
client.call_method('disable_share_autosubscribe',
2526
reply_handler=reply_handler,
2527
error_handler=self.error_handler)
2528
return d
2529
2446
2530
def test_autoconnect_enabled(self):
2447
2531
"""Test for Config.autoconnect_enabled."""
2448
2532
client = self.get_client()
2938
3022
'VM_UDF_CREATE_ERROR', path=path, error="I'm broken")
2939
3023
return d
2940
3024
3025
@defer.inlineCallbacks
2941
3026
def test_delete(self):
2942
3027
"""Test for Folders.delete."""
2943
3028
suggested_path = u'~/ñoño'
2944
3029
udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
2945
self.main.vm.add_udf(udf)
3030
yield self.main.vm.add_udf(udf)
2946
3031
d = defer.Deferred()
2947
3032
def delete_volume(volume_id, path):
2948
3033
"""Fake delete_volume."""
2967
3052
self.folders_client.call_method('delete', udf.volume_id,
2968
3053
reply_handler=check_deleted,
2969
3054
error_handler=self.error_handler)
2970
return d
3055
yield d
2971
3056
3057
@defer.inlineCallbacks
2972
3058
def test_delete_error_signal(self):
2973
3059
"""Test for FolderDeleteError."""
2974
3060
suggested_path = u'~/ñoño'
2975
3061
udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
2976
self.main.vm.add_udf(udf)
3062
yield self.main.vm.add_udf(udf)
2977
3063
d = defer.Deferred()
2978
3064
# patch delete_volume to fail
2979
3065
def delete_volume(volume_id, path):
2992
3078
self.folders_client.call_method('delete', udf.volume_id,
2993
3079
reply_handler=lambda *args: None,
2994
3080
error_handler=self.error_handler)
2995
d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id))
2996
return d
3081
yield d
3082
self.main.vm.udf_deleted(udf.volume_id)
2997
3083
2998
3084
@defer.inlineCallbacks
2999
3085
def test_delete_error_signal_folder_id(self):
3086
3172
d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id))
3087
3173
yield d
3088
3174
3175
@defer.inlineCallbacks
3089
3176
def test_refresh_volumes(self):
3090
3177
"""Just check that refresh_volumes method works."""
3091
3178
client = DBusClient(self.bus, '/folders', DBUS_IFACE_FOLDERS_NAME)
3179
list_volumes_d = defer.Deferred()
3180
self.main.action_q.list_volumes = lambda: list_volumes_d.callback(True)
3181
3092
3182
d = defer.Deferred()
3093
def list_volumes():
3094
"""Stub list_volumes."""
3095
d.callback(True)
3096
self.main.action_q.list_volumes = list_volumes
3097
3183
client.call_method('refresh_volumes',
3098
reply_handler=lambda _: None,
3184
reply_handler=d.callback,
3099
3185
error_handler=self.error_handler)
3100
return d
3186
yield list_volumes_d
3187
yield d
3101
3188
3102
3189
3103
3190
class ShareTests(DBusTwistedTestCase):
3104
3191
"""Share specific tests."""
3105
3192
3193
@defer.inlineCallbacks
3194
def setUp(self):
3195
"""Setup the test."""
3196
yield DBusTwistedTestCase.setUp(self)
3197
self.client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3198
3199
def _create_share(self, volume_id=None, node_id=None, access_level='View',
3200
accepted=True, subscribed=False):
3201
"""Create a Share and return it."""
3202
share_path = os.path.join(self.main.shares_dir, 'share')
3203
if volume_id is None:
3204
volume_id = str(uuid.uuid4())
3205
if node_id is None:
3206
node_id = str(uuid.uuid4())
3207
share = Share(path=share_path, volume_id=volume_id, node_id=node_id,
3208
accepted=accepted, access_level=access_level,
3209
subscribed=subscribed)
3210
return share
3211
3212
@defer.inlineCallbacks
3106
3213
def test_delete_share(self):
3107
3214
"""Test for Shares.delete_share."""
3108
share_path = os.path.join(self.main.shares_dir, 'share')
3109
share = Share(path=share_path, volume_id='share_id',
3110
node_id='node_id', accepted=True)
3111
self.main.vm.add_share(share)
3215
share = self._create_share(accepted=True)
3216
yield self.main.vm.add_share(share)
3112
3217
d = defer.Deferred()
3113
3218
def delete_volume(volume_id, path):
3114
3219
"""Fake delete_volume."""
3115
3220
self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=volume_id)
3116
3221
self.main.action_q.delete_volume = delete_volume
3117
3222
def deleted_handler(info):
3118
"""FolderDeleted handler."""
3223
"""ShareDeleted handler."""
3119
3224
self.assertRaises(KeyError, self.main.fs.get_by_path,
3120
3225
info['path'].decode('utf-8'))
3121
3226
self.assertRaises(VolumeDoesNotExist,
3130
3235
self.assertRaises(KeyError, self.main.fs.get_by_path, share.path)
3131
3236
self.assertRaises(VolumeDoesNotExist,
3132
3237
self.main.vm.get_volume, share.volume_id)
3133
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3134
client.call_method('delete_share', share.volume_id,
3238
self.client.call_method('delete_share', share.volume_id,
3135
3239
reply_handler=check_deleted,
3136
3240
error_handler=self.error_handler)
3137
return d
3241
yield d
3138
3242
3243
@defer.inlineCallbacks
3139
3244
def test_delete_share_from_me(self):
3140
3245
"""Test for Shares.delete_share with share from_me."""
3141
share_path = os.path.join(self.main.shares_dir, 'share')
3142
share = Shared(path=share_path, volume_id='share_id',
3143
node_id='node_id', accepted=True)
3144
self.main.vm.add_shared(share)
3246
share = self._create_share(accepted=True)
3247
yield self.main.vm.add_shared(share)
3145
3248
d = defer.Deferred()
3146
3249
def delete_share(volume_id):
3147
3250
"""Fake delete_volume."""
3155
3258
match = self.bus.add_signal_receiver(deleted_handler,
3156
3259
signal_name='ShareDeleted')
3157
3260
self.signal_receivers.add(match)
3158
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3159
client.call_method('delete_share', share.volume_id,
3261
self.client.call_method('delete_share', share.volume_id,
3160
3262
reply_handler=lambda _: None,
3161
3263
error_handler=self.error_handler)
3162
return d
3264
yield d
3163
3265
3266
@defer.inlineCallbacks
3164
3267
def test_delete_share_error_signal(self):
3165
3268
"""Test for Shares.delete_share with an error."""
3166
share_path = os.path.join(self.main.shares_dir, 'share')
3167
share = Share(path=share_path, volume_id='share_id',
3168
node_id='node_id', accepted=True)
3169
self.main.vm.add_share(share)
3269
share = self._create_share(accepted=True)
3270
yield self.main.vm.add_share(share)
3170
3271
d = defer.Deferred()
3171
3272
# patch delete_volume to fail
3172
3273
def delete_volume(volume_id, path):
3175
3276
volume_id=volume_id, error="I'm broken")
3176
3277
self.main.action_q.delete_volume = delete_volume
3177
3278
def deleted_error_handler(info, error):
3178
"""FolderDeleteError handler."""
3279
"""ShareDeleteError handler."""
3179
3280
self.assertEquals(info['volume_id'], share.volume_id)
3180
3281
self.assertEquals(error, "I'm broken")
3181
3282
d.callback(True)
3182
3283
match = self.bus.add_signal_receiver(deleted_error_handler,
3183
3284
signal_name='ShareDeleteError')
3184
3285
self.signal_receivers.add(match)
3185
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3186
client.call_method('delete_share', share.volume_id,
3286
self.client.call_method('delete_share', share.volume_id,
3187
3287
reply_handler=lambda *args: None,
3188
3288
error_handler=self.error_handler)
3189
return d
3289
yield d
3190
3290
3291
@defer.inlineCallbacks
3191
3292
def test_delete_share_from_me_error(self):
3192
3293
"""Test failure of Shares.delete_share with a share from_me."""
3193
share_path = os.path.join(self.main.shares_dir, 'share')
3194
share = Shared(path=share_path, volume_id='share_id',
3195
node_id='node_id', accepted=True)
3196
self.main.vm.add_shared(share)
3294
share = self._create_share(accepted=True)
3295
yield self.main.vm.add_shared(share)
3197
3296
d = defer.Deferred()
3198
3297
# patch delete_share to fail
3199
3298
def delete_share(share_id):
3202
3301
share_id=share_id, error="I'm broken")
3203
3302
self.patch(self.main.action_q, 'delete_share', delete_share)
3204
3303
def deleted_error_handler(info, error):
3205
"""FolderDeleteError handler."""
3304
"""ShareDeleteError handler."""
3206
3305
self.assertEquals(info['volume_id'], share.volume_id)
3207
3306
self.assertEquals(error, "I'm broken")
3208
3307
d.callback(True)
3209
3308
match = self.bus.add_signal_receiver(deleted_error_handler,
3210
3309
signal_name='ShareDeleteError')
3211
3310
self.signal_receivers.add(match)
3212
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3213
client.call_method('delete_share', share.volume_id,
3311
self.client.call_method('delete_share', share.volume_id,
3214
3312
reply_handler=lambda *args: None,
3215
3313
error_handler=self.error_handler)
3216
return d
3314
yield d
3217
3315
3218
3316
def test_delete_share_from_me_doesnotexist(self):
3219
3317
"""Test failure of Shares.delete_share with a share from_me."""
3220
3318
d = defer.Deferred()
3221
3319
# patch delete_share to fail
3222
3320
def deleted_error_handler(info, error):
3223
"""FolderDeleteError handler."""
3321
"""ShareDeleteError handler."""
3224
3322
self.assertEquals(info['volume_id'], 'missing_share_id')
3225
3323
self.assertEquals(error, "DOES_NOT_EXIST")
3226
3324
d.callback(True)
3227
3325
match = self.bus.add_signal_receiver(deleted_error_handler,
3228
3326
signal_name='ShareDeleteError')
3229
3327
self.signal_receivers.add(match)
3230
client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3231
client.call_method('delete_share', 'missing_share_id',
3328
self.client.call_method('delete_share', 'missing_share_id',
3232
3329
reply_handler=lambda *args: None,
3233
3330
error_handler=self.error_handler)
3234
3331
return d
3235
3332
3333
@defer.inlineCallbacks
3334
def test_subscribe(self):
3335
"""Test for Shares.subscribe and that it fires a dbus signal."""
3336
share = self._create_share(accepted=True, subscribed=False)
3337
yield self.main.vm.add_share(share)
3338
3339
d = defer.Deferred()
3340
match = self.bus.add_signal_receiver(d.callback,
3341
signal_name='ShareSubscribed')
3342
self.signal_receivers.add(match)
3343
3344
match = self.bus.add_signal_receiver(lambda _, error: d.errback(error),
3345
signal_name='ShareSubscribeError')
3346
self.signal_receivers.add(match)
3347
3348
self.client.call_method('subscribe', share.volume_id,
3349
reply_handler=lambda x: None,
3350
error_handler=self.error_handler)
3351
info = yield d
3352
self.assertTrue(bool(info['subscribed']),
3353
"share %r should be subscribed" % share)
3354
yield self.main.vm.share_deleted(share.volume_id)
3355
3356
@defer.inlineCallbacks
3357
def test_subscribe_error(self):
3358
"""Test for Shares.subscribe when there is an error."""
3359
# do not add a share to have an error
3360
3361
d = defer.Deferred()
3362
3363
match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid),
3364
signal_name='ShareSubscribeError')
3365
self.signal_receivers.add(match)
3366
3367
match = self.bus.add_signal_receiver(d.errback,
3368
signal_name='ShareSubscribed')
3369
self.signal_receivers.add(match)
3370
3371
self.client.call_method('subscribe', 'invalid_id',
3372
reply_handler=lambda x: None,
3373
error_handler=self.error_handler)
3374
yield d
3375
3376
@defer.inlineCallbacks
3377
def test_unsubscribe(self):
3378
"""Test for Shares.unsubscribe."""
3379
share = self._create_share(accepted=True, subscribed=True)
3380
yield self.main.vm.add_share(share)
3381
3382
d = defer.Deferred()
3383
match = self.bus.add_signal_receiver(d.callback,
3384
signal_name='ShareUnSubscribed')
3385
self.signal_receivers.add(match)
3386
3387
match = self.bus.add_signal_receiver(lambda _, error: d.errback(error),
3388
signal_name='ShareUnSubscribeError')
3389
self.signal_receivers.add(match)
3390
3391
self.client.call_method('unsubscribe', share.volume_id,
3392
reply_handler=lambda x: None,
3393
error_handler=self.error_handler)
3394
info = yield d
3395
3396
self.assertFalse(info['subscribed'],
3397
"share %r should be subscribed" % share)
3398
3399
self.main.vm.share_deleted(share.volume_id)
3400
3401
@defer.inlineCallbacks
3402
def test_unsubscribe_error(self):
3403
"""Test for Shares.unsubscribe when there is an error."""
3404
# do not add a share to have an error
3405
3406
d = defer.Deferred()
3407
match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid),
3408
signal_name='ShareUnSubscribeError')
3409
self.signal_receivers.add(match)
3410
3411
match = self.bus.add_signal_receiver(d.errback,
3412
signal_name='ShareUnSubscribed')
3413
self.signal_receivers.add(match)
3414
3415
self.client.call_method('unsubscribe', 'invalid_id',
3416
reply_handler=lambda x: None,
3417
error_handler=self.error_handler)
3418
yield d
3419
3236
3420
3237
3421
def test_suite():
3238
3422
"""Collect these tests only on linux."""
Loggerhead is a web-based interface for Breezy
Version: 2.0.1