snaps/openstack/tests/create_image_tests.py

   1 # Copyright (c) 2016 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15 import os
  16 import shutil
  17 import uuid
  18 import unittest
  19
  20 from snaps import file_utils
  21 from snaps.openstack.create_image import ImageSettings
  22
  23 import openstack_tests
  24 from snaps.openstack.utils import glance_utils, nova_utils
  25 from snaps.openstack import create_image
  26 from snaps.openstack import os_credentials
  27 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
  28
  29 __author__ = 'spisarski'
  30
  31
  32 class ImageSettingsUnitTests(unittest.TestCase):
  33     """
  34     Tests the construction of the ImageSettings class
  35     """
  36
  37     def test_no_params(self):
  38         with self.assertRaises(Exception):
  39             ImageSettings()
  40
  41     def test_empty_config(self):
  42         with self.assertRaises(Exception):
  43             ImageSettings(config=dict())
  44
  45     def test_name_only(self):
  46         with self.assertRaises(Exception):
  47             ImageSettings(name='foo')
  48
  49     def test_config_with_name_only(self):
  50         with self.assertRaises(Exception):
  51             ImageSettings(config={'name': 'foo'})
  52
  53     def test_name_user_only(self):
  54         with self.assertRaises(Exception):
  55             ImageSettings(name='foo', image_user='bar')
  56
  57     def test_config_with_name_user_only(self):
  58         with self.assertRaises(Exception):
  59             ImageSettings(config={'name': 'foo', 'image_user': 'bar'})
  60
  61     def test_name_user_format_only(self):
  62         with self.assertRaises(Exception):
  63             ImageSettings(name='foo', image_user='bar', img_format='qcow2')
  64
  65     def test_config_with_name_user_format_only(self):
  66         with self.assertRaises(Exception):
  67             ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2'})
  68
  69     def test_name_user_format_url_file_only(self):
  70         with self.assertRaises(Exception):
  71             ImageSettings(name='foo', image_user='bar', img_format='qcow2', url='http://foo.com',
  72                           image_file='/foo/bar.qcow')
  73
  74     def test_config_with_name_user_format_url_file_only(self):
  75         with self.assertRaises(Exception):
  76             ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
  77                                   'download_url': 'http://foo.com', 'image_file': '/foo/bar.qcow'})
  78
  79     def test_name_user_format_url_only(self):
  80         settings = ImageSettings(name='foo', image_user='bar', img_format='qcow2', url='http://foo.com')
  81         self.assertEquals('foo', settings.name)
  82         self.assertEquals('bar', settings.image_user)
  83         self.assertEquals('qcow2', settings.format)
  84         self.assertEquals('http://foo.com', settings.url)
  85         self.assertIsNone(settings.image_file)
  86         self.assertIsNone(settings.nic_config_pb_loc)
  87
  88     def test_name_user_format_url_only_properties(self):
  89         properties = {}
  90         properties['hw_video_model'] = 'vga'
  91         settings = ImageSettings(name='foo', image_user='bar', img_format='qcow2', url='http://foo.com', extra_properties=properties)
  92         self.assertEquals('foo', settings.name)
  93         self.assertEquals('bar', settings.image_user)
  94         self.assertEquals('qcow2', settings.format)
  95         self.assertEquals('http://foo.com', settings.url)
  96         self.assertEquals(properties, settings.extra_properties)
  97         self.assertIsNone(settings.image_file)
  98         self.assertIsNone(settings.nic_config_pb_loc)
  99
 100
 101     def test_config_with_name_user_format_url_only(self):
 102         settings = ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
 103                                          'download_url': 'http://foo.com'})
 104         self.assertEquals('foo', settings.name)
 105         self.assertEquals('bar', settings.image_user)
 106         self.assertEquals('qcow2', settings.format)
 107         self.assertEquals('http://foo.com', settings.url)
 108         self.assertIsNone(settings.image_file)
 109         self.assertIsNone(settings.nic_config_pb_loc)
 110
 111     def test_name_user_format_file_only(self):
 112         settings = ImageSettings(name='foo', image_user='bar', img_format='qcow2', image_file='/foo/bar.qcow')
 113         self.assertEquals('foo', settings.name)
 114         self.assertEquals('bar', settings.image_user)
 115         self.assertEquals('qcow2', settings.format)
 116         self.assertIsNone(settings.url)
 117         self.assertEquals('/foo/bar.qcow', settings.image_file)
 118         self.assertIsNone(settings.nic_config_pb_loc)
 119
 120     def test_config_with_name_user_format_file_only(self):
 121         settings = ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
 122                                          'image_file': '/foo/bar.qcow'})
 123         self.assertEquals('foo', settings.name)
 124         self.assertEquals('bar', settings.image_user)
 125         self.assertEquals('qcow2', settings.format)
 126         self.assertIsNone(settings.url)
 127         self.assertEquals('/foo/bar.qcow', settings.image_file)
 128         self.assertIsNone(settings.nic_config_pb_loc)
 129
 130     def test_all_url(self):
 131         properties = {}
 132         properties['hw_video_model'] = 'vga'
 133         settings = ImageSettings(name='foo', image_user='bar', img_format='qcow2', url='http://foo.com',
 134                                  extra_properties=properties, nic_config_pb_loc='/foo/bar')
 135         self.assertEquals('foo', settings.name)
 136         self.assertEquals('bar', settings.image_user)
 137         self.assertEquals('qcow2', settings.format)
 138         self.assertEquals('http://foo.com', settings.url)
 139         self.assertEquals(properties, settings.extra_properties)
 140         self.assertIsNone(settings.image_file)
 141         self.assertEquals('/foo/bar', settings.nic_config_pb_loc)
 142
 143     def test_config_all_url(self):
 144         settings = ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
 145                                          'download_url': 'http://foo.com',
 146                                          'extra_properties' : '{\'hw_video_model\': \'vga\'}',
 147                                          'nic_config_pb_loc': '/foo/bar'})
 148         self.assertEquals('foo', settings.name)
 149         self.assertEquals('bar', settings.image_user)
 150         self.assertEquals('qcow2', settings.format)
 151         self.assertEquals('http://foo.com', settings.url)
 152         self.assertEquals('{\'hw_video_model\': \'vga\'}', settings.extra_properties)
 153         self.assertIsNone(settings.image_file)
 154         self.assertEquals('/foo/bar', settings.nic_config_pb_loc)
 155
 156     def test_all_file(self):
 157         properties = {}
 158         properties['hw_video_model'] = 'vga'
 159         settings = ImageSettings(name='foo', image_user='bar', img_format='qcow2', image_file='/foo/bar.qcow',
 160                                  extra_properties=properties, nic_config_pb_loc='/foo/bar')
 161         self.assertEquals('foo', settings.name)
 162         self.assertEquals('bar', settings.image_user)
 163         self.assertEquals('qcow2', settings.format)
 164         self.assertIsNone(settings.url)
 165         self.assertEquals('/foo/bar.qcow', settings.image_file)
 166         self.assertEquals(properties, settings.extra_properties)
 167         self.assertEquals('/foo/bar', settings.nic_config_pb_loc)
 168
 169     def test_config_all_file(self):
 170         settings = ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
 171                                          'image_file': '/foo/bar.qcow',
 172                                          'extra_properties' : '{\'hw_video_model\' : \'vga\'}',
 173                                          'nic_config_pb_loc': '/foo/bar'})
 174         self.assertEquals('foo', settings.name)
 175         self.assertEquals('bar', settings.image_user)
 176         self.assertEquals('qcow2', settings.format)
 177         self.assertIsNone(settings.url)
 178         self.assertEquals('/foo/bar.qcow', settings.image_file)
 179         self.assertEquals('{\'hw_video_model\' : \'vga\'}', settings.extra_properties)
 180         self.assertEquals('/foo/bar', settings.nic_config_pb_loc)
 181
 182
 183 class CreateImageSuccessTests(OSIntegrationTestCase):
 184     """
 185     Test for the CreateImage class defined in create_image.py
 186     """
 187
 188     def setUp(self):
 189         """
 190         Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
 191         within OpenStack
 192         """
 193         super(self.__class__, self).__start__()
 194
 195         guid = uuid.uuid4()
 196         self.image_name = self.__class__.__name__ + '-' + str(guid)
 197
 198         self.nova = nova_utils.nova_client(self.os_creds)
 199         self.glance = glance_utils.glance_client(self.os_creds)
 200         self.image_creators = list()
 201
 202         self.tmp_dir = 'tmp/' + str(guid)
 203         if not os.path.exists(self.tmp_dir):
 204             os.makedirs(self.tmp_dir)
 205
 206     def tearDown(self):
 207         """
 208         Cleans the image and downloaded image file
 209         """
 210         if self.image_creators:
 211             while self.image_creators:
 212                 self.image_creators[-1].clean()
 213                 self.image_creators.pop()
 214
 215         if os.path.exists(self.tmp_dir) and os.path.isdir(self.tmp_dir):
 216             shutil.rmtree(self.tmp_dir)
 217
 218         super(self.__class__, self).__clean__()
 219
 220     def test_create_image_clean_url(self):
 221         """
 222         Tests the creation of an OpenStack image from a URL.
 223         """
 224         # Create Image
 225         # Set the default image settings, then set any custom parameters sent from the app
 226         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 227         if self.image_metadata:
 228             if self.image_metadata['disk_url']:
 229                 os_image_settings.url = self.image_metadata['disk_url']
 230             if self.image_metadata['extra_properties']:
 231                 os_image_settings.extra_properties = self.image_metadata['extra_properties']
 232
 233         # If this is a 3-part image create the kernel and ramdisk images first
 234         if self.image_metadata:
 235             if self.image_metadata['kernel_url']:
 236                 kernel_image_settings = openstack_tests.cirros_url_image(
 237                     name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
 238                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
 239                 kernel_image = self.image_creators[-1].create()
 240                 os_image_settings.extra_properties['kernel_id'] = kernel_image.id
 241
 242             if self.image_metadata['ramdisk_url']:
 243                 ramdisk_image_settings = openstack_tests.cirros_url_image(
 244                     name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
 245                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
 246                 ramdisk_image = self.image_creators[-1].create()
 247                 os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
 248
 249         self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
 250         created_image = self.image_creators[-1].create()
 251         self.assertIsNotNone(created_image)
 252
 253         retrieved_image = glance_utils.get_image(self.nova, self.glance, os_image_settings.name)
 254         self.assertIsNotNone(retrieved_image)
 255
 256         self.assertEquals(created_image.name, retrieved_image.name)
 257         self.assertEquals(created_image.id, retrieved_image.id)
 258
 259     def test_create_image_clean_url_properties(self):
 260         """
 261         Tests the creation of an OpenStack image from a URL and set properties.
 262         """
 263         # Create Image
 264         # Set the default image settings, then set any custom parameters sent from the app
 265         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 266         # Set properties
 267         os_image_settings.extra_properties = {'hw_video_model' :  'vga'}
 268
 269         if self.image_metadata:
 270             if self.image_metadata['disk_url']:
 271                 os_image_settings.url = self.image_metadata['disk_url']
 272             if self.image_metadata['extra_properties']:
 273                 os_image_settings.extra_properties = dict(os_image_settings.extra_properties.items()
 274                     + self.image_metadata['extra_properties'].items())
 275
 276         # If this is a 3-part image create the kernel and ramdisk images first
 277         if self.image_metadata:
 278             if self.image_metadata['kernel_url']:
 279                 kernel_image_settings = openstack_tests.cirros_url_image(
 280                     name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
 281                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
 282                 kernel_image = self.image_creators[-1].create()
 283                 os_image_settings.extra_properties['kernel_id'] = kernel_image.id
 284
 285             if self.image_metadata['ramdisk_url']:
 286                 ramdisk_image_settings = openstack_tests.cirros_url_image(
 287                     name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
 288                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
 289                 ramdisk_image = self.image_creators[-1].create()
 290                 os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
 291
 292         self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
 293         created_image = self.image_creators[-1].create()
 294         self.assertIsNotNone(created_image)
 295
 296         retrieved_image = glance_utils.get_image(self.nova, self.glance, os_image_settings.name)
 297         self.assertIsNotNone(retrieved_image)
 298
 299         self.assertEquals(created_image.name, retrieved_image.name)
 300         self.assertEquals(created_image.id, retrieved_image.id)
 301         self.assertEquals(created_image.properties, retrieved_image.properties)
 302
 303     def test_create_image_clean_file(self):
 304         """
 305         Tests the creation of an OpenStack image from a file.
 306         """
 307
 308         # Create Image
 309         # Set the default image settings, then set any custom parameters sent from the app
 310         url_image_settings = openstack_tests.cirros_url_image('foo')
 311         if self.image_metadata:
 312             if self.image_metadata['disk_url']:
 313                 url_image_settings.url = self.image_metadata['disk_url']
 314
 315         # Download the file of the image
 316         image_file = file_utils.download(url_image_settings.url, self.tmp_dir)
 317         file_image_settings = openstack_tests.file_image_test_settings(name=self.image_name, file_path=image_file.name)
 318
 319         # Set extra properties sent from the app (if any)
 320         if self.image_metadata:
 321             if self.image_metadata['extra_properties']:
 322                 file_image_settings.extra_properties = self.image_metadata['extra_properties']
 323
 324         # If this is a 3-part image create the kernel and ramdisk images first
 325         if self.image_metadata:
 326             if self.image_metadata['kernel_url']:
 327                 kernel_image_file = file_utils.download(self.image_metadata['kernel_url'], self.tmp_dir)
 328                 kernel_image_settings = openstack_tests.file_image_test_settings(
 329                     name=self.image_name+'_kernel', file_path=kernel_image_file.name)
 330                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
 331                 kernel_image = self.image_creators[-1].create()
 332                 file_image_settings.extra_properties['kernel_id'] = kernel_image.id
 333
 334             if self.image_metadata['ramdisk_url']:
 335                 ramdisk_image_file = file_utils.download(self.image_metadata['ramdisk_url'], self.tmp_dir)
 336                 ramdisk_image_settings = openstack_tests.file_image_test_settings(
 337                     name=self.image_name+'_ramdisk', file_path=ramdisk_image_file.name)
 338                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
 339                 ramdisk_image = self.image_creators[-1].create()
 340                 file_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
 341
 342         self.image_creators.append(create_image.OpenStackImage(self.os_creds, file_image_settings))
 343         created_image = self.image_creators[-1].create()
 344         self.assertIsNotNone(created_image)
 345         self.assertEqual(self.image_name, created_image.name)
 346
 347         retrieved_image = glance_utils.get_image(self.nova, self.glance, file_image_settings.name)
 348         self.assertIsNotNone(retrieved_image)
 349
 350         self.assertEquals(created_image.name, retrieved_image.name)
 351         self.assertEquals(created_image.id, retrieved_image.id)
 352
 353     def test_create_delete_image(self):
 354         """
 355         Tests the creation then deletion of an OpenStack image to ensure clean() does not raise an Exception.
 356         """
 357         # Create Image
 358         # Set the default image settings, then set any custom parameters sent from the app
 359         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 360         if self.image_metadata:
 361             if self.image_metadata['disk_url']:
 362                 os_image_settings.url = self.image_metadata['disk_url']
 363             if self.image_metadata['extra_properties']:
 364                 os_image_settings.extra_properties = self.image_metadata['extra_properties']
 365
 366         # If this is a 3-part image create the kernel and ramdisk images first
 367         if self.image_metadata:
 368             if self.image_metadata['kernel_url']:
 369                 kernel_image_settings = openstack_tests.cirros_url_image(
 370                     name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
 371                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
 372                 kernel_image = self.image_creators[-1].create()
 373                 os_image_settings.extra_properties['kernel_id'] = kernel_image.id
 374
 375             if self.image_metadata['ramdisk_url']:
 376                 ramdisk_image_settings = openstack_tests.cirros_url_image(
 377                     name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
 378                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
 379                 ramdisk_image = self.image_creators[-1].create()
 380                 os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
 381
 382         self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
 383         created_image = self.image_creators[-1].create()
 384         self.assertIsNotNone(created_image)
 385
 386         # Delete Image manually
 387         glance_utils.delete_image(self.glance, created_image)
 388
 389         self.assertIsNone(glance_utils.get_image(self.nova, self.glance, self.image_creators[-1].image_settings.name))
 390
 391         # Must not throw an exception when attempting to cleanup non-existent image
 392         self.image_creators[-1].clean()
 393         self.assertIsNone(self.image_creators[-1].get_image())
 394         self.image_creators.pop()
 395
 396     def test_create_same_image(self):
 397         """
 398         Tests the creation of an OpenStack image when the image already exists.
 399         """
 400         # Create Image
 401         # Set the default image settings, then set any custom parameters sent from the app
 402         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 403         if self.image_metadata:
 404             if self.image_metadata['disk_url']:
 405                 os_image_settings.url = self.image_metadata['disk_url']
 406             if self.image_metadata['extra_properties']:
 407                 os_image_settings.extra_properties = self.image_metadata['extra_properties']
 408
 409         # If this is a 3-part image create the kernel and ramdisk images first
 410         if self.image_metadata:
 411             if self.image_metadata['kernel_url']:
 412                 kernel_image_settings = openstack_tests.cirros_url_image(
 413                     name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
 414                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
 415                 kernel_image = self.image_creators[-1].create()
 416                 os_image_settings.extra_properties['kernel_id'] = kernel_image.id
 417
 418             if self.image_metadata['ramdisk_url']:
 419                 ramdisk_image_settings = openstack_tests.cirros_url_image(
 420                     name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
 421                 self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
 422                 ramdisk_image = self.image_creators[-1].create()
 423                 os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
 424
 425         self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
 426         image1 = self.image_creators[-1].create()
 427
 428         # Should be retrieving the instance data
 429         os_image_2 = create_image.OpenStackImage(self.os_creds, os_image_settings)
 430         image2 = os_image_2.create()
 431         self.assertEquals(image1.id, image2.id)
 432
 433
 434 class CreateImageNegativeTests(OSIntegrationTestCase):
 435     """
 436     Negative test cases for the CreateImage class
 437     """
 438
 439     def setUp(self):
 440         super(self.__class__, self).__start__()
 441
 442         self.image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
 443         self.image_creator = None
 444
 445     def tearDown(self):
 446         if self.image_creator:
 447             self.image_creator.clean()
 448
 449         super(self.__class__, self).__clean__()
 450
 451     def test_none_image_name(self):
 452         """
 453         Expect an exception when the image name is None
 454         """
 455         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 456         with self.assertRaises(Exception):
 457             self.image_creator = create_image.OpenStackImage(
 458                 self.os_creds, create_image.ImageSettings(
 459                     name=None, image_user=os_image_settings.image_user, img_format=os_image_settings.format,
 460                     url=os_image_settings.url))
 461
 462             self.fail('Exception should have been thrown prior to this line')
 463
 464     def test_bad_image_url(self):
 465         """
 466         Expect an exception when the image download url is bad
 467         """
 468         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 469         self.image_creator = create_image.OpenStackImage(self.os_creds, create_image.ImageSettings(
 470             name=os_image_settings.name, image_user=os_image_settings.image_user,
 471             img_format=os_image_settings.format, url="http://foo.bar"))
 472         with self.assertRaises(Exception):
 473             self.image_creator.create()
 474
 475     def test_bad_image_file(self):
 476         """
 477         Expect an exception when the image file does not exist
 478         """
 479         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 480         self.image_creator = create_image.OpenStackImage(
 481             self.os_creds,
 482             create_image.ImageSettings(name=os_image_settings.name, image_user=os_image_settings.image_user,
 483                                        img_format=os_image_settings.format, image_file="/foo/bar.qcow"))
 484         with self.assertRaises(Exception):
 485             self.image_creator.create()
 486
 487     def test_none_proj_name(self):
 488         """
 489         Expect an exception when the project name is None
 490         """
 491         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 492         with self.assertRaises(Exception):
 493             self.image_creator = create_image.OpenStackImage(
 494                 os_credentials.OSCreds(self.os_creds.username, self.os_creds.password, self.os_creds.auth_url, None,
 495                                        proxy_settings=self.os_creds.proxy_settings),
 496                 os_image_settings)
 497             self.image_creator.create()
 498
 499     def test_none_auth_url(self):
 500         """
 501         Expect an exception when the project name is None
 502         """
 503         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 504         with self.assertRaises(Exception):
 505             self.image_creator = create_image.OpenStackImage(
 506                 os_credentials.OSCreds(self.os_creds.username, self.os_creds.password, None,
 507                                        self.os_creds.project_name, proxy_settings=self.os_creds.proxy_settings),
 508                 os_image_settings)
 509             self.image_creator.create()
 510
 511     def test_none_password(self):
 512         """
 513         Expect an exception when the project name is None
 514         """
 515         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 516         with self.assertRaises(Exception):
 517             self.image_creator = create_image.OpenStackImage(
 518                 os_credentials.OSCreds(self.os_creds.username, None, self.os_creds.os_auth_url,
 519                                        self.os_creds.project_name, proxy_settings=self.os_creds.proxy_settings),
 520                 os_image_settings)
 521
 522     def test_none_user(self):
 523         """
 524         Expect an exception when the project name is None
 525         """
 526         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
 527         with self.assertRaises(Exception):
 528             self.image_creator = create_image.OpenStackImage(
 529                 os_credentials.OSCreds(None, self.os_creds.password, self.os_creds.os_auth_url,
 530                                        self.os_creds.project_name,
 531                                        proxy_settings=self.os_creds.proxy_settings),
 532                 os_image_settings)
 533
 534
 535 class CreateMultiPartImageTests(OSIntegrationTestCase):
 536     """
 537     Test for creating a 3-part image
 538     """
 539     def setUp(self):
 540         """
 541         Instantiates the CreateImage object that is responsible for
 542         downloading and creating an OS image file within OpenStack
 543         """
 544         super(self.__class__, self).__start__()
 545
 546         guid = uuid.uuid4()
 547         self.image_creators = list()
 548         self.image_name = self.__class__.__name__ + '-' + str(guid)
 549
 550         self.nova = nova_utils.nova_client(self.os_creds)
 551         self.glance = glance_utils.glance_client(self.os_creds)
 552
 553         self.tmp_dir = 'tmp/' + str(guid)
 554         if not os.path.exists(self.tmp_dir):
 555             os.makedirs(self.tmp_dir)
 556
 557     def tearDown(self):
 558         """
 559         Cleans the images and downloaded image file
 560         """
 561         while self.image_creators:
 562             self.image_creators[-1].clean()
 563             self.image_creators.pop()
 564
 565         if os.path.exists(self.tmp_dir) and os.path.isdir(self.tmp_dir):
 566             shutil.rmtree(self.tmp_dir)
 567
 568         super(self.__class__, self).__clean__()
 569
 570     def test_create_three_part_image_from_url(self):
 571         """
 572         Tests the creation of a 3-part OpenStack image from a URL.
 573         """
 574         # Set properties
 575         properties = {}
 576         if self.image_metadata and  self.image_metadata['extra_properties']:
 577             properties = self.image_metadata['extra_properties']
 578
 579         # Create the kernel image
 580         kernel_image_settings = openstack_tests.cirros_url_image(name=self.image_name+'_kernel',
 581             url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-kernel')
 582         if self.image_metadata and self.image_metadata['kernel_url']:
 583             kernel_image_settings.url = self.image_metadata['kernel_url']
 584         self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
 585         kernel_image = self.image_creators[-1].create()
 586         self.assertIsNotNone(kernel_image)
 587
 588         # Create the ramdisk image
 589         ramdisk_image_settings = openstack_tests.cirros_url_image(name=self.image_name+'_ramdisk',
 590             url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-initramfs')
 591         if self.image_metadata and self.image_metadata['ramdisk_url']:
 592             ramdisk_image_settings.url = self.image_metadata['ramdisk_url']
 593         self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
 594         ramdisk_image = self.image_creators[-1].create()
 595         self.assertIsNotNone(ramdisk_image)
 596
 597         # Create the main image
 598         os_image_settings = openstack_tests.cirros_url_image(name=self.image_name,
 599             url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img')
 600         if self.image_metadata and self.image_metadata['disk_url']:
 601             os_image_settings.url = self.image_metadata['disk_url']
 602
 603         properties['kernel_id'] = kernel_image.id
 604         properties['ramdisk_id'] = ramdisk_image.id
 605         os_image_settings.extra_properties = properties
 606
 607         self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
 608         created_image = self.image_creators[-1].create()
 609         self.assertIsNotNone(created_image)
 610         self.assertEqual(self.image_name, created_image.name)
 611
 612         retrieved_image = glance_utils.get_image(self.nova, self.glance, os_image_settings.name)
 613         self.assertIsNotNone(retrieved_image)
 614
 615         self.assertEquals(created_image.name, retrieved_image.name)
 616         self.assertEquals(created_image.id, retrieved_image.id)
 617         self.assertEquals(created_image.properties, retrieved_image.properties)
 618
 619     def test_create_three_part_image_from_file(self):
 620         """
 621         Tests the creation of a 3-part OpenStack image from files.
 622         """
 623         # Set properties
 624         properties = {}
 625         if self.image_metadata and  self.image_metadata['extra_properties']:
 626             properties = self.image_metadata['extra_properties']
 627         # Create the kernel image
 628         kernel_url = 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-kernel'
 629         if self.image_metadata and self.image_metadata['kernel_url']:
 630             kernel_url = self.image_metadata['kernel_url']
 631         kernel_image_file = file_utils.download(kernel_url, self.tmp_dir)
 632         kernel_file_image_settings = openstack_tests.file_image_test_settings(
 633             name=self.image_name+'_kernel', file_path=kernel_image_file.name)
 634         self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_file_image_settings))
 635         kernel_image = self.image_creators[-1].create()
 636         self.assertIsNotNone(kernel_image)
 637
 638         # Create the ramdisk image
 639         ramdisk_url = 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-initramfs'
 640         if self.image_metadata and self.image_metadata['ramdisk_url']:
 641             ramdisk_url = self.image_metadata['ramdisk_url']
 642         ramdisk_image_file = file_utils.download(ramdisk_url, self.tmp_dir)
 643         ramdisk_file_image_settings = openstack_tests.file_image_test_settings(
 644             name=self.image_name+'_ramdisk', file_path=ramdisk_image_file.name)
 645         self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_file_image_settings))
 646         ramdisk_image = self.image_creators[-1].create()
 647         self.assertIsNotNone(ramdisk_image)
 648
 649         # Create the main image
 650         image_url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img'
 651         if self.image_metadata and self.image_metadata['disk_url']:
 652             umage_url = self.image_metadata['disk_url']
 653         image_file = file_utils.download(image_url, self.tmp_dir)
 654         file_image_settings = openstack_tests.file_image_test_settings(name=self.image_name, file_path=image_file.name)
 655         properties['kernel_id'] = kernel_image.id
 656         properties['ramdisk_id'] = ramdisk_image.id
 657         file_image_settings.extra_properties = properties
 658         self.image_creators.append(create_image.OpenStackImage(self.os_creds, file_image_settings))
 659         created_image = self.image_creators[-1].create()
 660
 661         self.assertIsNotNone(created_image)
 662         self.assertEqual(self.image_name, created_image.name)
 663
 664         retrieved_image = glance_utils.get_image(self.nova, self.glance, file_image_settings.name)
 665         self.assertIsNotNone(retrieved_image)
 666
 667         self.assertEquals(created_image.name, retrieved_image.name)
 668         self.assertEquals(created_image.id, retrieved_image.id)
 669         self.assertEquals(created_image.properties, retrieved_image.properties)