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.Assert;
  17 import org.junit.Before;
  18 import org.junit.Ignore;
  19 import org.junit.Test;
  20 import org.junit.runner.RunWith;
  21 import org.mockito.Matchers;
  22 import org.mockito.Mock;
  23 import org.mockito.Mockito;
  24 import org.mockito.runners.MockitoJUnitRunner;
  25 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  26 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  27 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  28 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  31 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  32 import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
  33 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  34 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  35 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  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
  67     @Mock
  68     private KeyedInstanceIdentifier<Node, NodeKey> nodeKeyIdent;
  69
  70     private TransactionChainManager txChainManager;
  71     private InstanceIdentifier<Node> path;
  72     private NodeId nodeId;
  73
  74     @Before
  75     public void setUp() throws Exception {
  76         final ReadOnlyTransaction readOnlyTx = Mockito.mock(ReadOnlyTransaction.class);
  77         final CheckedFuture<Optional<Node>, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.<Node>absent());
  78         Mockito.when(readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture);
  79         Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTx);
  80         Mockito.when(dataBroker.createTransactionChain(Matchers.any(TransactionChainListener.class)))
  81                 .thenReturn(txChain);
  82         nodeId = new NodeId("h2g2:42");
  83         nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId);
  84         txChainManager = new TransactionChainManager(dataBroker, nodeKeyIdent, registration);
  85         Mockito.when(txChain.newWriteOnlyTransaction()).thenReturn(writeTx);
  86
  87         path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
  88         Mockito.when(writeTx.submit()).thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
  89         Assert.assertEquals(TransactionChainManager.TransactionChainManagerStatus.SLEEPING, txChainManager.getTransactionChainManagerStatus());
  90     }
  91
  92     @After
  93     public void tearDown() throws Exception {
  94         Mockito.verifyNoMoreInteractions(txChain, writeTx);
  95     }
  96
  97     @Test
  98     public void testWriteToTransaction() throws Exception {
  99         final Node data = new NodeBuilder().setId(nodeId).build();
 100         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 101
 102         Mockito.verify(txChain).newWriteOnlyTransaction();
 103         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data);
 104     }
 105
 106     /**
 107      * FIXME: Need to change the test on behalf the clustering transaction chain manager changes
 108      * @throws Exception
 109      */
 110     @Ignore
 111     @Test
 112     public void testSubmitTransaction() throws Exception {
 113         final Node data = new NodeBuilder().setId(nodeId).build();
 114         txChainManager.enableSubmit();
 115         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 116         txChainManager.activateTransactionManager(true);
 117         txChainManager.submitWriteTransaction();
 118
 119         Mockito.verify(txChain).newWriteOnlyTransaction();
 120         Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data);
 121         Mockito.verify(writeTx).submit();
 122     }
 123
 124     /**
 125      * test of {@link TransactionChainManager#enableSubmit()}: no submit - counter is not active
 126      *
 127      * @throws Exception
 128      */
 129     @Test
 130     public void testEnableCounter1() throws Exception {
 131         final Node data = new NodeBuilder().setId(nodeId).build();
 132         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 133         txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data);
 134
 135         Mockito.verify(txChain).newWriteOnlyTransaction();
 136         Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data);
 137         Mockito.verify(writeTx, Mockito.never()).submit();
 138     }
 139
 140     @Test
 141     public void testOnTransactionChainFailed() throws Exception {
 142         txChainManager.onTransactionChainFailed(transactionChain, Mockito.mock(AsyncTransaction.class), Mockito.mock(Throwable.class));
 143         Mockito.verify(dataBroker, Mockito.times(1)).createTransactionChain(txChainManager);
 144     }
 145
 146     @Test
 147     public void testOnTransactionChainSuccessful() throws Exception {
 148         txChainManager.onTransactionChainSuccessful(transactionChain);
 149         // NOOP
 150         Mockito.verifyZeroInteractions(transactionChain);
 151     }
 152
 153     @Test
 154     public void testAddDeleteOperationTotTxChain() throws Exception {
 155         txChainManager.addDeleteOperationTotTxChain(LogicalDatastoreType.CONFIGURATION, path);
 156
 157         Mockito.verify(txChain).newWriteOnlyTransaction();
 158         Mockito.verify(writeTx).delete(LogicalDatastoreType.CONFIGURATION, path);
 159     }
 160 }