← Back to branch summary

~ubuntu-branches/ubuntu/quantal/nova/quantal-proposed

« back to all changes in this revision

Viewing changes to nova/tests/test_imagebackend.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-08-16 14:04:11 UTC
  • mto: This revision was merged to the branch mainline in revision 84.
  • Revision ID: package-import@ubuntu.com-20120816140411-0mr4n241wmk30t9l
Tags: upstream-2012.2~f3
Import upstream version 2012.2~f3

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_imagebackend.py
1
 
#!/usr/bin/python
2
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
3
2
 
4
3
# Copyright 2012 Grid Dynamics
38
37
        super(_ImageTestCase, self).setUp()
39
38
        self.flags(instances_path=self.INSTANCES_PATH)
40
39
        self.INSTANCE = 'instance'
41
 
        self.NAME = 'fake'
42
 
        self.SUFFIX = 'vm'
 
40
        self.NAME = 'fake.vm'
43
41
        self.TEMPLATE = 'template'
44
42
 
45
43
        self.PATH = os.path.join(FLAGS.instances_path, self.INSTANCE,
46
 
                                 self.NAME + self.SUFFIX)
 
44
                                 self.NAME)
47
45
        self.TEMPLATE_DIR = os.path.join(FLAGS.instances_path,
48
46
                                         '_base')
49
47
        self.TEMPLATE_PATH = os.path.join(self.TEMPLATE_DIR, 'template')
61
59
        imagebackend.libvirt_utils.ensure_tree(self.TEMPLATE_DIR)
62
60
        self.mox.ReplayAll()
63
61
 
64
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
62
        image = self.image_class(self.INSTANCE, self.NAME)
65
63
        self.mock_create_image(image)
66
64
        image.cache(fn, self.TEMPLATE)
67
65
 
72
70
        os.path.exists(self.PATH).AndReturn(True)
73
71
        self.mox.ReplayAll()
74
72
 
75
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
73
        image = self.image_class(self.INSTANCE, self.NAME)
76
74
        image.cache(None, self.TEMPLATE)
77
75
 
78
76
        self.mox.VerifyAll()
87
85
        self.mox.StubOutWithMock(imagebackend.libvirt_utils, 'ensure_tree')
88
86
        self.mox.ReplayAll()
89
87
 
90
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
88
        image = self.image_class(self.INSTANCE, self.NAME)
91
89
        self.mock_create_image(image)
92
90
        image.cache(fn, self.TEMPLATE)
93
91
 
101
99
        fn = self.mox.CreateMockAnything()
102
100
        self.mox.ReplayAll()
103
101
 
104
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
102
        image = self.image_class(self.INSTANCE, self.NAME)
105
103
        self.mock_create_image(image)
106
104
        image.cache(fn, self.TEMPLATE)
107
105
 
129
127
        imagebackend.libvirt_utils.copy_image(self.TEMPLATE_PATH, self.PATH)
130
128
        self.mox.ReplayAll()
131
129
 
132
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
130
        image = self.image_class(self.INSTANCE, self.NAME)
133
131
        image.create_image(fn, self.TEMPLATE_PATH, None, image_id=None)
134
132
 
135
133
        self.mox.VerifyAll()
139
137
        fn(target=self.PATH)
140
138
        self.mox.ReplayAll()
141
139
 
142
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
140
        image = self.image_class(self.INSTANCE, self.NAME)
143
141
        image.create_image(fn, self.TEMPLATE_PATH, None)
144
142
 
145
143
        self.mox.VerifyAll()
151
149
        imagebackend.disk.extend(self.PATH, self.SIZE)
152
150
        self.mox.ReplayAll()
153
151
 
154
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
152
        image = self.image_class(self.INSTANCE, self.NAME)
155
153
        image.create_image(fn, self.TEMPLATE_PATH, self.SIZE, image_id=None)
156
154
 
157
155
        self.mox.VerifyAll()
182
180
                                                    self.PATH)
183
181
        self.mox.ReplayAll()
184
182
 
185
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
183
        image = self.image_class(self.INSTANCE, self.NAME)
186
184
        image.create_image(fn, self.TEMPLATE_PATH, None)
187
185
 
188
186
        self.mox.VerifyAll()
199
197
                                                    self.PATH)
200
198
        self.mox.ReplayAll()
201
199
 
202
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
200
        image = self.image_class(self.INSTANCE, self.NAME)
203
201
        image.create_image(fn, self.TEMPLATE_PATH, self.SIZE)
204
202
 
205
203
        self.mox.VerifyAll()
213
211
                                                    self.PATH)
214
212
        self.mox.ReplayAll()
215
213
 
216
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
214
        image = self.image_class(self.INSTANCE, self.NAME)
217
215
        image.create_image(fn, self.TEMPLATE_PATH, self.SIZE)
218
216
 
219
217
        self.mox.VerifyAll()
228
226
        self.image_class = imagebackend.Lvm
229
227
        super(LvmTestCase, self).setUp()
230
228
        self.flags(libvirt_images_volume_group=self.VG)
231
 
        self.LV = '%s_%s' % (self.INSTANCE, self.NAME + self.SUFFIX)
 
229
        self.LV = '%s_%s' % (self.INSTANCE, self.NAME)
232
230
        self.PATH = os.path.join('/dev', self.VG, self.LV)
233
231
 
234
232
        self.disk = imagebackend.disk
237
235
 
238
236
    def prepare_mocks(self):
239
237
        fn = self.mox.CreateMockAnything()
