Refactoring of VolumeSettings to extend VolumeConfig

[snaps.git] / snaps / openstack / utils / tests / settings_utils_tests.py

diff --git a/snaps/openstack/utils/tests/settings_utils_tests.py b/snaps/openstack/utils/tests/settings_utils_tests.py
index f84e6a0..1157f2c 100644 (file)
--- a/snaps/openstack/utils/tests/settings_utils_tests.py
+++ b/snaps/openstack/utils/tests/settings_utils_tests.py
@@ -13,9 +13,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import logging
+import unittest
+
 import os
 import uuid
 
+from snaps.config.flavor import FlavorConfig
+from snaps.config.keypair import KeypairConfig
+from snaps.config.qos import Consumer
+from snaps.domain.flavor import Flavor
+from snaps.domain.volume import (
+    Volume, VolumeType, VolumeTypeEncryption, QoSSpec)
 from snaps.openstack import (
     create_image, create_network, create_router, create_flavor,
     create_keypairs, create_instance)
@@ -144,8 +152,6 @@ class SettingsUtilsVmInstTests(OSComponentTestCase):
         Instantiates the CreateImage object that is responsible for downloading
         and creating an OS image file within OpenStack
         """
-        # super(self.__class__, self).__start__()
-
         self.nova = nova_utils.nova_client(self.os_creds)
         self.glance = glance_utils.glance_client(self.os_creds)
         self.neutron = neutron_utils.neutron_client(self.os_creds)
@@ -196,13 +202,13 @@ class SettingsUtilsVmInstTests(OSComponentTestCase):
             # Create Flavor
             self.flavor_creator = create_flavor.OpenStackFlavor(
                 self.os_creds,
-                create_flavor.FlavorSettings(name=guid + '-flavor-name',
-                                             ram=256, disk=1, vcpus=1))
+                FlavorConfig(
+                    name=guid + '-flavor-name', ram=256, disk=1, vcpus=1))
             self.flavor_creator.create()
 
             # Create Key/Pair
             self.keypair_creator = create_keypairs.OpenStackKeypair(
-                self.os_creds, create_keypairs.KeypairSettings(
+                self.os_creds, KeypairConfig(
                     name=self.keypair_name,
                     public_filepath=self.keypair_pub_filepath,
                     private_filepath=self.keypair_priv_filepath))
@@ -328,14 +334,71 @@ class SettingsUtilsVmInstTests(OSComponentTestCase):
     def test_derive_image_settings(self):
         """
         Validates the utility function settings_utils#create_image_settings
-        returns an acceptable ImageSettings object
+        returns an acceptable ImageConfig object
         """
         self.inst_creator.create(block=True)
 
         server = nova_utils.get_server(
             self.nova, vm_inst_settings=self.inst_creator.instance_settings)
-        derived_image_settings = settings_utils.determine_image_settings(
+        derived_image_settings = settings_utils.determine_image_config(
             self.glance, server, [self.image_creator.image_settings])
         self.assertIsNotNone(derived_image_settings)
         self.assertEqual(self.image_creator.image_settings.name,
                          derived_image_settings.name)
+
+
+class SettingsUtilsUnitTests(unittest.TestCase):
+    """
+    Exercises the settings_utils.py functions around volumes
+    """
+
+    def test_vol_settings_from_vol(self):
+        volume = Volume(
+            name='vol-name', volume_id='vol-id', description='desc', size=99,
+            vol_type='vol-type', availability_zone='zone1', multi_attach=True)
+        settings = settings_utils.create_volume_config(volume)
+        self.assertEqual(volume.name, settings.name)
+        self.assertEqual(volume.description, settings.description)
+        self.assertEqual(volume.size, settings.size)
+        self.assertEqual(volume.type, settings.type_name)
+        self.assertEqual(volume.availability_zone, settings.availability_zone)
+        self.assertEqual(volume.multi_attach, settings.multi_attach)
+
+    def test_vol_type_settings_from_vol(self):
+        encryption = VolumeTypeEncryption(
+            volume_encryption_id='vol-encrypt-id', volume_type_id='vol-typ-id',
+            control_location='front-end', provider='FooClass', cipher='1',
+            key_size=1)
+        qos_spec = QoSSpec(name='qos-spec-name', spec_id='qos-spec-id',
+                           consumer=Consumer.back_end)
+        volume_type = VolumeType(
+            name='vol-type-name', volume_type_id='vol-type-id', public=True,
+            encryption=encryption, qos_spec=qos_spec)
+
+        settings = settings_utils.create_volume_type_config(volume_type)
+        self.assertEqual(volume_type.name, settings.name)
+        self.assertEqual(volume_type.public, settings.public)
+
+        encrypt_settings = settings.encryption
+        self.assertIsNotNone(encrypt_settings)
+        self.assertEqual(encryption.control_location,
+                         encrypt_settings.control_location.value)
+        self.assertEqual(encryption.cipher, encrypt_settings.cipher)
+        self.assertEqual(encryption.key_size, encrypt_settings.key_size)
+
+        self.assertEqual(qos_spec.name, settings.qos_spec_name)
+
+    def test_flavor_settings_from_flavor(self):
+        flavor = Flavor(
+            name='flavor-name', flavor_id='flavor-id', ram=99, disk=101,
+            vcpus=9, ephemeral=3, swap=5, rxtx_factor=7, is_public=False)
+        settings = settings_utils.create_flavor_config(flavor)
+        self.assertEqual(flavor.name, settings.name)
+        self.assertEqual(flavor.id, settings.flavor_id)
+        self.assertEqual(flavor.ram, settings.ram)
+        self.assertEqual(flavor.disk, settings.disk)
+        self.assertEqual(flavor.vcpus, settings.vcpus)
+        self.assertEqual(flavor.ephemeral, settings.ephemeral)
+        self.assertEqual(flavor.swap, settings.swap)
+        self.assertEqual(flavor.rxtx_factor, settings.rxtx_factor)
+        self.assertEqual(flavor.is_public, settings.is_public)