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.
 
 
 
 

4526 lines
194 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 collections
import datetime
import eventlet
import itertools
import json
import os
import sys
import uuid
import mock
from oslo_config import cfg
import six
from heat.common import exception
from heat.common.i18n import _
from heat.common import short_id
from heat.common import timeutils
from heat.db.sqlalchemy import api as db_api
from heat.db.sqlalchemy import models
from heat.engine import attributes
from heat.engine.cfn import functions as cfn_funcs
from heat.engine import clients
from heat.engine import constraints
from heat.engine import dependencies
from heat.engine import environment
from heat.engine import node_data
from heat.engine import plugin_manager
from heat.engine import properties
from heat.engine import resource
from heat.engine import resources
from heat.engine.resources.openstack.heat import none_resource
from heat.engine.resources.openstack.heat import test_resource
from heat.engine import rsrc_defn
from heat.engine import scheduler
from heat.engine import stack as parser
from heat.engine import support
from heat.engine import template
from heat.engine import translation
from heat.objects import resource as resource_objects
from heat.objects import resource_data as resource_data_object
from heat.objects import resource_properties_data as rpd_object
from heat.tests import common
from heat.tests.engine import tools
from heat.tests import generic_resource as generic_rsrc
from heat.tests import utils
import neutronclient.common.exceptions as neutron_exp
empty_template = {"HeatTemplateFormatVersion": "2012-12-12"}
class ResourceTest(common.HeatTestCase):
def setUp(self):
super(ResourceTest, self).setUp()
self.env = environment.Environment()
self.env.load({u'resource_registry':
{u'OS::Test::GenericResource': u'GenericResourceType',
u'OS::Test::ResourceWithCustomConstraint':
u'ResourceWithCustomConstraint'}})
self.stack = parser.Stack(utils.dummy_context(), 'test_stack',
template.Template(empty_template,
env=self.env),
stack_id=str(uuid.uuid4()))
self.dummy_timeout = 10
self.dummy_event = eventlet.event.Event()
def test_get_class_ok(self):
cls = resources.global_env().get_class_to_instantiate(
'GenericResourceType')
self.assertEqual(generic_rsrc.GenericResource, cls)
def test_get_class_noexist(self):
self.assertRaises(exception.StackValidationFailed,
resources.global_env().get_class_to_instantiate,
'NoExistResourceType')
def test_resource_new_ok(self):
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
res = resource.Resource('aresource', snippet, self.stack)
self.assertIsInstance(res, generic_rsrc.GenericResource)
self.assertEqual("INIT", res.action)
def test_resource_load_with_state(self):
self.stack = parser.Stack(utils.dummy_context(), 'test_stack',
template.Template(empty_template))
self.stack.store()
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
# Store Resource
res = resource.Resource('aresource', snippet, self.stack)
res.current_template_id = self.stack.t.id
res.state_set('CREATE', 'IN_PROGRESS')
self.stack.add_resource(res)
loaded_res, res_owning_stack, stack = resource.Resource.load(
self.stack.context, res.id,
self.stack.current_traversal, True, {})
self.assertEqual(loaded_res.id, res.id)
self.assertEqual(self.stack.t, stack.t)
def test_resource_load_with_state_cleanup(self):
self.old_stack = parser.Stack(
utils.dummy_context(), 'test_old_stack',
template.Template({
'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {
'test_res': {'Type': 'ResourceWithPropsType',
'Properties': {'Foo': 'abc'}}}}))
self.old_stack.store()
self.new_stack = parser.Stack(utils.dummy_context(), 'test_new_stack',
template.Template(empty_template))
self.new_stack.store()
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
# Store Resource
res = resource.Resource('aresource', snippet, self.old_stack)
res.current_template_id = self.old_stack.t.id
res.state_set('CREATE', 'IN_PROGRESS')
self.old_stack.add_resource(res)
loaded_res, res_owning_stack, stack = resource.Resource.load(
self.old_stack.context, res.id,
self.stack.current_traversal, False, {})
self.assertEqual(loaded_res.id, res.id)
self.assertEqual(self.old_stack.t, stack.t)
self.assertNotEqual(self.new_stack.t, stack.t)
def test_resource_load_with_no_resources(self):
self.stack = parser.Stack(
utils.dummy_context(), 'test_old_stack',
template.Template({
'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {
'test_res': {'Type': 'ResourceWithPropsType',
'Properties': {'Foo': 'abc'}}}}))
self.stack.store()
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
# Store Resource
res = resource.Resource('aresource', snippet, self.stack)
res.current_template_id = self.stack.t.id
res.state_set('CREATE', 'IN_PROGRESS')
self.stack.add_resource(res)
origin_resources = self.stack.resources
self.stack._resources = None
loaded_res, res_owning_stack, stack = resource.Resource.load(
self.stack.context, res.id,
self.stack.current_traversal, False, {})
self.assertEqual(origin_resources, stack.resources)
self.assertEqual(loaded_res.id, res.id)
self.assertEqual(self.stack.t, stack.t)
def test_resource_invalid_name(self):
snippet = rsrc_defn.ResourceDefinition('wrong/name',
'GenericResourceType')
ex = self.assertRaises(exception.StackValidationFailed,
resource.Resource, 'wrong/name',
snippet, self.stack)
self.assertEqual('Resource name may not contain "/"',
six.text_type(ex))
@mock.patch.object(translation, 'resolve_and_find')
@mock.patch.object(parser.Stack, 'db_resource_get')
@mock.patch.object(resource.Resource, '_load_data')
@mock.patch.object(resource.Resource, 'translate_properties')
def test_stack_resources(self, mock_translate, mock_load,
mock_db_get, mock_resolve):
tpl = {'HeatTemplateFormatVersion': '2012-12-12',
'Resources':
{'A': {'Type': 'ResourceWithPropsType',
'Properties': {'Foo': 'abc'}}}}
stack = parser.Stack(utils.dummy_context(),
'test_stack',
template.Template(tpl))
stack.store()
mock_db_get.return_value = None
self.assertEqual(1, len(stack.resources))
self.assertEqual(1, mock_translate.call_count)
self.assertEqual(0, mock_load.call_count)
# set stack._resources = None to reload the resources
stack._resources = None
mock_db_get.return_value = mock.Mock()
self.assertEqual(1, len(stack.resources))
self.assertEqual(2, mock_translate.call_count)
self.assertEqual(1, mock_load.call_count)
self.assertEqual(0, mock_resolve.call_count)
def test_resource_new_stack_not_stored(self):
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
self.stack.id = None
db_method = 'get_by_name_and_stack'
with mock.patch.object(resource_objects.Resource,
db_method) as resource_get:
res = resource.Resource('aresource', snippet, self.stack)
self.assertEqual("INIT", res.action)
self.assertIs(False, resource_get.called)
def test_resource_new_err(self):
snippet = rsrc_defn.ResourceDefinition('aresource',
'NoExistResourceType')
self.assertRaises(exception.StackValidationFailed,
resource.Resource, 'aresource', snippet, self.stack)
def test_resource_non_type(self):
resource_name = 'aresource'
snippet = rsrc_defn.ResourceDefinition(resource_name, '')
ex = self.assertRaises(exception.StackValidationFailed,
resource.Resource, resource_name,
snippet, self.stack)
self.assertIn(_('Resource "%s" has no type') % resource_name,
six.text_type(ex))
def test_state_defaults(self):
tmpl = rsrc_defn.ResourceDefinition('test_res_def', 'Foo')
res = generic_rsrc.GenericResource('test_res_def', tmpl, self.stack)
self.assertEqual((res.INIT, res.COMPLETE), res.state)
self.assertEqual('', res.status_reason)
def test_signal_wrong_action_state(self):
snippet = rsrc_defn.ResourceDefinition('res',
'GenericResourceType')
res = resource.Resource('res', snippet, self.stack)
actions = [res.SUSPEND, res.DELETE]
for action in actions:
for status in res.STATUSES:
res.state_set(action, status)
ev = self.patchobject(res, '_add_event')
ex = self.assertRaises(exception.NotSupported,
res.signal)
self.assertEqual('Signal resource during %s is not '
'supported.' % action, six.text_type(ex))
ev.assert_called_with(
action, status,
'Cannot signal resource during %s' % action)
def test_resource_str_repr_stack_id_resource_id(self):
tmpl = rsrc_defn.ResourceDefinition('test_res_str_repr', 'Foo')
res = generic_rsrc.GenericResource('test_res_str_repr', tmpl,
self.stack)
res.stack.id = "123"
res.resource_id = "456"
expected = ('GenericResource "test_res_str_repr" [456] Stack '
'"test_stack" [123]')
observed = str(res)
self.assertEqual(expected, observed)
def test_resource_str_repr_stack_id_no_resource_id(self):
tmpl = rsrc_defn.ResourceDefinition('test_res_str_repr', 'Foo')
res = generic_rsrc.GenericResource('test_res_str_repr', tmpl,
self.stack)
res.stack.id = "123"
res.resource_id = None
expected = ('GenericResource "test_res_str_repr" Stack "test_stack" '
'[123]')
observed = str(res)
self.assertEqual(expected, observed)
def test_resource_str_repr_no_stack_id(self):
tmpl = rsrc_defn.ResourceDefinition('test_res_str_repr', 'Foo')
res = generic_rsrc.GenericResource('test_res_str_repr', tmpl,
self.stack)
res.stack.id = None
expected = ('GenericResource "test_res_str_repr"')
observed = str(res)
self.assertEqual(expected, observed)
def test_state_set(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_state_set')
self.assertIsNotNone(res.id)
self.assertEqual(res.CREATE, res.action)
self.assertEqual(res.IN_PROGRESS, res.status)
self.assertEqual('test_state_set', res.status_reason)
db_res = resource_objects.Resource.get_obj(res.context, res.id)
self.assertEqual(res.CREATE, db_res.action)
self.assertEqual(res.IN_PROGRESS, db_res.status)
self.assertEqual('test_state_set', db_res.status_reason)
res.state_set(res.CREATE, res.COMPLETE, 'test_update')
self.assertEqual(res.CREATE, res.action)
self.assertEqual(res.COMPLETE, res.status)
self.assertEqual('test_update', res.status_reason)
db_res.refresh()
self.assertEqual(res.CREATE, db_res.action)
self.assertEqual(res.COMPLETE, db_res.status)
self.assertEqual('test_update', db_res.status_reason)
def test_physical_resource_name_or_FnGetRefId(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
# use physical_resource_name when res.id is not None
self.assertIsNotNone(res.id)
expected = '%s-%s-%s' % (self.stack.name,
res.name,
short_id.get_id(res.uuid))
self.assertEqual(expected, res.physical_resource_name_or_FnGetRefId())
# otherwise use parent method
res.id = None
self.assertIsNone(res.resource_id)
self.assertEqual('test_resource',
res.physical_resource_name_or_FnGetRefId())
def test_prepare_abandon(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
expected = {
'action': 'INIT',
'metadata': {},
'name': 'test_resource',
'resource_data': {},
'resource_id': None,
'status': 'COMPLETE',
'type': 'Foo'
}
actual = res.prepare_abandon()
self.assertEqual(expected, actual)
def test_abandon_with_resource_data(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res._data = {"test-key": "test-value"}
expected = {
'action': 'INIT',
'metadata': {},
'name': 'test_resource',
'resource_data': {"test-key": "test-value"},
'resource_id': None,
'status': 'COMPLETE',
'type': 'Foo'
}
actual = res.prepare_abandon()
self.assertEqual(expected, actual)
def test_create_from_external(self):
tmpl = rsrc_defn.ResourceDefinition(
'test_resource', 'GenericResourceType',
external_id='f00d')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CHECK, res.COMPLETE), res.state)
self.assertEqual('f00d', res.resource_id)
def test_create_from_external_with_check(self):
tmpl = rsrc_defn.ResourceDefinition(
'test_resource', 'GenericResourceType',
external_id='f00d')
res = generic_rsrc.CheckableResource('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CHECK, res.COMPLETE), res.state)
self.assertEqual('f00d', res.resource_id)
def test_create_from_external_not_found(self):
external_id = 'f00d'
tmpl = rsrc_defn.ResourceDefinition(
'test_resource', 'GenericResourceType',
external_id=external_id)
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res._default_client_plugin = mock.Mock()
self.patchobject(res._default_client_plugin(), 'is_not_found',
return_value=True)
self.patchobject(res, '_show_resource', side_effect=Exception())
e = self.assertRaises(exception.StackValidationFailed,
res.validate_external)
message = (("Invalid external resource: Resource %(external_id)s "
"(%(type)s) can not be found.") %
{'external_id': external_id,
'type': res.type()})
self.assertEqual(message, six.text_type(e))
def test_updated_from_external(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType')
utmpl = rsrc_defn.ResourceDefinition(
'test_resource', 'GenericResourceType',
external_id='f00d')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
expected_err_msg = ('NotSupported: resources.test_resource: Update '
'to property external_id of test_resource '
'(GenericResourceType) is not supported.')
err = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(res.update, utmpl)
)
self.assertEqual(expected_err_msg, six.text_type(err))
def test_state_set_invalid(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertRaises(ValueError, res.state_set, 'foo', 'bla')
self.assertRaises(ValueError, res.state_set, 'foo', res.COMPLETE)
self.assertRaises(ValueError, res.state_set, res.CREATE, 'bla')
def test_state_del_stack(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
self.stack.action = self.stack.DELETE
self.stack.status = self.stack.IN_PROGRESS
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual(res.DELETE, res.action)
self.assertEqual(res.COMPLETE, res.status)
def test_type(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual('Foo', res.type())
def test_has_interface_direct_match(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertTrue(res.has_interface('GenericResourceType'))
def test_has_interface_no_match(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertFalse(res.has_interface('LookingForAnotherType'))
def test_has_interface_mapping(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'OS::Test::GenericResource')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertTrue(res.has_interface('GenericResourceType'))
def test_has_interface_mapping_no_match(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'OS::Test::GenoricResort')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertFalse(res.has_interface('GenericResourceType'))
def test_created_time(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_res_new', tmpl, self.stack)
self.assertIsNone(res.created_time)
res.store()
self.assertIsNotNone(res.created_time)
def test_updated_time(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.store()
stored_time = res.updated_time
utmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res.state_set(res.CREATE, res.COMPLETE)
scheduler.TaskRunner(res.update, utmpl)()
self.assertIsNotNone(res.updated_time)
self.assertNotEqual(res.updated_time, stored_time)
def _setup_resource_for_update(self, res_name):
class TestResource(resource.Resource):
properties_schema = {'a_string': {'Type': 'String'}}
update_allowed_properties = ('a_string',)
resource._register_class('TestResource', TestResource)
tmpl = rsrc_defn.ResourceDefinition(res_name,
'TestResource')
res = TestResource('test_resource', tmpl, self.stack)
utmpl = rsrc_defn.ResourceDefinition(res_name, 'TestResource',
{'a_string': 'foo'})
return res, utmpl
def test_update_replace(self):
res, utmpl = self._setup_resource_for_update(
res_name='test_update_replace')
self.assertEqual((res.INIT, res.COMPLETE), res.state)
res.prepare_for_replace = mock.Mock()
# resource replaced if in INIT_COMPLETE
self.assertRaises(
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl))
self.assertTrue(res.prepare_for_replace.called)
def test_update_replace_in_check_failed(self):
res, utmpl = self._setup_resource_for_update(
res_name='test_update_replace')
res.state_set(res.CHECK, res.FAILED)
res.prepare_for_replace = mock.Mock()
res.needs_replace_failed = mock.MagicMock(return_value=False)
self.assertRaises(
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl))
self.assertFalse(res.needs_replace_failed.called)
self.assertTrue(res.prepare_for_replace.called)
def test_no_update_or_replace_in_failed(self):
res, utmpl = self._setup_resource_for_update(
res_name='test_failed_res_no_update_or_replace')
res.state_set(res.CREATE, res.FAILED)
res.prepare_for_replace = mock.Mock()
res.needs_replace_failed = mock.MagicMock(return_value=False)
scheduler.TaskRunner(res.update, res.t)()
self.assertTrue(res.needs_replace_failed.called)
self.assertFalse(res.prepare_for_replace.called)
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
status_reason = _('Update status to COMPLETE for '
'FAILED resource neither update '
'nor replace.')
self.assertEqual(status_reason, res.status_reason)
def test_update_replace_prepare_replace_error(self):
# test if any error happened when prepare_for_replace,
# whether the resource will go to FAILED
res, utmpl = self._setup_resource_for_update(
res_name='test_update_replace_prepare_replace_error')
res.prepare_for_replace = mock.Mock(side_effect=Exception)
self.assertRaises(
exception.ResourceFailure,
scheduler.TaskRunner(res.update, utmpl))
self.assertTrue(res.prepare_for_replace.called)
self.assertEqual((res.UPDATE, res.FAILED), res.state)
def test_update_rsrc_in_progress_raises_exception(self):
res, utmpl = self._setup_resource_for_update(
res_name='test_update_rsrc_in_progress_raises_exception')
cfg.CONF.set_override('convergence_engine', False)
res.action = res.UPDATE
res.status = res.IN_PROGRESS
self.assertRaises(
exception.ResourceFailure, scheduler.TaskRunner(res.update, utmpl))
def test_update_replace_rollback(self):
cfg.CONF.set_override('convergence_engine', False)
res, utmpl = self._setup_resource_for_update(
res_name='test_update_replace_rollback')
res.restore_prev_rsrc = mock.Mock()
self.stack.state_set('ROLLBACK', 'IN_PROGRESS', 'Simulate rollback')
self.assertRaises(
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl))
self.assertTrue(res.restore_prev_rsrc.called)
def test_update_replace_rollback_restore_prev_rsrc_error(self):
cfg.CONF.set_override('convergence_engine', False)
res, utmpl = self._setup_resource_for_update(
res_name='restore_prev_rsrc_error')
res.restore_prev_rsrc = mock.Mock(side_effect=Exception)
self.stack.state_set('ROLLBACK', 'IN_PROGRESS', 'Simulate rollback')
self.assertRaises(
exception.ResourceFailure, scheduler.TaskRunner(res.update, utmpl))
self.assertTrue(res.restore_prev_rsrc.called)
self.assertEqual((res.UPDATE, res.FAILED), res.state)
def test_update_replace_in_failed_without_nested(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
m_hc = mock.Mock(side_effect=exception.ResourceFailure)
res.handle_create = m_hc
self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(res.create))
self.assertEqual((res.CREATE, res.FAILED), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'xyz'})
# resource in failed status and hasn't nested will enter
# UpdateReplace flow
self.assertRaises(
resource.UpdateReplace, scheduler.TaskRunner(res.update, utmpl))
m_hc.assert_called_once_with()
def test_updated_time_changes_only_when_it_changed(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.store()
self.assertIsNone(res.updated_time)
res.updated_time = datetime.datetime.utcnow()
res.store()
self.assertIsNotNone(res.updated_time)
def test_resource_object_get_obj_fields(self):
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
res = resource.Resource('aresource', snippet, self.stack)
res.store()
res_obj = resource_objects.Resource.get_obj(
res.context, res.id, refresh=False, fields=('status', ))
self.assertEqual(res_obj.status, res.COMPLETE)
self.assertRaises(AttributeError, getattr, res_obj, 'action')
def test_attributes_store(self):
res_def = rsrc_defn.ResourceDefinition('test_resource',
'ResWithStringPropAndAttr')
res = generic_rsrc.ResWithStringPropAndAttr(
'test_res_attr_store', res_def, self.stack)
res.action = res.CREATE
res.status = res.COMPLETE
res.store()
res.store_attributes()
# attr was not resolved, cache was not warmed, nothing to store
self.assertIsNone(res._attr_data_id)
with mock.patch.object(res, '_resolve_attribute') as res_attr:
attr_val = '0123 four'
res_attr.return_value = attr_val
res.attributes['string']
# attr cache is warmed, now store_attributes persists something
res.store_attributes()
self.assertIsNotNone(res._attr_data_id)
# verify the attribute rpd obj that was stored matches
self.assertEqual({'string': attr_val},
rpd_object.ResourcePropertiesData.get_by_id(
res.context, res._attr_data_id).data)
def test_attributes_load_stored(self):
res_def = rsrc_defn.ResourceDefinition('test_resource',
'ResWithStringPropAndAttr')
res = generic_rsrc.ResWithStringPropAndAttr(
'test_res_attr_store', res_def, self.stack)
res.action = res.UPDATE
res.status = res.COMPLETE
res.store()
attr_data = {'string': 'word'}
resource_objects.Resource.store_attributes(
res.context, res.id, res._atomic_key, attr_data, None)
res._load_data(resource_objects.Resource.get_obj(
res.context, res.id))
with mock.patch.object(res, '_resolve_attribute') as res_attr:
self.assertEqual(attr_data, res.attributes._resolved_values)
self.assertEqual('word', res.attributes['string'])
self.assertEqual(0, res_attr.call_count)
def test_store_attributes_fail(self):
res_def = rsrc_defn.ResourceDefinition('test_resource',
'ResWithStringPropAndAttr')
res = generic_rsrc.ResWithStringPropAndAttr(
'test_res_attr_store', res_def, self.stack)
res.action = res.UPDATE
res.status = res.COMPLETE
res.store()
attr_data = {'string': 'word'}
# set the attr_data_id first
resource_objects.Resource.update_by_id(res.context, res.id,
{'attr_data_id': 99})
new_attr_data_id = resource_objects.Resource.store_attributes(
res.context, res.id, res._atomic_key, attr_data, None)
# fail to store new attr data
self.assertIsNone(new_attr_data_id)
res._load_data(resource_objects.Resource.get_obj(
res.context, res.id))
self.assertEqual({}, res.attributes._resolved_values)
def test_resource_object_resource_properties_data(self):
cfg.CONF.set_override('encrypt_parameters_and_properties', True)
data = {'p1': 'i see',
'p2': 'good times, good times'}
rpd_obj = rpd_object.ResourcePropertiesData().create_or_update(
self.stack.context, data)
rpd_db_obj = self.stack.context.session.query(
models.ResourcePropertiesData).get(rpd_obj.id)
res_obj1 = resource_objects.Resource().create(
self.stack.context,
{'stack_id': self.stack.id,
'uuid': str(uuid.uuid4()),
'rsrc_prop_data': rpd_db_obj})
res_obj2 = resource_objects.Resource().create(
self.stack.context,
{'stack_id': self.stack.id,
'uuid': str(uuid.uuid4()),
'rsrc_prop_data_id': rpd_db_obj.id})
ctx2 = utils.dummy_context()
res_obj1 = resource_objects.Resource().get_obj(
ctx2, res_obj1.id)
res_obj2 = resource_objects.Resource().get_obj(
ctx2, res_obj2.id)
# verify the resource_properties_data association
# can be set by id
self.assertEqual(rpd_db_obj.id, res_obj1.rsrc_prop_data_id)
self.assertEqual(res_obj1.rsrc_prop_data_id,
res_obj2.rsrc_prop_data_id)
# properties data appears unencrypted to resource object
self.assertEqual(data, res_obj1.properties_data)
self.assertEqual(data, res_obj2.properties_data)
def test_make_replacement(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_res_upd', tmpl, self.stack)
res.store()
new_tmpl_id = 2
self.assertIsNotNone(res.id)
new_requires = {1, 2, 4}
new_id = res.make_replacement(new_tmpl_id, new_requires)
new_res = resource_objects.Resource.get_obj(res.context, new_id)
self.assertEqual(new_id, res.replaced_by)
self.assertEqual(res.id, new_res.replaces)
self.assertIsNone(new_res.physical_resource_id)
self.assertEqual(new_tmpl_id, new_res.current_template_id)
self.assertEqual([4, 2, 1], new_res.requires)
def test_metadata_default(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual({}, res.metadata_get())
def test_metadata_set_when_deleted(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.store()
md = {"don't": "care"}
res.action = 'CREATE'
res.metadata_set(md)
self.assertFalse(hasattr(res, '_db_res_is_deleted'))
res_obj = self.stack.context.session.query(
models.Resource).get(res.id)
res_obj.update({'action': 'DELETE'})
self.assertRaises(exception.ResourceNotAvailable,
res.metadata_set, md)
self.assertTrue(res._db_res_is_deleted)
def test_equals_different_stacks(self):
tmpl1 = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
tmpl2 = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
tmpl3 = rsrc_defn.ResourceDefinition('test_resource2', 'Bar')
stack2 = parser.Stack(utils.dummy_context(), 'test_stack',
template.Template(empty_template), stack_id=-1)
res1 = generic_rsrc.GenericResource('test_resource', tmpl1, self.stack)
res2 = generic_rsrc.GenericResource('test_resource', tmpl2, stack2)
res3 = generic_rsrc.GenericResource('test_resource2', tmpl3, stack2)
self.assertEqual(res1, res2)
self.assertNotEqual(res1, res3)
def test_equals_names(self):
tmpl1 = rsrc_defn.ResourceDefinition('test_resource1', 'Foo')
tmpl2 = rsrc_defn.ResourceDefinition('test_resource2', 'Foo')
res1 = generic_rsrc.GenericResource('test_resource1',
tmpl1, self.stack)
res2 = generic_rsrc.GenericResource('test_resource2', tmpl2,
self.stack)
self.assertNotEqual(res1, res2)
def test_update_template_diff_changed_modified(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
metadata={'foo': 123})
update_snippet = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
metadata={'foo': 456})
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
diff = res.update_template_diff(update_snippet, tmpl)
self.assertFalse(diff.properties_changed())
self.assertTrue(diff.metadata_changed())
self.assertFalse(diff.update_policy_changed())
def test_update_template_diff_changed_add(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
update_snippet = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
metadata={'foo': 123})
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
diff = res.update_template_diff(update_snippet, tmpl)
self.assertFalse(diff.properties_changed())
self.assertTrue(diff.metadata_changed())
self.assertFalse(diff.update_policy_changed())
def test_update_template_diff_changed_remove(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
metadata={'foo': 123})
update_snippet = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
diff = res.update_template_diff(update_snippet, tmpl)
self.assertFalse(diff.properties_changed())
self.assertTrue(diff.metadata_changed())
self.assertFalse(diff.update_policy_changed())
def test_update_template_diff_properties_none(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = tmpl.properties(res.properties_schema,
self.stack.context)
diff = res.update_template_diff_properties(after_props, before_props)
self.assertEqual({}, diff)
def test_update_template_diff_properties_added(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
update_defn = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
properties={'Foo': 123})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = update_defn.properties(res.properties_schema,
self.stack.context)
diff = res.update_template_diff_properties(after_props, before_props)
self.assertEqual({'Foo': '123'}, diff)
def test_update_template_diff_properties_removed_no_default_value(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': '123'})
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = new_t.properties(res.properties_schema,
self.stack.context)
diff = res.update_template_diff_properties(after_props, before_props)
self.assertEqual({'Foo': None}, diff)
def test_update_template_diff_properties_removed_with_default_value(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': '123'})
schema = {'Foo': {'Type': 'String', 'Default': '567'}}
self.patchobject(generic_rsrc.ResourceWithProps, 'properties_schema',
new=schema)
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = new_t.properties(res.properties_schema,
self.stack.context)
diff = res.update_template_diff_properties(after_props, before_props)
self.assertEqual({'Foo': '567'}, diff)
def test_update_template_diff_properties_changed(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': '123'})
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': '456'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = new_t.properties(res.properties_schema,
self.stack.context)
diff = res.update_template_diff_properties(after_props, before_props)
self.assertEqual({'Foo': '456'}, diff)
def test_update_template_diff_properties_notallowed(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': '123'})
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Bar': '456'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Cat',)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = new_t.properties(res.properties_schema,
self.stack.context)
self.assertRaises(resource.UpdateReplace,
res.update_template_diff_properties,
after_props, before_props)
def test_update_template_diff_properties_immutable_notsupported(self):
before = {'Foo': 'bar', 'Parrot': 'dead',
'Spam': 'ham', 'Viking': 'axe'}
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
before)
schema = {'Foo': {'Type': 'String'},
'Viking': {'Type': 'String', 'Immutable': True},
'Spam': {'Type': 'String', 'Immutable': True},
'Parrot': {'Type': 'String', 'Immutable': True},
}
after = {'Foo': 'baz', 'Parrot': 'dead',
'Spam': 'eggs', 'Viking': 'sword'}
new_t = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
after)
self.patchobject(generic_rsrc.ResourceWithProps,
'properties_schema', new=schema)
res = generic_rsrc.ResourceWithProps('test_resource', tmpl,
self.stack)
before_props = tmpl.properties(res.properties_schema,
self.stack.context)
after_props = new_t.properties(res.properties_schema,
self.stack.context)
ex = self.assertRaises(exception.NotSupported,
res.update_template_diff_properties,
after_props, before_props)
self.assertIn("Update to properties Spam, Viking of",
six.text_type(ex))
def test_resource(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
def test_deprecated_prop_data_updated(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
res_obj = db_api.resource_get(self.stack.context, res.id)
self.assertIsNone(res_obj.properties_data)
self.assertIsNone(res_obj.properties_data_encrypted)
# Now that we've established these couple of depcrated fields
# are not populated, let's populate them.
db_api.resource_update_and_save(self.stack.context, res_obj.id,
{'properties_data': {'Foo': 'lucky'},
'properties_data_encrypted': False,
'rsrc_prop_data': None})
res._rsrc_prop_data = None
res._load_data(res_obj)
# Legacy properties_data slurped into res._stored_properties_data
self.assertEqual(res._stored_properties_data, {'Foo': 'lucky'})
res._rsrc_prop_data = None
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_rpd')
# Modernity, the data is where it belongs
rsrc_prop_data_db_obj = db_api.resource_prop_data_get(
self.stack.context, res._rsrc_prop_data_id)
self.assertEqual(rsrc_prop_data_db_obj['data'], {'Foo': 'lucky'})
# legacy locations aren't being used anymore
self.assertFalse(hasattr(res, 'properties_data'))
self.assertFalse(hasattr(res, 'properties_data_encrypted'))
def test_deprecated_encrypted_prop_data_updated(self):
cfg.CONF.set_override('encrypt_parameters_and_properties', True)
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
res_obj = db_api.resource_get(self.stack.context, res.id)
self.assertIsNone(res_obj.properties_data)
self.assertIsNone(res_obj.properties_data_encrypted)
# Now that we've established these couple of depcrated fields
# are not populated, let's populate them.
encrypted_data = \
rpd_object.ResourcePropertiesData.encrypt_properties_data(
{'Foo': 'lucky'})[1]
db_api.resource_update_and_save(self.stack.context, res_obj.id,
{'properties_data': encrypted_data,
'properties_data_encrypted': True,
'rsrc_prop_data': None})
# This is where the decrypting of legacy data happens
res_obj = resource_objects.Resource._from_db_object(
resource_objects.Resource(), self.stack.context, res_obj)
self.assertEqual('lucky',
res_obj.properties_data['Foo'])
res._rsrc_prop_data = None
res._load_data(res_obj)
# Legacy properties_data slurped into res._stored_properties_data
self.assertEqual(res._stored_properties_data, {'Foo': 'lucky'})
res._rsrc_prop_data = None
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_store')
# Modernity, the data is where it belongs
# The db object data is encrypted
rsrc_prop_data_db_obj = db_api.resource_prop_data_get(
self.stack.context, res._rsrc_prop_data_id)
self.assertNotEqual(rsrc_prop_data_db_obj['data'], {'Foo': 'lucky'})
# But the objects/ rsrc_prop_data.data is always unencrypted
rsrc_prop_data_obj = rpd_object.ResourcePropertiesData._from_db_object(
rpd_object.ResourcePropertiesData(), self.stack.context,
rsrc_prop_data_db_obj)
self.assertEqual(rsrc_prop_data_obj.data, {'Foo': 'lucky'})
# legacy locations aren't being used anymore
self.assertFalse(hasattr(res, 'properties_data'))
self.assertFalse(hasattr(res, 'properties_data_encrypted'))
def test_create_fail_missing_req_prop(self):
rname = 'test_resource'
tmpl = rsrc_defn.ResourceDefinition(rname, 'Foo', {})
res = generic_rsrc.ResourceWithRequiredProps(rname, tmpl, self.stack)
estr = ('Property error: test_resource.Properties: '
'Property Foo not assigned')
create = scheduler.TaskRunner(res.create)
err = self.assertRaises(exception.ResourceFailure, create)
self.assertIn(estr, six.text_type(err))
self.assertEqual((res.CREATE, res.FAILED), res.state)
def test_create_fail_prop_typo(self):
rname = 'test_resource'
tmpl = rsrc_defn.ResourceDefinition(rname, 'GenericResourceType',
{'Food': 'abc'})
res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack)
estr = ('StackValidationFailed: resources.test_resource: '
'Property error: test_resource.Properties: '
'Unknown Property Food')
create = scheduler.TaskRunner(res.create)
err = self.assertRaises(exception.ResourceFailure, create)
self.assertIn(estr, six.text_type(err))
self.assertEqual((res.CREATE, res.FAILED), res.state)
def test_create_fail_metadata_parse_error(self):
rname = 'test_resource'
get_att = cfn_funcs.GetAtt(self.stack, 'Fn::GetAtt',
["ResourceA", "abc"])
tmpl = rsrc_defn.ResourceDefinition(rname, 'GenericResourceType',
properties={},
metadata={'foo': get_att})
res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack)
create = scheduler.TaskRunner(res.create)
self.assertRaises(exception.ResourceFailure, create)
self.assertEqual((res.CREATE, res.FAILED), res.state)
def test_create_resource_after_destroy(self):
rname = 'test_res_id_none'
tmpl = rsrc_defn.ResourceDefinition(rname, 'GenericResourceType')
res = generic_rsrc.ResourceWithProps(rname, tmpl, self.stack)
res.id = 'test_res_id'
(res.action, res.status) = (res.INIT, res.DELETE)
create = scheduler.TaskRunner(res.create)
self.assertRaises(exception.ResourceFailure, create)
scheduler.TaskRunner(res.destroy)()
res.state_reset()
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
@mock.patch.object(properties.Properties, 'validate')
@mock.patch.object(timeutils, 'retry_backoff_delay')
def test_create_validate(self, m_re, m_v):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
m_v.side_effect = [True, exception.StackValidationFailed()]
create_excs = [
exception.ResourceInError(resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='CREATE',
status_reason='just because'),
exception.ResourceInError(resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='CREATE',
status_reason='just because'),
None
]
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_create',
side_effect=create_excs)
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_delete',
return_value=None)
m_re.return_value = 0.01
scheduler.TaskRunner(res.create)()
self.assertEqual(2, m_re.call_count)
self.assertEqual(1, m_v.call_count)
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
def test_create_fail_retry(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
exc = exception.ResourceInError(resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='CREATE',
status_reason='just because')
self.patchobject(timeutils, 'retry_backoff_delay', return_value=0.01)
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_create',
side_effect=[exc, None])
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_delete')
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
self.assertEqual(
2, generic_rsrc.ResourceWithProps.handle_create.call_count)
self.assertEqual(
1, generic_rsrc.ResourceWithProps.handle_delete.call_count)
timeutils.retry_backoff_delay.assert_called_once_with(
1, jitter_max=2.0)
def test_create_fail_retry_disabled(self):
cfg.CONF.set_override('action_retry_limit', 0)
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
exc = exception.ResourceInError(resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='CREATE',
status_reason='just because')
self.patchobject(timeutils, 'retry_backoff_delay')
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_create',
side_effect=exc)
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_delete')
estr = ('ResourceInError: resources.test_resource: '
'Went to status ERROR due to "just because"')
create = scheduler.TaskRunner(res.create)
err = self.assertRaises(exception.ResourceFailure, create)
self.assertEqual(estr, six.text_type(err))
self.assertEqual((res.CREATE, res.FAILED), res.state)
self.assertEqual(
1, generic_rsrc.ResourceWithProps.handle_create.call_count)
def test_create_deletes_fail_retry(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
create_exc = exception.ResourceInError(
resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='CREATE',
status_reason='just because')
delete_exc = exception.ResourceInError(
resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='DELETE',
status_reason='delete failed')
self.patchobject(timeutils, 'retry_backoff_delay', return_value=0.01)
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_create',
side_effect=[create_exc, None])
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_delete',
side_effect=[delete_exc, delete_exc, None])
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
self.assertEqual(3, timeutils.retry_backoff_delay.call_count)
self.assertEqual(
2, generic_rsrc.ResourceWithProps.handle_create.call_count)
self.assertEqual(
3, generic_rsrc.ResourceWithProps.handle_delete.call_count)
def test_creates_fail_retry(self):
create_exc = exception.ResourceInError(
resource_name='test_resource',
resource_status='ERROR',
resource_type='GenericResourceType',
resource_action='CREATE',
status_reason='just because')
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
self.patchobject(timeutils, 'retry_backoff_delay', return_value=0.01)
self.patchobject(generic_rsrc.ResourceWithProps,
'handle_create', side_effect=[create_exc, create_exc,
None])
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_delete',
return_value=None)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
self.assertEqual(
3, generic_rsrc.ResourceWithProps.handle_create.call_count)
self.assertEqual(
2, generic_rsrc.ResourceWithProps.handle_delete.call_count)
def test_create_cancel(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.CancellableResource('test_resource', tmpl,
self.stack)
cookie = object()
m_hc = mock.Mock(return_value=cookie)
res.handle_create = m_hc
m_ccc = mock.Mock(return_value=False)
res.check_create_complete = m_ccc
m_hcc = mock.Mock()
res.handle_create_cancel = m_hcc
runner = scheduler.TaskRunner(res.create)
runner.start()
runner.step()
runner.cancel()
m_hc.assert_called_once_with()
m_ccc.assert_called_once_with(cookie)
m_hcc.assert_called_once_with(cookie)
def test_create_cancel_exception(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.CancellableResource('test_resource', tmpl,
self.stack)
cookie = object()
class FakeExc(Exception):
pass
m_hc = mock.Mock(return_value=cookie)
res.handle_create = m_hc
m_ccc = mock.Mock(return_value=False)
res.check_create_complete = m_ccc
m_hcc = mock.Mock(side_effect=FakeExc)
res.handle_create_cancel = m_hcc
runner = scheduler.TaskRunner(res.create)
runner.start()
runner.step()
runner.cancel()
m_hc.assert_called_once_with()
m_ccc.assert_called_once_with(cookie)
m_hcc.assert_called_once_with(cookie)
def test_preview(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType')
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
self.assertEqual(res, res.preview())
def test_update_ok(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'xyz'})
prop_diff = {'Foo': 'xyz'}
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_update')
scheduler.TaskRunner(res.update, utmpl)()
self.assertEqual((res.UPDATE, res.COMPLETE), res.state)
self.assertEqual({'Foo': 'xyz'}, res._stored_properties_data)
generic_rsrc.ResourceWithProps.handle_update.assert_called_once_with(
utmpl, mock.ANY, prop_diff)
def test_update_replace_with_resource_name(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'xyz'})
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_update',
side_effect=resource.UpdateReplace(res.name))
prop_diff = {'Foo': 'xyz'}
# should be re-raised so parser.Stack can handle replacement
updater = scheduler.TaskRunner(res.update, utmpl)
ex = self.assertRaises(resource.UpdateReplace, updater)
self.assertEqual('The Resource test_resource requires replacement.',
six.text_type(ex))
generic_rsrc.ResourceWithProps.handle_update.assert_called_once_with(
utmpl, mock.ANY, prop_diff)
def test_update_replace_without_resource_name(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'xyz'})
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_update',
side_effect=resource.UpdateReplace)
prop_diff = {'Foo': 'xyz'}
# should be re-raised so parser.Stack can handle replacement
updater = scheduler.TaskRunner(res.update, utmpl)
ex = self.assertRaises(resource.UpdateReplace, updater)
self.assertEqual('The Resource Unknown requires replacement.',
six.text_type(ex))
generic_rsrc.ResourceWithProps.handle_update.assert_called_once_with(
utmpl, mock.ANY, prop_diff)
def test_need_update_in_init_complete_state_for_resource(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
self.assertEqual((res.INIT, res.COMPLETE), res.state)
prop = {'Foo': 'abc'}
self.assertRaises(resource.UpdateReplace,
res._needs_update, tmpl, tmpl, prop, prop, res)
def test_need_update_in_create_failed_state_for_resource(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl,
self.stack)
res.update_allowed_properties = ('Foo',)
res.state_set(res.CREATE, res.FAILED)
prop = {'Foo': 'abc'}
self.assertRaises(resource.UpdateReplace,
res._needs_update, tmpl, tmpl, prop, prop, res)
def test_convg_need_update_in_delete_complete_state_for_resource(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl,
self.stack)
res.update_allowed_properties = ('Foo',)
res.stack.convergence = True
res.state_set(res.DELETE, res.COMPLETE)
prop = {'Foo': 'abc'}
self.assertRaises(resource.UpdateReplace,
res._needs_update, tmpl, tmpl, prop, prop, res)
def test_update_fail_missing_req_prop(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithRequiredProps('test_resource',
tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{})
updater = scheduler.TaskRunner(res.update, utmpl)
self.assertRaises(exception.ResourceFailure, updater)
self.assertEqual((res.UPDATE, res.FAILED), res.state)
def test_update_fail_prop_typo(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Food': 'xyz'})
updater = scheduler.TaskRunner(res.update, utmpl)
self.assertRaises(exception.ResourceFailure, updater)
self.assertEqual((res.UPDATE, res.FAILED), res.state)
def test_update_not_implemented(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
utmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'xyz'})
prop_diff = {'Foo': 'xyz'}
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_update',
side_effect=NotImplementedError)
updater = scheduler.TaskRunner(res.update, utmpl)
self.assertRaises(exception.ResourceFailure, updater)
self.assertEqual((res.UPDATE, res.FAILED), res.state)
generic_rsrc.ResourceWithProps.handle_update.assert_called_once_with(
utmpl, mock.ANY, prop_diff)
def test_update_cancel(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
res = generic_rsrc.CancellableResource('test_resource', tmpl,
self.stack)
cookie = object()
m_nu = mock.Mock(return_value=True)
res._needs_update = m_nu
m_hu = mock.Mock(return_value=cookie)
res.handle_update = m_hu
m_cuc = mock.Mock(return_value=False)
res.check_update_complete = m_cuc
m_huc = mock.Mock()
res.handle_update_cancel = m_huc
scheduler.TaskRunner(res.create)()
runner = scheduler.TaskRunner(res.update, tmpl)
runner.start()
runner.step()
runner.cancel()
m_nu.assert_called_once_with(
mock.ANY, mock.ANY,
mock.ANY, mock.ANY,
None)
m_hu.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY)
m_cuc.assert_called_once_with(cookie)
m_huc.assert_called_once_with(cookie)
def _mock_check_res(self, mock_check=True):
tmpl = rsrc_defn.ResourceDefinition('test_res', 'GenericResourceType')
res = generic_rsrc.ResourceWithProps('test_res', tmpl, self.stack)
res.state_set(res.CREATE, res.COMPLETE)
if mock_check:
res.handle_check = mock.Mock()
return res
def test_check_supported(self):
res = self._mock_check_res()
scheduler.TaskRunner(res.check)()
self.assertTrue(res.handle_check.called)
self.assertEqual(res.CHECK, res.action)
self.assertEqual(res.COMPLETE, res.status)
self.assertNotIn('not supported', res.status_reason)
def test_check_not_supported(self):
res = self._mock_check_res(mock_check=False)
scheduler.TaskRunner(res.check)()
self.assertIn('not supported', res.status_reason)
self.assertEqual(res.CHECK, res.action)
self.assertEqual(res.COMPLETE, res.status)
def test_check_failed(self):
res = self._mock_check_res()
res.handle_check.side_effect = Exception('boom')
self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(res.check))
self.assertTrue(res.handle_check.called)
self.assertEqual(res.CHECK, res.action)
self.assertEqual(res.FAILED, res.status)
self.assertIn('boom', res.status_reason)
def test_verify_check_conditions(self):
valid_foos = ['foo1', 'foo2']
checks = [
{'attr': 'foo1', 'expected': 'bar1', 'current': 'baz1'},
{'attr': 'foo2', 'expected': valid_foos, 'current': 'foo2'},
{'attr': 'foo3', 'expected': 'bar3', 'current': 'baz3'},
{'attr': 'foo4', 'expected': 'foo4', 'current': 'foo4'},
{'attr': 'foo5', 'expected': valid_foos, 'current': 'baz5'},
]
tmpl = rsrc_defn.ResourceDefinition('test_res', 'GenericResourceType')
res = generic_rsrc.ResourceWithProps('test_res', tmpl, self.stack)
exc = self.assertRaises(exception.Error,
res._verify_check_conditions, checks)
exc_text = six.text_type(exc)
self.assertNotIn("'foo2':", exc_text)
self.assertNotIn("'foo4':", exc_text)
self.assertIn("'foo1': expected 'bar1', got 'baz1'", exc_text)
self.assertIn("'foo3': expected 'bar3', got 'baz3'", exc_text)
self.assertIn("'foo5': expected '['foo1', 'foo2']', got 'baz5'",
exc_text)
def test_suspend_resume_ok(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Foo',)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
scheduler.TaskRunner(res.suspend)()
self.assertEqual((res.SUSPEND, res.COMPLETE), res.state)
scheduler.TaskRunner(res.resume)()
self.assertEqual((res.RESUME, res.COMPLETE), res.state)
def test_suspend_fail_invalid_states(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
invalid_actions = (a for a in res.ACTIONS if a != res.SUSPEND)
invalid_status = (s for s in res.STATUSES if s != res.COMPLETE)
invalid_states = [s for s in
itertools.product(invalid_actions, invalid_status)]
for state in invalid_states:
res.state_set(*state)
suspend = scheduler.TaskRunner(res.suspend)
expected = 'State %s invalid for suspend' % six.text_type(state)
exc = self.assertRaises(exception.ResourceFailure, suspend)
self.assertIn(expected, six.text_type(exc))
def test_resume_fail_invalid_states(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
invalid_states = [s for s in
itertools.product(res.ACTIONS, res.STATUSES)
if s not in ((res.SUSPEND, res.COMPLETE),
(res.RESUME, res.FAILED),
(res.RESUME, res.COMPLETE))]
for state in invalid_states:
res.state_set(*state)
resume = scheduler.TaskRunner(res.resume)
expected = 'State %s invalid for resume' % six.text_type(state)
exc = self.assertRaises(exception.ResourceFailure, resume)
self.assertIn(expected, six.text_type(exc))
def test_suspend_fail_exception(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
class FakeExc(Exception):
pass
self.patchobject(generic_rsrc.ResourceWithProps,
'handle_suspend', side_effect=FakeExc)
suspend = scheduler.TaskRunner(res.suspend)
self.assertRaises(exception.ResourceFailure, suspend)
self.assertEqual((res.SUSPEND, res.FAILED), res.state)
def test_resume_fail_exception(self):
tmpl = rsrc_defn.ResourceDefinition('test_resource',
'GenericResourceType',
{'Foo': 'abc'})
res = generic_rsrc.ResourceWithProps('test_resource', tmpl, self.stack)
scheduler.TaskRunner(res.create)()
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
class FakeExc(Exception):
pass
self.patchobject(generic_rsrc.ResourceWithProps, 'handle_resume',
side_effect=FakeExc)
res.state_set(res.SUSPEND, res.COMPLETE)
resume = scheduler.TaskRunner(res.resume)
self.assertRaises(exception.ResourceFailure, resume)
self.assertEqual((res.RESUME, res.FAILED), res.state)
self.assertEqual(
1, generic_rsrc.ResourceWithProps.handle_resume.call_count)
def test_resource_class_to_cfn_template(self):
class TestResource(resource.Resource):
list_schema = {'wont_show_up': {'Type': 'Number'}}
map_schema = {'will_show_up': {'Type': 'Integer'}}
properties_schema = {
'name': {'Type': 'String'},
'bool': {'Type': 'Boolean'},
'implemented': {'Type': 'String',
'Implemented': True,
'AllowedPattern': '.*',
'MaxLength': 7,
'MinLength': 2,
'Required': True},
'not_implemented': {'Type': 'String',
'Implemented': False},
'number': {'Type': 'Number',
'MaxValue': 77,
'MinValue': 41,
'Default': 42},
'list': {'Type': 'List', 'Schema': {'Type': 'Map',
'Schema': list_schema}},
'map': {'Type': 'Map', 'Schema': map_schema},
'hidden': properties.Schema(
properties.Schema.STRING,
support_status=support.SupportStatus(
status=support.HIDDEN))
}
attributes_schema = {
'output1': attributes.Schema('output1_desc'),
'output2': attributes.Schema('output2_desc')
}
expected_template = {
'HeatTemplateFormatVersion': '2012-12-12',
'Description': 'Initial template of TestResource',
'Parameters': {
'name': {'Type': 'String'},
'bool': {'Type': 'Boolean',
'AllowedValues': ['True', 'true', 'False', 'false']},
'implemented': {
'Type': 'String',
'AllowedPattern': '.*',
'MaxLength': 7,
'MinLength': 2
},
'number': {'Type': 'Number',
'MaxValue': 77,
'MinValue': 41,
'Default': 42},
'list': {'Type': 'CommaDelimitedList'},
'map': {'Type': 'Json'}
},
'Resources': {
'TestResource': {
'Type': 'Test::Resource::resource',
'Properties': {
'name': {'Ref': 'name'},
'bool': {'Ref': 'bool'},
'implemented': {'Ref': 'implemented'},
'number': {'Ref': 'number'},
'list': {'Fn::Split': [",", {'Ref': 'list'}]},
'map': {'Ref': 'map'}
}
}
},
'Outputs': {
'output1': {
'Description': 'output1_desc',
'Value': {"Fn::GetAtt": ["TestResource", "output1"]}
},
'output2': {
'Description': 'output2_desc',
'Value': {"Fn::GetAtt": ["TestResource", "output2"]}
},
'show': {
'Description': u'Detailed information about resource.',
'Value': {"Fn::GetAtt": ["TestResource", "show"]}
},
'OS::stack_id': {
'Value': {"Ref": "TestResource"}
}
}
}
self.assertEqual(expected_template,
TestResource.resource_to_template(
'Test::Resource::resource'))
def test_resource_class_to_hot_template(self):
class TestResource(resource.Resource):
list_schema = {'wont_show_up': {'Type': 'Number'}}
map_schema = {'will_show_up': {'Type': 'Integer'}}
properties_schema = {
'name': {'Type': 'String'},
'bool': {'Type': 'Boolean'},
'implemented': {'Type': 'String',
'Implemented': True,
'AllowedPattern': '.*',
'MaxLength': 7,
'MinLength': 2,
'Required': True},
'not_implemented': {'Type': 'String',
'Implemented': False},
'number': {'Type': 'Number',
'MaxValue': 77,
'MinValue': 41,
'Default': 42},
'list': {'Type': 'List', 'Schema': {'Type': 'Map',
'Schema': list_schema}},
'map': {'Type': 'Map', 'Schema': map_schema},
'hidden': properties.Schema(
properties.Schema.STRING,
support_status=support.SupportStatus(
status=support.HIDDEN))
}
attributes_schema = {
'output1': attributes.Schema('output1_desc'),
'output2': attributes.Schema('output2_desc')
}
expected_template = {
'heat_template_version': '2016-10-14',
'description': 'Initial template of TestResource',
'parameters': {
'name': {'type': 'string'},
'bool': {'type': 'boolean'},
'implemented': {
'type': 'string',
'constraints': [{'length': {'max': 7, 'min': 2}},
{'allowed_pattern': '.*'}]
},
'number': {'type': 'number',
'constraints': [{'range': {'max': 77, 'min': 41}}],
'default': 42},
'list': {'type': 'comma_delimited_list'},
'map': {'type': 'json'}
},
'resources': {
'TestResource': {
'type': 'Test::Resource::resource',
'properties': {
'name': {'get_param': 'name'},
'bool': {'get_param': 'bool'},
'implemented': {'get_param': 'implemented'},
'number': {'get_param': 'number'},
'list': {'get_param': 'list'},
'map': {'get_param': 'map'}
}
}
},
'outputs': {
'output1': {
'description': 'output1_desc',
'value': {"get_attr": ["TestResource", "output1"]}
},
'output2': {
'description': 'output2_desc',
'value': {"get_attr": ["TestResource", "output2"]}
},
'show': {
'description': u'Detailed information about resource.',
'value': {"get_attr": ["TestResource", "show"]}
},
'OS::stack_id': {
'value': {"get_resource": "TestResource"}
}
}
}
self.assertEqual(expected_template,
TestResource.resource_to_template(
'Test::Resource::resource',
template_type='hot'))
def test_is_not_using_neutron_exception(self):
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
res = resource.Resource('aresource', snippet, self.stack)
mock_create = self.patch(
'heat.engine.clients.os.neutron.NeutronClientPlugin._create')
mock_create.side_effect = Exception()
self.assertFalse(res.is_using_neutron())
def test_is_using_neutron_endpoint_lookup(self):
snippet = rsrc_defn.ResourceDefinition('aresource',
'GenericResourceType')
res = resource.Resource('aresource', snippet, self.stack)
client = mock.Mock()
self.patchobject(client.httpclient, 'get_endpoint',
return_value=None)
self.patch(
'heat.engine.clients.os.neutron.NeutronClientPlugin._create',
return_value=client)
self.assertFalse(res.is_using_neutron())
self.patchobject(client.httpclient, 'get_endpoint',
return_value=mock.Mock())
self.assertTrue(res.is_using_neutron())
def _test_skip_validation_if_custom_constraint(self, tmpl):
stack = parser.Stack(utils.dummy_context(), 'test', tmpl)
stack.store()
path = ('heat.engine.clients.os.neutron.neutron_constraints.'
'NetworkConstraint.validate_with_client')
with mock.patch(path) as mock_validate:
mock_validate.side_effect = neutron_exp.NeutronClientException
rsrc2 = stack['bar']
self.assertIsNone(rsrc2.validate())
def test_ref_skip_validation_if_custom_constraint(self):
tmpl = template.Template({
'HeatTemplateFormatVersion': '2012-12-12',
'Resources': {
'foo': {'Type': 'OS::Test::GenericResource'},
'bar': {
'Type': 'OS::Test::ResourceWithCustomConstraint',
'Properties': {
'Foo': {'Ref': 'foo'},
}
}
}
}, env=self.env)
self._test_skip_validation_if_custom_constraint(tmpl)
def test_hot_ref_skip_validation_if_custom_constraint(self):
tmpl = template.Template({
'heat_template_version': '2013-05-23',
'resources': {
'foo': {'type': 'GenericResourceType'},
'bar': {
'type': 'ResourceWithCustomConstraint',
'properties': {
'Foo': {'get_resource': 'foo'},
}
}
}
}, env=self.env)
self._test_skip_validation_if_custom_constraint(tmpl)
def test_no_resource_properties_required_default(self):
"""Test that there is no required properties with default value
Check all resources if they have properties with required flag and
default value because it is ambiguous.
"""
env = environment.Environment({}, user_env=False)
resources._load_global_environment(env)
# change loading mechanism for resources that require template files
mod_dir = os.path.dirname(sys.modules[__name__].__file__)
project_dir = os.path.abspath(os.path.join(mod_dir, '../../'))
template_path = os.path.join(project_dir, 'etc', 'heat', 'templates')
tri_db_instance = env.get_resource_info(
'AWS::RDS::DBInstance',
registry_type=environment.TemplateResourceInfo)
tri_db_instance.template_name = tri_db_instance.template_name.replace(
'/etc/heat/templates', template_path)
tri_alarm = env.get_resource_info(
'AWS::CloudWatch::Alarm',
registry_type=environment.TemplateResourceInfo)
tri_alarm.template_name = tri_alarm.template_name.replace(
'/etc/heat/templates', template_path)
def _validate_property_schema(prop_name, prop, res_name):
if isinstance(prop, properties.Schema) and prop.implemented:
ambiguous = (prop.default is not None) and prop.required
self.assertFalse(ambiguous,
"The definition of the property '{0}' "
"in resource '{1}' is ambiguous: it "
"has default value and required flag. "
"Please delete one of these options."
.format(prop_name, res_name))
if prop.schema is not None:
if isinstance(prop.schema, constraints.AnyIndexDict):
_validate_property_schema(
prop_name,
prop.schema.value,
res_name)
else:
for nest_prop_name, nest_prop in six.iteritems(
prop.schema):
_validate_property_schema(nest_prop_name,
nest_prop,
res_name)
resource_types = env.get_types()
for res_type in resource_types:
res_class = env.get_class(res_type)
if hasattr(res_class, "properties_schema"):
for property_schema_name, property_schema in six.iteritems(
res_class.properties_schema):
_validate_property_schema(
property_schema_name, property_schema,
res_class.__name__)
def test_getatt_invalid_type(self):
tmpl = template.Template({
'heat_template_version': '2013-05-23',
'resources': {
'res': {
'type': 'ResourceWithAttributeType'
}
}
})
stack = parser.Stack(utils.dummy_context(), 'test', tmpl)
res = stack['res']
self.assertEqual('valid_sting', res.FnGetAtt('attr1'))
res.FnGetAtt('attr2')
self.assertIn("Attribute attr2 is not of type Map", self.LOG.output)
def test_getatt_with_path(self):
tmpl = template.Template({
'heat_template_version': '2013-05-23',
'resources': {
'res': {
'type': 'ResourceWithComplexAttributesType'
}
}
})
stack = parser.Stack(utils.dummy_context(), 'test', tmpl)
res = stack['res']
self.assertEqual('abc', res.FnGetAtt('nested_dict', 'string'))
def test_getatt_with_cache_data(self):
tmpl = template.Template({
'heat_template_version': '2013-05-23',
'resources': {
'res': {
'type': 'ResourceWithAttributeType'
}
}
})
stack = parser.Stack(utils.dummy_context(), 'test', tmpl,
cache_data={
'res': node_data.NodeData.from_dict({
'attrs': {'Foo': 'Res',
'foo': 'res'},
'uuid': mock.ANY,
'id': mock.ANY,
'action': 'CREATE',
'status': 'COMPLETE'})})
res = stack.defn['res']
self.assertEqual('Res', res.FnGetAtt('Foo'))
def test_getatt_with_path_cache_data(self):
tmpl = template.Template({
'heat_template_version': '2013-05-23',
'resources': {
'res': {
'type': 'ResourceWithComplexAttributesType'
}
}
})
stack = parser.Stack(utils.dummy_context(), 'test', tmpl,
cache_data={
'res': node_data.NodeData.from_dict({
'attrs': {('nested', 'string'): 'abc'},
'uuid': mock.ANY,
'id': mock.ANY,
'action': 'CREATE',
'status': 'COMPLETE'})})
res = stack.defn['res']
self.assertEqual('abc', res.FnGetAtt('nested', 'string'))
def test_properties_data_stored_encrypted_decrypted_on_load(self):
cfg.CONF.set_override('encrypt_parameters_and_properties', True)
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
stored_properties_data = {'prop1': 'string',
'prop2': {'a': 'dict'},
'prop3': 1,
'prop4': ['a', 'list'],
'prop5': True}
# The db data should be encrypted when _store() is called
res = generic_rsrc.GenericResource('test_res_enc', tmpl, self.stack)
res._stored_properties_data = stored_properties_data
res._rsrc_prop_data = None
res.store()
db_res = db_api.resource_get(res.context, res.id)
self.assertNotEqual('string',
db_res.rsrc_prop_data.data['prop1'])
# The db data should be encrypted when state_set is called
res = generic_rsrc.GenericResource('test_res_enc', tmpl, self.stack)
res._stored_properties_data = stored_properties_data
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_store')
db_res = db_api.resource_get(res.context, res.id)
self.assertNotEqual('string',
db_res.rsrc_prop_data.data['prop1'])
# The properties data should be decrypted when the object is
# loaded using get_obj
res_obj = resource_objects.Resource.get_obj(res.context, res.id)
self.assertEqual('string', res_obj.properties_data['prop1'])
# _stored_properties_data should be decrypted when the object is
# loaded using get_all_by_stack
res_objs = resource_objects.Resource.get_all_by_stack(res.context,
self.stack.id)
res_obj = res_objs['test_res_enc']
self.assertEqual('string', res_obj.properties_data['prop1'])
# The properties data should be decrypted when the object is
# refreshed
res_obj = resource_objects.Resource.get_obj(res.context, res.id)
res_obj.refresh()
self.assertEqual('string', res_obj.properties_data['prop1'])
def test_properties_data_no_encryption(self):
cfg.CONF.set_override('encrypt_parameters_and_properties', False)
tmpl = rsrc_defn.ResourceDefinition('test_resource', 'Foo')
stored_properties_data = {'prop1': 'string',
'prop2': {'a': 'dict'},
'prop3': 1,
'prop4': ['a', 'list'],
'prop5': True}
# The db data should not be encrypted when state_set()
# is called
res = generic_rsrc.GenericResource('test_res_enc', tmpl, self.stack)
res._stored_properties_data = stored_properties_data
res._rsrc_prop_data = None
res.state_set(res.CREATE, res.IN_PROGRESS, 'test_store')
db_res = db_api.resource_get(res.context, res.id)
self.assertEqual('string', db_res.rsrc_prop_data.data['prop1'])
# The db data should not be encrypted when _store() is called
res = generic_rsrc.GenericResource('test_res_enc', tmpl, self.stack)
res._stored_properties_data = stored_properties_data
db_res = db_api.resource_get(res.context, res.id)
self.assertEqual('string', db_res.rsrc_prop_data.data['prop1'])
# The properties data should not be modified when the object
# is loaded using get_obj
prev_rsrc_prop_data_id = db_res.rsrc_prop_data.id
res_obj = resource_objects.Resource.get_obj(res.context, res.id)
self.assertEqual('string', res_obj.properties_data['prop1'])
self.assertEqual(prev_rsrc_prop_data_id, res_obj.rsrc_prop_data_id)
# The properties data should not be modified when the object
# is loaded using get_all_by_stack
res_objs = resource_objects.Resource.get_all_by_stack(res.context,
self.stack.id)
res_obj = res_objs['test_res_enc']
self.assertEqual('string', res_obj.properties_data[&