*/
package org.opendaylight.controller.cluster.databroker;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doThrow;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
-import com.google.common.util.concurrent.CheckedFuture;
-import java.util.Collection;
-import java.util.Collections;
-import org.junit.Assert;
-import org.junit.Before;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.mdsal.common.api.TransactionDatastoreMismatchException;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class AbstractDOMBrokerWriteTransactionTest {
@Mock
- private AbstractDOMTransactionFactory abstractDOMTransactionFactory;
-
+ private DOMStoreTransactionFactory txFactory;
+ @Mock
+ private AbstractDOMTransactionFactory<?> abstractDOMTransactionFactory;
@Mock
private DOMStoreWriteTransaction domStoreWriteTransaction;
extends AbstractDOMBrokerWriteTransaction<DOMStoreWriteTransaction> {
AbstractDOMBrokerWriteTransactionTestImpl() {
- super(new Object(), Collections.emptyMap(), abstractDOMTransactionFactory);
+ this(Map.of(CONFIGURATION, txFactory));
}
- @Override
- protected DOMStoreWriteTransaction createTransaction(LogicalDatastoreType key) {
- return null;
+ AbstractDOMBrokerWriteTransactionTestImpl(Map<LogicalDatastoreType, DOMStoreTransactionFactory> txFactoryMap) {
+ super(new Object(), txFactoryMap, abstractDOMTransactionFactory);
}
@Override
- protected Collection<DOMStoreWriteTransaction> getSubtransactions() {
- return Collections.singletonList(domStoreWriteTransaction);
+ protected DOMStoreWriteTransaction createTransaction(final LogicalDatastoreType key) {
+ return domStoreWriteTransaction;
}
- }
- @Before
- public void setup() {
- MockitoAnnotations.initMocks(this);
+ @Override
+ protected DOMStoreWriteTransaction getSubtransaction() {
+ return domStoreWriteTransaction;
+ }
}
@Test
AbstractDOMBrokerWriteTransactionTestImpl abstractDOMBrokerWriteTransactionTestImpl =
new AbstractDOMBrokerWriteTransactionTestImpl();
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture =
- abstractDOMBrokerWriteTransactionTestImpl.submit();
- try {
- submitFuture.checkedGet();
- Assert.fail("TransactionCommitFailedException expected");
- } catch (TransactionCommitFailedException e) {
- assertTrue(e.getCause() == thrown);
- abstractDOMBrokerWriteTransactionTestImpl.cancel();
- }
+ FluentFuture<? extends CommitInfo> submitFuture = abstractDOMBrokerWriteTransactionTestImpl.commit();
+ final var cause = assertThrows(ExecutionException.class, submitFuture::get).getCause();
+ assertTrue(cause instanceof TransactionCommitFailedException);
+ assertSame(thrown, cause.getCause());
+ abstractDOMBrokerWriteTransactionTestImpl.cancel();
}
@Test
- public void submitRuntimeExceptionAndCancel() {
+ public void submitRuntimeExceptionAndCancel() throws InterruptedException {
RuntimeException thrown = new RuntimeException();
- doThrow(thrown).when(abstractDOMTransactionFactory).submit(any(), any());
+ doThrow(thrown).when(abstractDOMTransactionFactory).commit(any(), any());
AbstractDOMBrokerWriteTransactionTestImpl abstractDOMBrokerWriteTransactionTestImpl
= new AbstractDOMBrokerWriteTransactionTestImpl();
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture =
- abstractDOMBrokerWriteTransactionTestImpl.submit();
- try {
- submitFuture.checkedGet();
- Assert.fail("TransactionCommitFailedException expected");
- } catch (TransactionCommitFailedException e) {
- assertTrue(e.getCause() == thrown);
- abstractDOMBrokerWriteTransactionTestImpl.cancel();
- }
+ FluentFuture<? extends CommitInfo> submitFuture = abstractDOMBrokerWriteTransactionTestImpl.commit();
+ final var cause = assertThrows(ExecutionException.class, submitFuture::get).getCause();
+ assertTrue(cause instanceof TransactionCommitFailedException);
+ assertSame(thrown, cause.getCause());
+ abstractDOMBrokerWriteTransactionTestImpl.cancel();
+ }
+
+ @Test
+ public void getSubtransactionStoreMismatch() {
+ final var testTx = new AbstractDOMBrokerWriteTransactionTestImpl(
+ Map.of(CONFIGURATION, txFactory, OPERATIONAL, txFactory));
+
+ assertEquals(domStoreWriteTransaction, testTx.getSubtransaction(CONFIGURATION));
+
+ final var exception = assertThrows(TransactionDatastoreMismatchException.class,
+ () -> testTx.getSubtransaction(OPERATIONAL));
+ assertEquals(CONFIGURATION, exception.expected());
+ assertEquals(OPERATIONAL, exception.encountered());
+ }
+
+ @Test
+ public void getSubtransactionStoreUndefined() {
+ final var testTx = new AbstractDOMBrokerWriteTransactionTestImpl(Map.of(OPERATIONAL, txFactory));
+
+ final var exception = assertThrows(IllegalArgumentException.class,
+ () -> testTx.getSubtransaction(CONFIGURATION));
+ assertEquals("CONFIGURATION is not supported", exception.getMessage());
}
}