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.HashSet;
  16 import java.util.List;
  17 import java.util.Set;
  18
  19 import org.junit.Assert;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.junit.runner.RunWith;
  23 import org.mockito.Matchers;
  24 import org.mockito.Mock;
  25 import org.mockito.Mockito;
  26 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  27 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  28 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  30 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.ServiceChainingUtil;
  31 import org.opendaylight.yang.gen.v1.urn.ios.rev160308.ClassNameType;
  32 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMap;
  33 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMapBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChain;
  35 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChainBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.Class;
  37 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.ClassBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.ServicePathBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.Local;
  40 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.LocalBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfName;
  42 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import org.powermock.api.mockito.PowerMockito;
  46 import org.powermock.core.classloader.annotations.PrepareForTest;
  47 import org.powermock.modules.junit4.PowerMockRunner;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 /**
  52  * Test for {@link PolicyWriterUtil}.
  53  */
  54 @RunWith(PowerMockRunner.class)
  55 @PrepareForTest({PolicyWriterUtil.class, NetconfTransactionCreator.class, ServiceChainingUtil.class})
  56 public class PolicyWriterUtilTest {
  57
  58     private static final Logger LOG = LoggerFactory.getLogger(PolicyWriterUtilTest.class);
  59
  60     private static final NodeId NODE_ID = new NodeId("unit-node-id-1");
  61     private static final String POLICY_MAP_NAME = "unit-policy-map-name-1";
  62     @Mock
  63     private DataBroker dataBroker;
  64     @Mock
  65     private WriteTransaction wTx;
  66     private java.util.Optional<WriteTransaction> wTxOptional;
  67     @Mock
  68     private ReadOnlyTransaction rTx;
  69     private java.util.Optional<ReadOnlyTransaction> rTxOptional;
  70
  71     @Before
  72     public void setUp() throws Exception {
  73         wTxOptional = java.util.Optional.of(wTx);
  74         rTxOptional = java.util.Optional.of(rTx);
  75     }
  76
  77     @Test
  78     public void testWriteClassMaps() throws Exception {
  79         LOG.debug("scenario: pass through with null classMapEntries collection");
  80         Assert.assertTrue(PolicyWriterUtil.writeClassMaps(null, NODE_ID, dataBroker));
  81
  82         LOG.debug("scenario: pass through with empty classMapEntries collection");
  83         final Set<ClassMap> classMapEntries = new HashSet<>();
  84         Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  85
  86         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
  87         classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
  88         Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  89
  90         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
  91         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
  92         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
  93         Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  94
  95         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
  96         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
  97         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
  98                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
  99                         new ClassMapBuilder().setName("asd").build())));
 100         Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
 101
 102         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
 103         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
 104         Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
 105     }
 106
 107     @Test
 108     public void testRemoveClassMaps() throws Exception {
 109         LOG.debug("scenario: pass through with null classMapEntries collection");
 110         Assert.assertTrue(PolicyWriterUtil.removeClassMaps(null, NODE_ID, dataBroker));
 111
 112         LOG.debug("scenario: pass through with empty classMapEntries collection");
 113         final Set<ClassMap> classMapEntries = new HashSet<>();
 114         Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 115
 116         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 117         classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
 118         Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 119
 120         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 121         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 122         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 123         Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 124
 125         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
 126         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
 127         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
 128                 .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
 129         Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 130
 131         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
 132         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkRemoved")).toReturn(false);
 133         Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 134     }
 135
 136     @Test
 137     public void testWritePolicyMap() throws Exception {
 138         final Set<Class> classEntries = new HashSet<>();
 139
 140         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 141         classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classEntry-name")).build());
 142         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 143
 144         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 145         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 146         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 147         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 148
 149         LOG.debug("scenario: fail with null classEntries collection");
 150         try {
 151             PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, null, NODE_ID, dataBroker);
 152             Assert.fail("expected NPE caused by classEntries parameter");
 153         } catch (Exception e) {
 154             // expected
 155         }
 156
 157         LOG.debug("scenario: fail with empty classEntries collection");
 158         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 159
 160         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
 161         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
 162         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
 163                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
 164                         new ClassMapBuilder().setName("asd").build())));
 165         Assert.assertTrue(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 166
 167         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
 168         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
 169         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 170     }
 171
 172     @Test
 173     public void testRemovePolicyMapEntries() throws Exception {
 174         LOG.debug("scenario: pass through with null classEntries collection");
 175         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, null, NODE_ID, dataBroker));
 176
 177         LOG.debug("scenario: pass through with empty classEntries collection");
 178         final Set<Class> classEntries = new HashSet<>();
 179         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 180
 181         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 182         classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classMapEntry-name")).build());
 183         Assert.assertFalse(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 184
 185         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 186         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 187         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 188         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 189
 190         //TODO: fix - failed remove transacion shall render whole operation as failed
 191         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
 192         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "deleteTransaction")).toReturn(false);
 193         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 194     }
 195
 196     @Test
 197     public void testWriteInterface() throws Exception {
 198         LOG.debug("scenario: fail with no writeOnlyTransaction");
 199         final String interfaceName = "unit-interface-1";
 200         Assert.assertFalse(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
 201
 202         LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
 203         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 204         Assert.assertTrue(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
 205
 206         LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
 207         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 208         Assert.assertTrue(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
 209     }
 210
 211     @Test
 212     public void testWriteRemote() throws Exception {
 213         LOG.debug("scenario: succeed with null List<ServiceFfName>");
 214         Assert.assertTrue(PolicyWriterUtil.writeRemote(null, NODE_ID, dataBroker));
 215
 216         LOG.debug("scenario: succeed with empty List<ServiceFfName>");
 217         Assert.assertTrue(PolicyWriterUtil.writeRemote(Collections.emptySet(), NODE_ID, dataBroker));
 218
 219         LOG.debug("scenario: fail with no writeOnlyTransaction");
 220         final Set<ServiceFfName> remotes = Collections.singleton(new ServiceFfNameBuilder().build());
 221         Assert.assertFalse(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
 222
 223         LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
 224         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 225         Assert.assertTrue(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
 226
 227         LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
 228         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 229         Assert.assertTrue(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
 230     }
 231
 232     @Test
 233     public void testWriteServicePaths() throws Exception {
 234         LOG.debug("scenario: succeed with empty List<remote>");
 235         Assert.assertTrue(PolicyWriterUtil.writeServicePaths(Collections.emptySet(), NODE_ID, dataBroker));
 236
 237         LOG.debug("scenario: fail with no writeOnlyTransaction");
 238         final Set<ServiceChain> serviceChains = Collections.singleton(new ServiceChainBuilder()
 239                 .setServicePath(Collections.singletonList(new ServicePathBuilder()
 240                         .setServicePathId(42L)
 241                         .build()))
 242                 .build());
 243         Assert.assertFalse(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
 244
 245         LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
 246         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 247         Assert.assertTrue(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
 248
 249         LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
 250         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 251         Assert.assertTrue(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
 252     }
 253
 254     @Test
 255     public void testRemoveServicePaths() throws Exception {
 256         LOG.debug("scenario: succeed with service path present null");
 257         Assert.assertTrue(PolicyWriterUtil.removeServicePaths(null, NODE_ID, dataBroker));
 258
 259         LOG.debug("scenario: succeed with no service path present");
 260         Assert.assertTrue(PolicyWriterUtil.removeServicePaths(Collections.emptySet(), NODE_ID, dataBroker));
 261
 262         LOG.debug("scenario: fail with service path present, no writeOnlyTransaction");
 263         final Set<ServiceChain> serviceChains = Collections.singleton(new ServiceChainBuilder()
 264                 .setServicePath(Collections.singletonList(new ServicePathBuilder()
 265                         .setServicePathId(42L)
 266                         .build()))
 267                 .build());
 268         Assert.assertFalse(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
 269
 270         LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, no submit future");
 271         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 272         Assert.assertTrue(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
 273
 274         LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, available future");
 275         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 276         Assert.assertTrue(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
 277     }
 278 }