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.Ignore;
  18 import org.junit.Test;
  19 import org.junit.runner.RunWith;
  20 import org.mockito.Matchers;
  21 import org.mockito.Mock;
  22 import org.mockito.Mockito;
  23 import org.mockito.runners.MockitoJUnitRunner;
  24 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  25 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  26 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  27 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  28 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  30 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  31 import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
  32 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  33 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  34 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  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.concepts.Registration;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  44
  45 /**
  46  * Created by mirehak on 4/5/15.
  47  */
  48 @RunWith(MockitoJUnitRunner.class)
  49 public class TransactionChainManagerTest {
  50
  51     @Mock
  52     private DataBroker dataBroker;
  53     @Mock
  54     private ConnectionContext connectionContext;
  55     @Mock
  56     private BindingTransactionChain txChain;
  57     @Mock
  58     private WriteTransaction writeTx;
  59     @Mock
  60     private TransactionChain<?, ?> transactionChain;
  61     @Mock
  62     HashedWheelTimer timer;
  63     @Mock
  64     Registration registration;
  65
  66     @Mock
  67     private KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent;
  68
  69     private TransactionChainManager txChainManager;
  70     private InstanceIdentifier<Node> path;
  71     private NodeId nodeId;
  72
  73     @Before
  74     public void setUp() throws Exception {
  75         final ReadOnlyTransaction readOnlyTx = Mockito.mock(ReadOnlyTransaction.class);
  76         final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.<Node>absent());
  77         Mockito.when(readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture);
  78         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTx);
  79         Mockito.when(dataBroker.createTransactionChain(Matchers.any(TransactionChainListener.class)))
  80                 .thenReturn(txChain);
  81         nodeId = new NodeId("h2g2:42");
  82         nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
  83         txChainManager = new TransactionChainManager(dataBroker, nodeKeyIdent, registration);
  84         Mockito.when(txChain.newWriteOnlyTransaction()).thenReturn(writeTx);
  85
  86         path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
  87         Mockito.when(writeTx.submit()).thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
  88     }
  89
  90     @After
  91     public void tearDown() throws Exception {
  92         Mockito.verifyNoMoreInteractions(txChain, writeTx);
  93     }
  94
  95     @Test
  96     public void testWriteToTransaction() throws Exception {
  97         final Node data = new NodeBuilder().setId(nodeId).build();
  98         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
  99
 100         Mockito.verify(txChain).newWriteOnlyTransaction();
 101         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data);
 102     }
 103
 104     @Test
 105     public void testSubmitTransaction() throws Exception {
 106         final Node data = new NodeBuilder().setId(nodeId).build();
 107         txChainManager.enableSubmit();
 108         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 109         txChainManager.submitWriteTransaction();
 110
 111         Mockito.verify(txChain).newWriteOnlyTransaction();
 112         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data);
 113         Mockito.verify(writeTx).submit();
 114     }
 115
 116     /**
 117      * test of {@link TransactionChainManager#enableSubmit()}: no submit - counter is not active
 118      *
 119      * @throws Exception
 120      */
 121     @Test
 122     public void testEnableCounter1() throws Exception {
 123         final Node data = new NodeBuilder().setId(nodeId).build();
 124         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 125         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 126
 127         Mockito.verify(txChain).newWriteOnlyTransaction();
 128         Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data);
 129     }
 130
 131     /**
 132      * test of {@link TransactionChainManager#enableSubmit()}: submit - after counter activated
 133      *
 134      * @throws Exception
 135      */
 136     @Test
 137     @Ignore  // FIXME : think about test -> we don't use submit by time and nrOfOperations
 138     public void testEnableCounter2() throws Exception {
 139         txChainManager.enableSubmit();
 140
 141         final Node data = new NodeBuilder().setId(nodeId).build();
 142         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 143         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 144
 145         Mockito.verify(txChain).newWriteOnlyTransaction();
 146         Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data);
 147         Mockito.verify(writeTx).submit();
 148
 149         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 150         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 151
 152         Mockito.verify(txChain, Mockito.times(2)).newWriteOnlyTransaction();
 153         Mockito.verify(writeTx, Mockito.times(4)).put(LogicalDatastoreType.CONFIGURATION, path, data);
 154         Mockito.verify(writeTx, Mockito.times(2)).submit();
 155         Mockito.verify(writeTx, Mockito.times(2)).getIdentifier();
 156     }
 157
 158     @Test
 159     public void testOnTransactionChainFailed() throws Exception {
 160         txChainManager.onTransactionChainFailed(transactionChain, Mockito.mock(AsyncTransaction.class), Mockito.mock(Throwable.class));
 161
 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).newWriteOnlyTransaction();
 178         Mockito.verify(writeTx).delete(LogicalDatastoreType.CONFIGURATION, path);
 179     }
 180 }