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