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