openstack
/
heat
Code Issues Proposed changes

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
This commit is contained in:
Steven Hardy 2013-05-23 15:42:01 +01:00
parent b34c3d359a
commit c35f673e38
38 changed files with 763 additions and 868 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
heat/engine/parser.py
View File

@ -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

45
heat/engine/resource.py
View File

@ -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):
'''

45
heat/engine/resources/autoscaling.py
View File

@ -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" %

15
heat/engine/resources/cloud_watch.py
View File

@ -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,

3
heat/engine/resources/dbinstance.py
View File

@ -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()

3
heat/engine/resources/eip.py
View File

@ -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:

11
heat/engine/resources/instance.py
View File

@ -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):
'''

6
heat/engine/resources/internet_gateway.py
View File

@ -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:

3
heat/engine/resources/loadbalancer.py
View File

@ -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()

3
heat/engine/resources/network_interface.py
View File

@ -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:

3
heat/engine/resources/quantum/quantum.py
View File

@ -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':

6
heat/engine/resources/route_table.py
View File

@ -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:

3
heat/engine/resources/s3.py
View File

@ -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)

3
heat/engine/resources/security_group.py
View File

@ -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()

3
heat/engine/resources/stack.py
View File

@ -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()

3
heat/engine/resources/subnet.py
View File

@ -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, '')

3
heat/engine/resources/swift.py
View File

@ -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)

9
heat/engine/resources/user.py
View File

@ -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']

6
heat/engine/resources/volume.py
View File

@ -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]

3
heat/engine/resources/vpc.py
View File

@ -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:

6
heat/engine/resources/wait_condition.py
View File

@ -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

302
heat/tests/test_autoscaling.py
View File

@ -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()

36
heat/tests/test_cw_alarm.py
View File

@ -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()

51
heat/tests/test_eip.py
View File

@ -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()

3
heat/tests/test_instance.py
View File

@ -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):

54
heat/tests/test_instance_group.py
View File

@ -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()

40
heat/tests/test_loadbalancer.py
View File

@ -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()

18
heat/tests/test_nested_stack.py
View File

@ -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()

73
heat/tests/test_parser.py
View File

@ -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(

141
heat/tests/test_quantum.py
View File

@ -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)

18
heat/tests/test_resource.py
View File

@ -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):

63
heat/tests/test_s3.py
View File

@ -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()

19
heat/tests/test_security_group.py
View File

@ -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')

59
heat/tests/test_swift.py
View File

@ -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()

207
heat/tests/test_user.py
View File

@ -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))

153
heat/tests/test_volume.py
View File

@ -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()

62
heat/tests/test_vpc.py
View File

@ -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()

130
heat/tests/test_waitcondition.py
View File

@ -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()