← Back to branch summary

~gandelman-a/ubuntu/precise/nova/UCA_2012.2.1

« back to all changes in this revision

Viewing changes to nova/tests/test_volume.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-05-24 13:12:53 UTC
  • mfrom: (1.1.55)
  • Revision ID: package-import@ubuntu.com-20120524131253-ommql08fg1en06ut
Tags: 2012.2~f1-0ubuntu1
https://launchpad.net/bugs/907197
* New upstream release.
* Prepare for quantal:
  - Dropped debian/patches/upstream/0006-Use-project_id-in-ec2.cloud._format_image.patch
  - Dropped debian/patches/upstream/0005-Populate-image-properties-with-project_id-again.patch
  - Dropped debian/patches/upstream/0004-Fixed-bug-962840-added-a-test-case.patch
  - Dropped debian/patches/upstream/0003-Allow-unprivileged-RADOS-users-to-access-rbd-volumes.patch
  - Dropped debian/patches/upstream/0002-Stop-libvirt-test-from-deleting-instances-dir.patch
  - Dropped debian/patches/upstream/0001-fix-bug-where-nova-ignores-glance-host-in-imageref.patch 
  - Dropped debian/patches/0001-fix-useexisting-deprecation-warnings.patch
* debian/control: Add python-keystone as a dependency. (LP: #907197)
* debian/patches/kombu_tests_timeout.patch: Refreshed.
* debian/nova.conf, debian/nova-common.postinst: Convert to new ini
  file configuration
* debian/patches/nova-manage_flagfile_location.patch: Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_volume.py
25
25
import mox
26
26
 
27
27
from nova import context
 
28
from nova import db
28
29
from nova import exception
29
 
from nova import db
30
30
from nova import flags
31
31
from nova import log as logging
 
32
from nova.notifier import test_notifier
 
33
from nova.openstack.common import importutils
32
34
import nova.policy
33
35
from nova import rpc
34
36
from nova import test
35
 
from nova import utils
36
37
import nova.volume.api
37
38
 
38
39
FLAGS = flags.FLAGS
44
45
 
45
46
    def setUp(self):
46
47
        super(VolumeTestCase, self).setUp()
47
 
        self.compute = utils.import_object(FLAGS.compute_manager)
 
48
        self.compute = importutils.import_object(FLAGS.compute_manager)
48
49
        self.flags(connection_type='fake')
49
 
        self.volume = utils.import_object(FLAGS.volume_manager)
 
50
        self.stubs.Set(nova.flags.FLAGS, 'notification_driver',
 
51
                'nova.notifier.test_notifier')
 
52
        self.volume = importutils.import_object(FLAGS.volume_manager)
50
53
        self.context = context.get_admin_context()
51
 
        self.instance_id = db.instance_create(self.context, {})['id']
 
54
        instance = db.instance_create(self.context, {})
 
55
        self.instance_id = instance['id']
 
56
        self.instance_uuid = instance['uuid']
 
57
        test_notifier.NOTIFICATIONS = []
52
58
 
53
59
    def tearDown(self):
54
60
        db.instance_destroy(self.context, self.instance_id)
55
61
        super(VolumeTestCase, self).tearDown()
56
62
 
57
63
    @staticmethod
58
 
    def _create_volume(size='0', snapshot_id=None):
 
64
    def _create_volume(size=0, snapshot_id=None):
59
65
        """Create a volume object."""
60
66
        vol = {}
61
67
        vol['size'] = size
67
73
        vol['attach_status'] = "detached"
68
74
        return db.volume_create(context.get_admin_context(), vol)
69
75
 
 
76
    def test_ec2_uuid_mapping(self):
 
77
        ec2_vol = db.ec2_volume_create(context.get_admin_context(),
 
78
                'aaaaaaaa-bbbb-bbbb-bbbb-aaaaaaaaaaaa', 5)
 
79
        self.assertEqual(5, ec2_vol['id'])
 
80
        self.assertEqual('aaaaaaaa-bbbb-bbbb-bbbb-aaaaaaaaaaaa',
 
81
                db.get_volume_uuid_by_ec2_id(context.get_admin_context(), 5))
 
82
 
 
83
        ec2_vol = db.ec2_volume_create(context.get_admin_context(),
 
84
                'aaaaaaaa-bbbb-bbbb-bbbb-aaaaaaaaaaaa', 1)
 
85
        self.assertEqual(1, ec2_vol['id'])
 
86
 
 
87
        ec2_vol = db.ec2_volume_create(context.get_admin_context(),
 
88
                'aaaaaaaa-bbbb-bbbb-bbbb-aaaaaaaaazzz')
 
89
        self.assertEqual(6, ec2_vol['id'])
 
90
 
70
91
    def test_create_delete_volume(self):
71
92
        """Test volume can be created and deleted."""
72
93
        volume = self._create_volume()
73
94
        volume_id = volume['id']
 
95
        self.assertEquals(len(test_notifier.NOTIFICATIONS), 0)
74
96
        self.volume.create_volume(self.context, volume_id)
 
97
        self.assertEquals(len(test_notifier.NOTIFICATIONS), 2)
75
98
        self.assertEqual(volume_id, db.volume_get(context.get_admin_context(),
76
99
                         volume_id).id)
77
100
 
78
101
        self.volume.delete_volume(self.context, volume_id)
 
102
        self.assertEquals(len(test_notifier.NOTIFICATIONS), 4)
79
103
        self.assertRaises(exception.NotFound,
80
104
                          db.volume_get,
81
105
                          self.context,
160
184
        inst['project_id'] = 'fake'
161
185
        inst['instance_type_id'] = '2'  # m1.tiny
162
186
        inst['ami_launch_index'] = 0
163
 
        instance_id = db.instance_create(self.context, inst)['id']
 
187
        instance = db.instance_create(self.context, {})
 
188
        instance_id = instance['id']
 
189
        instance_uuid = instance['uuid']
164
190
        mountpoint = "/dev/sdf"
165
191
        volume = self._create_volume()
166
192
        volume_id = volume['id']
167
193
        self.volume.create_volume(self.context, volume_id)
168
194
        if FLAGS.fake_tests:
169
 
            db.volume_attached(self.context, volume_id, instance_id,
 
195
            db.volume_attached(self.context, volume_id, instance_uuid,
170
196
                               mountpoint)
171
197
        else:
172
198
            self.compute.attach_volume(self.context,
173
 
                                       instance_id,
 
199
                                       instance_uuid,
174
200
                                       volume_id,
175
201
                                       mountpoint)
176
202
        vol = db.volume_get(context.get_admin_context(), volume_id)
177
203
        self.assertEqual(vol['status'], "in-use")
178
204
        self.assertEqual(vol['attach_status'], "attached")
179
205
        self.assertEqual(vol['mountpoint'], mountpoint)
180
 
        instance_ref = db.volume_get_instance(self.context, volume_id)
181
 
        self.assertEqual(instance_ref['id'], instance_id)
 
206
        self.assertEqual(vol['instance_uuid'], instance_uuid)
182
207
 
183
 
        self.assertRaises(exception.Error,
 
208
        self.assertRaises(exception.NovaException,
184
209
                          self.volume.delete_volume,
185
210
                          self.context,
186
211
                          volume_id)
188
213
            db.volume_detached(self.context, volume_id)
189
214
        else:
190
215
            self.compute.detach_volume(self.context,
191
 
                                       instance_id,
 
216
                                       instance_uuid,
192
217
                                       volume_id)
193
218
        vol = db.volume_get(self.context, volume_id)
194
219
        self.assertEqual(vol['status'], "available")
308
333
 
309
334
        volume = self._create_volume()
310
335
        self.volume.create_volume(self.context, volume['id'])
311
 
        db.volume_attached(self.context, volume['id'], self.instance_id,
 
336
        db.volume_attached(self.context, volume['id'], self.instance_uuid,
312
337
                           '/dev/sda1')
313
338
 
314
339
        volume_api = nova.volume.api.API()
345
370
        self.volume.delete_snapshot(self.context, snapshot_id)
346
371
        self.volume.delete_volume(self.context, volume_id)
347
372
 
 
373
    def test_create_volume_usage_notification(self):
 
374
        """Ensure create volume generates appropriate usage notification"""
 
375
        volume = self._create_volume()
 
376
        volume_id = volume['id']
 
377
        self.assertEquals(len(test_notifier.NOTIFICATIONS), 0)
 
378
        self.volume.create_volume(self.context, volume_id)
 
379
        self.assertEquals(len(test_notifier.NOTIFICATIONS), 2)
 
380
        msg = test_notifier.NOTIFICATIONS[0]
 
381
        self.assertEquals(msg['event_type'], 'volume.create.start')
 
382
        msg = test_notifier.NOTIFICATIONS[1]
 
383
        self.assertEquals(msg['priority'], 'INFO')
 
384
        self.assertEquals(msg['event_type'], 'volume.create.end')
 
385
        payload = msg['payload']
 
386
        self.assertEquals(payload['tenant_id'], volume['project_id'])
 
387
        self.assertEquals(payload['user_id'], volume['user_id'])
 
388
        self.assertEquals(payload['volume_id'], volume['id'])
 
389
        self.assertEquals(payload['status'], 'creating')
 
390
        self.assertEquals(payload['size'], volume['size'])
 
391
        self.assertTrue('display_name' in payload)
 
392
        self.assertTrue('snapshot_id' in payload)
 
393
        self.assertTrue('launched_at' in payload)
 
394
        self.assertTrue('created_at' in payload)
 
395
        self.volume.delete_volume(self.context, volume_id)
 
396
 
348
397
 
349
398
class DriverTestCase(test.TestCase):
350
399
    """Base Test class for Drivers."""
354
403
        super(DriverTestCase, self).setUp()
355
404
        self.flags(volume_driver=self.driver_name,
356
405
                   logging_default_format_string="%(message)s")
357
 
        self.volume = utils.import_object(FLAGS.volume_manager)
 
406
        self.volume = importutils.import_object(FLAGS.volume_manager)
358
407
        self.context = context.get_admin_context()
359
408
        self.output = ""
360
409
 
368
417
        log.logger.addHandler(logging.logging.StreamHandler(self.stream))
369
418
 
370
419
        inst = {}
371
 
        self.instance_id = db.instance_create(self.context, inst)['id']
 
420
        instance = db.instance_create(self.context, {})
 
421
        self.instance_id = instance['id']
 
422
        self.instance_uuid = instance['uuid']
372
423
 
373
424
    def _attach_volume(self):
374
425
        """Attach volumes to an instance. This function also sets
421
472
 
422
473
            # each volume has a different mountpoint
423
474
            mountpoint = "/dev/sd" + chr((ord('b') + index))
424
 
            db.volume_attached(self.context, vol_ref['id'], self.instance_id,
 
475
            db.volume_attached(self.context, vol_ref['id'], self.instance_uuid,
425
476
                               mountpoint)
426
477
            volume_id_list.append(vol_ref['id'])
427
478