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