1fde0ca0237802c64615ae032b02d7e759e907d0
[groupbasedpolicy.git] / 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 }