# If this test fails, we call the underlying resource.update
#
# Currently many resources have a default handle_update method
- # which returns "requires replacement" (res.UPDATE_REPLACE)
+ # which raises exception.ResourceReplace
# optionally they may implement non-interruptive logic and
# return UPDATE_COMPLETE. If resources do not implement the
# handle_update method at all, update will fail.
if old_snippet != new_snippet:
# res.update raises exception.ResourceFailure on error
- retval = self[res.name].update(new_snippet)
-
- if retval == self[res.name].UPDATE_COMPLETE:
- logger.info("Resource %s for stack %s updated" %
- (res.name, self.name))
- elif retval == self[res.name].UPDATE_REPLACE:
- logger.info("Resource %s for stack %s" %
- (res.name, self.name) +
- " update requires replacement")
+ # or exception.ResourceReplace if update requires
+ # replacement
+ try:
+ self[res.name].update(new_snippet)
+ except resource.UpdateReplace:
# Resource requires replacement for update
self[res.name].destroy()
res.stack = self
self.resources.itervalues())
scheduler.TaskRunner(res.create)()
else:
- raise exception.ResourceFailure(ValueError(
- "Unexpected update retval %s" % retval))
+ logger.info("Resource %s for stack %s updated" %
+ (res.name, self.name))
if action == self.UPDATE:
stack_status = self.UPDATE_COMPLETE
_resource_classes[resource_type] = resource_class
+class UpdateReplace(Exception):
+ '''
+ Raised when resource update requires replacement
+ '''
+ _message = _("The Resource %s requires replacement.")
+
+ def __init__(self, resource_name='Unknown',
+ message=_("The Resource %s requires replacement.")):
+ try:
+ msg = message % resource_name
+ except TypeError:
+ msg = message
+ super(Exception, self).__init__(msg)
+
+
class Metadata(object):
'''
A descriptor for accessing the metadata of a resource while ensuring the
UPDATE_FAILED = 'UPDATE_FAILED'
UPDATE_COMPLETE = 'UPDATE_COMPLETE'
- # Status value, returned from subclasses to indicate replacement required
- UPDATE_REPLACE = 'UPDATE_REPLACE'
-
# If True, this resource must be created before it can be referenced.
strict_dependency = True
Returns the difference between json_template and self.t
If something has been removed in json_snippet which exists
in self.t we set it to None. If any keys have changed which
- are not in update_allowed_keys, raises NotImplementedError
+ are not in update_allowed_keys, raises UpdateReplace if the
+ differing keys are not in update_allowed_keys
'''
update_allowed_set = set(self.update_allowed_keys)
if not changed_keys_set.issubset(update_allowed_set):
badkeys = changed_keys_set - update_allowed_set
- raise NotImplementedError("Cannot update keys %s for %s" %
- (badkeys, self.name))
+ raise UpdateReplace(self.name)
return dict((k, new_template.get(k)) for k in changed_keys_set)
Returns the changed Properties between json_template and self.t
If a property has been removed in json_snippet which exists
in self.t we set it to None. If any properties have changed which
- are not in update_allowed_properties, raises NotImplementedError
+ are not in update_allowed_properties, raises UpdateReplace if the
+ modified properties are not in the update_allowed_properties
'''
update_allowed_set = set(self.update_allowed_properties)
updated_properties.get(k))
if not changed_properties_set.issubset(update_allowed_set):
- badkeys = changed_properties_set - update_allowed_set
- raise NotImplementedError("Cannot update properties %s for %s" %
- (badkeys, self.name))
+ raise UpdateReplace(self.name)
return dict((k, updated_properties.get(k))
for k in changed_properties_set)
properties.validate()
if callable(getattr(self, 'handle_update', None)):
result = self.handle_update(json_snippet)
+ except UpdateReplace:
+ logger.debug("Resource %s update requires replacement" % self.name)
+ raise
except Exception as ex:
logger.exception('update %s : %s' % (str(self), str(ex)))
failure = exception.ResourceFailure(ex)
self.state_set(self.UPDATE_FAILED, str(failure))
raise failure
else:
- # If resource was updated (with or without interruption),
- # then we set the resource to UPDATE_COMPLETE
- if not result == self.UPDATE_REPLACE:
- self.t = self.stack.resolve_static_data(json_snippet)
- self.state_set(self.UPDATE_COMPLETE)
- return result
+ self.t = self.stack.resolve_static_data(json_snippet)
+ self.state_set(self.UPDATE_COMPLETE)
def physical_resource_name(self):
return '%s.%s' % (self.stack.name, self.name)
return base64.b64encode(data)
def handle_update(self, json_snippet=None):
- raise NotImplementedError("Update not implemented for Resource %s"
- % type(self))
+ raise UpdateReplace(self.name)
def metadata_update(self, new_metadata=None):
'''
creator.run_to_completion()
def handle_update(self, json_snippet):
- try:
- tmpl_diff = self.update_template_diff(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid key" % self.name)
- return self.UPDATE_REPLACE
-
- try:
- prop_diff = self.update_template_diff_properties(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid Property" % self.name)
- return self.UPDATE_REPLACE
+ tmpl_diff = self.update_template_diff(json_snippet)
+ prop_diff = self.update_template_diff_properties(json_snippet)
# If Properties has changed, update self.properties, so we
# get the new values during any subsequent adjustment
raise_on_error=True)
self._wait_for_activation(creator)
- return self.UPDATE_COMPLETE
-
def _make_instance(self, name):
Instance = resource.get_class('AWS::EC2::Instance')
return self._adjust(num_to_create)
def handle_update(self, json_snippet):
- try:
- tmpl_diff = self.update_template_diff(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid key" % self.name)
- return self.UPDATE_REPLACE
-
- try:
- prop_diff = self.update_template_diff_properties(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid Property" % self.name)
- return self.UPDATE_REPLACE
+ tmpl_diff = self.update_template_diff(json_snippet)
+ prop_diff = self.update_template_diff_properties(json_snippet)
# If Properties has changed, update self.properties, so we
# get the new values during any subsequent adjustment
creator = self._adjust(new_capacity)
self._wait_for_activation(creator)
- return self.UPDATE_COMPLETE
-
def adjust(self, adjustment, adjustment_type='ChangeInCapacity'):
creator = self._adjust(adjustment, adjustment_type, False)
self._wait_for_activation(creator)
super(ScalingPolicy, self).__init__(name, json_snippet, stack)
def handle_update(self, json_snippet):
- try:
- tmpl_diff = self.update_template_diff(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid key" % self.name)
- return self.UPDATE_REPLACE
-
- try:
- prop_diff = self.update_template_diff_properties(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid Property" % self.name)
- return self.UPDATE_REPLACE
+ tmpl_diff = self.update_template_diff(json_snippet)
+ prop_diff = self.update_template_diff_properties(json_snippet)
# If Properties has changed, update self.properties, so we
# get the new values during any subsequent adjustment
self.stack.resolve_runtime_data,
self.name)
- return self.UPDATE_COMPLETE
-
def alarm(self):
if self._cooldown_inprogress():
logger.info("%s NOT performing scaling action, cooldown %s" %
wr.store()
def handle_update(self, json_snippet):
- try:
- self.update_template_diff(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid key" % self.name)
- return self.UPDATE_REPLACE
-
- try:
- prop_diff = self.update_template_diff_properties(json_snippet)
- except NotImplementedError:
- logger.error("Could not update %s, invalid Property" % self.name)
- return self.UPDATE_REPLACE
+ self.update_template_diff(json_snippet)
+ prop_diff = self.update_template_diff_properties(json_snippet)
# If Properties has changed, update self.properties, so we
# get the new values during any subsequent adjustment
wr.rule = self.parsed_template('Properties')
wr.store()
- return self.UPDATE_COMPLETE
-
def handle_delete(self):
try:
db_api.watch_rule_delete(self.context,
templ = template_format.parse(mysql_template)
self.create_with_template(templ, self._params())
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
self.delete_nested()
self.ipaddress = ips.ip
self.resource_id_set(ips.id)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
"""De-allocate a floating IP."""
if self.resource_id is not None:
scheduler.TaskRunner(detach_task)()
def handle_update(self, json_snippet):
- status = self.UPDATE_REPLACE
- try:
- tmpl_diff = self.update_template_diff(json_snippet)
- except NotImplementedError:
- return self.UPDATE_REPLACE
+ tmpl_diff = self.update_template_diff(json_snippet)
for k in tmpl_diff:
if k == 'Metadata':
self.metadata = json_snippet.get('Metadata', {})
- status = self.UPDATE_COMPLETE
else:
- return self.UPDATE_REPLACE
-
- return status
+ raise resource.UpdateReplace(resource_name=self.name)
def metadata_update(self, new_metadata=None):
'''
def handle_delete(self):
pass
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
class VPCGatewayAttachment(resource.Resource):
if ex.status_code != 404:
raise ex
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def resource_mapping():
if clients.quantumclient is None:
self.create_with_template(templ, param)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
self.delete_nested()
if ex.status_code != 404:
raise ex
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def resource_mapping():
if clients.quantumclient is None:
raise exception.InvalidTemplateAttribute(resource=name, key=key)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
@staticmethod
def is_built(attributes):
if attributes['status'] == 'BUILD':
# TODO(sbaker) all_router_ids has changed, any VPCGatewayAttachment
# for this vpc needs to be notified
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
class SubnetRouteTableAssocation(resource.Resource):
client.add_interface_router(
default_router_id, {'subnet_id': subnet_id})
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def resource_mapping():
if clients.quantumclient is None:
self.swift().put_container(container, headers)
self.resource_id_set(container)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
"""Perform specified delete policy."""
logger.debug('S3Bucket delete container %s' % self.resource_id)
# unexpected error
raise
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
if self.properties['VpcId'] and clients.quantumclient is not None:
self._handle_delete_quantum()
self.create_with_template(template, self.properties[PROP_PARAMETERS])
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
self.delete_nested()
if ex.status_code != 404:
raise ex
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def FnGetAtt(self, key):
if key == 'AvailabilityZone':
return self.properties.get(key, '')
self.swift().put_container(container, headers)
self.resource_id_set(container)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
"""Perform specified delete policy."""
logger.debug('SwiftContainer delete container %s' % self.resource_id)
passwd)
self.resource_id_set(uid)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
if self.resource_id is None:
logger.error("Cannot delete User resource before user created!")
self.resource_id_set(kp.access)
self._secret = kp.secret
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
self._secret = None
if self.resource_id is None:
raise exception.ResourceNotFound(resource_name=resource,
stack_name=self.stack.name)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def access_allowed(self, resource_name):
return resource_name in self.properties['AllowedResources']
else:
raise exception.Error(vol.status)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def _backup(self):
backup = self.cinder().backups.create(self.resource_id)
while backup.status == 'creating':
def check_create_complete(self, attach_runner):
return attach_runner.step()
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
server_id = self.properties[self._instance_property]
volume_id = self.properties[self._volume_property]
if ex.status_code != 404:
raise ex
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def resource_mapping():
if clients.quantumclient is None:
return
self.keystone().delete_stack_user(self.resource_id)
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def FnGetRefId(self):
'''
Override the default resource FnGetRefId so we return the signed URL
def check_create_complete(self, runner):
return runner.step()
- def handle_update(self, json_snippet):
- return self.UPDATE_REPLACE
-
def handle_delete(self):
if self.resource_id is None:
return
from heat.engine.resources import autoscaling as asc
from heat.engine.resources import loadbalancer
from heat.engine.resources import instance
+from heat.engine import resource
from heat.engine import scheduler
from heat.engine.resource import Metadata
from heat.openstack.common import timeutils
setup_dummy_db()
def create_scaling_group(self, t, stack, resource_name):
- resource = asc.AutoScalingGroup(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(asc.AutoScalingGroup.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = asc.AutoScalingGroup(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(asc.AutoScalingGroup.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def create_scaling_policy(self, t, stack, resource_name):
- resource = asc.ScalingPolicy(resource_name,
- t['Resources'][resource_name],
- stack)
+ rsrc = asc.ScalingPolicy(resource_name,
+ t['Resources'][resource_name],
+ stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
self.assertEqual(asc.ScalingPolicy.CREATE_COMPLETE,
- resource.state)
- return resource
+ rsrc.state)
+ return rsrc
def _stub_create(self, num):
self.m.StubOutWithMock(eventlet, 'sleep')
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
- self.assertEqual('WebServerGroup', resource.FnGetRefId())
- self.assertEqual('WebServerGroup-0', resource.resource_id)
- self.assertEqual(asc.AutoScalingGroup.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertEqual('WebServerGroup', rsrc.FnGetRefId())
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_update_ok_maxsize(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Reduce the max size to 2, should complete without adjusting
- update_snippet = copy.deepcopy(resource.parsed_template())
+ update_snippet = copy.deepcopy(rsrc.parsed_template())
update_snippet['Properties']['MaxSize'] = '2'
- self.assertEqual(asc.AutoScalingGroup.UPDATE_COMPLETE,
- resource.handle_update(update_snippet))
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ self.assertEqual(None, rsrc.handle_update(update_snippet))
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_update_ok_minsize(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Increase min size to 2, should trigger an ExactCapacity adjust
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1'])
self._stub_create(1)
self.m.ReplayAll()
- update_snippet = copy.deepcopy(resource.parsed_template())
+ update_snippet = copy.deepcopy(rsrc.parsed_template())
update_snippet['Properties']['MinSize'] = '2'
- self.assertEqual(asc.AutoScalingGroup.UPDATE_COMPLETE,
- resource.handle_update(update_snippet))
+ self.assertEqual(None, rsrc.handle_update(update_snippet))
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_update_ok_desired(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Increase min size to 2 via DesiredCapacity, should adjust
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1'])
self._stub_create(1)
self.m.ReplayAll()
- update_snippet = copy.deepcopy(resource.parsed_template())
+ update_snippet = copy.deepcopy(rsrc.parsed_template())
update_snippet['Properties']['DesiredCapacity'] = '2'
- self.assertEqual(asc.AutoScalingGroup.UPDATE_COMPLETE,
- resource.handle_update(update_snippet))
+ self.assertEqual(None, rsrc.handle_update(update_snippet))
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_update_ok_desired_remove(self):
self._stub_meta_expected(now, 'ExactCapacity : 2')
self._stub_create(2)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Remove DesiredCapacity from the updated template, which should
# have no effect, it's an optional parameter
- update_snippet = copy.deepcopy(resource.parsed_template())
+ update_snippet = copy.deepcopy(rsrc.parsed_template())
del(update_snippet['Properties']['DesiredCapacity'])
- self.assertEqual(asc.AutoScalingGroup.UPDATE_COMPLETE,
- resource.handle_update(update_snippet))
+ self.assertEqual(None, rsrc.handle_update(update_snippet))
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_update_ok_cooldown(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
- self.assertEqual('WebServerGroup', resource.FnGetRefId())
- self.assertEqual('WebServerGroup-0', resource.resource_id)
- update_snippet = copy.deepcopy(resource.parsed_template())
+ self.assertEqual('WebServerGroup', rsrc.FnGetRefId())
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
+ update_snippet = copy.deepcopy(rsrc.parsed_template())
update_snippet['Properties']['Cooldown'] = '61'
- self.assertEqual(asc.AutoScalingGroup.UPDATE_COMPLETE,
- resource.handle_update(update_snippet))
+ self.assertEqual(None, rsrc.handle_update(update_snippet))
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_adjust(self):
self._stub_meta_expected(now, 'ExactCapacity : 3')
self._stub_create(3)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
# reduce to 1
self._stub_lb_reload(['WebServerGroup-0'])
self._stub_meta_expected(now, 'ChangeInCapacity : -2')
self.m.ReplayAll()
- resource.adjust(-2)
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc.adjust(-2)
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# raise to 3
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1',
self._stub_meta_expected(now, 'ChangeInCapacity : 2')
self._stub_create(2)
self.m.ReplayAll()
- resource.adjust(2)
+ rsrc.adjust(2)
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
# set to 2
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1'])
self._stub_meta_expected(now, 'ExactCapacity : 2')
self.m.ReplayAll()
- resource.adjust(2, 'ExactCapacity')
+ rsrc.adjust(2, 'ExactCapacity')
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
self.m.VerifyAll()
def test_scaling_group_nochange(self):
self._stub_meta_expected(now, 'ExactCapacity : 2')
self._stub_create(2)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# raise above the max
- resource.adjust(4)
+ rsrc.adjust(4)
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# lower below the min
- resource.adjust(-2)
+ rsrc.adjust(-2)
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# no change
- resource.adjust(0)
+ rsrc.adjust(0)
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
- resource.delete()
+ rsrc.resource_id)
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_group_percent(self):
now = timeutils.utcnow()
self._stub_meta_expected(now, 'ExactCapacity : 2')
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# reduce by 50%
self._stub_lb_reload(['WebServerGroup-0'])
self._stub_meta_expected(now, 'PercentChangeInCapacity : -50')
self.m.ReplayAll()
- resource.adjust(-50, 'PercentChangeInCapacity')
+ rsrc.adjust(-50, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0',
- resource.resource_id)
+ rsrc.resource_id)
# raise by 200%
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1',
self._stub_meta_expected(now, 'PercentChangeInCapacity : 200')
self._stub_create(2)
self.m.ReplayAll()
- resource.adjust(200, 'PercentChangeInCapacity')
+ rsrc.adjust(200, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
def test_scaling_group_cooldown_toosoon(self):
t = template_format.parse(as_template)
self._stub_meta_expected(now, 'ExactCapacity : 2')
self._stub_create(2)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# reduce by 50%
self._stub_lb_reload(['WebServerGroup-0'])
self._stub_meta_expected(now, 'PercentChangeInCapacity : -50')
self.m.ReplayAll()
- resource.adjust(-50, 'PercentChangeInCapacity')
+ rsrc.adjust(-50, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0',
- resource.resource_id)
+ rsrc.resource_id)
# Now move time on 10 seconds - Cooldown in template is 60
# so this should not update the policy metadata, and the
timeutils.utcnow().AndReturn(now)
self.m.StubOutWithMock(Metadata, '__get__')
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
self.m.ReplayAll()
# raise by 200%, too soon for Cooldown so there should be no change
- resource.adjust(200, 'PercentChangeInCapacity')
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc.adjust(200, 'PercentChangeInCapacity')
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
def test_scaling_group_cooldown_ok(self):
t = template_format.parse(as_template)
now = timeutils.utcnow()
self._stub_meta_expected(now, 'ExactCapacity : 2')
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# reduce by 50%
self._stub_lb_reload(['WebServerGroup-0'])
self._stub_meta_expected(now, 'PercentChangeInCapacity : -50')
self.m.ReplayAll()
- resource.adjust(-50, 'PercentChangeInCapacity')
+ rsrc.adjust(-50, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0',
- resource.resource_id)
+ rsrc.resource_id)
# Now move time on 61 seconds - Cooldown in template is 60
# so this should update the policy metadata, and the
now = now + datetime.timedelta(seconds=61)
self.m.StubOutWithMock(Metadata, '__get__')
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
# raise by 200%, should work
self._stub_create(2)
self._stub_meta_expected(now, 'PercentChangeInCapacity : 200')
self.m.ReplayAll()
- resource.adjust(200, 'PercentChangeInCapacity')
+ rsrc.adjust(200, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
def test_scaling_group_cooldown_zero(self):
t = template_format.parse(as_template)
self._stub_meta_expected(now, 'ExactCapacity : 2')
self._stub_create(2)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# reduce by 50%
self._stub_lb_reload(['WebServerGroup-0'])
self._stub_meta_expected(now, 'PercentChangeInCapacity : -50')
self.m.ReplayAll()
- resource.adjust(-50, 'PercentChangeInCapacity')
+ rsrc.adjust(-50, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0',
- resource.resource_id)
+ rsrc.resource_id)
# Don't move time, since cooldown is zero, it should work
previous_meta = {timeutils.strtime(now):
self.m.UnsetStubs()
self.m.StubOutWithMock(Metadata, '__get__')
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
# raise by 200%, should work
self._stub_meta_expected(now, 'PercentChangeInCapacity : 200')
self._stub_create(2)
self.m.ReplayAll()
- resource.adjust(200, 'PercentChangeInCapacity')
+ rsrc.adjust(200, 'PercentChangeInCapacity')
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_up(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Scale up one
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1'])
'WebServerScaleUpPolicy')
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_down(self):
self._stub_meta_expected(now, 'ExactCapacity : 2')
self._stub_create(2)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Scale down one
self._stub_lb_reload(['WebServerGroup-0'])
down_policy = self.create_scaling_policy(t, stack,
'WebServerScaleDownPolicy')
down_policy.alarm()
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_cooldown_toosoon(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Scale up one
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1'])
'WebServerScaleUpPolicy')
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Now move time on 10 seconds - Cooldown in template is 60
# so this should not update the policy metadata, and the
self.m.ReplayAll()
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_cooldown_ok(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Scale up one
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1'])
'WebServerScaleUpPolicy')
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Now move time on 61 seconds - Cooldown in template is 60
# so this should trigger a scale-up
self.m.StubOutWithMock(Metadata, '__get__')
Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg()
).AndReturn(previous_meta)
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
now = now + datetime.timedelta(seconds=61)
self.m.ReplayAll()
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_cooldown_zero(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Create the scaling policy (with Cooldown=0) and scale up one
properties = t['Resources']['WebServerScaleUpPolicy']['Properties']
'WebServerScaleUpPolicy')
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Now trigger another scale-up without changing time, should work
previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'}
self.m.StubOutWithMock(Metadata, '__get__')
Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg()
).AndReturn(previous_meta)
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1',
self.m.ReplayAll()
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_cooldown_none(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Create the scaling policy no Cooldown property, should behave the
# same as when Cooldown==0
'WebServerScaleUpPolicy')
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Now trigger another scale-up without changing time, should work
previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'}
self.m.StubOutWithMock(Metadata, '__get__')
Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg()
).AndReturn(previous_meta)
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
self._stub_lb_reload(['WebServerGroup-0', 'WebServerGroup-1',
self.m.ReplayAll()
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_scaling_policy_update(self):
self._stub_meta_expected(now, 'ExactCapacity : 1')
self._stub_create(1)
self.m.ReplayAll()
- resource = self.create_scaling_group(t, stack, 'WebServerGroup')
- stack.resources['WebServerGroup'] = resource
- self.assertEqual('WebServerGroup-0', resource.resource_id)
+ rsrc = self.create_scaling_group(t, stack, 'WebServerGroup')
+ stack.resources['WebServerGroup'] = rsrc
+ self.assertEqual('WebServerGroup-0', rsrc.resource_id)
# Create initial scaling policy
up_policy = self.create_scaling_policy(t, stack,
# Trigger alarm
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
# Update scaling policy
update_snippet = copy.deepcopy(up_policy.parsed_template())
update_snippet['Properties']['ScalingAdjustment'] = '2'
- self.assertEqual(asc.ScalingPolicy.UPDATE_COMPLETE,
+ self.assertEqual(None,
up_policy.handle_update(update_snippet))
self.assertEqual('2',
up_policy.properties['ScalingAdjustment'])
self.m.StubOutWithMock(Metadata, '__get__')
Metadata.__get__(mox.IgnoreArg(), up_policy, mox.IgnoreArg()
).AndReturn(previous_meta)
- Metadata.__get__(mox.IgnoreArg(), resource, mox.IgnoreArg()
+ Metadata.__get__(mox.IgnoreArg(), rsrc, mox.IgnoreArg()
).AndReturn(previous_meta)
now = now + datetime.timedelta(seconds=61)
up_policy.alarm()
self.assertEqual('WebServerGroup-0,WebServerGroup-1,'
'WebServerGroup-2,WebServerGroup-3',
- resource.resource_id)
+ rsrc.resource_id)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
from heat.common import template_format
from heat.engine.resources import cloud_watch
+from heat.engine import resource
from heat.engine import scheduler
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
setup_dummy_db()
def create_alarm(self, t, stack, resource_name):
- resource = cloud_watch.CloudWatchAlarm(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
+ rsrc = cloud_watch.CloudWatchAlarm(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
self.assertEqual(cloud_watch.CloudWatchAlarm.CREATE_COMPLETE,
- resource.state)
- return resource
+ rsrc.state)
+ return rsrc
def test_mem_alarm_high_update_no_replace(self):
'''
Make sure that we can change the update-able properties
- without replacing the Alarm resource.
+ without replacing the Alarm rsrc.
'''
t = template_format.parse(alarm_template)
stack.store()
self.m.ReplayAll()
- resource = self.create_alarm(t, stack, 'MEMAlarmHigh')
- snippet = copy.deepcopy(resource.parsed_template())
+ rsrc = self.create_alarm(t, stack, 'MEMAlarmHigh')
+ snippet = copy.deepcopy(rsrc.parsed_template())
snippet['Properties']['ComparisonOperator'] = 'LessThanThreshold'
snippet['Properties']['AlarmDescription'] = 'fruity'
snippet['Properties']['EvaluationPeriods'] = '2'
snippet['Properties']['Statistic'] = 'Maximum'
snippet['Properties']['Threshold'] = '39'
- self.assertEqual(cloud_watch.CloudWatchAlarm.UPDATE_COMPLETE,
- resource.handle_update(snippet))
+ self.assertEqual(None, rsrc.handle_update(snippet))
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_mem_alarm_high_update_replace(self):
stack.store()
self.m.ReplayAll()
- resource = self.create_alarm(t, stack, 'MEMAlarmHigh')
- snippet = copy.deepcopy(resource.parsed_template())
+ rsrc = self.create_alarm(t, stack, 'MEMAlarmHigh')
+ snippet = copy.deepcopy(rsrc.parsed_template())
snippet['Properties']['MetricName'] = 'temp'
- self.assertEqual(cloud_watch.CloudWatchAlarm.UPDATE_REPLACE,
- resource.handle_update(snippet))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, snippet)
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
from heat.common import template_format
from heat.engine.resources import eip
+from heat.engine import resource
from heat.engine import scheduler
from heat.tests.common import HeatTestCase
from heat.tests.v1_1 import fakes
setup_dummy_db()
def create_eip(self, t, stack, resource_name):
- resource = eip.ElasticIp(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(eip.ElasticIp.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = eip.ElasticIp(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(eip.ElasticIp.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def create_association(self, t, stack, resource_name):
- resource = eip.ElasticIpAssociation(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
+ rsrc = eip.ElasticIpAssociation(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
self.assertEqual(eip.ElasticIpAssociation.CREATE_COMPLETE,
- resource.state)
- return resource
+ rsrc.state)
+ return rsrc
def test_eip(self):
t = template_format.parse(eip_template)
stack = parse_stack(t)
- resource = self.create_eip(t, stack, 'IPAddress')
+ rsrc = self.create_eip(t, stack, 'IPAddress')
try:
- self.assertEqual('11.0.0.1', resource.FnGetRefId())
- resource.ipaddress = None
- self.assertEqual('11.0.0.1', resource.FnGetRefId())
+ self.assertEqual('11.0.0.1', rsrc.FnGetRefId())
+ rsrc.ipaddress = None
+ self.assertEqual('11.0.0.1', rsrc.FnGetRefId())
- self.assertEqual('1', resource.FnGetAtt('AllocationId'))
+ self.assertEqual('1', rsrc.FnGetAtt('AllocationId'))
- self.assertEqual(eip.ElasticIp.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
self.assertRaises(eip.exception.InvalidTemplateAttribute,
- resource.FnGetAtt, 'Foo')
+ rsrc.FnGetAtt, 'Foo')
finally:
- resource.destroy()
+ rsrc.destroy()
self.m.VerifyAll()
t = template_format.parse(eip_template)
stack = parse_stack(t)
- resource = self.create_eip(t, stack, 'IPAddress')
+ rsrc = self.create_eip(t, stack, 'IPAddress')
association = self.create_association(t, stack, 'IPAssoc')
# TODO(sbaker), figure out why this is an empty string
#self.assertEqual('', association.FnGetRefId())
association.delete()
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
update_template = copy.deepcopy(instance.t)
update_template['Metadata'] = {'test': 123}
- self.assertEqual(instance.update(update_template),
- instance.UPDATE_COMPLETE)
+ self.assertEqual(None, instance.update(update_template))
self.assertEqual(instance.metadata, {'test': 123})
def test_instance_status_build(self):
from heat.common import template_format
from heat.engine.resources import autoscaling as asc
from heat.engine.resources import instance
+from heat.engine import resource
from heat.engine import scheduler
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
cookie).MultipleTimes().AndReturn(True)
def create_instance_group(self, t, stack, resource_name):
- resource = asc.InstanceGroup(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(asc.InstanceGroup.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = asc.InstanceGroup(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(asc.InstanceGroup.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_instance_group(self):
instance.Instance.FnGetAtt('PublicIp').AndReturn('1.2.3.4')
self.m.ReplayAll()
- resource = self.create_instance_group(t, stack, 'JobServerGroup')
+ rsrc = self.create_instance_group(t, stack, 'JobServerGroup')
- self.assertEqual('JobServerGroup', resource.FnGetRefId())
- self.assertEqual('1.2.3.4', resource.FnGetAtt('InstanceList'))
- self.assertEqual('JobServerGroup-0', resource.resource_id)
- self.assertEqual(asc.InstanceGroup.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertEqual('JobServerGroup', rsrc.FnGetRefId())
+ self.assertEqual('1.2.3.4', rsrc.FnGetAtt('InstanceList'))
+ self.assertEqual('JobServerGroup-0', rsrc.resource_id)
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_missing_image(self):
t = template_format.parse(ig_template)
stack = parse_stack(t)
- resource = asc.InstanceGroup('JobServerGroup',
- t['Resources']['JobServerGroup'],
- stack)
+ rsrc = asc.InstanceGroup('JobServerGroup',
+ t['Resources']['JobServerGroup'],
+ stack)
self.m.StubOutWithMock(instance.Instance, 'handle_create')
not_found = exception.ImageNotFound(image_name='bla')
self.m.ReplayAll()
- create = scheduler.TaskRunner(resource.create)
+ create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
- self.assertEqual(asc.InstanceGroup.CREATE_FAILED, resource.state)
+ self.assertEqual(asc.InstanceGroup.CREATE_FAILED, rsrc.state)
self.m.VerifyAll()
self._stub_create(2)
self.m.ReplayAll()
- resource = self.create_instance_group(t, stack, 'JobServerGroup')
+ rsrc = self.create_instance_group(t, stack, 'JobServerGroup')
self.assertEqual('JobServerGroup-0,JobServerGroup-1',
- resource.resource_id)
+ rsrc.resource_id)
self.m.VerifyAll()
self.m.UnsetStubs()
self.m.ReplayAll()
- update_snippet = copy.deepcopy(resource.parsed_template())
+ update_snippet = copy.deepcopy(rsrc.parsed_template())
update_snippet['Properties']['Size'] = '5'
- self.assertEqual(asc.AutoScalingGroup.UPDATE_COMPLETE,
- resource.handle_update(update_snippet))
+ self.assertEqual(None, rsrc.handle_update(update_snippet))
assert_str = ','.join(['JobServerGroup-%s' % x for x in range(5)])
self.assertEqual(assert_str,
- resource.resource_id)
+ rsrc.resource_id)
self.assertEqual('10.0.0.2,10.0.0.3,10.0.0.4,10.0.0.5,10.0.0.6',
- resource.FnGetAtt('InstanceList'))
+ rsrc.FnGetAtt('InstanceList'))
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
from heat.common import config
from heat.common import template_format
from heat.engine import clients
+from heat.engine import resource
from heat.engine import scheduler
from heat.engine.resources import instance
from heat.engine.resources import user
setup_dummy_db()
def create_loadbalancer(self, t, stack, resource_name):
- resource = lb.LoadBalancer(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(lb.LoadBalancer.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = lb.LoadBalancer(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(lb.LoadBalancer.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_loadbalancer(self):
self.m.StubOutWithMock(user.User, 'keystone')
s = parse_stack(t)
s.store()
- resource = self.create_loadbalancer(t, s, 'LoadBalancer')
+ rsrc = self.create_loadbalancer(t, s, 'LoadBalancer')
hc = {
'Target': 'HTTP:80/',
'UnhealthyThreshold': '5',
'Interval': '30',
'Timeout': '5'}
- resource.t['Properties']['HealthCheck'] = hc
- self.assertEqual(None, resource.validate())
+ rsrc.t['Properties']['HealthCheck'] = hc
+ self.assertEqual(None, rsrc.validate())
hc['Timeout'] = 35
self.assertEqual(
{'Error': 'Interval must be larger than Timeout'},
- resource.validate())
+ rsrc.validate())
hc['Timeout'] = 5
- self.assertEqual('LoadBalancer', resource.FnGetRefId())
+ self.assertEqual('LoadBalancer', rsrc.FnGetRefId())
templ = template_format.parse(lb.lb_template)
- ha_cfg = resource._haproxy_config(templ,
- resource.properties['Instances'])
+ ha_cfg = rsrc._haproxy_config(templ, rsrc.properties['Instances'])
self.assertRegexpMatches(ha_cfg, 'bind \*:80')
self.assertRegexpMatches(ha_cfg, 'server server1 1\.2\.3\.4:80 '
'check inter 30s fall 5 rise 3')
s)
id_list.append(inst.FnGetRefId())
- resource.reload(id_list)
+ rsrc.reload(id_list)
- self.assertEqual('4.5.6.7', resource.FnGetAtt('DNSName'))
- self.assertEqual('', resource.FnGetAtt('SourceSecurityGroupName'))
+ self.assertEqual('4.5.6.7', rsrc.FnGetAtt('DNSName'))
+ self.assertEqual('', rsrc.FnGetAtt('SourceSecurityGroupName'))
try:
- resource.FnGetAtt('Foo')
+ rsrc.FnGetAtt('Foo')
raise Exception('Expected InvalidTemplateAttribute')
except exception.InvalidTemplateAttribute:
pass
- self.assertEqual(lb.LoadBalancer.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
self.m.VerifyAll()
from heat.common import exception
from heat.common import template_format
from heat.engine import parser
-from heat.engine.resources import stack as nested_stack
+from heat.engine import resource
from heat.common import urlfetch
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
self.m.ReplayAll()
stack = self.create_stack(self.test_template)
- resource = stack['the_nested']
- self.assertTrue(resource.FnGetRefId().startswith(
+ rsrc = stack['the_nested']
+ self.assertTrue(rsrc.FnGetRefId().startswith(
'arn:openstack:heat::aaaa:stacks/test_stack.the_nested/'))
- self.assertEqual(nested_stack.NestedStack.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- self.assertEqual('bar', resource.FnGetAtt('Outputs.Foo'))
+ self.assertEqual('bar', rsrc.FnGetAtt('Outputs.Foo'))
self.assertRaises(
- exception.InvalidTemplateAttribute, resource.FnGetAtt, 'Foo')
+ exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'Foo')
- resource.delete()
- self.assertTrue(resource.FnGetRefId().startswith(
+ rsrc.delete()
+ self.assertTrue(rsrc.FnGetRefId().startswith(
'arn:openstack:heat::aaaa:stacks/test_stack.the_nested/'))
self.m.VerifyAll()
self.stack.create()
self.assertEqual(self.stack.state, parser.Stack.CREATE_COMPLETE)
self.assertTrue('AResource' in self.stack)
- resource = self.stack['AResource']
- resource.resource_id_set('aaaa')
+ rsrc = self.stack['AResource']
+ rsrc.resource_id_set('aaaa')
self.assertNotEqual(None, resource)
- self.assertEqual(resource, self.stack.resource_by_refid('aaaa'))
+ self.assertEqual(rsrc, self.stack.resource_by_refid('aaaa'))
- resource.state = resource.DELETE_IN_PROGRESS
+ rsrc.state = rsrc.DELETE_IN_PROGRESS
try:
self.assertEqual(None, self.stack.resource_by_refid('aaaa'))
self.assertEqual(None, self.stack.resource_by_refid('bbbb'))
finally:
- resource.state = resource.CREATE_COMPLETE
+ rsrc.state = rsrc.CREATE_COMPLETE
@stack_delete_after
def test_update_add(self):
# patch in a dummy handle_update
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
self.m.ReplayAll()
self.stack.update(updated_stack)
# patch in a dummy handle_update
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
# make the update fail deleting the existing resource
self.m.StubOutWithMock(resource.Resource, 'destroy')
# patch in a dummy handle_update
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
# patch in a dummy handle_create making the replace fail creating
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
# then another (with the initial template) for rollback
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
generic_rsrc.GenericResource.handle_update(
- tmpl['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
# patch in a dummy handle_create making the replace fail when creating
- # the replacement resource, but succeed the second call (rollback)
+ # the replacement rsrc, but succeed the second call (rollback)
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
generic_rsrc.GenericResource.handle_create().AndReturn(None)
# then another (with the initial template) for rollback
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
generic_rsrc.GenericResource.handle_update(
- tmpl['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
# patch in a dummy handle_create making the replace fail when creating
- # the replacement resource, and again on the second call (rollback)
+ # the replacement rsrc, and again on the second call (rollback)
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
template.Template(tmpl2))
# patch in a dummy handle_create making the replace fail when creating
- # the replacement resource, and succeed on the second call (rollback)
+ # the replacement rsrc, and succeed on the second call (rollback)
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
self.m.ReplayAll()
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
br2_snip = {'Type': 'GenericResourceType',
'Properties': {'Foo': 'inst-007'}}
generic_rsrc.GenericResource.handle_update(
- br2_snip).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ br2_snip).AndRaise(resource.UpdateReplace)
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'FnGetRefId')
generic_rsrc.GenericResource.FnGetRefId().AndReturn(
# mocks for first (failed update)
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
generic_rsrc.GenericResource.FnGetRefId().AndReturn(
'AResource')
# mocks for second rollback update
generic_rsrc.GenericResource.handle_update(
- tmpl['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
generic_rsrc.GenericResource.handle_create().AndReturn(None)
generic_rsrc.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
# mocks for first and second (failed update)
generic_rsrc.GenericResource.handle_update(
- tmpl2['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl2['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
br2_snip = {'Type': 'GenericResourceType',
'Properties': {'Foo': 'inst-007'}}
generic_rsrc.GenericResource.handle_update(
- br2_snip).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ br2_snip).AndRaise(resource.UpdateReplace)
generic_rsrc.GenericResource.FnGetRefId().AndReturn(
'AResource')
# mocks for second rollback update
generic_rsrc.GenericResource.handle_update(
- tmpl['Resources']['AResource']).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ tmpl['Resources']['AResource']).AndRaise(
+ resource.UpdateReplace)
br2_snip = {'Type': 'GenericResourceType',
'Properties': {'Foo': 'AResource'}}
generic_rsrc.GenericResource.handle_update(
- br2_snip).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ br2_snip).AndRaise(resource.UpdateReplace)
# self.state_set(self.DELETE_IN_PROGRESS)
generic_rsrc.GenericResource.FnGetRefId().AndReturn(
from heat.common import exception
from heat.common import template_format
from heat.engine import properties
+from heat.engine import resource
from heat.engine import scheduler
from heat.engine.resources.quantum import net
from heat.engine.resources.quantum import subnet
setup_dummy_db()
def create_net(self, t, stack, resource_name):
- resource = net.Net('test_net', t['Resources'][resource_name], stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(net.Net.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = net.Net('test_net', t['Resources'][resource_name], stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(net.Net.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_net(self):
quantumclient.Client.create_network({
self.m.ReplayAll()
t = template_format.parse(quantum_template)
stack = parse_stack(t)
- resource = self.create_net(t, stack, 'network')
+ rsrc = self.create_net(t, stack, 'network')
- resource.validate()
+ rsrc.validate()
- ref_id = resource.FnGetRefId()
+ ref_id = rsrc.FnGetRefId()
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766', ref_id)
- self.assertEqual(None, resource.FnGetAtt('status'))
- self.assertEqual('ACTIVE', resource.FnGetAtt('status'))
+ self.assertEqual(None, rsrc.FnGetAtt('status'))
+ self.assertEqual('ACTIVE', rsrc.FnGetAtt('status'))
try:
- resource.FnGetAtt('Foo')
+ rsrc.FnGetAtt('Foo')
raise Exception('Expected InvalidTemplateAttribute')
except exception.InvalidTemplateAttribute:
pass
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
- resource.FnGetAtt('id'))
+ rsrc.FnGetAtt('id'))
- self.assertEqual(net.Net.UPDATE_REPLACE, resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- resource.delete()
- resource.state_set(resource.CREATE_COMPLETE, 'to delete again')
- resource.delete()
+ rsrc.delete()
+ rsrc.state_set(rsrc.CREATE_COMPLETE, 'to delete again')
+ rsrc.delete()
self.m.VerifyAll()
setup_dummy_db()
def create_subnet(self, t, stack, resource_name):
- resource = subnet.Subnet('test_subnet', t['Resources'][resource_name],
- stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(subnet.Subnet.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = subnet.Subnet('test_subnet', t['Resources'][resource_name],
+ stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(subnet.Subnet.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_subnet(self):
self.m.ReplayAll()
t = template_format.parse(quantum_template)
stack = parse_stack(t)
- resource = self.create_subnet(t, stack, 'subnet')
+ rsrc = self.create_subnet(t, stack, 'subnet')
- resource.validate()
+ rsrc.validate()
- ref_id = resource.FnGetRefId()
+ ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertEqual(None,
- resource.FnGetAtt('network_id'))
+ rsrc.FnGetAtt('network_id'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
- resource.FnGetAtt('network_id'))
- self.assertEqual('8.8.8.8', resource.FnGetAtt('dns_nameservers')[0])
+ rsrc.FnGetAtt('network_id'))
+ self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0])
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1',
- resource.FnGetAtt('id'))
+ rsrc.FnGetAtt('id'))
- self.assertEqual(subnet.Subnet.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- self.assertEqual(resource.delete(), None)
- resource.state_set(resource.CREATE_COMPLETE, 'to delete again')
- self.assertEqual(resource.delete(), None)
+ self.assertEqual(rsrc.delete(), None)
+ rsrc.state_set(rsrc.CREATE_COMPLETE, 'to delete again')
+ self.assertEqual(rsrc.delete(), None)
self.m.VerifyAll()
setup_dummy_db()
def create_router(self, t, stack, resource_name):
- resource = router.Router('router', t['Resources'][resource_name],
- stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(router.Router.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = router.Router('router', t['Resources'][resource_name], stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(router.Router.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def create_router_interface(self, t, stack, resource_name, properties={}):
t['Resources'][resource_name]['Properties'] = properties
- resource = router.RouterInterface(
+ rsrc = router.RouterInterface(
'router_interface',
t['Resources'][resource_name],
stack)
- scheduler.TaskRunner(resource.create)()
+ scheduler.TaskRunner(rsrc.create)()
self.assertEqual(
- router.RouterInterface.CREATE_COMPLETE, resource.state)
- return resource
+ router.RouterInterface.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def create_gateway_router(self, t, stack, resource_name, properties={}):
t['Resources'][resource_name]['Properties'] = properties
- resource = router.RouterGateway(
+ rsrc = router.RouterGateway(
'gateway',
t['Resources'][resource_name],
stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(router.RouterGateway.CREATE_COMPLETE, resource.state)
- return resource
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(router.RouterGateway.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_router(self):
quantumclient.Client.create_router({
self.m.ReplayAll()
t = template_format.parse(quantum_template)
stack = parse_stack(t)
- resource = self.create_router(t, stack, 'router')
+ rsrc = self.create_router(t, stack, 'router')
- resource.validate()
+ rsrc.validate()
- ref_id = resource.FnGetRefId()
+ ref_id = rsrc.FnGetRefId()
self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8', ref_id)
self.assertEqual(None,
- resource.FnGetAtt('tenant_id'))
+ rsrc.FnGetAtt('tenant_id'))
self.assertEqual('3e21026f2dc94372b105808c0e721661',
- resource.FnGetAtt('tenant_id'))
+ rsrc.FnGetAtt('tenant_id'))
self.assertEqual('3e46229d-8fce-4733-819a-b5fe630550f8',
- resource.FnGetAtt('id'))
+ rsrc.FnGetAtt('id'))
- self.assertEqual(router.Router.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- self.assertEqual(resource.delete(), None)
- resource.state_set(resource.CREATE_COMPLETE, 'to delete again')
- self.assertEqual(resource.delete(), None)
+ self.assertEqual(rsrc.delete(), None)
+ rsrc.state_set(rsrc.CREATE_COMPLETE, 'to delete again')
+ self.assertEqual(rsrc.delete(), None)
self.m.VerifyAll()
def test_router_interface(self):
t = template_format.parse(quantum_template)
stack = parse_stack(t)
- resource = self.create_router_interface(
+ rsrc = self.create_router_interface(
t, stack, 'router_interface', properties={
'router_id': '3e46229d-8fce-4733-819a-b5fe630550f8',
'subnet_id': '91e47a57-7508-46fe-afc9-fc454e8580e1'
})
- self.assertEqual(resource.delete(), None)
- resource.state_set(resource.CREATE_COMPLETE, 'to delete again')
- self.assertEqual(resource.delete(), None)
+ self.assertEqual(rsrc.delete(), None)
+ rsrc.state_set(rsrc.CREATE_COMPLETE, 'to delete again')
+ self.assertEqual(rsrc.delete(), None)
self.m.VerifyAll()
def test_gateway_router(self):
t = template_format.parse(quantum_template)
stack = parse_stack(t)
- resource = self.create_gateway_router(
+ rsrc = self.create_gateway_router(
t, stack, 'gateway', properties={
'router_id': '3e46229d-8fce-4733-819a-b5fe630550f8',
'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
})
- self.assertEqual(resource.delete(), None)
- resource.state_set(resource.CREATE_COMPLETE, 'to delete again')
- self.assertEqual(resource.delete(), None)
+ self.assertEqual(rsrc.delete(), None)
+ rsrc.state_set(rsrc.CREATE_COMPLETE, 'to delete again')
+ self.assertEqual(rsrc.delete(), None)
self.m.VerifyAll()
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
fip.FnGetAtt('id'))
- self.assertEqual(floatingip.FloatingIP.UPDATE_REPLACE,
- fip.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ fip.handle_update, {})
self.assertEqual(fip.delete(), None)
fip.state_set(fip.CREATE_COMPLETE, 'to delete again')
self.assertEqual(fip.delete(), None)
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
p.FnGetAtt('id'))
- self.assertEqual(port.Port.UPDATE_REPLACE,
- p.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ p.handle_update, {})
self.m.VerifyAll()
fip_id = fip.FnGetRefId()
port_id = p.FnGetRefId()
self.assertEqual('%s:%s' % (fip_id, port_id), fipa_id)
- self.assertEqual(floatingip.FloatingIP.UPDATE_REPLACE,
- fipa.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ fipa.handle_update, {})
self.assertEqual(fipa.delete(), None)
self.assertEqual(p.delete(), None)
tmpl = {'Type': 'Foo'}
update_snippet = {}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
- self.assertRaises(NotImplementedError, res.update_template_diff,
+ self.assertRaises(resource.UpdateReplace, res.update_template_diff,
update_snippet)
def test_update_template_diff_changed_notallowed(self):
tmpl = {'Type': 'Foo'}
update_snippet = {'Type': 'Bar'}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
- self.assertRaises(NotImplementedError, res.update_template_diff,
+ self.assertRaises(resource.UpdateReplace, res.update_template_diff,
update_snippet)
def test_update_template_diff_changed_modified(self):
update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 456}}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Cat',)
- self.assertRaises(NotImplementedError,
+ self.assertRaises(resource.UpdateReplace,
res.update_template_diff_properties,
update_snippet)
utmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'xyz'}}
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
- generic_rsrc.GenericResource.handle_update(utmpl).AndReturn(
- resource.Resource.UPDATE_COMPLETE)
+ generic_rsrc.GenericResource.handle_update(utmpl).AndReturn(None)
self.m.ReplayAll()
- self.assertEqual(res.UPDATE_COMPLETE, res.update(utmpl))
+ self.assertEqual(None, res.update(utmpl))
self.assertEqual(res.UPDATE_COMPLETE, res.state)
self.m.VerifyAll()
utmpl = {'Type': 'GenericResourceType', 'Properties': {'Foo': 'xyz'}}
self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
- generic_rsrc.GenericResource.handle_update(utmpl).AndReturn(
- resource.Resource.UPDATE_REPLACE)
+ generic_rsrc.GenericResource.handle_update(utmpl).AndRaise(
+ resource.UpdateReplace())
self.m.ReplayAll()
- self.assertEqual(res.UPDATE_REPLACE, res.update(utmpl))
+ # should be re-raised so parser.Stack can handle replacement
+ self.assertRaises(resource.UpdateReplace, res.update, utmpl)
self.m.VerifyAll()
def test_update_fail_missing_req_prop(self):
from heat.common import template_format
from heat.openstack.common.importutils import try_import
from heat.engine.resources import s3
+from heat.engine import resource
from heat.engine import scheduler
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
setup_dummy_db()
def create_resource(self, t, stack, resource_name):
- resource = s3.S3Bucket('test_resource',
- t['Resources'][resource_name],
- stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(s3.S3Bucket.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = s3.S3Bucket('test_resource',
+ t['Resources'][resource_name],
+ stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(s3.S3Bucket.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_create_container_name(self):
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = s3.S3Bucket('test_resource',
- t['Resources']['S3Bucket'],
- stack)
+ rsrc = s3.S3Bucket('test_resource',
+ t['Resources']['S3Bucket'],
+ stack)
self.assertTrue(re.match(self.container_pattern,
- resource._create_container_name()))
+ rsrc._create_container_name()))
def test_attributes(self):
swiftclient.Connection.put_container(
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3Bucket')
+ rsrc = self.create_resource(t, stack, 'S3Bucket')
- ref_id = resource.FnGetRefId()
+ ref_id = rsrc.FnGetRefId()
self.assertTrue(re.match(self.container_pattern,
ref_id))
- self.assertEqual('localhost', resource.FnGetAtt('DomainName'))
+ self.assertEqual('localhost', rsrc.FnGetAtt('DomainName'))
url = 'http://localhost:8080/v_2/%s' % ref_id
- self.assertEqual(url, resource.FnGetAtt('WebsiteURL'))
+ self.assertEqual(url, rsrc.FnGetAtt('WebsiteURL'))
try:
- resource.FnGetAtt('Foo')
+ rsrc.FnGetAtt('Foo')
raise Exception('Expected InvalidTemplateAttribute')
except s3.exception.InvalidTemplateAttribute:
pass
- self.assertEqual(s3.S3Bucket.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_public_read(self):
properties = t['Resources']['S3Bucket']['Properties']
properties['AccessControl'] = 'PublicRead'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3Bucket')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'S3Bucket')
+ rsrc.delete()
self.m.VerifyAll()
def test_public_read_write(self):
properties = t['Resources']['S3Bucket']['Properties']
properties['AccessControl'] = 'PublicReadWrite'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3Bucket')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'S3Bucket')
+ rsrc.delete()
self.m.VerifyAll()
def test_authenticated_read(self):
properties = t['Resources']['S3Bucket']['Properties']
properties['AccessControl'] = 'AuthenticatedRead'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3Bucket')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'S3Bucket')
+ rsrc.delete()
self.m.VerifyAll()
def test_website(self):
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3BucketWebsite')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'S3BucketWebsite')
+ rsrc.delete()
self.m.VerifyAll()
def test_delete_exception(self):
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3Bucket')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'S3Bucket')
+ rsrc.delete()
self.m.VerifyAll()
bucket = t['Resources']['S3Bucket']
bucket['DeletionPolicy'] = 'Retain'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'S3Bucket')
+ rsrc = self.create_resource(t, stack, 'S3Bucket')
# if delete_container is called, mox verify will succeed
- resource.delete()
- self.assertEqual(resource.DELETE_COMPLETE, resource.state)
+ rsrc.delete()
+ self.assertEqual(rsrc.DELETE_COMPLETE, rsrc.state)
try:
self.m.VerifyAll()
from heat.common import context
from heat.common import template_format
from heat.engine import parser
+from heat.engine import resource
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
from heat.tests.v1_1 import fakes
stack.store()
return stack
- def assertResourceState(self, resource, ref_id, metadata={}):
- self.assertEqual(None, resource.validate())
- self.assertEqual(resource.CREATE_COMPLETE, resource.state)
- self.assertEqual(ref_id, resource.FnGetRefId())
- self.assertEqual(metadata, dict(resource.metadata))
+ def assertResourceState(self, rsrc, ref_id, metadata={}):
+ self.assertEqual(None, rsrc.validate())
+ self.assertEqual(rsrc.CREATE_COMPLETE, rsrc.state)
+ self.assertEqual(ref_id, rsrc.FnGetRefId())
+ self.assertEqual(metadata, dict(rsrc.metadata))
@stack_delete_after
def test_security_group_nova(self):
stack = self.create_stack(self.test_template_nova)
sg = stack['the_sg']
- self.assertEqual(sg.UPDATE_REPLACE, sg.handle_update({}))
+ self.assertRaises(resource.UpdateReplace, sg.handle_update, {})
self.assertResourceState(sg, 'the_sg')
stack = self.create_stack(self.test_template_nova)
sg = stack['the_sg']
- self.assertEqual(sg.UPDATE_REPLACE, sg.handle_update({}))
+ self.assertRaises(resource.UpdateReplace, sg.handle_update, {})
self.assertResourceState(sg, 'the_sg')
stack = self.create_stack(self.test_template_quantum)
sg = stack['the_sg']
- self.assertEqual(sg.UPDATE_REPLACE, sg.handle_update({}))
+ self.assertRaises(resource.UpdateReplace, sg.handle_update, {})
self.assertResourceState(sg, 'the_sg')
stack = self.create_stack(self.test_template_quantum)
sg = stack['the_sg']
- self.assertEqual(sg.UPDATE_REPLACE, sg.handle_update({}))
+ self.assertRaises(resource.UpdateReplace, sg.handle_update, {})
self.assertResourceState(sg, 'the_sg')
from heat.common import template_format
from heat.openstack.common.importutils import try_import
from heat.engine.resources import swift
+from heat.engine import resource
from heat.engine import scheduler
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
setup_dummy_db()
def create_resource(self, t, stack, resource_name):
- resource = swift.SwiftContainer(
+ rsrc = swift.SwiftContainer(
'test_resource',
t['Resources'][resource_name],
stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(swift.SwiftContainer.CREATE_COMPLETE, resource.state)
- return resource
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(swift.SwiftContainer.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_create_container_name(self):
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = swift.SwiftContainer(
+ rsrc = swift.SwiftContainer(
'test_resource',
t['Resources']['SwiftContainer'],
stack)
self.assertTrue(re.match(self.container_pattern,
- resource._create_container_name()))
+ rsrc._create_container_name()))
self.assertEqual(
'the_name',
- resource._create_container_name('the_name'))
+ rsrc._create_container_name('the_name'))
def test_build_meta_headers(self):
self.m.UnsetStubs()
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'SwiftContainer')
+ rsrc = self.create_resource(t, stack, 'SwiftContainer')
- ref_id = resource.FnGetRefId()
+ ref_id = rsrc.FnGetRefId()
self.assertTrue(re.match(self.container_pattern,
ref_id))
- self.assertEqual('localhost', resource.FnGetAtt('DomainName'))
+ self.assertEqual('localhost', rsrc.FnGetAtt('DomainName'))
url = 'http://localhost:8080/v_2/%s' % ref_id
- self.assertEqual(url, resource.FnGetAtt('WebsiteURL'))
- self.assertEqual('82', resource.FnGetAtt('ObjectCount'))
- self.assertEqual('17680980', resource.FnGetAtt('BytesUsed'))
- self.assertEqual(headers, resource.FnGetAtt('HeadContainer'))
+ self.assertEqual(url, rsrc.FnGetAtt('WebsiteURL'))
+ self.assertEqual('82', rsrc.FnGetAtt('ObjectCount'))
+ self.assertEqual('17680980', rsrc.FnGetAtt('BytesUsed'))
+ self.assertEqual(headers, rsrc.FnGetAtt('HeadContainer'))
try:
- resource.FnGetAtt('Foo')
+ rsrc.FnGetAtt('Foo')
raise Exception('Expected InvalidTemplateAttribute')
except swift.exception.InvalidTemplateAttribute:
pass
- self.assertEqual(swift.SwiftContainer.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- resource.delete()
+ rsrc.delete()
self.m.VerifyAll()
def test_public_read(self):
properties = t['Resources']['SwiftContainer']['Properties']
properties['X-Container-Read'] = '.r:*'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'SwiftContainer')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'SwiftContainer')
+ rsrc.delete()
self.m.VerifyAll()
def test_public_read_write(self):
properties['X-Container-Read'] = '.r:*'
properties['X-Container-Write'] = '.r:*'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'SwiftContainer')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'SwiftContainer')
+ rsrc.delete()
self.m.VerifyAll()
def test_website(self):
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'SwiftContainerWebsite')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'SwiftContainerWebsite')
+ rsrc.delete()
self.m.VerifyAll()
def test_delete_exception(self):
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'SwiftContainer')
- resource.delete()
+ rsrc = self.create_resource(t, stack, 'SwiftContainer')
+ rsrc.delete()
self.m.VerifyAll()
container = t['Resources']['SwiftContainer']
container['DeletionPolicy'] = 'Retain'
stack = parse_stack(t)
- resource = self.create_resource(t, stack, 'SwiftContainer')
+ rsrc = self.create_resource(t, stack, 'SwiftContainer')
# if delete_container is called, mox verify will succeed
- resource.delete()
- self.assertEqual(resource.DELETE_COMPLETE, resource.state)
+ rsrc.delete()
+ self.assertEqual(rsrc.DELETE_COMPLETE, rsrc.state)
try:
self.m.VerifyAll()
from heat.common import config
from heat.common import exception
from heat.common import template_format
+from heat.engine import resource
from heat.engine import scheduler
from heat.engine.resources import user
from heat.tests.common import HeatTestCase
class UserTest(UserPolicyTestCase):
def create_user(self, t, stack, resource_name):
- resource = user.User(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(user.User.CREATE_COMPLETE, resource.state)
- return resource
+ rsrc = user.User(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(user.User.CREATE_COMPLETE, rsrc.state)
+ return rsrc
def test_user(self):
t = template_format.parse(user_template)
stack = parse_stack(t)
- resource = self.create_user(t, stack, 'CfnUser')
- self.assertEqual(self.fc.user_id, resource.resource_id)
- self.assertEqual('test_stack.CfnUser', resource.FnGetRefId())
+ rsrc = self.create_user(t, stack, 'CfnUser')
+ self.assertEqual(self.fc.user_id, rsrc.resource_id)
+ self.assertEqual('test_stack.CfnUser', rsrc.FnGetRefId())
- self.assertEqual('CREATE_COMPLETE', resource.state)
- self.assertEqual(user.User.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertEqual('CREATE_COMPLETE', rsrc.state)
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- resource.resource_id = None
- self.assertEqual(None, resource.delete())
- self.assertEqual('DELETE_COMPLETE', resource.state)
+ rsrc.resource_id = None
+ self.assertEqual(None, rsrc.delete())
+ self.assertEqual('DELETE_COMPLETE', rsrc.state)
- resource.resource_id = self.fc.access
- resource.state_set('CREATE_COMPLETE')
- self.assertEqual('CREATE_COMPLETE', resource.state)
+ rsrc.resource_id = self.fc.access
+ rsrc.state_set('CREATE_COMPLETE')
+ self.assertEqual('CREATE_COMPLETE', rsrc.state)
- self.assertEqual(None, resource.delete())
- self.assertEqual('DELETE_COMPLETE', resource.state)
+ self.assertEqual(None, rsrc.delete())
+ self.assertEqual('DELETE_COMPLETE', rsrc.state)
- resource.state_set('CREATE_COMPLETE')
- self.assertEqual('CREATE_COMPLETE', resource.state)
+ rsrc.state_set('CREATE_COMPLETE')
+ self.assertEqual('CREATE_COMPLETE', rsrc.state)
- self.assertEqual(None, resource.delete())
- self.assertEqual('DELETE_COMPLETE', resource.state)
+ self.assertEqual(None, rsrc.delete())
+ self.assertEqual('DELETE_COMPLETE', rsrc.state)
self.m.VerifyAll()
def test_user_validate_policies(self):
t = template_format.parse(user_policy_template)
stack = parse_stack(t)
- resource = self.create_user(t, stack, 'CfnUser')
- self.assertEqual(self.fc.user_id, resource.resource_id)
- self.assertEqual('test_stack.CfnUser', resource.FnGetRefId())
- self.assertEqual('CREATE_COMPLETE', resource.state)
+ rsrc = self.create_user(t, stack, 'CfnUser')
+ self.assertEqual(self.fc.user_id, rsrc.resource_id)
+ self.assertEqual('test_stack.CfnUser', rsrc.FnGetRefId())
+ self.assertEqual('CREATE_COMPLETE', rsrc.state)
self.assertEqual([u'WebServerAccessPolicy'],
- resource.properties['Policies'])
+ rsrc.properties['Policies'])
# OK
self.assertTrue(
- resource._validate_policies([u'WebServerAccessPolicy']))
+ rsrc._validate_policies([u'WebServerAccessPolicy']))
# Resource name doesn't exist in the stack
- self.assertFalse(resource._validate_policies([u'NoExistAccessPolicy']))
+ self.assertFalse(rsrc._validate_policies([u'NoExistAccessPolicy']))
# Resource name is wrong Resource type
- self.assertFalse(resource._validate_policies([u'NoExistAccessPolicy',
- u'WikiDatabase']))
+ self.assertFalse(rsrc._validate_policies([u'NoExistAccessPolicy',
+ u'WikiDatabase']))
# Wrong type (AWS embedded policy format, not yet supported)
dict_policy = {"PolicyName": "AccessForCFNInit",
"Resource": "*"}]}}
# However we should just ignore it to avoid breaking existing templates
- self.assertTrue(resource._validate_policies([dict_policy]))
+ self.assertTrue(rsrc._validate_policies([dict_policy]))
self.m.VerifyAll()
t['Resources']['CfnUser']['Properties']['Policies'] = ['NoExistBad']
stack = parse_stack(t)
resource_name = 'CfnUser'
- resource = user.User(resource_name,
- t['Resources'][resource_name],
- stack)
+ rsrc = user.User(resource_name,
+ t['Resources'][resource_name],
+ stack)
self.assertRaises(exception.InvalidTemplateAttribute,
- resource.handle_create)
+ rsrc.handle_create)
self.m.VerifyAll()
def test_user_access_allowed(self):
t = template_format.parse(user_policy_template)
stack = parse_stack(t)
- resource = self.create_user(t, stack, 'CfnUser')
- self.assertEqual(self.fc.user_id, resource.resource_id)
- self.assertEqual('test_stack.CfnUser', resource.FnGetRefId())
- self.assertEqual('CREATE_COMPLETE', resource.state)
+ rsrc = self.create_user(t, stack, 'CfnUser')
+ self.assertEqual(self.fc.user_id, rsrc.resource_id)
+ self.assertEqual('test_stack.CfnUser', rsrc.FnGetRefId())
+ self.assertEqual('CREATE_COMPLETE', rsrc.state)
- self.assertTrue(resource.access_allowed('a_resource'))
- self.assertFalse(resource.access_allowed('b_resource'))
+ self.assertTrue(rsrc.access_allowed('a_resource'))
+ self.assertFalse(rsrc.access_allowed('b_resource'))
self.m.VerifyAll()
def test_user_access_allowed_ignorepolicy(self):
'WebServerAccessPolicy', {'an_ignored': 'policy'}]
stack = parse_stack(t)
- resource = self.create_user(t, stack, 'CfnUser')
- self.assertEqual(self.fc.user_id, resource.resource_id)
- self.assertEqual('test_stack.CfnUser', resource.FnGetRefId())
- self.assertEqual('CREATE_COMPLETE', resource.state)
+ rsrc = self.create_user(t, stack, 'CfnUser')
+ self.assertEqual(self.fc.user_id, rsrc.resource_id)
+ self.assertEqual('test_stack.CfnUser', rsrc.FnGetRefId())
+ self.assertEqual('CREATE_COMPLETE', rsrc.state)
- self.assertTrue(resource.access_allowed('a_resource'))
- self.assertFalse(resource.access_allowed('b_resource'))
+ self.assertTrue(rsrc.access_allowed('a_resource'))
+ self.assertFalse(rsrc.access_allowed('b_resource'))
self.m.VerifyAll()
class AccessKeyTest(UserPolicyTestCase):
def create_access_key(self, t, stack, resource_name):
- resource = user.AccessKey(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(None, resource.validate())
- scheduler.TaskRunner(resource.create)()
+ rsrc = user.AccessKey(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(None, rsrc.validate())
+ scheduler.TaskRunner(rsrc.create)()
self.assertEqual(user.AccessKey.CREATE_COMPLETE,
- resource.state)
- return resource
+ rsrc.state)
+ return rsrc
def test_access_key(self):
self.m.StubOutWithMock(user.AccessKey, 'keystone')
stack.resources['CfnUser'].resource_id = self.fc.user_id
stack.resources['CfnUser'].state = 'CREATE_COMPLETE'
- resource = self.create_access_key(t, stack, 'HostKeys')
+ rsrc = self.create_access_key(t, stack, 'HostKeys')
- self.assertEqual(user.AccessKey.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
self.assertEqual(self.fc.access,
- resource.resource_id)
+ rsrc.resource_id)
self.assertEqual(self.fc.secret,
- resource._secret)
+ rsrc._secret)
- self.assertEqual(resource.FnGetAtt('UserName'), 'test_stack.CfnUser')
- resource._secret = None
- self.assertEqual(resource.FnGetAtt('SecretAccessKey'),
+ self.assertEqual(rsrc.FnGetAtt('UserName'), 'test_stack.CfnUser')
+ rsrc._secret = None
+ self.assertEqual(rsrc.FnGetAtt('SecretAccessKey'),
self.fc.secret)
self.assertRaises(exception.InvalidTemplateAttribute,
- resource.FnGetAtt, 'Foo')
- self.assertEqual(None, resource.delete())
+ rsrc.FnGetAtt, 'Foo')
+ self.assertEqual(None, rsrc.delete())
self.m.VerifyAll()
# Check for double delete
test_key).AndRaise(NotFound('Gone'))
self.m.ReplayAll()
- resource.state = resource.CREATE_COMPLETE
- resource.resource_id = test_key
- self.assertEqual(None, resource.delete())
+ rsrc.state = rsrc.CREATE_COMPLETE
+ rsrc.resource_id = test_key
+ self.assertEqual(None, rsrc.delete())
self.m.VerifyAll()
def test_access_key_no_user(self):
stack = parse_stack(t)
stack.resources['CfnUser'].resource_id = self.fc.user_id
- resource = user.AccessKey('HostKeys',
- t['Resources']['HostKeys'],
- stack)
- create = scheduler.TaskRunner(resource.create)
+ rsrc = user.AccessKey('HostKeys',
+ t['Resources']['HostKeys'],
+ stack)
+ create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
self.assertEqual(user.AccessKey.CREATE_FAILED,
- resource.state)
+ rsrc.state)
- self.assertEqual(None, resource.delete())
- self.assertEqual(user.AccessKey.DELETE_COMPLETE, resource.state)
+ self.assertEqual(None, rsrc.delete())
+ self.assertEqual(user.AccessKey.DELETE_COMPLETE, rsrc.state)
self.m.VerifyAll()
stack = parse_stack(t)
resource_name = 'WebServerAccessPolicy'
- resource = user.AccessPolicy(resource_name,
- t['Resources'][resource_name],
- stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(user.User.CREATE_COMPLETE, resource.state)
+ rsrc = user.AccessPolicy(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(user.User.CREATE_COMPLETE, rsrc.state)
def test_accesspolicy_create_ok_empty(self):
t = template_format.parse(user_policy_template)
t['Resources'][resource_name]['Properties']['AllowedResources'] = []
stack = parse_stack(t)
- resource = user.AccessPolicy(resource_name,
- t['Resources'][resource_name],
- stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(user.User.CREATE_COMPLETE, resource.state)
+ rsrc = user.AccessPolicy(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(user.User.CREATE_COMPLETE, rsrc.state)
def test_accesspolicy_create_err_notfound(self):
t = template_format.parse(user_policy_template)
'NoExistResource']
stack = parse_stack(t)
- resource = user.AccessPolicy(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertRaises(exception.ResourceNotFound, resource.handle_create)
+ rsrc = user.AccessPolicy(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertRaises(exception.ResourceNotFound, rsrc.handle_create)
def test_accesspolicy_update(self):
t = template_format.parse(user_policy_template)
resource_name = 'WebServerAccessPolicy'
stack = parse_stack(t)
- resource = user.AccessPolicy(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(user.AccessPolicy.UPDATE_REPLACE,
- resource.handle_update({}))
+ rsrc = user.AccessPolicy(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
def test_accesspolicy_access_allowed(self):
t = template_format.parse(user_policy_template)
resource_name = 'WebServerAccessPolicy'
stack = parse_stack(t)
- resource = user.AccessPolicy(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertTrue(resource.access_allowed('WikiDatabase'))
- self.assertFalse(resource.access_allowed('NotWikiDatabase'))
- self.assertFalse(resource.access_allowed(None))
+ rsrc = user.AccessPolicy(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertTrue(rsrc.access_allowed('WikiDatabase'))
+ self.assertFalse(rsrc.access_allowed('NotWikiDatabase'))
+ self.assertFalse(rsrc.access_allowed(None))
from heat.engine import scheduler
from heat.engine.resources import volume as vol
from heat.engine import clients
+from heat.engine import resource
from heat.openstack.common.importutils import try_import
from heat.tests.common import HeatTestCase
from heat.tests.v1_1 import fakes
def create_volume(self, t, stack, resource_name):
data = t['Resources'][resource_name]
data['Properties']['AvailabilityZone'] = 'nova'
- resource = vol.Volume(resource_name, data, stack)
- self.assertEqual(resource.validate(), None)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(resource.state, vol.Volume.CREATE_COMPLETE)
- return resource
+ rsrc = vol.Volume(resource_name, data, stack)
+ self.assertEqual(rsrc.validate(), None)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(rsrc.state, vol.Volume.CREATE_COMPLETE)
+ return rsrc
def create_attachment(self, t, stack, resource_name):
- resource = vol.VolumeAttachment(resource_name,
- t['Resources'][resource_name],
- stack)
- self.assertEqual(resource.validate(), None)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(resource.state, vol.VolumeAttachment.CREATE_COMPLETE)
- return resource
+ rsrc = vol.VolumeAttachment(resource_name,
+ t['Resources'][resource_name],
+ stack)
+ self.assertEqual(rsrc.validate(), None)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(rsrc.state, vol.VolumeAttachment.CREATE_COMPLETE)
+ return rsrc
def test_volume(self):
fv = FakeVolume('creating', 'available')
t = template_format.parse(volume_template)
stack = parse_stack(t, stack_name=stack_name)
- resource = self.create_volume(t, stack, 'DataVolume')
+ rsrc = self.create_volume(t, stack, 'DataVolume')
self.assertEqual(fv.status, 'available')
- self.assertEqual(resource.handle_update({}), vol.Volume.UPDATE_REPLACE)
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
fv.status = 'in-use'
- self.assertRaises(exception.ResourceFailure, resource.destroy)
+ self.assertRaises(exception.ResourceFailure, rsrc.destroy)
fv.status = 'available'
- self.assertEqual(resource.destroy(), None)
+ self.assertEqual(rsrc.destroy(), None)
# Test when volume already deleted
- resource.state = resource.CREATE_COMPLETE
- self.assertEqual(resource.destroy(), None)
+ rsrc.state = rsrc.CREATE_COMPLETE
+ self.assertEqual(rsrc.destroy(), None)
self.m.VerifyAll()
t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova'
stack = parse_stack(t, stack_name=stack_name)
- resource = vol.Volume('DataVolume',
- t['Resources']['DataVolume'],
- stack)
- create = scheduler.TaskRunner(resource.create)
+ rsrc = vol.Volume('DataVolume',
+ t['Resources']['DataVolume'],
+ stack)
+ create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
self.m.VerifyAll()
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
- resource = vol.VolumeAttachment('MountPoint',
- t['Resources']['MountPoint'],
- stack)
- create = scheduler.TaskRunner(resource.create)
+ rsrc = vol.VolumeAttachment('MountPoint',
+ t['Resources']['MountPoint'],
+ stack)
+ create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
self.m.VerifyAll()
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
- resource = self.create_attachment(t, stack, 'MountPoint')
+ rsrc = self.create_attachment(t, stack, 'MountPoint')
- self.assertEqual(resource.handle_update({}), vol.Volume.UPDATE_REPLACE)
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- self.assertEqual(resource.delete(), None)
+ self.assertEqual(rsrc.delete(), None)
self.m.VerifyAll()
t['Resources']['DataVolume']['DeletionPolicy'] = 'Snapshot'
stack = parse_stack(t, stack_name=stack_name)
- resource = self.create_volume(t, stack, 'DataVolume')
+ rsrc = self.create_volume(t, stack, 'DataVolume')
- self.assertEqual(resource.destroy(), None)
+ self.assertEqual(rsrc.destroy(), None)
self.m.VerifyAll()
t['Resources']['DataVolume']['DeletionPolicy'] = 'Snapshot'
stack = parse_stack(t, stack_name=stack_name)
- resource = self.create_volume(t, stack, 'DataVolume')
+ rsrc = self.create_volume(t, stack, 'DataVolume')
- self.assertRaises(exception.ResourceFailure, resource.destroy)
+ self.assertRaises(exception.ResourceFailure, rsrc.destroy)
self.m.VerifyAll()
t['Resources']['DataVolume']['DeletionPolicy'] = 'Snapshot'
t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova'
stack = parse_stack(t, stack_name=stack_name)
- resource = vol.Volume('DataVolume',
- t['Resources']['DataVolume'],
- stack)
+ rsrc = vol.Volume('DataVolume',
+ t['Resources']['DataVolume'],
+ stack)
- create = scheduler.TaskRunner(resource.create)
+ create = scheduler.TaskRunner(rsrc.create)
self.assertRaises(exception.ResourceFailure, create)
- self.assertEqual(resource.destroy(), None)
+ self.assertEqual(rsrc.destroy(), None)
self.m.VerifyAll()
}
stack = parse_stack(t, stack_name=stack_name)
- resource = vol.CinderVolume('DataVolume',
- t['Resources']['DataVolume'],
- stack)
- self.assertEqual(resource.validate(), None)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(resource.state, vol.Volume.CREATE_COMPLETE)
+ rsrc = vol.CinderVolume('DataVolume',
+ t['Resources']['DataVolume'],
+ stack)
+ self.assertEqual(rsrc.validate(), None)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(rsrc.state, vol.Volume.CREATE_COMPLETE)
self.assertEqual(fv.status, 'available')
self.m.VerifyAll()
}
stack = parse_stack(t, stack_name=stack_name)
- resource = vol.CinderVolume('DataVolume',
- t['Resources']['DataVolume'],
- stack)
- self.assertEqual(resource.validate(), None)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(resource.state, vol.Volume.CREATE_COMPLETE)
+ rsrc = vol.CinderVolume('DataVolume',
+ t['Resources']['DataVolume'],
+ stack)
+ self.assertEqual(rsrc.validate(), None)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(rsrc.state, vol.Volume.CREATE_COMPLETE)
self.assertEqual(fv.status, 'available')
self.m.VerifyAll()
}
stack = parse_stack(t, stack_name=stack_name)
- resource = vol.CinderVolume('DataVolume',
- t['Resources']['DataVolume'],
- stack)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(u'vol-123', resource.FnGetAtt('id'))
- self.assertEqual(u'zone1', resource.FnGetAtt('availability_zone'))
- self.assertEqual(u'1', resource.FnGetAtt('size'))
- self.assertEqual(u'snap-123', resource.FnGetAtt('snapshot_id'))
- self.assertEqual(u'name', resource.FnGetAtt('display_name'))
- self.assertEqual(u'desc', resource.FnGetAtt('display_description'))
- self.assertEqual(u'lvm', resource.FnGetAtt('volume_type'))
+ rsrc = vol.CinderVolume('DataVolume',
+ t['Resources']['DataVolume'],
+ stack)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(u'vol-123', rsrc.FnGetAtt('id'))
+ self.assertEqual(u'zone1', rsrc.FnGetAtt('availability_zone'))
+ self.assertEqual(u'1', rsrc.FnGetAtt('size'))
+ self.assertEqual(u'snap-123', rsrc.FnGetAtt('snapshot_id'))
+ self.assertEqual(u'name', rsrc.FnGetAtt('display_name'))
+ self.assertEqual(u'desc', rsrc.FnGetAtt('display_description'))
+ self.assertEqual(u'lvm', rsrc.FnGetAtt('volume_type'))
self.assertEqual(json.dumps({'key': 'value'}),
- resource.FnGetAtt('metadata'))
- self.assertEqual(u'None', resource.FnGetAtt('source_volid'))
- self.assertEqual(u'available', resource.FnGetAtt('status'))
+ rsrc.FnGetAtt('metadata'))
+ self.assertEqual(u'None', rsrc.FnGetAtt('source_volid'))
+ self.assertEqual(u'available', rsrc.FnGetAtt('status'))
self.assertEqual(u'2013-02-25T02:40:21.000000',
- resource.FnGetAtt('created_at'))
- self.assertEqual(u'False', resource.FnGetAtt('bootable'))
+ rsrc.FnGetAtt('created_at'))
+ self.assertEqual(u'False', rsrc.FnGetAtt('bootable'))
error = self.assertRaises(exception.InvalidTemplateAttribute,
- resource.FnGetAtt, 'unknown')
+ rsrc.FnGetAtt, 'unknown')
self.assertEqual(
'The Referenced Attribute (DataVolume unknown) is incorrect.',
str(error))
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
- resource = vol.CinderVolumeAttachment('MountPoint',
- t['Resources']['MountPoint'],
- stack)
- self.assertEqual(resource.validate(), None)
- scheduler.TaskRunner(resource.create)()
- self.assertEqual(resource.state, vol.VolumeAttachment.CREATE_COMPLETE)
+ rsrc = vol.CinderVolumeAttachment('MountPoint',
+ t['Resources']['MountPoint'],
+ stack)
+ self.assertEqual(rsrc.validate(), None)
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(rsrc.state, vol.VolumeAttachment.CREATE_COMPLETE)
- self.assertEqual(resource.handle_update({}), vol.Volume.UPDATE_REPLACE)
+ self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {})
- self.assertEqual(resource.delete(), None)
+ self.assertEqual(rsrc.delete(), None)
self.m.VerifyAll()
from heat.common import exception
from heat.common import template_format
from heat.engine import parser
+from heat.engine import resource
from heat.tests.common import HeatTestCase
from heat.tests.utils import setup_dummy_db
{'subnet_id': 'cccc'}).AndReturn(None)
quantumclient.Client.delete_subnet('cccc').AndReturn(None)
- def assertResourceState(self, resource, ref_id, metadata={}):
- self.assertEqual(None, resource.validate())
- self.assertEqual(resource.CREATE_COMPLETE, resource.state)
- self.assertEqual(ref_id, resource.FnGetRefId())
- self.assertEqual(metadata, dict(resource.metadata))
+ def assertResourceState(self, rsrc, ref_id, metadata={}):
+ self.assertEqual(None, rsrc.validate())
+ self.assertEqual(rsrc.CREATE_COMPLETE, rsrc.state)
+ self.assertEqual(ref_id, rsrc.FnGetRefId())
+ self.assertEqual(metadata, dict(rsrc.metadata))
class VPCTest(VPCTestBase):
self.m.ReplayAll()
stack = self.create_stack(self.test_template)
- resource = stack['the_vpc']
- self.assertResourceState(resource, 'aaaa', {
+ rsrc = stack['the_vpc']
+ self.assertResourceState(rsrc, 'aaaa', {
'router_id': 'bbbb',
'all_router_ids': ['bbbb']})
- self.assertEqual(resource.UPDATE_REPLACE, resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
- self.assertEqual(None, resource.delete())
+ self.assertEqual(None, rsrc.delete())
self.m.VerifyAll()
self.m.ReplayAll()
stack = self.create_stack(self.test_template)
- resource = stack['the_subnet']
- self.assertResourceState(resource, 'cccc', {
+ rsrc = stack['the_subnet']
+ self.assertResourceState(rsrc, 'cccc', {
'router_id': 'bbbb',
'default_router_id': 'bbbb'})
- self.assertEqual(resource.UPDATE_REPLACE, resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
self.assertRaises(
exception.InvalidTemplateAttribute,
- resource.FnGetAtt,
+ rsrc.FnGetAtt,
'Foo')
- self.assertEqual('moon', resource.FnGetAtt('AvailabilityZone'))
+ self.assertEqual('moon', rsrc.FnGetAtt('AvailabilityZone'))
- self.assertEqual(None, resource.delete())
- resource.state_set(resource.CREATE_COMPLETE, 'to delete again')
- self.assertEqual(None, resource.delete())
+ self.assertEqual(None, rsrc.delete())
+ rsrc.state_set(rsrc.CREATE_COMPLETE, 'to delete again')
+ self.assertEqual(None, rsrc.delete())
self.assertEqual(None, stack['the_vpc'].delete())
self.m.VerifyAll()
stack = self.create_stack(self.test_template)
try:
- resource = stack['the_nic']
- self.assertResourceState(resource, 'dddd')
+ rsrc = stack['the_nic']
+ self.assertResourceState(rsrc, 'dddd')
- self.assertEqual(resource.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
finally:
stack.delete()
gateway = stack['the_gateway']
self.assertResourceState(gateway, 'the_gateway', {
'external_network_id': 'eeee'})
- self.assertEqual(gateway.UPDATE_REPLACE, gateway.handle_update({}))
+ self.assertRaises(resource.UpdateReplace, gateway.handle_update, {})
attachment = stack['the_attachment']
self.assertResourceState(attachment, 'the_attachment')
- self.assertEqual(gateway.UPDATE_REPLACE, attachment.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ attachment.handle_update, {})
stack.delete()
self.m.VerifyAll()
route_table = stack['the_route_table']
self.assertResourceState(route_table, 'ffff', {})
- self.assertEqual(
- route_table.UPDATE_REPLACE,
- route_table.handle_update({}))
+ self.assertRaises(
+ resource.UpdateReplace,
+ route_table.handle_update, {})
association = stack['the_association']
self.assertResourceState(association, 'the_association', {})
- self.assertEqual(
- association.UPDATE_REPLACE,
- association.handle_update({}))
+ self.assertRaises(
+ resource.UpdateReplace,
+ association.handle_update, {})
association.delete()
route_table.delete()
from heat.common import template_format
from heat.common import identifier
from heat.engine import parser
+from heat.engine import resource
from heat.engine import scheduler
from heat.engine.resources import wait_condition as wc
from heat.common import config
self.stack.create()
- resource = self.stack.resources['WaitForTheHandle']
- self.assertEqual(resource.state,
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertEqual(rsrc.state,
'CREATE_COMPLETE')
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.create()
- resource = self.stack.resources['WaitForTheHandle']
- self.assertEqual(resource.state, resource.CREATE_FAILED)
- reason = resource.state_description
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertEqual(rsrc.state, rsrc.CREATE_FAILED)
+ reason = rsrc.state_description
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.create()
- resource = self.stack.resources['WaitForTheHandle']
- self.assertEqual(resource.state,
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertEqual(rsrc.state,
'CREATE_COMPLETE')
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.create()
- resource = self.stack.resources['WaitForTheHandle']
- self.assertEqual(resource.state, resource.CREATE_FAILED)
- reason = resource.state_description
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertEqual(rsrc.state, rsrc.CREATE_FAILED)
+ reason = rsrc.state_description
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.create()
- resource = self.stack.resources['WaitForTheHandle']
+ rsrc = self.stack.resources['WaitForTheHandle']
- self.assertEqual(resource.state, resource.CREATE_FAILED)
- reason = resource.state_description
+ self.assertEqual(rsrc.state, rsrc.CREATE_FAILED)
+ reason = rsrc.state_description
self.assertTrue(reason.startswith('WaitConditionTimeout:'))
- self.assertEqual(wc.WaitCondition.UPDATE_REPLACE,
- resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
self.m.VerifyAll()
@stack_delete_after
self.m.ReplayAll()
self.stack.create()
- resource = self.stack.resources['WaitForTheHandle']
- self.assertEqual(resource.state, 'CREATE_COMPLETE')
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
- wc_att = resource.FnGetAtt('Data')
+ wc_att = rsrc.FnGetAtt('Data')
self.assertEqual(wc_att, unicode({}))
handle = self.stack.resources['WaitHandle']
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
handle.metadata_update(new_metadata=test_metadata)
- wc_att = resource.FnGetAtt('Data')
+ wc_att = rsrc.FnGetAtt('Data')
self.assertEqual(wc_att, '{"123": "foo"}')
test_metadata = {'Data': 'dog', 'Reason': 'cat',
'Status': 'SUCCESS', 'UniqueId': '456'}
handle.metadata_update(new_metadata=test_metadata)
- wc_att = resource.FnGetAtt('Data')
+ wc_att = rsrc.FnGetAtt('Data')
self.assertEqual(wc_att, u'{"123": "foo", "456": "dog"}')
self.m.VerifyAll()
self.stack = self.create_stack(template=json.dumps(t), stub=False)
self.m.ReplayAll()
- resource = self.stack.resources['WaitForTheHandle']
- self.assertRaises(ValueError, resource.handle_create)
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertRaises(ValueError, rsrc.handle_create)
self.m.VerifyAll()
t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle
self.stack = self.create_stack(template=json.dumps(t), stub=False)
- resource = self.stack.resources['WaitForTheHandle']
- self.assertRaises(ValueError, resource.handle_create)
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertRaises(ValueError, rsrc.handle_create)
self.m.VerifyAll()
t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle
self.stack = self.create_stack(template=json.dumps(t), stub=False)
- resource = self.stack.resources['WaitForTheHandle']
- self.assertRaises(ValueError, resource.handle_create)
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertRaises(ValueError, rsrc.handle_create)
self.m.VerifyAll()
t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle
self.stack = self.create_stack(template=json.dumps(t), stub=False)
- resource = self.stack.resources['WaitForTheHandle']
- self.assertRaises(ValueError, resource.handle_create)
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertRaises(ValueError, rsrc.handle_create)
self.m.VerifyAll()
t['Resources']['WaitForTheHandle']['Properties']['Handle'] = badhandle
self.stack = self.create_stack(template=json.dumps(t), stub=False)
- resource = self.stack.resources['WaitForTheHandle']
- self.assertRaises(ValueError, resource.handle_create)
+ rsrc = self.stack.resources['WaitForTheHandle']
+ self.assertRaises(ValueError, rsrc.handle_create)
self.m.VerifyAll()
def test_handle(self):
created_time = datetime.datetime(2012, 11, 29, 13, 49, 37)
- resource = self.stack.resources['WaitHandle']
- resource.created_time = created_time
- self.assertEqual(resource.state, 'CREATE_COMPLETE')
+ rsrc = self.stack.resources['WaitHandle']
+ rsrc.created_time = created_time
+ self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
expected_url = "".join([
'http://127.0.0.1:8000/v1/waitcondition/',
'Signature=',
'ePyTwmC%2F1kSigeo%2Fha7kP8Avvb45G9Y7WOQWe4F%2BnXM%3D'])
- self.assertEqual(expected_url, resource.FnGetRefId())
+ self.assertEqual(expected_url, rsrc.FnGetRefId())
- self.assertEqual(resource.UPDATE_REPLACE, resource.handle_update({}))
+ self.assertRaises(resource.UpdateReplace,
+ rsrc.handle_update, {})
self.m.VerifyAll()
@stack_delete_after
def test_metadata_update(self):
- resource = self.stack.resources['WaitHandle']
- self.assertEqual(resource.state, 'CREATE_COMPLETE')
+ rsrc = self.stack.resources['WaitHandle']
+ self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
- resource.metadata_update(new_metadata=test_metadata)
+ rsrc.metadata_update(new_metadata=test_metadata)
handle_metadata = {u'123': {u'Data': u'foo',
u'Reason': u'bar',
u'Status': u'SUCCESS'}}
- self.assertEqual(resource.metadata, handle_metadata)
+ self.assertEqual(rsrc.metadata, handle_metadata)
self.m.VerifyAll()
@stack_delete_after
def test_metadata_update_invalid(self):
- resource = self.stack.resources['WaitHandle']
- self.assertEqual(resource.state, 'CREATE_COMPLETE')
+ rsrc = self.stack.resources['WaitHandle']
+ self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
# metadata_update should raise a ValueError if the metadata
# is missing any of the expected keys
err_metadata = {'Data': 'foo', 'Status': 'SUCCESS', 'UniqueId': '123'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
err_metadata = {'Data': 'foo', 'Reason': 'bar', 'UniqueId': '1234'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
err_metadata = {'Data': 'foo', 'Reason': 'bar', 'UniqueId': '1234'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
err_metadata = {'data': 'foo', 'reason': 'bar',
'status': 'SUCCESS', 'uniqueid': '1234'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
# Also any Status other than SUCCESS or FAILURE should be rejected
err_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'UCCESS', 'UniqueId': '123'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
err_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'wibble', 'UniqueId': '123'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
err_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'success', 'UniqueId': '123'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
err_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'FAIL', 'UniqueId': '123'}
- self.assertRaises(ValueError, resource.metadata_update,
+ self.assertRaises(ValueError, rsrc.metadata_update,
new_metadata=err_metadata)
self.m.VerifyAll()
@stack_delete_after
def test_get_status(self):
- resource = self.stack.resources['WaitHandle']
- self.assertEqual(resource.state, 'CREATE_COMPLETE')
+ rsrc = self.stack.resources['WaitHandle']
+ self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
# UnsetStubs, don't want get_status stubbed anymore..
self.m.VerifyAll()
self.m.UnsetStubs()
- self.assertEqual(resource.get_status(), [])
+ self.assertEqual(rsrc.get_status(), [])
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
- resource.metadata_update(new_metadata=test_metadata)
- self.assertEqual(resource.get_status(), ['SUCCESS'])
+ rsrc.metadata_update(new_metadata=test_metadata)
+ self.assertEqual(rsrc.get_status(), ['SUCCESS'])
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '456'}
- resource.metadata_update(new_metadata=test_metadata)
- self.assertEqual(resource.get_status(), ['SUCCESS', 'SUCCESS'])
+ rsrc.metadata_update(new_metadata=test_metadata)
+ self.assertEqual(rsrc.get_status(), ['SUCCESS', 'SUCCESS'])
# re-stub keystone() with fake client or stack delete fails
self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone')
@stack_delete_after
def test_get_status_reason(self):
- resource = self.stack.resources['WaitHandle']
- self.assertEqual(resource.state, 'CREATE_COMPLETE')
+ rsrc = self.stack.resources['WaitHandle']
+ self.assertEqual(rsrc.state, 'CREATE_COMPLETE')
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
- resource.metadata_update(new_metadata=test_metadata)
- self.assertEqual(resource.get_status_reason('SUCCESS'), 'bar')
+ rsrc.metadata_update(new_metadata=test_metadata)
+ self.assertEqual(rsrc.get_status_reason('SUCCESS'), 'bar')
test_metadata = {'Data': 'dog', 'Reason': 'cat',
'Status': 'SUCCESS', 'UniqueId': '456'}
- resource.metadata_update(new_metadata=test_metadata)
- self.assertEqual(resource.get_status_reason('SUCCESS'), 'bar;cat')
+ rsrc.metadata_update(new_metadata=test_metadata)
+ self.assertEqual(rsrc.get_status_reason('SUCCESS'), 'bar;cat')
test_metadata = {'Data': 'boo', 'Reason': 'hoo',
'Status': 'FAILURE', 'UniqueId': '789'}
- resource.metadata_update(new_metadata=test_metadata)
- self.assertEqual(resource.get_status_reason('FAILURE'), 'hoo')
+ rsrc.metadata_update(new_metadata=test_metadata)
+ self.assertEqual(rsrc.get_status_reason('FAILURE'), 'hoo')
self.m.VerifyAll()
Code Review / openstack-build / heat-build.git / commitdiff