← Back to branch summary

~didrocks/ubuntuone-client/use_result_var

« back to all changes in this revision

Viewing changes to tests/syncdaemon/test_localrescan.py

  • 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

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/syncdaemon/test_localrescan.py
45
45
    def __init__(self):
46
46
        self.pushed = []
47
47
 
48
 
    def push(self, event, *args):
 
48
    def push(self, event, **kwargs):
49
49
        """Store stuff as pushed."""
50
 
        self.pushed.append((event,) + args)
 
50
        self.pushed.append((event, kwargs))
51
51
 
52
52
    def _fake(self, *a, **k):
53
53
        """fake"""
119
119
        self.rmtree(self.tmpdir)
120
120
        testcase.BaseTwistedTestCase.tearDown(self)
121
121
 
122
 
    @staticmethod
123
 
    def create_share(share_id, share_name, fsm, shares_dir,
124
 
                     access_level='Modify', accepted=True):
125
 
        """ creates a share """
126
 
        share_path = os.path.join(shares_dir, share_name)
 
122
    @defer.inlineCallbacks
 
123
    def create_share(self, share_id, share_name,
 
124
                     access_level='Modify', accepted=True, subscribed=True):
 
125
        """Create a share."""
 
126
        share_path = os.path.join(self.shares_dir, share_name)
127
127
        os.makedirs(share_path)
128
128
        share = volume_manager.Share(path=share_path, volume_id=share_id,
129
129
                                     access_level=access_level,
130
 
                                     accepted=accepted)
131
 
        fsm.vm.add_share(share)
132
 
        return share
 
130
                                     accepted=accepted,
 
131
                                     subscribed=subscribed)
 
132
        yield self.fsm.vm.add_share(share)
 
133
        defer.returnValue(share)
133
134
 
 
135
    @defer.inlineCallbacks
134
136
    def create_udf(self, udf_id, node_id, suggested_path, path, subscribed,
135
137
                   generation=None, free_bytes=100):
136
138
        """Create an UDF and add it to the volume manager."""
138
140
                                   suggested_path.decode('utf-8'))
139
141
        udf = volume_manager.UDF.from_udf_volume(volume, path)
140
142
        udf.subscribed = subscribed
141
 
        self.fsm.vm.add_udf(udf)
142
 
        return udf
 
143
        yield self.fsm.vm.add_udf(udf)
 
144
        defer.returnValue(udf)
143
145
 
144
146
    def create_node(self, path, is_dir, real=True, which_share=None):
145
147
        """Creates a node, really (maybe) and in the metadata."""
188
190
        lr.start()
189
191
        self.assertEqual(toscan, [self.vm.root.path])
190
192
 
 
193
    @defer.inlineCallbacks
191
194
    def test_empty_rw(self):
192
195
        """Test with one empty Modify share."""
193
196
        # create the share
194
 
        share = self.create_share('share_id', 'rw_share',  self.fsm,
195
 
                                       self.shares_dir, access_level='Modify')
 
197
        share = yield self.create_share('share_id', 'rw_share',
 
198
                                        access_level='Modify')
196
199
        self.fsm.create(share.path, "share_id", is_dir=True)
197
200
        self.fsm.set_node_id(share.path, "uuid")
198
201
 
209
212
        lr.start()
210
213
        self.assertEqual(sorted(toscan), [share.path, self.vm.root.path])
211
214
 
 
215
    @defer.inlineCallbacks
212
216
    def test_not_empty_rw(self):
213
217
        """Test with a Modify share with info."""
214
218
        # create the share
215
 
        share = self.create_share('share_id', 'ro_share',  self.fsm,
216
 
                                       self.shares_dir, access_level='Modify')
 
219
        share = yield self.create_share('share_id', 'ro_share',
 
220
                                        access_level='Modify')
217
221
        self.fsm.create(share.path, "share_id", is_dir=True)
218
222
        self.fsm.set_node_id(share.path, "uuid1")
219
223
 
236
240
        lr.start()
237
241
        self.assertEqual(sorted(toscan), [share.path, self.vm.root.path])
238
242
 
 
243
    @defer.inlineCallbacks
239
244
    def test_deleted_rw(self):
