snaps/openstack/tests/create_project_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 keystoneclient.exceptions import BadRequest
  19
  20 from snaps.domain.project import ComputeQuotas, NetworkQuotas
  21 from snaps.openstack.create_project import (
  22     OpenStackProject, ProjectSettings, ProjectSettingsError)
  23 from snaps.openstack.create_security_group import OpenStackSecurityGroup
  24 from snaps.openstack.create_security_group import SecurityGroupSettings
  25 from snaps.openstack.create_user import OpenStackUser
  26 from snaps.openstack.create_user import UserSettings
  27 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
  28 from snaps.openstack.utils import keystone_utils, nova_utils, neutron_utils
  29
  30 __author__ = 'spisarski'
  31
  32
  33 class ProjectSettingsUnitTests(unittest.TestCase):
  34     """
  35     Tests the construction of the ProjectSettings class
  36     """
  37
  38     def test_no_params(self):
  39         with self.assertRaises(ProjectSettingsError):
  40             ProjectSettings()
  41
  42     def test_empty_config(self):
  43         with self.assertRaises(ProjectSettingsError):
  44             ProjectSettings(**dict())
  45
  46     def test_name_only(self):
  47         settings = ProjectSettings(name='foo')
  48         self.assertEqual('foo', settings.name)
  49         self.assertEqual('Default', settings.domain_name)
  50         self.assertIsNone(settings.description)
  51         self.assertTrue(settings.enabled)
  52
  53     def test_config_with_name_only(self):
  54         settings = ProjectSettings(**{'name': 'foo'})
  55         self.assertEqual('foo', settings.name)
  56         self.assertEqual('Default', settings.domain_name)
  57         self.assertIsNone(settings.description)
  58         self.assertTrue(settings.enabled)
  59
  60     def test_all(self):
  61         settings = ProjectSettings(name='foo', domain='bar',
  62                                    description='foobar', enabled=False)
  63         self.assertEqual('foo', settings.name)
  64         self.assertEqual('bar', settings.domain_name)
  65         self.assertEqual('foobar', settings.description)
  66         self.assertFalse(settings.enabled)
  67
  68     def test_config_all(self):
  69         settings = ProjectSettings(
  70             **{'name': 'foo', 'domain': 'bar', 'description': 'foobar',
  71                'enabled': False})
  72         self.assertEqual('foo', settings.name)
  73         self.assertEqual('bar', settings.domain_name)
  74         self.assertEqual('foobar', settings.description)
  75         self.assertFalse(settings.enabled)
  76
  77
  78 class CreateProjectSuccessTests(OSComponentTestCase):
  79     """
  80     Test for the CreateImage class defined in create_image.py
  81     """
  82
  83     def setUp(self):
  84         """
  85         Instantiates the CreateImage object that is responsible for downloading
  86         and creating an OS image file within OpenStack
  87         """
  88         guid = str(uuid.uuid4())[:-19]
  89         guid = self.__class__.__name__ + '-' + guid
  90         self.project_settings = ProjectSettings(
  91             name=guid + '-name',
  92             domain=self.os_creds.project_domain_name)
  93
  94         self.keystone = keystone_utils.keystone_client(self.os_creds)
  95
  96         # Initialize for cleanup
  97         self.project_creator = None
  98
  99     def tearDown(self):
 100         """
 101         Cleans the image and downloaded image file
 102         """
 103         if self.project_creator:
 104             self.project_creator.clean()
 105
 106     def test_create_project_bad_domain(self):
 107         """
 108         Tests the creation of an OpenStack project with an invalid domain
 109         value. This test will not do anything with a keystone v2.0 client.
 110         """
 111         if self.keystone.version != keystone_utils.V2_VERSION_STR:
 112             self.project_settings.domain_name = 'foo'
 113             self.project_creator = OpenStackProject(self.os_creds,
 114                                                     self.project_settings)
 115
 116             with self.assertRaises(BadRequest):
 117                 self.project_creator.create()
 118
 119     def test_create_project(self):
 120         """
 121         Tests the creation of an OpenStack project.
 122         """
 123         self.project_creator = OpenStackProject(self.os_creds,
 124                                                 self.project_settings)
 125         created_project = self.project_creator.create()
 126         self.assertIsNotNone(created_project)
 127
 128         retrieved_project = keystone_utils.get_project(
 129             keystone=self.keystone, project_settings=self.project_settings)
 130         self.assertIsNotNone(retrieved_project)
 131         self.assertEqual(created_project, retrieved_project)
 132         self.assertTrue(validate_project(self.keystone, self.project_settings,
 133                                          created_project))
 134
 135     def test_create_project_2x(self):
 136         """
 137         Tests the creation of an OpenStack project twice to ensure it only
 138         creates one.
 139         """
 140         self.project_creator = OpenStackProject(self.os_creds,
 141                                                 self.project_settings)
 142         created_project = self.project_creator.create()
 143         self.assertIsNotNone(created_project)
 144
 145         retrieved_project = keystone_utils.get_project(
 146             keystone=self.keystone, project_settings=self.project_settings)
 147         self.assertIsNotNone(retrieved_project)
 148         self.assertEqual(created_project, retrieved_project)
 149
 150         project2 = OpenStackProject(self.os_creds,
 151                                     self.project_settings).create()
 152         self.assertEqual(retrieved_project, project2)
 153         self.assertTrue(validate_project(self.keystone, self.project_settings,
 154                                          created_project))
 155
 156     def test_create_delete_project(self):
 157         """
 158         Tests the creation of an OpenStack project, it's deletion, then cleanup
 159         """
 160         # Create Image
 161         self.project_creator = OpenStackProject(self.os_creds,
 162                                                 self.project_settings)
 163         created_project = self.project_creator.create()
 164         self.assertIsNotNone(created_project)
 165
 166         keystone_utils.delete_project(self.keystone, created_project)
 167
 168         self.project_creator.clean()
 169
 170         self.assertIsNone(self.project_creator.get_project())
 171
 172         self.assertTrue(validate_project(self.keystone, self.project_settings,
 173                                          created_project))
 174
 175     def test_update_quotas(self):
 176         """
 177         Tests the creation of an OpenStack project where the quotas get
 178         updated.
 179         """
 180         self.project_creator = OpenStackProject(self.os_creds,
 181                                                 self.project_settings)
 182         created_project = self.project_creator.create()
 183         self.assertIsNotNone(created_project)
 184
 185         retrieved_project = keystone_utils.get_project(
 186             keystone=self.keystone, project_settings=self.project_settings)
 187         self.assertIsNotNone(retrieved_project)
 188         self.assertEqual(created_project, retrieved_project)
 189         self.assertTrue(validate_project(self.keystone, self.project_settings,
 190                                          created_project))
 191
 192         update_compute_quotas = ComputeQuotas(
 193             **{'metadata_items': 64, 'cores': 5, 'instances': 5,
 194                'injected_files': 3, 'injected_file_content_bytes': 5120,
 195                'ram': 25600, 'fixed_ips': 100, 'key_pairs': 50})
 196         self.project_creator.update_compute_quotas(update_compute_quotas)
 197
 198         update_network_quotas = NetworkQuotas(
 199             **{'security_group': 5, 'security_group_rule': 50,
 200                'floatingip': 25, 'network': 5, 'port': 25, 'router': 6,
 201                'subnet': 7})
 202         self.project_creator.update_network_quotas(update_network_quotas)
 203
 204         self.assertEqual(update_compute_quotas,
 205                          self.project_creator.get_compute_quotas())
 206         self.assertEqual(update_network_quotas,
 207                          self.project_creator.get_network_quotas())
 208
 209         nova = nova_utils.nova_client(self.os_creds)
 210         new_compute_quotas = nova_utils.get_compute_quotas(
 211             nova, self.project_creator.get_project().id)
 212         self.assertEqual(update_compute_quotas, new_compute_quotas)
 213
 214         neutron = neutron_utils.neutron_client(self.os_creds)
 215         new_network_quotas = neutron_utils.get_network_quotas(
 216             neutron, self.project_creator.get_project().id)
 217         self.assertEqual(update_network_quotas, new_network_quotas)
 218
 219
 220 class CreateProjectUserTests(OSComponentTestCase):
 221     """
 222     Test for the CreateImage class defined in create_image.py
 223     """
 224
 225     def setUp(self):
 226         """
 227         Instantiates the CreateImage object that is responsible for downloading
 228         and creating an OS image file within OpenStack
 229         """
 230         guid = str(uuid.uuid4())[:-19]
 231         self.guid = self.__class__.__name__ + '-' + guid
 232         self.project_settings = ProjectSettings(
 233             name=self.guid + '-name',
 234             domain=self.os_creds.project_domain_name)
 235
 236         self.keystone = keystone_utils.keystone_client(self.os_creds)
 237
 238         # Initialize for cleanup
 239         self.project_creator = None
 240         self.user_creators = list()
 241
 242         self.sec_grp_creators = list()
 243
 244     def tearDown(self):
 245         """
 246         Cleans the image and downloaded image file
 247         """
 248         for sec_grp_creator in self.sec_grp_creators:
 249             sec_grp_creator.clean()
 250
 251         for user_creator in self.user_creators:
 252             user_creator.clean()
 253
 254         if self.project_creator:
 255             self.project_creator.clean()
 256
 257     def test_create_project_sec_grp_one_user(self):
 258         """
 259         Tests the creation of an OpenStack object to a project with a new users
 260         and to create a security group
 261         """
 262         self.project_creator = OpenStackProject(self.os_creds,
 263                                                 self.project_settings)
 264         created_project = self.project_creator.create()
 265         self.assertIsNotNone(created_project)
 266
 267         user_creator = OpenStackUser(
 268             self.os_creds, UserSettings(
 269                 name=self.guid + '-user',
 270                 password=self.guid, roles={'admin': 'admin'},
 271                 domain_name=self.os_creds.user_domain_name))
 272         self.project_creator.assoc_user(user_creator.create())
 273         self.user_creators.append(user_creator)
 274
 275         sec_grp_os_creds = user_creator.get_os_creds(
 276             self.project_creator.get_project().name)
 277         sec_grp_creator = OpenStackSecurityGroup(
 278             sec_grp_os_creds, SecurityGroupSettings(name=self.guid + '-name',
 279                                                     description='hello group'))
 280         sec_grp = sec_grp_creator.create()
 281         self.assertIsNotNone(sec_grp)
 282         self.sec_grp_creators.append(sec_grp_creator)
 283
 284         self.assertEqual(self.project_creator.get_project().id,
 285                          sec_grp.project_id)
 286
 287     def test_create_project_sec_grp_two_users(self):
 288         """
 289         Tests the creation of an OpenStack object to a project with two new
 290         users and use each user to create a security group
 291         """
 292         self.project_creator = OpenStackProject(self.os_creds,
 293                                                 self.project_settings)
 294         created_project = self.project_creator.create()
 295         self.assertIsNotNone(created_project)
 296
 297         user_creator_1 = OpenStackUser(
 298             self.os_creds, UserSettings(
 299                 name=self.guid + '-user1', password=self.guid,
 300                 roles={'admin': 'admin'},
 301                 domain_name=self.os_creds.user_domain_name))
 302         self.project_creator.assoc_user(user_creator_1.create())
 303         self.user_creators.append(user_creator_1)
 304
 305         user_creator_2 = OpenStackUser(
 306             self.os_creds, UserSettings(
 307                 name=self.guid + '-user2', password=self.guid,
 308                 roles={'admin': 'admin'},
 309                 domain_name=self.os_creds.user_domain_name))
 310         self.project_creator.assoc_user(user_creator_2.create())
 311         self.user_creators.append(user_creator_2)
 312
 313         ctr = 0
 314         for user_creator in self.user_creators:
 315             ctr += 1
 316             sec_grp_os_creds = user_creator.get_os_creds(
 317                 self.project_creator.get_project().name)
 318
 319             sec_grp_creator = OpenStackSecurityGroup(
 320                 sec_grp_os_creds,
 321                 SecurityGroupSettings(name=self.guid + '-name',
 322                                       description='hello group'))
 323             sec_grp = sec_grp_creator.create()
 324             self.assertIsNotNone(sec_grp)
 325             self.sec_grp_creators.append(sec_grp_creator)
 326
 327             self.assertEqual(self.project_creator.get_project().id,
 328                              sec_grp.project_id)
 329
 330
 331 def validate_project(keystone, project_settings, project):
 332     """
 333     Validates that the project_settings used to create the project have been
 334     properly set
 335     :param keystone: the keystone client for version checking
 336     :param project_settings: the settings used to create the project
 337     :param project: the SNAPS-OO Project domain object
 338     :return: T/F
 339     """
 340     if keystone.version == keystone_utils.V2_VERSION_STR:
 341         return project_settings.name == project.name
 342     else:
 343         domain = keystone_utils.get_domain_by_id(keystone, project.domain_id)
 344         return (project_settings.name == project.name and
 345                 project_settings.domain_name == domain.name)