def test_launch_stack(self):
template = self.stack_templates.first()
stack = self.stacks.first()
self.mock_template_validate.return_value = \
json.loads(template.validate)
self.mock_stack_create.reutrn_value = None
self.mock_network_list_for_tenant.side_effect = \
[self.networks.list(), self.networks.list()]
url = reverse('horizon:project:stacks:select_template')
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/select_template.html')
form_data = {
'template_source': 'raw',
'template_data': template.data,
'referenced_files': {},
'method': forms.TemplateForm.__name__
}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/create.html')
url = reverse('horizon:project:stacks:launch')
form_data = {
'template_source': 'raw',
'template_data': template.data,
'password': '******',
'parameters': template.validate,
'stack_name': stack.stack_name,
"timeout_mins": 60,
"disable_rollback": True,
"__param_DBUsername": "******",
"__param_LinuxDistribution": "F17",
"__param_InstanceType": "m1.small",
"__param_KeyName": "test",
"__param_DBPassword": "******",
"__param_DBRootPassword": "******",
"__param_DBName": "wordpress",
"__param_Network": self.networks.list()[0]['id'],
'method': forms.CreateStackForm.__name__
}
res = self.client.post(url, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
self.mock_template_validate.assert_called_once_with(
test.IsHttpRequest(),
files={},
template=hc_format.parse(template.data))
self.mock_stack_create.assert_called_once_with(
test.IsHttpRequest(),
stack_name=stack.stack_name,
timeout_mins=60,
disable_rollback=True,
template=None,
parameters=test.IsA(dict),
password='******',
files=None)
self.mock_network_list_for_tenant.assert_has_calls([
mock.call(test.IsHttpRequest(), self.tenant.id),
mock.call(test.IsHttpRequest(), self.tenant.id)
])
def test_detail_stack_topology(self):
stack = self.stacks.first()
template = self.stack_templates.first()
self.mock_stack_get.return_value = stack
self.mock_template_get.return_value = \
json.loads(template.validate)
self.mock_resources_list.return_value = []
url = '?'.join([
reverse(DETAIL_URL, args=[stack.id]),
'='.join(['tab', 'stack_details__stack_topology'])
])
res = self.client.get(url)
tab = res.context['tab_group'].get_tab('topology')
d3_data = tab.data['d3_data']
self.assertEqual(tab.template_name,
'project/stacks/_detail_topology.html')
# status is CREATE_COMPLETE, so we expect the topology to display it
self.assertIn('info_box', d3_data)
self.assertIn('stack-green.svg', d3_data)
self.assertIn('Create Complete', d3_data)
self.mock_template_get.assert_called_once_with(test.IsHttpRequest(),
stack.id)
self.mock_resources_list.assert_called_once_with(
test.IsHttpRequest(), stack.stack_name)
def test_index_prev_paginated(self):
stacks = self.stacks.list()[:3]
filters = {}
self.mock_stacks_list.side_effect = [[stacks, True, False],
[stacks[:2], True, True],
[stacks[2:], True, True],
[stacks[:2], True, True]]
url = reverse('horizon:project:stacks:index')
res = self.client.get(url)
# get all
self.assertEqual(len(res.context['stacks_table'].data), len(stacks))
self.assertTemplateUsed(res, INDEX_TEMPLATE)
res = self.client.get(url)
# get first page with 2 items
self.assertEqual(len(res.context['stacks_table'].data),
settings.API_RESULT_PAGE_SIZE)
url = "%s?%s=%s" % (reverse('horizon:project:stacks:index'),
tables.StacksTable._meta.pagination_param,
stacks[2].id)
res = self.client.get(url)
# get second page (item 3)
self.assertEqual(len(res.context['stacks_table'].data), 1)
url = "%s?%s=%s" % (reverse('horizon:project:stacks:index'),
tables.StacksTable._meta.prev_pagination_param,
stacks[2].id)
res = self.client.get(url)
# prev back to get first page with 2 pages
self.assertEqual(len(res.context['stacks_table'].data),
settings.API_RESULT_PAGE_SIZE)
self.mock_stacks_list.assert_has_calls([
mock.call(test.IsHttpRequest(),
marker=None,
paginate=True,
sort_dir='desc',
filters=filters),
mock.call(test.IsHttpRequest(),
marker=None,
paginate=True,
sort_dir='desc',
filters=filters),
mock.call(test.IsHttpRequest(),
marker=stacks[2].id,
paginate=True,
sort_dir='desc',
filters=filters)
])
def test_resource_view(self):
stack = self.stacks.first()
resource = self.heat_resources.first()
metadata = {}
self.mock_resource_get.return_value = resource
self.mock_resource_metadata_get.return_value = metadata
url = reverse('horizon:project:stacks:resource',
args=[stack.id, resource.resource_name])
res = self.client.get(url)
self.assertTemplateUsed(res, 'horizon/common/_detail.html')
self.assertTemplateUsed(res, 'project/stacks/_resource_overview.html')
self.assertEqual(res.context['resource'].logical_resource_id,
resource.logical_resource_id)
self.mock_resource_get.assert_called_once_with(
test.IsHttpRequest(), stack.id, resource.resource_name)
self.mock_resource_get.assert_called_once_with(
test.IsHttpRequest(), stack.id, resource.resource_name)
def test_launch_stack_with_hidden_parameters(self):
template = {
'data': ('heat_template_version: 2013-05-23\n'
'parameters:\n'
' public_string:\n'
' type: string\n'
' secret_string:\n'
' type: string\n'
' hidden: true\n'),
'validate': {
'Description': 'No description',
'Parameters': {
'public_string': {
'Label': 'public_string',
'Description': '',
'Type': 'String',
'NoEcho': 'false'
},
'secret_string': {
'Label': 'secret_string',
'Description': '',
'Type': 'String',
'NoEcho': 'true'
}
}
}
}
self.mock_template_validate.return_value = template['validate']
url = reverse('horizon:project:stacks:select_template')
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/select_template.html')
form_data = {
'template_source': 'raw',
'template_data': template['data'],
'method': forms.TemplateForm.__name__
}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/create.html')
# ensure the fields were rendered correctly
pattern = ('<input class="form-control" '
'id="id___param_public_string" '
'name="__param_public_string" type="text" required/>')
secret = ('<input class="form-control" '
'id="id___param_secret_string" '
'name="__param_secret_string" '
'type="password" required>')
self.assertContains(res, pattern, html=True)
self.assertContains(res, secret, html=True)
self.mock_template_validate.assert_called_once_with(
test.IsHttpRequest(),
files={},
template=hc_format.parse(template['data']))
def test_detail_stack_template(self):
stack = self.stacks.first()
template = self.stack_templates.first()
self.mock_stack_get.return_value = stack
self.mock_template_get.return_value = \
json.loads(template.validate)
url = '?'.join([reverse(DETAIL_URL, args=[stack.id]),
'='.join(['tab', 'stack_details__stack_template'])])
res = self.client.get(url)
tab = res.context['tab_group'].get_tab('stack_template')
template_data = tab.data['stack_template']
self.assertEqual(tab.template_name,
'project/stacks/_stack_template.html')
self.assertIn(json.loads(template.validate)['Description'],
template_data)
self.mock_stack_get.assert_called_once_with(
test.IsHttpRequest(), stack.id)
self.mock_template_get.assert_called_once_with(
test.IsHttpRequest(), stack.id)
def test_preview_stack(self):
template = self.stack_templates.first()
stack = self.stacks.first()
self.mock_template_validate.return_value = \
json.loads(template.validate)
self.mock_stack_preview.return_value = stack
url = reverse('horizon:project:stacks:preview_template')
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/preview_template.html')
form_data = {
'template_source': 'raw',
'template_data': template.data,
'method': forms.PreviewTemplateForm.__name__
}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/preview.html')
url = reverse('horizon:project:stacks:preview')
form_data = {
'template_source': 'raw',
'template_data': template.data,
'parameters': template.validate,
'stack_name': stack.stack_name,
"timeout_mins": 60,
"disable_rollback": True,
"__param_DBUsername": "******",
"__param_LinuxDistribution": "F17",
"__param_InstanceType": "m1.small",
"__param_KeyName": "test",
"__param_DBPassword": "******",
"__param_DBRootPassword": "******",
"__param_DBName": "wordpress",
'method': forms.PreviewStackForm.__name__
}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/preview_details.html')
self.assertEqual(res.context['stack_preview']['stack_name'],
stack.stack_name)
self.mock_template_validate.assert_called_once_with(
test.IsHttpRequest(),
files={},
template=hc_format.parse(template.data))
def test_detail_stack_overview(self):
stack = self.stacks.first()
template = self.stack_templates.first()
self.mock_stack_get.return_value = stack
self.mock_resources_list.return_value = []
self.mock_template_get.return_value = \
json.loads(template.validate)
url = '?'.join([reverse(DETAIL_URL, args=[stack.id]),
'='.join(['tab', 'stack_details__stack_overview'])])
res = self.client.get(url)
tab = res.context['tab_group'].get_tab('overview')
overview_data = tab.data['stack']
self.assertEqual(tab.template_name,
'project/stacks/_detail_overview.html')
self.assertEqual(stack.stack_name, overview_data.stack_name)
self.mock_template_get.assert_called_once_with(
test.IsHttpRequest(), stack.id)
def test_edit_stack_template(self):
template = self.stack_templates.first()
stack = self.stacks.first()
self.mock_stack_get.return_value = stack
self.mock_template_validate.return_value = \
json.loads(template.validate)
self.mock_stack_get.reutrn_value = stack
self.mock_template_get.return_value = \
json.loads(template.validate)
fields = {
'stack_name': stack.stack_name,
'disable_rollback': True,
'timeout_mins': 61,
'password': '******',
'template': None,
'parameters': test.IsA(dict),
'files': None
}
self.mock_stack_update.return_value = None
self.mock_network_list_for_tenant.return_value = \
self.networks.list()
url = reverse('horizon:project:stacks:change_template',
args=[stack.id])
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/change_template.html')
form_data = {
'template_source': 'raw',
'template_data': template.data,
'method': forms.ChangeTemplateForm.__name__
}
res = self.client.post(url, form_data)
url = reverse('horizon:project:stacks:edit_stack', args=[
stack.id,
])
form_data = {
'template_source': 'raw',
'template_data': template.data,
'password': '******',
'parameters': template.validate,
'stack_name': stack.stack_name,
'stack_id': stack.id,
"timeout_mins": 61,
"disable_rollback": True,
"__param_DBUsername": "******",
"__param_LinuxDistribution": "F17",
"__param_InstanceType": "m1.small",
"__param_KeyName": "test",
"__param_DBPassword": "******",
"__param_DBRootPassword": "******",
"__param_DBName": "wordpress",
"__param_Network": self.networks.list()[0]['id'],
'method': forms.EditStackForm.__name__
}
res = self.client.post(url, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
self.mock_template_validate.assert_called_once_with(
test.IsHttpRequest(),
files={},
template=hc_format.parse(template.data))
self.mock_template_get.assert_called_once_with(test.IsHttpRequest(),
stack.id)
self.mock_stack_update.assert_called_once_with(test.IsHttpRequest(),
stack_id=stack.id,
**fields)
self.mock_network_list_for_tenant.assert_called_once_with(
test.IsHttpRequest(), self.tenant.id)
def test_launch_stack_parameter_types(self):
template = {
'data': ('heat_template_version: 2013-05-23\n'
'parameters:\n'
' param1:\n'
' type: string\n'
' param2:\n'
' type: number\n'
' param3:\n'
' type: json\n'
' param4:\n'
' type: comma_delimited_list\n'
' param5:\n'
' type: boolean\n'),
'validate': {
"Description": "No description",
"Parameters": {
"param1": {
"Type": "String",
"NoEcho": "false",
"Description": "",
"Label": "param1"
},
"param2": {
"Type": "Number",
"NoEcho": "false",
"Description": "",
"Label": "param2"
},
"param3": {
"Type": "Json",
"NoEcho": "false",
"Description": "",
"Label": "param3"
},
"param4": {
"Type": "CommaDelimitedList",
"NoEcho": "false",
"Description": "",
"Label": "param4"
},
"param5": {
"Type": "Boolean",
"NoEcho": "false",
"Description": "",
"Label": "param5"
}
}
}
}
stack = self.stacks.first()
self.mock_template_validate.return_value = \
template['validate']
self.mock_stack_create.return_value = None
url = reverse('horizon:project:stacks:select_template')
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/select_template.html')
form_data = {
'template_source': 'raw',
'template_data': template['data'],
'method': forms.TemplateForm.__name__
}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/create.html')
# ensure the fields were rendered correctly
input_str = ('<input class="form-control" '
'id="id___param_param{0}" '
'name="__param_param{0}" type="{1}" required/>')
self.assertContains(res, input_str.format(3, 'text'), html=True)
self.assertContains(res, input_str.format(4, 'text'), html=True)
input_str_param2 = ('<input type="number" name="__param_param2" '
'autocomplete="off" '
'required class="form-control" '
'id="id___param_param2" />')
self.assertContains(res, input_str_param2, html=True)
# post some sample data and make sure it validates
url = reverse('horizon:project:stacks:launch')
form_data = {
'template_source': 'raw',
'template_data': template['data'],
'password': '******',
'parameters': json.dumps(template['validate']),
'stack_name': stack.stack_name,
"timeout_mins": 60,
"disable_rollback": True,
"__param_param1": "some string",
"__param_param2": 42,
"__param_param3": '{"key": "value"}',
"__param_param4": "a,b,c",
"__param_param5": True,
'method': forms.CreateStackForm.__name__
}
res = self.client.post(url, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
self.mock_template_validate.assert_called_once_with(
test.IsHttpRequest(),
files={},
template=hc_format.parse(template['data']))
self.mock_stack_create.assert_called_once_with(
test.IsHttpRequest(),
stack_name=stack.stack_name,
timeout_mins=60,
disable_rollback=True,
template=hc_format.parse(template['data']),
parameters={
'param1': 'some string',
'param2': 42,
'param3': '{"key": "value"}',
'param4': 'a,b,c',
'param5': True
},
password='******',
files={})
def test_option(self):
volumes = self.cinder_volumes.list()
volume_snapshots = self.cinder_volume_snapshots.list()
volume_types = self.cinder_volume_types.list()
volume_backups = self.cinder_volume_backups.list()
images = self.imagesV2.list()
networks = self.networks.list()
subnets = self.subnets.list()
floating_ips = self.floating_ips.list()
ports = self.ports.list()
security_groups = self.security_groups.list()
routers = self.routers.list()
qos_policies = self.qos_policies.list()
availability_zones = self.availability_zones.list()
flavors = self.flavors.list()
instances = self.servers.list()
keypairs = self.keypairs.list()
template_versions = self.template_versions.list()
self.mock_volume_list.return_value = volumes
self.mock_volume_snapshot_list.return_value = volume_snapshots
self.mock_volume_type_list.return_vlue = volume_types
self.mock_volume_backup_list.return_value = volume_backups
self.mock_image_list_detailed.return_value = images
self.mock_network_list.return_value = networks
self.mock_subnet_list.return_value = subnets
self.mock_tenant_floating_ip_list.return_value = floating_ips
self.mock_port_list.return_value = ports
self.mock_security_group_list.return_value = security_groups
self.mock_router_list.return_value = routers
self.mock_policy_list.return_value = qos_policies
self.mock_availability_zone_list.return_value = availability_zones
self.mock_flavor_list.return_value = flavors
self.mock_server_list.return_value = instances
self.mock_keypair_list.return_value = keypairs
self.mock_template_version_list.return_value = template_versions
resp = self.client.get(reverse(
'horizon:project:template_generator:apis'))
data = resp.content
if isinstance(data, bytes):
data = data.decode('utf-8')
json_data = json.loads(data)
self.assertEqual(len(json_data.keys()), 20)
self.mock_volume_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_volume_snapshot_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_volume_type_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_volume_backup_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_image_list_detailed.assert_called_once_with(
test.IsHttpRequest())
self.mock_network_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_subnet_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_tenant_floating_ip_list.assert_called_once_with(
test.IsHttpRequest(), True)
self.mock_port_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_security_group_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_router_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_policy_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_availability_zone_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_flavor_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_server_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_keypair_list.assert_called_once_with(
test.IsHttpRequest())
self.mock_template_version_list.assert_called_once_with(
test.IsHttpRequest())
