Refactored multi-part images.

The logic used for creating multi-part images for the Danube release
was copied all throughout the tests, which was not sustainable.
This patch encapsulates the kernel and ramdisk images within the
same OpenStackImage object as the disk image.

JIRA: SNAPS-59

Change-Id: I45ec0ccc666accb4e768c41e249e6130dc07f6d1
Signed-off-by: spisarski <s.pisarski@cablelabs.com>

1 files changed, 137 insertions, 225 deletions

diff --git a/snaps/openstack/tests/create_image_tests.py b/snaps/openstack/tests/create_image_tests.py
index 0abd33c..1fb4e29 100644
--- a/snaps/openstack/tests/create_image_tests.py
+++ b/snaps/openstack/tests/create_image_tests.py
@@ -128,8 +128,11 @@ class ImageSettingsUnitTests(unittest.TestCase):
 
     def test_all_url(self):
         properties = {'hw_video_model': 'vga'}
+        kernel_settings = ImageSettings(name='kernel', url='http://kernel.com', image_user='bar', img_format='qcow2')
+        ramdisk_settings = ImageSettings(name='ramdisk', url='http://ramdisk.com', image_user='bar', img_format='qcow2')
         settings = ImageSettings(name='foo', image_user='bar', img_format='qcow2', url='http://foo.com',
-                                 extra_properties=properties, nic_config_pb_loc='/foo/bar')
+                                 extra_properties=properties, nic_config_pb_loc='/foo/bar',
+                                 kernel_image_settings=kernel_settings, ramdisk_image_settings=ramdisk_settings)
         self.assertEquals('foo', settings.name)
         self.assertEquals('bar', settings.image_user)
         self.assertEquals('qcow2', settings.format)
@@ -137,12 +140,25 @@ class ImageSettingsUnitTests(unittest.TestCase):
         self.assertEquals(properties, settings.extra_properties)
         self.assertIsNone(settings.image_file)
         self.assertEquals('/foo/bar', settings.nic_config_pb_loc)
+        self.assertEquals('kernel', settings.kernel_image_settings.name)
+        self.assertEquals('http://kernel.com', settings.kernel_image_settings.url)
+        self.assertEquals('bar', settings.kernel_image_settings.image_user)
+        self.assertEquals('qcow2', settings.kernel_image_settings.format)
+        self.assertEquals('ramdisk', settings.ramdisk_image_settings.name)
+        self.assertEquals('http://ramdisk.com', settings.ramdisk_image_settings.url)
+        self.assertEquals('bar', settings.ramdisk_image_settings.image_user)
+        self.assertEquals('qcow2', settings.ramdisk_image_settings.format)
 
     def test_config_all_url(self):
-        settings = ImageSettings(config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
-                                         'download_url': 'http://foo.com',
-                                         'extra_properties': '{\'hw_video_model\': \'vga\'}',
-                                         'nic_config_pb_loc': '/foo/bar'})
+        settings = ImageSettings(
+            config={'name': 'foo', 'image_user': 'bar', 'format': 'qcow2',
+                    'download_url': 'http://foo.com',
+                    'extra_properties': '{\'hw_video_model\': \'vga\'}',
+                    'nic_config_pb_loc': '/foo/bar',
+                    'kernel_image_settings': {'name': 'kernel', 'download_url': 'http://kernel.com',
+                                              'image_user': 'bar', 'format': 'qcow2'},
+                    'ramdisk_image_settings': {'name': 'ramdisk', 'download_url': 'http://ramdisk.com',
+                                               'image_user': 'bar', 'format': 'qcow2'}})
         self.assertEquals('foo', settings.name)
         self.assertEquals('bar', settings.image_user)
         self.assertEquals('qcow2', settings.format)
@@ -150,6 +166,10 @@ class ImageSettingsUnitTests(unittest.TestCase):
         self.assertEquals('{\'hw_video_model\': \'vga\'}', settings.extra_properties)
         self.assertIsNone(settings.image_file)
         self.assertEquals('/foo/bar', settings.nic_config_pb_loc)
