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.manager.PolicyManagerImpl;
  28 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.ServiceChainingUtil;
  29 import org.opendaylight.yang.gen.v1.urn.ios.rev160308.ClassNameType;
  30 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMap;
  31 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMapBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.PolicyMap;
  33 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.PolicyMapBuilder;
  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.ServiceFfName;
  40 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  44 import org.powermock.api.mockito.PowerMockito;
  45 import org.powermock.core.classloader.annotations.PrepareForTest;
  46 import org.powermock.modules.junit4.PowerMockRunner;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 /**
  51  * Test for {@link PolicyWriterUtil}.
  52  */
  53 @RunWith(PowerMockRunner.class)
  54 @PrepareForTest({PolicyWriterUtil.class, NetconfTransactionCreator.class, ServiceChainingUtil.class})
  55 public class PolicyWriterUtilTest {
  56
  57     private static final Logger LOG = LoggerFactory.getLogger(PolicyWriterUtilTest.class);
  58
  59     private static final NodeId NODE_ID = new NodeId("unit-node-id-1");
  60     private static final String POLICY_MAP_NAME = "unit-policy-map-name-1";
  61     @Mock
  62     private DataBroker dataBroker;
  63     @Mock
  64     private WriteTransaction wTx;
  65     private java.util.Optional<WriteTransaction> wTxOptional;
  66     @Mock
  67     private ReadOnlyTransaction rTx;
  68     private java.util.Optional<ReadOnlyTransaction> rTxOptional;
  69
  70     @Before
  71     public void setUp() throws Exception {
  72         wTxOptional = java.util.Optional.of(wTx);
  73         rTxOptional = java.util.Optional.of(rTx);
  74     }
  75
  76     @Test
  77     public void testWriteClassMap() throws Exception {
  78         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
  79         final ClassMap classMap = new ClassMapBuilder().setName("unit-classMapEntry-name").build();
  80         Assert.assertFalse(PolicyWriterUtil.writeClassMap(classMap, getLocation()));
  81
  82         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
  83         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
  84         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
  85         Assert.assertFalse(PolicyWriterUtil.writeClassMap(classMap, getLocation()));
  86
  87         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
  88         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
  89         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
  90                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
  91                         new ClassMapBuilder().setName("asd").build())));
  92         Assert.assertTrue(PolicyWriterUtil.writeClassMap(classMap, getLocation()));
  93
  94         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
  95         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(null);
  96         Assert.assertFalse(PolicyWriterUtil.writeClassMap(classMap, getLocation()));
  97     }
  98
  99     @Test
 100     public void testRemoveClassMap() throws Exception {
 101         LOG.debug("scenario: pass through with null classMapEntries collection");
 102         Assert.assertTrue(PolicyWriterUtil.removeClassMap(null, getLocation()));
 103
 104         LOG.debug("scenario: pass through with empty classMapEntries collection");
 105         final ClassMap classMap = new ClassMapBuilder().setName("unit-classMapEntry-name").build();
 106         Assert.assertTrue(PolicyWriterUtil.removeClassMap(classMap, getLocation()));
 107
 108         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 109         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
 110         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction"))
 111                 .toReturn(java.util.Optional.empty());
 112         Assert.assertFalse(PolicyWriterUtil.removeClassMap(classMap, getLocation()));
 113
 114         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 115         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 116         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 117         Assert.assertFalse(PolicyWriterUtil.removeClassMap(classMap, getLocation()));
 118
 119         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
 120         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
 121         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(null);
 122         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
 123                 .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
 124         Assert.assertTrue(PolicyWriterUtil.removeClassMap(classMap, getLocation()));
 125
 126         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
 127         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
 128         Assert.assertFalse(PolicyWriterUtil.removeClassMap(classMap, getLocation()));
 129     }
 130
 131     @Test
 132     public void testWritePolicyMap() throws Exception {
 133         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 134         final PolicyMap policyMap = new PolicyMapBuilder().setName("unit-policyMap-name").build();
 135         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(policyMap, getLocation()));
 136
 137         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 138         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 139         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 140         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(policyMap, getLocation()));
 141
 142         LOG.debug("scenario: fail with empty classEntries collection");
 143         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(policyMap, getLocation()));
 144
 145         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
 146         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
 147         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
 148                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
 149                         new ClassMapBuilder().setName("asd").build())));
 150         Assert.assertTrue(PolicyWriterUtil.writePolicyMap(policyMap, getLocation()));
 151
 152         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
 153         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(null);
 154         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(policyMap, getLocation()));
 155     }
 156
 157     @Test
 158     public void testRemovePolicyMapEntry() throws Exception {
 159         LOG.debug("scenario: pass through with empty classEntries collection");
 160         final Class entry = new ClassBuilder().setName(new ClassNameType("unit-class-name")).build();
 161         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntry(entry, getLocation()));
 162
 163         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 164         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
 165         Assert.assertFalse(PolicyWriterUtil.removePolicyMapEntry(entry, getLocation()));
 166
 167         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 168         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 169         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 170         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntry(entry, getLocation()));
 171     }
 172
 173     @Test
 174     public void testWriteInterface() throws Exception {
 175         LOG.debug("scenario: fail with no writeOnlyTransaction");
 176         Assert.assertFalse(PolicyWriterUtil.writeInterface(getLocation()));
 177
 178         LOG.debug("scenario: fail - available writeOnlyTransaction, no submit future");
 179         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 180         Assert.assertFalse(PolicyWriterUtil.writeInterface(getLocation()));
 181
 182         LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
 183         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 184         Assert.assertTrue(PolicyWriterUtil.writeInterface(getLocation()));
 185     }
 186
 187     @Test
 188     public void testWriteRemote() throws Exception {
 189         LOG.debug("scenario: succeed with empty List<ServiceFfName>");
 190         final ServiceFfName forwarder = new ServiceFfNameBuilder().setName("unit-service-forwarder-name").build();
 191         Assert.assertFalse(PolicyWriterUtil.writeRemote(forwarder, getLocation()));
 192
 193         LOG.debug("scenario: fail - available writeOnlyTransaction, no submit future");
 194         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 195         Assert.assertFalse(PolicyWriterUtil.writeRemote(forwarder, getLocation()));
 196
 197         LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
 198         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 199         Assert.assertTrue(PolicyWriterUtil.writeRemote(forwarder, getLocation()));
 200     }
 201
 202     @Test
 203     public void testWriteServicePath() throws Exception {
 204         LOG.debug("scenario: fail with no writeOnlyTransaction");
 205         final ServiceChain serviceChain = new ServiceChainBuilder()
 206                 .setServicePath(Collections.singletonList(new ServicePathBuilder()
 207                         .setServicePathId(42L)
 208                         .build()))
 209                 .build();
 210         Assert.assertFalse(PolicyWriterUtil.writeServicePath(serviceChain, getLocation()));
 211
 212         LOG.debug("scenario: fail - available writeOnlyTransaction, no submit future");
 213         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 214         Assert.assertFalse(PolicyWriterUtil.writeServicePath(serviceChain, getLocation()));
 215
 216         LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
 217         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 218         Assert.assertTrue(PolicyWriterUtil.writeServicePath(serviceChain, getLocation()));
 219     }
 220
 221     @Test
 222     public void testRemoveServicePath() throws Exception {
 223         LOG.debug("scenario: fail with service path present, no writeOnlyTransaction");
 224         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
 225         final ServiceChain serviceChain = new ServiceChainBuilder()
 226                 .setServicePath(Collections.singletonList(new ServicePathBuilder()
 227                         .setServicePathId(42L)
 228                         .build()))
 229                 .build();
 230         Assert.assertFalse(PolicyWriterUtil.removeServicePath(serviceChain, getLocation()));
 231
 232         LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, no submit future");
 233         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 234         Assert.assertFalse(PolicyWriterUtil.removeServicePath(serviceChain, getLocation()));
 235
 236         LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, available future");
 237         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 238         Assert.assertTrue(PolicyWriterUtil.removeServicePath(serviceChain, getLocation()));
 239     }
 240
 241     private PolicyManagerImpl.PolicyMapLocation getLocation() {
 242         final String POLICY_MAP = "policy-map";
 243         final String INTERFACE = "interface";
 244         final NodeId nodeId = new NodeId("node-id");
 245         final String IP_ADDRESS = "ip-address";
 246         return new PolicyManagerImpl.PolicyMapLocation(POLICY_MAP, INTERFACE, nodeId, IP_ADDRESS, dataBroker);
 247     }
 248 }