2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.writer;
11 import com.google.common.base.Optional;
12 import com.google.common.util.concurrent.Futures;
13 import java.util.ArrayList;
14 import java.util.Collections;
15 import java.util.List;
16 import org.junit.Assert;
17 import org.junit.Before;
18 import org.junit.Test;
19 import org.junit.runner.RunWith;
20 import org.mockito.Matchers;
21 import org.mockito.Mock;
22 import org.mockito.Mockito;
23 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
25 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
27 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.ServiceChainingUtil;
28 import org.opendaylight.yang.gen.v1.urn.ios.rev160308.ClassNameType;
29 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMap;
30 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMapBuilder;
31 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChain;
32 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChainBuilder;
33 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.Class;
34 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.ClassBuilder;
35 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.ServicePathBuilder;
36 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.Local;
37 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.LocalBuilder;
38 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfName;
39 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameBuilder;
40 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
42 import org.powermock.api.mockito.PowerMockito;
43 import org.powermock.core.classloader.annotations.PrepareForTest;
44 import org.powermock.modules.junit4.PowerMockRunner;
45 import org.slf4j.Logger;
46 import org.slf4j.LoggerFactory;
49 * Test for {@link PolicyWriterUtil}.
51 @RunWith(PowerMockRunner.class)
52 @PrepareForTest({PolicyWriterUtil.class, NetconfTransactionCreator.class, ServiceChainingUtil.class})
53 public class PolicyWriterUtilTest {
55 private static final Logger LOG = LoggerFactory.getLogger(PolicyWriterUtilTest.class);
57 private static final NodeId NODE_ID = new NodeId("unit-node-id-1");
58 private static final String POLICY_MAP_NAME = "unit-policy-map-name-1";
60 private DataBroker dataBroker;
62 private WriteTransaction wTx;
63 private java.util.Optional<WriteTransaction> wTxOptional;
65 private ReadOnlyTransaction rTx;
66 private java.util.Optional<ReadOnlyTransaction> rTxOptional;
69 public void setUp() throws Exception {
70 wTxOptional = java.util.Optional.of(wTx);
71 rTxOptional = java.util.Optional.of(rTx);
75 public void testWriteClassMaps() throws Exception {
76 LOG.debug("scenario: pass through with null classMapEntries collection");
77 Assert.assertTrue(PolicyWriterUtil.writeClassMaps(null, NODE_ID, dataBroker));
79 LOG.debug("scenario: pass through with empty classMapEntries collection");
80 final List<ClassMap> classMapEntries = new ArrayList<>();
81 Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
83 LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
84 classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
85 Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
87 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
88 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
89 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
90 Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
92 LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
93 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
94 Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
95 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
96 new ClassMapBuilder().setName("asd").build())));
97 Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
99 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
100 PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
101 Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
105 public void testRemoveClassMaps() throws Exception {
106 LOG.debug("scenario: pass through with null classMapEntries collection");
107 Assert.assertTrue(PolicyWriterUtil.removeClassMaps(null, NODE_ID, dataBroker));
109 LOG.debug("scenario: pass through with empty classMapEntries collection");
110 final List<ClassMap> classMapEntries = new ArrayList<>();
111 Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
113 LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
114 classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
115 Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
117 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
118 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
119 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
120 Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
122 LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
123 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
124 Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
125 .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
126 Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
128 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
129 PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkRemoved")).toReturn(false);
130 Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
134 public void testWritePolicyMap() throws Exception {
135 final List<Class> classEntries = new ArrayList<>();
137 LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
138 classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classEntry-name")).build());
139 Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
141 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
142 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
143 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
144 Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
146 LOG.debug("scenario: fail with null classEntries collection");
148 PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, null, NODE_ID, dataBroker);
149 Assert.fail("expected NPE caused by classEntries parameter");
150 } catch (Exception e) {
154 LOG.debug("scenario: fail with empty classEntries collection");
155 Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
157 LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
158 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
159 Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
160 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
161 new ClassMapBuilder().setName("asd").build())));
162 Assert.assertTrue(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
164 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
165 PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
166 Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
170 public void testRemovePolicyMapEntries() throws Exception {
171 LOG.debug("scenario: pass through with null classEntries collection");
172 Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, null, NODE_ID, dataBroker));
174 LOG.debug("scenario: pass through with empty classEntries collection");
175 final List<Class> classEntries = new ArrayList<>();
176 Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
178 LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
179 classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classMapEntry-name")).build());
180 Assert.assertFalse(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
182 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
183 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
184 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
185 Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
187 //TODO: fix - failed remove transacion shall render whole operation as failed
188 LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
189 PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "deleteTransaction")).toReturn(false);
190 Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
194 public void testWriteInterface() throws Exception {
195 LOG.debug("scenario: fail with no writeOnlyTransaction");
196 final String interfaceName = "unit-interface-1";
197 Assert.assertFalse(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
199 LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
200 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
201 Assert.assertTrue(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
203 LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
204 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
205 Assert.assertTrue(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
209 public void testWriteLocal() throws Exception {
210 LOG.debug("scenario: succeed with null localForwarder");
211 Assert.assertTrue(PolicyWriterUtil.writeLocal(null, NODE_ID, dataBroker));
213 LOG.debug("scenario: fail with no writeOnlyTransaction");
214 final Local localForwarder = new LocalBuilder().build();
215 Assert.assertFalse(PolicyWriterUtil.writeLocal(localForwarder, NODE_ID, dataBroker));
217 LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
218 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
219 Assert.assertTrue(PolicyWriterUtil.writeLocal(localForwarder, NODE_ID, dataBroker));
221 LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
222 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
223 Assert.assertTrue(PolicyWriterUtil.writeLocal(localForwarder, NODE_ID, dataBroker));
227 public void testRemoveLocal() throws Exception {
228 LOG.debug("scenario: succeed with no service path present");
229 Assert.assertTrue(PolicyWriterUtil.removeLocal(NODE_ID, dataBroker));
231 LOG.debug("scenario: fail with service path present, no writeOnlyTransaction");
232 PowerMockito.stub(PowerMockito.method(ServiceChainingUtil.class, "checkServicePathPresence")).toReturn(true);
233 Assert.assertFalse(PolicyWriterUtil.removeLocal(NODE_ID, dataBroker));
235 LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, no submit future");
236 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
237 Assert.assertTrue(PolicyWriterUtil.removeLocal(NODE_ID, dataBroker));
239 LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, available future");
240 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
241 Assert.assertTrue(PolicyWriterUtil.removeLocal(NODE_ID, dataBroker));
245 public void testWriteRemote() throws Exception {
246 LOG.debug("scenario: succeed with null List<ServiceFfName>");
247 Assert.assertTrue(PolicyWriterUtil.writeRemote(null, NODE_ID, dataBroker));
249 LOG.debug("scenario: succeed with empty List<ServiceFfName>");
250 Assert.assertTrue(PolicyWriterUtil.writeRemote(Collections.emptyList(), NODE_ID, dataBroker));
252 LOG.debug("scenario: fail with no writeOnlyTransaction");
253 final List<ServiceFfName> remotes = Collections.singletonList(new ServiceFfNameBuilder().build());
254 Assert.assertFalse(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
256 LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
257 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
258 Assert.assertTrue(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
260 LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
261 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
262 Assert.assertTrue(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
266 public void testWriteServicePaths() throws Exception {
267 LOG.debug("scenario: succeed with empty List<remote>");
268 Assert.assertTrue(PolicyWriterUtil.writeServicePaths(Collections.emptyList(), NODE_ID, dataBroker));
270 LOG.debug("scenario: fail with no writeOnlyTransaction");
271 final List<ServiceChain> serviceChains = Collections.singletonList(new ServiceChainBuilder()
272 .setServicePath(Collections.singletonList(new ServicePathBuilder()
273 .setServicePathId(42L)
276 Assert.assertFalse(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
278 LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
279 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
280 Assert.assertTrue(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
282 LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
283 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
284 Assert.assertTrue(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
288 public void testRemoveServicePaths() throws Exception {
289 LOG.debug("scenario: succeed with service path present null");
290 Assert.assertTrue(PolicyWriterUtil.removeServicePaths(null, NODE_ID, dataBroker));
292 LOG.debug("scenario: succeed with no service path present");
293 Assert.assertTrue(PolicyWriterUtil.removeServicePaths(Collections.emptyList(), NODE_ID, dataBroker));
295 LOG.debug("scenario: fail with service path present, no writeOnlyTransaction");
296 final List<ServiceChain> serviceChains = Collections.singletonList(new ServiceChainBuilder()
297 .setServicePath(Collections.singletonList(new ServicePathBuilder()
298 .setServicePathId(42L)
301 Assert.assertFalse(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
303 LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, no submit future");
304 PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
305 Assert.assertTrue(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
307 LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, available future");
308 Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
309 Assert.assertTrue(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));