X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fbroker%2Fimpl%2FDOMTransactionChainTest.java;h=f0be8bb8005e2fbfb875f75770868e0e9dfaaf8d;hp=b360cb1694eab7224980ed6ed078f39a51942e1e;hb=4ef15f7a7e3fb5bcaa6a3202d268a5c945e0aa71;hpb=430114ac078864cd36fbe7d543440dde029a1dc7 diff --git a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMTransactionChainTest.java b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMTransactionChainTest.java index b360cb1694..f0be8bb800 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMTransactionChainTest.java +++ b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/md/sal/dom/broker/impl/DOMTransactionChainTest.java @@ -7,21 +7,23 @@ */ package org.opendaylight.controller.md.sal.dom.broker.impl; -import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableMap; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; - import org.junit.Before; import org.junit.Test; -import org.opendaylight.controller.md.sal.common.api.TransactionStatus; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction; import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; @@ -29,38 +31,31 @@ import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore; import org.opendaylight.controller.md.sal.dom.store.impl.TestModel; import org.opendaylight.controller.sal.core.spi.data.DOMStore; -import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -import com.google.common.base.Optional; -import com.google.common.collect.ImmutableMap; -import com.google.common.util.concurrent.ListenableFuture; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; - public class DOMTransactionChainTest { private SchemaContext schemaContext; - private DOMDataBrokerImpl domBroker; + private AbstractDOMDataBroker domBroker; @Before public void setupStore() { - InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", MoreExecutors.sameThreadExecutor()); - InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG", MoreExecutors.sameThreadExecutor()); + InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", MoreExecutors.newDirectExecutorService()); + InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG", MoreExecutors.newDirectExecutorService()); schemaContext = TestModel.createTestContext(); operStore.onGlobalContextUpdated(schemaContext); configStore.onGlobalContextUpdated(schemaContext); - ImmutableMap stores = ImmutableMap. builder() // + ImmutableMap stores = ImmutableMap.builder() // .put(CONFIGURATION, configStore) // .put(OPERATIONAL, operStore) // .build(); ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()); - domBroker = new DOMDataBrokerImpl(stores, executor); + domBroker = new SerializedDOMDataBroker(stores, executor); } @Test @@ -70,17 +65,15 @@ public class DOMTransactionChainTest { assertNotNull(txChain); /** - * We alocate new read-write transaction and write /test - * - * + * We alocate new read-write transaction and write /test. */ DOMDataReadWriteTransaction firstTx = allocateAndWrite(txChain); /** * First transaction is marked as ready, we are able to allocate chained - * transactions + * transactions. */ - ListenableFuture> firstWriteTxFuture = firstTx.commit(); + ListenableFuture firstWriteTxFuture = firstTx.submit(); /** * We alocate chained transaction - read transaction. @@ -88,44 +81,40 @@ public class DOMTransactionChainTest { DOMDataReadTransaction secondReadTx = txChain.newReadOnlyTransaction(); /** - * + * * We test if we are able to read data from tx, read should not fail * since we are using chained transaction. - * - * */ assertTestContainerExists(secondReadTx); /** - * * We alocate next transaction, which is still based on first one, but * is read-write. - * + * */ DOMDataReadWriteTransaction thirdDeleteTx = allocateAndDelete(txChain); /** - * third transaction is sealed. + * We commit first transaction. + * */ - ListenableFuture> thirdDeleteTxFuture = thirdDeleteTx.commit(); + assertCommitSuccessful(firstWriteTxFuture); /** - * We commit first transaction - * + * Allocates transaction from data store. */ - assertCommitSuccessful(firstWriteTxFuture); - - // Alocates store transaction DOMDataReadTransaction storeReadTx = domBroker.newReadOnlyTransaction(); + /** * We verify transaction is commited to store, container should exists * in datastore. */ assertTestContainerExists(storeReadTx); + /** - * We commit third transaction - * + * third transaction is sealed and commited. */ + ListenableFuture thirdDeleteTxFuture = thirdDeleteTx.submit(); assertCommitSuccessful(thirdDeleteTxFuture); /** @@ -137,6 +126,7 @@ public class DOMTransactionChainTest { } @Test + @SuppressWarnings("checkstyle:IllegalCatch") public void testTransactionChainNotSealed() throws InterruptedException, ExecutionException, TimeoutException { BlockingTransactionChainListener listener = new BlockingTransactionChainListener(); DOMTransactionChain txChain = domBroker.createTransactionChain(listener); @@ -144,8 +134,6 @@ public class DOMTransactionChainTest { /** * We alocate new read-write transaction and write /test - * - * */ allocateAndWrite(txChain); @@ -155,21 +143,21 @@ public class DOMTransactionChainTest { * IllegalStateException. */ try { - DOMDataReadTransaction secondReadTx = txChain.newReadOnlyTransaction(); + txChain.newReadOnlyTransaction(); fail("Allocation of secondReadTx should fail with IllegalStateException"); } catch (Exception e) { assertTrue(e instanceof IllegalStateException); } } - private static DOMDataReadWriteTransaction allocateAndDelete(DOMTransactionChain txChain) - throws InterruptedException, ExecutionException { + private static DOMDataReadWriteTransaction allocateAndDelete( + final DOMTransactionChain txChain) throws InterruptedException, ExecutionException { DOMDataReadWriteTransaction tx = txChain.newReadWriteTransaction(); /** * We test existence of /test in third transaction container should * still be visible from first one (which is still uncommmited). - * + * */ assertTestContainerExists(tx); @@ -180,29 +168,27 @@ public class DOMTransactionChainTest { return tx; } - private static DOMDataReadWriteTransaction allocateAndWrite(DOMTransactionChain txChain) - throws InterruptedException, ExecutionException { + private static DOMDataReadWriteTransaction allocateAndWrite( + final DOMTransactionChain txChain) throws InterruptedException, ExecutionException { DOMDataReadWriteTransaction tx = txChain.newReadWriteTransaction(); assertTestContainerWrite(tx); return tx; } - private static void assertCommitSuccessful(ListenableFuture> future) - throws InterruptedException, ExecutionException { - RpcResult rpcResult = future.get(); - assertTrue(rpcResult.isSuccessful()); - assertEquals(TransactionStatus.COMMITED, rpcResult.getResult()); + private static void assertCommitSuccessful( + final ListenableFuture future) throws InterruptedException, ExecutionException { + future.get(); } - private static void assertTestContainerExists(DOMDataReadTransaction readTx) throws InterruptedException, - ExecutionException { + private static void assertTestContainerExists( + final DOMDataReadTransaction readTx) throws InterruptedException, ExecutionException { ListenableFuture>> readFuture = readTx.read(OPERATIONAL, TestModel.TEST_PATH); Optional> readedData = readFuture.get(); assertTrue(readedData.isPresent()); } - private static void assertTestContainerWrite(DOMDataReadWriteTransaction tx) throws InterruptedException, - ExecutionException { + private static void assertTestContainerWrite( + final DOMDataReadWriteTransaction tx) throws InterruptedException, ExecutionException { tx.put(OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); assertTestContainerExists(tx); }