+        self.assertEquals('kernel', settings.kernel_image_settings.name)
+        self.assertEquals('http://kernel.com', settings.kernel_image_settings.url)
+        self.assertEquals('ramdisk', settings.ramdisk_image_settings.name)
+        self.assertEquals('http://ramdisk.com', settings.ramdisk_image_settings.url)
 
     def test_all_file(self):
         properties = {'hw_video_model': 'vga'}
@@ -192,7 +212,7 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
         guid = uuid.uuid4()
         self.image_name = self.__class__.__name__ + '-' + str(guid)
         self.glance = glance_utils.glance_client(self.os_creds)
-        self.image_creators = list()
+        self.image_creator = None
 
         self.tmp_dir = 'tmp/' + str(guid)
         if not os.path.exists(self.tmp_dir):
@@ -202,10 +222,8 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
         """
         Cleans the image and downloaded image file
         """
-        if self.image_creators:
-            while self.image_creators:
-                self.image_creators[-1].clean()
-                self.image_creators.pop()
+        if self.image_creator:
+            self.image_creator.clean()
 
         if os.path.exists(self.tmp_dir) and os.path.isdir(self.tmp_dir):
             shutil.rmtree(self.tmp_dir)
@@ -218,35 +236,10 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
         """
         # Create Image
         # Set the default image settings, then set any custom parameters sent from the app
-        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
-        if self.image_metadata:
-            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
-                os_image_settings.url = self.image_metadata['disk_url']
-            if 'extra_properties' in self.image_metadata and self.image_metadata['extra_properties']:
-                os_image_settings.extra_properties = self.image_metadata['extra_properties']
+        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name, image_metadata=self.image_metadata)
 
-        # If this is a 3-part image create the kernel and ramdisk images first
-        if self.image_metadata:
-            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
-                kernel_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
-                kernel_image = self.image_creators[-1].create()
-                self.assertIsNotNone(kernel_image)
-                os_image_settings.extra_properties['kernel_id'] = kernel_image.id
-                self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
-
-            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
-                ramdisk_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
-                ramdisk_image = self.image_creators[-1].create()
-                self.assertIsNotNone(ramdisk_image)
-                os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
-                self.assertEquals(get_image_size(ramdisk_image_settings), ramdisk_image.size)
-
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
-        created_image = self.image_creators[-1].create()
+        self.image_creator = create_image.OpenStackImage(self.os_creds, os_image_settings)
+        created_image = self.image_creator.create()
         self.assertIsNotNone(created_image)
 
         retrieved_image = glance_utils.get_image(self.glance, os_image_settings.name)
@@ -262,49 +255,19 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
         """
         # Create Image
         # Set the default image settings, then set any custom parameters sent from the app
-        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
-        # Set properties
-        os_image_settings.extra_properties = {'hw_video_model': 'vga'}
+        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name, image_metadata=self.image_metadata)
 
-        if self.image_metadata:
-            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
-                os_image_settings.url = self.image_metadata['disk_url']
-            if 'extra_properties' in self.image_metadata and self.image_metadata['extra_properties']:
-                os_image_settings.extra_properties = dict(
-                    os_image_settings.extra_properties.items()
-                    + self.image_metadata['extra_properties'].items())
-
-        # If this is a 3-part image create the kernel and ramdisk images first
-        if self.image_metadata:
-            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
-                kernel_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
-                kernel_image = self.image_creators[-1].create()
-                self.assertIsNotNone(kernel_image)
-                os_image_settings.extra_properties[str('kernel_id')] = kernel_image.id
-                self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
-
-            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
-                ramdisk_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
-                ramdisk_image = self.image_creators[-1].create()
-                self.assertIsNotNone(ramdisk_image)
-                os_image_settings.extra_properties[str('ramdisk_id')] = ramdisk_image.id
-                self.assertEquals(get_image_size(ramdisk_image_settings), ramdisk_image.size)
-
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
-        created_image = self.image_creators[-1].create()
+        self.image_creator = create_image.OpenStackImage(self.os_creds, os_image_settings)
+        created_image = self.image_creator.create()
         self.assertIsNotNone(created_image)
 
         retrieved_image = glance_utils.get_image(self.glance, os_image_settings.name)
         self.assertIsNotNone(retrieved_image)
