git.opendaylight Code Review - controller.git/blob

   1 /*
   2  * Copyright (c) 2016 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.controller.md.sal.dom.broker.impl.legacy.sharded.adapter;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.ArgumentMatchers.eq;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.doReturn;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.times;
  18 import static org.mockito.Mockito.verify;
  19
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.mockito.ArgumentCaptor;
  23 import org.mockito.Mock;
  24 import org.mockito.MockitoAnnotations;
  25 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  26 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  27 import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
  28 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  29 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  30 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  31 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
  32
  33 @Deprecated
  34 public class ShardedDOMDataBrokerDelegatingTransactionChainTest {
  35
  36     @Mock
  37     private DOMDataBroker dataBroker;
  38
  39     @Mock
  40     private DOMTransactionChain delegateTxChain;
  41
  42     @Mock
  43     private TransactionChainListener txChainlistener;
  44
  45     private ShardedDOMDataBrokerDelegatingTransactionChain txChain;
  46
  47     @Before
  48     public void setUp() {
  49         MockitoAnnotations.initMocks(this);
  50
  51         doReturn(delegateTxChain).when(dataBroker).createTransactionChain(any());
  52         txChain = new ShardedDOMDataBrokerDelegatingTransactionChain("1", TestModel.createTestContext(), dataBroker,
  53                                                                      txChainlistener);
  54     }
  55
  56     @Test
  57     public void testClose() {
  58         doNothing().when(delegateTxChain).close();
  59         txChain.close();
  60         verify(delegateTxChain).close();
  61     }
  62
  63     @Test
  64     public void testNewWriteTransaction() {
  65         DOMDataTreeWriteTransaction delegateWriteTx = mock(DOMDataTreeWriteTransaction.class);
  66         doReturn(delegateWriteTx).when(delegateTxChain).newWriteOnlyTransaction();
  67         doReturn("TEST-WRITE-TX-DELEGATE").when(delegateWriteTx).getIdentifier();
  68         txChain.newWriteOnlyTransaction();
  69         verify(delegateTxChain).newWriteOnlyTransaction();
  70     }
  71
  72     @Test
  73     public void testNewReadOnlyTransaction() {
  74         DOMDataTreeReadTransaction delegateReadTx = mock(DOMDataTreeReadTransaction.class);
  75         doReturn("TEST-READ-TX-DELEGATE").when(delegateReadTx).getIdentifier();
  76         doReturn(delegateReadTx).when(delegateTxChain).newReadOnlyTransaction();
  77         txChain.newReadOnlyTransaction();
  78         verify(delegateTxChain).newReadOnlyTransaction();
  79     }
  80
  81
  82     @Test
  83     public void testNewReadWriteTransaction() {
  84         DOMDataTreeReadTransaction delegateReadTx = mock(DOMDataTreeReadTransaction.class);
  85         doReturn("TEST-READ-TX-DELEGATE").when(delegateReadTx).getIdentifier();
  86         doReturn(delegateReadTx).when(delegateTxChain).newReadOnlyTransaction();
  87
  88         DOMDataTreeWriteTransaction delegateWriteTx = mock(DOMDataTreeWriteTransaction.class);
  89         doReturn(delegateWriteTx).when(delegateTxChain).newWriteOnlyTransaction();
  90         doReturn("TEST-WRITE-TX-DELEGATE").when(delegateWriteTx).getIdentifier();
  91
  92         txChain.newReadWriteTransaction();
  93         verify(delegateTxChain).newReadOnlyTransaction();
  94         verify(delegateTxChain).newWriteOnlyTransaction();
  95     }
  96
  97     @Test
  98     public void testTransactionChainFailed() {
  99         final DOMDataTreeWriteTransaction writeTxDelegate = mock(DOMDataTreeWriteTransaction.class);
 100         doReturn("DELEGATE-WRITE-TX-1").when(writeTxDelegate).getIdentifier();
 101         doReturn(writeTxDelegate).when(delegateTxChain).newWriteOnlyTransaction();
 102         doNothing().when(txChainlistener).onTransactionChainFailed(any(), any(), any());
 103
 104         // verify writetx fail
 105         txChain.newWriteOnlyTransaction();
 106         txChain.onTransactionChainFailed(delegateTxChain, writeTxDelegate, new Throwable("Fail"));
 107
 108         final ArgumentCaptor<AsyncTransaction> txCaptor = ArgumentCaptor.forClass(AsyncTransaction.class);
 109         final ArgumentCaptor<Throwable> throwableCaptor = ArgumentCaptor.forClass(Throwable.class);
 110         verify(txChainlistener).onTransactionChainFailed(eq(txChain), txCaptor.capture(), throwableCaptor.capture());
 111         assertEquals("DOM-CHAIN-1-0", txCaptor.getValue().getIdentifier());
 112         assertEquals("Fail", throwableCaptor.getValue().getMessage());
 113
 114         // verify readtx fail
 115         final DOMDataTreeReadTransaction readTxDelegate = mock(DOMDataTreeReadTransaction.class);
 116         doReturn("DELEGATE-READ-TX-1").when(readTxDelegate).getIdentifier();
 117         doReturn(readTxDelegate).when(delegateTxChain).newReadOnlyTransaction();
 118         doNothing().when(txChainlistener).onTransactionChainFailed(any(), any(), any());
 119         txChain.newReadOnlyTransaction();
 120         txChain.onTransactionChainFailed(delegateTxChain, readTxDelegate, new Throwable("Fail"));
 121         verify(txChainlistener, times(2))
 122                 .onTransactionChainFailed(eq(txChain), txCaptor.capture(), throwableCaptor.capture());
 123         assertEquals("DOM-CHAIN-1-1", txCaptor.getValue().getIdentifier());
 124         assertEquals("Fail", throwableCaptor.getValue().getMessage());
 125
 126
 127         // verify readwritetx fail, we must check both read and write failure
 128         // translates to returned readwritetx
 129
 130         // we can reuse write and read tx delegates, just return different
 131         // identifiers to avoid conflicts in keys in tx dictionary
 132         doReturn("DELEGATE-WRITE-RWTX-1").when(writeTxDelegate).getIdentifier();
 133         doReturn("DELEGATE-READ-RWTX-1").when(readTxDelegate).getIdentifier();
 134         txChain.newReadWriteTransaction();
 135         txChain.onTransactionChainFailed(delegateTxChain, writeTxDelegate, new Throwable("Fail"));
 136         verify(txChainlistener, times(3))
 137                 .onTransactionChainFailed(eq(txChain), txCaptor.capture(), throwableCaptor.capture());
 138         assertEquals("DOM-CHAIN-1-2", txCaptor.getValue().getIdentifier());
 139         assertEquals("Fail", throwableCaptor.getValue().getMessage());
 140
 141         txChain.onTransactionChainFailed(delegateTxChain, readTxDelegate, new Throwable("Fail"));
 142         verify(txChainlistener, times(4))
 143                 .onTransactionChainFailed(eq(txChain), txCaptor.capture(), throwableCaptor.capture());
 144         assertEquals("DOM-CHAIN-1-2", txCaptor.getValue().getIdentifier());
 145         assertEquals("Fail", throwableCaptor.getValue().getMessage());
 146     }
 147
 148     @Test
 149     public void testTransactionChainSuccessful() {
 150         doNothing().when(txChainlistener).onTransactionChainSuccessful(any());
 151         txChain.onTransactionChainSuccessful(delegateTxChain);
 152         verify(txChainlistener).onTransactionChainSuccessful(eq(txChain));
 153     }
 154 }