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