-        self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
+        self.assertEquals(self.image_creator.get_image().size, retrieved_image.size)
         self.assertEquals(get_image_size(os_image_settings), retrieved_image.size)
         self.assertEquals(created_image.name, retrieved_image.name)
         self.assertEquals(created_image.id, retrieved_image.id)
-        # self.assertEquals(created_image.properties, retrieved_image.properties)
+        self.assertEquals(created_image.properties, retrieved_image.properties)
 
     def test_create_image_clean_file(self):
         """
@@ -313,50 +276,21 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
 
         # Create Image
         # Set the default image settings, then set any custom parameters sent from the app
-        url_image_settings = openstack_tests.cirros_url_image('foo')
-        if self.image_metadata:
-            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
-                url_image_settings.url = self.image_metadata['disk_url']
+        url_image_settings = openstack_tests.cirros_url_image(self.image_name, image_metadata=self.image_metadata)
 
         # Download the file of the image
         image_file = file_utils.download(url_image_settings.url, self.tmp_dir)
-        file_image_settings = openstack_tests.file_image_test_settings(name=self.image_name, file_path=image_file.name)
-
-        # Set extra properties sent from the app (if any)
-        if self.image_metadata:
-            if 'extra_properties' in self.image_metadata and self.image_metadata['extra_properties']:
-                file_image_settings.extra_properties = self.image_metadata['extra_properties']
+        file_image_settings = openstack_tests.file_image_test_settings(
+            name=self.image_name, file_path=image_file.name, image_metadata=self.image_metadata)
 
-        # If this is a 3-part image create the kernel and ramdisk images first
-        if self.image_metadata:
-            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
-                kernel_image_file = file_utils.download(self.image_metadata['kernel_url'], self.tmp_dir)
-                kernel_image_settings = openstack_tests.file_image_test_settings(
-                    name=self.image_name+'_kernel', file_path=kernel_image_file.name)
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
-                kernel_image = self.image_creators[-1].create()
-                self.assertIsNotNone(kernel_image)
-                file_image_settings.extra_properties['kernel_id'] = kernel_image.id
-                self.assertIsNotNone(kernel_image)
-                self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
-
-            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
-                ramdisk_image_file = file_utils.download(self.image_metadata['ramdisk_url'], self.tmp_dir)
-                ramdisk_image_settings = openstack_tests.file_image_test_settings(
-                    name=self.image_name+'_ramdisk', file_path=ramdisk_image_file.name)
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
-                ramdisk_image = self.image_creators[-1].create()
-                self.assertIsNotNone(ramdisk_image)
-                file_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
-
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, file_image_settings))
-        created_image = self.image_creators[-1].create()
+        self.image_creator = create_image.OpenStackImage(self.os_creds, file_image_settings)
+        created_image = self.image_creator.create()
         self.assertIsNotNone(created_image)
         self.assertEqual(self.image_name, created_image.name)
 
         retrieved_image = glance_utils.get_image(self.glance, file_image_settings.name)
         self.assertIsNotNone(retrieved_image)
-        self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
+        self.assertEquals(self.image_creator.get_image().size, retrieved_image.size)
         self.assertEquals(get_image_size(file_image_settings), retrieved_image.size)
 
         self.assertEquals(created_image.name, retrieved_image.name)
@@ -368,51 +302,25 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
         """
         # Create Image
         # Set the default image settings, then set any custom parameters sent from the app
