snaps/openstack/tests/create_flavor_tests.py

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