diff --git a/gbpautomation/heat/engine/resources/neutron/grouppolicy.py b/gbpautomation/heat/engine/resources/neutron/grouppolicy.py index 2fcb1a0..0f3637b 100644 --- a/gbpautomation/heat/engine/resources/neutron/grouppolicy.py +++ b/gbpautomation/heat/engine/resources/neutron/grouppolicy.py @@ -21,12 +21,12 @@ from heat.engine import constraints from heat.engine import properties -class Endpoint(gbpresource.GBPResource): +class PolicyTarget(gbpresource.GBPResource): PROPERTIES = ( - TENANT_ID, NAME, DESCRIPTION, ENDPOINT_GROUP_ID + TENANT_ID, NAME, DESCRIPTION, POLICY_TARGET_GROUP_ID ) = ( - 'tenant_id', 'name', 'description', 'endpoint_group_id' + 'tenant_id', 'name', 'description', 'policy_target_group_id' ) ATTRIBUTES = ( @@ -38,21 +38,21 @@ class Endpoint(gbpresource.GBPResource): properties_schema = { TENANT_ID: properties.Schema( properties.Schema.STRING, - _('Tenant id of the endpoint.') + _('Tenant id of the policy target.') ), NAME: properties.Schema( properties.Schema.STRING, - _('Name of the endpoint.'), + _('Name of the policy target.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, - _('Description of the endpoint.'), + _('Description of the policy target.'), update_allowed=True ), - ENDPOINT_GROUP_ID: properties.Schema( + POLICY_TARGET_GROUP_ID: properties.Schema( properties.Schema.STRING, - _('Endpoint group id of the endpoint.'), + _('Policy target group id of the policy target.'), required=True, update_allowed=True ) @@ -60,14 +60,14 @@ class Endpoint(gbpresource.GBPResource): attributes_schema = { PORT_ID: attributes.Schema( - _("Neutron port id of this endpoint") + _("Neutron port id of this policy target") ) } def _show_resource(self): client = self.grouppolicy() - ep_id = self.resource_id - return client.show_endpoint(ep_id)['endpoint'] + pt_id = self.resource_id + return client.show_policy_target(pt_id)['policy_target'] def handle_create(self): client = self.grouppolicy() @@ -77,24 +77,25 @@ class Endpoint(gbpresource.GBPResource): if self.properties.get(key) is not None: props[key] = self.properties.get(key) - ep = client.create_endpoint({'endpoint': props})['endpoint'] + pt = client.create_policy_target( + {'policy_target': props})['policy_target'] - self.resource_id_set(ep['id']) + self.resource_id_set(pt['id']) def _resolve_attribute(self, name): client = self.grouppolicy() - ep_id = self.resource_id + pt_id = self.resource_id if name == 'port_id': - return client.show_endpoint(ep_id)['endpoint']['port_id'] - return super(Endpoint, self)._resolve_attribute(name) + return client.show_policy_target(pt_id)['policy_target']['port_id'] + return super(PolicyTarget, self)._resolve_attribute(name) def handle_delete(self): client = self.grouppolicy() - ep_id = self.resource_id + pt_id = self.resource_id try: - client.delete_endpoint(ep_id) + client.delete_policy_target(pt_id) except NeutronClientException as ex: self.client_plugin().ignore_not_found(ex) else: @@ -102,61 +103,62 @@ class Endpoint(gbpresource.GBPResource): def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: - self.grouppolicy().update_endpoint( - self.resource_id, {'endpoint': prop_diff}) + self.grouppolicy().update_policy_target( + self.resource_id, {'policy_target': prop_diff}) -class EndpointGroup(gbpresource.GBPResource): +class PolicyTargetGroup(gbpresource.GBPResource): PROPERTIES = ( - TENANT_ID, NAME, DESCRIPTION, L2_POLICY_ID, - PROVIDED_CONTRACTS, CONSUMED_CONTRACTS, NETWORK_SERVICE_POLICY_ID + TENANT_ID, NAME, DESCRIPTION, L2_POLICY_ID, PROVIDED_POLICY_RULE_SETS, + CONSUMED_POLICY_RULE_SETS, NETWORK_SERVICE_POLICY_ID ) = ( 'tenant_id', 'name', 'description', 'l2_policy_id', - 'provided_contracts', 'consumed_contracts', 'network_service_policy_id' + 'provided_policy_rule_sets', 'consumed_policy_rule_sets', + 'network_service_policy_id' ) properties_schema = { TENANT_ID: properties.Schema( properties.Schema.STRING, - _('Tenant id of the endpoint group.') + _('Tenant id of the policy target group.') ), NAME: properties.Schema( properties.Schema.STRING, - _('Name of the endpoint group.'), + _('Name of the policy target group.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, - _('Description of the endpoint group.'), + _('Description of the policy target group.'), update_allowed=True ), L2_POLICY_ID: properties.Schema( properties.Schema.STRING, - _('L2 policy id of the endpoint group.'), + _('L2 policy id of the policy target group.'), update_allowed=True ), - PROVIDED_CONTRACTS: properties.Schema( + PROVIDED_POLICY_RULE_SETS: properties.Schema( properties.Schema.LIST, - _('Provided contracts for the endpoint group.'), + _('Provided policy rule set for the policy target group.'), update_allowed=True ), - CONSUMED_CONTRACTS: properties.Schema( + CONSUMED_POLICY_RULE_SETS: properties.Schema( properties.Schema.LIST, - _('Consumed contracts for the endpoint group.'), + _('Consumed policy rule set for the policy target group.'), update_allowed=True ), NETWORK_SERVICE_POLICY_ID: properties.Schema( properties.Schema.STRING, - _('Network service policy id of the endpoint group.'), + _('Network service policy id of the policy target group.'), update_allowed=True, default=None ) } def _show_resource(self): client = self.grouppolicy() - epg_id = self.resource_id - return client.show_endpoint_group(epg_id)['endpoint_group'] + ptg_id = self.resource_id + return client.show_policy_target_group(ptg_id)['policy_target_group'] def handle_create(self): client = self.grouppolicy() @@ -166,38 +168,46 @@ class EndpointGroup(gbpresource.GBPResource): if self.properties.get(key) is not None: props[key] = self.properties.get(key) - provided_contracts_list = {} - consumed_contracts_list = {} - props_provided_contracts = props.get('provided_contracts', []) - props_consumed_contracts = props.get('consumed_contracts', []) + provided_policy_rule_set_list = {} + consumed_policy_rule_set_list = {} + props_provided_policy_rule_sets = props.get( + 'provided_policy_rule_sets', []) + props_consumed_policy_rule_sets = props.get( + 'consumed_policy_rule_sets', []) - for prop_prov_contract in props_provided_contracts: - contract_id = prop_prov_contract['contract_id'] - contract_scope = prop_prov_contract['contract_scope'] - provided_contracts_list.update({contract_id: contract_scope}) + for prop_prov_policy_rule_set in props_provided_policy_rule_sets: + policy_rule_set_id = ( + prop_prov_policy_rule_set['policy_rule_set_id']) + policy_rule_set_scope = ( + prop_prov_policy_rule_set['policy_rule_set_scope']) + provided_policy_rule_set_list.update({policy_rule_set_id: + policy_rule_set_scope}) - for prop_cons_contract in props_consumed_contracts: - contract_id = prop_cons_contract['contract_id'] - contract_scope = prop_cons_contract['contract_scope'] - consumed_contracts_list.update({contract_id: contract_scope}) + for prop_cons_policy_rule_set in props_consumed_policy_rule_sets: + policy_rule_set_id = ( + prop_cons_policy_rule_set['policy_rule_set_id']) + policy_rule_set_scope = ( + prop_cons_policy_rule_set['policy_rule_set_scope']) + consumed_policy_rule_set_list.update({policy_rule_set_id: + policy_rule_set_scope}) - if provided_contracts_list: - props['provided_contracts'] = provided_contracts_list - if consumed_contracts_list: - props['consumed_contracts'] = consumed_contracts_list + if provided_policy_rule_set_list: + props['provided_policy_rule_sets'] = provided_policy_rule_set_list + if consumed_policy_rule_set_list: + props['consumed_policy_rule_sets'] = consumed_policy_rule_set_list - epg = client.create_endpoint_group( - {'endpoint_group': props})['endpoint_group'] + ptg = client.create_policy_target_group( + {'policy_target_group': props})['policy_target_group'] - self.resource_id_set(epg['id']) + self.resource_id_set(ptg['id']) def handle_delete(self): client = self.grouppolicy() - epg_id = self.resource_id + ptg_id = self.resource_id try: - client.delete_endpoint_group(epg_id) + client.delete_policy_target_group(ptg_id) except NeutronClientException as ex: self.client_plugin().ignore_not_found(ex) else: @@ -205,8 +215,8 @@ class EndpointGroup(gbpresource.GBPResource): def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: - self.grouppolicy().update_endpoint_group( - self.resource_id, {'endpoint_group': prop_diff}) + self.grouppolicy().update_policy_target_group( + self.resource_id, {'policy_target_group': prop_diff}) class L2Policy(gbpresource.GBPResource): @@ -590,39 +600,39 @@ class PolicyRule(gbpresource.GBPResource): self.resource_id, {'policy_rule': prop_diff}) -class Contract(gbpresource.GBPResource): +class PolicyRuleSet(gbpresource.GBPResource): PROPERTIES = ( - TENANT_ID, NAME, DESCRIPTION, PARENT_ID, CHILD_CONTRACTS, + TENANT_ID, NAME, DESCRIPTION, PARENT_ID, CHILD_POLICY_RULE_SETS, POLICY_RULES ) = ( - 'tenant_id', 'name', 'description', 'parent_id', 'child_contracts', - 'policy_rules' + 'tenant_id', 'name', 'description', 'parent_id', + 'child_policy_rule_sets', 'policy_rules' ) properties_schema = { TENANT_ID: properties.Schema( properties.Schema.STRING, - _('Tenant id of the contract.') + _('Tenant id of the policy rule set.') ), NAME: properties.Schema( properties.Schema.STRING, - _('Name of the contract.'), + _('Name of the policy rule set.'), update_allowed=True ), DESCRIPTION: properties.Schema( properties.Schema.STRING, - _('Description of the contract.'), + _('Description of the policy rule set.'), update_allowed=True ), PARENT_ID: properties.Schema( properties.Schema.STRING, - _('Parent id of the contract.'), + _('Parent id of the policy rule set.'), update_allowed=False ), - CHILD_CONTRACTS: properties.Schema( + CHILD_POLICY_RULE_SETS: properties.Schema( properties.Schema.LIST, - _('List of child contracts.'), + _('List of child policy rule sets.'), default=None, update_allowed=True ), POLICY_RULES: properties.Schema( @@ -634,8 +644,8 @@ class Contract(gbpresource.GBPResource): def _show_resource(self): client = self.grouppolicy() - contract_id = self.resource_id - return client.show_contract(contract_id)['contract'] + prs_id = self.resource_id + return client.show_policy_rule_set(prs_id)['policy_rule_set'] def handle_create(self): client = self.grouppolicy() @@ -645,18 +655,18 @@ class Contract(gbpresource.GBPResource): if self.properties.get(key) is not None: props[key] = self.properties.get(key) - contract = client.create_contract( - {'contract': props})['contract'] + policy_rule_set = client.create_policy_rule_set( + {'policy_rule_set': props})['policy_rule_set'] - self.resource_id_set(contract['id']) + self.resource_id_set(policy_rule_set['id']) def handle_delete(self): client = self.grouppolicy() - contract_id = self.resource_id + policy_rule_set_id = self.resource_id try: - client.delete_contract(contract_id) + client.delete_policy_rule_set(policy_rule_set_id) except NeutronClientException as ex: self.client_plugin().ignore_not_found(ex) else: @@ -664,8 +674,8 @@ class Contract(gbpresource.GBPResource): def handle_update(self, json_snippet, tmpl_diff, prop_diff): if prop_diff: - self.grouppolicy().update_contract( - self.resource_id, {'contract': prop_diff}) + self.grouppolicy().update_policy_rule_set( + self.resource_id, {'policy_rule_set': prop_diff}) class NetworkServicePolicy(gbpresource.GBPResource): @@ -737,13 +747,13 @@ class NetworkServicePolicy(gbpresource.GBPResource): def resource_mapping(): return { - 'OS::Neutron::Endpoint': Endpoint, - 'OS::Neutron::EndpointGroup': EndpointGroup, + 'OS::Neutron::PolicyTarget': PolicyTarget, + 'OS::Neutron::PolicyTargetGroup': PolicyTargetGroup, 'OS::Neutron::L2Policy': L2Policy, 'OS::Neutron::L3Policy': L3Policy, 'OS::Neutron::PolicyClassifier': PolicyClassifier, 'OS::Neutron::PolicyAction': PolicyAction, 'OS::Neutron::PolicyRule': PolicyRule, - 'OS::Neutron::Contract': Contract, + 'OS::Neutron::PolicyRuleSet': PolicyRuleSet, 'OS::Neutron::NetworkServicePolicy': NetworkServicePolicy } diff --git a/gbpautomation/heat/tests/test_grouppolicy.py b/gbpautomation/heat/tests/test_grouppolicy.py index da18c6b..81bef9e 100644 --- a/gbpautomation/heat/tests/test_grouppolicy.py +++ b/gbpautomation/heat/tests/test_grouppolicy.py @@ -23,43 +23,47 @@ from heat.engine import scheduler from heat.tests import utils -endpoint_template = ''' +policy_target_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", - "Description" : "Template to test neutron endpoint resource", + "Description" : "Template to test neutron policy target resource", "Parameters" : {}, "Resources" : { - "endpoint": { - "Type": "OS::Neutron::Endpoint", + "policy_target": { + "Type": "OS::Neutron::PolicyTarget", "Properties": { - "name": "test-endpoint", - "endpoint_group_id": "epg-id", - "description": "test endpoint resource" + "name": "test-policy-target", + "policy_target_group_id": "ptg-id", + "description": "test policy target resource" } } } } ''' -endpoint_group_template = ''' +policy_target_group_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", - "Description" : "Template to test neutron endpoint group resource", + "Description" : "Template to test neutron policy target group resource", "Parameters" : {}, "Resources" : { - "endpoint_group": { - "Type": "OS::Neutron::EndpointGroup", + "policy_target_group": { + "Type": "OS::Neutron::PolicyTargetGroup", "Properties": { - "name": "test-endpoint-group", - "description": "test endpoint group resource", + "name": "test-policy-target-group", + "description": "test policy target group resource", "l2_policy_id": "l2-policy-id", - "provided_contracts": [ - {"contract_id": "contract1", "contract_scope": "scope1"}, - {"contract_id": "contract2", "contract_scope": "scope2"} + "provided_policy_rule_sets": [ + {"policy_rule_set_id": "policy_rule_set1", + "policy_rule_set_scope": "scope1"}, + {"policy_rule_set_id": "policy_rule_set2", + "policy_rule_set_scope": "scope2"} ], - "consumed_contracts": [ - {"contract_id": "contract3", "contract_scope": "scope3"}, - {"contract_id": "contract4", "contract_scope": "scope4"} + "consumed_policy_rule_sets": [ + {"policy_rule_set_id": "policy_rule_set3", + "policy_rule_set_scope": "scope3"}, + {"policy_rule_set_id": "policy_rule_set4", + "policy_rule_set_scope": "scope4"} ] } } @@ -164,19 +168,19 @@ policy_rule_template = ''' } ''' -contract_template = ''' +policy_rule_set_template = ''' { "AWSTemplateFormatVersion" : "2010-09-09", - "Description" : "Template to test contract", + "Description" : "Template to test policy rule set", "Parameters" : {}, "Resources" : { - "contract": { - "Type": "OS::Neutron::Contract", + "policy_rule_set": { + "Type": "OS::Neutron::PolicyRuleSet", "Properties": { - "name": "test-contract", - "description": "test contract resource", + "name": "test-policy-rule-set", + "description": "test policy rule set resource", "parent_id": "3456", - "child_contracts": ["7890", "1234"], + "child_policy_rule_sets": ["7890", "1234"], "policy_rules": ["2345", "6789"] } } @@ -204,53 +208,53 @@ network_service_policy_template = ''' ''' -class EndpointTest(HeatTestCase): +class PolicyTargetTest(HeatTestCase): def setUp(self): - super(EndpointTest, self).setUp() - self.m.StubOutWithMock(gbpclient.Client, 'create_endpoint') - self.m.StubOutWithMock(gbpclient.Client, 'delete_endpoint') - self.m.StubOutWithMock(gbpclient.Client, 'show_endpoint') - self.m.StubOutWithMock(gbpclient.Client, 'update_endpoint') + super(PolicyTargetTest, self).setUp() + self.m.StubOutWithMock(gbpclient.Client, 'create_policy_target') + self.m.StubOutWithMock(gbpclient.Client, 'delete_policy_target') + self.m.StubOutWithMock(gbpclient.Client, 'show_policy_target') + self.m.StubOutWithMock(gbpclient.Client, 'update_policy_target') self.stub_keystoneclient() - def create_endpoint(self): - gbpclient.Client.create_endpoint({ - 'endpoint': { - 'name': 'test-endpoint', - 'endpoint_group_id': 'epg-id', - "description": "test endpoint resource" + def create_policy_target(self): + gbpclient.Client.create_policy_target({ + 'policy_target': { + 'name': 'test-policy-target', + 'policy_target_group_id': 'ptg-id', + "description": "test policy target resource" } - }).AndReturn({'endpoint': {'id': '5678'}}) + }).AndReturn({'policy_target': {'id': '5678'}}) - snippet = template_format.parse(endpoint_template) + snippet = template_format.parse(policy_target_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) - return grouppolicy.Endpoint( - 'endpoint', resource_defns['endpoint'], stack) + return grouppolicy.PolicyTarget( + 'policy_target', resource_defns['policy_target'], stack) def test_create(self): - rsrc = self.create_endpoint() + rsrc = self.create_policy_target() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): - gbpclient.Client.create_endpoint({ - 'endpoint': { - 'name': 'test-endpoint', - 'endpoint_group_id': 'epg-id', - "description": "test endpoint resource" + gbpclient.Client.create_policy_target({ + 'policy_target': { + 'name': 'test-policy-target', + 'policy_target_group_id': 'ptg-id', + "description": "test policy target resource" } }).AndRaise(grouppolicy.NeutronClientException()) self.m.ReplayAll() - snippet = template_format.parse(endpoint_template) + snippet = template_format.parse(policy_target_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) - rsrc = grouppolicy.Endpoint( - 'endpoint', resource_defns['endpoint'], stack) + rsrc = grouppolicy.PolicyTarget( + 'policy_target', resource_defns['policy_target'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) @@ -261,11 +265,11 @@ class EndpointTest(HeatTestCase): self.m.VerifyAll() def test_delete(self): - gbpclient.Client.delete_endpoint('5678') - gbpclient.Client.show_endpoint('5678').AndRaise( + gbpclient.Client.delete_policy_target('5678') + gbpclient.Client.show_policy_target('5678').AndRaise( grouppolicy.NeutronClientException(status_code=404)) - rsrc = self.create_endpoint() + rsrc = self.create_policy_target() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() @@ -273,10 +277,10 @@ class EndpointTest(HeatTestCase): self.m.VerifyAll() def test_delete_already_gone(self): - gbpclient.Client.delete_endpoint('5678').AndRaise( + gbpclient.Client.delete_policy_target('5678').AndRaise( grouppolicy.NeutronClientException(status_code=404)) - rsrc = self.create_endpoint() + rsrc = self.create_policy_target() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() @@ -284,10 +288,10 @@ class EndpointTest(HeatTestCase): self.m.VerifyAll() def test_delete_failed(self): - gbpclient.Client.delete_endpoint('5678').AndRaise( + gbpclient.Client.delete_policy_target('5678').AndRaise( grouppolicy.NeutronClientException(status_code=400)) - rsrc = self.create_endpoint() + rsrc = self.create_policy_target() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, @@ -299,103 +303,107 @@ class EndpointTest(HeatTestCase): self.m.VerifyAll() def test_attribute(self): - rsrc = self.create_endpoint() - gbpclient.Client.show_endpoint('5678').MultipleTimes( + rsrc = self.create_policy_target() + gbpclient.Client.show_policy_target('5678').MultipleTimes( ).AndReturn( - {'endpoint': {'port_id': '1234'}}) + {'policy_target': {'port_id': '1234'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual('1234', rsrc.FnGetAtt('port_id')) self.m.VerifyAll() def test_attribute_failed(self): - rsrc = self.create_endpoint() + rsrc = self.create_policy_target() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.InvalidTemplateAttribute, rsrc.FnGetAtt, 'l2_policy_id') self.assertEqual( - 'The Referenced Attribute (endpoint l2_policy_id) is ' + 'The Referenced Attribute (policy_target l2_policy_id) is ' 'incorrect.', str(error)) self.m.VerifyAll() def test_update(self): - rsrc = self.create_endpoint() - gbpclient.Client.update_endpoint( - '5678', {'endpoint': {'endpoint_group_id': 'epg_id_update'}}) + rsrc = self.create_policy_target() + gbpclient.Client.update_policy_target( + '5678', {'policy_target': {'policy_target_group_id': + 'ptg_id_update'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) - update_template['Properties']['endpoint_group_id'] = 'epg_id_update' + update_template['Properties']['policy_target_group_id'] = ( + 'ptg_id_update') scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll() -class EndpointGroupTest(HeatTestCase): +class PolicyTargetGroupTest(HeatTestCase): def setUp(self): - super(EndpointGroupTest, self).setUp() - self.m.StubOutWithMock(gbpclient.Client, 'create_endpoint_group') - self.m.StubOutWithMock(gbpclient.Client, 'delete_endpoint_group') - self.m.StubOutWithMock(gbpclient.Client, 'show_endpoint_group') - self.m.StubOutWithMock(gbpclient.Client, 'update_endpoint_group') + super(PolicyTargetGroupTest, self).setUp() + self.m.StubOutWithMock(gbpclient.Client, 'create_policy_target_group') + self.m.StubOutWithMock(gbpclient.Client, 'delete_policy_target_group') + self.m.StubOutWithMock(gbpclient.Client, 'show_policy_target_group') + self.m.StubOutWithMock(gbpclient.Client, 'update_policy_target_group') self.stub_keystoneclient() - def create_endpoint_group(self): - gbpclient.Client.create_endpoint_group({ - "endpoint_group": { - "name": "test-endpoint-group", - "description": "test endpoint group resource", + def create_policy_target_group(self): + gbpclient.Client.create_policy_target_group({ + "policy_target_group": { + "name": "test-policy-target-group", + "description": "test policy target group resource", "l2_policy_id": "l2-policy-id", - "provided_contracts": { - "contract1": "scope1", - "contract2": "scope2" + "provided_policy_rule_sets": { + "policy_rule_set1": "scope1", + "policy_rule_set2": "scope2" }, - "consumed_contracts": { - "contract3": "scope3", - "contract4": "scope4" + "consumed_policy_rule_sets": { + "policy_rule_set3": "scope3", + "policy_rule_set4": "scope4" } } - }).AndReturn({'endpoint_group': {'id': '5678'}}) + }).AndReturn({'policy_target_group': {'id': '5678'}}) - snippet = template_format.parse(endpoint_group_template) + snippet = template_format.parse(policy_target_group_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) - return grouppolicy.EndpointGroup( - 'endpoint_group', resource_defns['endpoint_group'], stack) + return grouppolicy.PolicyTargetGroup( + 'policy_target_group', resource_defns['policy_target_group'], + stack) def test_create(self): - rsrc = self.create_endpoint_group() + rsrc = self.create_policy_target_group() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): - gbpclient.Client.create_endpoint_group({ - "endpoint_group": { - "name": "test-endpoint-group", - "description": "test endpoint group resource", + gbpclient.Client.create_policy_target_group({ + "policy_target_group": { + "name": "test-policy-target-group", + "description": "test policy target group resource", "l2_policy_id": "l2-policy-id", - "provided_contracts": { - "contract1": "scope1", - "contract2": "scope2" + "provided_policy_rule_sets": { + "policy_rule_set1": "scope1", + "policy_rule_set2": "scope2" }, - "consumed_contracts": { - "contract3": "scope3", - "contract4": "scope4" + "consumed_policy_rule_sets": { + "policy_rule_set3": "scope3", + "policy_rule_set4": "scope4" } } }).AndRaise(grouppolicy.NeutronClientException()) self.m.ReplayAll() - snippet = template_format.parse(endpoint_group_template) + snippet = template_format.parse(policy_target_group_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) - rsrc = grouppolicy.EndpointGroup( - 'endpoint_group', resource_defns['endpoint_group'], stack) + rsrc = grouppolicy.PolicyTargetGroup( + 'policy_target_group', resource_defns['policy_target_group'], + stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) @@ -406,11 +414,11 @@ class EndpointGroupTest(HeatTestCase): self.m.VerifyAll() def test_delete(self): - gbpclient.Client.delete_endpoint_group('5678') - gbpclient.Client.show_endpoint_group('5678').AndRaise( + gbpclient.Client.delete_policy_target_group('5678') + gbpclient.Client.show_policy_target_group('5678').AndRaise( grouppolicy.NeutronClientException(status_code=404)) - rsrc = self.create_endpoint_group() + rsrc = self.create_policy_target_group() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() @@ -418,10 +426,10 @@ class EndpointGroupTest(HeatTestCase): self.m.VerifyAll() def test_delete_already_gone(self): - gbpclient.Client.delete_endpoint_group('5678').AndRaise( + gbpclient.Client.delete_policy_target_group('5678').AndRaise( grouppolicy.NeutronClientException(status_code=404)) - rsrc = self.create_endpoint_group() + rsrc = self.create_policy_target_group() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() @@ -429,10 +437,10 @@ class EndpointGroupTest(HeatTestCase): self.m.VerifyAll() def test_delete_failed(self): - gbpclient.Client.delete_endpoint_group('5678').AndRaise( + gbpclient.Client.delete_policy_target_group('5678').AndRaise( grouppolicy.NeutronClientException(status_code=400)) - rsrc = self.create_endpoint_group() + rsrc = self.create_policy_target_group() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, @@ -444,9 +452,9 @@ class EndpointGroupTest(HeatTestCase): self.m.VerifyAll() def test_update(self): - rsrc = self.create_endpoint_group() - gbpclient.Client.update_endpoint_group( - '5678', {'endpoint_group': {'l2_policy_id': 'l2_id_update'}}) + rsrc = self.create_policy_target_group() + gbpclient.Client.update_policy_target_group( + '5678', {'policy_target_group': {'l2_policy_id': 'l2_id_update'}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() @@ -1015,57 +1023,57 @@ class PolicyRuleTest(HeatTestCase): self.m.VerifyAll() -class ContractTest(HeatTestCase): +class PolicyRuleSetTest(HeatTestCase): def setUp(self): - super(ContractTest, self).setUp() - self.m.StubOutWithMock(gbpclient.Client, 'create_contract') - self.m.StubOutWithMock(gbpclient.Client, 'delete_contract') - self.m.StubOutWithMock(gbpclient.Client, 'show_contract') - self.m.StubOutWithMock(gbpclient.Client, 'update_contract') + super(PolicyRuleSetTest, self).setUp() + self.m.StubOutWithMock(gbpclient.Client, 'create_policy_rule_set') + self.m.StubOutWithMock(gbpclient.Client, 'delete_policy_rule_set') + self.m.StubOutWithMock(gbpclient.Client, 'show_policy_rule_set') + self.m.StubOutWithMock(gbpclient.Client, 'update_policy_rule_set') self.stub_keystoneclient() - def create_contract(self): - gbpclient.Client.create_contract({ - 'contract': { - "name": "test-contract", - "description": "test contract resource", + def create_policy_rule_set(self): + gbpclient.Client.create_policy_rule_set({ + 'policy_rule_set': { + "name": "test-policy-rule-set", + "description": "test policy rule set resource", "parent_id": "3456", - "child_contracts": ["7890", "1234"], + "child_policy_rule_sets": ["7890", "1234"], "policy_rules": ["2345", "6789"] } - }).AndReturn({'contract': {'id': '5678'}}) + }).AndReturn({'policy_rule_set': {'id': '5678'}}) - snippet = template_format.parse(contract_template) + snippet = template_format.parse(policy_rule_set_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) - return grouppolicy.Contract( - 'contract', resource_defns['contract'], stack) + return grouppolicy.PolicyRuleSet( + 'policy_rule_set', resource_defns['policy_rule_set'], stack) def test_create(self): - rsrc = self.create_contract() + rsrc = self.create_policy_rule_set() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() def test_create_failed(self): - gbpclient.Client.create_contract({ - 'contract': { - "name": "test-contract", - "description": "test contract resource", + gbpclient.Client.create_policy_rule_set({ + 'policy_rule_set': { + "name": "test-policy-rule-set", + "description": "test policy rule set resource", "parent_id": "3456", - "child_contracts": ["7890", "1234"], + "child_policy_rule_sets": ["7890", "1234"], "policy_rules": ["2345", "6789"] } }).AndRaise(grouppolicy.NeutronClientException()) self.m.ReplayAll() - snippet = template_format.parse(contract_template) + snippet = template_format.parse(policy_rule_set_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) - rsrc = grouppolicy.Contract( - 'contract', resource_defns['contract'], stack) + rsrc = grouppolicy.PolicyRuleSet( + 'policy_rule_set', resource_defns['policy_rule_set'], stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) @@ -1076,11 +1084,11 @@ class ContractTest(HeatTestCase): self.m.VerifyAll() def test_delete(self): - gbpclient.Client.delete_contract('5678') - gbpclient.Client.show_contract('5678').AndRaise( + gbpclient.Client.delete_policy_rule_set('5678') + gbpclient.Client.show_policy_rule_set('5678').AndRaise( grouppolicy.NeutronClientException(status_code=404)) - rsrc = self.create_contract() + rsrc = self.create_policy_rule_set() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() @@ -1088,10 +1096,10 @@ class ContractTest(HeatTestCase): self.m.VerifyAll() def test_delete_already_gone(self): - gbpclient.Client.delete_contract('5678').AndRaise( + gbpclient.Client.delete_policy_rule_set('5678').AndRaise( grouppolicy.NeutronClientException(status_code=404)) - rsrc = self.create_contract() + rsrc = self.create_policy_rule_set() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() scheduler.TaskRunner(rsrc.delete)() @@ -1099,10 +1107,10 @@ class ContractTest(HeatTestCase): self.m.VerifyAll() def test_delete_failed(self): - gbpclient.Client.delete_contract('5678').AndRaise( + gbpclient.Client.delete_policy_rule_set('5678').AndRaise( grouppolicy.NeutronClientException(status_code=400)) - rsrc = self.create_contract() + rsrc = self.create_policy_rule_set() self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() error = self.assertRaises(exception.ResourceFailure, @@ -1114,14 +1122,14 @@ class ContractTest(HeatTestCase): self.m.VerifyAll() def test_update(self): - rsrc = self.create_contract() - gbpclient.Client.update_contract( - '5678', {'contract': {'child_contracts': ["1234"]}}) + rsrc = self.create_policy_rule_set() + gbpclient.Client.update_policy_rule_set( + '5678', {'policy_rule_set': {'child_policy_rule_sets': ["1234"]}}) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() update_template = copy.deepcopy(rsrc.t) - update_template['Properties']['child_contracts'] = ["1234"] + update_template['Properties']['child_policy_rule_sets'] = ["1234"] scheduler.TaskRunner(rsrc.update, update_template)() self.m.VerifyAll()