240
245
        """Test with a deleted rw share."""
241
246
        # create the share
242
 
        share = self.create_share('share_id', 'rw_share',  self.fsm,
243
 
                                  self.shares_dir, access_level='Modify')
 
247
        share = yield self.create_share('share_id', 'rw_share',
 
248
                                        access_level='Modify')
244
249
        self.fsm.create(share.path, "share_id", is_dir=True)
245
250
        self.fsm.set_node_id(share.path, "uuid")
246
251
 
265
270
        self.assertEqual(vol_id, share.volume_id)
266
271
        self.assertEqual(sorted(toscan), [self.vm.root.path])
267
272
 
 
273
    @defer.inlineCallbacks
268
274
    def test_deleted_rw_not_empty(self):
269
275
        """Test with a deleted rw share with some nodes in it."""
270
276
        # create the share
271
 
        share = self.create_share('share_id', 'rw_share',  self.fsm,
272
 
                                  self.shares_dir, access_level='Modify')
 
277
        share = yield self.create_share('share_id', 'rw_share',
 
278
                                        access_level='Modify')
273
279
        self.fsm.create(share.path, "share_id", is_dir=True)
274
280
        self.fsm.set_node_id(share.path, "uuid")
275
281
 
306
312
        """Test with a deleted udf."""
307
313
        # create the udf
308
314
        udf_path = os.path.expanduser("~/myudf")
309
 
        udf = self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
 
315
        udf = yield self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
310
316
                                    udf_path, True)
311
317
        os.makedirs(udf.path)
312
318
        self.fsm.create(udf.path, 'udf_id', is_dir=True)
336
342
class VolumeTestCase(BaseTestCase):
337
343
    """Test how LocalRescan manages volumes."""
338
344
 
 
345
    @defer.inlineCallbacks
339
346
    def setUp(self):
340
347
        """Init."""
341
 
        BaseTestCase.setUp(self)
 
348
        yield BaseTestCase.setUp(self)
342
349
 
343
350
        self.env_var = 'HOME'
344
351
        self.old_value = os.environ.get(self.env_var, None)
354
361
            path = os.path.expanduser(suggested_path).encode("utf8")
355
362
            os.makedirs(path)
356
363
            udf_id, node_id = 'udf_id%i' % i, 'node_id%i' % i
357
 
            udf = self.create_udf(udf_id, node_id, suggested_path, path, True)
 
364
            udf = yield self.create_udf(udf_id, node_id, suggested_path,
 
365
                                        path, True)
358
366
            self.volumes.append(udf)
359
367
 
360
368
            # make FSM aware of it
492
500
 
493
501
    timeout = 2
494
502
 
 
503
    @defer.inlineCallbacks
495
504
    def setUp(self):
496
505
        """Set up the test."""
497
506
        BaseTestCase.setUp(self)
499
508
        self.lr = LocalRescan(self.vm, self.fsm, self.eq, self.aq)
500
509
 
501
510
        # create a share
502
 
        self.share = self.create_share('share_id', 'ro_share',  self.fsm,
503
 
                                       self.shares_dir, access_level='Modify')
 
511
        self.share = yield self.create_share('share_id', 'ro_share',
 
512
                                             access_level='Modify')
504
513
        self.fsm.create(self.share.path, "share_id", is_dir=True)
505
514
        self.fsm.set_node_id(self.share.path, "uuidshare")
506
515
        self.share.node_id = "uuidshare"
534
543
 
535
544
    timeout = 20
536
545
 
 
546
    @defer.inlineCallbacks
537
547
    def setUp(self):
538
 
        TwistedBase.setUp(self)
 
548
        yield TwistedBase.setUp(self)
539
549
 
540
550
        # create an udf
541
551
        udf_path = os.path.join(self.home_dir, "myudf")
542
552
        os.mkdir(udf_path)
543
 
        self.udf = self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
544
 
                                   udf_path, True)
 
553
        self.udf = yield self.create_udf('udf_id', 'udf_root_node_id',
 
554
                                         "~/myudf", udf_path, True)
545
555
        self.fsm.create(self.udf.path, 'udf_id', is_dir=True)
