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