openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/TransactionChainManagerTest.java

   1 /*
   2  * Copyright (c) 2015 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.openflowplugin.impl.device;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import com.google.common.util.concurrent.Futures;
  14 import io.netty.util.HashedWheelTimer;
  15 import org.junit.After;
  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.mockito.runners.MockitoJUnitRunner;
  23 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  26 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  27 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  28 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  29 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  30 import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
  31 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  32 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  33 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  34 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
  35 import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleConductor;
  36 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  42 import org.opendaylight.yangtools.concepts.Registration;
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  44 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  45
  46 /**
  47  * Created by mirehak on 4/5/15.
  48  */
  49 @RunWith(MockitoJUnitRunner.class)
  50 public class TransactionChainManagerTest {
  51
  52     @Mock
  53     private DataBroker dataBroker;
  54     @Mock
  55     private ConnectionContext connectionContext;
  56     @Mock
  57     private BindingTransactionChain txChain;
  58     @Mock
  59     private WriteTransaction writeTx;
  60     @Mock
  61     private TransactionChain<?, ?> transactionChain;
  62     @Mock
  63     HashedWheelTimer timer;
  64     @Mock
  65     Registration registration;
  66     @Mock
  67     DeviceState deviceState;
  68     @Mock
  69     LifecycleConductor conductor;
  70
  71     @Mock
  72     private KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent;
  73
  74     private TransactionChainManager txChainManager;
  75     private InstanceIdentifier<Node> path;
  76     private NodeId nodeId;
  77
  78     @Before
  79     public void setUp() throws Exception {
  80         final ReadOnlyTransaction readOnlyTx = Mockito.mock(ReadOnlyTransaction.class);
  81         final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.<Node>absent());
  82         Mockito.when(readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture);
  83         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTx);
  84         Mockito.when(dataBroker.createTransactionChain(Matchers.any(TransactionChainListener.class)))
  85                 .thenReturn(txChain);
  86         nodeId = new NodeId("h2g2:42");
  87         nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
  88         Mockito.when(deviceState.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent);
  89         Mockito.when(deviceState.getNodeId()).thenReturn(nodeId);
  90         txChainManager = new TransactionChainManager(dataBroker, deviceState, conductor);
  91         Mockito.when(txChain.newWriteOnlyTransaction()).thenReturn(writeTx);
  92
  93         path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
  94         Mockito.when(writeTx.submit()).thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
  95         txChainManager.activateTransactionManager();
  96     }
  97
  98     @After
  99     public void tearDown() throws Exception {
 100         Mockito.verifyNoMoreInteractions(txChain, writeTx);
 101     }
 102
 103     @Test
 104     public void testWriteToTransaction() throws Exception {
 105         final Node data = new NodeBuilder().setId(nodeId).build();
 106         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 107
 108         Mockito.verify(txChain).newWriteOnlyTransaction();
 109         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 110     }
 111
 112     /**
 113      * test of {@link TransactionChainManager#submitWriteTransaction()}
 114      * @throws Exception
 115      */
 116     @Test
 117     public void testSubmitTransaction() throws Exception {
 118         final Node data = new NodeBuilder().setId(nodeId).build();
 119         txChainManager.initialSubmitWriteTransaction();
 120         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 121         txChainManager.submitWriteTransaction();
 122
 123         Mockito.verify(txChain).newWriteOnlyTransaction();
 124         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 125         Mockito.verify(writeTx).submit();
 126     }
 127
 128     /**
 129      * test of {@link TransactionChainManager#submitWriteTransaction()}: no submit, never enabled
 130      * @throws Exception
 131      */
 132     @Test
 133     public void testSubmitTransaction1() throws Exception {
 134         final Node data = new NodeBuilder().setId(nodeId).build();
 135         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 136         txChainManager.submitWriteTransaction();
 137
 138         Mockito.verify(txChain).newWriteOnlyTransaction();
 139         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 140         Mockito.verify(writeTx, Mockito.never()).submit();
 141     }
 142
 143     /**
 144      * @throws Exception
 145      */
 146     @Test
 147     public void testSubmitTransactionFailed() throws Exception {
 148         Mockito.when(writeTx.submit()).thenReturn(Futures.<Void, TransactionCommitFailedException>immediateFailedCheckedFuture(new TransactionCommitFailedException("mock")));
 149         final Node data = new NodeBuilder().setId(nodeId).build();
 150         txChainManager.initialSubmitWriteTransaction();
 151         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 152         txChainManager.submitWriteTransaction();
 153
 154         Mockito.verify(txChain).newWriteOnlyTransaction();
 155         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 156         Mockito.verify(writeTx).submit();
 157     }
 158
 159     /**
 160      * test of {@link TransactionChainManager#enableSubmit()}: no submit - counter is not active
 161      *
 162      * @throws Exception
 163      */
 164     @Test
 165     public void testEnableCounter1() throws Exception {
 166         final Node data = new NodeBuilder().setId(nodeId).build();
 167         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 168         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 169
 170         Mockito.verify(txChain).newWriteOnlyTransaction();
 171         Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 172         Mockito.verify(writeTx, Mockito.never()).submit();
 173     }
 174
 175     /**
 176      * @throws Exception
 177      */
 178     @Test
 179     public void testOnTransactionChainFailed() throws Exception {
 180         txChainManager.onTransactionChainFailed(transactionChain, Mockito.mock(AsyncTransaction.class), Mockito.mock(Throwable.class));
 181         Mockito.verify(txChain).close();
 182         Mockito.verify(dataBroker, Mockito.times(2)).createTransactionChain(txChainManager);
 183     }
 184
 185     @Test
 186     public void testOnTransactionChainSuccessful() throws Exception {
 187         txChainManager.onTransactionChainSuccessful(transactionChain);
 188         // NOOP
 189         Mockito.verifyZeroInteractions(transactionChain);
 190     }
 191
 192     @Test
 193     public void testAddDeleteOperationTotTxChain() throws Exception {
 194         txChainManager.addDeleteOperationTotTxChain(LogicalDatastoreType.CONFIGURATION, path);
 195
 196         Mockito.verify(txChain).newWriteOnlyTransaction();
 197         Mockito.verify(writeTx).delete(LogicalDatastoreType.CONFIGURATION, path);
 198     }
 199
 200     @Test
 201     public void testDeactivateTransactionChainManager() throws Exception {
 202         txChainManager.deactivateTransactionManager();
 203
 204         Mockito.verify(txChain).close();
 205     }
 206
 207     /**
 208      * @throws Exception
 209      */
 210     @Test
 211     public void testDeactivateTransactionChainManagerFailed() throws Exception {
 212         Mockito.when(writeTx.submit()).thenReturn(Futures.<Void, TransactionCommitFailedException>immediateFailedCheckedFuture(new TransactionCommitFailedException("mock")));
 213         final Node data = new NodeBuilder().setId(nodeId).build();
 214         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 215
 216         txChainManager.deactivateTransactionManager();
 217
 218         Mockito.verify(txChain).newWriteOnlyTransaction();
 219         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 220         Mockito.verify(writeTx).submit();
 221         Mockito.verify(txChain).close();
 222     }
 223
 224     @Test
 225     public void testShuttingDown() throws Exception{
 226         final Node data = new NodeBuilder().setId(nodeId).build();
 227         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 228
 229         txChainManager.shuttingDown();
 230
 231         Mockito.verify(txChain).newWriteOnlyTransaction();
 232         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 233         Mockito.verify(writeTx).submit();
 234     }
 235
 236     @Test
 237     public void testClose() {
 238         txChainManager.shuttingDown();
 239         txChainManager.close();
 240         Mockito.verify(txChain).close();
 241     }
 242 }