240
 
        self.mox.StubOutWithMock(self.disk, 'get_image_virtual_size')
241
238
        self.mox.StubOutWithMock(self.disk, 'resize2fs')
242
239
        self.mox.StubOutWithMock(self.libvirt_utils, 'create_lvm_image')
 
240
        self.mox.StubOutWithMock(self.disk, 'get_disk_size')
243
241
        self.mox.StubOutWithMock(self.utils, 'execute')
244
242
        return fn
245
243
 
246
244
    def _create_image(self, sparse):
247
245
        fn = self.prepare_mocks()
248
246
        fn(target=self.TEMPLATE_PATH)
249
 
        self.disk.get_image_virtual_size(self.TEMPLATE_PATH
250
 
                                         ).AndReturn(self.TEMPLATE_SIZE)
251
247
        self.libvirt_utils.create_lvm_image(self.VG,
252
248
                                            self.LV,
253
249
                                            self.TEMPLATE_SIZE,
254
250
                                            sparse=sparse)
 
251
        self.disk.get_disk_size(self.TEMPLATE_PATH
 
252
                                         ).AndReturn(self.TEMPLATE_SIZE)
255
253
        cmd = ('dd', 'if=%s' % self.TEMPLATE_PATH,
256
254
               'of=%s' % self.PATH, 'bs=4M')
257
255
        self.utils.execute(*cmd, run_as_root=True)
258
256
        self.mox.ReplayAll()
259
257
 
260
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
258
        image = self.image_class(self.INSTANCE, self.NAME)
261
259
        image.create_image(fn, self.TEMPLATE_PATH, None)
262
260
 
263
261
        self.mox.VerifyAll()
269
267
        fn(target=self.PATH, ephemeral_size=None)
270
268
        self.mox.ReplayAll()
271
269
 
272
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
270
        image = self.image_class(self.INSTANCE, self.NAME)
273
271
        image.create_image(fn, self.TEMPLATE_PATH,
274
272
                self.SIZE, ephemeral_size=None)
275
273
 
278
276
    def _create_image_resize(self, sparse):
279
277
        fn = self.prepare_mocks()
280
278
        fn(target=self.TEMPLATE_PATH)
281
 
        self.disk.get_image_virtual_size(self.TEMPLATE_PATH
282
 
                                         ).AndReturn(self.TEMPLATE_SIZE)
283
279
        self.libvirt_utils.create_lvm_image(self.VG, self.LV,
284
280
                                            self.SIZE, sparse=sparse)
 
281
        self.disk.get_disk_size(self.TEMPLATE_PATH
 
282
                                         ).AndReturn(self.TEMPLATE_SIZE)
285
283
        cmd = ('dd', 'if=%s' % self.TEMPLATE_PATH,
286
284
               'of=%s' % self.PATH, 'bs=4M')
287
285
        self.utils.execute(*cmd, run_as_root=True)
288
286
        self.disk.resize2fs(self.PATH)
289
287
        self.mox.ReplayAll()
290
288
 
291
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
289
        image = self.image_class(self.INSTANCE, self.NAME)
292
290
        image.create_image(fn, self.TEMPLATE_PATH, self.SIZE)
293
291
 
294
292
        self.mox.VerifyAll()
317
315
    def test_create_image_negative(self):
318
316
        fn = self.prepare_mocks()
319
317
        fn(target=self.TEMPLATE_PATH)
320
 
        self.disk.get_image_virtual_size(self.TEMPLATE_PATH
321
 
                                         ).AndReturn(self.TEMPLATE_SIZE)
322
318
        self.libvirt_utils.create_lvm_image(self.VG,
323
319
                                            self.LV,
324
320
                                            self.SIZE,
325
321
                                            sparse=False
326
322
                                            ).AndRaise(RuntimeError())
 
323
        self.disk.get_disk_size(self.TEMPLATE_PATH
 
324
                                         ).AndReturn(self.TEMPLATE_SIZE)
327
325
        self.mox.StubOutWithMock(self.libvirt_utils, 'remove_logical_volumes')
328
326
        self.libvirt_utils.remove_logical_volumes(self.PATH)
329
327
        self.mox.ReplayAll()
330
328
 
331
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
329
        image = self.image_class(self.INSTANCE, self.NAME)
332
330
 
333
331
        self.assertRaises(RuntimeError, image.create_image, fn,
334
332
                          self.TEMPLATE_PATH, self.SIZE)
346
344
        self.libvirt_utils.remove_logical_volumes(self.PATH)
347
345
        self.mox.ReplayAll()
348
346
 
349
 
        image = self.image_class(self.INSTANCE, self.NAME, self.SUFFIX)
 
347
        image = self.image_class(self.INSTANCE, self.NAME)
350
348
 
351
349
        self.assertRaises(RuntimeError, image.create_image, fn,
352
350
                          self.TEMPLATE_PATH, self.SIZE,
356
354
 
357
355
class BackendTestCase(test.TestCase):
358
356
    INSTANCE = 'fake-instance'
359
 
    NAME = 'fake-name'
360
 
    SUFFIX = 'suffix'
 
357
    NAME = 'fake-name.suffix'
361
358
 
362
359
    def get_image(self, use_cow, image_type):
363
360
        return imagebackend.Backend(use_cow).image(self.INSTANCE,
364
361
                                                   self.NAME,
365
 
                                                   self.SUFFIX,
366
362
                                                   image_type)
367
363
 
368
364
    def _test_image(self, image_type, image_not_cow, image_cow):