From c35f673e380163e8b440b65dd6ef218da1dbfaaa Mon Sep 17 00:00:00 2001 From: Steven Hardy Date: Thu, 23 May 2013 15:42:01 +0100 Subject: [PATCH] engine : replace UPDATE_REPLACE with ResourceReplace exception Replace the handle_update returned value with a new ResourceReplace exception, which allows the replacement logic in resource.py and parser.py to be cleaner Change-Id: If652d031e8baeb8f4c6015e5ed2d0e5bb25f0fc6 --- heat/engine/parser.py | 20 +- heat/engine/resource.py | 45 +-- heat/engine/resources/autoscaling.py | 45 +-- heat/engine/resources/cloud_watch.py | 15 +- heat/engine/resources/dbinstance.py | 3 - heat/engine/resources/eip.py | 3 - heat/engine/resources/instance.py | 11 +- heat/engine/resources/internet_gateway.py | 6 - heat/engine/resources/loadbalancer.py | 3 - heat/engine/resources/network_interface.py | 3 - heat/engine/resources/quantum/quantum.py | 3 - heat/engine/resources/route_table.py | 6 - heat/engine/resources/s3.py | 3 - heat/engine/resources/security_group.py | 3 - heat/engine/resources/stack.py | 3 - heat/engine/resources/subnet.py | 3 - heat/engine/resources/swift.py | 3 - heat/engine/resources/user.py | 9 - heat/engine/resources/volume.py | 6 - heat/engine/resources/vpc.py | 3 - heat/engine/resources/wait_condition.py | 6 - heat/tests/test_autoscaling.py | 302 ++++++++++----------- heat/tests/test_cw_alarm.py | 36 +-- heat/tests/test_eip.py | 51 ++-- heat/tests/test_instance.py | 3 +- heat/tests/test_instance_group.py | 54 ++-- heat/tests/test_loadbalancer.py | 40 +-- heat/tests/test_nested_stack.py | 18 +- heat/tests/test_parser.py | 73 +++-- heat/tests/test_quantum.py | 141 +++++----- heat/tests/test_resource.py | 18 +- heat/tests/test_s3.py | 63 ++--- heat/tests/test_security_group.py | 19 +- heat/tests/test_swift.py | 59 ++-- heat/tests/test_user.py | 207 +++++++------- heat/tests/test_volume.py | 153 ++++++----- heat/tests/test_vpc.py | 62 +++-- heat/tests/test_waitcondition.py | 130 ++++----- 38 files changed, 763 insertions(+), 868 deletions(-) diff --git a/heat/engine/parser.py b/heat/engine/parser.py index 7dcccf3eff..54e6f137a7 100644 --- a/heat/engine/parser.py +++ b/heat/engine/parser.py @@ -376,7 +376,7 @@ class Stack(object): # 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. @@ -389,15 +389,11 @@ class Stack(object): 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 @@ -406,8 +402,8 @@ class Stack(object): 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 diff --git a/heat/engine/resource.py b/heat/engine/resource.py index 0a93cd4edb..2d20f5da26 100644 --- a/heat/engine/resource.py +++ b/heat/engine/resource.py @@ -57,6 +57,21 @@ def _register_class(resource_type, resource_class): _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 @@ -93,9 +108,6 @@ class Resource(object): 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 @@ -203,7 +215,8 @@ class Resource(object): 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) @@ -221,8 +234,7 @@ class Resource(object): 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) @@ -231,7 +243,8 @@ class Resource(object): 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) @@ -249,9 +262,7 @@ class Resource(object): 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) @@ -377,18 +388,17 @@ class Resource(object): 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) @@ -566,8 +576,7 @@ class Resource(object): 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): ''' diff --git a/heat/engine/resources/autoscaling.py b/heat/engine/resources/autoscaling.py index bcf911db91..fe4dc7b34c 100644 --- a/heat/engine/resources/autoscaling.py +++ b/heat/engine/resources/autoscaling.py @@ -91,17 +91,8 @@ class InstanceGroup(resource.Resource): 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 @@ -123,8 +114,6 @@ class InstanceGroup(resource.Resource): 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') @@ -292,17 +281,8 @@ class AutoScalingGroup(InstanceGroup, CooldownMixin): 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 @@ -336,8 +316,6 @@ class AutoScalingGroup(InstanceGroup, CooldownMixin): 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) @@ -434,17 +412,8 @@ class ScalingPolicy(resource.Resource, CooldownMixin): 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 @@ -454,8 +423,6 @@ class ScalingPolicy(resource.Resource, CooldownMixin): 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" % diff --git a/heat/engine/resources/cloud_watch.py b/heat/engine/resources/cloud_watch.py index 9511094323..5b8d1d5bc4 100644 --- a/heat/engine/resources/cloud_watch.py +++ b/heat/engine/resources/cloud_watch.py @@ -91,17 +91,8 @@ class CloudWatchAlarm(resource.Resource): 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 @@ -117,8 +108,6 @@ class CloudWatchAlarm(resource.Resource): wr.rule = self.parsed_template('Properties') wr.store() - return self.UPDATE_COMPLETE - def handle_delete(self): try: db_api.watch_rule_delete(self.context, diff --git a/heat/engine/resources/dbinstance.py b/heat/engine/resources/dbinstance.py index 49ba870c59..567bc1e069 100644 --- a/heat/engine/resources/dbinstance.py +++ b/heat/engine/resources/dbinstance.py @@ -216,9 +216,6 @@ class DBInstance(stack_resource.StackResource): 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() diff --git a/heat/engine/resources/eip.py b/heat/engine/resources/eip.py index c0e4dc4e47..a5be2794fa 100644 --- a/heat/engine/resources/eip.py +++ b/heat/engine/resources/eip.py @@ -49,9 +49,6 @@ class ElasticIp(resource.Resource): 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: diff --git a/heat/engine/resources/instance.py b/heat/engine/resources/instance.py index 883be60aed..198f04f09a 100644 --- a/heat/engine/resources/instance.py +++ b/heat/engine/resources/instance.py @@ -386,20 +386,13 @@ class Instance(resource.Resource): 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): ''' diff --git a/heat/engine/resources/internet_gateway.py b/heat/engine/resources/internet_gateway.py index f19bbcc4a1..092ab2b41c 100644 --- a/heat/engine/resources/internet_gateway.py +++ b/heat/engine/resources/internet_gateway.py @@ -58,9 +58,6 @@ class InternetGateway(resource.Resource): def handle_delete(self): pass - def handle_update(self, json_snippet): - return self.UPDATE_REPLACE - class VPCGatewayAttachment(resource.Resource): @@ -99,9 +96,6 @@ 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: diff --git a/heat/engine/resources/loadbalancer.py b/heat/engine/resources/loadbalancer.py index aaf9e985f9..9c93224cec 100644 --- a/heat/engine/resources/loadbalancer.py +++ b/heat/engine/resources/loadbalancer.py @@ -333,9 +333,6 @@ class LoadBalancer(stack_resource.StackResource): self.create_with_template(templ, param) - def handle_update(self, json_snippet): - return self.UPDATE_REPLACE - def handle_delete(self): self.delete_nested() diff --git a/heat/engine/resources/network_interface.py b/heat/engine/resources/network_interface.py index eee083ec83..188d23d4ba 100644 --- a/heat/engine/resources/network_interface.py +++ b/heat/engine/resources/network_interface.py @@ -92,9 +92,6 @@ class NetworkInterface(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: diff --git a/heat/engine/resources/quantum/quantum.py b/heat/engine/resources/quantum/quantum.py index d42dd0ecca..5368fa1855 100644 --- a/heat/engine/resources/quantum/quantum.py +++ b/heat/engine/resources/quantum/quantum.py @@ -84,9 +84,6 @@ class QuantumResource(resource.Resource): 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': diff --git a/heat/engine/resources/route_table.py b/heat/engine/resources/route_table.py index d1d81d0792..a71945061f 100644 --- a/heat/engine/resources/route_table.py +++ b/heat/engine/resources/route_table.py @@ -75,9 +75,6 @@ class RouteTable(resource.Resource): # 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): @@ -133,9 +130,6 @@ 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: diff --git a/heat/engine/resources/s3.py b/heat/engine/resources/s3.py index 86a0bcfda6..de2d693907 100644 --- a/heat/engine/resources/s3.py +++ b/heat/engine/resources/s3.py @@ -85,9 +85,6 @@ class S3Bucket(resource.Resource): 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) diff --git a/heat/engine/resources/security_group.py b/heat/engine/resources/security_group.py index ac934d9ef9..94f8f1d97b 100644 --- a/heat/engine/resources/security_group.py +++ b/heat/engine/resources/security_group.py @@ -130,9 +130,6 @@ class SecurityGroup(resource.Resource): # 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() diff --git a/heat/engine/resources/stack.py b/heat/engine/resources/stack.py index 589e1f0a4f..739d91d7f4 100644 --- a/heat/engine/resources/stack.py +++ b/heat/engine/resources/stack.py @@ -44,9 +44,6 @@ class NestedStack(stack_resource.StackResource): 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() diff --git a/heat/engine/resources/subnet.py b/heat/engine/resources/subnet.py index bbdbbc9a65..2e92c5b97c 100644 --- a/heat/engine/resources/subnet.py +++ b/heat/engine/resources/subnet.py @@ -94,9 +94,6 @@ class Subnet(resource.Resource): 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, '') diff --git a/heat/engine/resources/swift.py b/heat/engine/resources/swift.py index a55feac2f2..aee482bed7 100644 --- a/heat/engine/resources/swift.py +++ b/heat/engine/resources/swift.py @@ -74,9 +74,6 @@ class SwiftContainer(resource.Resource): 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) diff --git a/heat/engine/resources/user.py b/heat/engine/resources/user.py index de01b485b9..ea591c1f2c 100644 --- a/heat/engine/resources/user.py +++ b/heat/engine/resources/user.py @@ -84,9 +84,6 @@ class User(resource.Resource): 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!") @@ -155,9 +152,6 @@ class AccessKey(resource.Resource): 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: @@ -241,9 +235,6 @@ class AccessPolicy(resource.Resource): 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'] diff --git a/heat/engine/resources/volume.py b/heat/engine/resources/volume.py index 56fecf7fac..fea76fcebb 100644 --- a/heat/engine/resources/volume.py +++ b/heat/engine/resources/volume.py @@ -80,9 +80,6 @@ class Volume(resource.Resource): 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': @@ -259,9 +256,6 @@ class VolumeAttachment(resource.Resource): 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] diff --git a/heat/engine/resources/vpc.py b/heat/engine/resources/vpc.py index 24b5d80471..d0702d287b 100644 --- a/heat/engine/resources/vpc.py +++ b/heat/engine/resources/vpc.py @@ -74,9 +74,6 @@ class VPC(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: diff --git a/heat/engine/resources/wait_condition.py b/heat/engine/resources/wait_condition.py index 4ad3944699..5b7395ae59 100644 --- a/heat/engine/resources/wait_condition.py +++ b/heat/engine/resources/wait_condition.py @@ -91,9 +91,6 @@ class WaitConditionHandle(resource.Resource): 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 @@ -259,9 +256,6 @@ class WaitCondition(resource.Resource): 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 diff --git a/heat/tests/test_autoscaling.py b/heat/tests/test_autoscaling.py index f556ebcf7d..29283bf4c5 100644 --- a/heat/tests/test_autoscaling.py +++ b/heat/tests/test_autoscaling.py @@ -22,6 +22,7 @@ from heat.common import template_format 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 @@ -84,24 +85,24 @@ class AutoScalingTest(HeatTestCase): 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') @@ -146,14 +147,14 @@ class AutoScalingTest(HeatTestCase): 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): @@ -168,17 +169,16 @@ class AutoScalingTest(HeatTestCase): 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): @@ -193,8 +193,8 @@ class AutoScalingTest(HeatTestCase): 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']) @@ -202,14 +202,13 @@ class AutoScalingTest(HeatTestCase): 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): @@ -224,8 +223,8 @@ class AutoScalingTest(HeatTestCase): 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']) @@ -233,14 +232,13 @@ class AutoScalingTest(HeatTestCase): 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): @@ -254,20 +252,19 @@ class AutoScalingTest(HeatTestCase): 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): @@ -281,16 +278,15 @@ class AutoScalingTest(HeatTestCase): 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): @@ -306,16 +302,16 @@ class AutoScalingTest(HeatTestCase): 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', @@ -323,17 +319,17 @@ class AutoScalingTest(HeatTestCase): 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): @@ -348,26 +344,26 @@ class AutoScalingTest(HeatTestCase): 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): @@ -382,18 +378,18 @@ class AutoScalingTest(HeatTestCase): 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', @@ -401,11 +397,11 @@ class AutoScalingTest(HeatTestCase): 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) @@ -420,18 +416,18 @@ class AutoScalingTest(HeatTestCase): 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 @@ -449,16 +445,16 @@ class AutoScalingTest(HeatTestCase): 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) @@ -473,18 +469,18 @@ class AutoScalingTest(HeatTestCase): 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 @@ -498,7 +494,7 @@ class AutoScalingTest(HeatTestCase): 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 @@ -507,11 +503,11 @@ class AutoScalingTest(HeatTestCase): 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) @@ -526,18 +522,18 @@ class AutoScalingTest(HeatTestCase): 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): @@ -547,7 +543,7 @@ class AutoScalingTest(HeatTestCase): 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 @@ -556,11 +552,11 @@ class AutoScalingTest(HeatTestCase): 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): @@ -573,9 +569,9 @@ class AutoScalingTest(HeatTestCase): 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']) @@ -586,9 +582,9 @@ class AutoScalingTest(HeatTestCase): '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): @@ -603,10 +599,10 @@ class AutoScalingTest(HeatTestCase): 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']) @@ -615,9 +611,9 @@ class AutoScalingTest(HeatTestCase): 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): @@ -630,9 +626,9 @@ class AutoScalingTest(HeatTestCase): 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']) @@ -643,7 +639,7 @@ class AutoScalingTest(HeatTestCase): '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 @@ -666,9 +662,9 @@ class AutoScalingTest(HeatTestCase): 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): @@ -681,9 +677,9 @@ class AutoScalingTest(HeatTestCase): 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']) @@ -694,7 +690,7 @@ class AutoScalingTest(HeatTestCase): '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 @@ -705,7 +701,7 @@ class AutoScalingTest(HeatTestCase): 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) @@ -717,9 +713,9 @@ class AutoScalingTest(HeatTestCase): 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): @@ -732,9 +728,9 @@ class AutoScalingTest(HeatTestCase): 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'] @@ -747,7 +743,7 @@ class AutoScalingTest(HeatTestCase): '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'} @@ -757,7 +753,7 @@ class AutoScalingTest(HeatTestCase): 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', @@ -768,9 +764,9 @@ class AutoScalingTest(HeatTestCase): 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): @@ -783,9 +779,9 @@ class AutoScalingTest(HeatTestCase): 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 @@ -800,7 +796,7 @@ class AutoScalingTest(HeatTestCase): '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'} @@ -810,7 +806,7 @@ class AutoScalingTest(HeatTestCase): 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', @@ -821,9 +817,9 @@ class AutoScalingTest(HeatTestCase): 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): @@ -836,9 +832,9 @@ class AutoScalingTest(HeatTestCase): 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, @@ -853,12 +849,12 @@ class AutoScalingTest(HeatTestCase): # 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']) @@ -872,7 +868,7 @@ class AutoScalingTest(HeatTestCase): 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) @@ -888,7 +884,7 @@ class AutoScalingTest(HeatTestCase): 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() diff --git a/heat/tests/test_cw_alarm.py b/heat/tests/test_cw_alarm.py index 879ec0230a..44c43afb77 100644 --- a/heat/tests/test_cw_alarm.py +++ b/heat/tests/test_cw_alarm.py @@ -17,6 +17,7 @@ import copy 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 @@ -55,19 +56,19 @@ class CloudWatchAlarmTest(HeatTestCase): 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) @@ -81,8 +82,8 @@ class CloudWatchAlarmTest(HeatTestCase): 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' @@ -90,10 +91,9 @@ class CloudWatchAlarmTest(HeatTestCase): 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): @@ -113,12 +113,12 @@ class CloudWatchAlarmTest(HeatTestCase): 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() diff --git a/heat/tests/test_eip.py b/heat/tests/test_eip.py index d01373d9c3..05487fd42f 100644 --- a/heat/tests/test_eip.py +++ b/heat/tests/test_eip.py @@ -15,6 +15,7 @@ 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 @@ -56,23 +57,23 @@ class EIPTest(HeatTestCase): 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): @@ -83,23 +84,23 @@ class EIPTest(HeatTestCase): 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() @@ -116,13 +117,13 @@ class EIPTest(HeatTestCase): 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() diff --git a/heat/tests/test_instance.py b/heat/tests/test_instance.py index ad3b638a7c..0d3d316fba 100644 --- a/heat/tests/test_instance.py +++ b/heat/tests/test_instance.py @@ -140,8 +140,7 @@ class instancesTest(HeatTestCase): 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): diff --git a/heat/tests/test_instance_group.py b/heat/tests/test_instance_group.py index 5039fd4fa7..dac6dd1a63 100644 --- a/heat/tests/test_instance_group.py +++ b/heat/tests/test_instance_group.py @@ -21,6 +21,7 @@ from heat.common import exception 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 @@ -75,13 +76,13 @@ class InstanceGroupTest(HeatTestCase): 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): @@ -94,15 +95,15 @@ class InstanceGroupTest(HeatTestCase): 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): @@ -110,9 +111,9 @@ class InstanceGroupTest(HeatTestCase): 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') @@ -120,9 +121,9 @@ class InstanceGroupTest(HeatTestCase): 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() @@ -134,9 +135,9 @@ class InstanceGroupTest(HeatTestCase): 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() @@ -152,15 +153,14 @@ class InstanceGroupTest(HeatTestCase): 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() diff --git a/heat/tests/test_loadbalancer.py b/heat/tests/test_loadbalancer.py index 644b61e8da..f9dfd40b6b 100644 --- a/heat/tests/test_loadbalancer.py +++ b/heat/tests/test_loadbalancer.py @@ -21,6 +21,7 @@ from heat.common import exception 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 @@ -88,13 +89,13 @@ class LoadBalancerTest(HeatTestCase): 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') @@ -124,7 +125,7 @@ class LoadBalancerTest(HeatTestCase): s = parse_stack(t) s.store() - resource = self.create_loadbalancer(t, s, 'LoadBalancer') + rsrc = self.create_loadbalancer(t, s, 'LoadBalancer') hc = { 'Target': 'HTTP:80/', @@ -132,20 +133,19 @@ class LoadBalancerTest(HeatTestCase): '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') @@ -158,19 +158,19 @@ class LoadBalancerTest(HeatTestCase): 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() diff --git a/heat/tests/test_nested_stack.py b/heat/tests/test_nested_stack.py index 06170f5718..34e8e1a14c 100644 --- a/heat/tests/test_nested_stack.py +++ b/heat/tests/test_nested_stack.py @@ -17,7 +17,7 @@ from heat.common import context 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 @@ -73,19 +73,19 @@ Outputs: 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() diff --git a/heat/tests/test_parser.py b/heat/tests/test_parser.py index 6f0df68517..335c914a5e 100644 --- a/heat/tests/test_parser.py +++ b/heat/tests/test_parser.py @@ -468,18 +468,18 @@ class StackTest(HeatTestCase): 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): @@ -563,8 +563,8 @@ class StackTest(HeatTestCase): # 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) @@ -629,8 +629,8 @@ class StackTest(HeatTestCase): # 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') @@ -669,8 +669,8 @@ class StackTest(HeatTestCase): # 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') @@ -738,14 +738,14 @@ class StackTest(HeatTestCase): # 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) @@ -782,14 +782,14 @@ class StackTest(HeatTestCase): # 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) @@ -818,7 +818,7 @@ class StackTest(HeatTestCase): 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() @@ -893,14 +893,13 @@ class StackTest(HeatTestCase): 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( @@ -956,8 +955,8 @@ class StackTest(HeatTestCase): # 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') @@ -966,8 +965,8 @@ class StackTest(HeatTestCase): # 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( @@ -1023,13 +1022,12 @@ class StackTest(HeatTestCase): # 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') @@ -1058,13 +1056,12 @@ class StackTest(HeatTestCase): # 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( diff --git a/heat/tests/test_quantum.py b/heat/tests/test_quantum.py index 5121b5177e..8a73a8f275 100644 --- a/heat/tests/test_quantum.py +++ b/heat/tests/test_quantum.py @@ -19,6 +19,7 @@ from testtools import skipIf 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 @@ -199,10 +200,10 @@ class QuantumNetTest(HeatTestCase): 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({ @@ -269,29 +270,30 @@ class QuantumNetTest(HeatTestCase): 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() @@ -306,11 +308,11 @@ class QuantumSubnetTest(HeatTestCase): 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): @@ -369,26 +371,26 @@ class QuantumSubnetTest(HeatTestCase): 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() @@ -407,32 +409,31 @@ class QuantumRouterTest(HeatTestCase): 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({ @@ -499,25 +500,25 @@ class QuantumRouterTest(HeatTestCase): 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): @@ -537,15 +538,15 @@ class QuantumRouterTest(HeatTestCase): 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): @@ -563,15 +564,15 @@ class QuantumRouterTest(HeatTestCase): 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() @@ -637,8 +638,8 @@ class QuantumFloatingIPTest(HeatTestCase): 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) @@ -705,8 +706,8 @@ class QuantumFloatingIPTest(HeatTestCase): 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() @@ -798,8 +799,8 @@ class QuantumFloatingIPTest(HeatTestCase): 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) diff --git a/heat/tests/test_resource.py b/heat/tests/test_resource.py index d69db9ec00..2f2baf9a5e 100644 --- a/heat/tests/test_resource.py +++ b/heat/tests/test_resource.py @@ -143,14 +143,14 @@ class ResourceTest(HeatTestCase): 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): @@ -213,7 +213,7 @@ class ResourceTest(HeatTestCase): 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) @@ -267,11 +267,10 @@ class ResourceTest(HeatTestCase): 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() @@ -287,10 +286,11 @@ class ResourceTest(HeatTestCase): 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): diff --git a/heat/tests/test_s3.py b/heat/tests/test_s3.py index 54d892d546..2ef126bc79 100644 --- a/heat/tests/test_s3.py +++ b/heat/tests/test_s3.py @@ -22,6 +22,7 @@ from testtools import skipIf 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 @@ -69,22 +70,22 @@ class s3Test(HeatTestCase): 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( @@ -100,27 +101,27 @@ class s3Test(HeatTestCase): 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): @@ -136,8 +137,8 @@ class s3Test(HeatTestCase): 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): @@ -153,8 +154,8 @@ class s3Test(HeatTestCase): 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): @@ -170,8 +171,8 @@ class s3Test(HeatTestCase): 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): @@ -188,8 +189,8 @@ class s3Test(HeatTestCase): 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): @@ -205,8 +206,8 @@ class s3Test(HeatTestCase): 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() @@ -227,10 +228,10 @@ class s3Test(HeatTestCase): 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() diff --git a/heat/tests/test_security_group.py b/heat/tests/test_security_group.py index 22ad385793..ffb8c65301 100644 --- a/heat/tests/test_security_group.py +++ b/heat/tests/test_security_group.py @@ -18,6 +18,7 @@ from heat.engine import clients 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 @@ -122,11 +123,11 @@ Resources: 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): @@ -192,7 +193,7 @@ Resources: 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') @@ -265,7 +266,7 @@ Resources: 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') @@ -409,7 +410,7 @@ Resources: 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') @@ -525,7 +526,7 @@ Resources: 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') diff --git a/heat/tests/test_swift.py b/heat/tests/test_swift.py index a036d121e9..c537a5537f 100644 --- a/heat/tests/test_swift.py +++ b/heat/tests/test_swift.py @@ -22,6 +22,7 @@ from testtools import skipIf 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 @@ -69,28 +70,28 @@ class swiftTest(HeatTestCase): 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() @@ -133,30 +134,30 @@ class swiftTest(HeatTestCase): 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): @@ -172,8 +173,8 @@ class swiftTest(HeatTestCase): 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): @@ -190,8 +191,8 @@ class swiftTest(HeatTestCase): 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): @@ -208,8 +209,8 @@ class swiftTest(HeatTestCase): 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): @@ -225,8 +226,8 @@ class swiftTest(HeatTestCase): 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() @@ -247,10 +248,10 @@ class swiftTest(HeatTestCase): 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() diff --git a/heat/tests/test_user.py b/heat/tests/test_user.py index a9407a0ff0..fe784183fe 100644 --- a/heat/tests/test_user.py +++ b/heat/tests/test_user.py @@ -18,6 +18,7 @@ from oslo.config import cfg 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 @@ -99,13 +100,13 @@ class UserPolicyTestCase(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): @@ -117,30 +118,30 @@ class UserTest(UserPolicyTestCase): 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): @@ -153,24 +154,24 @@ class UserTest(UserPolicyTestCase): 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", @@ -181,7 +182,7 @@ class UserTest(UserPolicyTestCase): "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() @@ -192,11 +193,11 @@ class UserTest(UserPolicyTestCase): 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): @@ -213,13 +214,13 @@ class UserTest(UserPolicyTestCase): 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): @@ -238,27 +239,27 @@ class UserTest(UserPolicyTestCase): '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') @@ -275,24 +276,24 @@ class AccessKeyTest(UserPolicyTestCase): 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 @@ -303,9 +304,9 @@ class AccessKeyTest(UserPolicyTestCase): 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): @@ -318,16 +319,16 @@ class AccessKeyTest(UserPolicyTestCase): 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() @@ -339,11 +340,11 @@ class AccessPolicyTest(UserPolicyTestCase): 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) @@ -351,11 +352,11 @@ class AccessPolicyTest(UserPolicyTestCase): 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) @@ -364,30 +365,30 @@ class AccessPolicyTest(UserPolicyTestCase): '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)) diff --git a/heat/tests/test_volume.py b/heat/tests/test_volume.py index 9dbe45704b..530c030d82 100644 --- a/heat/tests/test_volume.py +++ b/heat/tests/test_volume.py @@ -23,6 +23,7 @@ from heat.common import template_format 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 @@ -88,20 +89,20 @@ class VolumeTest(HeatTestCase): 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') @@ -128,19 +129,20 @@ class VolumeTest(HeatTestCase): 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() @@ -161,10 +163,10 @@ class VolumeTest(HeatTestCase): 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() @@ -201,10 +203,10 @@ class VolumeTest(HeatTestCase): 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() @@ -246,11 +248,12 @@ class VolumeTest(HeatTestCase): 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() @@ -279,9 +282,9 @@ class VolumeTest(HeatTestCase): 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() @@ -309,9 +312,9 @@ class VolumeTest(HeatTestCase): 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() @@ -337,14 +340,14 @@ class VolumeTest(HeatTestCase): 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() @@ -411,12 +414,12 @@ class VolumeTest(HeatTestCase): } 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() @@ -441,12 +444,12 @@ class VolumeTest(HeatTestCase): } 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() @@ -478,26 +481,26 @@ class VolumeTest(HeatTestCase): } 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)) @@ -546,16 +549,16 @@ class VolumeTest(HeatTestCase): 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() diff --git a/heat/tests/test_vpc.py b/heat/tests/test_vpc.py index 5748a69e2f..beea1795d3 100644 --- a/heat/tests/test_vpc.py +++ b/heat/tests/test_vpc.py @@ -18,6 +18,7 @@ from heat.common import context 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 @@ -200,11 +201,11 @@ class VPCTestBase(HeatTestCase): {'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): @@ -223,13 +224,14 @@ Resources: 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() @@ -266,22 +268,23 @@ Resources: 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() @@ -439,11 +442,11 @@ Resources: 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() @@ -561,11 +564,12 @@ Resources: 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() @@ -647,15 +651,15 @@ Resources: 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() diff --git a/heat/tests/test_waitcondition.py b/heat/tests/test_waitcondition.py index 71aa475d8a..6ead438624 100644 --- a/heat/tests/test_waitcondition.py +++ b/heat/tests/test_waitcondition.py @@ -31,6 +31,7 @@ import heat.db.api as db_api 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 @@ -133,8 +134,8 @@ class WaitConditionTest(HeatTestCase): 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', @@ -155,9 +156,9 @@ class WaitConditionTest(HeatTestCase): 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', @@ -181,8 +182,8 @@ class WaitConditionTest(HeatTestCase): 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', @@ -203,9 +204,9 @@ class WaitConditionTest(HeatTestCase): 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', @@ -235,14 +236,14 @@ class WaitConditionTest(HeatTestCase): 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 @@ -253,10 +254,10 @@ class WaitConditionTest(HeatTestCase): 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'] @@ -265,13 +266,13 @@ class WaitConditionTest(HeatTestCase): 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() @@ -293,8 +294,8 @@ class WaitConditionTest(HeatTestCase): 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() @@ -314,8 +315,8 @@ class WaitConditionTest(HeatTestCase): 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() @@ -335,8 +336,8 @@ class WaitConditionTest(HeatTestCase): 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() @@ -356,8 +357,8 @@ class WaitConditionTest(HeatTestCase): 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() @@ -377,8 +378,8 @@ class WaitConditionTest(HeatTestCase): 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() @@ -430,9 +431,9 @@ class WaitConditionHandleTest(HeatTestCase): 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/', @@ -446,88 +447,89 @@ class WaitConditionHandleTest(HeatTestCase): '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') @@ -536,21 +538,21 @@ class WaitConditionHandleTest(HeatTestCase): @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()