← Back to branch summary

~didrocks/ubuntuone-client/dont-suffer-zg-crash

« back to all changes in this revision

Viewing changes to tests/syncdaemon/test_vm.py

  • Committer: Bazaar Package Importer
  • Author(s): Rodney Dawes
  • Date: 2011-01-25 16:42:52 UTC
  • mto: This revision was merged to the branch mainline in revision 64.
  • Revision ID: james.westby@ubuntu.com-20110125164252-rl1pybasx1nsqgoy
Tags: upstream-1.5.3
Import upstream version 1.5.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/syncdaemon/test_vm.py
27
27
import os
28
28
import uuid
29
29
 
 
30
 
30
31
from ubuntuone.storageprotocol.client import ListShares
31
32
from ubuntuone.storageprotocol.sharersp import (
32
33
    NotifyShareHolder,
37
38
    FakeMain,
38
39
    BaseTwistedTestCase,
39
40
    environ,
40
 
    MementoHandler,
41
41
)
 
42
from ubuntuone.devtools.handlers import MementoHandler
42
43
from ubuntuone.syncdaemon import config, event_queue, tritcask
43
44
from ubuntuone.syncdaemon.volume_manager import (
44
45
    Share,
345
346
        self.main.fs.get_by_node_id("", 'node_id')
346
347
 
347
348
        # helper method, pylint: disable-msg=C0111
348
 
        def fake_create_share(node_id, user, name, access_level, marker):
 
349
        def fake_create_share(node_id, user, name, access_level, marker, path):
349
350
            self.assertIn(marker, self.vm.marker_share_map)
350
351
            self.vm.handle_AQ_CREATE_SHARE_OK(share_id='share_id',
351
352
                                              marker=marker)
368
369
        self.main.fs.get_by_node_id("", 'node_id')
369
370
 
370
371
        # helper method, pylint: disable-msg=C0111
371
 
        def fake_create_share(node_id, user, name, access_level, marker):
 
372
        def fake_create_share(node_id, user, name, access_level, marker, path):
372
373
            self.assertEquals('node_id', node_id)
373
374
            self.assertEquals('fake_user', user)
374
375
            self.assertEquals('shared_name', name)
392
393
        self.main.fs.get_by_node_id("", 'node_id')
393
394
 
394
395
        # helper method, pylint: disable-msg=C0111
395
 
        def fake_create_share(node_id, user, name, access_level, marker):
 
396
        def fake_create_share(node_id, user, name, access_level, marker, path):
396
397
            self.vm.handle_AQ_CREATE_SHARE_ERROR(marker, 'a fake error')
397
398
 
398
399
        self.main.action_q.create_share = fake_create_share
407
408
        expected_share_id = uuid.uuid4()
408
409
 
409
410
        # helper method, pylint: disable-msg=C0111
410
 
        def fake_create_share(node_id, user, name, access_level, marker):
 
411
        def fake_create_share(node_id, user, name, access_level, marker, path):
411
412
            # some sanity checks
412
413
            share = self.vm.marker_share_map[marker]
413
414
            self.assertEquals(path, share.path)
1379
1380
        self.vm.add_share(share)
1380
1381
        d = defer.Deferred()
1381
1382
        # patch AQ.delete_volume
1382
 
        def delete_volume(volume_id):
 
1383
        def delete_volume(volume_id, path):
1383
1384
            """Fake delete_volume"""
1384
1385
            self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=volume_id)
1385
1386
        self.main.action_q.delete_volume = delete_volume
1413
1414
        yield d
1414
1415
 
1415
1416
    @defer.inlineCallbacks
 
1417
    def test_delete_volume_aq_args(self):
 
1418
        """Test that VolumeManager.delete_volume calls AQ.delete_volume."""
 
1419
        suggested_path = "suggested_path"
 
1420
        udf, volume = self._create_udf(uuid.uuid4(), 'udf_node_id',
 
1421
                                       '~/' + suggested_path, subscribed=False)
 
1422
        yield self.vm.add_udf(udf)
 
1423
        d = defer.Deferred()
 
1424
        # patch AQ.delete_volume
 
