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