def test_properties_type_mismatch(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'String'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.MAP)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
ex = self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
self.assertEqual("Property Foo type mismatch between facade "
"DummyResource (Map) and provider (String)",
six.text_type(ex))
def test_boolean_type_provider(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'Boolean'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.BOOLEAN)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files), env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "False"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def test_attributes_not_parsable(self):
provider = {"HeatTemplateFormatVersion": "2012-12-12", "Outputs": {"Foo": {"Value": "bar"}}}
files = {"test_resource.template": json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
env = environment.Environment()
resource._register_class("DummyResource", DummyResource)
env.load({"resource_registry": {"DummyResource": "test_resource.template"}})
stack = parser.Stack(
utils.dummy_context(),
"test_stack",
template.Template(empty_template, files=files, env=env),
stack_id=str(uuid.uuid4()),
)
definition = rsrc_defn.ResourceDefinition("test_t_res", "DummyResource")
temp_res = template_resource.TemplateResource("test_t_res", definition, stack)
self.assertIsNone(temp_res.validate())
nested = mock.Mock()
nested.outputs = {"Foo": {"Value": "not-this", "error_msg": "it is all bad"}}
nested.output.return_value = None
temp_res._nested = nested
self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, "Foo")
def test_attributes_extra(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Outputs': {
'Foo': {'Value': 'bar'},
'Blarg': {'Value': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
properties_schema = {}
attributes_schema = {"Foo": "A test attribute"}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template({}, files=files), env=env,
stack_id=str(uuid.uuid4()))
json_snippet = {
"Type": "DummyResource",
}
temp_res = template_resource.TemplateResource('test_t_res',
json_snippet, stack)
self.assertIsNone(temp_res.validate())
def test_resource_info_special(self):
provider = {"HeatTemplateFormatVersion": "2012-12-12", "Parameters": {"Foo": {"Type": "Boolean"}}}
files = {"test_resource.template": json.dumps(provider), "foo.template": json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo": properties.Schema(properties.Schema.BOOLEAN)}
attributes_schema = {}
env = environment.Environment()
resource._register_class("DummyResource", DummyResource)
env.load(
{
"resource_registry": {
"DummyResource": "test_resource.template",
"resources": {"foo": {"DummyResource": "foo.template"}},
}
}
)
stack = parser.Stack(
utils.dummy_context(),
"test_stack",
template.Template({"HeatTemplateFormatVersion": "2012-12-12"}, files=files, env=env),
stack_id=str(uuid.uuid4()),
)
definition = rsrc_defn.ResourceDefinition("foo", "DummyResource", {"Foo": "False"})
temp_res = template_resource.TemplateResource("foo", definition, stack)
self.assertEqual("foo.template", temp_res.template_name)
def setUp(self):
super(WebHookTest, self).setUp()
for res_name, res_class in auto_scale.resource_mapping().items():
resource._register_class(res_name, res_class)
self.fake_auto_scale = FakeAutoScale()
self.patch(clients.OpenStackClients,
'auto_scale', lambda resource: self.fake_auto_scale)
def test_properties_extra_required(self):
provider = {
'Parameters': {
'Blarg': {'Type': 'String'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
properties_schema = {}
attributes_schema = {}
json_snippet = {
"Type": "DummyResource",
"Properties": {
"Blarg": "wibble",
},
}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template({}, files=files), env=env,
stack_id=str(uuid.uuid4()))
temp_res = template_resource.TemplateResource('test_t_res',
json_snippet, stack)
self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
def test_properties_extra_required(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Blarg': {'Type': 'String'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Blarg": "wibble"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
def setUp(self):
super(TemplateResourceCrudTest, self).setUp()
files = {'test_resource.template': json.dumps(self.provider)}
self.ctx = utils.dummy_context()
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.STRING,
required=True)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(self.ctx, 'test_stack',
parser.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
self.defn = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
self.res = template_resource.TemplateResource('test_t_res',
self.defn, stack)
self.assertIsNone(self.res.validate())
def test_properties_type_mismatch(self):
provider = {"HeatTemplateFormatVersion": "2012-12-12", "Parameters": {"Foo": {"Type": "String"}}}
files = {"test_resource.template": json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {"Foo": properties.Schema(properties.Schema.MAP)}
attributes_schema = {}
env = environment.Environment()
resource._register_class("DummyResource", DummyResource)
env.load({"resource_registry": {"DummyResource": "test_resource.template"}})
stack = parser.Stack(
utils.dummy_context(),
"test_stack",
template.Template({"HeatTemplateFormatVersion": "2012-12-12"}, files=files, env=env),
stack_id=str(uuid.uuid4()),
)
definition = rsrc_defn.ResourceDefinition("test_t_res", "DummyResource", {"Foo": "bar"})
temp_res = template_resource.TemplateResource("test_t_res", definition, stack)
ex = self.assertRaises(exception.StackValidationFailed, temp_res.validate)
self.assertEqual(
"Property Foo type mismatch between facade " "DummyResource (Map) and provider (String)", six.text_type(ex)
)
def setUp(self):
super(StackTest, self).setUp()
self.tmpl = template.Template(copy.deepcopy(empty_template))
self.ctx = utils.dummy_context()
resource._register_class('GenericResourceType',
generic_rsrc.GenericResource)
def test_nested_stack_create_equals_resource_limit(self):
cfg.CONF.set_override('max_resources_per_stack', 2)
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
urlfetch.get('https://server.test/the.template').MultipleTimes().\
AndReturn('''
HeatTemplateFormatVersion: '2012-12-12'
Parameters:
KeyName:
Type: String
Resources:
NestedResource:
Type: GenericResource
Outputs:
Foo:
Value: bar
''')
self.m.ReplayAll()
t = template_format.parse(self.test_template)
stack = self.parse_stack(t)
stack.create()
self.assertEquals(stack.state, (stack.CREATE, stack.COMPLETE))
self.assertIn('NestedResource',
stack['the_nested'].nested())
self.m.VerifyAll()
def test_properties_normal(self):
provider = {
'Parameters': {
'Foo': {'Type': 'String'},
'Blarg': {'Type': 'String', 'Default': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
properties_schema = {"Foo": properties.Schema(properties.STRING,
required=True)}
attributes_schema = {}
json_snippet = {
"Type": "DummyResource",
"Properties": {
"Foo": "bar",
},
}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template({}, files=files), env=env,
stack_id=uuidutils.generate_uuid())
temp_res = template_resource.TemplateResource('test_t_res',
json_snippet, stack)
self.assertEqual(None, temp_res.validate())
def test_properties_type_match(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Length': {'Type': 'Number'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {"Length":
properties.Schema(properties.Schema.INTEGER)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
template.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Length": 10})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def setUp(self):
super(ProviderTemplateTest, self).setUp()
utils.setup_dummy_db()
resource._register_class('OS::ResourceType',
generic_rsrc.GenericResource)
resource._register_class('myCloud::ResourceType',
MyCloudResource)
def test_properties_type_mismatch(self):
provider = {
'Parameters': {
'Foo': {'Type': 'String'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
properties_schema = {"Foo": properties.Schema(properties.MAP)}
attributes_schema = {}
json_snippet = {
"Type": "DummyResource",
"Properties": {
"Foo": "bar",
},
}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template({}, files=files), env=env,
stack_id=uuidutils.generate_uuid())
temp_res = template_resource.TemplateResource('test_t_res',
json_snippet, stack)
self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
def setUp(self):
super(KeystoneRoleAssignmentMixinTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider explicitly.
resource._register_class(RESOURCE_TYPE, DummyRoleAssignment)
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone',
template.Template(keystone_role_assignment_template)
)
self.test_role_assignment = self.stack['test_role_assignment']
# Mock client
self.keystoneclient = mock.MagicMock()
self.test_role_assignment.client = mock.MagicMock()
self.test_role_assignment.client.return_value = self.keystoneclient
self.roles = self.keystoneclient.roles
# Mock client plugin
def _side_effect(value):
return value
self.keystone_client_plugin = mock.MagicMock()
(self.keystone_client_plugin.get_domain_id.
side_effect) = _side_effect
(self.keystone_client_plugin.get_role_id.
side_effect) = _side_effect
(self.keystone_client_plugin.get_project_id.
side_effect) = _side_effect
self.test_role_assignment.client_plugin = mock.MagicMock()
(self.test_role_assignment.client_plugin.
return_value) = self.keystone_client_plugin
def test_attributes_extra(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Outputs': {
'Foo': {'Value': 'bar'},
'Blarg': {'Value': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource")
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def test_properties_normal(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'String'},
'Blarg': {'Type': 'String', 'Default': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {"Foo":
properties.Schema(properties.Schema.STRING,
required=True)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertIsNone(temp_res.validate())
def test_resource_info_general(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {'Type': 'Boolean'},
},
}
files = {'test_resource.template': json.dumps(provider),
'foo.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
properties_schema = {"Foo":
properties.Schema(properties.Schema.BOOLEAN)}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template',
'resources': {'foo': 'foo.template'}}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
template.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files, env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "False"})
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertEqual('test_resource.template',
temp_res.template_name)
def test_attributes_missing(self):
provider = {
'Outputs': {
'Blarg': {'Value': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
properties_schema = {}
attributes_schema = {"Foo": "A test attribute"}
json_snippet = {
"Type": "DummyResource",
}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
parser.Template({}, files=files), env=env,
stack_id=uuidutils.generate_uuid())
temp_res = template_resource.TemplateResource('test_t_res',
json_snippet, stack)
self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
def setUp(self):
super(MonascaAlarmDefinitionTest, self).setUp()
self.ctx = utils.dummy_context()
# As monascaclient is not part of requirements.txt, RESOURCE_TYPE is
# not registered by default. For testing, its registered here
resource._register_class(RESOURCE_TYPE,
MonascaAlarmDefinition)
self.stack = stack.Stack(
self.ctx, 'test_stack',
template.Template(sample_template)
)
self.test_resource = self.stack['test_resource']
# Mock client plugin
self.test_client_plugin = mock.MagicMock()
self.test_resource.client_plugin = mock.MagicMock(
return_value=self.test_client_plugin)
self.test_client_plugin.get_notification.return_value = (
'sample_notification'
)
# Mock client
self.test_client = mock.MagicMock()
self.test_resource.client = mock.MagicMock(
return_value=self.test_client)
def test_instance_group_custom_resource(self):
"""
If AWS::EC2::Instance is overridden, InstanceGroup will automatically
use that overridden resource type.
"""
# resources may need to be initialised if this is the first test run.
resources.initialise()
class MyInstance(instance.Instance):
"""A customized Instance resource."""
original_instance = resource.get_class("AWS::EC2::Instance")
resource._register_class("AWS::EC2::Instance", MyInstance)
self.addCleanup(resource._register_class, "AWS::EC2::Instance",
original_instance)
t = template_format.parse(ig_template)
stack = utils.parse_stack(t)
self._stub_create(1, instance_class=MyInstance)
self.m.ReplayAll()
conf = self.create_resource(t, stack, 'JobServerConfig')
rsrc = self.create_resource(t, stack, 'JobServerGroup')
self.assertEqual(utils.PhysName(stack.name, rsrc.name),
rsrc.FnGetRefId())
rsrc.delete()
self.m.VerifyAll()
def setUp(self):
super(ValidateGetAttTest, self).setUp()
resource._register_class('GenericResourceType',
generic_rsrc.GenericResource)
env = environment.Environment()
env.load({u'resource_registry':
{u'OS::Test::GenericResource': u'GenericResourceType'}})
class FakeResource(generic_rsrc.GenericResource):
def FnGetAtt(self, name):
pass
resource._register_class('OverwrittenFnGetAttType', FakeResource)
env.load({u'resource_registry':
{u'OS::Test::FakeResource': u'OverwrittenFnGetAttType'}})
self.stack = parser.Stack(
utils.dummy_context(), 'test_stack',
parser.Template({"HeatTemplateFormatVersion": "2012-12-12"}),
env=env, stack_id=str(uuid.uuid4()))
res_defn = rsrc_defn.ResourceDefinition('test_rsrc',
'OS::Test::GenericResource')
self.rsrc = resource.Resource('test_rsrc', res_defn, self.stack)
self.stack.add_resource(self.rsrc)
def setUp(self):
super(WebHookTest, self).setUp()
for res_name, res_class in auto_scale.resource_mapping().items():
resource._register_class(res_name, res_class)
self.fake_auto_scale = FakeAutoScale()
self.patchobject(auto_scale.WebHook, 'auto_scale',
return_value=self.fake_auto_scale)
def test_attributes_missing_based_on_class(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Outputs': {
'Blarg': {'Value': 'wibble'},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({'resource_registry':
{'DummyResource': 'test_resource.template'}})
stack = parser.Stack(utils.dummy_context(), 'test_stack',
template.Template(empty_template, files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource")
temp_res = template_resource.TemplateResource('test_t_res',
definition, stack)
self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
def setUp(self):
super(KeystoneUserTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider explicitly.
resource._register_class(RESOURCE_TYPE, user.KeystoneUser)
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone',
template.Template(keystone_user_template)
)
self.test_user = self.stack['test_user']
# Mock client
self.keystoneclient = mock.MagicMock()
self.test_user.keystone = mock.MagicMock()
self.test_user.keystone.return_value = self.keystoneclient
self.users = self.keystoneclient.client.users
# Mock client plugin
def _side_effect(value):
return value
self.keystone_client_plugin = mock.MagicMock()
(self.keystone_client_plugin.get_domain_id.
side_effect) = _side_effect
(self.keystone_client_plugin.get_group_id.
side_effect) = _side_effect
(self.keystone_client_plugin.get_project_id.
side_effect) = _side_effect
self.test_user.client_plugin = mock.MagicMock()
(self.test_user.client_plugin.
return_value) = self.keystone_client_plugin
def test_nested_stack_adopt_fail(self):
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
urlfetch.get('https://server.test/the.template').MultipleTimes().\
AndReturn('''
HeatTemplateFormatVersion: '2012-12-12'
Parameters:
KeyName:
Type: String
Resources:
NestedResource:
Type: GenericResource
Outputs:
Foo:
Value: bar
''')
self.m.ReplayAll()
adopt_data = {
"resources": {
"the_nested": {
"resource_id": "test-res-id",
"resources": {
}
}
}
}
stack = self.adopt_stack(self.test_template, adopt_data)
rsrc = stack['the_nested']
self.assertEqual((rsrc.ADOPT, rsrc.FAILED), rsrc.nested().state)
nested_name = utils.PhysName(stack.name, 'the_nested')
self.assertEqual(nested_name, rsrc.physical_resource_name())
rsrc.delete()
self.m.VerifyAll()
def setUp(self):
super(KeystoneProjectTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider explicitly.
resource._register_class(RESOURCE_TYPE, project.KeystoneProject)
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone',
template.Template(keystone_project_template)
)
self.test_project = self.stack['test_project']
# Mock client
self.keystoneclient = mock.MagicMock()
self.test_project.keystone = mock.MagicMock()
self.test_project.keystone.return_value = self.keystoneclient
self.projects = self.keystoneclient.client.projects
# Mock client plugin
def _domain_side_effect(value):
return value
keystone_client_plugin = mock.MagicMock()
keystone_client_plugin.get_domain_id.side_effect = _domain_side_effect
self.test_project.client_plugin = mock.MagicMock()
self.test_project.client_plugin.return_value = keystone_client_plugin
def setUp(self):
super(RackspaceCloudServerTest, self).setUp()
self.fc = fakes.FakeClient()
setup_dummy_db()
# Test environment may not have pyrax client library installed and if
# pyrax is not installed resource class would not be registered.
# So register resource provider class explicitly for unit testing.
resource._register_class("Rackspace::Cloud::Server",
cloud_server.CloudServer)
f2 = self.m.CreateMockAnything()
f2.id = '2'
f3 = self.m.CreateMockAnything()
f3.id = '3'
f4 = self.m.CreateMockAnything()
f4.id = '4'
f5 = self.m.CreateMockAnything()
f5.id = '5'
f6 = self.m.CreateMockAnything()
f6.id = '6'
f7 = self.m.CreateMockAnything()
f7.id = '7'
f8 = self.m.CreateMockAnything()
f8.id = '8'
self.flavors = [f2, f3, f4, f5, f6, f7, f8]
def setUp(self):
super(CloudServersTest, self).setUp()
cfg.CONF.set_override('region_name_for_services', 'RegionOne')
self.ctx = utils.dummy_context()
self.fc = fakes.FakeClient()
mock_nova_create = mock.Mock()
self.ctx.clients.client_plugin('nova')._create = mock_nova_create
mock_nova_create.return_value = self.fc
# Test environment may not have pyrax client library installed and if
# pyrax is not installed resource class would not be registered.
# So register resource provider class explicitly for unit testing.
resource._register_class("OS::Nova::Server", cloud_server.CloudServer)
def setUp(self):
super(ScalingGroupTest, self).setUp()
for res_name, res_class in auto_scale.resource_mapping().items():
resource._register_class(res_name, res_class)
self.fake_auto_scale = FakeAutoScale()
self.patchobject(auto_scale.Group, 'auto_scale',
return_value=self.fake_auto_scale)
# mock nova and glance client methods to satisfy constraints
mock_im = self.patchobject(glance.GlanceClientPlugin,
'find_image_by_name_or_id')
mock_im.return_value = 'image-ref'
mock_fl = self.patchobject(nova.NovaClientPlugin,
'find_flavor_by_name_or_id')
mock_fl.return_value = 'flavor-ref'
def setUp(self):
super(RollingUpdatesTest, self).setUp()
utils.setup_dummy_db()
resource._register_class('ResourceWithProps',
generic_resource.ResourceWithProps)
cfg.CONF.set_default('heat_waitcondition_server_url',
'http://server.test:8000/v1/waitcondition')
self.fc = fakes.FakeKeystoneClient()
client = self.patchobject(clients.OpenStackClients, "keystone")
client.return_value = self.fc
self.parsed = template_format.parse(self.as_template)
generate_id = self.patchobject(short_id, 'generate_id')
generate_id.side_effect = ('id-%d' % (i,)
for i in itertools.count()).next
def setUp(self):
super(SignalTest, self).setUp()
utils.setup_dummy_db()
resource._register_class('SignalResourceType',
generic_resource.SignalResource)
resource._register_class('GenericResourceType',
generic_resource.GenericResource)
cfg.CONF.set_default('heat_waitcondition_server_url',
'http://127.0.0.1:8000/v1/waitcondition')
self.stack_id = 'STACKABCD1234'
self.fc = fakes.FakeKeystoneClient()
def test_attributes_not_parsable(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Outputs': {
'Foo': {
'Value': 'bar'
},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load(
{'resource_registry': {
'DummyResource': 'test_resource.template'
}})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(empty_template,
files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource")
temp_res = template_resource.TemplateResource('test_t_res', definition,
stack)
temp_res.resource_id = 'dummy_id'
temp_res.nested_identifier = mock.Mock()
temp_res.nested_identifier.return_value = {'foo': 'bar'}
temp_res._rpc_client = mock.MagicMock()
output = {
'outputs': [{
'output_key': 'Foo',
'output_value': None,
'output_error': 'it is all bad'
}]
}
temp_res._rpc_client.show_stack.return_value = [output]
temp_res._rpc_client.list_stack_resources.return_value = []
self.assertIsNone(temp_res.validate())
self.assertRaises(exception.TemplateOutputError, temp_res.FnGetAtt,
'Foo')
def setUp(self):
super(TestGroupCrud, self).setUp()
resource._register_class('ResourceWithPropsAndAttrs',
generic_resource.ResourceWithPropsAndAttrs)
cfg.CONF.set_default('heat_waitcondition_server_url',
'http://server.test:8000/v1/waitcondition')
self.stub_keystoneclient()
self.stub_ImageConstraint_validate()
self.stub_FlavorConstraint_validate()
self.stub_SnapshotConstraint_validate()
t = template_format.parse(inline_templates.as_heat_template)
stack = utils.parse_stack(t, params=inline_templates.as_params)
self.group = stack['my-group']
self.assertIsNone(self.group.validate())
def setUp(self):
super(TestMagnumBayModel, self).setUp()
self.ctx = utils.dummy_context()
resource._register_class(RESOURCE_TYPE, baymodel.BayModel)
t = template_format.parse(self.magnum_template)
self.stack = utils.parse_stack(t)
resource_defns = self.stack.t.resource_definitions(self.stack)
self.rsrc_defn = resource_defns['test_baymodel']
self.client = mock.Mock()
self.patchobject(baymodel.BayModel, 'client', return_value=self.client)
self.stub_FlavorConstraint_validate()
self.stub_KeypairConstraint_validate()
self.stub_ImageConstraint_validate()
self.stub_NetworkConstraint_validate()
def setUp(self):
self.username = '******'
self.m = mox.Mox()
self.ctx = context.get_admin_context()
self.m.StubOutWithMock(self.ctx, 'username')
self.ctx.username = self.username
self.ctx.tenant_id = 'test_tenant'
generic_rsrc.GenericResource.properties_schema = {}
resource._register_class('GenericResourceType',
generic_rsrc.GenericResource)
self.m.ReplayAll()
def setUp(self):
super(KeystoneRoleAssignmentMixinTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider explicitly.
resource._register_class(RESOURCE_TYPE, DummyRoleAssignment)
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone',
template.Template(keystone_role_assignment_template))
self.test_role_assignment = self.stack['test_role_assignment']
# Mock client
self.keystoneclient = mock.MagicMock()
self.test_role_assignment.client = mock.MagicMock()
self.test_role_assignment.client.return_value = self.keystoneclient
self.roles = self.keystoneclient.roles
# Mock client plugin
def _side_effect(value):
return value
self.keystone_client_plugin = mock.MagicMock()
(self.keystone_client_plugin.get_domain_id.side_effect) = _side_effect
(self.keystone_client_plugin.get_role_id.side_effect) = _side_effect
(self.keystone_client_plugin.get_project_id.side_effect) = _side_effect
self.test_role_assignment.client_plugin = mock.MagicMock()
(self.test_role_assignment.client_plugin.return_value
) = self.keystone_client_plugin
self.parse_assgmnts = self.test_role_assignment.parse_list_assignments
self.test_role_assignment.parse_list_assignments = mock.MagicMock()
self.test_role_assignment.parse_list_assignments.return_value = [{
'role':
'role_1',
'domain':
'domain_1',
'project':
None
}, {
'role':
'role_1',
'project':
'project_1',
'domain':
None
}]
def setUp(self):
super(StackResourceAttrTest, self).setUp()
resource._register_class('some_magic_type',
MyStackResource)
ws_resname = "provider_resource"
t = templatem.Template(
{'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {ws_resname: ws_res_snippet}})
self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack',
t, stack_id=str(uuid.uuid4()),
user_creds_id='uc123',
stack_user_project_id='aprojectid')
resource_defns = t.resource_definitions(self.parent_stack)
self.parent_resource = MyStackResource('test',
resource_defns[ws_resname],
self.parent_stack)
def setUp(self):
super(StackResourceTest, self).setUp()
resource._register_class('some_magic_type',
MyStackResource)
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
t = parser.Template({'HeatTemplateFormatVersion': '2012-12-12',
'Resources':
{"provider_resource": ws_res_snippet}})
self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack',
t, stack_id=str(uuid.uuid4()))
self.parent_resource = MyStackResource('test',
ws_res_snippet,
self.parent_stack)
self.templ = template_format.parse(param_template)
self.simple_template = template_format.parse(simple_template)
def setUp(self):
super(FormatTest, self).setUp()
utils.setup_dummy_db()
template = parser.Template({
'Resources': {
'generic1': {'Type': 'GenericResourceType'},
'generic2': {
'Type': 'GenericResourceType',
'DependsOn': 'generic1'}
}
})
resource._register_class('GenericResourceType',
generic_rsrc.GenericResource)
self.stack = parser.Stack(utils.dummy_context(), 'test_stack',
template, stack_id=str(uuid.uuid4()))
def setUp(self):
super(KeystoneRoleTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider explicitly.
resource._register_class(RESOURCE_TYPE, KeystoneRole)
self.stack = parser.Stack(self.ctx, 'test_stack_keystone',
template.Template(keystone_role_template))
self.test_role = self.stack['test_role']
self.keystoneclient = mock.MagicMock()
self.test_role.keystone = mock.MagicMock()
self.test_role.keystone.return_value = self.keystoneclient
self.roles = self.keystoneclient.client.roles
def test_attributes_not_parsable(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Outputs': {
'Foo': {
'Value': 'bar'
},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {}
attributes_schema = {"Foo": attributes.Schema("A test attribute")}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load(
{'resource_registry': {
'DummyResource': 'test_resource.template'
}})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(empty_template,
files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource")
temp_res = template_resource.TemplateResource('test_t_res', definition,
stack)
self.assertIsNone(temp_res.validate())
nested = mock.Mock()
nested.outputs = {
'Foo': {
'Value': 'not-this',
'error_msg': 'it is all bad'
}
}
nested.output.return_value = None
temp_res._nested = nested
self.assertRaises(exception.InvalidTemplateAttribute,
temp_res.FnGetAtt, 'Foo')
def test_resource_info_special(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {
'Type': 'Boolean'
},
},
}
files = {
'test_resource.template': json.dumps(provider),
'foo.template': json.dumps(provider)
}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {
"Foo": properties.Schema(properties.Schema.BOOLEAN)
}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load({
'resource_registry': {
'DummyResource': 'test_resource.template',
'resources': {
'foo': {
'DummyResource': 'foo.template'
}
}
}
})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('foo', 'DummyResource',
{"Foo": "False"})
temp_res = template_resource.TemplateResource('foo', definition, stack)
self.assertEqual('foo.template', temp_res.template_name)
def setUp(self):
super(RackspaceDnsTest, self).setUp()
# Test environment may not have pyrax client library installed and if
# pyrax is not installed resource class would not be registered.
# So register resource provider class explicitly for unit testing.
resource._register_class("Rackspace::Cloud::DNS", cloud_dns.CloudDns)
self.create_domain_only_args = {
"name": 'dnsheatunittest.com',
"emailAddress": '*****@*****.**',
"ttl": 3600,
"comment": 'Testing Cloud DNS integration with Heat',
"records": None
}
self.update_domain_only_args = {
"emailAddress": '*****@*****.**',
"ttl": 5555,
"comment": 'updated comment'
}
def setUp(self):
super(TestMagnumClusterTemplate, self).setUp()
resource._register_class(RESOURCE_TYPE,
cluster_template.ClusterTemplate)
self.t = template_format.parse(self.magnum_template)
self.stack = utils.parse_stack(self.t)
resource_defns = self.stack.t.resource_definitions(self.stack)
self.rsrc_defn = resource_defns['test_cluster_template']
self.client = mock.Mock()
self.patchobject(cluster_template.ClusterTemplate,
'client',
return_value=self.client)
self.stub_FlavorConstraint_validate()
self.stub_KeypairConstraint_validate()
self.stub_ImageConstraint_validate()
self.stub_NetworkConstraint_validate()
self.stub_SubnetConstraint_validate()
def setUp(self):
super(FormatTest, self).setUp()
template = parser.Template({
'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {
'generic1': {'Type': 'GenericResourceType'},
'generic2': {
'Type': 'GenericResourceType',
'DependsOn': 'generic1'}
}
})
resource._register_class('GenericResourceType',
generic_rsrc.GenericResource)
resource._register_class('ResWithComplexPropsAndAttrs',
generic_rsrc.ResWithComplexPropsAndAttrs)
self.stack = parser.Stack(utils.dummy_context(), 'test_stack',
template, stack_id=str(uuid.uuid4()))
def setUp(self):
super(NovaFlavorTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider
# explicitly.
resource._register_class("OS::Nova::Flavor", nova_flavor.NovaFlavor)
self.stack = parser.Stack(self.ctx, 'nova_flavor_test_stack',
template.Template(flavor_template))
self.my_flavor = self.stack['my_flavor']
nova = mock.MagicMock()
self.novaclient = mock.MagicMock()
self.my_flavor.nova = nova
nova.return_value = self.novaclient
self.flavors = self.novaclient.flavors
def setUp(self):
super(EventTest, self).setUp()
self.username = '******'
self.ctx = utils.dummy_context()
self.m.ReplayAll()
resource._register_class('ResourceWithRequiredProps',
generic_rsrc.ResourceWithRequiredProps)
self.stack = parser.Stack(self.ctx, 'event_load_test_stack',
template.Template(tmpl))
self.stack.store()
self.resource = self.stack['EventTestResource']
self.resource._store()
self.addCleanup(db_api.stack_delete, self.ctx, self.stack.id)
def setUp(self):
super(CinderVolumeTypeTest, self).setUp()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider
# explicitly.
resource._register_class('OS::Cinder::VolumeType', CinderVolumeType)
self.stack = stack.Stack(self.ctx, 'cinder_volume_type_test_stack',
template.Template(volume_type_template))
self.my_volume_type = self.stack['my_volume_type']
cinder = mock.MagicMock()
self.cinderclient = mock.MagicMock()
self.my_volume_type.cinder = cinder
cinder.return_value = self.cinderclient
self.volume_types = self.cinderclient.volume_types
def setUp(self):
super(StackResourceTest, self).setUp()
utils.setup_dummy_db()
resource._register_class('some_magic_type', MyStackResource)
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
t = parser.Template(
{template.RESOURCES: {
"provider_resource": ws_res_snippet
}})
self.parent_stack = parser.Stack(utils.dummy_context(),
'test_stack',
t,
stack_id=uuidutils.generate_uuid())
self.parent_resource = MyStackResource('test', ws_res_snippet,
self.parent_stack)
self.templ = template_format.parse(param_template)
self.simple_template = template_format.parse(simple_template)
def test_properties_list_with_none(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {
'Type': "CommaDelimitedList"
},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {
"Foo": properties.Schema(properties.Schema.LIST)
}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load(
{'resource_registry': {
'DummyResource': 'test_resource.template'
}})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition(
'test_t_res', "DummyResource", {"Foo": [None, 'test', None]})
temp_res = template_resource.TemplateResource('test_t_res', definition,
stack)
self.assertIsNone(temp_res.validate())
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": [None, None, None]})
temp_res = template_resource.TemplateResource('test_t_res', definition,
stack)
self.assertIsNone(temp_res.validate())
def test_properties_normal(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {
'Type': 'String'
},
'Blarg': {
'Type': 'String',
'Default': 'wibble'
},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
properties_schema = {
"Foo": properties.Schema(properties.Schema.STRING,
required=True)
}
attributes_schema = {}
json_snippet = {
"Type": "DummyResource",
"Properties": {
"Foo": "bar",
},
}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load(
{'resource_registry': {
'DummyResource': 'test_resource.template'
}})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
parser.Template(empty_template, files=files),
env=env,
stack_id=str(uuid.uuid4()))
temp_res = template_resource.TemplateResource('test_t_res',
json_snippet, stack)
self.assertIsNone(temp_res.validate())
def setUp(self):
super(GlanceImageTest, self).setUp()
utils.setup_dummy_db()
self.ctx = utils.dummy_context()
# For unit testing purpose. Register resource provider
# explicitly.
resource._register_class("OS::Glance::Image", gi.GlanceImage)
tpl = template_format.parse(image_template)
self.stack = parser.Stack(self.ctx, 'glance_image_test_stack',
parser.Template(tpl))
self.my_image = self.stack['my_image']
glance = mock.MagicMock()
self.glanceclient = mock.MagicMock()
self.my_image.glance = glance
glance.return_value = self.glanceclient
self.images = self.glanceclient.images
def setUp(self):
super(ResourceTest, self).setUp()
utils.setup_dummy_db()
resource._register_class('GenericResourceType',
generic_rsrc.GenericResource)
env = environment.Environment()
env.load({
u'resource_registry': {
u'OS::Test::GenericResource': u'GenericResourceType'
}
})
self.stack = parser.Stack(utils.dummy_context(),
'test_stack',
parser.Template({}),
env=env,
stack_id=uuidutils.generate_uuid())
def test_properties_type_mismatch(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {
'Type': 'String'
},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(generic_rsrc.GenericResource):
support_status = support.SupportStatus()
properties_schema = {
"Foo": properties.Schema(properties.Schema.MAP)
}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load(
{'resource_registry': {
'DummyResource': 'test_resource.template'
}})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(
{'HeatTemplateFormatVersion': '2012-12-12'},
files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
temp_res = template_resource.TemplateResource('test_t_res', definition,
stack)
ex = self.assertRaises(exception.StackValidationFailed,
temp_res.validate)
self.assertEqual(
"Property Foo type mismatch between facade "
"DummyResource (Map) and provider (String)", six.text_type(ex))
def test_nested_stack_adopt(self):
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
urlfetch.get('https://server.test/the.template'
).MultipleTimes().AndReturn(
'''
HeatTemplateFormatVersion: '2012-12-12'
Parameters:
KeyName:
Type: String
Resources:
NestedResource:
Type: GenericResource
Outputs:
Foo:
Value: bar
''')
self.m.ReplayAll()
adopt_data = {
"resources": {
"the_nested": {
"resource_id": "test-res-id",
"resources": {
"NestedResource": {
"resource_id": "test-nested-res-id"
}
}
}
}
}
stack = self.adopt_stack(self.test_template, adopt_data)
self.assertEqual((stack.ADOPT, stack.COMPLETE), stack.state)
rsrc = stack['the_nested']
self.assertEqual((rsrc.ADOPT, rsrc.COMPLETE), rsrc.state)
nested_name = utils.PhysName(stack.name, 'the_nested')
self.assertEqual(nested_name, rsrc.physical_resource_name())
self.assertEqual('test-nested-res-id',
rsrc.nested()['NestedResource'].resource_id)
rsrc.delete()
self.m.VerifyAll()
def test_properties_normal(self):
provider = {
'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {
'Foo': {
'Type': 'String'
},
'Blarg': {
'Type': 'String',
'Default': 'wibble'
},
},
}
files = {'test_resource.template': json.dumps(provider)}
class DummyResource(object):
support_status = support.SupportStatus()
properties_schema = {
"Foo": properties.Schema(properties.Schema.STRING,
required=True)
}
attributes_schema = {}
env = environment.Environment()
resource._register_class('DummyResource', DummyResource)
env.load(
{'resource_registry': {
'DummyResource': 'test_resource.template'
}})
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(empty_template,
files=files,
env=env),
stack_id=str(uuid.uuid4()))
definition = rsrc_defn.ResourceDefinition('test_t_res',
"DummyResource",
{"Foo": "bar"})
temp_res = template_resource.TemplateResource('test_t_res', definition,
stack)
self.assertIsNone(temp_res.validate())
def setUp(self):
super(ReplaceTest, self).setUp()
resource._register_class('ResourceWithPropsAndAttrs',
generic_resource.ResourceWithPropsAndAttrs)
t = template_format.parse(inline_templates.as_template)
self.stack = utils.parse_stack(t, params=inline_templates.as_params)
lc = self.create_launch_config(t, self.stack)
lcid = lc.FnGetRefId()
self.defn = rsrc_defn.ResourceDefinition(
'asg', 'OS::Heat::InstanceGroup', {
'Size': 2,
'AvailabilityZones': ['zoneb'],
'LaunchConfigurationName': lcid
})
self.group = instgrp.InstanceGroup('asg', self.defn, self.stack)
self.group._lb_reload = mock.Mock()
self.group.update_with_template = mock.Mock()
self.group.check_update_complete = mock.Mock()
self.group._nested = self.get_fake_nested_stack()
