Do not allow multi-datastore transactions

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / databroker / AbstractDOMBrokerWriteTransactionTest.java

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java
index e77f6456dedc24a4a46ffb7353b7dc6e2d358b1a..d8b1c3bf3996df5ddce35bd0e4c67f0be387492a 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/AbstractDOMBrokerWriteTransactionTest.java
@@ -6,15 +6,18 @@
  */
 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.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.FluentFuture;
-import java.util.Collection;
-import java.util.Collections;
+import java.util.Map;
 import java.util.concurrent.ExecutionException;
-import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -22,10 +25,15 @@ 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 DOMStoreTransactionFactory txFactory;
     @Mock
     private AbstractDOMTransactionFactory<?> abstractDOMTransactionFactory;
     @Mock
@@ -35,36 +43,36 @@ public class AbstractDOMBrokerWriteTransactionTest {
             extends AbstractDOMBrokerWriteTransaction<DOMStoreWriteTransaction> {
 
         AbstractDOMBrokerWriteTransactionTestImpl() {
-            super(new Object(), Collections.emptyMap(), abstractDOMTransactionFactory);
+            this(Map.of(CONFIGURATION, txFactory));
+        }
+
+        AbstractDOMBrokerWriteTransactionTestImpl(Map<LogicalDatastoreType, DOMStoreTransactionFactory> txFactoryMap) {
+            super(new Object(), txFactoryMap, abstractDOMTransactionFactory);
         }
 
         @Override
         protected DOMStoreWriteTransaction createTransaction(final LogicalDatastoreType key) {
-            return null;
+            return domStoreWriteTransaction;
         }
 
         @Override
-        protected Collection<DOMStoreWriteTransaction> getSubtransactions() {
-            return Collections.singletonList(domStoreWriteTransaction);
+        protected DOMStoreWriteTransaction getSubtransaction() {
+            return domStoreWriteTransaction;
         }
     }
 
     @Test
-    public void readyRuntimeExceptionAndCancel() throws InterruptedException {
+    public void readyRuntimeExceptionAndCancel() {
         RuntimeException thrown = new RuntimeException();
         doThrow(thrown).when(domStoreWriteTransaction).ready();
         AbstractDOMBrokerWriteTransactionTestImpl abstractDOMBrokerWriteTransactionTestImpl =
                 new AbstractDOMBrokerWriteTransactionTestImpl();
 
         FluentFuture<? extends CommitInfo> submitFuture = abstractDOMBrokerWriteTransactionTestImpl.commit();
-        try {
-            submitFuture.get();
-            Assert.fail("TransactionCommitFailedException expected");
-        } catch (ExecutionException e) {
-            assertTrue(e.getCause() instanceof TransactionCommitFailedException);
-            assertTrue(e.getCause().getCause() == thrown);
-            abstractDOMBrokerWriteTransactionTestImpl.cancel();
-        }
+        final var cause = assertThrows(ExecutionException.class, submitFuture::get).getCause();
+        assertTrue(cause instanceof TransactionCommitFailedException);
+        assertSame(thrown, cause.getCause());
+        abstractDOMBrokerWriteTransactionTestImpl.cancel();
     }
 
     @Test
@@ -75,13 +83,31 @@ public class AbstractDOMBrokerWriteTransactionTest {
                 = new AbstractDOMBrokerWriteTransactionTestImpl();
 
         FluentFuture<? extends CommitInfo> submitFuture = abstractDOMBrokerWriteTransactionTestImpl.commit();
-        try {
-            submitFuture.get();
-            Assert.fail("TransactionCommitFailedException expected");
-        } catch (ExecutionException e) {
-            assertTrue(e.getCause() instanceof TransactionCommitFailedException);
-            assertTrue(e.getCause().getCause() == thrown);
-            abstractDOMBrokerWriteTransactionTestImpl.cancel();
-        }
+        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());
     }
 }