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