← Back to branch summary

~facundo/ubuntuone-client/lr-dont-delete-partial-nopartialfile

« back to all changes in this revision

Viewing changes to tests/syncdaemon/test_vm.py

  • Committer: Tarmac
  • Author(s): guillermo.gonzalez at canonical
  • Date: 2010-09-24 08:44:39 UTC
  • mfrom: (716.3.5 fix-645519)
  • Revision ID: tarmac-20100924084439-3mdg6qr39r5jvhvz
Fix delete_share DBus method to actually delete shares

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/syncdaemon/test_vm.py
412
412
        share = self.vm.shared[str(expected_share_id)]
413
413
        self.assertEquals(str(expected_node_id), share.node_id)
414
414
 
 
415
    @defer.inlineCallbacks
 
416
    def test_delete_shared(self):
 
417
        """Test VolumeManager.delete_share."""
 
418
        path = os.path.join(self.vm.root.path, 'shared_path')
 
419
        self.main.fs.create(path, "")
 
420
        self.main.fs.set_node_id(path, 'node_id')
 
421
        share = Shared(path=path, volume_id='share_id', node_id="node_id")
 
422
        self.vm.add_shared(share)
 
423
 
 
424
        def fake_delete_share(share_id):
 
425
            """Fake delete_share."""
 
426
            self.assertEqual(share_id, share.volume_id)
 
427
            self.main.event_q.push('AQ_DELETE_SHARE_OK', share_id)
 
428
 
 
429
        self.patch(self.main.action_q, 'delete_share', fake_delete_share)
 
430
        d = defer.Deferred()
 
431
        self._listen_for('VM_SHARE_DELETED', d.callback, 1, collect=True)
 
432
        self.vm.delete_share(share.volume_id)
 
433
        events = yield d
 
434
        event = events[0]
 
435
        self.assertEqual(event[0], (share,))
 
436
 
 
437
    @defer.inlineCallbacks
 
438
    def test_delete_shared_error(self):
 
439
        """Test VolumeManager.delete_share."""
 
440
        path = os.path.join(self.vm.root.path, 'shared_path')
 
441
        self.main.fs.create(path, "")
 
442
        self.main.fs.set_node_id(path, 'node_id')
 
443
        share = Shared(path=path, volume_id='share_id', node_id="node_id")
 
444
        self.vm.add_shared(share)
 
445
 
 
446
        def fake_delete_share(share_id):
 
447
            """Fake delete_share that always fails."""
 
448
            self.main.event_q.push('AQ_DELETE_SHARE_ERROR',
 
449
                                   share_id, 'a fake error')
 
450
 
 
451
        self.patch(self.main.action_q, 'delete_share', fake_delete_share)
 
452
        d = defer.Deferred()
 
453
        self._listen_for('VM_SHARE_DELETE_ERROR', d.callback, 1, collect=True)
 
454
        self.vm.delete_share(share.volume_id)
 
455
        events = yield d
 
456
        event = events[0]
 
457
        self.assertEqual(event[0], (share.volume_id, 'a fake error'))
 
458
 
 
459
    @defer.inlineCallbacks
 
460
    def test_delete_shared_error_missing_share(self):
 
461
        """Test VolumeManager.delete_share with a non-existent share."""
 
462
        path = os.path.join(self.vm.root.path, 'shared_path')
 
463
        self.main.fs.create(path, "")
 
464
        self.main.fs.set_node_id(path, 'node_id')
 
465
        d = defer.Deferred()
 
466
        self._listen_for('VM_SHARE_DELETE_ERROR', d.callback, 1, collect=True)
 
467
        self.vm.delete_share('fake_share_id')
 
468
        events = yield d
 
469
        event = events[0]
 
470
        self.assertEqual(event[0], ('fake_share_id', 'DOES_NOT_EXIST'))
 
471
 
415
472
    def test_accept_share(self):
416
473
        """ Test the accept_share method. """
417
474
        d = defer.Deferred()
680
737
        self.assertTrue(os.path.exists(share.path),
681
738
                        'share path missing on disk!')
682
739
 
 
740
    @defer.inlineCallbacks
 
741
    def test_handle_AQ_DELETE_SHARE_OK(self):
 
742
        """Test for handle_AQ_DELETE_SHARE_OK."""
 
743
        path = os.path.join(self.vm.root.path, 'shared_path')
 
744
        self.main.fs.create(path, "")
 
745
        self.main.fs.set_node_id(path, 'node_id')
 
746
        share = Shared(path=path, volume_id='share_id', node_id="node_id")
 
747
        self.vm.add_shared(share)
 
748
        d = defer.Deferred()
 
749
        self._listen_for('VM_SHARE_DELETED', d.callback, 1, collect=True)
 
750
        self.main.event_q.push('AQ_DELETE_SHARE_OK', 'share_id')
 
