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 uuid
  16 import unittest
  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, swap=5, rxtx_factor=6.0,
  65                            is_public=False)
  66
  67     def test_config_ram_string(self):
  68         with self.assertRaises(Exception):
  69             FlavorSettings(config={'name': 'foo', 'ram': 'bar', 'disk': 2, 'vcpus': 3, 'ephemeral': 4, 'swap': 5,
  70                                    'rxtx_factor': 6.0, 'is_public': False})
  71
  72     def test_ram_float(self):
  73         with self.assertRaises(Exception):
  74             FlavorSettings(name='foo', ram=1.5, disk=2, vcpus=3, ephemeral=4, swap=5, rxtx_factor=6.0, is_public=False)
  75
  76     def test_config_ram_float(self):
  77         with self.assertRaises(Exception):
  78             FlavorSettings(config={'name': 'foo', 'ram': 1.5, 'disk': 2, 'vcpus': 3, 'ephemeral': 4, 'swap': 5,
  79                                    'rxtx_factor': 6.0, 'is_public': False})
  80
  81     def test_disk_string(self):
  82         with self.assertRaises(Exception):
  83             FlavorSettings(name='foo', ram=1, disk='bar', vcpus=3, ephemeral=4, swap=5, rxtx_factor=6.0,
  84                            is_public=False)
  85
  86     def test_config_disk_string(self):
  87         with self.assertRaises(Exception):
  88             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 'bar', 'vcpus': 3, 'ephemeral': 4, 'swap': 5,
  89                                    'rxtx_factor': 6.0, 'is_public': False})
  90
  91     def test_disk_float(self):
  92         with self.assertRaises(Exception):
  93             FlavorSettings(name='foo', ram=1, disk=2.5, vcpus=3, ephemeral=4, swap=5, rxtx_factor=6.0, is_public=False)
  94
  95     def test_config_disk_float(self):
  96         with self.assertRaises(Exception):
  97             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2.5, 'vcpus': 3, 'ephemeral': 4, 'swap': 5,
  98                                    'rxtx_factor': 6.0, 'is_public': False})
  99
 100     def test_vcpus_string(self):
 101         with self.assertRaises(Exception):
 102             FlavorSettings(name='foo', ram=1, disk=2, vcpus='bar', ephemeral=4, swap=5, rxtx_factor=6.0,
 103                            is_public=False)
 104
 105     def test_config_vcpus_string(self):
 106         with self.assertRaises(Exception):
 107             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 'bar', 'ephemeral': 4, 'swap': 5,
 108                                    'rxtx_factor': 6.0, 'is_public': False})
 109
 110     def test_ephemeral_string(self):
 111         with self.assertRaises(Exception):
 112             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral='bar', swap=5, rxtx_factor=6.0,
 113                            is_public=False)
 114
 115     def test_config_ephemeral_string(self):
 116         with self.assertRaises(Exception):
 117             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3, 'ephemeral': 'bar', 'swap': 5,
 118                                    'rxtx_factor': 6.0, 'is_public': False})
 119
 120     def test_ephemeral_float(self):
 121         with self.assertRaises(Exception):
 122             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4.5, swap=5, rxtx_factor=6.0, is_public=False)
 123
 124     def test_config_ephemeral_float(self):
 125         with self.assertRaises(Exception):
 126             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3, 'ephemeral': 4.5, 'swap': 5,
 127                                    'rxtx_factor': 6.0, 'is_public': False})
 128
 129     def test_swap_string(self):
 130         with self.assertRaises(Exception):
 131             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4, swap='bar', rxtx_factor=6.0,
 132                            is_public=False)
 133
 134     def test_config_swap_string(self):
 135         with self.assertRaises(Exception):
 136             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3, 'ephemeral': 4, 'swap': 'bar',
 137                                    'rxtx_factor': 6.0, 'is_public': False})
 138
 139     def test_swap_float(self):
 140         with self.assertRaises(Exception):
 141             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4, swap=5.5, rxtx_factor=6.0, is_public=False)
 142
 143     def test_config_swap_float(self):
 144         with self.assertRaises(Exception):
 145             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3, 'ephemeral': 4, 'swap': 5.5,
 146                                    'rxtx_factor': 6.0, 'is_public': False})
 147
 148     def test_rxtx_string(self):
 149         with self.assertRaises(Exception):
 150             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4, swap=5, rxtx_factor='bar', is_public=False)
 151
 152     def test_config_rxtx_string(self):
 153         with self.assertRaises(Exception):
 154             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3, 'ephemeral': 4, 'swap': 5,
 155                                    'rxtx_factor': 'bar', 'is_public': False})
 156
 157     def test_is_pub_string(self):
 158         with self.assertRaises(Exception):
 159             FlavorSettings(name='foo', ram=1, disk=2, vcpus=3, ephemeral=4, swap=5, rxtx_factor=6.0, is_public='bar')
 160
 161     def test_config_is_pub_string(self):
 162         with self.assertRaises(Exception):
 163             FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3, 'ephemeral': 4, 'swap': 5,
 164                                    'rxtx_factor': 6.0, 'is_public': 'bar'})
 165
 166     def test_name_ram_disk_vcpus_only(self):
 167         settings = FlavorSettings(name='foo', ram=1, disk=2, vcpus=3)
 168         self.assertEqual('foo', settings.name)
 169         self.assertEqual('auto', settings.flavor_id)
 170         self.assertEqual(1, settings.ram)
 171         self.assertEqual(2, settings.disk)
 172         self.assertEqual(3, settings.vcpus)
 173         self.assertEqual(0, settings.ephemeral)
 174         self.assertEqual(0, settings.swap)
 175         self.assertEqual(1.0, settings.rxtx_factor)
 176         self.assertEqual(True, settings.is_public)
 177         self.assertEqual(None, settings.metadata)
 178
 179     def test_config_with_name_ram_disk_vcpus_only(self):
 180         settings = FlavorSettings(config={'name': 'foo', 'ram': 1, 'disk': 2, 'vcpus': 3})
 181         self.assertEqual('foo', settings.name)
 182         self.assertEqual('auto', settings.flavor_id)
 183         self.assertEqual(1, settings.ram)
 184         self.assertEqual(2, settings.disk)
 185         self.assertEqual(3, settings.vcpus)
 186         self.assertEqual(0, settings.ephemeral)
 187         self.assertEqual(0, settings.swap)
 188         self.assertEqual(1.0, settings.rxtx_factor)
 189         self.assertEqual(True, settings.is_public)
 190         self.assertEqual(None, settings.metadata)
 191
 192     def test_all(self):
 193         metadata = {'foo': 'bar'}
 194         settings = FlavorSettings(name='foo', flavor_id='bar', ram=1, disk=2, vcpus=3, ephemeral=4, swap=5,
 195                                   rxtx_factor=6.0, is_public=False, metadata=metadata)
 196         self.assertEqual('foo', settings.name)
 197         self.assertEqual('bar', settings.flavor_id)
 198         self.assertEqual(1, settings.ram)
 199         self.assertEqual(2, settings.disk)
 200         self.assertEqual(3, settings.vcpus)
 201         self.assertEqual(4, settings.ephemeral)
 202         self.assertEqual(5, settings.swap)
 203         self.assertEqual(6.0, settings.rxtx_factor)
 204         self.assertEqual(False, settings.is_public)
 205         self.assertEqual(metadata, settings.metadata)
 206
 207     def test_config_all(self):
 208         metadata = {'foo': 'bar'}
 209         settings = FlavorSettings(config={'name': 'foo', 'flavor_id': 'bar', 'ram': 1, 'disk': 2, 'vcpus': 3,
 210                                           'ephemeral': 4, 'swap': 5, 'rxtx_factor': 6.0, 'is_public': False,
 211                                           'metadata': metadata})
 212         self.assertEqual('foo', settings.name)
 213         self.assertEqual('bar', settings.flavor_id)
 214         self.assertEqual(1, settings.ram)
 215         self.assertEqual(2, settings.disk)
 216         self.assertEqual(3, settings.vcpus)
 217         self.assertEqual(4, settings.ephemeral)
 218         self.assertEqual(5, settings.swap)
 219         self.assertEqual(6.0, settings.rxtx_factor)
 220         self.assertEqual(False, settings.is_public)
 221         self.assertEqual(metadata, settings.metadata)
 222
 223
 224 class CreateFlavorTests(OSComponentTestCase):
 225     """
 226     Test for the CreateSecurityGroup class defined in create_security_group.py
 227     """
 228
 229     def setUp(self):
 230         """
 231         Instantiates the CreateSecurityGroup object that is responsible for downloading and creating an OS image file
 232         within OpenStack
 233         """
 234         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 235         self.flavor_name = guid + 'name'
 236
 237         self.nova = nova_utils.nova_client(self.os_creds)
 238
 239         # Initialize for cleanup
 240         self.flavor_creator = None
 241
 242     def tearDown(self):
 243         """
 244         Cleans the image and downloaded image file
 245         """
 246         if self.flavor_creator:
 247             self.flavor_creator.clean()
 248
 249     def test_create_flavor(self):
 250         """
 251         Tests the creation of an OpenStack flavor.
 252         """
 253         # Create Flavor
 254         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1, vcpus=1)
 255         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 256         flavor = self.flavor_creator.create()
 257         self.assertTrue(validate_flavor(flavor_settings, flavor))
 258
 259     def test_create_flavor_existing(self):
 260         """
 261         Tests the creation of an OpenStack flavor then starts another creator to ensure it has not been done twice.
 262         """
 263         # Create Flavor
 264         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1, vcpus=1)
 265         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 266         flavor = self.flavor_creator.create()
 267         self.assertTrue(validate_flavor(flavor_settings, flavor))
 268
 269         flavor_creator_2 = OpenStackFlavor(self.os_creds, flavor_settings)
 270         flavor2 = flavor_creator_2.create()
 271
 272         self.assertEqual(flavor.id, flavor2.id)
 273
 274     def test_create_clean_flavor(self):
 275         """
 276         Tests the creation and cleanup of an OpenStack flavor.
 277         """
 278         # Create Flavor
 279         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1, vcpus=1)
 280         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 281         flavor = self.flavor_creator.create()
 282         self.assertTrue(validate_flavor(flavor_settings, flavor))
 283
 284         # Clean Flavor
 285         self.flavor_creator.clean()
 286
 287         self.assertIsNone(self.flavor_creator.get_flavor())
 288         self.assertIsNone(nova_utils.get_flavor_by_name(self.nova, flavor_settings.name))
 289
 290     def test_create_delete_flavor(self):
 291         """
 292         Tests the creation of an OpenStack Security Group, the deletion, then cleanup to ensure clean() does not
 293         raise any exceptions.
 294         """
 295         # Create Flavor
 296         flavor_settings = FlavorSettings(name=self.flavor_name, ram=1, disk=1, vcpus=1)
 297         self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_settings)
 298         flavor = self.flavor_creator.create()
 299         self.assertTrue(validate_flavor(flavor_settings, flavor))
 300
 301         # Delete Flavor
 302         nova_utils.delete_flavor(self.nova, flavor)
 303         self.assertIsNone(nova_utils.get_flavor_by_name(self.nova, flavor_settings.name))
 304
 305         # Attempt to cleanup
 306         self.flavor_creator.clean()
 307
 308         self.assertIsNone(self.flavor_creator.get_flavor())
 309
 310         # TODO - Add more tests to exercise all configuration options
 311
 312
 313 def validate_flavor(flavor_settings, flavor):
 314     """
 315     Validates the flavor_settings against the OpenStack flavor object
 316     :param flavor_settings: the settings used to create the flavor
 317     :param flavor: the OpenStack flavor object
 318     """
 319     return flavor is not None \
 320            and flavor_settings.name == flavor.name \
 321            and flavor_settings.ram == flavor.ram \
 322            and flavor_settings.disk == flavor.disk \
 323            and flavor_settings.vcpus == flavor.vcpus