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.List;
  15 import org.junit.Assert;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.junit.runner.RunWith;
  19 import org.mockito.Matchers;
  20 import org.mockito.Mock;
  21 import org.mockito.Mockito;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.yang.gen.v1.urn.ios.rev160308.ClassNameType;
  27 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMap;
  28 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMapBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.Class;
  30 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.ClassBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  32 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  33 import org.powermock.api.mockito.PowerMockito;
  34 import org.powermock.core.classloader.annotations.PrepareForTest;
  35 import org.powermock.modules.junit4.PowerMockRunner;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * Test for {@link PolicyWriterUtil}.
  41  */
  42 @RunWith(PowerMockRunner.class)
  43 @PrepareForTest({PolicyWriterUtil.class, NetconfTransactionCreator.class})
  44 public class PolicyWriterUtilTest {
  45
  46     private static final Logger LOG = LoggerFactory.getLogger(PolicyWriterUtilTest.class);
  47
  48     private static final NodeId NODE_ID = new NodeId("unit-node-id-1");
  49     private static final String POLICY_MAP_NAME = "unit-policy-map-name-1";
  50     @Mock
  51     private DataBroker dataBroker;
  52     @Mock
  53     private WriteTransaction wTx;
  54     private java.util.Optional<WriteTransaction> wTxOptional;
  55     @Mock
  56     private ReadOnlyTransaction rTx;
  57     private java.util.Optional<ReadOnlyTransaction> rTxOptional;
  58
  59     @Before
  60     public void setUp() throws Exception {
  61         wTxOptional = java.util.Optional.of(wTx);
  62         rTxOptional = java.util.Optional.of(rTx);
  63     }
  64
  65     @Test
  66     public void testWriteClassMaps() throws Exception {
  67         LOG.debug("scenario: pass through with null classMapEntries collection");
  68         Assert.assertTrue(PolicyWriterUtil.writeClassMaps(null, NODE_ID, dataBroker));
  69
  70         LOG.debug("scenario: pass through with empty classMapEntries collection");
  71         final List<ClassMap> classMapEntries = new ArrayList<>();
  72         Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  73
  74         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
  75         classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
  76         Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  77
  78         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
  79         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
  80         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
  81         Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  82
  83         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
  84         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
  85         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
  86                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
  87                         new ClassMapBuilder().setName("asd").build())));
  88         Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  89
  90         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
  91         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
  92         Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
  93     }
  94
  95     @Test
  96     public void testRemoveClassMaps() throws Exception {
  97         LOG.debug("scenario: pass through with null classMapEntries collection");
  98         Assert.assertTrue(PolicyWriterUtil.removeClassMaps(null, NODE_ID, dataBroker));
  99
 100         LOG.debug("scenario: pass through with empty classMapEntries collection");
 101         final List<ClassMap> classMapEntries = new ArrayList<>();
 102         Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 103
 104         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 105         classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
 106         Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 107
 108         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 109         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 110         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 111         Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 112
 113         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
 114         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
 115         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
 116                 .thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
 117         Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 118
 119         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
 120         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkRemoved")).toReturn(false);
 121         Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
 122     }
 123
 124     @Test
 125     public void testWritePolicyMap() throws Exception {
 126         final List<Class> classEntries = new ArrayList<>();
 127
 128         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 129         classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classEntry-name")).build());
 130         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 131
 132         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 133         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 134         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 135         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 136
 137         LOG.debug("scenario: fail with null classEntries collection");
 138         try {
 139             PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, null, NODE_ID, dataBroker);
 140             Assert.fail("expected NPE caused by classEntries parameter");
 141         } catch (Exception e) {
 142             // expected
 143         }
 144
 145         LOG.debug("scenario: fail with empty classEntries collection");
 146         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 147
 148         LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
 149         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
 150         Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
 151                 .thenReturn(Futures.immediateCheckedFuture(Optional.of(
 152                         new ClassMapBuilder().setName("asd").build())));
 153         Assert.assertTrue(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 154
 155         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
 156         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
 157         Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 158     }
 159
 160     @Test
 161     public void testRemovePolicyMapEntries() throws Exception {
 162         LOG.debug("scenario: pass through with null classEntries collection");
 163         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, null, NODE_ID, dataBroker));
 164
 165         LOG.debug("scenario: pass through with empty classEntries collection");
 166         final List<Class> classEntries = new ArrayList<>();
 167         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 168
 169         LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
 170         classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classMapEntry-name")).build());
 171         Assert.assertFalse(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 172
 173         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
 174         PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
 175         Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
 176         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 177
 178         //TODO: fix - failed remove transacion shall render whole operation as failed
 179         LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
 180         PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "deleteTransaction")).toReturn(false);
 181         Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
 182     }
 183
 184     @Test
 185     public void testWriteInterface() throws Exception {
 186
 187     }
 188
 189     @Test
 190     public void testWriteLocal() throws Exception {
 191
 192     }
 193
 194     @Test
 195     public void testRemoveLocal() throws Exception {
 196
 197     }
 198
 199     @Test
 200     public void testWriteRemote() throws Exception {
 201
 202     }
 203
 204     @Test
 205     public void testWriteServicePaths() throws Exception {
 206
 207     }
 208
 209     @Test
 210     public void testRemoveServicePaths() throws Exception {
 211
 212     }
 213 }