546
556
        self.fsm.set_node_id(self.udf.path, 'udf_root_node_id')
547
557
 
953
963
        reactor.callLater(.2, self.deferred.callback, None)
954
964
        return self.deferred
955
965
 
 
966
    @defer.inlineCallbacks
956
967
    def test_one_dir_ro_share(self):
957
968
        """The dir is in a share that's RO, no error but no action."""
958
969
        # create the share
959
 
        share = self.create_share('share_id', 'ro_share2',  self.fsm,
960
 
                                       self.shares_dir, access_level='View')
 
970
        share = yield self.create_share('share_id', 'ro_share2',
 
971
                                        access_level='View')
961
972
        self.fsm.create(share.path, "share_id", is_dir=True)
962
973
        self.fsm.set_node_id(share.path, "uuidshare")
963
974
 
1008
1019
        def check(_):
1009
1020
            """check"""
1010
1021
            self.assertEqual(self.eq.pushed, [
1011
 
                ('LR_SCAN_ERROR', "mdid", False),
 
1022
                ('LR_SCAN_ERROR', dict(mdid="mdid", udfmode=False)),
1012
1023
            ])
1013
1024
 
1014
1025
        self.deferred.addCallback(check)
1025
1036
        def check(_):
1026
1037
            """check"""
1027
1038
            self.assertEqual(self.eq.pushed, [
1028
 
                ('LR_SCAN_ERROR', "mdid", True),
 
1039
                ('LR_SCAN_ERROR', dict(mdid="mdid", udfmode=True)),
1029
1040
            ])
1030
1041
 
1031
1042
        self.deferred.addCallback(check)
1154
1165
    """Test that simultaneus calls are queued."""
1155
1166
    timeout = 2
1156
1167
 
 
1168
    @defer.inlineCallbacks
1157
1169
    def setUp(self):
1158
1170
        """set up the test."""
1159
 
        BaseTestCase.setUp(self)
 
1171
        yield BaseTestCase.setUp(self)
1160
1172
        self.deferred = defer.Deferred()
1161
1173
        self.eq = event_queue.EventQueue(self.fsm)
1162
1174
        self.lr = LocalRescan(self.vm, self.fsm, self.eq, self.aq)
1163
1175
 
1164
1176
        # create two shares
1165
 
        self.share1 = self.create_share('share_id1', 'ro_share_1',  self.fsm,
1166
 
                                       self.shares_dir, access_level='Modify')
 
1177
        self.share1 = yield self.create_share('share_id1', 'ro_share_1',
 
1178
                                              access_level='Modify')
1167
1179
        self.fsm.create(self.share1.path, "share_id1", is_dir=True)
1168
1180
        self.fsm.set_node_id(self.share1.path, "uuidshare1")
1169
 
        self.share2 = self.create_share('share_id2', 'ro_share_2',  self.fsm,
1170
 
                                       self.shares_dir, access_level='Modify')
 
1181
        self.share2 = yield self.create_share('share_id2', 'ro_share_2',
 
1182
                                              access_level='Modify')
1171
1183
        self.fsm.create(self.share2.path, "share_id2", is_dir=True)
1172
1184
        self.fsm.set_node_id(self.share2.path, "uuidshare2")
1173
1185
 
2006
2018
        self.startTest(check)
2007
2019
        return self.deferred
2008
2020
 
 
2021
    @defer.inlineCallbacks
2009
2022
    def test_SERVER_file_ro_share(self):
2010
2023
        """We were downloading the file, but it was interrupted in RO share."""
2011
2024
        # create the file in metadata
2012
 
        ro_share = self.create_share('share_ro_id', 'share_ro2',  self.fsm,
2013
 
                                       self.shares_dir, access_level='View')
 
2025
        ro_share = yield self.create_share('share_ro_id', 'share_ro2',
 
2026
                                           access_level='View')
2014
2027
        self.fsm.create(ro_share.path, ro_share.id, is_dir=True)
2015
2028
        self.fsm.set_node_id(ro_share.path, "uuidshare")
2016
2029
        path = os.path.join(ro_share.path, "a")
2039
2052
            self.assertTrue(self.handler.check_debug("comp yield", "SERVER"))
2040
2053
 
