# License for the specific language governing permissions and limitations
# under the License.
+from heat.common import exception
from heat.engine import clients
from heat.engine import scheduler
from heat.engine.resources.neutron import neutron
'expected_codes', 'url_path')
attributes_schema = {
- 'admin_state_up': 'the administrative state of this port',
+ 'admin_state_up': 'the administrative state of this health monitor',
'delay': 'the minimum time in seconds between regular connections '
'of the member',
'expected_codes': 'the list of HTTP status codes expected in '
self.resource_id)['health_monitor']
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
- self.neutron().update_health_monitor(
- self.resource_id, {'health_monitor': prop_diff})
+ if prop_diff:
+ self.neutron().update_health_monitor(
+ self.resource_id, {'health_monitor': prop_diff})
def handle_delete(self):
try:
return scheduler.TaskRunner(self._confirm_delete)()
+class Pool(neutron.NeutronResource):
+ """
+ A resource for managing load balancer pools in Neutron.
+ """
+
+ vip_schema = {
+ 'name': {'Type': 'String'},
+ 'description': {'Type': 'String'},
+ 'address': {'Type': 'String'},
+ 'connection_limit': {'Type': 'Integer'},
+ 'protocol_port': {'Type': 'Integer', 'Required': True},
+ 'admin_state_up': {'Default': True, 'Type': 'Boolean'},
+ }
+
+ properties_schema = {
+ 'protocol': {'Type': 'String', 'Required': True,
+ 'AllowedValues': ['TCP', 'HTTP', 'HTTPS']},
+ 'subnet_id': {'Type': 'String', 'Required': True},
+ 'lb_method': {'Type': 'String', 'Required': True,
+ 'AllowedValues': ['ROUND_ROBIN', 'LEAST_CONNECTIONS',
+ 'SOURCE_IP']},
+ 'name': {'Type': 'String'},
+ 'description': {'Type': 'String'},
+ 'admin_state_up': {'Default': True, 'Type': 'Boolean'},
+ 'vip': {'Type': 'Map', 'Schema': vip_schema, 'Required': True},
+ 'monitors': {'Type': 'List'},
+ }
+
+ update_allowed_keys = ('Properties',)
+ update_allowed_properties = ('description', 'admin_state_up', 'lb_method',
+ 'monitors')
+
+ attributes_schema = {
+ 'admin_state_up': 'the administrative state of this pool',
+ 'id': 'unique identifier for this pool',
+ 'name': 'friendly name of the pool',
+ 'protocol': 'protocol to balance',
+ 'subnet_id': 'the subnet on which the members of the pool '
+ 'will be located',
+ 'lb_method': 'the algorithm used to distribute load between the '
+ 'members of the pool',
+ 'description': 'description of the pool',
+ 'tenant_id': 'tenant owning the pool',
+ 'vip': 'ip of the pool',
+ }
+
+ def handle_create(self):
+ properties = self.prepare_properties(
+ self.properties,
+ self.physical_resource_name())
+ vip_properties = properties.pop('vip')
+ monitors = properties.pop('monitors', [])
+ client = self.neutron()
+ pool = client.create_pool({'pool': properties})['pool']
+ self.resource_id_set(pool['id'])
+
+ for monitor in monitors:
+ client.associate_health_monitor(
+ pool['id'], {'health_monitor': {'id': monitor}})
+
+ vip_arguments = self.prepare_properties(
+ vip_properties,
+ '%s.vip' % (self.name,))
+ vip_arguments['protocol'] = self.properties['protocol']
+ vip_arguments['subnet_id'] = self.properties['subnet_id']
+ vip_arguments['pool_id'] = pool['id']
+ vip = client.create_vip({'vip': vip_arguments})['vip']
+
+ self.metadata = {'vip': vip['id']}
+
+ def _show_resource(self):
+ return self.neutron().show_pool(self.resource_id)['pool']
+
+ def check_create_complete(self, data):
+ attributes = self._show_resource()
+ if attributes['status'] == 'PENDING_CREATE':
+ return False
+ elif attributes['status'] == 'ACTIVE':
+ vip_attributes = self.neutron().show_vip(
+ self.metadata['vip'])['vip']
+ if vip_attributes['status'] == 'PENDING_CREATE':
+ return False
+ elif vip_attributes['status'] == 'ACTIVE':
+ return True
+ raise exception.Error(
+ 'neutron reported unexpected vip resource[%s] status[%s]' %
+ (vip_attributes['name'], vip_attributes['status']))
+ raise exception.Error(
+ 'neutron report unexpected pool resource[%s] status[%s]' %
+ (attributes['name'], attributes['status']))
+
+ def handle_update(self, json_snippet, tmpl_diff, prop_diff):
+ if prop_diff:
+ client = self.neutron()
+ monitors = set(prop_diff.pop('monitors', []))
+ if monitors:
+ old_monitors = set(self.t['Properties'].get('monitors', []))
+ for monitor in old_monitors - monitors:
+ client.disassociate_health_monitor(
+ self.resource_id, {'health_monitor': {'id': monitor}})
+ for monitor in monitors - old_monitors:
+ client.associate_health_monitor(
+ self.resource_id, {'health_monitor': {'id': monitor}})
+
+ if prop_diff:
+ client.update_pool(self.resource_id, {'pool': prop_diff})
+
+ def _resolve_attribute(self, name):
+ if name == 'vip':
+ return self.neutron().show_vip(self.metadata['vip'])['vip']
+ return super(Pool, self)._resolve_attribute(name)
+
+ def _confirm_vip_delete(self):
+ client = self.neutron()
+ while True:
+ try:
+ yield
+ client.show_vip(self.metadata['vip'])
+ except NeutronClientException as ex:
+ if ex.status_code != 404:
+ raise ex
+ break
+ self._delete_pool()
+
+ def _delete_pool(self):
+ try:
+ self.neutron().delete_pool(self.resource_id)
+ except NeutronClientException as ex:
+ if ex.status_code != 404:
+ raise ex
+ else:
+ return scheduler.TaskRunner(self._confirm_delete)()
+
+ def handle_delete(self):
+ if self.metadata:
+ try:
+ self.neutron().delete_vip(self.metadata['vip'])
+ except NeutronClientException as ex:
+ if ex.status_code != 404:
+ raise ex
+ self._delete_pool()
+ else:
+ return scheduler.TaskRunner(self._confirm_vip_delete)()
+ else:
+ self._delete_pool()
+
+
def resource_mapping():
if clients.neutronclient is None:
return {}
return {
'OS::Neutron::HealthMonitor': HealthMonitor,
+ 'OS::Neutron::Pool': Pool,
}
}
'''
+pool_template = '''
+{
+ "AWSTemplateFormatVersion" : "2010-09-09",
+ "Description" : "Template to test load balancer resources",
+ "Parameters" : {},
+ "Resources" : {
+ "pool": {
+ "Type": "OS::Neutron::Pool",
+ "Properties": {
+ "protocol": "HTTP",
+ "subnet_id": "sub123",
+ "lb_method": "ROUND_ROBIN",
+ "vip": {
+ "protocol_port": 80
+ }
+ }
+ }
+ }
+}
+'''
+
@skipIf(neutronclient is None, 'neutronclient unavailable')
class HealthMonitorTest(HeatTestCase):
stack = utils.parse_stack(snippet)
rsrc = loadbalancer.HealthMonitor(
'monitor', snippet['Resources']['monitor'], stack)
- self.assertRaises(exception.ResourceFailure,
- scheduler.TaskRunner(rsrc.create))
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.create))
+ self.assertEqual(
+ 'NeutronClientException: An unknown exception occurred.',
+ str(error))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def test_delete(self):
- neutronclient.Client.delete_health_monitor('5678').AndReturn(None)
+ neutronclient.Client.delete_health_monitor('5678')
neutronclient.Client.show_health_monitor('5678').AndRaise(
loadbalancer.NeutronClientException(status_code=404))
rsrc = self.create_health_monitor()
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
- self.assertRaises(exception.ResourceFailure,
- scheduler.TaskRunner(rsrc.delete))
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.delete))
+ self.assertEqual(
+ 'NeutronClientException: An unknown exception occurred.',
+ str(error))
self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
rsrc = self.create_health_monitor()
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
- self.assertRaises(exception.InvalidTemplateAttribute,
- rsrc.FnGetAtt, 'subnet_id')
+ error = self.assertRaises(exception.InvalidTemplateAttribute,
+ rsrc.FnGetAtt, 'subnet_id')
+ self.assertEqual(
+ 'The Referenced Attribute (monitor subnet_id) is incorrect.',
+ str(error))
self.m.VerifyAll()
def test_update(self):
rsrc = self.create_health_monitor()
neutronclient.Client.update_health_monitor(
- '5678', {'health_monitor': {'delay': 10}}).AndReturn(None)
+ '5678', {'health_monitor': {'delay': 10}})
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(None, rsrc.update(update_template))
self.m.VerifyAll()
+
+
+@skipIf(neutronclient is None, 'neutronclient unavailable')
+class PoolTest(HeatTestCase):
+
+ def setUp(self):
+ super(PoolTest, self).setUp()
+ self.m.StubOutWithMock(neutronclient.Client, 'create_pool')
+ self.m.StubOutWithMock(neutronclient.Client, 'delete_pool')
+ self.m.StubOutWithMock(neutronclient.Client, 'show_pool')
+ self.m.StubOutWithMock(neutronclient.Client, 'update_pool')
+ self.m.StubOutWithMock(neutronclient.Client,
+ 'associate_health_monitor')
+ self.m.StubOutWithMock(neutronclient.Client,
+ 'disassociate_health_monitor')
+ self.m.StubOutWithMock(neutronclient.Client, 'create_vip')
+ self.m.StubOutWithMock(neutronclient.Client, 'delete_vip')
+ self.m.StubOutWithMock(neutronclient.Client, 'show_vip')
+ self.m.StubOutWithMock(clients.OpenStackClients, 'keystone')
+ utils.setup_dummy_db()
+
+ def create_pool(self):
+ clients.OpenStackClients.keystone().AndReturn(
+ fakes.FakeKeystoneClient())
+ neutronclient.Client.create_pool({
+ 'pool': {
+ 'subnet_id': 'sub123', 'protocol': u'HTTP',
+ 'name': utils.PhysName('test_stack', 'pool'),
+ 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
+ ).AndReturn({'pool': {'id': '5678'}})
+ neutronclient.Client.create_vip({
+ 'vip': {
+ 'protocol': u'HTTP', 'name': 'pool.vip',
+ 'admin_state_up': True, 'subnet_id': u'sub123',
+ 'pool_id': '5678', 'protocol_port': 80}}
+ ).AndReturn({'vip': {'id': 'xyz'}})
+ neutronclient.Client.show_pool('5678').AndReturn(
+ {'pool': {'status': 'ACTIVE'}})
+ neutronclient.Client.show_vip('xyz').AndReturn(
+ {'vip': {'status': 'ACTIVE'}})
+
+ snippet = template_format.parse(pool_template)
+ stack = utils.parse_stack(snippet)
+ return loadbalancer.Pool(
+ 'pool', snippet['Resources']['pool'], stack)
+
+ def test_create(self):
+ rsrc = self.create_pool()
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_create_pending(self):
+ clients.OpenStackClients.keystone().AndReturn(
+ fakes.FakeKeystoneClient())
+ neutronclient.Client.create_pool({
+ 'pool': {
+ 'subnet_id': 'sub123', 'protocol': u'HTTP',
+ 'name': utils.PhysName('test_stack', 'pool'),
+ 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
+ ).AndReturn({'pool': {'id': '5678'}})
+ neutronclient.Client.create_vip({
+ 'vip': {
+ 'protocol': u'HTTP', 'name': 'pool.vip',
+ 'admin_state_up': True, 'subnet_id': u'sub123',
+ 'pool_id': '5678', 'protocol_port': 80}}
+ ).AndReturn({'vip': {'id': 'xyz'}})
+ neutronclient.Client.show_pool('5678').AndReturn(
+ {'pool': {'status': 'PENDING_CREATE'}})
+ neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn(
+ {'pool': {'status': 'ACTIVE'}})
+ neutronclient.Client.show_vip('xyz').AndReturn(
+ {'vip': {'status': 'PENDING_CREATE'}})
+ neutronclient.Client.show_vip('xyz').AndReturn(
+ {'vip': {'status': 'ACTIVE'}})
+
+ snippet = template_format.parse(pool_template)
+ stack = utils.parse_stack(snippet)
+ rsrc = loadbalancer.Pool(
+ 'pool', snippet['Resources']['pool'], stack)
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_create_failed_unexpected_status(self):
+ clients.OpenStackClients.keystone().AndReturn(
+ fakes.FakeKeystoneClient())
+ neutronclient.Client.create_pool({
+ 'pool': {
+ 'subnet_id': 'sub123', 'protocol': u'HTTP',
+ 'name': utils.PhysName('test_stack', 'pool'),
+ 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
+ ).AndReturn({'pool': {'id': '5678'}})
+ neutronclient.Client.create_vip({
+ 'vip': {
+ 'protocol': u'HTTP', 'name': 'pool.vip',
+ 'admin_state_up': True, 'subnet_id': u'sub123',
+ 'pool_id': '5678', 'protocol_port': 80}}
+ ).AndReturn({'vip': {'id': 'xyz'}})
+ neutronclient.Client.show_pool('5678').AndReturn(
+ {'pool': {'status': 'ERROR', 'name': '5678'}})
+
+ snippet = template_format.parse(pool_template)
+ stack = utils.parse_stack(snippet)
+ rsrc = loadbalancer.Pool(
+ 'pool', snippet['Resources']['pool'], stack)
+ self.m.ReplayAll()
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.create))
+ self.assertEqual(
+ 'Error: neutron report unexpected pool '
+ 'resource[5678] status[ERROR]',
+ str(error))
+ self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_create_failed_unexpected_vip_status(self):
+ clients.OpenStackClients.keystone().AndReturn(
+ fakes.FakeKeystoneClient())
+ neutronclient.Client.create_pool({
+ 'pool': {
+ 'subnet_id': 'sub123', 'protocol': u'HTTP',
+ 'name': utils.PhysName('test_stack', 'pool'),
+ 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
+ ).AndReturn({'pool': {'id': '5678'}})
+ neutronclient.Client.create_vip({
+ 'vip': {
+ 'protocol': u'HTTP', 'name': 'pool.vip',
+ 'admin_state_up': True, 'subnet_id': u'sub123',
+ 'pool_id': '5678', 'protocol_port': 80}}
+ ).AndReturn({'vip': {'id': 'xyz'}})
+ neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn(
+ {'pool': {'status': 'ACTIVE'}})
+ neutronclient.Client.show_vip('xyz').AndReturn(
+ {'vip': {'status': 'ERROR', 'name': 'xyz'}})
+
+ snippet = template_format.parse(pool_template)
+ stack = utils.parse_stack(snippet)
+ rsrc = loadbalancer.Pool(
+ 'pool', snippet['Resources']['pool'], stack)
+ self.m.ReplayAll()
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.create))
+ self.assertEqual(
+ 'Error: neutron reported unexpected vip '
+ 'resource[xyz] status[ERROR]',
+ str(error))
+ self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_create_failed(self):
+ clients.OpenStackClients.keystone().AndReturn(
+ fakes.FakeKeystoneClient())
+ neutronclient.Client.create_pool({
+ 'pool': {
+ 'subnet_id': 'sub123', 'protocol': u'HTTP',
+ 'name': utils.PhysName('test_stack', 'pool'),
+ 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
+ ).AndRaise(loadbalancer.NeutronClientException())
+ self.m.ReplayAll()
+
+ snippet = template_format.parse(pool_template)
+ stack = utils.parse_stack(snippet)
+ rsrc = loadbalancer.Pool(
+ 'pool', snippet['Resources']['pool'], stack)
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.create))
+ self.assertEqual(
+ 'NeutronClientException: An unknown exception occurred.',
+ str(error))
+ self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_delete(self):
+ rsrc = self.create_pool()
+ neutronclient.Client.delete_vip('xyz')
+ neutronclient.Client.show_vip('xyz').AndRaise(
+ loadbalancer.NeutronClientException(status_code=404))
+ neutronclient.Client.delete_pool('5678')
+ neutronclient.Client.show_pool('5678').AndRaise(
+ loadbalancer.NeutronClientException(status_code=404))
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ scheduler.TaskRunner(rsrc.delete)()
+ self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_delete_already_gone(self):
+ neutronclient.Client.delete_vip('xyz').AndRaise(
+ loadbalancer.NeutronClientException(status_code=404))
+ neutronclient.Client.delete_pool('5678').AndRaise(
+ loadbalancer.NeutronClientException(status_code=404))
+
+ rsrc = self.create_pool()
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ scheduler.TaskRunner(rsrc.delete)()
+ self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_delete_vip_failed(self):
+ neutronclient.Client.delete_vip('xyz').AndRaise(
+ loadbalancer.NeutronClientException(status_code=400))
+
+ rsrc = self.create_pool()
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.delete))
+ self.assertEqual(
+ 'NeutronClientException: An unknown exception occurred.',
+ str(error))
+ self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_delete_failed(self):
+ neutronclient.Client.delete_vip('xyz').AndRaise(
+ loadbalancer.NeutronClientException(status_code=404))
+ neutronclient.Client.delete_pool('5678').AndRaise(
+ loadbalancer.NeutronClientException(status_code=400))
+
+ rsrc = self.create_pool()
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ error = self.assertRaises(exception.ResourceFailure,
+ scheduler.TaskRunner(rsrc.delete))
+ self.assertEqual(
+ 'NeutronClientException: An unknown exception occurred.',
+ str(error))
+ self.assertEqual((rsrc.DELETE, rsrc.FAILED), rsrc.state)
+ self.m.VerifyAll()
+
+ def test_attribute(self):
+ rsrc = self.create_pool()
+ neutronclient.Client.show_pool('5678').MultipleTimes(
+ ).AndReturn(
+ {'pool': {'admin_state_up': True, 'lb_method': 'ROUND_ROBIN'}})
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual(True, rsrc.FnGetAtt('admin_state_up'))
+ self.assertEqual('ROUND_ROBIN', rsrc.FnGetAtt('lb_method'))
+ self.m.VerifyAll()
+
+ def test_vip_attribute(self):
+ rsrc = self.create_pool()
+ neutronclient.Client.show_vip('xyz').AndReturn(
+ {'vip': {'address': '10.0.0.3', 'name': 'xyz'}})
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ self.assertEqual({'address': '10.0.0.3', 'name': 'xyz'},
+ rsrc.FnGetAtt('vip'))
+ self.m.VerifyAll()
+
+ def test_attribute_failed(self):
+ rsrc = self.create_pool()
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+ error = self.assertRaises(exception.InvalidTemplateAttribute,
+ rsrc.FnGetAtt, 'net_id')
+ self.assertEqual(
+ 'The Referenced Attribute (pool net_id) is incorrect.',
+ str(error))
+ self.m.VerifyAll()
+
+ def test_update(self):
+ rsrc = self.create_pool()
+ neutronclient.Client.update_pool(
+ '5678', {'pool': {'admin_state_up': False}})
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+
+ update_template = copy.deepcopy(rsrc.t)
+ update_template['Properties']['admin_state_up'] = False
+ self.assertEqual(None, rsrc.update(update_template))
+
+ self.m.VerifyAll()
+
+ def test_update_monitors(self):
+ clients.OpenStackClients.keystone().AndReturn(
+ fakes.FakeKeystoneClient())
+ neutronclient.Client.create_pool({
+ 'pool': {
+ 'subnet_id': 'sub123', 'protocol': u'HTTP',
+ 'name': utils.PhysName('test_stack', 'pool'),
+ 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
+ ).AndReturn({'pool': {'id': '5678'}})
+ neutronclient.Client.associate_health_monitor(
+ '5678', {'health_monitor': {'id': 'mon123'}})
+ neutronclient.Client.associate_health_monitor(
+ '5678', {'health_monitor': {'id': 'mon456'}})
+ neutronclient.Client.create_vip({
+ 'vip': {
+ 'protocol': u'HTTP', 'name': 'pool.vip',
+ 'admin_state_up': True, 'subnet_id': u'sub123',
+ 'pool_id': '5678', 'protocol_port': 80}}
+ ).AndReturn({'vip': {'id': 'xyz'}})
+ neutronclient.Client.show_pool('5678').AndReturn(
+ {'pool': {'status': 'ACTIVE'}})
+ neutronclient.Client.show_vip('xyz').AndReturn(
+ {'vip': {'status': 'ACTIVE'}})
+ neutronclient.Client.disassociate_health_monitor(
+ '5678', {'health_monitor': {'id': 'mon456'}})
+ neutronclient.Client.associate_health_monitor(
+ '5678', {'health_monitor': {'id': 'mon789'}})
+
+ snippet = template_format.parse(pool_template)
+ stack = utils.parse_stack(snippet)
+ snippet['Resources']['pool']['Properties']['monitors'] = [
+ 'mon123', 'mon456']
+ rsrc = loadbalancer.Pool(
+ 'pool', snippet['Resources']['pool'], stack)
+ self.m.ReplayAll()
+ scheduler.TaskRunner(rsrc.create)()
+
+ update_template = copy.deepcopy(rsrc.t)
+ update_template['Properties']['monitors'] = ['mon123', 'mon789']
+ self.assertEqual(None, rsrc.update(update_template))
+
+ self.m.VerifyAll()
Code Review / openstack-build / heat-build.git / commitdiff