← Back to branch summary

~nataliabidart/ubuntuone-client/get-sharesdir

« back to all changes in this revision

Viewing changes to tests/platform/linux/test_dbus.py

  • Committer: Tarmac
  • Author(s): Natalia B. Bidart
  • Date: 2011-02-04 19:17:07 UTC
  • mfrom: (827.2.32 share-subscribe-dbus)
  • Revision ID: tarmac-20110204191707-0wrlgpvii6ysnxdh
- Exposing {subscribe,unsubscribe}_share methods over u1sdtool (part of LP: #708335).
- Implemented DBus ops subscribe and unsubscribe for shares (part of LP: #708335).

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/platform/linux/test_dbus.py
3178
3178
    """Share specific tests."""
3179
3179
 
3180
3180
    @defer.inlineCallbacks
 
3181
    def setUp(self):
 
3182
        """Setup the test."""
 
3183
        yield DBusTwistedTestCase.setUp(self)
 
3184
        self.client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
 
3185
 
 
3186
    def _create_share(self, volume_id=None, node_id=None, access_level='View',
 
3187
                      accepted=True, subscribed=False):
 
3188
        """Create a Share and return it."""
 
3189
        share_path = os.path.join(self.main.shares_dir, 'share')
 
3190
        if volume_id is None:
 
3191
            volume_id = str(uuid.uuid4())
 
3192
        if node_id is None:
 
3193
            node_id = str(uuid.uuid4())
 
3194
        share = Share(path=share_path, volume_id=volume_id, node_id=node_id,
 
3195
                      accepted=accepted, access_level=access_level,
 
3196
                      subscribed=subscribed)
 
3197
        return share
 
3198
 
 
3199
    @defer.inlineCallbacks
3181
3200
    def test_delete_share(self):
3182
3201
        """Test for Shares.delete_share."""
3183
 
        share_path = os.path.join(self.main.shares_dir, 'share')
3184
 
        share = Share(path=share_path, volume_id='share_id',
3185
 
                      node_id='node_id', accepted=True)
 
3202
        share = self._create_share(accepted=True)
3186
3203
        yield self.main.vm.add_share(share)
3187
3204
        d = defer.Deferred()
3188
3205
        def delete_volume(volume_id, path):
3205
3222
            self.assertRaises(KeyError, self.main.fs.get_by_path, share.path)
3206
3223
            self.assertRaises(VolumeDoesNotExist,
3207
3224
                              self.main.vm.get_volume, share.volume_id)
3208
 
        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3209
 
        client.call_method('delete_share', share.volume_id,
 
3225
        self.client.call_method('delete_share', share.volume_id,
3210
3226
                           reply_handler=check_deleted,
3211
3227
                           error_handler=self.error_handler)
3212
3228
        yield d
3214
3230
    @defer.inlineCallbacks
3215
3231
    def test_delete_share_from_me(self):
3216
3232
        """Test for Shares.delete_share with share from_me."""
3217
 
        share_path = os.path.join(self.main.shares_dir, 'share')
3218
 
        share = Shared(path=share_path, volume_id='share_id',
3219
 
                      node_id='node_id', accepted=True)
 
3233
        share = self._create_share(accepted=True)
3220
3234
        yield self.main.vm.add_shared(share)
3221
3235
        d = defer.Deferred()
3222
3236
        def delete_share(volume_id):
3231
3245
        match = self.bus.add_signal_receiver(deleted_handler,
3232
3246
                                             signal_name='ShareDeleted')
3233
3247
        self.signal_receivers.add(match)
3234
 
        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3235
 
        client.call_method('delete_share', share.volume_id,
 
3248
        self.client.call_method('delete_share', share.volume_id,
3236
3249
                           reply_handler=lambda _: None,
3237
3250
                           error_handler=self.error_handler)
3238
3251
        yield d
3240
3253
    @defer.inlineCallbacks
3241
3254
    def test_delete_share_error_signal(self):
3242
3255
        """Test for Shares.delete_share with an error."""
3243
 
        share_path = os.path.join(self.main.shares_dir, 'share')
3244
 
        share = Share(path=share_path, volume_id='share_id',
3245
 
                      node_id='node_id', accepted=True)
 
3256
        share = self._create_share(accepted=True)
3246
3257
        yield self.main.vm.add_share(share)
3247
3258
        d = defer.Deferred()
3248
3259
        # patch delete_volume to fail
3259
3270
        match = self.bus.add_signal_receiver(deleted_error_handler,
3260
3271
                                             signal_name='ShareDeleteError')
3261
3272
        self.signal_receivers.add(match)
3262
 
        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3263
 
        client.call_method('delete_share', share.volume_id,
 
3273
        self.client.call_method('delete_share', share.volume_id,
3264
3274
                           reply_handler=lambda *args: None,
3265
3275
                           error_handler=self.error_handler)
3266
3276
        yield d
3268
3278
    @defer.inlineCallbacks
3269
3279
    def test_delete_share_from_me_error(self):
3270
3280
        """Test failure of Shares.delete_share with a share from_me."""
3271
 
        share_path = os.path.join(self.main.shares_dir, 'share')
3272
 
        share = Shared(path=share_path, volume_id='share_id',
3273
 
                      node_id='node_id', accepted=True)
 
3281
        share = self._create_share(accepted=True)
3274
3282
        yield self.main.vm.add_shared(share)
3275
3283
        d = defer.Deferred()
3276
3284
        # patch delete_share to fail
3287
3295
        match = self.bus.add_signal_receiver(deleted_error_handler,
3288
3296
                                             signal_name='ShareDeleteError')
3289
3297
        self.signal_receivers.add(match)
3290
 
        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3291
 
        client.call_method('delete_share', share.volume_id,
 
3298
        self.client.call_method('delete_share', share.volume_id,
3292
3299
                           reply_handler=lambda *args: None,
3293
3300
                           error_handler=self.error_handler)
3294
3301
        yield d
3305
3312
        match = self.bus.add_signal_receiver(deleted_error_handler,
3306
3313
                                             signal_name='ShareDeleteError')
3307
3314
        self.signal_receivers.add(match)
3308
 
        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
3309
 
        client.call_method('delete_share', 'missing_share_id',
 
3315
        self.client.call_method('delete_share', 'missing_share_id',
3310
3316
                           reply_handler=lambda *args: None,
3311
3317
                           error_handler=self.error_handler)
3312
3318
        return d
3313
3319
 
 
3320
    @defer.inlineCallbacks
 
3321
    def test_subscribe(self):
 
3322
        """Test for Shares.subscribe and that it fires a dbus signal."""
 
3323
        share = self._create_share(accepted=True, subscribed=False)
 
3324
        yield self.main.vm.add_share(share)
 
3325
 
 
3326
        d = defer.Deferred()
 
3327
        match = self.bus.add_signal_receiver(d.callback,
 
3328
                                             signal_name='ShareSubscribed')
 
3329
        self.signal_receivers.add(match)
 
3330
 
 
3331
        match = self.bus.add_signal_receiver(lambda _, error: d.errback(error),
 
3332
                                             signal_name='ShareSubscribeError')
 
3333
        self.signal_receivers.add(match)
 
3334
 
 
3335
        self.client.call_method('subscribe', share.volume_id,
 
3336
                                reply_handler=lambda x: None,
 
3337
                                error_handler=self.error_handler)
 
3338
        info = yield d
 
3339
        self.assertTrue(bool(info['subscribed']),
 
3340
                        "share %r should be subscribed" % share)
 
3341
        yield self.main.vm.share_deleted(share.volume_id)
 
3342
 
 
3343
    @defer.inlineCallbacks
 
3344
    def test_subscribe_error(self):
 
3345
        """Test for Shares.subscribe when there is an error."""
 
3346
        # do not add a share to have an error
 
3347
 
 
3348
        d = defer.Deferred()
 
3349
 
 
3350
        match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid),
 
3351
                                             signal_name='ShareSubscribeError')
 
3352
        self.signal_receivers.add(match)
 
3353
 
 
3354
        match = self.bus.add_signal_receiver(d.errback,
 
3355
                                             signal_name='ShareSubscribed')
 
3356
        self.signal_receivers.add(match)
 
3357
 
 
3358
        self.client.call_method('subscribe', 'invalid_id',
 
3359
                                reply_handler=lambda x: None,
 
3360
                                error_handler=self.error_handler)
 
3361
        yield d
 
3362
 
 
3363
    @defer.inlineCallbacks
 
3364
    def test_unsubscribe(self):
 
3365
        """Test for Shares.unsubscribe."""
 
3366
        share = self._create_share(accepted=True, subscribed=True)
 
3367
        yield self.main.vm.add_share(share)
 
3368
 
 
3369
        d = defer.Deferred()
 
3370
        match = self.bus.add_signal_receiver(d.callback,
 
3371
                                             signal_name='ShareUnSubscribed')
 
3372
        self.signal_receivers.add(match)
 
3373
 
 
3374
        match = self.bus.add_signal_receiver(lambda _, error: d.errback(error),
 
3375
                                           signal_name='ShareUnSubscribeError')
 
3376
        self.signal_receivers.add(match)
 
3377
 
 
3378
        self.client.call_method('unsubscribe', share.volume_id,
 
3379
                                reply_handler=lambda x: None,
 
3380
                                error_handler=self.error_handler)
 
3381
        info = yield d
 
3382
 
 
3383
        self.assertFalse(info['subscribed'],
 
3384
                         "share %r should be subscribed" % share)
 
3385
 
 
3386
        self.main.vm.share_deleted(share.volume_id)
 
3387
 
 
3388
    @defer.inlineCallbacks
 
3389
    def test_unsubscribe_error(self):
 
3390
        """Test for Shares.unsubscribe when there is an error."""
 
3391
        # do not add a share to have an error
 
3392
 
 
3393
        d = defer.Deferred()
 
3394
        match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid),
 
3395
                                           signal_name='ShareUnSubscribeError')
 
3396
        self.signal_receivers.add(match)
 
3397
 
 
3398
        match = self.bus.add_signal_receiver(d.errback,
 
3399
                                             signal_name='ShareUnSubscribed')
 
3400
        self.signal_receivers.add(match)
 
3401
 
 
3402
        self.client.call_method('unsubscribe', 'invalid_id',
 
3403
                                reply_handler=lambda x: None,
 
3404
                                error_handler=self.error_handler)
 
3405
        yield d
 
3406
 
3314
3407
 
3315
3408
def test_suite():
3316
3409
    """Collect these tests only on linux."""