-        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
-        if self.image_metadata:
-            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
-                os_image_settings.url = self.image_metadata['disk_url']
-            if 'extra_properties' in self.image_metadata and self.image_metadata['extra_properties']:
-                os_image_settings.extra_properties = self.image_metadata['extra_properties']
-
-        # If this is a 3-part image create the kernel and ramdisk images first
-        if self.image_metadata:
-            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
-                kernel_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
-                kernel_image = self.image_creators[-1].create()
-                self.assertIsNotNone(kernel_image)
-                self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
-                os_image_settings.extra_properties['kernel_id'] = kernel_image.id
-
-            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
-                ramdisk_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
-                ramdisk_image = self.image_creators[-1].create()
-                self.assertIsNotNone(ramdisk_image)
-                self.assertEquals(get_image_size(ramdisk_image_settings), ramdisk_image.size)
-                os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
+        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name, image_metadata=self.image_metadata)
 
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
-        created_image = self.image_creators[-1].create()
+        self.image_creator = create_image.OpenStackImage(self.os_creds, os_image_settings)
+        created_image = self.image_creator.create()
         self.assertIsNotNone(created_image)
 
         retrieved_image = glance_utils.get_image(self.glance, os_image_settings.name)
         self.assertIsNotNone(retrieved_image)
-        self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
+        self.assertEquals(self.image_creator.get_image().size, retrieved_image.size)
         self.assertEquals(get_image_size(os_image_settings), retrieved_image.size)
 
         # Delete Image manually
         glance_utils.delete_image(self.glance, created_image)
 
-        self.assertIsNone(glance_utils.get_image(self.glance, self.image_creators[-1].image_settings.name))
+        self.assertIsNone(glance_utils.get_image(self.glance, self.image_creator.image_settings.name))
 
         # Must not throw an exception when attempting to cleanup non-existent image
-        self.image_creators[-1].clean()
-        self.assertIsNone(self.image_creators[-1].get_image())
-        self.image_creators.pop()
+        self.image_creator.clean()
+        self.assertIsNone(self.image_creator.get_image())
 
     def test_create_same_image(self):
         """
@@ -420,38 +328,14 @@ class CreateImageSuccessTests(OSIntegrationTestCase):
         """
         # Create Image
         # Set the default image settings, then set any custom parameters sent from the app
-        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name)
-        if self.image_metadata:
-            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
-                os_image_settings.url = self.image_metadata['disk_url']
-            if 'extra_properties' in self.image_metadata and self.image_metadata['extra_properties']:
-                os_image_settings.extra_properties = self.image_metadata['extra_properties']
-
-        # If this is a 3-part image create the kernel and ramdisk images first
-        if self.image_metadata:
-            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
-                kernel_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_kernel', url=self.image_metadata['kernel_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
-                kernel_image = self.image_creators[-1].create()
-                self.assertIsNotNone(kernel_image)
-                self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
-                os_image_settings.extra_properties['kernel_id'] = kernel_image.id
+        os_image_settings = openstack_tests.cirros_url_image(name=self.image_name, image_metadata=self.image_metadata)
 
-            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
-                ramdisk_image_settings = openstack_tests.cirros_url_image(
-                    name=self.image_name+'_ramdisk', url=self.image_metadata['ramdisk_url'])
-                self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
-                ramdisk_image = self.image_creators[-1].create()
-                self.assertIsNotNone(ramdisk_image)
-                os_image_settings.extra_properties['ramdisk_id'] = ramdisk_image.id
-
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
-        image1 = self.image_creators[-1].create()
+        self.image_creator = create_image.OpenStackImage(self.os_creds, os_image_settings)
+        image1 = self.image_creator.create()
 
         retrieved_image = glance_utils.get_image(self.glance, os_image_settings.name)
         self.assertIsNotNone(retrieved_image)
-        self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
+        self.assertEquals(self.image_creator.get_image().size, retrieved_image.size)
         self.assertEquals(get_image_size(os_image_settings), retrieved_image.size)
         self.assertEquals(image1.name, retrieved_image.name)
         self.assertEquals(image1.id, retrieved_image.id)