1425
        def delete_volume(volume_id, path):
 
1426
            """Fake AQ.delete_volume."""
 
1427
            if volume_id == udf.volume_id and path == udf.path:
 
1428
                d.callback(None)
 
1429
            else:
 
1430
                d.errback(Exception(""))
 
1431
        self.patch(self.main.action_q, 'delete_volume', delete_volume)
 
1432
        with environ('HOME', self.home_dir):
 
1433
            self.vm.delete_volume(udf.volume_id)
 
1434
        yield d
 
1435
 
 
1436
    @defer.inlineCallbacks
1416
1437
    def test_subscribe_udf(self):
1417
1438
        """Test VolumeManager.subscribe_udf method."""
1418
1439
        # create and add a UDF
1755
1776
        yield self.vm.add_udf(udf)
1756
1777
        d = defer.Deferred()
1757
1778
        # patch AQ.delete_volume
1758
 
        def delete_volume(path):
 
1779
        def delete_volume(vol_id, path):
1759
1780
            """Fake delete_volume"""
1760
 
            self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=udf.volume_id)
 
1781
            self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=vol_id)
1761
1782
        self.main.action_q.delete_volume = delete_volume
1762
1783
        def check(info):
1763
1784
            """Check the udf attributes."""
1782
1803
        yield self.vm.add_udf(udf)
1783
1804
        d = defer.Deferred()
1784
1805
        # patch AQ.delete_volume
1785
 
        def delete_volume(path):
 
1806
        def delete_volume(vol_id, path):
1786
1807
            """Fake delete_volume"""
1787
1808
            self.main.event_q.push("AQ_DELETE_VOLUME_ERROR",
1788
 
                                   volume_id=udf.volume_id, error="ERROR!")
 
1809
                                   volume_id=vol_id, error="ERROR!")
1789
1810
        self.main.action_q.delete_volume = delete_volume
1790
1811
        def check(info):
1791
1812
            """Check the udf attributes."""
1808
1829
        self.assertTrue(self.handler.check_warning("missing volume id"))
1809
1830
 
1810
1831
    @defer.inlineCallbacks
1811
 
    def _test_handle_SV_VOLUME_CREATED(self, auto_subscribe):
1812
 
        """Test for handle_SV_VOLUME_CREATED."""
1813
 
        user_conf = config.get_user_config()
1814
 
        user_conf.set_udf_autosubscribe(auto_subscribe)
 
1832
    def test_handle_SV_VOLUME_CREATED_share(self):
 
1833
        """Test for handle_SV_VOLUME_CREATED with shares."""
1815
1834
        # start the test
1816
 
        udf_id = uuid.uuid4()
1817
 
        udf_volume = volumes.UDFVolume(udf_id, 'udf_uuid', None, 10, u'~/ñoño')
1818
1835
        share_id = uuid.uuid4()
1819
 
        share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
1820
 
                                           10, 'to_me', u'ñoño',
1821
 
                                           'username', u'visible_username',
1822
 
                                           True, 'View')
 
1836
        share_volume = volumes.ShareVolume(
 
1837
            share_id, 'fake_share_uuid', None, 10, 'to_me', u'ñoño',
 
1838
            'username', u'visible_username',
 
1839
            False, # this is how the protocol send it
 
1840
            'View')
1823
1841
        # initialize the the root
1824
1842
        self.vm._got_root('root_uuid')
1825
 
 
1826
 
        d = defer.Deferred()
1827
 
        self._listen_for('VM_UDF_CREATED', d.callback)
1828
 
        rescan_cb = defer.Deferred()
1829
 
        self.patch(self.main.action_q, 'rescan_from_scratch', rescan_cb.callback)
1830
 
 
1831
 
        with environ('HOME', self.home_dir):
1832
 
            self.vm.handle_SV_VOLUME_CREATED(udf_volume)
1833
 
        info = yield d
1834
 
        udf = info['udf']
1835
 
        self.assertEquals(udf.volume_id, str(udf_id))
1836
 
        self.assertIn(str(udf_id), self.vm.udfs)
1837
 
        if auto_subscribe:
1838
 
            self.assertTrue(udf.subscribed)
