1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
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:
8 # http://www.apache.org/licenses/LICENSE-2.0
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.
18 from keystoneclient.exceptions import BadRequest
20 from snaps.config.security_group import SecurityGroupConfig
21 from snaps.config.user import UserConfig
22 from snaps.config.project import ProjectConfigError, ProjectConfig
23 from snaps.domain.project import ComputeQuotas, NetworkQuotas
24 from snaps.openstack.create_project import (
25 OpenStackProject, ProjectSettings)
26 from snaps.openstack.create_security_group import OpenStackSecurityGroup
27 from snaps.openstack.create_user import OpenStackUser
28 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
29 from snaps.openstack.utils import keystone_utils, nova_utils, neutron_utils
31 __author__ = 'spisarski'
34 class ProjectSettingsUnitTests(unittest.TestCase):
36 Tests the construction of the ProjectSettings class
39 def test_no_params(self):
40 with self.assertRaises(ProjectConfigError):
43 def test_empty_config(self):
44 with self.assertRaises(ProjectConfigError):
45 ProjectSettings(**dict())
47 def test_name_only(self):
48 settings = ProjectSettings(name='foo')
49 self.assertEqual('foo', settings.name)
50 self.assertEqual('Default', settings.domain_name)
51 self.assertIsNone(settings.description)
52 self.assertTrue(settings.enabled)
53 self.assertEqual(list(), settings.users)
55 def test_config_with_name_only(self):
56 settings = ProjectSettings(**{'name': 'foo'})
57 self.assertEqual('foo', settings.name)
58 self.assertEqual('Default', settings.domain_name)
59 self.assertIsNone(settings.description)
60 self.assertTrue(settings.enabled)
61 self.assertEqual(list(), settings.users)
64 users = ['test1', 'test2']
65 settings = ProjectSettings(
66 name='foo', domain='bar', description='foobar', enabled=False,
68 self.assertEqual('foo', settings.name)
69 self.assertEqual('bar', settings.domain_name)
70 self.assertEqual('foobar', settings.description)
71 self.assertFalse(settings.enabled)
72 self.assertEqual(users, settings.users)
74 def test_config_all(self):
75 users = ['test1', 'test2']
76 settings = ProjectSettings(
77 **{'name': 'foo', 'domain': 'bar', 'description': 'foobar',
78 'enabled': False, 'users': users})
79 self.assertEqual('foo', settings.name)
80 self.assertEqual('bar', settings.domain_name)
81 self.assertEqual('foobar', settings.description)
82 self.assertFalse(settings.enabled)
83 self.assertEqual(users, settings.users)
86 class CreateProjectSuccessTests(OSComponentTestCase):
88 Test for the CreateImage class defined in create_image.py
93 Instantiates the CreateImage object that is responsible for downloading
94 and creating an OS image file within OpenStack
96 guid = str(uuid.uuid4())[:-19]
97 guid = self.__class__.__name__ + '-' + guid
98 self.project_settings = ProjectConfig(
100 domain=self.os_creds.project_domain_name)
102 self.keystone = keystone_utils.keystone_client(
103 self.os_creds, self.os_session)
105 # Initialize for cleanup
106 self.project_creator = None
110 Cleans the image and downloaded image file
112 if self.project_creator:
113 self.project_creator.clean()
115 super(self.__class__, self).__clean__()
117 def test_create_project_bad_domain(self):
119 Tests the creation of an OpenStack project with an invalid domain
120 value. This test will not do anything with a keystone v2.0 client.
122 if self.keystone.version != keystone_utils.V2_VERSION_STR:
123 self.project_settings.domain_name = 'foo'
124 self.project_creator = OpenStackProject(self.os_creds,
125 self.project_settings)
127 with self.assertRaises(BadRequest):
128 self.project_creator.create()
130 def test_create_project(self):
132 Tests the creation of an OpenStack project.
134 self.project_creator = OpenStackProject(self.os_creds,
135 self.project_settings)
136 created_project = self.project_creator.create()
137 self.assertIsNotNone(created_project)
139 retrieved_project = keystone_utils.get_project(
140 keystone=self.keystone, project_settings=self.project_settings)
141 self.assertIsNotNone(retrieved_project)
142 self.assertEqual(created_project, retrieved_project)
143 self.assertTrue(validate_project(self.keystone, self.project_settings,
146 def test_create_project_2x(self):
148 Tests the creation of an OpenStack project twice to ensure it only
151 self.project_creator = OpenStackProject(self.os_creds,
152 self.project_settings)
153 created_project = self.project_creator.create()
154 self.assertIsNotNone(created_project)
156 retrieved_project = keystone_utils.get_project(
157 keystone=self.keystone, project_settings=self.project_settings)
158 self.assertIsNotNone(retrieved_project)
159 self.assertEqual(created_project, retrieved_project)
161 project2 = OpenStackProject(self.os_creds,
162 self.project_settings).create()
163 self.assertEqual(retrieved_project, project2)
164 self.assertTrue(validate_project(self.keystone, self.project_settings,
167 def test_create_delete_project(self):
169 Tests the creation of an OpenStack project, it's deletion, then cleanup
172 self.project_creator = OpenStackProject(self.os_creds,
173 self.project_settings)
174 created_project = self.project_creator.create()
175 self.assertIsNotNone(created_project)
177 keystone_utils.delete_project(self.keystone, created_project)
179 self.project_creator.clean()
181 self.assertIsNone(self.project_creator.get_project())
183 self.assertTrue(validate_project(self.keystone, self.project_settings,
186 def test_update_quotas(self):
188 Tests the creation of an OpenStack project where the quotas get
191 self.project_creator = OpenStackProject(self.os_creds,
192 self.project_settings)
193 created_project = self.project_creator.create()
194 self.assertIsNotNone(created_project)
196 retrieved_project = keystone_utils.get_project(
197 keystone=self.keystone, project_settings=self.project_settings)
198 self.assertIsNotNone(retrieved_project)
199 self.assertEqual(created_project, retrieved_project)
200 self.assertTrue(validate_project(self.keystone, self.project_settings,
203 update_compute_quotas = ComputeQuotas(
204 **{'metadata_items': 64, 'cores': 5, 'instances': 5,
205 'injected_files': 3, 'injected_file_content_bytes': 5120,
206 'ram': 25600, 'fixed_ips': 100, 'key_pairs': 50})
207 self.project_creator.update_compute_quotas(update_compute_quotas)
209 update_network_quotas = NetworkQuotas(
210 **{'security_group': 5, 'security_group_rule': 50,
211 'floatingip': 25, 'network': 5, 'port': 25, 'router': 6,
213 self.project_creator.update_network_quotas(update_network_quotas)
215 self.assertEqual(update_compute_quotas,
216 self.project_creator.get_compute_quotas())
217 self.assertEqual(update_network_quotas,
218 self.project_creator.get_network_quotas())
220 nova = nova_utils.nova_client(self.os_creds, self.os_session)
221 new_compute_quotas = nova_utils.get_compute_quotas(
222 nova, self.project_creator.get_project().id)
223 self.assertEqual(update_compute_quotas, new_compute_quotas)
225 neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
226 new_network_quotas = neutron_utils.get_network_quotas(
227 neutron, self.project_creator.get_project().id)
228 self.assertEqual(update_network_quotas, new_network_quotas)
231 class CreateProjectUserTests(OSComponentTestCase):
233 Test for the CreateImage class defined in create_image.py
238 Instantiates the CreateImage object that is responsible for downloading
239 and creating an OS image file within OpenStack
241 guid = str(uuid.uuid4())[:-19]
242 self.guid = self.__class__.__name__ + '-' + guid
243 self.project_settings = ProjectConfig(
244 name=self.guid + '-name',
245 domain=self.os_creds.project_domain_name)
247 self.keystone = keystone_utils.keystone_client(
248 self.os_creds, self.os_session)
250 # Initialize for cleanup
251 self.project_creator = None
252 self.user_creators = list()
254 self.sec_grp_creators = list()
258 Cleans the image and downloaded image file
260 for sec_grp_creator in self.sec_grp_creators:
261 sec_grp_creator.clean()
263 for user_creator in self.user_creators:
266 if self.project_creator:
267 self.project_creator.clean()
269 super(self.__class__, self).__clean__()
271 def test_create_project_sec_grp_one_user(self):
273 Tests the creation of an OpenStack object to a project with a new users
274 and to create a security group
276 self.project_creator = OpenStackProject(self.os_creds,
277 self.project_settings)
278 created_project = self.project_creator.create()
279 self.assertIsNotNone(created_project)
281 user_creator = OpenStackUser(
282 self.os_creds, UserConfig(
283 name=self.guid + '-user',
285 roles={'admin': self.project_settings.name},
286 domain_name=self.os_creds.user_domain_name))
287 self.project_creator.assoc_user(user_creator.create())
288 self.user_creators.append(user_creator)
290 sec_grp_os_creds = user_creator.get_os_creds(
291 self.project_creator.get_project().name)
292 sec_grp_creator = OpenStackSecurityGroup(
293 sec_grp_os_creds, SecurityGroupConfig(
294 name=self.guid + '-name', description='hello group'))
295 sec_grp = sec_grp_creator.create()
296 self.assertIsNotNone(sec_grp)
297 self.sec_grp_creators.append(sec_grp_creator)
299 self.assertEqual(self.project_creator.get_project().id,
302 def test_create_project_sec_grp_two_users(self):
304 Tests the creation of an OpenStack object to a project with two new
305 users and use each user to create a security group
307 self.project_creator = OpenStackProject(self.os_creds,
308 self.project_settings)
309 created_project = self.project_creator.create()
310 self.assertIsNotNone(created_project)
312 user_creator_1 = OpenStackUser(
313 self.os_creds, UserConfig(
314 name=self.guid + '-user1', 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_1.create())
318 self.user_creators.append(user_creator_1)
320 user_creator_2 = OpenStackUser(
321 self.os_creds, UserConfig(
322 name=self.guid + '-user2', password=self.guid,
323 roles={'admin': self.project_settings.name},
324 domain_name=self.os_creds.user_domain_name))
325 self.project_creator.assoc_user(user_creator_2.create())
326 self.user_creators.append(user_creator_2)
329 for user_creator in self.user_creators:
331 sec_grp_os_creds = user_creator.get_os_creds(
332 self.project_creator.get_project().name)
334 sec_grp_creator = OpenStackSecurityGroup(
337 name=self.guid + '-name', description='hello group'))
338 sec_grp = sec_grp_creator.create()
339 self.assertIsNotNone(sec_grp)
340 self.sec_grp_creators.append(sec_grp_creator)
342 self.assertEqual(self.project_creator.get_project().id,
346 def validate_project(keystone, project_settings, project):
348 Validates that the project_settings used to create the project have been
350 :param keystone: the keystone client for version checking
351 :param project_settings: the settings used to create the project
352 :param project: the SNAPS-OO Project domain object
355 if keystone.version == keystone_utils.V2_VERSION_STR:
356 return project_settings.name == project.name
358 domain = keystone_utils.get_domain_by_id(keystone, project.domain_id)
359 return (project_settings.name == project.name and
360 project_settings.domain_name == domain.name)