@@ -566,7 +450,7 @@ class CreateImageNegativeTests(OSIntegrationTestCase):
 
 class CreateMultiPartImageTests(OSIntegrationTestCase):
     """
-    Test for creating a 3-part image
+    Test different means for creating a 3-part images
     """
     def setUp(self):
         """
@@ -588,9 +472,8 @@ class CreateMultiPartImageTests(OSIntegrationTestCase):
         """
         Cleans the images and downloaded image file
         """
-        while self.image_creators:
-            self.image_creators[-1].clean()
-            self.image_creators.pop()
+        for image_creator in self.image_creators:
+            image_creator.clean()
 
         if os.path.exists(self.tmp_dir) and os.path.isdir(self.tmp_dir):
             shutil.rmtree(self.tmp_dir)
@@ -601,63 +484,33 @@ class CreateMultiPartImageTests(OSIntegrationTestCase):
         """
         Tests the creation of a 3-part OpenStack image from a URL.
         """
-        # Set properties
-        properties = {}
-        if self.image_metadata:
-            if 'extra_properties' in self.image_metadata and self.image_metadata['extra_properties']:
-                properties = self.image_metadata['extra_properties']
-
         # Create the kernel image
-        kernel_image_settings = openstack_tests.cirros_url_image(
-            name=self.image_name+'_kernel',
-            url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-kernel')
-
-        if self.image_metadata:
-            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
-                kernel_image_settings.url = self.image_metadata['kernel_url']
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
-        kernel_image = self.image_creators[-1].create()
-        self.assertIsNotNone(kernel_image)
-        self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
-
-        # Create the ramdisk image
-        ramdisk_image_settings = openstack_tests.cirros_url_image(
-            name=self.image_name+'_ramdisk',
-            url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-initramfs')
-        if self.image_metadata:
-            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
-                ramdisk_image_settings.url = self.image_metadata['ramdisk_url']
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
-        ramdisk_image = self.image_creators[-1].create()
-        self.assertIsNotNone(ramdisk_image)
-        self.assertEquals(get_image_size(ramdisk_image_settings), ramdisk_image.size)
-
-        # Create the main image
-        os_image_settings = openstack_tests.cirros_url_image(
+        image_settings = openstack_tests.cirros_url_image(
             name=self.image_name,
-            url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img')
-        if self.image_metadata:
-            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
-                os_image_settings.url = self.image_metadata['disk_url']
+            image_metadata={'disk_url': 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img',
+                            'kernel_url': 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-kernel',
+                            'ramdisk_url': 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-initramfs'})
 
-        properties['kernel_id'] = kernel_image.id
-        properties['ramdisk_id'] = ramdisk_image.id
-        os_image_settings.extra_properties = properties
+        image_creator = create_image.OpenStackImage(self.os_creds, image_settings)
+        self.image_creators.append(image_creator)
+        image_creator.create()
 
-        self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
-        created_image = self.image_creators[-1].create()
-        self.assertIsNotNone(created_image)
-        self.assertEqual(self.image_name, created_image.name)
+        main_image = glance_utils.get_image(self.glance, image_settings.name)
+        self.assertIsNotNone(main_image)
+        self.assertIsNotNone(image_creator.get_image())
+        self.assertEquals(image_creator.get_image().id, main_image.id)
 
-        retrieved_image = glance_utils.get_image(self.glance, os_image_settings.name)
-        self.assertIsNotNone(retrieved_image)
-        self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
-        self.assertEquals(get_image_size(os_image_settings), retrieved_image.size)
-        self.assertEquals(created_image.name, retrieved_image.name)
-        self.assertEquals(created_image.id, retrieved_image.id)
-        self.assertEquals(created_image.properties, retrieved_image.properties)
+        kernel_image = glance_utils.get_image(self.glance, image_settings.kernel_image_settings.name)
+        self.assertIsNotNone(kernel_image)
+        self.assertIsNotNone(image_creator.get_kernel_image())
+        self.assertEquals(kernel_image.id, image_creator.get_kernel_image().id)
 
-    def test_create_three_part_image_from_file(self):
+        ramdisk_image = glance_utils.get_image(self.glance, image_settings.ramdisk_image_settings.name)
+        self.assertIsNotNone(ramdisk_image)
+        self.assertIsNotNone(image_creator.get_ramdisk_image())
+        self.assertEquals(ramdisk_image.id, image_creator.get_ramdisk_image().id)
+
+    def test_create_three_part_image_from_file_3_creators(self):
         """
         Tests the creation of a 3-part OpenStack image from files.
         """
@@ -707,9 +560,68 @@ class CreateMultiPartImageTests(OSIntegrationTestCase):
 
         retrieved_image = glance_utils.get_image(self.glance, file_image_settings.name)
         self.assertIsNotNone(retrieved_image)
-
         self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
         self.assertEquals(get_image_size(file_image_settings), retrieved_image.size)
+        self.assertEquals(created_image.name, retrieved_image.name)
+        self.assertEquals(created_image.id, retrieved_image.id)
+        self.assertEquals(created_image.properties, retrieved_image.properties)
+
+    def test_create_three_part_image_from_url_3_creators(self):
+        """
+        Tests the creation of a 3-part OpenStack image from a URL.
+        """
+        # Set properties
+        properties = {}
+        if self.image_metadata and self.image_metadata['extra_properties']:
+            properties = self.image_metadata['extra_properties']
+
+        # Create the kernel image
+        kernel_image_settings = openstack_tests.cirros_url_image(
+            name=self.image_name+'_kernel',
+            url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-kernel')
+
+        if self.image_metadata:
+            if 'kernel_url' in self.image_metadata and self.image_metadata['kernel_url']:
+                kernel_image_settings.url = self.image_metadata['kernel_url']
+        self.image_creators.append(create_image.OpenStackImage(self.os_creds, kernel_image_settings))
+        kernel_image = self.image_creators[-1].create()
+        self.assertIsNotNone(kernel_image)
+        self.assertEquals(get_image_size(kernel_image_settings), kernel_image.size)
+
+        # Create the ramdisk image
+        ramdisk_image_settings = openstack_tests.cirros_url_image(
+            name=self.image_name+'_ramdisk',
+            url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-initramfs')
+        if self.image_metadata:
+            if 'ramdisk_url' in self.image_metadata and self.image_metadata['ramdisk_url']:
+                ramdisk_image_settings.url = self.image_metadata['ramdisk_url']
+        self.image_creators.append(create_image.OpenStackImage(self.os_creds, ramdisk_image_settings))
+        ramdisk_image = self.image_creators[-1].create()
+        self.assertIsNotNone(ramdisk_image)
+        self.assertEquals(get_image_size(ramdisk_image_settings), ramdisk_image.size)
+
+        # Create the main image
+        os_image_settings = openstack_tests.cirros_url_image(
+            name=self.image_name,
+            url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img')
+        if self.image_metadata:
+            if 'disk_url' in self.image_metadata and self.image_metadata['disk_url']:
+                os_image_settings.url = self.image_metadata['disk_url']
+
+        properties['kernel_id'] = kernel_image.id
+        properties['ramdisk_id'] = ramdisk_image.id
+        os_image_settings.extra_properties = properties
+
+        self.image_creators.append(create_image.OpenStackImage(self.os_creds, os_image_settings))
+        created_image = self.image_creators[-1].create()
+        self.assertIsNotNone(created_image)
+        self.assertEqual(self.image_name, created_image.name)
+
+        retrieved_image = glance_utils.get_image(self.glance, os_image_settings.name)
+        self.assertIsNotNone(retrieved_image)
+
+        self.assertEquals(self.image_creators[-1].get_image().size, retrieved_image.size)
+        self.assertEquals(get_image_size(os_image_settings), retrieved_image.size)
 
         self.assertEquals(created_image.name, retrieved_image.name)
         self.assertEquals(created_image.id, retrieved_image.id)