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