groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerDataBrokerTest.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;
  10
  11 import java.util.Arrays;
  12 import java.util.Collections;
  13
  14 import org.junit.Assert;
  15 import org.junit.Before;
  16 import org.junit.Test;
  17 import org.junit.runner.RunWith;
  18 import org.mockito.ArgumentCaptor;
  19 import org.mockito.Mock;
  20 import org.mockito.Mockito;
  21 import org.mockito.runners.MockitoJUnitRunner;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  24 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  25 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  26 import org.opendaylight.groupbasedpolicy.base_endpoint.EndpointAugmentorRegistryImpl;
  27 import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointsBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpointsBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpointsBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCase;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCaseBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocationBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ForwardingBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenantBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.Tenants;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RenderersBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodesBuilder;
  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.nodes.RendererNodeBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
  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.RendererEndpoints;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPoliciesBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRule;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
  72 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  73
  74 import com.google.common.collect.ImmutableList;
  75 import com.google.common.util.concurrent.CheckedFuture;
  76
  77 @RunWith(MockitoJUnitRunner.class)
  78 public class RendererManagerDataBrokerTest {
  79
  80     private static final RendererName RENDERER_NAME_R1 = new RendererName("R1");
  81     private static final EndpointGroupId EPG_BLUE = new EndpointGroupId("blue_epg");
  82     private static final EndpointGroupId EPG_PURPLE = new EndpointGroupId("purple_epg");
  83     private static final ContractId CONTRACT_1 = new ContractId("contract_1");
  84     private static final SubjectName SUBJECT_1 = new SubjectName("subject_1");
  85     private static final RuleName RULE_1 = new RuleName("rule_1");
  86     private static final String ADR_1 = "adr_1";
  87     private static final String ADR_2 = "adr_2";
  88     private static final InstanceIdentifier<?> NODE_PATH_1 = InstanceIdentifier.create(Tenants.class);
  89     private static final InternalLocationCase INT_LOC_CASE_NODE_PATH_1 =
  90             new InternalLocationCaseBuilder().setInternalNode(NODE_PATH_1).build();
  91     private static final InternalLocation INT_LOC_NODE_PATH_1 =
  92             new InternalLocationBuilder().setInternalNode(NODE_PATH_1).build();
  93     private static final ExternalLocationCase EXT_LOC_CASE_NODE_PATH_1 =
  94             new ExternalLocationCaseBuilder().setExternalNodeMountPoint(NODE_PATH_1).build();
  95
  96     @Mock
  97     private DataBroker dataProvider;
  98     @Mock
  99     private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry;
 100     @Mock
 101     private EndpointAugmentorRegistryImpl epAugmentorRegistry;
 102     @Mock
 103     private WriteTransaction wTx;
 104     @Mock
 105     private CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
 106
 107     private RendererManager rendererManager;
 108
 109     @Before
 110     public void init() {
 111         Mockito.when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
 112         Mockito.when(wTx.submit()).thenReturn(submitFuture);
 113         Mockito.when(netDomainAugmentorRegistry.getNetworkDomainAugmentors()).thenReturn(Collections.emptySet());
 114         Mockito.when(epAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet());
 115         rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry, epAugmentorRegistry);
 116         RendererManager.resetVersion();
 117     }
 118
 119     /**
 120      * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
 121      */
 122     @Test
 123     public void testProcessState_dispatchOnePolicy_rendererFeedbackPositive() throws Exception {
 124         ArgumentCaptor<Renderers> acRenderers = ArgumentCaptor.forClass(Renderers.class);
 125         ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
 126         PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
 127         ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1).build();
 128         ResolvedPolicies resolvedPolicies =
 129                 new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
 130         rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
 131
 132         AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
 133         AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE).build();
 134         rendererManager.endpointsUpdated(new EndpointsBuilder()
 135             .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2)).build())
 136             .build());
 137
 138         AddressEndpointLocation ep1Loc =
 139                 TestDataFactory.defaultAdrEpLoc(ep1.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
 140         AddressEndpointLocation ep2Loc =
 141                 TestDataFactory.defaultAdrEpLoc(ep2.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
 142         EndpointLocations endpointLocations =
 143                 new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc)).build();
 144         rendererManager.endpointLocationsUpdated(endpointLocations);
 145
 146         rendererManager
 147             .forwardingUpdated(new ForwardingBuilder()
 148                 .setForwardingByTenant(
 149                         Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
 150                             .setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
 151                                 .setContextType(ContextType.class)
 152                                 .setContextId(TestDataFactory.CTX_1)
 153                                 .build()))
 154                             .build()))
 155                 .build());
 156
 157         rendererManager.renderersUpdated(new RenderersBuilder()
 158             .setRenderer(Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
 159                 .setRendererNodes(new RendererNodesBuilder()
 160                     .setRendererNode(Arrays.asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build())).build())
 161                 .build()))
 162             .build());
 163
 164         // assert dispatch one policy
 165         Assert.assertEquals(1, rendererManager.getProcessingRenderers().size());
 166         Mockito.verify(wTx).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
 167                 Mockito.eq(InstanceIdentifier.create(Renderers.class)),
 168                 acRenderers.capture());
 169
 170         Renderers renderers = acRenderers.getValue();
 171         Assert.assertNotNull(renderers);
 172         Assert.assertNotNull(renderers.getRenderer());
 173         Assert.assertEquals(1, renderers.getRenderer().size());
 174         Renderer renderer = renderers.getRenderer().get(0);
 175         Assert.assertEquals(RENDERER_NAME_R1, renderer.getName());
 176         RendererPolicy rendererPolicy = renderer.getRendererPolicy();
 177         Assert.assertNotNull(rendererPolicy);
 178         Assert.assertEquals(1, rendererPolicy.getVersion().longValue());
 179
 180         Configuration configuration = rendererPolicy.getConfiguration();
 181         Assert.assertNotNull(configuration);
 182         RendererEndpoints rendererEndpoints = configuration.getRendererEndpoints();
 183         Assert.assertNotNull(rendererEndpoints);
 184         Assert.assertEquals(2, rendererEndpoints.getRendererEndpoint().size());
 185
 186         RendererForwarding rendererForwarding = configuration.getRendererForwarding();
 187         Assert.assertNotNull(rendererForwarding);
 188         Assert.assertEquals(1, rendererForwarding.getRendererForwardingByTenant().size());
 189
 190         Endpoints endpoints = configuration.getEndpoints();
 191         Assert.assertNotNull(endpoints);
 192         Assert.assertEquals(2, endpoints.getAddressEndpointWithLocation().size());
 193
 194         RuleGroups ruleGroups = configuration.getRuleGroups();
 195         Assert.assertNotNull(ruleGroups);
 196         Assert.assertEquals(1, ruleGroups.getRuleGroup().size());
 197
 198         rendererManager
 199             .renderersUpdated(
 200                     new RenderersBuilder()
 201                         .setRenderer(
 202                                 Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
 203                                     .setRendererNodes(new RendererNodesBuilder()
 204                                         .setRendererNode(Arrays
 205                                             .asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build()))
 206                                         .build())
 207                                     .setRendererPolicy(new RendererPolicyBuilder().setVersion(1L).build())
 208                                     .build()))
 209                         .build());
 210         Assert.assertEquals(0, rendererManager.getProcessingRenderers().size());
 211     }
 212
 213     /**
 214      * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE(EIG)--EP2(containment)
 215      */
 216     @Test
 217     public void testProcessState_dispatchOneExternalPolicyWithContainmentEp_noRendererFeedback() throws Exception {
 218         ArgumentCaptor<Renderers> acRenderers = ArgumentCaptor.forClass(Renderers.class);
 219         ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
 220         PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
 221         ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1)
 222             .setExternalImplicitGroup(ExternalImplicitGroup.ProviderEpg)
 223             .build();
 224         ResolvedPolicies resolvedPolicies =
 225                 new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
 226         rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
 227
 228         AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
 229         ContainmentEndpoint ep2 = TestDataFactory.defaultContEp(EPG_PURPLE).build();
 230         rendererManager
 231             .endpointsUpdated(new EndpointsBuilder()
 232                 .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1)).build())
 233                 .setContainmentEndpoints(
 234                         new ContainmentEndpointsBuilder().setContainmentEndpoint(ImmutableList.of(ep2)).build())
 235                 .build());
 236
 237         AddressEndpointLocation ep1Loc =
 238                 TestDataFactory.defaultAdrEpLoc(ep1.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
 239         ContainmentEndpointLocation ep2Loc =
 240                 TestDataFactory.defaultContEpLoc(ep2.getKey(), INT_LOC_NODE_PATH_1).build();
 241         EndpointLocations endpointLocations =
 242                 new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc))
 243                     .setContainmentEndpointLocation(ImmutableList.of(ep2Loc))
 244                     .build();
 245         rendererManager.endpointLocationsUpdated(endpointLocations);
 246
 247         rendererManager
 248             .forwardingUpdated(new ForwardingBuilder()
 249                 .setForwardingByTenant(
 250                         Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
 251                             .setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
 252                                 .setContextType(ContextType.class)
 253                                 .setContextId(TestDataFactory.CTX_1)
 254                                 .build()))
 255                             .build()))
 256                 .build());
 257
 258         rendererManager.renderersUpdated(new RenderersBuilder()
 259             .setRenderer(Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
 260                 .setRendererNodes(new RendererNodesBuilder()
 261                     .setRendererNode(Arrays.asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build())).build())
 262                 .build()))
 263             .build());
 264
 265         // assert dispatch one policy
 266         Assert.assertEquals(1, rendererManager.getProcessingRenderers().size());
 267         Mockito.verify(wTx).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
 268                 Mockito.eq(InstanceIdentifier.create(Renderers.class)),
 269                 acRenderers.capture());
 270
 271         Renderers renderers = acRenderers.getValue();
 272         Assert.assertNotNull(renderers);
 273         Assert.assertNotNull(renderers.getRenderer());
 274         Assert.assertEquals(1, renderers.getRenderer().size());
 275         Renderer renderer = renderers.getRenderer().get(0);
 276         Assert.assertEquals(RENDERER_NAME_R1, renderer.getName());
 277         RendererPolicy rendererPolicy = renderer.getRendererPolicy();
 278         Assert.assertNotNull(rendererPolicy);
 279         Assert.assertEquals(1, rendererPolicy.getVersion().longValue());
 280
 281         Configuration configuration = rendererPolicy.getConfiguration();
 282         Assert.assertNotNull(configuration);
 283         RendererEndpoints rendererEndpoints = configuration.getRendererEndpoints();
 284         Assert.assertNotNull(rendererEndpoints);
 285         Assert.assertEquals(1, rendererEndpoints.getRendererEndpoint().size());
 286
 287         RendererForwarding rendererForwarding = configuration.getRendererForwarding();
 288         Assert.assertNotNull(rendererForwarding);
 289         Assert.assertEquals(1, rendererForwarding.getRendererForwardingByTenant().size());
 290
 291         Endpoints endpoints = configuration.getEndpoints();
 292         Assert.assertNotNull(endpoints);
 293         Assert.assertEquals(1, endpoints.getAddressEndpointWithLocation().size());
 294         Assert.assertEquals(1, endpoints.getContainmentEndpointWithLocation().size());
 295
 296         RuleGroups ruleGroups = configuration.getRuleGroups();
 297         Assert.assertNotNull(ruleGroups);
 298         Assert.assertEquals(1, ruleGroups.getRuleGroup().size());
 299     }
 300
 301     /**
 302      * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE(EIG)--EP2()
 303      */
 304     @Test
 305     public void testProcessState_dispatchOneExternalPolicyWithEp_noRendererFeedback() {
 306         ArgumentCaptor<Renderers> acRenderers = ArgumentCaptor.forClass(Renderers.class);
 307         ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
 308         PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
 309         ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1)
 310             .setExternalImplicitGroup(ExternalImplicitGroup.ProviderEpg)
 311             .build();
 312         ResolvedPolicies resolvedPolicies =
 313                 new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
 314         rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
 315
 316         AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
 317         AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE).build();
 318         rendererManager.endpointsUpdated(new EndpointsBuilder()
 319             .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2)).build())
 320             .build());
 321
 322         AddressEndpointLocation ep1Loc =
 323                 TestDataFactory.defaultAdrEpLoc(ep1.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
 324         AddressEndpointLocation ep2Loc =
 325                 TestDataFactory.defaultAdrEpLoc(ep2.getKey(), EXT_LOC_CASE_NODE_PATH_1).build();
 326         EndpointLocations endpointLocations =
 327                 new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc)).build();
 328         rendererManager.endpointLocationsUpdated(endpointLocations);
 329
 330         rendererManager
 331             .forwardingUpdated(new ForwardingBuilder()
 332                 .setForwardingByTenant(
 333                         Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
 334                             .setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
 335                                 .setContextType(ContextType.class)
 336                                 .setContextId(TestDataFactory.CTX_1)
 337                                 .build()))
 338                             .build()))
 339                 .build());
 340
 341         rendererManager.renderersUpdated(new RenderersBuilder()
 342             .setRenderer(Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
 343                 .setRendererNodes(new RendererNodesBuilder()
 344                     .setRendererNode(Arrays.asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build())).build())
 345                 .build()))
 346             .build());
 347
 348         // assert dispatch one policy
 349         Assert.assertEquals(1, rendererManager.getProcessingRenderers().size());
 350         Mockito.verify(wTx).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
 351                 Mockito.eq(InstanceIdentifier.create(Renderers.class)),
 352                 acRenderers.capture());
 353
 354         Renderers renderers = acRenderers.getValue();
 355         Assert.assertNotNull(renderers);
 356         Assert.assertNotNull(renderers.getRenderer());
 357         Assert.assertEquals(1, renderers.getRenderer().size());
 358         Renderer renderer = renderers.getRenderer().get(0);
 359         Assert.assertEquals(RENDERER_NAME_R1, renderer.getName());
 360         RendererPolicy rendererPolicy = renderer.getRendererPolicy();
 361         Assert.assertNotNull(rendererPolicy);
 362         Assert.assertEquals(1, rendererPolicy.getVersion().longValue());
 363
 364         Configuration configuration = rendererPolicy.getConfiguration();
 365         Assert.assertNotNull(configuration);
 366         RendererEndpoints rendererEndpoints = configuration.getRendererEndpoints();
 367         Assert.assertNotNull(rendererEndpoints);
 368         Assert.assertEquals(1, rendererEndpoints.getRendererEndpoint().size());
 369
 370         RendererForwarding rendererForwarding = configuration.getRendererForwarding();
 371         Assert.assertNotNull(rendererForwarding);
 372         Assert.assertEquals(1, rendererForwarding.getRendererForwardingByTenant().size());
 373
 374         Endpoints endpoints = configuration.getEndpoints();
 375         Assert.assertNotNull(endpoints);
 376         Assert.assertEquals(2, endpoints.getAddressEndpointWithLocation().size());
 377
 378         RuleGroups ruleGroups = configuration.getRuleGroups();
 379         Assert.assertNotNull(ruleGroups);
 380         Assert.assertEquals(1, ruleGroups.getRuleGroup().size());
 381     }
 382
 383 }