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 heatclient.exc import HTTPBadRequest
19 from snaps import file_utils
20 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
21 from snaps.openstack.create_image import OpenStackImage
24 from urllib.request import URLError
26 from urllib2 import URLError
32 from snaps.openstack import create_stack
33 from snaps.openstack.create_stack import (
34 StackSettings, StackSettingsError, StackCreationError)
35 from snaps.openstack.tests import openstack_tests, create_instance_tests
36 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
37 from snaps.openstack.utils import heat_utils, neutron_utils, nova_utils
39 __author__ = 'spisarski'
41 logger = logging.getLogger('create_stack_tests')
44 class StackSettingsUnitTests(unittest.TestCase):
46 Tests the construction of the StackSettings class
49 def test_no_params(self):
50 with self.assertRaises(StackSettingsError):
53 def test_empty_config(self):
54 with self.assertRaises(StackSettingsError):
55 StackSettings(**dict())
57 def test_name_only(self):
58 with self.assertRaises(StackSettingsError):
59 StackSettings(name='foo')
61 def test_config_with_name_only(self):
62 with self.assertRaises(StackSettingsError):
63 StackSettings(**{'name': 'foo'})
65 def test_config_minimum_template(self):
66 settings = StackSettings(**{'name': 'stack', 'template': 'foo'})
67 self.assertEqual('stack', settings.name)
68 self.assertEqual('foo', settings.template)
69 self.assertIsNone(settings.template_path)
70 self.assertIsNone(settings.env_values)
71 self.assertEqual(create_stack.STACK_COMPLETE_TIMEOUT,
72 settings.stack_create_timeout)
74 def test_config_minimum_template_path(self):
75 settings = StackSettings(**{'name': 'stack', 'template_path': 'foo'})
76 self.assertEqual('stack', settings.name)
77 self.assertIsNone(settings.template)
78 self.assertEqual('foo', settings.template_path)
79 self.assertIsNone(settings.env_values)
80 self.assertEqual(create_stack.STACK_COMPLETE_TIMEOUT,
81 settings.stack_create_timeout)
83 def test_minimum_template(self):
84 settings = StackSettings(name='stack', template='foo')
85 self.assertEqual('stack', settings.name)
86 self.assertEqual('foo', settings.template)
87 self.assertIsNone(settings.template_path)
88 self.assertIsNone(settings.env_values)
89 self.assertEqual(create_stack.STACK_COMPLETE_TIMEOUT,
90 settings.stack_create_timeout)
92 def test_minimum_template_path(self):
93 settings = StackSettings(name='stack', template_path='foo')
94 self.assertEqual('stack', settings.name)
95 self.assertEqual('foo', settings.template_path)
96 self.assertIsNone(settings.template)
97 self.assertIsNone(settings.env_values)
98 self.assertEqual(create_stack.STACK_COMPLETE_TIMEOUT,
99 settings.stack_create_timeout)
102 env_values = {'foo': 'bar'}
103 settings = StackSettings(name='stack', template='bar',
104 template_path='foo', env_values=env_values,
105 stack_create_timeout=999)
106 self.assertEqual('stack', settings.name)
107 self.assertEqual('bar', settings.template)
108 self.assertEqual('foo', settings.template_path)
109 self.assertEqual(env_values, settings.env_values)
110 self.assertEqual(999, settings.stack_create_timeout)
112 def test_config_all(self):
113 env_values = {'foo': 'bar'}
114 settings = StackSettings(
115 **{'name': 'stack', 'template': 'bar', 'template_path': 'foo',
116 'env_values': env_values, 'stack_create_timeout': 999})
117 self.assertEqual('stack', settings.name)
118 self.assertEqual('bar', settings.template)
119 self.assertEqual('foo', settings.template_path)
120 self.assertEqual(env_values, settings.env_values)
121 self.assertEqual(999, settings.stack_create_timeout)
124 class CreateStackSuccessTests(OSIntegrationTestCase):
126 Tests for the CreateStack class defined in create_stack.py
131 Instantiates the CreateStack object that is responsible for downloading
132 and creating an OS stack file within OpenStack
134 super(self.__class__, self).__start__()
136 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
138 self.heat_creds = self.admin_os_creds
139 self.heat_creds.project_name = self.admin_os_creds.project_name
141 self.heat_cli = heat_utils.heat_client(self.heat_creds)
142 self.stack_creator = None
144 self.image_creator = OpenStackImage(
145 self.heat_creds, openstack_tests.cirros_image_settings(
146 name=self.guid + '-image',
147 image_metadata=self.image_metadata))
148 self.image_creator.create()
151 self.flavor_creator = OpenStackFlavor(
153 FlavorSettings(name=self.guid + '-flavor-name', ram=256, disk=10,
155 self.flavor_creator.create()
157 self.network_name = self.guid + '-net'
158 self.subnet_name = self.guid + '-subnet'
159 self.vm_inst_name = self.guid + '-inst'
162 'image_name': self.image_creator.image_settings.name,
163 'flavor_name': self.flavor_creator.flavor_settings.name,
164 'net_name': self.network_name,
165 'subnet_name': self.subnet_name,
166 'inst_name': self.vm_inst_name}
168 self.heat_tmplt_path = pkg_resources.resource_filename(
169 'snaps.openstack.tests.heat', 'test_heat_template.yaml')
173 Cleans the stack and downloaded stack file
175 if self.stack_creator:
177 self.stack_creator.clean()
181 if self.image_creator:
183 self.image_creator.clean()
187 if self.flavor_creator:
189 self.flavor_creator.clean()
193 super(self.__class__, self).__clean__()
195 def test_create_stack_template_file(self):
197 Tests the creation of an OpenStack stack from Heat template file.
200 # Set the default stack settings, then set any custom parameters sent
202 stack_settings = StackSettings(
203 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
204 template_path=self.heat_tmplt_path,
205 env_values=self.env_values)
206 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
208 created_stack = self.stack_creator.create()
209 self.assertIsNotNone(created_stack)
211 retrieved_stack = heat_utils.get_stack_by_id(self.heat_cli,
213 self.assertIsNotNone(retrieved_stack)
214 self.assertEqual(created_stack.name, retrieved_stack.name)
215 self.assertEqual(created_stack.id, retrieved_stack.id)
216 self.assertEqual(0, len(self.stack_creator.get_outputs()))
218 def test_create_stack_short_timeout(self):
220 Tests the creation of an OpenStack stack from Heat template file.
223 # Set the default stack settings, then set any custom parameters sent
225 stack_settings = StackSettings(
226 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
227 template_path=self.heat_tmplt_path,
228 env_values=self.env_values, stack_create_timeout=0)
230 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
232 with self.assertRaises(StackCreationError):
233 self.stack_creator.create()
235 def test_create_stack_template_dict(self):
237 Tests the creation of an OpenStack stack from a heat dict() object.
240 # Set the default stack settings, then set any custom parameters sent
242 template_dict = heat_utils.parse_heat_template_str(
243 file_utils.read_file(self.heat_tmplt_path))
244 stack_settings = StackSettings(
245 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
246 template=template_dict,
247 env_values=self.env_values)
248 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
250 created_stack = self.stack_creator.create()
251 self.assertIsNotNone(created_stack)
253 retrieved_stack = heat_utils.get_stack_by_id(self.heat_cli,
255 self.assertIsNotNone(retrieved_stack)
256 self.assertEqual(created_stack.name, retrieved_stack.name)
257 self.assertEqual(created_stack.id, retrieved_stack.id)
258 self.assertEqual(0, len(self.stack_creator.get_outputs()))
260 def test_create_delete_stack(self):
262 Tests the creation then deletion of an OpenStack stack to ensure
263 clean() does not raise an Exception.
266 template_dict = heat_utils.parse_heat_template_str(
267 file_utils.read_file(self.heat_tmplt_path))
268 stack_settings = StackSettings(
269 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
270 template=template_dict,
271 env_values=self.env_values)
272 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
274 created_stack = self.stack_creator.create()
275 self.assertIsNotNone(created_stack)
277 retrieved_stack = heat_utils.get_stack_by_id(self.heat_cli,
279 self.assertIsNotNone(retrieved_stack)
280 self.assertEqual(created_stack.name, retrieved_stack.name)
281 self.assertEqual(created_stack.id, retrieved_stack.id)
282 self.assertEqual(0, len(self.stack_creator.get_outputs()))
283 self.assertEqual(create_stack.STATUS_CREATE_COMPLETE,
284 self.stack_creator.get_status())
286 # Delete Stack manually
287 heat_utils.delete_stack(self.heat_cli, created_stack)
289 end_time = time.time() + 90
291 while time.time() < end_time:
292 status = heat_utils.get_stack_status(self.heat_cli,
294 if status == create_stack.STATUS_DELETE_COMPLETE:
298 self.assertTrue(deleted)
300 # Must not throw an exception when attempting to cleanup non-existent
302 self.stack_creator.clean()
303 self.assertIsNone(self.stack_creator.get_stack())
305 def test_create_same_stack(self):
307 Tests the creation of an OpenStack stack when the stack already exists.
310 template_dict = heat_utils.parse_heat_template_str(
311 file_utils.read_file(self.heat_tmplt_path))
312 stack_settings = StackSettings(
313 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
314 template=template_dict,
315 env_values=self.env_values)
316 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
318 created_stack1 = self.stack_creator.create()
320 retrieved_stack = heat_utils.get_stack_by_id(self.heat_cli,
322 self.assertIsNotNone(retrieved_stack)
323 self.assertEqual(created_stack1.name, retrieved_stack.name)
324 self.assertEqual(created_stack1.id, retrieved_stack.id)
325 self.assertEqual(0, len(self.stack_creator.get_outputs()))
327 # Should be retrieving the instance data
328 stack_creator2 = create_stack.OpenStackHeatStack(self.heat_creds,
330 stack2 = stack_creator2.create()
331 self.assertEqual(created_stack1.id, stack2.id)
333 def test_retrieve_network_creators(self):
335 Tests the creation of an OpenStack stack from Heat template file and
336 the retrieval of the network creator.
338 stack_settings = StackSettings(
339 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
340 template_path=self.heat_tmplt_path,
341 env_values=self.env_values)
342 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
344 created_stack = self.stack_creator.create()
345 self.assertIsNotNone(created_stack)
347 net_creators = self.stack_creator.get_network_creators()
348 self.assertIsNotNone(net_creators)
349 self.assertEqual(1, len(net_creators))
350 self.assertEqual(self.network_name, net_creators[0].get_network().name)
352 neutron = neutron_utils.neutron_client(self.os_creds)
353 net_by_name = neutron_utils.get_network(
354 neutron, network_name=net_creators[0].get_network().name)
355 self.assertEqual(net_creators[0].get_network(), net_by_name)
356 self.assertIsNotNone(neutron_utils.get_network_by_id(
357 neutron, net_creators[0].get_network().id))
359 self.assertEqual(1, len(net_creators[0].get_subnets()))
360 subnet = net_creators[0].get_subnets()[0]
361 subnet_by_name = neutron_utils.get_subnet(
362 neutron, subnet_name=subnet.name)
363 self.assertEqual(subnet, subnet_by_name)
365 subnet_by_id = neutron_utils.get_subnet_by_id(neutron, subnet.id)
366 self.assertIsNotNone(subnet_by_id)
367 self.assertEqual(subnet_by_name, subnet_by_id)
369 def test_retrieve_vm_inst_creators(self):
371 Tests the creation of an OpenStack stack from Heat template file and
372 the retrieval of the network creator.
374 stack_settings = StackSettings(
375 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
376 template_path=self.heat_tmplt_path,
377 env_values=self.env_values)
378 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
380 created_stack = self.stack_creator.create()
381 self.assertIsNotNone(created_stack)
383 vm_inst_creators = self.stack_creator.get_vm_inst_creators()
384 self.assertIsNotNone(vm_inst_creators)
385 self.assertEqual(1, len(vm_inst_creators))
386 self.assertEqual(self.vm_inst_name,
387 vm_inst_creators[0].get_vm_inst().name)
389 nova = nova_utils.nova_client(self.admin_os_creds)
390 vm_inst_by_name = nova_utils.get_server(
391 nova, server_name=vm_inst_creators[0].get_vm_inst().name)
392 self.assertEqual(vm_inst_creators[0].get_vm_inst(), vm_inst_by_name)
393 self.assertIsNotNone(nova_utils.get_server_object_by_id(
394 nova, vm_inst_creators[0].get_vm_inst().id))
397 class CreateStackFloatingIpTests(OSIntegrationTestCase):
399 Tests for the CreateStack class defined in create_stack.py
404 Instantiates the CreateStack object that is responsible for downloading
405 and creating an OS stack file within OpenStack
407 super(self.__class__, self).__start__()
409 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
411 self.heat_creds = self.admin_os_creds
412 self.heat_creds.project_name = self.admin_os_creds.project_name
414 self.heat_cli = heat_utils.heat_client(self.heat_creds)
415 self.stack_creator = None
417 self.image_creator = OpenStackImage(
418 self.heat_creds, openstack_tests.cirros_image_settings(
419 name=self.guid + '-image',
420 image_metadata=self.image_metadata))
421 self.image_creator.create()
423 self.network_name = self.guid + '-net'
424 self.subnet_name = self.guid + '-subnet'
425 self.flavor1_name = self.guid + '-flavor1'
426 self.flavor2_name = self.guid + '-flavor2'
427 self.sec_grp_name = self.guid + '-sec_grp'
428 self.vm_inst1_name = self.guid + '-inst1'
429 self.vm_inst2_name = self.guid + '-inst2'
430 self.keypair_name = self.guid + '-kp'
433 'image1_name': self.image_creator.image_settings.name,
434 'image2_name': self.image_creator.image_settings.name,
435 'flavor1_name': self.flavor1_name,
436 'flavor2_name': self.flavor2_name,
437 'net_name': self.network_name,
438 'subnet_name': self.subnet_name,
439 'inst1_name': self.vm_inst1_name,
440 'inst2_name': self.vm_inst2_name,
441 'keypair_name': self.keypair_name,
442 'external_net_name': self.ext_net_name,
443 'security_group_name': self.sec_grp_name}
445 self.heat_tmplt_path = pkg_resources.resource_filename(
446 'snaps.openstack.tests.heat', 'floating_ip_heat_template.yaml')
450 Cleans the stack and downloaded stack file
452 if self.stack_creator:
454 self.stack_creator.clean()
458 if self.image_creator:
460 self.image_creator.clean()
464 super(self.__class__, self).__clean__()
466 def test_connect_via_ssh_heat_vm(self):
468 Tests the creation of an OpenStack stack from Heat template file and
469 the retrieval of two VM instance creators and attempt to connect via
470 SSH to the first one with a floating IP.
472 stack_settings = StackSettings(
473 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
474 template_path=self.heat_tmplt_path,
475 env_values=self.env_values)
476 self.stack_creator = create_stack.OpenStackHeatStack(
477 self.heat_creds, stack_settings,
478 [self.image_creator.image_settings])
479 created_stack = self.stack_creator.create()
480 self.assertIsNotNone(created_stack)
482 vm_inst_creators = self.stack_creator.get_vm_inst_creators(
483 heat_keypair_option='private_key')
484 self.assertIsNotNone(vm_inst_creators)
485 self.assertEqual(2, len(vm_inst_creators))
487 for vm_inst_creator in vm_inst_creators:
488 if vm_inst_creator.get_vm_inst().name == self.vm_inst1_name:
490 create_instance_tests.validate_ssh_client(vm_inst_creator))
492 vm_settings = vm_inst_creator.instance_settings
493 self.assertEqual(0, len(vm_settings.floating_ip_settings))
496 class CreateStackVolumeTests(OSIntegrationTestCase):
498 Tests for the CreateStack class as they pertain to volumes
503 Instantiates the CreateStack object that is responsible for downloading
504 and creating an OS stack file within OpenStack
506 super(self.__class__, self).__start__()
508 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
510 self.heat_creds = self.admin_os_creds
511 self.heat_creds.project_name = self.admin_os_creds.project_name
513 self.heat_cli = heat_utils.heat_client(self.heat_creds)
514 self.stack_creator = None
516 self.volume_name = self.guid + '-volume'
517 self.volume_type_name = self.guid + '-volume-type'
520 'volume_name': self.volume_name,
521 'volume_type_name': self.volume_type_name}
523 self.heat_tmplt_path = pkg_resources.resource_filename(
524 'snaps.openstack.tests.heat', 'volume_heat_template.yaml')
526 stack_settings = StackSettings(
527 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
528 template_path=self.heat_tmplt_path,
529 env_values=self.env_values)
530 self.stack_creator = create_stack.OpenStackHeatStack(
531 self.heat_creds, stack_settings)
532 self.created_stack = self.stack_creator.create()
533 self.assertIsNotNone(self.created_stack)
537 Cleans the stack and downloaded stack file
539 if self.stack_creator:
541 self.stack_creator.clean()
545 super(self.__class__, self).__clean__()
547 def test_retrieve_volume_creator(self):
549 Tests the creation of an OpenStack stack from Heat template file and
550 the retrieval of an OpenStackVolume creator/state machine instance
552 volume_creators = self.stack_creator.get_volume_creators()
553 self.assertEqual(1, len(volume_creators))
555 creator = volume_creators[0]
556 self.assertEqual(self.volume_name, creator.volume_settings.name)
557 self.assertEqual(self.volume_name, creator.get_volume().name)
558 self.assertEqual(self.volume_type_name,
559 creator.volume_settings.type_name)
560 self.assertEqual(self.volume_type_name, creator.get_volume().type)
561 self.assertEqual(1, creator.volume_settings.size)
562 self.assertEqual(1, creator.get_volume().size)
564 def test_retrieve_volume_type_creator(self):
566 Tests the creation of an OpenStack stack from Heat template file and
567 the retrieval of an OpenStackVolume creator/state machine instance
569 volume_type_creators = self.stack_creator.get_volume_type_creators()
570 self.assertEqual(1, len(volume_type_creators))
572 creator = volume_type_creators[0]
573 self.assertIsNotNone(creator)
575 volume_type = creator.get_volume_type()
576 self.assertIsNotNone(volume_type)
578 self.assertEqual(self.volume_type_name, volume_type.name)
579 self.assertTrue(volume_type.public)
580 self.assertIsNone(volume_type.qos_spec)
582 encryption = volume_type.encryption
583 self.assertIsNotNone(encryption)
584 self.assertIsNone(encryption.cipher)
585 self.assertEqual('front-end', encryption.control_location)
586 self.assertIsNone(encryption.key_size)
587 self.assertEqual(u'nova.volume.encryptors.luks.LuksEncryptor',
589 self.assertEqual(volume_type.id, encryption.volume_type_id)
592 class CreateStackFlavorTests(OSIntegrationTestCase):
594 Tests for the CreateStack class defined in create_stack.py
599 Instantiates the CreateStack object that is responsible for downloading
600 and creating an OS stack file within OpenStack
602 super(self.__class__, self).__start__()
604 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
606 self.heat_creds = self.admin_os_creds
607 self.heat_creds.project_name = self.admin_os_creds.project_name
609 self.heat_cli = heat_utils.heat_client(self.heat_creds)
610 self.stack_creator = None
612 self.heat_tmplt_path = pkg_resources.resource_filename(
613 'snaps.openstack.tests.heat', 'flavor_heat_template.yaml')
615 stack_settings = StackSettings(
616 name=self.guid + '-stack',
617 template_path=self.heat_tmplt_path)
618 self.stack_creator = create_stack.OpenStackHeatStack(
619 self.heat_creds, stack_settings)
620 self.created_stack = self.stack_creator.create()
621 self.assertIsNotNone(self.created_stack)
625 Cleans the stack and downloaded stack file
627 if self.stack_creator:
629 self.stack_creator.clean()
633 super(self.__class__, self).__clean__()
635 def test_retrieve_flavor_creator(self):
637 Tests the creation of an OpenStack stack from Heat template file and
638 the retrieval of an OpenStackVolume creator/state machine instance
640 flavor_creators = self.stack_creator.get_flavor_creators()
641 self.assertEqual(1, len(flavor_creators))
643 creator = flavor_creators[0]
644 self.assertTrue(creator.get_flavor().name.startswith(self.guid))
645 self.assertEqual(1024, creator.get_flavor().ram)
646 self.assertEqual(200, creator.get_flavor().disk)
647 self.assertEqual(8, creator.get_flavor().vcpus)
648 self.assertEqual(0, creator.get_flavor().ephemeral)
649 self.assertIsNone(creator.get_flavor().swap)
650 self.assertEqual(1.0, creator.get_flavor().rxtx_factor)
651 self.assertTrue(creator.get_flavor().is_public)
654 class CreateStackKeypairTests(OSIntegrationTestCase):
656 Tests for the CreateStack class as they pertain to keypairs
661 Instantiates the CreateStack object that is responsible for downloading
662 and creating an OS stack file within OpenStack
664 super(self.__class__, self).__start__()
666 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
668 self.heat_creds = self.admin_os_creds
669 self.heat_creds.project_name = self.admin_os_creds.project_name
671 self.heat_cli = heat_utils.heat_client(self.heat_creds)
672 self.nova = nova_utils.nova_client(self.heat_creds)
673 self.stack_creator = None
675 self.keypair_name = self.guid + '-kp'
678 'keypair_name': self.keypair_name}
680 self.heat_tmplt_path = pkg_resources.resource_filename(
681 'snaps.openstack.tests.heat', 'keypair_heat_template.yaml')
683 stack_settings = StackSettings(
684 name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
685 template_path=self.heat_tmplt_path,
686 env_values=self.env_values)
687 self.stack_creator = create_stack.OpenStackHeatStack(
688 self.heat_creds, stack_settings)
689 self.created_stack = self.stack_creator.create()
690 self.assertIsNotNone(self.created_stack)
694 Cleans the stack and downloaded stack file
696 if self.stack_creator:
698 self.stack_creator.clean()
702 super(self.__class__, self).__clean__()
704 def test_retrieve_keypair_creator(self):
706 Tests the creation of an OpenStack stack from Heat template file and
707 the retrieval of an OpenStackKeypair creator/state machine instance
709 kp_creators = self.stack_creator.get_keypair_creators('private_key')
710 self.assertEqual(1, len(kp_creators))
712 creator = kp_creators[0]
714 self.assertEqual(self.keypair_name, creator.get_keypair().name)
715 self.assertIsNotNone(creator.keypair_settings.private_filepath)
717 private_file_contents = file_utils.read_file(
718 creator.keypair_settings.private_filepath)
719 self.assertTrue(private_file_contents.startswith(
720 '-----BEGIN RSA PRIVATE KEY-----'))
722 keypair = nova_utils.get_keypair_by_id(
723 self.nova, creator.get_keypair().id)
724 self.assertIsNotNone(keypair)
725 self.assertEqual(creator.get_keypair(), keypair)
728 class CreateStackNegativeTests(OSIntegrationTestCase):
730 Negative test cases for the CreateStack class
734 super(self.__class__, self).__start__()
736 self.heat_creds = self.admin_os_creds
737 self.heat_creds.project_name = self.admin_os_creds.project_name
739 self.stack_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
740 self.stack_creator = None
741 self.heat_tmplt_path = pkg_resources.resource_filename(
742 'snaps.openstack.tests.heat', 'test_heat_template.yaml')
745 if self.stack_creator:
746 self.stack_creator.clean()
747 super(self.__class__, self).__clean__()
749 def test_missing_dependencies(self):
751 Expect an StackCreationError when the stack file does not exist
753 stack_settings = StackSettings(name=self.stack_name,
754 template_path=self.heat_tmplt_path)
755 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
757 with self.assertRaises(HTTPBadRequest):
758 self.stack_creator.create()
760 def test_bad_stack_file(self):
762 Expect an StackCreationError when the stack file does not exist
764 stack_settings = StackSettings(name=self.stack_name,
766 self.stack_creator = create_stack.OpenStackHeatStack(self.heat_creds,
768 with self.assertRaises(IOError):
769 self.stack_creator.create()