renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
  10
  11 import java.util.Arrays;
  12 import java.util.Collection;
  13 import java.util.List;
  14
  15 import org.junit.Assert;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.junit.runner.RunWith;
  19 import org.mockito.Mockito;
  20 import org.mockito.runners.MockitoJUnitRunner;
  21 import org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppRenderer;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.RendererPolicyConfEvent;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
  29 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppEndpointLocationProvider;
  30 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppPathMapper;
  31 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.KeyFactory;
  32 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
  33 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
  34 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.ForwardingContextContainmentBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipation;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipationBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.ConfigurationBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.EndpointsBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpointsBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroupsBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicyBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroup;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.bridge.domain.PhysicalLocationRef;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanVni;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.base.attributes.Interconnection;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.base.attributes.interconnection.BridgeBased;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.BridgeDomains;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.TunnelTypeVxlan;
  88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  89 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  90 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
  91 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  92 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  93 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  94 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  95 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  96
  97 import com.google.common.base.Optional;
  98 import com.google.common.util.concurrent.MoreExecutors;
  99
 100 @RunWith(MockitoJUnitRunner.class)
 101 public class VppRendererPolicyManagerTest extends CustomDataBrokerTest {
 102
 103     private static final InstanceIdentifier<RendererPolicy> RENDERER_POLICY_IID =
 104             IidFactory.rendererIid(VppRenderer.NAME).child(RendererPolicy.class);
 105     private static final ContextId CTX_ID = new ContextId("ctx");
 106     private static final AddressEndpointWithLocationKey CLIENT_EP_KEY =
 107             new AddressEndpointWithLocationKey("1.1.1.1", AddressType.class, CTX_ID, ContextType.class);
 108     private static final AddressEndpointWithLocationKey WEB_EP_KEY =
 109             new AddressEndpointWithLocationKey("2.2.2.2", AddressType.class, CTX_ID, ContextType.class);
 110     private static final ContextId L2FD_CTX = new ContextId("l2fd");
 111     private static final NetworkContainment L2FD_NET_CONT =
 112             new NetworkContainmentBuilder().setContainment(new ForwardingContextContainmentBuilder()
 113                 .setContextType(L2FloodDomain.class).setContextId(L2FD_CTX).build()).build();
 114     private final static TopologyKey TOPO_KEY = new TopologyKey(new TopologyId("topo1"));
 115     private final static NodeKey NODE_KEY = new NodeKey(new NodeId("node1"));
 116     private final static InstanceIdentifier<Node> VPP_NODE_IID = InstanceIdentifier.builder(NetworkTopology.class)
 117         .child(Topology.class, TOPO_KEY)
 118         .child(Node.class, NODE_KEY)
 119         .build();
 120     private static final String IFACE_NAME_CLIENT_EP = "interfaceClient";
 121     private static final String NODE_CONNECTOR_CLIENT_EP = VppPathMapper.interfaceToRestPath(IFACE_NAME_CLIENT_EP);
 122     private static final String IFACE_NAME_WEB_EP = "interfaceWeb";
 123     private static final String NODE_CONNECTOR_WEB_EP = VppPathMapper.interfaceToRestPath(IFACE_NAME_WEB_EP);
 124     private static final ContractId CONTRACT_ID = new ContractId("contract");
 125     private static final TenantId TENANT_ID = new TenantId("tenant");
 126     private static final SubjectName SUBJECT_NAME = new SubjectName("subject");
 127     private static final RuleName RULE_NAME = new RuleName("rule");
 128     private static final RuleGroupWithRendererEndpointParticipation RULE_GROUP_WITH_REND_EP_PART =
 129             new RuleGroupWithRendererEndpointParticipationBuilder().setContractId(CONTRACT_ID)
 130                 .setTenantId(TENANT_ID)
 131                 .setSubjectName(SUBJECT_NAME)
 132                 .setRendererEndpointParticipation(EndpointPolicyParticipation.CONSUMER)
 133                 .build();
 134     private static final RuleGroup RULE_GROUP = new RuleGroupBuilder().setContractId(CONTRACT_ID)
 135         .setTenantId(TENANT_ID)
 136         .setSubjectName(SUBJECT_NAME)
 137         .setResolvedRule(Arrays.asList(new ResolvedRuleBuilder().setName(RULE_NAME).build()))
 138         .build();
 139     // data for InterfaceManager
 140     private final static InstanceIdentifier<VppEndpoint> BASIC_VPP_CLIENT_EP_IID =
 141             InstanceIdentifier.builder(Config.class)
 142                 .child(VppEndpoint.class, new VppEndpointKey(CLIENT_EP_KEY.getAddress(), CLIENT_EP_KEY.getAddressType(),
 143                         CLIENT_EP_KEY.getContextId(), CLIENT_EP_KEY.getContextType()))
 144                 .build();
 145     private final static InstanceIdentifier<VppEndpoint> BASIC_VPP_WEB_EP_IID = InstanceIdentifier.builder(Config.class)
 146         .child(VppEndpoint.class, new VppEndpointKey(WEB_EP_KEY.getAddress(), WEB_EP_KEY.getAddressType(),
 147                 WEB_EP_KEY.getContextId(), WEB_EP_KEY.getContextType()))
 148         .build();
 149     private final static String SOCKET = "socket";
 150
 151     private MountedDataBrokerProvider mountedDataProviderMock;
 152     private DataBroker mountPointDataBroker;
 153     private DataBroker dataBroker;
 154
 155     private BridgeDomainManager bdManager;
 156     private InterfaceManager ifaceManager;
 157     private ForwardingManager fwManager;
 158     private VppRendererPolicyManager vppRendererPolicyManager;
 159
 160     @Override
 161     public Collection<Class<?>> getClassesFromModules() {
 162         return Arrays.asList(Node.class, VppEndpoint.class, Interfaces.class, BridgeDomains.class,
 163                 LocationProviders.class, L2FloodDomain.class, VxlanVni.class, TopologyVbridgeAugment.class,
 164                 TunnelTypeVxlan.class, PhysicalLocationRef.class);
 165     }
 166
 167     @Before
 168     public void init() throws Exception {
 169         ForwardingManager.WAIT_FOR_BD_CREATION = 2;
 170         BridgeDomainManagerImpl.WAIT_FOR_TOPOLOGY_CREATION = 2;
 171         mountedDataProviderMock = Mockito.mock(MountedDataBrokerProvider.class);
 172         mountPointDataBroker = getDataBroker();
 173         setup(); // initialize new data broker for ODL data store
 174         dataBroker = getDataBroker();
 175         Mockito.when(mountedDataProviderMock.getDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class)))
 176             .thenReturn(Optional.of(mountPointDataBroker));
 177         ifaceManager = new InterfaceManager(mountedDataProviderMock, dataBroker, MoreExecutors.newDirectExecutorService());
 178         bdManager = new BridgeDomainManagerImpl(mountPointDataBroker);
 179         fwManager = new ForwardingManager(ifaceManager, bdManager, dataBroker);
 180         vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, dataBroker);
 181     }
 182
 183     @Test
 184     public void testRendererPolicyChanged_createdClient() throws Exception {
 185         storeInterfaceFor(CLIENT_EP_KEY, IFACE_NAME_CLIENT_EP, BASIC_VPP_CLIENT_EP_IID);
 186
 187         AddressEndpointWithLocation clientEp = new AddressEndpointWithLocationBuilder().setKey(CLIENT_EP_KEY)
 188             .setNetworkContainment(L2FD_NET_CONT)
 189             .setAbsoluteLocation(absoluteLocation(VPP_NODE_IID, null, NODE_CONNECTOR_CLIENT_EP))
 190             .build();
 191         AddressEndpointWithLocation webEp = new AddressEndpointWithLocationBuilder().setKey(WEB_EP_KEY)
 192             .setNetworkContainment(L2FD_NET_CONT)
 193             .setAbsoluteLocation(absoluteLocation(VPP_NODE_IID, null, NODE_CONNECTOR_WEB_EP))
 194             .build();
 195         Endpoints endpoints =
 196                 new EndpointsBuilder().setAddressEndpointWithLocation(Arrays.asList(clientEp, webEp)).build();
 197         RendererEndpoint rendererEndpoint = new RendererEndpointBuilder()
 198             .setKey(KeyFactory.rendererEndpointKey(CLIENT_EP_KEY))
 199             .setPeerEndpointWithPolicy(Arrays.asList(new PeerEndpointWithPolicyBuilder()
 200                 .setKey(KeyFactory.peerEndpointWithPolicyKey(WEB_EP_KEY))
 201                 .setRuleGroupWithRendererEndpointParticipation(Arrays.asList(RULE_GROUP_WITH_REND_EP_PART))
 202                 .build()))
 203             .build();
 204         Configuration configuration = new ConfigurationBuilder().setEndpoints(endpoints)
 205             .setRendererEndpoints(
 206                     new RendererEndpointsBuilder().setRendererEndpoint(Arrays.asList(rendererEndpoint)).build())
 207             .setRuleGroups(new RuleGroupsBuilder().setRuleGroup(Arrays.asList(RULE_GROUP)).build())
 208             .build();
 209         RendererPolicy rendererPolicy =
 210                 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
 211         RendererPolicyConfEvent event = new RendererPolicyConfEvent(RENDERER_POLICY_IID, null, rendererPolicy);
 212
 213         vppRendererPolicyManager.rendererPolicyChanged(event);
 214
 215         // assert state on data store behind mount point
 216         ReadOnlyTransaction rTxMount = mountPointDataBroker.newReadOnlyTransaction();
 217         Optional<Interface> potentialIface = rTxMount.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier
 218             .builder(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME_CLIENT_EP)).build()).get();
 219         Assert.assertTrue(potentialIface.isPresent());
 220         Interface iface = potentialIface.get();
 221         VppInterfaceAugmentation vppIfaceAug = iface.getAugmentation(VppInterfaceAugmentation.class);
 222         Assert.assertNotNull(vppIfaceAug);
 223         Interconnection interconnection = vppIfaceAug.getL2().getInterconnection();
 224         Assert.assertNotNull(interconnection);
 225         Assert.assertTrue(interconnection instanceof BridgeBased);
 226         Assert.assertEquals(L2FD_CTX.getValue(), ((BridgeBased) interconnection).getBridgeDomain());
 227         // assert state on ODL data store
 228         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 229         Optional<LocationProvider> optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION,
 230                 IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER))
 231             .get();
 232         Assert.assertTrue(optLocationProvider.isPresent());
 233         List<ProviderAddressEndpointLocation> epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
 234         Assert.assertNotNull(epLocs);
 235         Assert.assertEquals(1, epLocs.size());
 236         Assert.assertEquals(absoluteLocation(VPP_NODE_IID, VppPathMapper.bridgeDomainToRestPath(L2FD_CTX.getValue()),
 237                 NODE_CONNECTOR_CLIENT_EP), epLocs.get(0).getAbsoluteLocation());
 238     }
 239
 240     @Test
 241     public void testRendererPolicyChanged_createdClientAndThenWeb() throws Exception {
 242         testRendererPolicyChanged_createdClient();
 243
 244         storeInterfaceFor(WEB_EP_KEY, IFACE_NAME_WEB_EP, BASIC_VPP_WEB_EP_IID);
 245
 246         AddressEndpointWithLocation webEp = new AddressEndpointWithLocationBuilder().setKey(WEB_EP_KEY)
 247             .setNetworkContainment(L2FD_NET_CONT)
 248             .setAbsoluteLocation(absoluteLocation(VPP_NODE_IID, null, NODE_CONNECTOR_WEB_EP))
 249             .build();
 250         AddressEndpointWithLocation clientEp = new AddressEndpointWithLocationBuilder().setKey(CLIENT_EP_KEY)
 251             .setNetworkContainment(L2FD_NET_CONT)
 252             .setAbsoluteLocation(absoluteLocation(VPP_NODE_IID, null, NODE_CONNECTOR_CLIENT_EP))
 253             .build();
 254         Endpoints endpoints =
 255                 new EndpointsBuilder().setAddressEndpointWithLocation(Arrays.asList(webEp, clientEp)).build();
 256         RendererEndpoint rendererEndpoint = new RendererEndpointBuilder()
 257             .setKey(KeyFactory.rendererEndpointKey(WEB_EP_KEY))
 258             .setPeerEndpointWithPolicy(Arrays.asList(new PeerEndpointWithPolicyBuilder()
 259                 .setKey(KeyFactory.peerEndpointWithPolicyKey(CLIENT_EP_KEY))
 260                 .setRuleGroupWithRendererEndpointParticipation(Arrays.asList(RULE_GROUP_WITH_REND_EP_PART))
 261                 .build()))
 262             .build();
 263         Configuration configuration = new ConfigurationBuilder().setEndpoints(endpoints)
 264             .setRendererEndpoints(
 265                     new RendererEndpointsBuilder().setRendererEndpoint(Arrays.asList(rendererEndpoint)).build())
 266             .setRuleGroups(new RuleGroupsBuilder().setRuleGroup(Arrays.asList(RULE_GROUP)).build())
 267             .build();
 268         RendererPolicy rendererPolicy =
 269                 new RendererPolicyBuilder().setVersion(1L).setConfiguration(configuration).build();
 270         RendererPolicyConfEvent event = new RendererPolicyConfEvent(RENDERER_POLICY_IID, null, rendererPolicy);
 271
 272         vppRendererPolicyManager.rendererPolicyChanged(event);
 273
 274         // assert state on data store behind mount point
 275         ReadOnlyTransaction rTxMount = mountPointDataBroker.newReadOnlyTransaction();
 276         Optional<Interface> potentialIface = rTxMount.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier
 277             .builder(Interfaces.class).child(Interface.class, new InterfaceKey(IFACE_NAME_WEB_EP)).build()).get();
 278         Assert.assertTrue(potentialIface.isPresent());
 279         Interface iface = potentialIface.get();
 280         VppInterfaceAugmentation vppIfaceAug = iface.getAugmentation(VppInterfaceAugmentation.class);
 281         Assert.assertNotNull(vppIfaceAug);
 282         Interconnection interconnection = vppIfaceAug.getL2().getInterconnection();
 283         Assert.assertNotNull(interconnection);
 284         Assert.assertTrue(interconnection instanceof BridgeBased);
 285         Assert.assertEquals(L2FD_CTX.getValue(), ((BridgeBased) interconnection).getBridgeDomain());
 286         // assert state on ODL data store
 287         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 288         Optional<LocationProvider> optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION,
 289                 IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER))
 290             .get();
 291         Assert.assertTrue(optLocationProvider.isPresent());
 292         List<ProviderAddressEndpointLocation> epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
 293         Assert.assertNotNull(epLocs);
 294         Assert.assertEquals(2, epLocs.size());
 295         if (epLocs.get(0).getAddress().equals(CLIENT_EP_KEY.getAddress())) {
 296             Assert.assertEquals(absoluteLocation(VPP_NODE_IID,
 297                     VppPathMapper.bridgeDomainToRestPath(L2FD_CTX.getValue()), NODE_CONNECTOR_CLIENT_EP),
 298                     epLocs.get(0).getAbsoluteLocation());
 299             Assert.assertEquals(absoluteLocation(VPP_NODE_IID,
 300                     VppPathMapper.bridgeDomainToRestPath(L2FD_CTX.getValue()), NODE_CONNECTOR_WEB_EP),
 301                     epLocs.get(1).getAbsoluteLocation());
 302         } else {
 303             Assert.assertEquals(absoluteLocation(VPP_NODE_IID,
 304                     VppPathMapper.bridgeDomainToRestPath(L2FD_CTX.getValue()), NODE_CONNECTOR_CLIENT_EP),
 305                     epLocs.get(1).getAbsoluteLocation());
 306             Assert.assertEquals(absoluteLocation(VPP_NODE_IID,
 307                     VppPathMapper.bridgeDomainToRestPath(L2FD_CTX.getValue()), NODE_CONNECTOR_WEB_EP),
 308                     epLocs.get(0).getAbsoluteLocation());
 309         }
 310     }
 311
 312     private void storeInterfaceFor(AddressEndpointWithLocationKey epKey, String ifaceName,
 313             InstanceIdentifier<VppEndpoint> vppEpIid) {
 314         VppEndpoint vhostEp = new VppEndpointBuilder().setAddress(epKey.getAddress())
 315             .setAddressType(epKey.getAddressType())
 316             .setContextId(epKey.getContextId())
 317             .setContextType(epKey.getContextType())
 318             .setVppInterfaceName(ifaceName)
 319             .setVppNodePath(VPP_NODE_IID)
 320             .setInterfaceTypeChoice(new VhostUserCaseBuilder().setSocket(SOCKET).build())
 321             .build();
 322         VppEndpointConfEvent vppEpEvent = new VppEndpointConfEvent(vppEpIid, null, vhostEp);
 323         ifaceManager.vppEndpointChanged(vppEpEvent);
 324     }
 325
 326     private static AbsoluteLocation absoluteLocation(InstanceIdentifier<?> mountPoint, String node,
 327             String nodeConnector) {
 328         return new AbsoluteLocationBuilder()
 329             .setLocationType(new ExternalLocationCaseBuilder().setExternalNodeMountPoint(mountPoint)
 330                 .setExternalNode(node)
 331                 .setExternalNodeConnector(nodeConnector)
 332                 .build())
 333             .build();
 334     }
 335
 336 }