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