def test_543351_HeatStackUpdateReplace(self):
""" This test case checks change stack id after stack update.
Steps:
1. Create stack using template.
2. Check id of created image.
3. Update stack template:
disk_format = 'ami',
container_format = 'ami'
4. Update stack.
5. Check id of updated image.
"""
stack_name = "image_stack"
template_name = "cirros_image_tmpl.yaml"
template_path = os.path.join(self.templates_dir, template_name)
try:
create_template = common_functions.read_template(self.templates_dir, template_name)
sid = common_functions.create_stack(self.heat, stack_name, create_template)
self.uid_list.append(sid)
first_resource_id = common_functions.get_resource_id(self.heat, sid)
format_change = {"disk_format": "ami", "container_format": "ami"}
common_functions.update_template_file(template_path, "format", **format_change)
update_template = common_functions.read_template(self.templates_dir, template_name)
common_functions.update_stack(self.heat, sid, update_template)
second_resource_id = common_functions.get_resource_id(self.heat, sid)
self.assertNotEqual(
first_resource_id, second_resource_id, msg="Resource id should be changed" " after modifying stack"
)
finally:
back_format_change = {"disk_format": "qcow2", "container_format": "bare"}
common_functions.update_template_file(template_path, "format", **back_format_change)
def test_543352_HeatStackUpdateInPlace(self):
""" This test case checks stack id doesn't change after stack update.
Steps:
1. Create stack using template nova_server.yaml.
2. Check id of created image.
3. Update stack template: flavor = 'm1.small'
4. Update stack.
5. Check id of updated image.
"""
stack_name = "vm_stack"
template_name = "nova_server.yaml"
template_path = os.path.join(self.templates_dir, template_name)
try:
networks = self.neutron.list_networks()
if len(networks["networks"]) < 2:
raise AssertionError("ERROR: Need to have at least 2 networks")
internal_network_id = networks["networks"][1]["id"]
create_template = common_functions.read_template(self.templates_dir, template_name)
parameters = {"network": internal_network_id}
sid = common_functions.create_stack(self.heat, stack_name, create_template, parameters)
first_resource_id = common_functions.get_specific_resource_id(self.heat, sid, "vm")
flavor_change = {"flavor": "m1.small"}
common_functions.update_template_file(template_path, "flavor", **flavor_change)
update_template = common_functions.read_template(self.templates_dir, template_name)
common_functions.update_stack(self.heat, sid, update_template, parameters)
second_resource_id = common_functions.get_specific_resource_id(self.heat, sid, "vm")
self.assertEqual(
first_resource_id, second_resource_id, msg="Resource id should not be changed" " after modifying stack"
)
finally:
common_functions.delete_stack(self.heat, sid)
back_flavor_change = {"flavor": "m1.tiny"}
common_functions.update_template_file(template_path, "flavor", **back_flavor_change)
def test_543342_ShowInfoOfSpecifiedStackEvent(self):
""" This test checks info about stack event
Steps:
1. Create new stack
2. Launch heat event-list stack_name
3. Launch heat event-show <NAME or ID> <RESOURCE> <EVENT> \
for specified event and check result
"""
stack_name = "stack_to_show_event_info_543342"
template_content = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
stack_id = common_functions.create_stack(self.heat, stack_name, template_content, {"param": 123})
self.uid_list.append(stack_id)
stack_status = self.heat.stacks.get(stack_id).to_dict()["stack_status"]
even_list = self.heat.events.list(stack_id)
self.assertTrue(even_list, "NOK, event list is empty")
event_to_show = even_list[-1]
resource_name, event_id = event_to_show.resource_name, event_to_show.id
event_info = self.heat.events.get(stack_id, resource_name, event_id)
self.assertEqual(
event_info.resource_name,
stack_name,
"Expected resource name: {0}, actual: {1}".format(event_info.resource_name, stack_id),
)
self.assertEqual(
event_info.resource_status,
stack_status,
"Expected resource status: {0}, actual: {1}".format(event_info.resource_status, stack_status),
)
common_functions.delete_stack(self.heat, stack_id)
def test_543353_HeatStackOutputShow(self):
""" This test case checks value of specific attribute
as well as list of all stack attributes.
Steps:
1. Create stack using template.
2. Check value of attribute random_str1.
3. Check list of all stack outputs (value, key and description)
"""
stack_name = "random_str_stack"
template_name = "random_str.yaml"
create_template = common_functions.read_template(self.templates_dir, template_name)
sid = common_functions.create_stack(self.heat, stack_name, create_template)
self.uid_list.append(sid)
data = self.heat.stacks.get(stack_id=sid)
outputs = data.to_dict()["outputs"]
output_value = [item["output_value"] for item in outputs if item["output_key"] == "random_str1"]
for item in output_value:
self.assertIsNotNone(re.match("^[a-zA-Z0-9]{32}$", item))
correct_attributes = [
{"output_key": "random_str1", "description": "The random string generated by" " resource random_str1"},
{"output_key": "random_str2", "description": "The random string generated by" " resource random_str2"},
]
stack_attributes = [{k: item[k] for k in item.keys() if k != "output_value"} for item in outputs]
self.assertEqual(stack_attributes, correct_attributes)
def test_543340_StackResumeSuspend(self):
""" Suspend and resume stack
(with its resources for which that feature works)
Steps:
1. Create new stack
2. Launch heat action-suspend stack_name. Check status
3. Launch heat action-resume stack_name. Check status
"""
# Create stack with resource
stack_name = "stack_to_suspend_resume_543340"
template_content = common_functions.read_template(self.templates_dir, "resource_group_template.yaml")
stack_id = common_functions.create_stack(self.heat, stack_name, template_content)
self.uid_list.append(stack_id)
# Suspend stack, check statuses of stack and its resources
self.heat.actions.suspend(stack_id)
timeout = time.time() + 60
while True:
status = self.heat.stacks.get(stack_id).to_dict()["stack_status"]
if status == "SUSPEND_COMPLETE":
break
elif time.time() > timeout:
raise AssertionError("Unable to find stack in 'SUSPEND_COMPLETE' state")
else:
time.sleep(1)
res = self.heat.resources.list(stack_id)
res_states = {r.resource_name: r.resource_status for r in res}
for name, status in res_states.items():
self.assertEqual(
status,
"SUSPEND_COMPLETE",
"Resource '{0}' has '{1}' " "status instead of 'SUSPEND_COMPLETE'".format(name, status),
)
# Resume stack, check statuses of stack and its resources
self.heat.actions.resume(stack_id)
timeout = time.time() + 60
while True:
status = self.heat.stacks.get(stack_id).to_dict()["stack_status"]
if status == "RESUME_COMPLETE":
break
elif time.time() > timeout:
raise AssertionError("Unable to find stack in 'RESUME_COMPLETE' state")
else:
time.sleep(1)
res = self.heat.resources.list(stack_id)
res_states = {r.resource_name: r.resource_status for r in res}
for name, status in res_states.items():
self.assertEqual(
status,
"RESUME_COMPLETE",
"Resource '{0}' has '{1}' " "status instead of 'RESUME_COMPLETE'".format(name, status),
)
def test_543336_HeatStackShow(self):
""" This test case checks detailed stack's information.
Steps:
1. Create stack using template file empty_heat_templ.yaml
2. Check that the stack is in the list of stacks
3. Check that stack status is 'CREATE_COMPLETE'
4. Check stack's information
5. Delete stack
"""
stack_name = "empty__543336"
parameter = "some_param_string"
timeout = 20
if common_functions.is_stack_exists(stack_name, self.heat):
uid = common_functions.get_stack_id(self.heat, stack_name)
common_functions.delete_stack(self.heat, uid)
template = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
uid = common_functions.create_stack(
self.heat, stack_name, template, timeout=timeout, parameters={"param": parameter}
)
self.uid_list.append(uid)
parameters = {
"OS::project_id": self.keystone.auth_tenant_id,
"OS::stack_id": uid,
"OS::stack_name": stack_name,
"param": parameter,
}
correct_data = {
"description": "Sample template",
"stack_name": stack_name,
"disable_rollback": True,
"template_description": "Sample template",
"timeout_mins": timeout,
"stack_status": "CREATE_COMPLETE",
"id": uid,
"stack_status_reason": "Stack CREATE completed " "successfully",
"parameters": parameters,
}
output = self.heat.stacks.get(uid)
show_data = {
"description": output.description,
"stack_name": output.stack_name,
"disable_rollback": output.disable_rollback,
"template_description": output.template_description,
"timeout_mins": output.timeout_mins,
"stack_status": output.stack_status,
"id": output.id,
"stack_status_reason": output.stack_status_reason,
"parameters": output.parameters,
}
self.assertDictEqual(show_data, correct_data)
self.assertEqual(len(output.links), 1)
self.assertEqual(len(output.links[0]), 2)
self.assertNotEqual(output.links[0]["href"].find(stack_name), -1)
self.assertEqual(output.links[0]["rel"], "self")
def test_543343_HeatStackTemplateValidate(self):
""" This test case checks representation of template file.
Steps:
1. Check that selected template file has correct \
representation.
"""
template_content = common_functions.read_template(self.templates_dir, "heat_create_nova_stack_template.yaml")
template_data = {"template": template_content}
result = self.heat.stacks.validate(**template_data)
self.assertIsInstance(result, dict)
def test_543341_ShowStackEventList(self):
""" This test checks list events for a stack
Steps:
1. Create new stack
2. Launch heat event-list stack_name
"""
stack_name = "stack_to_show_event_543341"
template_content = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
stack_id = common_functions.create_stack(self.heat, stack_name, template_content, {"param": "just text"})
self.uid_list.append(stack_id)
event_list = self.heat.events.list(stack_id)
self.assertTrue(event_list, "NOK, event list is empty")
resources = [event.resource_name for event in event_list]
self.assertIn(stack_name, resources, "Event list doesn't contain at least one event for {0}".format(stack_name))
def test_543338_StackCancelUpdate(self):
""" This test check the possibility to cancel update
Steps:
1. Create new stack
2. Launch heat action-suspend stack_name
3. Launch heat stack-update stack_name
4. Launch heat stack-cancel-update stack_name while update
operation is in progress
5. Check state of stack after cancel update
"""
# network ID, image ID, InstanceType
networks = self.neutron.list_networks()["networks"]
internal_net = [net["id"] for net in networks if not net["router:external"]][0]
image_id = self.nova.images.list()[0].id
instance_type = "m1.tiny"
# Stack creation
stack_name = "stack_to_cancel_update_543338"
template_content = common_functions.read_template(self.templates_dir, "heat_create_neutron_stack_template.yaml")
initial_params = {"network": internal_net, "ImageId": image_id, "InstanceType": instance_type}
stack_id = common_functions.create_stack(self.heat, stack_name, template_content, initial_params)
self.uid_list.append(stack_id)
# Stack update (from m1.tiny to m1.small)
upd_params = {"network": internal_net, "ImageId": image_id, "InstanceType": "m1.small"}
d_updated = {"stack_name": stack_name, "template": template_content, "parameters": upd_params}
self.heat.stacks.update(stack_id, **d_updated)
# Perform cancel-update operation
# when stack status is 'UPDATE_IN_PROGRESS'
timeout = time.time() + 60
while True:
status = self.heat.stacks.get(stack_id).to_dict()["stack_status"]
if status == "UPDATE_IN_PROGRESS":
self.heat.actions.cancel_update(stack_id)
break
elif time.time() > timeout:
raise AttributeError(
"Unable to find stack in 'UPDATE_IN_PROGRESS' state. "
"Status '{0}' doesn't allow to perform cancel-update".format(status)
)
else:
time.sleep(1)
# Wait for rollback competed and check
self.assertTrue(common_functions.check_stack_status(stack_name, self.heat, "ROLLBACK_COMPLETE", 120))
def test_543353_HeatStackOutputList(self):
""" This test case checks list of all stack attributes.
Steps:
1. Create stack using template.
2. Check list of all attributes in format:
output_key - description.
"""
stack_name = "random_str_stack"
template_name = "random_str.yaml"
create_template = common_functions.read_template(self.templates_dir, template_name)
sid = common_functions.create_stack(self.heat, stack_name, create_template)
self.uid_list.append(sid)
correct_attributes = [
{"output_key": "random_str1", "description": "The random string generated by" " resource random_str1"},
{"output_key": "random_str2", "description": "The random string generated by" " resource random_str2"},
]
data = self.heat.stacks.get(stack_id=sid)
outputs = data.to_dict()["outputs"]
stack_attributes = [{k: item[k] for k in ("output_key", "description")} for item in outputs]
self.assertEqual(stack_attributes, correct_attributes)
def test_543332_HeatStackPreview(self):
""" This test case previews a stack.
Steps:
1. Execute stack preview.
2. Check output result.
"""
stack_name = "empty__543332"
parameter = "some_param_string"
parameters = {
"OS::project_id": self.keystone.auth_tenant_id,
"OS::stack_id": "None",
"OS::stack_name": stack_name,
"param": parameter,
}
correct_data = {
"description": "Sample template",
"stack_name": stack_name,
"disable_rollback": True,
"template_description": "Sample template",
"parameters": parameters,
}
if common_functions.is_stack_exists(stack_name, self.heat):
uid = common_functions.get_stack_id(self.heat, stack_name)
common_functions.delete_stack(self.heat, uid)
template = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
stack_data = {"stack_name": stack_name, "template": template, "parameters": {"param": parameter}}
output = self.heat.stacks.preview(**stack_data)
preview_data = {
"description": output.description,
"stack_name": output.stack_name,
"disable_rollback": output.disable_rollback,
"template_description": output.template_description,
"parameters": output.parameters,
}
self.assertDictEqual(preview_data, correct_data)
self.assertEqual(len(output.links), 1)
self.assertEqual(len(output.links[0]), 2)
self.assertNotEqual(output.links[0]["href"].find(stack_name), -1)
self.assertEqual(output.links[0]["rel"], "self")
def test_543339_CheckStackResourcesStatuses(self):
""" This test case checks that stack resources are in expected states
Steps:
1. Create new stack
2. Launch heat action-check stack_name
3. Launch heat stack-list and check 'CHECK_COMPLETE' status
"""
stack_name = "stack_to_check_543339"
template_content = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
stack_id = common_functions.create_stack(self.heat, stack_name, template_content, {"param": "just text"})
self.uid_list.append(stack_id)
self.heat.actions.check(stack_id)
timeout = time.time() + 10
while True:
stack_dict = {s.stack_name: s.id for s in self.heat.stacks.list() if s.stack_status == "CHECK_COMPLETE"}
if stack_name in stack_dict.keys():
break
elif time.time() > timeout:
raise AssertionError("Stack {0} is not in CHECK_COMPLETE state".format(stack_name))
else:
time.sleep(1)
self.assertIn(stack_name, stack_dict, "Stack {0} is not in CHECK_COMPLETE state".format(stack_name))
def test_543333_HeatStackCreateWithTemplate(self):
""" This test case checks creation of stack.
Steps:
1. Create stack using template file empty_heat_templ.yaml.
2. Check that the stack is in the list of stacks
3. Check that stack status is 'CREATE_COMPLETE'
4. Delete stack
"""
stack_name = "empty__543333"
parameter = "some_param_string"
timeout = 20
if common_functions.is_stack_exists(stack_name, self.heat):
uid = common_functions.get_stack_id(self.heat, stack_name)
common_functions.delete_stack(self.heat, uid)
template = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
uid = common_functions.create_stack(
self.heat, stack_name, template, timeout=timeout, parameters={"param": parameter}
)
self.uid_list.append(uid)
stacks_id = [s.id for s in self.heat.stacks.list()]
self.assertIn(uid, stacks_id)
self.assertTrue(common_functions.check_stack_status(stack_name, self.heat, "CREATE_COMPLETE", timeout))
def test_543337_HeatStackUpdate(self):
""" This test case checks stack-update action.
Steps:
1. Create stack using template file empty_heat_templ.yaml
2. Update stack parameter
"""
stack_name = "empty_543337"
template_content = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
stack_id = common_functions.create_stack(self.heat, stack_name, template_content, {"param": "string"})
self.uid_list.append(stack_id)
d_updated = {"stack_name": stack_name, "template": template_content, "parameters": {"param": "string2"}}
self.heat.stacks.update(stack_id, **d_updated)
timeout = time.time() + 10
while True:
stack_dict_upd = {
s.stack_name: s.id for s in self.heat.stacks.list() if s.stack_status == "UPDATE_COMPLETE"
}
if stack_name in stack_dict_upd.keys():
break
elif time.time() > timeout:
raise AssertionError("Unable to find stack 'empty' in " "'UPDATE_COMPLETE' state")
else:
time.sleep(1)
def test_543335_HeatStackDelete(self):
""" This test case checks deletion of stack.
Steps:
1. Create stack using template file empty_heat_templ.yaml.
2. Check that the stack is in the list of stacks
3. Delete the stack.
4. Check that the stack is absent in the list of stacks
"""
stack_name = "empty_543335"
timeout = 20
parameter = "some_param_string"
if common_functions.is_stack_exists(stack_name, self.heat):
uid = common_functions.get_stack_id(self.heat, stack_name)
common_functions.delete_stack(self.heat, uid)
template = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
uid = common_functions.create_stack(
self.heat, stack_name, template, timeout=timeout, parameters={"param": parameter}
)
self.assertTrue(common_functions.check_stack_status(stack_name, self.heat, "CREATE_COMPLETE", timeout))
common_functions.delete_stack(self.heat, uid)
stacks = [s.stack_name for s in self.heat.stacks.list()]
self.assertNotIn(stack_name, stacks)
def test_543344_HeatStackTemplateShow(self):
""" This test case checks representation of template of created stack.
Steps:
1. Create stack using template file empty_heat_templ.yaml.
2. Check that template of created stack has correct \
representation.
"""
stack_name = "empty_stack"
timeout = 60
parameter = "some_string"
if common_functions.is_stack_exists(stack_name, self.heat):
uid = common_functions.get_stack_id(self.heat, stack_name)
common_functions.delete_stack(self.heat, uid)
template = common_functions.read_template(self.templates_dir, "empty_heat_templ.yaml")
uid = common_functions.create_stack(
self.heat, stack_name, template, timeout=timeout, parameters={"param": parameter}
)
self.uid_list.append(uid)
self.assertTrue(common_functions.check_stack_status(stack_name, self.heat, "CREATE_COMPLETE"))
stack_dict = {s.stack_name: s.id for s in self.heat.stacks.list()}
stack_id = stack_dict[stack_name]
stack_template = self.heat.stacks.template(stack_id)
self.assertIsInstance(stack_template, dict)
def test_543349_HeatCreateStackNeutronResources(self):
""" This test creates stack with Neutron resources
Steps:
1. Download Cirros image
2. Create image with Glance and check that it is 'Active'
3. Create new key-pair with Nova
4. Find ID of internal network with Neutron
5. Find ID of internal sub network with Neutron
6. Find ID of public network with Neutron
7. Create stack with Neutron resources and check that it was \
created successfully
8. CleanUp
https://mirantis.testrail.com/index.php?/cases/view/543349
"""
file_name = "cirros-0.3.4-x86_64-disk.img.txt"
image_name = "543349_Cirros-image" + "_" + str(randint(100, 10000))
# Prepare full path to image file. Return e.g.:
# Like: /root/mos_tests/heat/images/cirros-0.3.4-x86_64-disk.img.txt
image_link_location = os.path.join(self.images_dir, file_name)
# Download image on node. Like: /tmp/cirros-0.3.4-x86_64-disk.img
image_path = common_functions.download_image(image_link_location)
# Create image in Glance
image = self.glance.images.create(
name=image_name, os_distro="Cirros", disk_format="qcow2", visibility="public", container_format="bare"
)
# Check that status is 'queued'
if image.status != "queued":
raise AssertionError(
"ERROR: Image status after creation is:" "[{0}]. " "Expected [queued]".format(image.status)
)
# Put image-file in created Image
with open(image_path, "rb") as image_content:
self.glance.images.upload(image.id, image_content)
# Check that status of image is 'active'
self.assertEqual(
self.glance.images.get(image.id)["status"],
"active",
"After creation in Glance image status is [{0}]. "
"Expected is [active]".format(self.glance.images.get(image.id)["status"]),
)
# Create new keypair
keypair = self.nova.keypairs.create(name=image_name)
# Get list of networks
networks = self.neutron.list_networks()
# Check if Neutron has more then 1 network. We need intern and extern.
if len(networks["networks"]) < 2:
raise AssertionError("ERROR: Need to have at least 2 networks")
# Find internal network ID if network name contains 'inter'
int_network_id = [x["id"] for x in networks["networks"] if "intern" in x["name"] and x["status"] == "ACTIVE"]
# If can't find 'inter' in networks -> get ID of last network
if not int_network_id:
int_network_id = networks["networks"][-1]["id"]
else:
int_network_id = int_network_id[0]
# Find private subnet ID
int_sub_network_id = [
x["subnets"][0] for x in networks["networks"] if int_network_id in x["id"] and x["status"] == "ACTIVE"
]
int_sub_network_id = int_sub_network_id[0]
# Find public network ID
pub_network_id = [x["id"] for x in networks["networks"] if "float" in x["name"] and x["status"] == "ACTIVE"]
# If can't find 'float' in networks -> get ID of 0 network
if not int_network_id:
pub_network_id = networks["networks"][0]["id"]
else:
pub_network_id = pub_network_id[0]
# Create stack with Heat
template = common_functions.read_template(self.templates_dir, "Heat_Neutron_resources_543349.yaml")
uid = common_functions.create_stack(
self.heat,
"Heat_Neutron_resources_543349",
template,
{
"key_name": image_name,
"image": image_name,
"flavor": "m1.small",
"public_net_id": pub_network_id,
"private_net_id": int_network_id,
"private_subnet_id": int_sub_network_id,
},
15,
)
# CLEANUP
# Delete stack with tearDown:
self.uid_list.append(uid)
# Delete image:
self.glance.images.delete(image.id)
# Delete keypair:
keypair.delete()
def test_543345_HeatCreateStackAWS(self):
""" This test creates stack using AWS format template
Steps:
1. Connect to Neutron and get ID of internal_network
2. Get ID of external_network
3. Get ID of internal_subnet of internal_network
4. Find IP for internal_subnet
5. Create stack
6. Delete stack
https://mirantis.testrail.com/index.php?/cases/view/543345
"""
# Prepare new name. Like: 'Test_1449484927'
new_stack_name = "Test_{0}".format(str(time.time())[0:10:])
# Get networks from Neutron
networks = self.neutron.list_networks()
# Check if Neutron has more then 1 network. We need intern and extern.
if len(networks["networks"]) < 2:
raise AssertionError("ERROR: Need to have at least 2 networks")
# - 1,2,3 -
# Get IDs of networks
network_1_id = networks["networks"][1]["id"]
network_1_subnet = networks["networks"][1]["subnets"][0]
network_2_id = networks["networks"][0]["id"]
# - 4 -
# Get list of occupied IPs in "network_1_id"
neutron_list_ports = self.neutron.list_ports()["ports"]
occupied_ips = [
x["fixed_ips"][0]["ip_address"]
for x in neutron_list_ports
if network_1_subnet in x["fixed_ips"][0]["subnet_id"]
]
# Cut last part of IPs: '192.168.111.3 --> 192.168.111._'
ips_without_last_part = [".".join(x.split(".")[0:-1]) + "." for x in occupied_ips]
# Get unique IP without last part: '192.168.111._'
seen = set()
seen_add = seen.add
ip_no_last_part = [x for x in ips_without_last_part if not (x in seen or seen_add(x))]
ip_no_last_part = ip_no_last_part[0]
# Generate new IP and check that it is free
internal_subnet_ip = ip_no_last_part + str(randint(100, 240))
while internal_subnet_ip in occupied_ips:
internal_subnet_ip = ip_no_last_part + str(randint(100, 240))
# - 5 -
# Prepare parameters
parameters = {
"internal_network": network_1_id,
"internal_subnet": network_1_subnet,
"internal_subnet_ip": internal_subnet_ip,
"external_network": network_2_id,
}
# Read template
template = common_functions.read_template(self.templates_dir, "Heat_template_AWL_543345.yaml")
# Create stack
uid = common_functions.create_stack(self.heat, new_stack_name, template, parameters)
self.uid_list.append(uid)
def test_543350_HeatCreateStackNovaResources(self):
""" This test creates stack with Nova resources
Steps:
1. Download Cirros image
2. Create image with Glance and check that it is 'Active'
3. Create new key-pair with Nova
4. Find network ID
5. Prepare template and reference template
6. Create stack
7. CleanUp
https://mirantis.testrail.com/index.php?/cases/view/543350
"""
file_name = "cirros-0.3.4-x86_64-disk.img.txt"
image_name = "543350_Cirros-image" + "_" + str(randint(100, 10000))
# Prepare full path to image file. Return e.g.:
# Like: /root/mos_tests/heat/images/cirros-0.3.4-x86_64-disk.img.txt
image_link_location = os.path.join(self.images_dir, file_name)
# Download image on node. Like: /tmp/cirros-0.3.4-x86_64-disk.img
image_path = common_functions.download_image(image_link_location)
# Create image in Glance
image = self.glance.images.create(
name=image_name, os_distro="Cirros", disk_format="qcow2", visibility="public", container_format="bare"
)
# Check that status is 'queued'
if image.status != "queued":
raise AssertionError(
"ERROR: Image status after creation is:" "[{0}]. " "Expected [queued]".format(image.status)
)
# Put image-file in created Image
with open(image_path, "rb") as image_content:
self.glance.images.upload(image.id, image_content)
# Check that status of image is 'active'
self.assertEqual(
self.glance.images.get(image.id)["status"],
"active",
"After creation in Glance image status is [{0}]. "
"Expected is [active]".format(self.glance.images.get(image.id)["status"]),
)
# Create new keypair
keypair = self.nova.keypairs.create(name=image_name)
# Get list of networks
networks = self.neutron.list_networks()
# Find internal network ID if network name contains 'inter'
int_network_id = [x["id"] for x in networks["networks"] if "intern" in x["name"] and x["status"] == "ACTIVE"]
# If can't find 'inter' in networks -> get ID of last network
if not int_network_id:
int_network_id = networks["networks"][-1]["id"]
else:
int_network_id = int_network_id[0]
# Read main template for creation
template = common_functions.read_template(self.templates_dir, "Heat_Nova_resources_543350.yaml")
# Read additional reference template for creation
template_additional = common_functions.read_template(
self.templates_dir, "Heat_Nova_resources_543350_volume_with_attachment.yaml"
)
# Create stack
uid = common_functions.create_stack(
self.heat,
"Heat_Nova_resources_543350",
template,
{
"key_name": image_name,
"image_id": image_name,
"volume_size": 1,
"num_volumes": 1,
"flavor": "m1.tiny",
"network_id": int_network_id,
},
15,
{"Heat_Nova_resources_543350" "_volume_with_attachment.yaml": template_additional},
)
# CLEANUP
# Delete stack with tearDown:
self.uid_list.append(uid)
# Delete image:
self.glance.images.delete(image.id)
# Delete keypair:
keypair.delete()
def test_543346_HeatCreateStackDockerResources(self):
""" This test creates stack with Docker resource
Steps:
1. Download custom Fedora image
2. Create image in Glance and check status
3. With Nova create new key-pair
4. Find internal network ID
5. Find name of public network
6. Create stack with Docker host
7. Get public floating IP of Docker host instance
8. Prepare docker endpoint URL
9. Create Docker stack
10. CleanUp
https://mirantis.testrail.com/index.php?/cases/view/543346
"""
# At first we need to check that heat has Docker resources
# but it was already verified in "test_543328_HeatResourceTypeList".
# So nothing to do here.
file_name = "fedora_22-docker-image.qcow2.txt"
image_name = "543346_Fedora-docker" + "_" + str(randint(100, 10000))
# Prepare full path to image file. Return e.g.
# like: /root/mos_tests/heat/images/fedora_22-docker-image.qcow2.txt
image_link_location = os.path.join(self.images_dir, file_name)
# Download image on node. Like: /tmp/fedora-software-config.qcow2
image_path = common_functions.download_image(image_link_location)
# Create image in Glance
image = self.glance.images.create(
name=image_name, os_distro="Fedora", disk_format="qcow2", visibility="public", container_format="bare"
)
# Check that status is 'queued'
if image.status != "queued":
raise AssertionError(
"ERROR: Image status after creation is:" "[{0}]. " "Expected [queued]".format(image.status)
)
# Put image-file in created Image
with open(image_path, "rb") as image_content:
self.glance.images.upload(image.id, image_content)
# Check that status of image is 'active'
self.assertEqual(
self.glance.images.get(image.id)["status"],
"active",
"After creation in Glance image status is [{0}]. "
"Expected is [active]".format(self.glance.images.get(image.id)["status"]),
)
# Create new keypair
keypair = self.nova.keypairs.create(name=image_name)
# Get list of networks
networks = self.neutron.list_networks()
# Find internal network ID if network name contains 'inter'
int_network_id = [x["id"] for x in networks["networks"] if "intern" in x["name"] and x["status"] == "ACTIVE"]
# If can't find 'inter' in networks -> get ID of last network
if not int_network_id:
int_network_id = networks["networks"][-1]["id"]
else:
int_network_id = int_network_id[0]
# Find name of public network
pub_network_name = [
x["name"]
for x in networks["networks"]
if "float" in x["name"] or "public" in x["name"] and x["status"] == "ACTIVE"
]
# If can't find 'float/public' in networks -> get ID of first network
if not pub_network_name:
pub_network_name = pub_network_name["networks"][0]["name"]
else:
pub_network_name = pub_network_name[0]
# Read template for Docker host creation
template = common_functions.read_template(self.templates_dir, "Heat_Docker_Resources_543346_Host.yaml")
# Create stack for Docker host
uid = common_functions.create_stack(
self.heat,
"Heat_Docker_543346_Host",
template,
{
"key": image_name,
"flavor": "m1.small",
"image": image_name,
"public_net": pub_network_name,
"int_network_id": int_network_id,
"timeout": 600,
},
15,
)
# Get resource ID of 'docker_server'. We know this name from template
instance_id = self.heat.resources.get(uid, "docker_server").to_dict()
instance_id = instance_id["physical_resource_id"]
# Get public floating IP of created server instance in stack
floating_ip_list = self.nova.floating_ips.list()
floating_ip = [x.ip for x in floating_ip_list if x.instance_id == instance_id]
floating_ip = floating_ip[0]
# Check that floating IP is not empty
self.assertIsNotNone(floating_ip, "ERROR: Floating IP of Docker host instance is empty")
# Read template for Docker stack creation
template = common_functions.read_template(self.templates_dir, "Heat_Docker_Resources_543346_docker.yaml")
# Before creating new docker stack give a few second too start
# Docker bind in first stack. We have a WaitCondition in it, but
# anyway there may be a need to wait several seconds.
time.sleep(5)
# Prepare docker endpoint. Like: 'tcp://172.16.0.161:2376'
# Where IP is a floating IP of host instance. And port# is in template.
docker_endpoint = "tcp://{0}:2376".format(floating_ip)
# Create Docker stack
docker_uid = common_functions.create_stack(
self.heat, "Heat_Docker_543346_docker", template, {"docker_endpoint": docker_endpoint}, 15
)
# CLEANUP
# First we need to delete second docker stack
common_functions.delete_stack(self.heat, docker_uid)
# Delete host stack with tearDown:
self.uid_list.append(uid)
# Delete image:
self.glance.images.delete(image.id)
# Delete keypair:
keypair.delete()