OpenStack Orchestration (Heat)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
heat/heat/tests/test_validate.py

2041 lines
64 KiB

#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import mock
from oslo_messaging.rpc import dispatcher
import six
import webob
from heat.common import exception
from heat.common.i18n import _
from heat.common import template_format
from heat.common import urlfetch
from heat.engine.clients.os import glance
from heat.engine import dependencies
from heat.engine import environment
from heat.engine.hot import template as hot_tmpl
from heat.engine import resources
from heat.engine import service
from heat.engine import stack as parser
from heat.engine import template as tmpl
from heat.tests import common
from heat.tests.openstack.nova import fakes as fakes_nova
from heat.tests import utils
test_template_volumeattach = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"DeletionPolicy": "Delete",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": "test_KeyName"
}
},
"DataVolume" : {
"Type" : "AWS::EC2::Volume",
"Properties" : {
"Size" : "6",
"AvailabilityZone" : "nova"
}
},
"MountPoint" : {
"Type" : "AWS::EC2::VolumeAttachment",
"Properties" : {
"InstanceId" : { "Ref" : "WikiDatabase" },
"VolumeId" : { "Ref" : "DataVolume" },
"Device" : "/dev/%s"
}
}
}
}
'''
test_template_ref = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" }
}
},
"DataVolume" : {
"Type" : "AWS::EC2::Volume",
"Properties" : {
"Size" : "6",
"AvailabilityZone" : "nova"
}
},
"MountPoint" : {
"Type" : "AWS::EC2::VolumeAttachment",
"Properties" : {
"InstanceId" : { "Ref" : "%s" },
"VolumeId" : { "Ref" : "DataVolume" },
"Device" : "/dev/vdb"
}
}
}
}
'''
test_template_findinmap_valid = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" }
}
},
"DataVolume" : {
"Type" : "AWS::EC2::Volume",
"Properties" : {
"Size" : "6",
"AvailabilityZone" : "nova"
}
},
"MountPoint" : {
"Type" : "AWS::EC2::VolumeAttachment",
"Properties" : {
"InstanceId" : { "Ref" : "WikiDatabase" },
"VolumeId" : { "Ref" : "DataVolume" },
"Device" : "/dev/vdb"
}
}
}
}
'''
test_template_findinmap_invalid = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Mappings" : {
"AWSInstanceType2Arch" : {
"t1.micro" : { "Arch" : "64" },
"m1.small" : { "Arch" : "64" },
"m1.medium" : { "Arch" : "64" },
"m1.large" : { "Arch" : "64" },
"m1.xlarge" : { "Arch" : "64" },
"m2.xlarge" : { "Arch" : "64" },
"m2.2xlarge" : { "Arch" : "64" },
"m2.4xlarge" : { "Arch" : "64" },
"c1.medium" : { "Arch" : "64" },
"c1.xlarge" : { "Arch" : "64" },
"cc1.4xlarge" : { "Arch" : "64HVM" },
"cc2.8xlarge" : { "Arch" : "64HVM" },
"cg1.4xlarge" : { "Arch" : "64HVM" }
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId" : {
"Fn::FindInMap" : [
"DistroArch2AMI", { "Ref" : "LinuxDistribution" },
{ "Fn::FindInMap" : [
"AWSInstanceType2Arch",
{ "Ref" : "InstanceType" }, "Arch" ] } ]
},
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName"}
}
},
"DataVolume" : {
"Type" : "AWS::EC2::Volume",
"Properties" : {
"Size" : "6",
"AvailabilityZone" : "nova"
}
},
"MountPoint" : {
"Type" : "AWS::EC2::VolumeAttachment",
"Properties" : {
"InstanceId" : { "Ref" : "WikiDatabase" },
"VolumeId" : { "Ref" : "DataVolume" },
"Device" : "/dev/vdb"
}
}
}
}
'''
test_template_bad_yaql_metadata = '''
heat_template_version: 2016-10-14
parameters:
resources:
my_instance:
type: OS::Heat::TestResource
metadata:
test:
yaql:
expression: {'foo': 'bar'}
data: "$.data"
'''
test_template_invalid_resources = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "AWS CloudFormation Sample Template for xyz.",
"Parameters" : {
"InstanceType" : {
"Description" : "Defined instance type",
"Type" : "String",
"Default" : "node.ee",
"AllowedValues" : ["node.ee", "node.apache", "node.api"],
"ConstraintDescription" : "must be a valid instance type."
}
},
"Resources" : {
"Type" : "AWS::EC2::Instance"
}
}
'''
test_template_invalid_property = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2 KeyPai",
"Type" : "String"
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" },
"UnknownProperty": "unknown"
}
}
}
}
'''
test_template_unimplemented_property = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" },
"SourceDestCheck": "false"
}
}
}
}
'''
test_template_invalid_deletion_policy = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"DeletionPolicy": "Destroy",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" }
}
}
}
}
'''
test_template_snapshot_deletion_policy = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"WikiDatabase": {
"Type": "AWS::EC2::Instance",
"DeletionPolicy": "Snapshot",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" }
}
}
}
}
'''
test_template_volume_snapshot = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Resources" : {
"DataVolume" : {
"Type" : "AWS::EC2::Volume",
"DeletionPolicy": "Snapshot",
"Properties" : {
"Size" : "6",
"AvailabilityZone" : "nova"
}
}
}
}
'''
test_unregistered_key = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"Instance": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" }
}
}
}
}
'''
test_template_image = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"Instance": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" }
}
}
}
}
'''
test_template_invalid_secgroups = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"Instance": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" },
"SecurityGroups": [ "default" ],
"NetworkInterfaces": [ "mgmt", "data" ]
}
}
}
}
'''
test_template_invalid_secgroupids = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
}
},
"Resources" : {
"Instance": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" },
"SecurityGroupIds": [ "default" ],
"NetworkInterfaces": [ "mgmt", "data" ]
}
}
}
}
'''
test_template_glance_client_exception = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Resources" : {
"Instance": {
"Type": "AWS::EC2::Instance",
"DeletionPolicy": "Delete",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large"
}
}
}
}
'''
test_template_unique_logical_name = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String"
},
"AName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String",
}
},
"Resources" : {
"AName": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" },
"NetworkInterfaces": [ "mgmt", "data" ]
}
}
}
}
'''
test_template_cfn_parameter_label = '''
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "test.",
"Parameters" : {
"KeyName" : {
"Description" : "Name of an existing EC2KeyPair",
"Type" : "String",
"Label" : "Nova KeyPair Name"
}
},
"Resources" : {
"AName": {
"Type": "AWS::EC2::Instance",
"Properties": {
"ImageId": "image_name",
"InstanceType": "m1.large",
"KeyName": { "Ref" : "KeyName" },
"NetworkInterfaces": [ "mgmt", "data" ]
}
}
}
}
'''
test_template_hot_parameter_label = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
label: Nova KeyPair Name
resources:
my_instance:
type: AWS::EC2::Instance
properties:
KeyName: { get_param: KeyName }
ImageId: { get_param: ImageId }
InstanceType: { get_param: InstanceType }
outputs:
instance_ip:
description: The IP address of the deployed instance
value: { get_attr: [my_instance, PublicIp] }
'''
test_template_duplicate_parameters = '''
# This is a hello world HOT template just defining a single compute instance
heat_template_version: 2013-05-23
parameter_groups:
- label: Server Group
description: A group of parameters for the server
parameters:
- InstanceType
- KeyName
- ImageId
- label: Database Group
description: A group of parameters for the database
parameters:
- db_password
- db_port
- InstanceType
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
InstanceType:
type: string
description: Instance type for the instance to be created
default: m1.small
constraints:
- allowed_values: [m1.tiny, m1.small, m1.large]
description: Value must be one of 'm1.tiny', 'm1.small' or 'm1.large'
ImageId:
type: string
description: ID of the image to use for the instance
# parameters below are not used in template, but are for verifying parameter
# validation support in HOT
db_password:
type: string
description: Database password
hidden: true
constraints:
- length: { min: 6, max: 8 }
description: Password length must be between 6 and 8 characters
- allowed_pattern: "[a-zA-Z0-9]+"
description: Password must consist of characters and numbers only
- allowed_pattern: "[A-Z]+[a-zA-Z0-9]*"
description: Password must start with an uppercase character
db_port:
type: number
description: Database port number
default: 50000
constraints:
- range: { min: 40000, max: 60000 }
description: Port number must be between 40000 and 60000
resources:
my_instance:
# Use an AWS resource type since this exists; so why use other name here?
type: AWS::EC2::Instance
properties:
KeyName: { get_param: KeyName }
ImageId: { get_param: ImageId }
InstanceType: { get_param: InstanceType }
outputs:
instance_ip:
description: The IP address of the deployed instance
value: { get_attr: [my_instance, PublicIp] }
'''
test_template_invalid_parameter_name = '''
# This is a hello world HOT template just defining a single compute instance
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameter_groups:
- label: Server Group
description: A group of parameters for the server
parameters:
- InstanceType
- KeyName
- ImageId
- label: Database Group
description: A group of parameters for the database
parameters:
- db_password
- db_port
- SomethingNotHere
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
InstanceType:
type: string
description: Instance type for the instance to be created
default: m1.small
constraints:
- allowed_values: [m1.tiny, m1.small, m1.large]
description: Value must be one of 'm1.tiny', 'm1.small' or 'm1.large'
ImageId:
type: string
description: ID of the image to use for the instance
# parameters below are not used in template, but are for verifying parameter
# validation support in HOT
db_password:
type: string
description: Database password
hidden: true
constraints:
- length: { min: 6, max: 8 }
description: Password length must be between 6 and 8 characters
- allowed_pattern: "[a-zA-Z0-9]+"
description: Password must consist of characters and numbers only
- allowed_pattern: "[A-Z]+[a-zA-Z0-9]*"
description: Password must start with an uppercase character
db_port:
type: number
description: Database port number
default: 50000
constraints:
- range: { min: 40000, max: 60000 }
description: Port number must be between 40000 and 60000
resources:
my_instance:
# Use an AWS resource type since this exists; so why use other name here?
type: AWS::EC2::Instance
properties:
KeyName: { get_param: KeyName }
ImageId: { get_param: ImageId }
InstanceType: { get_param: InstanceType }
outputs:
instance_ip:
description: The IP address of the deployed instance
value: { get_attr: [my_instance, PublicIp] }
'''
test_template_hot_no_parameter_label = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
resources:
my_instance:
type: AWS::EC2::Instance
properties:
KeyName: { get_param: KeyName }
ImageId: { get_param: ImageId }
InstanceType: { get_param: InstanceType }
'''
test_template_no_parameters = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameter_groups:
- label: Server Group
description: A group of parameters for the server
- label: Database Group
description: A group of parameters for the database
resources:
server:
type: OS::Nova::Server
'''
test_template_parameter_groups_not_list = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameter_groups:
label: Server Group
description: A group of parameters for the server
parameters:
key_name: heat_key
label: Database Group
description: A group of parameters for the database
parameters:
public_net: public
resources:
server:
type: OS::Nova::Server
'''
test_template_parameters_not_list = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameter_groups:
- label: Server Group
description: A group of parameters for the server
parameters:
key_name: heat_key
public_net: public
resources:
server:
type: OS::Nova::Server
'''
test_template_parameters_error_no_label = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameter_groups:
- parameters:
key_name: heat_key
resources:
server:
type: OS::Nova::Server
'''
test_template_parameters_duplicate_no_label = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameters:
key_name:
type: string
description: Name of an existing key pair to use for the instance
default: heat_key
parameter_groups:
- parameters:
- key_name
- parameters:
- key_name
resources:
server:
type: OS::Nova::Server
'''
test_template_invalid_parameter_no_label = '''
heat_template_version: 2013-05-23
description: >
Hello world HOT template that just defines a single compute instance.
Contains just base features to verify base HOT support.
parameter_groups:
- parameters:
- key_name
resources:
server:
type: OS::Nova::Server
'''
test_template_allowed_integers = '''
heat_template_version: 2013-05-23
parameters:
size:
type: number
constraints:
- allowed_values: [1, 4, 8]
resources:
my_volume:
type: OS::Cinder::Volume
properties:
size: { get_param: size }
'''
test_template_allowed_integers_str = '''
heat_template_version: 2013-05-23
parameters:
size:
type: number
constraints:
- allowed_values: ['1', '4', '8']
resources:
my_volume:
type: OS::Cinder::Volume
properties:
size: { get_param: size }
'''
test_template_default_override = '''
heat_template_version: 2013-05-23
description: create a network
parameters:
net_name:
type: string
default: defaultnet
description: Name of private network to be created
resources:
private_net:
type: OS::Neutron::Net
properties:
name: { get_param: net_name }
'''
test_template_no_default = '''
heat_template_version: 2013-05-23
description: create a network
parameters:
net_name:
type: string
description: Name of private network to be created
merged_param:
type: comma_delimited_list
description: A merged list of values
resources:
private_net:
type: OS::Neutron::Net
properties:
name: { get_param: net_name }
'''
test_template_invalid_outputs = '''
heat_template_version: 2013-05-23
resources:
random_str:
type: OS::Heat::RandomString
outputs:
string:
value: {get_attr: [[random_str, value]]}
'''
test_template_circular_reference = '''
heat_template_version: 2013-05-23
resources:
res1:
type: OS::Heat::None
depends_on: res3
res2:
type: OS::Heat::None
depends_on: res1
res3:
type: OS::Heat::None
depends_on: res2
'''
test_template_external_rsrc = '''
heat_template_version: pike
resources:
random_str:
type: OS::Nova::Server
external_id: foobar
'''
test_template_hot_parameter_tags_older = '''
heat_template_version: 2013-05-23
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
label: Nova KeyPair Name
tags:
- feature1
- feature2
'''
test_template_hot_parameter_tags_pass = '''
heat_template_version: 2018-03-02
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
label: Nova KeyPair Name
tags:
- feature1
- feature2
'''
test_template_hot_parameter_tags_fail = '''
heat_template_version: 2018-03-02
parameters:
KeyName:
type: string
description: Name of an existing key pair to use for the instance
label: Nova KeyPair Name
tags: feature
'''
class ValidateTest(common.HeatTestCase):
def setUp(self):
super(ValidateTest, self).setUp()
resources.initialise()
self.fc = fakes_nova.FakeClient()
self.gc = fakes_nova.FakeClient()
resources.initialise()
self.ctx = utils.dummy_context()
self.mock_isa = mock.patch(
'heat.engine.resource.Resource.is_service_available',
return_value=(True, None))
self.mock_is_service_available = self.mock_isa.start()
self.addCleanup(self.mock_isa.stop)
self.engine = service.EngineService('a', 't')
self.empty_environment = {
'event_sinks': [],
'parameter_defaults': {},
'parameters': {},
'resource_registry': {'resources': {}}}
def _mock_get_image_id_success(self, imageId):
self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id',
return_value=imageId)
def _mock_get_image_id_fail(self, exp):
self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id',
side_effect=exp)
def test_validate_volumeattach_valid(self):
t = template_format.parse(test_template_volumeattach % 'vdq')
stack = parser.Stack(self.ctx, 'test_stack', tmpl.Template(t))
volumeattach = stack['MountPoint']
self.assertIsNone(volumeattach.validate())
def test_validate_volumeattach_invalid(self):
t = template_format.parse(test_template_volumeattach % 'sda')
stack = parser.Stack(self.ctx, 'test_stack', tmpl.Template(t))
volumeattach = stack['MountPoint']
self.assertRaises(exception.StackValidationFailed,
volumeattach.validate)
def test_validate_ref_valid(self):
t = template_format.parse(test_template_ref % 'WikiDatabase')
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual('test.', res['Description'])
def test_validate_with_environment(self):
test_template = test_template_ref % 'WikiDatabase'
test_template = test_template.replace('AWS::EC2::Instance',
'My::Instance')
t = template_format.parse(test_template)
params = {'resource_registry': {'My::Instance': 'AWS::EC2::Instance'}}
res = dict(self.engine.validate_template(self.ctx, t, params))
self.assertEqual('test.', res['Description'])
def test_validate_hot_valid(self):
t = template_format.parse(
"""
heat_template_version: 2013-05-23
description: test.
resources:
my_instance:
type: AWS::EC2::Instance
""")
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual('test.', res['Description'])
def test_validate_ref_invalid(self):
t = template_format.parse(test_template_ref % 'WikiDatabasez')
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertNotEqual(res['Description'], 'Successfully validated')
def test_validate_findinmap_valid(self):
t = template_format.parse(test_template_findinmap_valid)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual('test.', res['Description'])
def test_validate_findinmap_invalid(self):
t = template_format.parse(test_template_findinmap_invalid)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertNotEqual(res['Description'], 'Successfully validated')
def test_validate_bad_yaql_metadata(self):
t = template_format.parse(test_template_bad_yaql_metadata)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertIn('Error', res)
self.assertIn('yaql', res['Error'])
def test_validate_parameters(self):
t = template_format.parse(test_template_ref % 'WikiDatabase')
res = dict(self.engine.validate_template(self.ctx, t, {}))
# Note: the assertion below does not expect a CFN dict of the parameter
# but a dict of the parameters.Schema object.
# For API CFN backward compatibility, formating to CFN is done in the
# API layer in heat.engine.api.format_validate_parameter.
expected = {'KeyName': {
'Type': 'String',
'Description': 'Name of an existing EC2KeyPair',
'NoEcho': 'false',
'Label': 'KeyName'}}
self.assertEqual(expected, res['Parameters'])
def test_validate_parameters_env_override(self):
t = template_format.parse(test_template_default_override)
env_params = {'net_name': 'betternetname'}
res = dict(self.engine.validate_template(self.ctx, t, env_params))
self.assertEqual('defaultnet',
res['Parameters']['net_name']['Default'])
self.assertEqual('betternetname',
res['Parameters']['net_name']['Value'])
def test_validate_parameters_env_provided(self):
t = template_format.parse(test_template_no_default)
env_params = {'net_name': 'betternetname'}
res = dict(self.engine.validate_template(self.ctx, t, env_params))
self.assertEqual('betternetname',
res['Parameters']['net_name']['Value'])
self.assertNotIn('Default', res['Parameters']['net_name'])
def test_validate_parameters_nested(self):
t = template_format.parse(test_template_allowed_integers)
other_template = test_template_no_default.replace(
'net_name', 'net_name2')
files = {'env1': 'parameter_defaults:'
'\n net_name: net1',
'env2': 'parameter_defaults:'
'\n net_name: net2'
'\n net_name2: net3',
'tmpl1.yaml': test_template_no_default,
'tmpl2.yaml': other_template}
params = {'parameters': {}, 'parameter_defaults': {}}
ret = self.engine.validate_template(
self.ctx, t,
params=params,
files=files, environment_files=['env1', 'env2'])
self.assertEqual('net2', params['parameter_defaults']['net_name'])
self.assertEqual('net3', params['parameter_defaults']['net_name2'])
expected = {
'Description': 'No description',
'Parameters': {
'size': {'AllowedValues': [1, 4, 8],
'Description': '',
'Label': u'size',
'NoEcho': 'false',
'Type': 'Number'}},
'Environment': {
'event_sinks': [],
'parameter_defaults': {
'net_name': u'net2',
'net_name2': u'net3'},
'parameters': {},
'resource_registry': {'resources': {}}}}
self.assertEqual(expected, ret)
def test_validate_parameters_merged_env(self):
t = template_format.parse(test_template_allowed_integers)
other_template = test_template_no_default.replace(
'net_name', 'net_name2')
files = {'env1': 'parameter_defaults:'
'\n net_name: net1'
'\n merged_param: [net1, net2]'
'\nparameter_merge_strategies:'
'\n merged_param: merge',
'env2': 'parameter_defaults:'
'\n net_name: net2'
'\n net_name2: net3'
'\n merged_param: [net3, net4]'
'\nparameter_merge_strategies:'
'\n merged_param: merge',
'tmpl1.yaml': test_template_no_default,
'tmpl2.yaml': other_template}
params = {'parameters': {}, 'parameter_defaults': {}}
expected = {
'Description': 'No description',
'Parameters': {
'size': {'AllowedValues': [1, 4, 8],
'Description': '',
'Label': u'size',
'NoEcho': 'false',
'Type': 'Number'}},
'Environment': {
'event_sinks': [],
'parameter_defaults': {
'net_name': u'net2',
'net_name2': u'net3',
'merged_param': ['net1', 'net2', 'net3', 'net4']},
'parameters': {},
'resource_registry': {'resources': {}}}}
ret = self.engine.validate_template(
self.ctx, t,
params=params,
files=files, environment_files=['env1', 'env2'])
self.assertEqual(expected, ret)
def test_validate_hot_empty_parameters_valid(self):
t = template_format.parse(
"""
heat_template_version: 2013-05-23
description: test.
parameters:
resources:
my_instance:
type: AWS::EC2::Instance
""")
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual({}, res['Parameters'])
def test_validate_hot_parameter_label(self):
t = template_format.parse(test_template_hot_parameter_label)
res = dict(self.engine.validate_template(self.ctx, t, {}))
parameters = res['Parameters']
expected = {'KeyName': {
'Type': 'String',
'Description': 'Name of an existing key pair to use for the '
'instance',
'NoEcho': 'false',
'Label': 'Nova KeyPair Name'}}
self.assertEqual(expected, parameters)
def test_validate_hot_no_parameter_label(self):
t = template_format.parse(test_template_hot_no_parameter_label)
res = dict(self.engine.validate_template(self.ctx, t, {}))
parameters = res['Parameters']
expected = {'KeyName': {
'Type': 'String',
'Description': 'Name of an existing key pair to use for the '
'instance',
'NoEcho': 'false',
'Label': 'KeyName'}}
self.assertEqual(expected, parameters)
def test_validate_cfn_parameter_label(self):
t = template_format.parse(test_template_cfn_parameter_label)
res = dict(self.engine.validate_template(self.ctx, t, {}))
parameters = res['Parameters']
expected = {'KeyName': {
'Type': 'String',
'Description': 'Name of an existing EC2KeyPair',
'NoEcho': 'false',
'Label': 'Nova KeyPair Name'}}
self.assertEqual(expected, parameters)
def test_validate_hot_parameter_type(self):
t = template_format.parse(
"""
heat_template_version: 2013-05-23
parameters:
param1:
type: string
param2:
type: number
param3:
type: json
param4:
type: comma_delimited_list
param5:
type: boolean
""")
res = dict(self.engine.validate_template(self.ctx, t, {}))
parameters = res['Parameters']
# make sure all the types are reported correctly
self.assertEqual('String', parameters["param1"]["Type"])
self.assertEqual('Number', parameters["param2"]["Type"])
self.assertEqual('Json', parameters["param3"]["Type"])
self.assertEqual('CommaDelimitedList', parameters["param4"]["Type"])
self.assertEqual('Boolean', parameters["param5"]["Type"])
def test_validate_hot_empty_resources_valid(self):
t = template_format.parse(
"""
heat_template_version: 2013-05-23
description: test.
resources:
""")
res = dict(self.engine.validate_template(self.ctx, t, {}))
expected = {"Description": "test.",
"Parameters": {},
"Environment": self.empty_environment}
self.assertEqual(expected, res)
def test_validate_hot_empty_outputs_valid(self):
t = template_format.parse(
"""
heat_template_version: 2013-05-23
description: test.
outputs:
""")
res = dict(self.engine.validate_template(self.ctx, t, {}))
expected = {"Description": "test.",
"Parameters": {},
"Environment": self.empty_environment}
self.assertEqual(expected, res)
def test_validate_properties(self):
t = template_format.parse(test_template_invalid_property)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual(
{'Error': 'Property error: Resources.WikiDatabase.Properties: '
'Unknown Property UnknownProperty'}, res)
def test_invalid_resources(self):
t = template_format.parse(test_template_invalid_resources)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual({'Error': 'Resources must contain Resource. '
'Found a [%s] instead' % six.text_type},
res)
def test_invalid_section_cfn(self):
t = template_format.parse(
"""
{
'AWSTemplateFormatVersion': '2010-09-09',
'Resources': {
'server': {
'Type': 'OS::Nova::Server'
}
},
'Output': {}
}
""")
res = dict(self.engine.validate_template(self.ctx, t))
self.assertEqual({'Error': 'The template section is invalid: Output'},
res)
def test_invalid_section_hot(self):
t = template_format.parse(
"""
heat_template_version: 2013-05-23
resources:
server:
type: OS::Nova::Server
output:
""")
res = dict(self.engine.validate_template(self.ctx, t))
self.assertEqual({'Error': 'The template section is invalid: output'},
res)
def test_unimplemented_property(self):
t = template_format.parse(test_template_unimplemented_property)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual(
{'Error': 'Property error: Resources.WikiDatabase.Properties: '
'Property SourceDestCheck not implemented yet'},
res)
def test_invalid_deletion_policy(self):
t = template_format.parse(test_template_invalid_deletion_policy)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual({'Error': 'Invalid deletion policy "Destroy"'}, res)
def test_snapshot_deletion_policy(self):
t = template_format.parse(test_template_snapshot_deletion_policy)
res = dict(self.engine.validate_template(self.ctx, t, {}))
self.assertEqual({'Error': 'Resources.WikiDatabase.DeletionPolicy: '
'"Snapshot" deletion policy '
'not supported'},
res)
def test_volume_snapshot_deletion_policy(self):
t = template_format.parse(test_template_volume_snapshot)
res = dict(self.engine.validate_template(self.ctx, t, {}))
expected = {'Description': u'test.', 'Parameters': {},
'Environment': self.empty_environment}
self.assertEqual(expected, res)
def test_validate_template_without_resources(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
expected = {'Description': 'No description', 'Parameters': {},
'Environment': self.empty_environment}
self.assertEqual(expected, res)
def test_validate_template_with_invalid_resource_type(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
resources:
resource1:
Type: AWS::EC2::Instance
properties:
property1: value1
metadata:
foo: bar
depends_on: dummy
deletion_policy: dummy
update_policy:
foo: bar
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
self.assertEqual({'Error': '"Type" is not a valid keyword '
'inside a resource definition'}, res)
def test_validate_template_with_invalid_resource_properties(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
resources:
resource1:
type: AWS::EC2::Instance
Properties:
property1: value1
metadata:
foo: bar
depends_on: dummy
deletion_policy: dummy
update_policy:
foo: bar
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
self.assertEqual({'Error': '"Properties" is not a valid keyword '
'inside a resource definition'}, res)
def test_validate_template_with_invalid_resource_matadata(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
resources:
resource1:
type: AWS::EC2::Instance
properties:
property1: value1
Metadata:
foo: bar
depends_on: dummy
deletion_policy: dummy
update_policy:
foo: bar
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
self.assertEqual({'Error': '"Metadata" is not a valid keyword '
'inside a resource definition'}, res)
def test_validate_template_with_invalid_resource_depends_on(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
resources:
resource1:
type: AWS::EC2::Instance
properties:
property1: value1
metadata:
foo: bar
DependsOn: dummy
deletion_policy: dummy
update_policy:
foo: bar
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
self.assertEqual({'Error': '"DependsOn" is not a valid keyword '
'inside a resource definition'}, res)
def test_validate_template_with_invalid_resource_deletion_policy(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
resources:
resource1:
type: AWS::EC2::Instance
properties:
property1: value1
metadata:
foo: bar
depends_on: dummy
DeletionPolicy: dummy
update_policy:
foo: bar
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
self.assertEqual({'Error': '"DeletionPolicy" is not a valid '
'keyword inside a resource definition'},
res)
def test_validate_template_with_invalid_resource_update_policy(self):
hot_tpl = template_format.parse('''
heat_template_version: 2013-05-23
resources:
resource1:
type: AWS::EC2::Instance
properties:
property1: value1
metadata:
foo: bar
depends_on: dummy
deletion_policy: dummy
UpdatePolicy:
foo: bar
''')
res = dict(self.engine.validate_template(self.ctx, hot_tpl, {}))
self.assertEqual({'Error': '"UpdatePolicy" is not a valid '
'keyword inside a resource definition'},
res)
def test_unregistered_key(self):
t = template_format.parse(test_unregistered_key)
params = {'KeyName': 'not_registered'}
template = tmpl.Template(t, env=environment.Environment(params))
stack = parser.Stack(self.ctx, 'test_stack', template)
self.stub_FlavorConstraint_validate()
self.stub_ImageConstraint_validate()
resource = stack['Instance']
self.assertRaises(exception.StackValidationFailed, resource.validate)
def test_unregistered_image(self):
t = template_format.parse(test_template_image)
template = tmpl.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_fail(exception.EntityNotFound(
entity='Image',
name='image_name'))
self.stub_KeypairConstraint_validate()
self.stub_FlavorConstraint_validate()
resource = stack['Instance']
self.assertRaises(exception.StackValidationFailed, resource.validate)
def test_duplicated_image(self):
t = template_format.parse(test_template_image)
template = tmpl.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_fail(exception.PhysicalResourceNameAmbiguity(
name='image_name'))
self.stub_KeypairConstraint_validate()
self.stub_FlavorConstraint_validate()
resource = stack['Instance']
self.assertRaises(exception.StackValidationFailed,
resource.validate)
@mock.patch('heat.engine.clients.os.nova.NovaClientPlugin._create')
def test_invalid_security_groups_with_nics(self, mock_create):
t = template_format.parse(test_template_invalid_secgroups)
template = tmpl.Template(t,
env=environment.Environment(
{'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_success('image_id')
mock_create.return_value = self.fc
resource = stack['Instance']
self.assertRaises(exception.ResourcePropertyConflict,
resource.validate)
@mock.patch('heat.engine.clients.os.nova.NovaClientPlugin._create')
def test_invalid_security_group_ids_with_nics(self, mock_create):
t = template_format.parse(test_template_invalid_secgroupids)
template = tmpl.Template(
t, env=environment.Environment({'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self._mock_get_image_id_success('image_id')
mock_create.return_value = self.fc
resource = stack['Instance']
self.assertRaises(exception.ResourcePropertyConflict,
resource.validate)
@mock.patch('heat.engine.clients.os.glance.GlanceClientPlugin.client')
def test_client_exception_from_glance_client(self, mock_client):
t = template_format.parse(test_template_glance_client_exception)
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
mock_client.return_value = self.gc
self.stub_FlavorConstraint_validate()
self.assertRaises(exception.StackValidationFailed, stack.validate)
def test_validate_unique_logical_name(self):
t = template_format.parse(test_template_unique_logical_name)
template = tmpl.Template(
t, env=environment.Environment(
{'AName': 'test', 'KeyName': 'test'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertRaises(exception.StackValidationFailed, stack.validate)
def test_validate_duplicate_parameters_in_group(self):
t = template_format.parse(test_template_duplicate_parameters)
template = hot_tmpl.HOTemplate20130523(
t, env=environment.Environment({
'KeyName': 'test',
'ImageId': 'sometestid',
'db_password': 'Pass123'
}))
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: '
'parameter_groups.Database '
'Group: The InstanceType parameter must be '
'assigned to one parameter group only.'),
six.text_type(exc))
def test_validate_duplicate_parameters_no_label(self):
t = template_format.parse(test_template_parameters_duplicate_no_label)
template = hot_tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: '
'parameter_groups.: '
'The key_name parameter must be '
'assigned to one parameter group only.'),
six.text_type(exc))
def test_validate_invalid_parameter_in_group(self):
t = template_format.parse(test_template_invalid_parameter_name)
template = hot_tmpl.HOTemplate20130523(t,
env=environment.Environment({
'KeyName': 'test',
'ImageId': 'sometestid',
'db_password': 'Pass123'}))
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: '
'parameter_groups.Database Group: The grouped '
'parameter SomethingNotHere does not '
'reference a valid parameter.'),
six.text_type(exc))
def test_validate_invalid_parameter_no_label(self):
t = template_format.parse(test_template_invalid_parameter_no_label)
template = hot_tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: '
'parameter_groups.: The grouped '
'parameter key_name does not '
'reference a valid parameter.'),
six.text_type(exc))
def test_validate_no_parameters_in_group(self):
t = template_format.parse(test_template_no_parameters)
template = hot_tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: parameter_groups.Server '
'Group: The parameters must be provided for each '
'parameter group.'), six.text_type(exc))
def test_validate_parameter_groups_not_list(self):
t = template_format.parse(test_template_parameter_groups_not_list)
template = hot_tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: parameter_groups: '
'The parameter_groups should be '
'a list.'), six.text_type(exc))
def test_validate_parameters_not_list(self):
t = template_format.parse(test_template_parameters_not_list)
template = hot_tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: '
'parameter_groups.Server Group: '
'The parameters of parameter group should be '
'a list.'), six.text_type(exc))
def test_validate_parameters_error_no_label(self):
t = template_format.parse(test_template_parameters_error_no_label)
template = hot_tmpl.HOTemplate20130523(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
exc = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertEqual(_('Parameter Groups error: parameter_groups.: '
'The parameters of parameter group should be '
'a list.'), six.text_type(exc))
def test_validate_allowed_values_integer(self):
t = template_format.parse(test_template_allowed_integers)
template = tmpl.Template(t,
env=environment.Environment({'size': '4'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
# test with size parameter provided as number
template.env = environment.Environment({'size': 4})
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
def test_validate_allowed_values_integer_str(self):
t = template_format.parse(test_template_allowed_integers_str)
template = tmpl.Template(t,
env=environment.Environment({'size': '4'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
# test with size parameter provided as number
template.env = environment.Environment({'size': 4})
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate())
def test_validate_not_allowed_values_integer(self):
t = template_format.parse(test_template_allowed_integers)
template = tmpl.Template(t,
env=environment.Environment({'size': '3'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
six.text_type(err))
# test with size parameter provided as number
template.env = environment.Environment({'size': 3})
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
six.text_type(err))
def test_validate_not_allowed_values_integer_str(self):
t = template_format.parse(test_template_allowed_integers_str)
template = tmpl.Template(t,
env=environment.Environment({'size': '3'}))
# test with size parameter provided as string
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
six.text_type(err))
# test with size parameter provided as number
template.env = environment.Environment({'size': 3})
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
self.assertIn('"3" is not an allowed value [1, 4, 8]',
six.text_type(err))
def test_validate_invalid_outputs(self):
t = template_format.parse(test_template_invalid_outputs)
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
err = self.assertRaises(exception.StackValidationFailed,
stack.validate)
error_message = ('outputs.string.value.get_attr: Arguments to '
'"get_attr" must be of the form '
'[resource_name, attribute, (path), ...]')
self.assertEqual(error_message, six.text_type(err))
def test_validate_resource_attr_invalid_type(self):
t = template_format.parse("""
heat_template_version: 2013-05-23
resources:
resource:
type: 123
""")
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
ex = self.assertRaises(exception.StackValidationFailed, stack.validate)
self.assertEqual('Resource resource type type must be string',
six.text_type(ex))
def test_validate_resource_attr_invalid_type_cfn(self):
t = template_format.parse("""
HeatTemplateFormatVersion: '2012-12-12'
Resources:
Resource:
Type: [Wrong, Type]
""")
stack = parser.Stack(self.ctx, 'test_stack', tmpl.Template(t))
ex = self.assertRaises(exception.StackValidationFailed, stack.validate)
self.assertEqual('Resource Resource Type type must be string',
six.text_type(ex))
def test_validate_resource_invalid_key(self):
t = template_format.parse("""
heat_template_version: 2013-05-23
resources:
resource:
type: OS::Heat::TestResource
wibble: bar
""")
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
ex = self.assertRaises(exception.StackValidationFailed, stack.validate)
self.assertIn('wibble', six.text_type(ex))
def test_validate_resource_invalid_cfn_key_in_hot(self):
t = template_format.parse("""
heat_template_version: 2013-05-23
resources:
resource:
type: OS::Heat::TestResource
Properties: {foo: bar}
""")
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
ex = self.assertRaises(exception.StackValidationFailed, stack.validate)
self.assertIn('Properties', six.text_type(ex))
def test_validate_resource_invalid_key_cfn(self):
t = template_format.parse("""
HeatTemplateFormatVersion: '2012-12-12'
Resources:
Resource:
Type: OS::Heat::TestResource
Wibble: bar
""")
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
# We have always allowed unknown keys in CFN-style templates, so we
# more or less have to keep allowing it.
self.assertIsNone(stack.validate())
def test_validate_is_service_available(self):
t = template_format.parse(
"""
heat_template_version: 2015-10-15
resources:
my_instance:
type: AWS::EC2::Instance
""")
self.mock_is_service_available.return_value = (
False, 'Service endpoint not in service catalog.')
ex = self.assertRaises(dispatcher.ExpectedException,
self.engine.validate_template,
self.ctx,
t,
{})
self.assertEqual(exception.ResourceTypeUnavailable, ex.exc_info[0])
def test_validate_with_ignorable_errors(self):
t = template_format.parse(
"""
heat_template_version: 2015-10-15
resources:
my_instance:
type: AWS::EC2::Instance
""")
engine = service.EngineService('a', 't')
self.mock_is_service_available.return_value = (
False, 'Service endpoint not in service catalog.')
res = dict(engine.validate_template(
self.ctx,
t,
{},
ignorable_errors=[exception.ResourceTypeUnavailable.error_code]))
expected = {'Description': 'No description', 'Parameters': {},
'Environment': self.empty_environment}
self.assertEqual(expected, res)
def test_validate_with_ignorable_errors_invalid_error_code(self):
engine = service.EngineService('a', 't')
invalide_error_code = '123456'
invalid_codes = ['99001', invalide_error_code]
res = engine.validate_template(
self.ctx,
mock.MagicMock(),
{},
ignorable_errors=invalid_codes)
msg = _("Invalid codes in ignore_errors : %s") % [invalide_error_code]
ex = webob.exc.HTTPBadRequest(explanation=msg)
self.assertIsInstance(res, webob.exc.HTTPBadRequest)
self.assertEqual(ex.explanation, res.explanation)
def test_validate_parameter_group_output(self):
engine = service.EngineService('a', 't')
params = {
"resource_registry": {
"OS::Test::TestResource": "https://server.test/nested.template"
}
}
root_template_str = '''
heat_template_version: 2015-10-15
parameters:
test_root_param:
type: string
parameter_groups:
- label: RootTest
parameters:
- test_root_param
resources:
Nested:
type: OS::Test::TestResource
'''
nested_template_str = '''
heat_template_version: 2015-10-15
parameters:
test_param:
type: string
parameter_groups:
- label: Test
parameters:
- test_param
'''
root_template = template_format.parse(root_template_str)
self.patchobject(urlfetch, 'get')
urlfetch.get.return_value = nested_template_str
res = dict(engine.validate_template(self.ctx, root_template,
params, show_nested=True))
expected = {
'Description': 'No description',
'ParameterGroups': [{
'label': 'RootTest',
'parameters': ['test_root_param']}],
'Parameters': {
'test_root_param': {
'Description': '',
'Label': 'test_root_param',
'NoEcho': 'false',
'Type': 'String'}},
'NestedParameters': {
'Nested': {
'Description': 'No description',
'ParameterGroups': [{
'label': 'Test',
'parameters': ['test_param']}],
'Parameters': {
'test_param': {
'Description': '',
'Label': 'test_param',
'NoEcho': 'false',
'Type': 'String'}},
'Type': 'OS::Test::TestResource'}},
'Environment': {
'event_sinks': [],
'parameter_defaults': {},
'parameters': {},
'resource_registry': {
'OS::Test::TestResource':
'https://server.test/nested.template',
'resources': {}}}}
self.assertEqual(expected, res)
def test_validate_allowed_external_rsrc(self):
t = template_format.parse(test_template_external_rsrc)
template = tmpl.Template(t)
stack = parser.Stack(self.ctx, 'test_stack', template)
self.assertIsNone(stack.validate(validate_res_tmpl_only=True))
with mock.patch(
'heat.engine.resources.server_base.BaseServer._show_resource',
return_value={'id': 'foobar'}
):
self.assertIsNone(stack.validate(validate_res_tmpl_only=False))
def test_validate_circular_reference(self):
t = template_format.parse(test_template_circular_reference)
exc = self.assertRaises(dispatcher.ExpectedException,
self.engine.validate_template,
self.ctx, t, {})
self.assertEqual(dependencies.CircularDependencyException,
exc.exc_info[0])
def test_validate_hot_parameter_tags_older(self):
t = template_format.parse(test_template_hot_parameter_tags_older)
exc = self.assertRaises(dispatcher.ExpectedException,
self.engine.validate_template,
self.ctx, t, {})
self.assertEqual(exception.InvalidSchemaError,
exc.exc_info[0])
def test_validate_hot_parameter_tags_pass(self):
t = template_format.parse(test_template_hot_parameter_tags_pass)
res = dict(self.engine.validate_template(self.ctx, t, {}))
parameters = res['Parameters']
expected = {'KeyName': {
'Description': 'Name of an existing key pair to use for the '
'instance',
'NoEcho': 'false',
'Label': 'Nova KeyPair Name',
'Type': 'String',
'Tags': [
'feature1',
'feature2'
]}}
self.assertEqual(expected, parameters)
def test_validate_hot_parameter_tags_fail(self):
t = template_format.parse(test_template_hot_parameter_tags_fail)
exc = self.assertRaises(dispatcher.ExpectedException,
self.engine.validate_template,
self.ctx, t, {})
self.assertEqual(exception.InvalidSchemaError,
exc.exc_info[0])