751
        events = yield d
 
752
        event = events[0]
 
753
        self.assertEqual(event[0], (share,))
 
754
 
 
755
    @defer.inlineCallbacks
 
756
    def test_handle_AQ_DELETE_SHARE_ERROR(self):
 
757
        """Test for handle_AQ_DELETE_SHARE_ERROR."""
 
758
        path = os.path.join(self.vm.root.path, 'shared_path')
 
759
        self.main.fs.create(path, "")
 
760
        self.main.fs.set_node_id(path, 'node_id')
 
761
        share = Shared(path=path, volume_id='share_id', node_id="node_id")
 
762
        self.vm.add_shared(share)
 
763
        d = defer.Deferred()
 
764
        self._listen_for('VM_SHARE_DELETE_ERROR', d.callback, 1, collect=True)
 
765
        self.main.event_q.push('AQ_DELETE_SHARE_ERROR',
 
766
                               'share_id', 'a fake error')
 
767
        events = yield d
 
768
        event = events[0]
 
769
        self.assertEqual(event[0], (share.volume_id, 'a fake error'))
 
770
 
683
771
 
684
772
class VolumeManagerUnicodeTests(BaseVolumeManagerTests):
685
773
    """Tests for Volume Manager unicode capabilities."""
1008
1096
        """Test the handling of the AQ_LIST_VOLUMES event."""
1009
1097
        share_id = uuid.uuid4()
1010
1098
        share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
1011
 
                                           10, 'to_me', u'ñoño'.encode("utf8"),
1012
 
                                           'username', 'visible_username',
 
1099
                                           10, 'to_me', u'ñoño',
 
1100
                                           'username', u'visible_username',
1013
1101
                                           True, 'View')
1014
1102
        udf_id = uuid.uuid4()
1015
1103
        udf_volume = volumes.UDFVolume(udf_id, 'udf_uuid', None, 10, u'~/ñoño')
1028
1116
        self.assertIn(str(share_id), self.vm.shares)
1029
1117
        self.assertIn(str(udf_id), self.vm.udfs)
1030
1118
        share = self.vm.shares[str(share_id)]
1031
 
        self.assertEqual(u'ñoño'.encode("utf8"), share.name)
 
1119
        self.assertEqual(u'ñoño', share.name)
1032
1120
        self.assertEqual('fake_share_uuid', share.node_id)
1033
1121
        udf = self.vm.udfs[str(udf_id)]
1034
1122
        self.assertEqual('udf_uuid', udf.node_id)
1140
1228
        yield self.vm.add_udf(udf)
1141
1229
        share_id = uuid.uuid4()
1142
1230
        share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
1143
 
                                           10, 'to_me', u'ñoño'.encode("utf8"),
1144
 
                                           'username', 'visible_username',
 
1231
                                           10, 'to_me', u'ñoño',
 
1232
                                           'username', u'visible_username',
1145
1233
                                           True, 'View')
1146
1234
        dir_name = self.vm._build_share_path(share_volume.share_name,
1147
1235
                                          share_volume.other_visible_name)
1604
1692
        udf_volume = volumes.UDFVolume(udf_id, 'udf_uuid', None, 10, u'~/ñoño')
1605
1693
        share_id = uuid.uuid4()
1606
1694
        share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
1607
 
                                           10, 'to_me', u'ñoño'.encode("utf8"),
1608
 
                                           'username', 'visible_username',
 
1695
                                           10, 'to_me', u'ñoño',
 
1696
                                           'username', u'visible_username',
1609
1697
                                           True, 'View')
1610
1698
        # initialize the the root
1611
1699
        self.vm._got_root('root_uuid')
1656
1744
        """Test for handle_SV_VOLUME_DELETED."""
1657
1745
        share_id = uuid.uuid4()
1658
1746
        share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
1659
 
                                           10, 'to_me', u'ñoño'.encode("utf8"),
1660
 
                                           'username', 'visible_username',
 
1747
                                           10, 'to_me', u'ñoño',
 
1748
                                           'username', u'visible_username',
1661
1749
                                           True, 'View')
1662
1750
        dir_name = self.vm._build_share_path(share_volume.share_name,
1663
1751
                                          share_volume.other_visible_name)
1665
1753
        share = Share.from_share_volume(share_volume, share_path)
1666
1754
        # create a UDF
1667
1755
        udf_id = uuid.uuid4()
1668
 
        udf, udf_volume = self._create_udf(udf_id, 'udf_uuid',
1669
 
                                           u'~/ñoño'.encode("utf8"))
 
1756
        udf, udf_volume = self._create_udf(udf_id, 'udf_uuid', u'~/ñoño')
1670
1757
        yield self.vm.add_udf(udf)
1671
1758
        self.vm.add_share(share)
1672
1759
        # initialize the the root