renderers/ios-xe/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/writer/PolicyWriterUtilTest.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.ios_xe_provider.impl.writer;
  10
  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;
  47
  48 /**
  49  * Test for {@link PolicyWriterUtil}.
  50  */
  51 @RunWith(PowerMockRunner.class)
  52 @PrepareForTest({PolicyWriterUtil.class, NetconfTransactionCreator.class, ServiceChainingUtil.class})
  53 public class PolicyWriterUtilTest {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(PolicyWriterUtilTest.class);
  56
  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";
  59     @Mock
  60     private DataBroker dataBroker;
  61     @Mock
  62     private WriteTransaction wTx;
  63     private java.util.Optional<WriteTransaction> wTxOptional;
  64     @Mock
  65     private ReadOnlyTransaction rTx;
  66     private java.util.Optional<ReadOnlyTransaction> rTxOptional;
  67
  68     @Before
  69     public void setUp() throws Exception {
  70         wTxOptional = java.util.Optional.of(wTx);
  71         rTxOptional = java.util.Optional.of(rTx);
  72     }
  73
  74     @Test
  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));
  78
  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));
  82
  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));
  86
  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));
  91
  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));
  98
  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));
 102     }
 103
 104     @Test
 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));
 108
 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));
 112
 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));
 116
 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));
 121
 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));
 127
 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));
 131     }
 132
 133     @Test
 134     public void testWritePolicyMap() throws Exception {
 135         final List<Class> classEntries = new ArrayList<>();
 136
 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));
 140
 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));
 145
 146         LOG.debug("scenario: fail with null classEntries collection");
 147         try {
 148             PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, null, NODE_ID, dataBroker);
 149             Assert.fail("expected NPE caused by classEntries parameter");
 150         } catch (Exception e) {
 151             // expected
 152         }
 153
 154         LOG.debug("scenario: fail with empty classEntries collection");
 155         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 156
 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));
 163
 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));
 167     }
 168
 169     @Test
 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));
 173
 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));
 177
 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));
 181
 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));
 186
 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));
 191     }
 192
 193     @Test
 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));
 198
 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));
 202
 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));
 206     }
 207
 208     @Test
 209     public void testWriteLocal() throws Exception {
 210         LOG.debug("scenario: succeed with null localForwarder");
 211         Assert.assertTrue(PolicyWriterUtil.writeLocal(null, NODE_ID, dataBroker));
 212
 213         LOG.debug("scenario: fail with no writeOnlyTransaction");
 214         final Local localForwarder = new LocalBuilder().build();
 215         Assert.assertFalse(PolicyWriterUtil.writeLocal(localForwarder, NODE_ID, dataBroker));
 216
 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));
 220
 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));
 224     }
 225
 226     @Test
 227     public void testRemoveLocal() throws Exception {
 228         LOG.debug("scenario: succeed with no service path present");
 229         Assert.assertTrue(PolicyWriterUtil.removeLocal(NODE_ID, dataBroker));
 230
 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));
 234
 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));
 238
 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));
 242     }
 243
 244     @Test
 245     public void testWriteRemote() throws Exception {
 246         LOG.debug("scenario: succeed with null List<ServiceFfName>");
 247         Assert.assertTrue(PolicyWriterUtil.writeRemote(null, NODE_ID, dataBroker));
 248
 249         LOG.debug("scenario: succeed with empty List<ServiceFfName>");
 250         Assert.assertTrue(PolicyWriterUtil.writeRemote(Collections.emptyList(), NODE_ID, dataBroker));
 251
 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));
 255
 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));
 259
 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));
 263     }
 264
 265     @Test
 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));
 269
 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)
 274                         .build()))
 275                 .build());
 276         Assert.assertFalse(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
 277
 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));
 281
 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));
 285     }
 286
 287     @Test
 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));
 291
 292         LOG.debug("scenario: succeed with no service path present");
 293         Assert.assertTrue(PolicyWriterUtil.removeServicePaths(Collections.emptyList(), NODE_ID, dataBroker));
 294
 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)
 299                         .build()))
 300                 .build());
 301         Assert.assertFalse(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
 302
 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));
 306
 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));
 310     }
 311 }