X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-inmemory-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fstore%2Fimpl%2FInMemoryDataStoreTest.java;h=5734f9ac5b27c635fdf01a9fab66d084863c0ab4;hp=96369dea5fabc7d3ce25272f5e0cceaf5291a0c6;hb=7292faba613ab556babd7bbcdd78984f5668bf9b;hpb=5ce59af75c7f53e05fccb55b6cf03350ab0eebac diff --git a/opendaylight/md-sal/sal-inmemory-datastore/src/test/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDataStoreTest.java b/opendaylight/md-sal/sal-inmemory-datastore/src/test/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDataStoreTest.java index 96369dea5f..5734f9ac5b 100644 --- a/opendaylight/md-sal/sal-inmemory-datastore/src/test/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDataStoreTest.java +++ b/opendaylight/md-sal/sal-inmemory-datastore/src/test/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDataStoreTest.java @@ -7,250 +7,495 @@ */ package org.opendaylight.controller.md.sal.dom.store.impl; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; - +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.MoreExecutors; import java.util.concurrent.ExecutionException; - +import org.junit.Assert; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction; import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction; import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort; import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain; +import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction; +import org.opendaylight.controller.sal.core.spi.data.SnapshotBackedTransactions; +import org.opendaylight.controller.sal.core.spi.data.SnapshotBackedWriteTransaction.TransactionReadyPrototype; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; +import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.ListenableFuture; -import com.google.common.util.concurrent.MoreExecutors; +public class InMemoryDataStoreTest { + private SchemaContext schemaContext; + private InMemoryDOMDataStore domStore; -public class InMemoryDataStoreTest { + @Before + public void setupStore() { + domStore = new InMemoryDOMDataStore("TEST", MoreExecutors.newDirectExecutorService()); + schemaContext = TestModel.createTestContext(); + domStore.onGlobalContextUpdated(schemaContext); + } - private SchemaContext schemaContext; - private InMemoryDOMDataStore domStore; + @Test + public void testTransactionIsolation() throws InterruptedException, ExecutionException { - @Before - public void setupStore() { - domStore = new InMemoryDOMDataStore("TEST", MoreExecutors.sameThreadExecutor()); - schemaContext = TestModel.createTestContext(); - domStore.onGlobalContextUpdated(schemaContext); + assertNotNull(domStore); - } + DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction(); + assertNotNull(readTx); - @Test - public void testTransactionIsolation() throws InterruptedException, ExecutionException { + DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); + assertNotNull(writeTx); - assertNotNull(domStore); + /** + * Writes /test in writeTx + */ + NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + writeTx.write(TestModel.TEST_PATH, testNode); - DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction(); - assertNotNull(readTx); + /** + * Reads /test from writeTx Read should return container. + */ + ListenableFuture>> writeTxContainer = writeTx.read(TestModel.TEST_PATH); + assertEquals("read: isPresent", true, writeTxContainer.get().isPresent()); + assertEquals("read: data", testNode, writeTxContainer.get().get()); - DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); - assertNotNull(writeTx); - /** - * - * Writes /test in writeTx - * - */ - writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); + /** + * Reads /test from readTx Read should return Absent. + */ + ListenableFuture>> readTxContainer = readTx.read(TestModel.TEST_PATH); + assertEquals("read: isPresent", false, readTxContainer.get().isPresent()); + } - /** - * - * Reads /test from writeTx Read should return container. - * - */ - ListenableFuture>> writeTxContainer = writeTx.read(TestModel.TEST_PATH); - assertTrue(writeTxContainer.get().isPresent()); + @Test + public void testTransactionCommit() throws InterruptedException, ExecutionException { - /** - * - * Reads /test from readTx Read should return Absent. - * - */ - ListenableFuture>> readTxContainer = readTx.read(TestModel.TEST_PATH); - assertFalse(readTxContainer.get().isPresent()); - } + DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); + assertNotNull(writeTx); - @Test - public void testTransactionCommit() throws InterruptedException, ExecutionException { + /** + * Writes /test in writeTx + */ + NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + writeTx.write(TestModel.TEST_PATH, testNode); - DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); - assertNotNull(writeTx); - /** - * - * Writes /test in writeTx - * - */ - writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); + /** + * Reads /test from writeTx Read should return container. + */ + ListenableFuture>> writeTxContainer = writeTx.read(TestModel.TEST_PATH); + assertEquals("read: isPresent", true, writeTxContainer.get().isPresent()); + assertEquals("read: data", testNode, writeTxContainer.get().get()); - /** - * - * Reads /test from writeTx Read should return container. - * - */ - ListenableFuture>> writeTxContainer = writeTx.read(TestModel.TEST_PATH); - assertTrue(writeTxContainer.get().isPresent()); + DOMStoreThreePhaseCommitCohort cohort = writeTx.ready(); - DOMStoreThreePhaseCommitCohort cohort = writeTx.ready(); + assertThreePhaseCommit(cohort); - assertThreePhaseCommit(cohort); + Optional> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH) + .get(); + assertEquals("After commit read: isPresent", true, afterCommitRead.isPresent()); + assertEquals("After commit read: data", testNode, afterCommitRead.get()); + } - Optional> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH) - .get(); - assertTrue(afterCommitRead.isPresent()); - } + @Test + public void testDelete() throws Exception { - @Test - public void testTransactionAbort() throws InterruptedException, ExecutionException { + DOMStoreWriteTransaction writeTx = domStore.newWriteOnlyTransaction(); + assertNotNull( writeTx ); - DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); - assertNotNull(writeTx); + // Write /test and commit - assertTestContainerWrite(writeTx); + writeTx.write( TestModel.TEST_PATH, ImmutableNodes.containerNode( TestModel.TEST_QNAME ) ); - DOMStoreThreePhaseCommitCohort cohort = writeTx.ready(); + assertThreePhaseCommit( writeTx.ready() ); - assertTrue(cohort.canCommit().get().booleanValue()); - cohort.preCommit().get(); - cohort.abort().get(); + Optional> afterCommitRead = domStore.newReadOnlyTransaction(). + read(TestModel.TEST_PATH ).get(); + assertEquals( "After commit read: isPresent", true, afterCommitRead.isPresent() ); - Optional> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH) - .get(); - assertFalse(afterCommitRead.isPresent()); - } + // Delete /test and verify - @Test - public void testTransactionChain() throws InterruptedException, ExecutionException { - DOMStoreTransactionChain txChain = domStore.createTransactionChain(); - assertNotNull(txChain); + writeTx = domStore.newWriteOnlyTransaction(); - /** - * We alocate new read-write transaction and write /test - * - * - */ - DOMStoreReadWriteTransaction firstTx = txChain.newReadWriteTransaction(); - assertTestContainerWrite(firstTx); + writeTx.delete( TestModel.TEST_PATH ); - /** - * First transaction is marked as ready, we are able to allocate chained - * transactions - */ - DOMStoreThreePhaseCommitCohort firstWriteTxCohort = firstTx.ready(); + assertThreePhaseCommit( writeTx.ready() ); - /** - * We alocate chained transaction - read transaction, note first one is - * still not commited to datastore. - */ - DOMStoreReadTransaction secondReadTx = txChain.newReadOnlyTransaction(); + afterCommitRead = domStore.newReadOnlyTransaction(). + read(TestModel.TEST_PATH ).get(); + assertEquals( "After commit read: isPresent", false, afterCommitRead.isPresent() ); + } - /** - * - * We test if we are able to read data from tx, read should not fail - * since we are using chained transaction. - * - * - */ - assertTestContainerExists(secondReadTx); + @Test + public void testMerge() throws Exception { - /** - * - * We alocate next transaction, which is still based on first one, but - * is read-write. - * - */ - DOMStoreReadWriteTransaction thirdDeleteTx = txChain.newReadWriteTransaction(); + DOMStoreWriteTransaction writeTx = domStore.newWriteOnlyTransaction(); + assertNotNull( writeTx ); - /** - * We test existence of /test in third transaction container should - * still be visible from first one (which is still uncommmited). - * - * - */ - assertTestContainerExists(thirdDeleteTx); + ContainerNode containerNode = ImmutableContainerNodeBuilder.create() + .withNodeIdentifier( new NodeIdentifier( TestModel.TEST_QNAME ) ) + .addChild( ImmutableNodes.mapNodeBuilder( TestModel.OUTER_LIST_QNAME ) + .addChild( ImmutableNodes.mapEntry( TestModel.OUTER_LIST_QNAME, + TestModel.ID_QNAME, 1 ) ).build() ).build(); - /** - * We delete node in third transaction - */ - thirdDeleteTx.delete(TestModel.TEST_PATH); + writeTx.merge( TestModel.TEST_PATH, containerNode ); - /** - * third transaction is sealed. - */ - DOMStoreThreePhaseCommitCohort thirdDeleteTxCohort = thirdDeleteTx.ready(); + assertThreePhaseCommit( writeTx.ready() ); - /** - * We commit first transaction - * - */ - assertThreePhaseCommit(firstWriteTxCohort); + Optional> afterCommitRead = domStore.newReadOnlyTransaction(). + read(TestModel.TEST_PATH ).get(); + assertEquals( "After commit read: isPresent", true, afterCommitRead.isPresent() ); + assertEquals( "After commit read: data", containerNode, afterCommitRead.get() ); - // Alocates store transacion - DOMStoreReadTransaction storeReadTx = domStore.newReadOnlyTransaction(); - /** - * We verify transaction is commited to store, container should exists - * in datastore. - */ - assertTestContainerExists(storeReadTx); - /** - * We commit third transaction - * - */ - assertThreePhaseCommit(thirdDeleteTxCohort); - } + // Merge a new list entry node - @Test - @Ignore - public void testTransactionConflict() throws InterruptedException, ExecutionException { - DOMStoreReadWriteTransaction txOne = domStore.newReadWriteTransaction(); - DOMStoreReadWriteTransaction txTwo = domStore.newReadWriteTransaction(); - assertTestContainerWrite(txOne); - assertTestContainerWrite(txTwo); + writeTx = domStore.newWriteOnlyTransaction(); + assertNotNull( writeTx ); - /** - * Commits transaction - */ - assertThreePhaseCommit(txOne.ready()); + containerNode = ImmutableContainerNodeBuilder.create() + .withNodeIdentifier( new NodeIdentifier( TestModel.TEST_QNAME ) ) + .addChild( ImmutableNodes.mapNodeBuilder( TestModel.OUTER_LIST_QNAME ) + .addChild( ImmutableNodes.mapEntry( TestModel.OUTER_LIST_QNAME, + TestModel.ID_QNAME, 1 ) ) + .addChild( ImmutableNodes.mapEntry( TestModel.OUTER_LIST_QNAME, + TestModel.ID_QNAME, 2 ) ).build() ).build(); + + writeTx.merge( TestModel.TEST_PATH, containerNode ); + + assertThreePhaseCommit( writeTx.ready() ); + + afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH ).get(); + assertEquals( "After commit read: isPresent", true, afterCommitRead.isPresent() ); + assertEquals( "After commit read: data", containerNode, afterCommitRead.get() ); + } - /** - * Asserts that txTwo could not be commited - */ - assertFalse(txTwo.ready().canCommit().get()); - } - - private static void assertThreePhaseCommit(final DOMStoreThreePhaseCommitCohort cohort) - throws InterruptedException, ExecutionException { - assertTrue(cohort.canCommit().get().booleanValue()); - cohort.preCommit().get(); - cohort.commit().get(); - } - - private static Optional> assertTestContainerWrite(final DOMStoreReadWriteTransaction writeTx) - throws InterruptedException, ExecutionException { - /** - * - * Writes /test in writeTx - * - */ - writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); - return assertTestContainerExists(writeTx); - } + @Test + public void testExistsForExistingData() throws Exception { - /** - * Reads /test from readTx Read should return container. - */ - private static Optional> assertTestContainerExists(final DOMStoreReadTransaction readTx) - throws InterruptedException, ExecutionException { + DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); + assertNotNull( writeTx ); + + ContainerNode containerNode = ImmutableContainerNodeBuilder.create() + .withNodeIdentifier( new NodeIdentifier( TestModel.TEST_QNAME ) ) + .addChild( ImmutableNodes.mapNodeBuilder( TestModel.OUTER_LIST_QNAME ) + .addChild( ImmutableNodes.mapEntry( TestModel.OUTER_LIST_QNAME, + TestModel.ID_QNAME, 1 ) ).build() ).build(); + + writeTx.merge( TestModel.TEST_PATH, containerNode ); + + CheckedFuture exists = + writeTx.exists(TestModel.TEST_PATH); + + assertEquals(true, exists.checkedGet()); + + DOMStoreThreePhaseCommitCohort ready = writeTx.ready(); + + ready.preCommit().get(); + + ready.commit().get(); + + DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction(); + assertNotNull( readTx ); + + exists = + readTx.exists(TestModel.TEST_PATH); + + assertEquals(true, exists.checkedGet()); + } + + @Test + public void testExistsForNonExistingData() throws Exception { + + DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); + assertNotNull( writeTx ); + + CheckedFuture exists = + writeTx.exists(TestModel.TEST_PATH); + + assertEquals(false, exists.checkedGet()); + + DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction(); + assertNotNull( readTx ); + + exists = + readTx.exists(TestModel.TEST_PATH); + + assertEquals(false, exists.checkedGet()); + } + + @Test(expected=ReadFailedException.class) + public void testExistsThrowsReadFailedException() throws Exception { + + DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction(); + assertNotNull( readTx ); + + readTx.close(); + + readTx.exists(TestModel.TEST_PATH).checkedGet(); + } + + + + @Test(expected=ReadFailedException.class) + public void testReadWithReadOnlyTransactionClosed() throws Throwable { + + DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction(); + assertNotNull( readTx ); + + readTx.close(); + + doReadAndThrowEx( readTx ); + } + + @Test(expected=ReadFailedException.class) + public void testReadWithReadOnlyTransactionFailure() throws Throwable { + + DataTreeSnapshot mockSnapshot = Mockito.mock( DataTreeSnapshot.class ); + Mockito.doThrow( new RuntimeException( "mock ex" ) ).when( mockSnapshot ) + .readNode( Mockito.any( YangInstanceIdentifier.class ) ); + + DOMStoreReadTransaction readTx = SnapshotBackedTransactions.newReadTransaction("1", true, mockSnapshot); + + doReadAndThrowEx( readTx ); + } + + @Test(expected=ReadFailedException.class) + public void testReadWithReadWriteTransactionClosed() throws Throwable { + + DOMStoreReadTransaction readTx = domStore.newReadWriteTransaction(); + assertNotNull( readTx ); + + readTx.close(); + + doReadAndThrowEx( readTx ); + } + + @Test(expected=ReadFailedException.class) + public void testReadWithReadWriteTransactionFailure() throws Throwable { + + DataTreeSnapshot mockSnapshot = Mockito.mock( DataTreeSnapshot.class ); + DataTreeModification mockModification = Mockito.mock( DataTreeModification.class ); + Mockito.doThrow( new RuntimeException( "mock ex" ) ).when( mockModification ) + .readNode( Mockito.any( YangInstanceIdentifier.class ) ); + Mockito.doReturn( mockModification ).when( mockSnapshot ).newModification(); + @SuppressWarnings("unchecked") + TransactionReadyPrototype mockReady = Mockito.mock( TransactionReadyPrototype.class ); + DOMStoreReadTransaction readTx = SnapshotBackedTransactions.newReadWriteTransaction("1", false, mockSnapshot, mockReady); + + doReadAndThrowEx( readTx ); + } + + private static void doReadAndThrowEx( final DOMStoreReadTransaction readTx ) throws Throwable { + try { + readTx.read(TestModel.TEST_PATH).get(); + } catch( ExecutionException e ) { + throw e.getCause(); + } + } + + @Test(expected=IllegalStateException.class) + public void testWriteWithTransactionReady() throws Exception { + + DOMStoreWriteTransaction writeTx = domStore.newWriteOnlyTransaction(); + + writeTx.ready(); + + // Should throw ex + writeTx.write( TestModel.TEST_PATH, ImmutableNodes.containerNode( TestModel.TEST_QNAME ) ); + } + + @Test(expected=IllegalStateException.class) + public void testReadyWithTransactionAlreadyReady() throws Exception { + + DOMStoreWriteTransaction writeTx = domStore.newWriteOnlyTransaction(); + + writeTx.ready(); + + // Should throw ex + writeTx.ready(); + } + + @Test + public void testReadyWithMissingMandatoryData() throws InterruptedException { + DOMStoreWriteTransaction writeTx = domStore.newWriteOnlyTransaction(); + NormalizedNode testNode = ImmutableContainerNodeBuilder.create() + .withNodeIdentifier(new NodeIdentifier(TestModel.MANDATORY_DATA_TEST_QNAME)) + .addChild(ImmutableNodes.leafNode(TestModel.OPTIONAL_QNAME, "data")) + .build(); + writeTx.write(TestModel.MANDATORY_DATA_TEST_PATH, testNode); + DOMStoreThreePhaseCommitCohort ready = writeTx.ready(); + try { + ready.canCommit().get(); + Assert.fail("Expected exception on canCommit"); + } catch (ExecutionException e) { + // nop + } + } + + @Test + public void testTransactionAbort() throws InterruptedException, ExecutionException { + + DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction(); + assertNotNull(writeTx); + + assertTestContainerWrite(writeTx); + + DOMStoreThreePhaseCommitCohort cohort = writeTx.ready(); + + assertTrue(cohort.canCommit().get().booleanValue()); + cohort.preCommit().get(); + cohort.abort().get(); + + Optional> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH) + .get(); + assertFalse(afterCommitRead.isPresent()); + } + + @Test + public void testTransactionChain() throws InterruptedException, ExecutionException { + DOMStoreTransactionChain txChain = domStore.createTransactionChain(); + assertNotNull(txChain); + + /** + * We alocate new read-write transaction and write /test + * + * + */ + DOMStoreReadWriteTransaction firstTx = txChain.newReadWriteTransaction(); + assertTestContainerWrite(firstTx); + + /** + * First transaction is marked as ready, we are able to allocate chained + * transactions + */ + DOMStoreThreePhaseCommitCohort firstWriteTxCohort = firstTx.ready(); + + /** + * We alocate chained transaction - read transaction, note first one is + * still not commited to datastore. + */ + DOMStoreReadTransaction 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. + * + */ + DOMStoreReadWriteTransaction thirdDeleteTx = txChain.newReadWriteTransaction(); + + /** + * We test existence of /test in third transaction container should + * still be visible from first one (which is still uncommmited). + * + * + */ + assertTestContainerExists(thirdDeleteTx); + + /** + * We delete node in third transaction + */ + thirdDeleteTx.delete(TestModel.TEST_PATH); + + /** + * third transaction is sealed. + */ + DOMStoreThreePhaseCommitCohort thirdDeleteTxCohort = thirdDeleteTx.ready(); + + /** + * We commit first transaction + * + */ + assertThreePhaseCommit(firstWriteTxCohort); + + // Alocates store transacion + DOMStoreReadTransaction storeReadTx = domStore.newReadOnlyTransaction(); + /** + * We verify transaction is commited to store, container should exists + * in datastore. + */ + assertTestContainerExists(storeReadTx); + /** + * We commit third transaction + * + */ + assertThreePhaseCommit(thirdDeleteTxCohort); + } + + @Test + @Ignore + public void testTransactionConflict() throws InterruptedException, ExecutionException { + DOMStoreReadWriteTransaction txOne = domStore.newReadWriteTransaction(); + DOMStoreReadWriteTransaction txTwo = domStore.newReadWriteTransaction(); + assertTestContainerWrite(txOne); + assertTestContainerWrite(txTwo); + + /** + * Commits transaction + */ + assertThreePhaseCommit(txOne.ready()); + + /** + * Asserts that txTwo could not be commited + */ + assertFalse(txTwo.ready().canCommit().get()); + } + + private static void assertThreePhaseCommit(final DOMStoreThreePhaseCommitCohort cohort) + throws InterruptedException, ExecutionException { + assertTrue(cohort.canCommit().get().booleanValue()); + cohort.preCommit().get(); + cohort.commit().get(); + } + + private static Optional> assertTestContainerWrite(final DOMStoreReadWriteTransaction writeTx) + throws InterruptedException, ExecutionException { + /** + * + * Writes /test in writeTx + * + */ + writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); + + return assertTestContainerExists(writeTx); + } + + /** + * Reads /test from readTx Read should return container. + */ + private static Optional> assertTestContainerExists(final DOMStoreReadTransaction readTx) + throws InterruptedException, ExecutionException { - ListenableFuture>> writeTxContainer = readTx.read(TestModel.TEST_PATH); - assertTrue(writeTxContainer.get().isPresent()); - return writeTxContainer.get(); - } + ListenableFuture>> writeTxContainer = readTx.read(TestModel.TEST_PATH); + assertTrue(writeTxContainer.get().isPresent()); + return writeTxContainer.get(); + } }