2041
2054
        self.startTest(check)
2042
 
        return self.deferred
 
2055
        yield self.deferred
2043
2056
 
 
2057
    @defer.inlineCallbacks
2044
2058
    def test_SERVER_dir_ro_share(self):
2045
2059
        """Found a dir in SERVER in a ro_share.
2046
2060
 
2047
2061
        This was valid before, but no more, so we just fix and log in warning.
2048
2062
        """
2049
2063
        # create the dir in metadata
2050
 
        ro_share = self.create_share('share_ro_id', 'share_ro2',  self.fsm,
2051
 
                                       self.shares_dir, access_level='View')
 
2064
        ro_share = yield self.create_share('share_ro_id', 'share_ro2',
 
2065
                                           access_level='View')
2052
2066
        self.fsm.create(ro_share.path, ro_share.id, is_dir=True)
2053
2067
        self.fsm.set_node_id(ro_share.path, "uuidshare")
2054
2068
 
2077
2091
                                                "Found a directory in SERVER"))
2078
2092
 
2079
2093
        self.startTest(check)
2080
 
        return self.deferred
 
2094
        yield self.deferred
2081
2095
 
2082
2096
    def test_check_stat_None(self):
2083
2097
        """Test check_stat with oldstat = None."""
2135
2149
        self.fsm.set_node_id(self.vm.root.path, self.vm.root.node_id)
2136
2150
        return self._test_it(self.vm.root)
2137
2151
 
 
2152
    @defer.inlineCallbacks
2138
2153
    def test_SERVER_share(self):
2139
2154
        """We were downloading the share root dir but it was interrupted."""
2140
2155
        # create a share
2141
 
        share = self.create_share('share_id_1', 'rw_share',  self.fsm,
2142
 
                                       self.shares_dir, access_level='Modify')
 
2156
        share = yield self.create_share('share_id_1', 'rw_share',
 
2157
                                        access_level='Modify')
2143
2158
        self.fsm.create(share.path, "share_id_1", is_dir=True)
2144
2159
        self.fsm.set_node_id(share.path, "uuid_share_1")
2145
2160
        share.node_id = "uuid_share_1"
2146
2161
        self.vm.shares['share_id_1'] = share
2147
 
        return self._test_it(share)
 
2162
        yield self._test_it(share)
2148
2163
 
 
2164
    @defer.inlineCallbacks
2149
2165
    def test_SERVER_udf(self):
2150
2166
        """We were downloading the udf root dir, but it was interrupted."""
2151
2167
        udf_path = os.path.join(self.home_dir, "myudf")
2152
2168
        os.mkdir(udf_path)
2153
 
        udf = self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
2154
 
                                   udf_path, True)
 
2169
        udf = yield self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
 
2170
                                    udf_path, True)
2155
2171
        self.fsm.create(udf.path, 'udf_id', is_dir=True)
2156
2172
        self.fsm.set_node_id(udf.path, 'udf_root_node_id')
2157
 
        return self._test_it(udf)
 
2173
        yield self._test_it(udf)
2158
2174
 
2159
2175
 
2160
2176
class LimboTests(TwistedBase):
2338
2354
 
2339
2355
    timeout = 2
2340
2356
 
 
2357
    @defer.inlineCallbacks
2341
2358
    def setUp(self):
2342
2359
        """Init."""
2343
 
        BaseTestCase.setUp(self)
 
2360
        yield BaseTestCase.setUp(self)
2344
2361
        self._deferred = defer.Deferred()
2345
2362
        self.eq = event_queue.EventQueue(self.fsm)
2346
2363
        self.original_add = self.eq.add_watch
2360
2377
        path = os.path.expanduser(suggested_path).encode("utf8")
2361
2378
        os.makedirs(path)
2362
2379
        udf_id, node_id = 'udf_id', 'node_id'
2363
 
        self.udf = self.create_udf(udf_id, node_id, suggested_path, path, True)
 
2380
        self.udf = yield self.create_udf(udf_id, node_id, suggested_path,
 
2381
                                         path, True)
2364
2382
        self.ancestors = self.udf.ancestors # need a fake HOME
2365
2383
 
2366
2384
        # make FSM aware of it