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