southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/TransactionInvokerImplTest.java

   1 /*
   2  * Copyright (c) 2015 Inocybe Technologies 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.ovsdb.southbound.transactions.md;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Matchers.any;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.verify;
  18 import static org.mockito.Mockito.when;
  19
  20 import java.util.ArrayList;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.concurrent.BlockingQueue;
  25 import java.util.concurrent.ExecutorService;
  26 import java.util.concurrent.LinkedBlockingQueue;
  27 import java.util.concurrent.atomic.AtomicBoolean;
  28
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.junit.runner.RunWith;
  32 import org.mockito.Mock;
  33 import org.mockito.Mockito;
  34 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  35 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  36 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  37 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  38 import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
  39 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  40 import org.powermock.api.mockito.PowerMockito;
  41 import org.powermock.api.support.membermodification.MemberModifier;
  42 import org.powermock.core.classloader.annotations.PrepareForTest;
  43 import org.powermock.modules.junit4.PowerMockRunner;
  44 import org.powermock.reflect.Whitebox;
  45
  46 @PrepareForTest({TransactionInvokerImpl.class})
  47 @RunWith(PowerMockRunner.class)
  48 public class TransactionInvokerImplTest {
  49     private static final int QUEUE_SIZE = 10000;
  50     @Mock private BindingTransactionChain chain;
  51     @Mock private DataBroker db;
  52     private BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<TransactionCommand>(QUEUE_SIZE);
  53     private BlockingQueue<ReadWriteTransaction> successfulTransactionQueue
  54         = new LinkedBlockingQueue<ReadWriteTransaction>(QUEUE_SIZE);
  55     private BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue
  56         = new LinkedBlockingQueue<AsyncTransaction<?, ?>>(QUEUE_SIZE);
  57     @Mock private ExecutorService executor;
  58     @Mock private AtomicBoolean runTask;
  59     private Map<ReadWriteTransaction,TransactionCommand> transactionToCommand
  60         = new HashMap<ReadWriteTransaction,TransactionCommand>();
  61     private List<ReadWriteTransaction> pendingTransactions = new ArrayList<ReadWriteTransaction>();
  62     private TransactionInvokerImpl transactionInvokerImpl;
  63
  64     @Before
  65     public void setUp() throws Exception {
  66         transactionInvokerImpl = PowerMockito.mock(TransactionInvokerImpl.class, Mockito.CALLS_REAL_METHODS);
  67         MemberModifier.field(TransactionInvokerImpl.class, "chain").set(transactionInvokerImpl, chain);
  68         MemberModifier.field(TransactionInvokerImpl.class, "db").set(transactionInvokerImpl, db);
  69     }
  70
  71     @Test
  72     public void testTransactionInvokerImpl() throws Exception {
  73         MemberModifier.field(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
  74         when(db.createTransactionChain(any(TransactionChainListener.class))).thenReturn(mock(BindingTransactionChain.class));
  75         TransactionInvokerImpl transactionInvokerImpl1 = new TransactionInvokerImpl(db);
  76         verify(db).createTransactionChain(any(TransactionChainListener.class));
  77         assertNotNull(Whitebox.getInternalState(transactionInvokerImpl1, "executor"));
  78     }
  79
  80     @Test
  81     public void testInvoke() throws Exception {
  82         MemberModifier.field(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
  83         TransactionCommand command = mock(TransactionCommand.class);
  84         transactionInvokerImpl.invoke(command);
  85         BlockingQueue<TransactionCommand> testInputQueue = Whitebox.getInternalState(transactionInvokerImpl, "inputQueue");
  86         assertTrue(testInputQueue.contains(command));
  87     }
  88
  89     @Test
  90     public void testOnTransactionChainFailed() throws Exception {
  91         MemberModifier.field(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl, failedTransactionQueue);
  92         TransactionChain<?, ?> chain = mock(TransactionChain.class);
  93         AsyncTransaction<?, ?> transaction = mock(AsyncTransaction.class);
  94         Throwable cause = mock(Throwable.class);
  95         transactionInvokerImpl.onTransactionChainFailed(chain, transaction, cause);
  96         BlockingQueue<AsyncTransaction<?, ?>> testFailedTransactionQueue = Whitebox.getInternalState(transactionInvokerImpl, "failedTransactionQueue");
  97         assertTrue(testFailedTransactionQueue.contains(transaction));
  98     }
  99
 100     @SuppressWarnings("rawtypes")
 101     @Test
 102     public void testExtractResubmitCommands() throws Exception {
 103         AsyncTransaction<?, ?> transaction = mock(ReadWriteTransaction.class);
 104         failedTransactionQueue.put(transaction);
 105         MemberModifier.field(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl, failedTransactionQueue);
 106
 107         AsyncTransaction tx1 = mock(ReadWriteTransaction.class);
 108         AsyncTransaction tx2 = mock(ReadWriteTransaction.class);
 109         pendingTransactions.add((ReadWriteTransaction) tx1);
 110         pendingTransactions.add((ReadWriteTransaction) transaction);
 111         pendingTransactions.add((ReadWriteTransaction) tx2);
 112         MemberModifier.field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
 113
 114         List<ReadWriteTransaction> transactions= new ArrayList<ReadWriteTransaction>();
 115         transactions.add((ReadWriteTransaction) tx1);
 116
 117         TransactionCommand txCommand = mock(TransactionCommand.class);
 118         transactionToCommand.put((ReadWriteTransaction) tx1, txCommand);
 119         transactionToCommand.put((ReadWriteTransaction) tx2, txCommand);
 120         transactionToCommand.put((ReadWriteTransaction) transaction, txCommand);
 121         MemberModifier.field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
 122         PowerMockito.suppress(MemberModifier.method(TransactionInvokerImpl.class, "resetTransactionQueue"));
 123
 124         List<TransactionCommand> testCommands = new ArrayList<TransactionCommand>();
 125         testCommands.add(txCommand);
 126
 127         assertEquals(testCommands, Whitebox.invokeMethod(transactionInvokerImpl, "extractResubmitCommands"));
 128     }
 129
 130     @Test
 131     public void testResetTransactionQueue() throws Exception {
 132         doNothing().when(chain).close();
 133         when(db.createTransactionChain(any(TransactionInvokerImpl.class))).thenReturn(chain);
 134
 135         failedTransactionQueue.add(mock(AsyncTransaction.class));
 136         MemberModifier.field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
 137         MemberModifier.field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
 138         MemberModifier.field(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl, failedTransactionQueue);
 139         MemberModifier.field(TransactionInvokerImpl.class, "successfulTransactionQueue").set(transactionInvokerImpl, successfulTransactionQueue);
 140
 141         Whitebox.invokeMethod(transactionInvokerImpl, "resetTransactionQueue");
 142         assertNotNull(Whitebox.getInternalState(transactionInvokerImpl, "pendingTransactions"));
 143         assertNotNull(Whitebox.getInternalState(transactionInvokerImpl, "transactionToCommand"));
 144         BlockingQueue<AsyncTransaction<?, ?>> testFailedTransactionQueue = Whitebox.getInternalState(transactionInvokerImpl, "failedTransactionQueue");
 145         assertEquals(0, testFailedTransactionQueue.size());
 146     }
 147
 148     @Test
 149     public void testRecordPendingTransaction() throws Exception {
 150         TransactionCommand command = mock(TransactionCommand.class);
 151         ReadWriteTransaction transaction= mock(ReadWriteTransaction.class);
 152         MemberModifier.field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
 153         MemberModifier.field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
 154         Whitebox.invokeMethod(transactionInvokerImpl, "recordPendingTransaction", command, transaction);
 155
 156         List<ReadWriteTransaction> testPendingTransactions = Whitebox.getInternalState(transactionInvokerImpl, "pendingTransactions");
 157         assertEquals(1, testPendingTransactions.size());
 158
 159         Map<ReadWriteTransaction, TransactionCommand> testTransactionToCommand = Whitebox.getInternalState(transactionInvokerImpl, "transactionToCommand");
 160         assertEquals(1, testTransactionToCommand.size());
 161     }
 162
 163     @Test
 164     public void testExtractCommands() throws Exception {
 165         List<TransactionCommand> commands = new ArrayList<>();
 166         PowerMockito.doReturn(commands).when(transactionInvokerImpl, "extractResubmitCommands");
 167
 168         List<TransactionCommand> resubmitCommands = new ArrayList<>();
 169         resubmitCommands.add(mock(TransactionCommand.class));
 170         PowerMockito.doReturn(resubmitCommands).when(transactionInvokerImpl, "extractCommandsFromQueue");
 171
 172         List<TransactionCommand> testCommands = new ArrayList<>();
 173         testCommands.addAll(resubmitCommands);
 174
 175         assertEquals(testCommands, Whitebox.invokeMethod(transactionInvokerImpl, "extractCommands"));
 176     }
 177
 178     @Test
 179     public void testExtractCommandsFromQueue() throws Exception {
 180         TransactionCommand command = mock(TransactionCommand.class);
 181         inputQueue.add(command);
 182         MemberModifier.field(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
 183         List<TransactionCommand> testResult = new ArrayList<TransactionCommand>();
 184         testResult.add(command);
 185         assertEquals(testResult, Whitebox.invokeMethod(transactionInvokerImpl, "extractCommandsFromQueue"));
 186     }
 187
 188     @Test
 189     public void testForgetSuccessfulTransactions() throws Exception {
 190         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 191         successfulTransactionQueue.add(transaction);
 192         pendingTransactions.add(transaction);
 193         transactionToCommand.put(transaction, mock(TransactionCommand.class));
 194         MemberModifier.field(TransactionInvokerImpl.class, "successfulTransactionQueue").set(transactionInvokerImpl, successfulTransactionQueue);
 195         MemberModifier.field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
 196         MemberModifier.field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
 197
 198         Whitebox.invokeMethod(transactionInvokerImpl, "forgetSuccessfulTransactions");
 199
 200         List<ReadWriteTransaction> testPendingTransactions = Whitebox.getInternalState(transactionInvokerImpl, "pendingTransactions");
 201         Map<ReadWriteTransaction, TransactionCommand> testTransactionToCommand = Whitebox.getInternalState(transactionInvokerImpl, "transactionToCommand");
 202         assertTrue(testPendingTransactions.isEmpty());
 203         assertTrue(testTransactionToCommand.isEmpty());
 204     }
 205
 206     @Test
 207     public void testClose() throws Exception {
 208         MemberModifier.field(TransactionInvokerImpl.class, "executor").set(transactionInvokerImpl, executor);
 209         MemberModifier.field(TransactionInvokerImpl.class, "runTask").set(transactionInvokerImpl, runTask);
 210         doNothing().when(executor).shutdown();
 211         transactionInvokerImpl.close();
 212         verify(executor).shutdown();
 213     }
 214 }