snaps/openstack/tests/create_flavor_tests.py

   1 # Copyright (c) 2017 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 unittest
  16 import uuid
  17
  18 from snaps.openstack.create_flavor import FlavorSettings, OpenStackFlavor, \
  19     FlavorSettingsError
  20 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
  21 from snaps.openstack.utils import nova_utils
  22
  23 __author__ = 'spisarski'
  24
  25
  26 class FlavorSettingsUnitTests(unittest.TestCase):
  27     """
  28     Tests the construction of the FlavorSettings class
  29     """
  30
  31     def test_no_params(self):
  32         with self.assertRaises(FlavorSettingsError):
  33             FlavorSettings()
  34
  35     def test_empty_config(self):
  36         with self.assertRaises(FlavorSettingsError):
  37             FlavorSettings(config=dict())
  38
  39     def test_name_only(self):
  40         with self.assertRaises(FlavorSettingsError):
  41             FlavorSettings(name='foo')
  42
  43     def test_config_with_name_only(self):
  44         with self.assertRaises(FlavorSettingsError):
  45             FlavorSettings(config={'name': 'foo'})
  46
  47     def test_name_ram_only(self):
  48         with self.assertRaises(FlavorSettingsError):
  49             FlavorSettings(name='foo', ram=1)
  50
  51     def test_config_with_name_ram_only(self):
  52         with self.assertRaises(FlavorSettingsError):
  53             FlavorSettings(config={'name': 'foo', 'ram': 1})
  54
  55     def test_name_ram_disk_only(self):
  56         with self.assertRaises(FlavorSettingsError):
  57             FlavorSettings(name='foo', ram=1, disk=1)
  58
  59     def test_config_with_name_ram_disk_only(self):
  60         with self.assertRaises(FlavorSettingsError):
  61             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 1})
  62
  63     def test_ram_string(self):
  64         with self.assertRaises(FlavorSettingsError):
  65             FlavorSettings(name='foo', ram='bar', disk=2, vcpus=3, ephemeral=4,
  66                            swap=5, rxtx_factor=6.0,
  67                            is_public=False)
  68
  69     def test_config_ram_string(self):
  70         with self.assertRaises(FlavorSettingsError):
  71             FlavorSettings(
  72                 config={'name': 'foo', 'ram': 'bar', 'disk': 2, 'vcpus': 3,
  73                         'ephemeral': 4, 'swap': 5,
  74                         'rxtx_factor': 6.0, 'is_public': False})
  75
  76     def test_ram_float(self):
  77         with self.assertRaises(FlavorSettingsError):
  78             FlavorSettings(name='foo', ram=1.5, disk=2, vcpus=3, ephemeral=4,
  79                            swap=5, rxtx_factor=6.0, is_public=False)
  80
  81     def test_config_ram_float(self):
  82         with self.assertRaises(FlavorSettingsError):
  83             FlavorSettings(
  84                 config={'name': 'foo', 'ram': 1.5, 'disk': 2, 'vcpus': 3,
  85                         'ephemeral': 4, 'swap': 5,
  86                         'rxtx_factor': 6.0, 'is_public': False})
  87
  88     def test_disk_string(self):
  89         with self.assertRaises(FlavorSettingsError):
  90             FlavorSettings(name='foo', ram=1, disk='bar', vcpus=3, ephemeral=4,
  91                            swap=5, rxtx_factor=6.0,
  92                            is_public=False)
  93
  94     def test_config_disk_string(self):
  95         with self.assertRaises(FlavorSettingsError):
  96             FlavorSettings(
  97                 config={'name': 'foo', 'ram': 1, 'disk': 'bar', 'vcpus': 3,
  98                         'ephemeral': 4, 'swap': 5,
  99                         'rxtx_factor': 6.0, 'is_public': False})
 100
 101     def test_disk_float(self):
 102         with self.assertRaises(FlavorSettingsError):
 103             FlavorSettings(name='foo', ram=1, disk=2.5, vcpus=3, ephemeral=4,
 104                            swap=5, rxtx_factor=6.0, is_public=False)
 105
 106     def test_config_disk_float(self):
 107         with self.assertRaises(FlavorSettingsError):
 108             FlavorSettings(
 109                 config={'name': 'foo', 'ram': 1, 'disk': 2.5, 'vcpus': 3,
 110                         'ephemeral': 4, 'swap': 5,
 111                         'rxtx_factor': 6.0, 'is_public': False})
 112
 113     def test_vcpus_string(self):
 114         with self.assertRaises(FlavorSettingsError):
 115             FlavorSettings(name='foo', ram=1, disk=2, vcpus='bar', ephemeral=4,
 116                            swap=5, rxtx_factor=6.0,
 117                            is_public=False)
 118
 119     def test_config_vcpus_string(self):
 120         with self.assertRaises(FlavorSettingsError):
 121             FlavorSettings(
 122                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 'bar',
 123                         'ephemeral': 4, 'swap': 5,
 124                         'rxtx_factor': 6.0, 'is_public': False})
 125
 126     def test_ephemeral_string(self):
 127         with self.assertRaises(FlavorSettingsError):
 128             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral='bar',
 129                            swap=5, rxtx_factor=6.0,
 130                            is_public=False)
 131
 132     def test_config_ephemeral_string(self):
 133         with self.assertRaises(FlavorSettingsError):
 134             FlavorSettings(
 135                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3,
 136                         'ephemeral': 'bar', 'swap': 5,
 137                         'rxtx_factor': 6.0, 'is_public': False})
 138
 139     def test_ephemeral_float(self):
 140         with self.assertRaises(FlavorSettingsError):
 141             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4.5,
 142                            swap=5, rxtx_factor=6.0, is_public=False)
 143
 144     def test_config_ephemeral_float(self):
 145         with self.assertRaises(FlavorSettingsError):
 146             FlavorSettings(
 147                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3,
 148                         'ephemeral': 4.5, 'swap': 5,
 149                         'rxtx_factor': 6.0, 'is_public': False})
 150
 151     def test_swap_string(self):
 152         with self.assertRaises(FlavorSettingsError):
 153             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4,
 154                            swap='bar', rxtx_factor=6.0,
 155                            is_public=False)
 156
 157     def test_config_swap_string(self):
 158         with self.assertRaises(FlavorSettingsError):
 159             FlavorSettings(
 160                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3,
 161                         'ephemeral': 4, 'swap': 'bar',
 162                         'rxtx_factor': 6.0, 'is_public': False})
 163
 164     def test_swap_float(self):
 165         with self.assertRaises(FlavorSettingsError):
 166             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4,
 167                            swap=5.5, rxtx_factor=6.0, is_public=False)
 168
 169     def test_config_swap_float(self):
 170         with self.assertRaises(FlavorSettingsError):
 171             FlavorSettings(
 172                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3,
 173                         'ephemeral': 4, 'swap': 5.5,
 174                         'rxtx_factor': 6.0, 'is_public': False})
 175
 176     def test_rxtx_string(self):
 177         with self.assertRaises(FlavorSettingsError):
 178             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4,
 179                            swap=5, rxtx_factor='bar', is_public=False)
 180
 181     def test_config_rxtx_string(self):
 182         with self.assertRaises(FlavorSettingsError):
 183             FlavorSettings(
 184                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3,
 185                         'ephemeral': 4, 'swap': 5,
 186                         'rxtx_factor': 'bar', 'is_public': False})
 187
 188     def test_is_pub_string(self):
 189         with self.assertRaises(FlavorSettingsError):
 190             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4,
 191                            swap=5, rxtx_factor=6.0, is_public='bar')
 192
 193     def test_config_is_pub_string(self):
 194         with self.assertRaises(FlavorSettingsError):
 195             FlavorSettings(
 196                 config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3,
 197                         'ephemeral': 4, 'swap': 5,
 198                         'rxtx_factor': 6.0, 'is_public': 'bar'})
 199
 200     def test_name_ram_disk_vcpus_only(self):
 201         settings = FlavorSettings(name='foo', ram=1, disk=2, vcpus=3)
 202         self.assertEqual('foo', settings.name)
 203         self.assertEqual('auto', settings.flavor_id)
 204         self.assertEqual(1, settings.ram)
 205         self.assertEqual(2, settings.disk)
 206         self.assertEqual(3, settings.vcpus)
 207         self.assertEqual(0, settings.ephemeral)
 208         self.assertEqual(0, settings.swap)
 209         self.assertEqual(1.0, settings.rxtx_factor)
 210         self.assertEqual(True, settings.is_public)
 211         self.assertEqual(None, settings.metadata)
 212
 213     def test_config_with_name_ram_disk_vcpus_only(self):
 214         settings = FlavorSettings(
 215             **{'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3})
 216         self.assertEqual('foo', settings.name)
 217         self.assertEqual('auto', settings.flavor_id)
 218         self.assertEqual(1, settings.ram)
 219         self.assertEqual(2, settings.disk)
 220         self.assertEqual(3, settings.vcpus)
 221         self.assertEqual(0, settings.ephemeral)
 222         self.assertEqual(0, settings.swap)
 223         self.assertEqual(1.0, settings.rxtx_factor)
 224         self.assertEqual(True, settings.is_public)
 225         self.assertEqual(None, settings.metadata)
 226
 227     def test_all(self):
 228         metadata = {'foo': 'bar'}
 229         settings = FlavorSettings(
 230             name='foo', flavor_id='bar', ram=1, disk=2, vcpus=3, ephemeral=4,
 231             swap=5, rxtx_factor=6.0, is_public=False, metadata=metadata)
 232         self.assertEqual('foo', settings.name)
 233         self.assertEqual('bar', settings.flavor_id)
 234         self.assertEqual(1, settings.ram)
 235         self.assertEqual(2, settings.disk)
 236         self.assertEqual(3, settings.vcpus)
 237         self.assertEqual(4, settings.ephemeral)
 238         self.assertEqual(5, settings.swap)
 239         self.assertEqual(6.0, settings.rxtx_factor)
 240         self.assertEqual(False, settings.is_public)
 241         self.assertEqual(metadata, settings.metadata)
 242
 243     def test_config_all(self):
 244         metadata = {'foo': 'bar'}
 245         settings = FlavorSettings(
 246             **{'name': 'foo', 'flavor_id': 'bar', 'ram': 1, 'disk': 2,
 247                'vcpus': 3,
 248                'ephemeral': 4, 'swap': 5, 'rxtx_factor': 6.0,
 249                'is_public': False,
 250                'metadata': metadata})
 251         self.assertEqual('foo', settings.name)
 252         self.assertEqual('bar', settings.flavor_id)
 253         self.assertEqual(1, settings.ram)
 254         self.assertEqual(2, settings.disk)
 255         self.assertEqual(3, settings.vcpus)
 256         self.assertEqual(4, settings.ephemeral)
 257         self.assertEqual(5, settings.swap)
 258         self.assertEqual(6.0, settings.rxtx_factor)
 259         self.assertEqual(False, settings.is_public)
 260         self.assertEqual(metadata, settings.metadata)
 261
 262
 263 class CreateFlavorTests(OSComponentTestCase):
 264     """
 265     Test for the CreateSecurityGroup class defined in create_security_group.py
 266     """
 267
 268     def setUp(self):
 269         """
 270         Instantiates the CreateSecurityGroup object that is responsible for
 271         downloading and creating an OS image file within OpenStack
 272         """
 273         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 274         self.flavor_name = guid + 'name'
 275
 276         self.nova = nova_utils.nova_client(self.os_creds)
 277
 278         # Initialize for cleanup
 279         self.flavor_creator = None
 280
 281     def tearDown(self):
 282         """
 283         Cleans the image and downloaded image file
 284         """
 285         if self.flavor_creator:
 286             self.flavor_creator.clean()
 287
 288     def test_create_flavor(self):
 289         """
 290         Tests the creation of an OpenStack flavor.
 291         """
 292         # Create Flavor
 293         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1,
 294                                          vcpus=1)
 295         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 296         flavor = self.flavor_creator.create()
 297         self.assertTrue(validate_flavor(flavor_settings, flavor))
 298
 299     def test_create_flavor_existing(self):
 300         """
 301         Tests the creation of an OpenStack flavor then starts another creator
 302         to ensure it has not been done twice.
 303         """
 304         # Create Flavor
 305         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1,
 306                                          vcpus=1)
 307         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 308         flavor = self.flavor_creator.create()
 309         self.assertTrue(validate_flavor(flavor_settings, flavor))
 310
 311         flavor_creator_2 = OpenStackFlavor(self.os_creds, flavor_settings)
 312         flavor2 = flavor_creator_2.create()
 313
 314         self.assertEqual(flavor.id, flavor2.id)
 315
 316     def test_create_clean_flavor(self):
 317         """
 318         Tests the creation and cleanup of an OpenStack flavor.
 319         """
 320         # Create Flavor
 321         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1,
 322                                          vcpus=1)
 323         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 324         flavor = self.flavor_creator.create()
 325         self.assertTrue(validate_flavor(flavor_settings, flavor))
 326
 327         # Clean Flavor
 328         self.flavor_creator.clean()
 329
 330         self.assertIsNone(self.flavor_creator.get_flavor())
 331         self.assertIsNone(
 332             nova_utils.get_flavor_by_name(self.nova, flavor_settings.name))
 333
 334     def test_create_delete_flavor(self):
 335         """
 336         Tests the creation of an OpenStack Security Group, the deletion, then
 337         cleanup to ensure clean() does not
 338         raise any exceptions.
 339         """
 340         # Create Flavor
 341         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1,
 342                                          vcpus=1)
 343         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 344         flavor = self.flavor_creator.create()
 345         self.assertTrue(validate_flavor(flavor_settings, flavor))
 346
 347         # Delete Flavor
 348         nova_utils.delete_flavor(self.nova, flavor)
 349         self.assertIsNone(
 350             nova_utils.get_flavor_by_name(self.nova, flavor_settings.name))
 351
 352         # Attempt to cleanup
 353         self.flavor_creator.clean()
 354
 355         self.assertIsNone(self.flavor_creator.get_flavor())
 356
 357         # TODO - Add more tests to exercise all configuration options
 358
 359
 360 def validate_flavor(flavor_settings, flavor):
 361     """
 362     Validates the flavor_settings against the OpenStack flavor object
 363     :param flavor_settings: the settings used to create the flavor
 364     :param flavor: the OpenStack flavor object
 365     """
 366     return flavor is not None \
 367         and flavor_settings.name == flavor.name \
 368         and flavor_settings.ram == flavor.ram \
 369         and flavor_settings.disk == flavor.disk \
 370         and flavor_settings.vcpus == flavor.vcpus