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 static org.mockito.ArgumentMatchers.any;
  12
  13 import com.google.common.base.Optional;
  14 import com.google.common.util.concurrent.CheckedFuture;
  15 import com.google.common.util.concurrent.Futures;
  16 import org.junit.After;
  17 import org.junit.Before;
  18 import org.junit.Test;
  19 import org.junit.runner.RunWith;
  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.ReadWriteTransaction;
  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.device.DeviceInfo;
  34 import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager;
  35 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  42 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  43
  44 @RunWith(MockitoJUnitRunner.class)
  45 public class TransactionChainManagerTest {
  46
  47     @Mock
  48     private DataBroker dataBroker;
  49     @Mock
  50     private BindingTransactionChain txChain;
  51     @Mock
  52     private ReadWriteTransaction writeTx;
  53     @Mock
  54     private TransactionChain<?, ?> transactionChain;
  55     @Mock
  56     DeviceInfo deviceInfo;
  57
  58     @Mock
  59     private KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent;
  60
  61     private TransactionChainManager txChainManager;
  62     private InstanceIdentifier<Node> path;
  63     private NodeId nodeId;
  64
  65     @Before
  66     public void setUp() throws Exception {
  67         final ReadOnlyTransaction readOnlyTx = Mockito.mock(ReadOnlyTransaction.class);
  68         final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures
  69                 .immediateCheckedFuture(Optional.<Node>absent());
  70         Mockito.when(dataBroker.createTransactionChain(any(TransactionChainListener.class)))
  71                 .thenReturn(txChain);
  72         nodeId = new NodeId("h2g2:42");
  73         nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
  74         txChainManager = new TransactionChainManager(dataBroker, nodeId.getValue());
  75         Mockito.when(txChain.newReadWriteTransaction()).thenReturn(writeTx);
  76
  77         path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
  78         Mockito.when(writeTx.submit())
  79                 .thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
  80         txChainManager.activateTransactionManager();
  81     }
  82
  83     @After
  84     public void tearDown() throws Exception {
  85         Mockito.verifyNoMoreInteractions(txChain, writeTx);
  86     }
  87
  88     @Test
  89     public void testWriteToTransaction() throws Exception {
  90         final Node data = new NodeBuilder().setId(nodeId).build();
  91         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
  92
  93         Mockito.verify(txChain).newReadWriteTransaction();
  94         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
  95     }
  96
  97     /**
  98      * Tests transaction submit {@link TransactionChainManager#submitTransaction()}.
  99      */
 100     @Test
 101     public void testSubmitTransaction() throws Exception {
 102         final Node data = new NodeBuilder().setId(nodeId).build();
 103         txChainManager.initialSubmitWriteTransaction();
 104         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 105         txChainManager.submitTransaction();
 106
 107         Mockito.verify(txChain).newReadWriteTransaction();
 108         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 109         Mockito.verify(writeTx).submit();
 110     }
 111
 112     /**
 113      * test of {@link TransactionChainManager#submitTransaction()}: no submit, never enabled.
 114      */
 115     @Test
 116     public void testSubmitTransaction1() throws Exception {
 117         final Node data = new NodeBuilder().setId(nodeId).build();
 118         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 119         txChainManager.submitTransaction();
 120
 121         Mockito.verify(txChain).newReadWriteTransaction();
 122         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 123         Mockito.verify(writeTx, Mockito.never()).submit();
 124     }
 125
 126     @Test
 127     public void testSubmitTransactionFailed() throws Exception {
 128         Mockito.when(writeTx.submit()).thenReturn(
 129                 Futures.<Void, TransactionCommitFailedException>immediateFailedCheckedFuture(
 130                         new TransactionCommitFailedException("mock")));
 131         final Node data = new NodeBuilder().setId(nodeId).build();
 132         txChainManager.initialSubmitWriteTransaction();
 133         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 134         txChainManager.submitTransaction();
 135
 136         Mockito.verify(txChain).newReadWriteTransaction();
 137         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 138         Mockito.verify(writeTx).submit();
 139     }
 140
 141     /**
 142      * Test of {@link TransactionChainManager#enableSubmit()}: no submit - counter is not active.
 143      */
 144     @Test
 145     public void testEnableCounter1() throws Exception {
 146         final Node data = new NodeBuilder().setId(nodeId).build();
 147         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 148         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 149
 150         Mockito.verify(txChain).newReadWriteTransaction();
 151         Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 152         Mockito.verify(writeTx, Mockito.never()).submit();
 153     }
 154
 155     @Test
 156     public void testOnTransactionChainFailed() throws Exception {
 157         txChainManager
 158                 .onTransactionChainFailed(txChain, Mockito.mock(AsyncTransaction.class), Mockito.mock(Throwable.class));
 159         Mockito.verify(txChain).close();
 160         Mockito.verify(dataBroker, Mockito.times(2)).createTransactionChain(txChainManager);
 161     }
 162
 163     @Test
 164     public void testOnTransactionChainSuccessful() throws Exception {
 165         txChainManager.onTransactionChainSuccessful(transactionChain);
 166         // NOOP
 167         Mockito.verifyZeroInteractions(transactionChain);
 168     }
 169
 170     @Test
 171     public void testAddDeleteOperationTotTxChain() throws Exception {
 172         txChainManager.addDeleteOperationToTxChain(LogicalDatastoreType.CONFIGURATION, path);
 173
 174         Mockito.verify(txChain).newReadWriteTransaction();
 175         Mockito.verify(writeTx).delete(LogicalDatastoreType.CONFIGURATION, path);
 176     }
 177
 178     @Test
 179     public void testDeactivateTransactionChainManager() throws Exception {
 180         txChainManager.deactivateTransactionManager();
 181
 182         Mockito.verify(txChain).close();
 183     }
 184
 185     @Test
 186     public void testDeactivateTransactionChainManagerFailed() throws Exception {
 187         final Node data = new NodeBuilder().setId(nodeId).build();
 188         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 189
 190         txChainManager.deactivateTransactionManager();
 191
 192         Mockito.verify(txChain).newReadWriteTransaction();
 193         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 194         Mockito.verify(writeTx, Mockito.never()).submit();
 195         Mockito.verify(writeTx).cancel();
 196         Mockito.verify(txChain).close();
 197     }
 198
 199     @Test
 200     public void testShuttingDown() throws Exception {
 201         final Node data = new NodeBuilder().setId(nodeId).build();
 202         txChainManager.initialSubmitWriteTransaction();
 203         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false);
 204         txChainManager.shuttingDown();
 205
 206         Mockito.verify(txChain).newReadWriteTransaction();
 207         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false);
 208         Mockito.verify(writeTx).submit();
 209     }
 210
 211     @Test
 212     public void testClose() {
 213         txChainManager.shuttingDown();
 214         txChainManager.close();
 215         Mockito.verify(txChain).close();
 216     }
 217 }