1839
 
            self.assertTrue(os.path.exists(udf.path))
1840
 
            # check that rescan_from_scratch is called
1841
 
            vol_id = yield rescan_cb
1842
 
            self.assertEqual(vol_id, udf.volume_id)
1843
 
        else:
1844
 
            self.assertFalse(udf.subscribed)
1845
 
            self.assertFalse(os.path.exists(udf.path))
1846
 
        # subscribe a new listener
1847
1843
        d = defer.Deferred()
1848
1844
        self._listen_for('VM_SHARE_CREATED', d.callback)
1849
1845
        rescan_cb = defer.Deferred()
1860
1856
        vol_id = yield rescan_cb
1861
1857
        self.assertEqual(vol_id, share.volume_id)
1862
1858
 
1863
 
    def test_handle_SV_VOLUME_CREATED_subscribe(self):
 
1859
    @defer.inlineCallbacks
 
1860
    def _test_handle_SV_VOLUME_CREATED_udf(self, auto_subscribe):
 
1861
        """Test for handle_SV_VOLUME_CREATED with udfs."""
 
1862
        user_conf = config.get_user_config()
 
1863
        user_conf.set_udf_autosubscribe(auto_subscribe)
 
1864
        # start the test
 
1865
        udf_id = uuid.uuid4()
 
1866
        udf_volume = volumes.UDFVolume(udf_id, 'udf_uuid', None, 10, u'~/ñoño')
 
1867
        # initialize the the root
 
1868
        self.vm._got_root('root_uuid')
 
1869
 
 
1870
        d = defer.Deferred()
 
1871
        self._listen_for('VM_UDF_CREATED', d.callback)
 
1872
        rescan_cb = defer.Deferred()
 
1873
        self.patch(self.main.action_q, 'rescan_from_scratch', rescan_cb.callback)
 
1874
 
 
1875
        with environ('HOME', self.home_dir):
 
1876
            self.vm.handle_SV_VOLUME_CREATED(udf_volume)
 
1877
        info = yield d
 
1878
        udf = info['udf']
 
1879
        self.assertEquals(udf.volume_id, str(udf_id))
 
1880
        self.assertIn(str(udf_id), self.vm.udfs)
 
1881
        if auto_subscribe:
 
1882
            self.assertTrue(udf.subscribed)
 
1883
            self.assertTrue(os.path.exists(udf.path))
 
1884
            # check that rescan_from_scratch is called
 
1885
            vol_id = yield rescan_cb
 
1886
            self.assertEqual(vol_id, udf.volume_id)
 
1887
        else:
 
1888
            self.assertFalse(udf.subscribed)
 
1889
            self.assertFalse(os.path.exists(udf.path))
 
1890
 
 
1891
    def test_handle_SV_VOLUME_CREATED_udf_subscribe(self):
1864
1892
        """Test SV_VOLUME_CREATED with udf auto_subscribe """
1865
 
        return self._test_handle_SV_VOLUME_CREATED(True)
 
1893
        return self._test_handle_SV_VOLUME_CREATED_udf(True)
1866
1894
 
1867
 
    def test_handle_SV_VOLUME_CREATED_no_subscribe(self):
 
1895
    def test_handle_SV_VOLUME_CREATED_udf_no_subscribe(self):
1868
1896
        """Test SV_VOLUME_CREATED without udf auto_subscribe """
1869
 
        return self._test_handle_SV_VOLUME_CREATED(False)
 
1897
        return self._test_handle_SV_VOLUME_CREATED_udf(False)
1870
1898
 
1871
1899
    @defer.inlineCallbacks
1872
1900
    def test_handle_SV_VOLUME_DELETED(self):
3095
3123
 
3096
3124
    def test_get_key(self):
3097
3125
        """Test for the _get_key method."""
3098
 
        self.assertEqual(self.shelf.key, self.shelf._get_key(request.ROOT))
 
3126
        self.assertEqual(self.shelf._root_key,
 
3127
                         self.shelf._get_key(request.ROOT))
3099
3128
        self.assertEqual('foo', self.shelf._get_key('foo'))
3100
3129