opendaylight/md-sal/sal-inmemory-datastore/src/test/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDataStoreTest.java

   1 package org.opendaylight.controller.md.sal.dom.store.impl;
   2
   3 import com.google.common.base.Optional;
   4 import com.google.common.util.concurrent.ListenableFuture;
   5 import com.google.common.util.concurrent.MoreExecutors;
   6 import org.junit.Before;
   7 import org.junit.Ignore;
   8 import org.junit.Test;
   9 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
  10 import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
  11 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
  12 import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
  13 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  14 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  15 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  16
  17 import java.util.concurrent.ExecutionException;
  18
  19 import static org.junit.Assert.assertFalse;
  20 import static org.junit.Assert.assertNotNull;
  21 import static org.junit.Assert.assertTrue;
  22
  23
  24 public class InMemoryDataStoreTest {
  25
  26   private SchemaContext schemaContext;
  27   private InMemoryDOMDataStore domStore;
  28
  29   @Before
  30   public void setupStore() {
  31     domStore = new InMemoryDOMDataStore("TEST", MoreExecutors.sameThreadExecutor());
  32     schemaContext = TestModel.createTestContext();
  33     domStore.onGlobalContextUpdated(schemaContext);
  34
  35   }
  36
  37   @Test
  38   public void testTransactionIsolation() throws InterruptedException, ExecutionException {
  39
  40     assertNotNull(domStore);
  41
  42     DOMStoreReadTransaction readTx = domStore.newReadOnlyTransaction();
  43     assertNotNull(readTx);
  44
  45     DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction();
  46     assertNotNull(writeTx);
  47     /**
  48      *
  49      * Writes /test in writeTx
  50      *
  51      */
  52     writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
  53
  54     /**
  55      *
  56      * Reads /test from writeTx Read should return container.
  57      *
  58      */
  59     ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = writeTx.read(TestModel.TEST_PATH);
  60     assertTrue(writeTxContainer.get().isPresent());
  61
  62     /**
  63      *
  64      * Reads /test from readTx Read should return Absent.
  65      *
  66      */
  67     ListenableFuture<Optional<NormalizedNode<?, ?>>> readTxContainer = readTx.read(TestModel.TEST_PATH);
  68     assertFalse(readTxContainer.get().isPresent());
  69   }
  70
  71   @Test
  72   public void testTransactionCommit() throws InterruptedException, ExecutionException {
  73
  74     DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction();
  75     assertNotNull(writeTx);
  76     /**
  77      *
  78      * Writes /test in writeTx
  79      *
  80      */
  81     writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
  82
  83     /**
  84      *
  85      * Reads /test from writeTx Read should return container.
  86      *
  87      */
  88     ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = writeTx.read(TestModel.TEST_PATH);
  89     assertTrue(writeTxContainer.get().isPresent());
  90
  91     DOMStoreThreePhaseCommitCohort cohort = writeTx.ready();
  92
  93     assertThreePhaseCommit(cohort);
  94
  95     Optional<NormalizedNode<?, ?>> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH)
  96         .get();
  97     assertTrue(afterCommitRead.isPresent());
  98   }
  99
 100   @Test
 101   public void testTransactionAbort() throws InterruptedException, ExecutionException {
 102
 103     DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction();
 104     assertNotNull(writeTx);
 105
 106     assertTestContainerWrite(writeTx);
 107
 108     DOMStoreThreePhaseCommitCohort cohort = writeTx.ready();
 109
 110     assertTrue(cohort.canCommit().get().booleanValue());
 111     cohort.preCommit().get();
 112     cohort.abort().get();
 113
 114     Optional<NormalizedNode<?, ?>> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH)
 115         .get();
 116     assertFalse(afterCommitRead.isPresent());
 117   }
 118
 119   @Test
 120   public void testTransactionChain() throws InterruptedException, ExecutionException {
 121     DOMStoreTransactionChain txChain = domStore.createTransactionChain();
 122     assertNotNull(txChain);
 123
 124     /**
 125      * We alocate new read-write transaction and write /test
 126      *
 127      *
 128      */
 129     DOMStoreReadWriteTransaction firstTx = txChain.newReadWriteTransaction();
 130     assertTestContainerWrite(firstTx);
 131
 132     /**
 133      * First transaction is marked as ready, we are able to allocate chained
 134      * transactions
 135      */
 136     DOMStoreThreePhaseCommitCohort firstWriteTxCohort = firstTx.ready();
 137
 138     /**
 139      * We alocate chained transaction - read transaction, note first one is
 140      * still not commited to datastore.
 141      */
 142     DOMStoreReadTransaction secondReadTx = txChain.newReadOnlyTransaction();
 143
 144     /**
 145      *
 146      * We test if we are able to read data from tx, read should not fail
 147      * since we are using chained transaction.
 148      *
 149      *
 150      */
 151     assertTestContainerExists(secondReadTx);
 152
 153     /**
 154      *
 155      * We alocate next transaction, which is still based on first one, but
 156      * is read-write.
 157      *
 158      */
 159     DOMStoreReadWriteTransaction thirdDeleteTx = txChain.newReadWriteTransaction();
 160
 161     /**
 162      * We test existence of /test in third transaction container should
 163      * still be visible from first one (which is still uncommmited).
 164      *
 165      *
 166      */
 167     assertTestContainerExists(thirdDeleteTx);
 168
 169     /**
 170      * We delete node in third transaction
 171      */
 172     thirdDeleteTx.delete(TestModel.TEST_PATH);
 173
 174     /**
 175      * third transaction is sealed.
 176      */
 177     DOMStoreThreePhaseCommitCohort thirdDeleteTxCohort = thirdDeleteTx.ready();
 178
 179     /**
 180      * We commit first transaction
 181      *
 182      */
 183     assertThreePhaseCommit(firstWriteTxCohort);
 184
 185     // Alocates store transacion
 186     DOMStoreReadTransaction storeReadTx = domStore.newReadOnlyTransaction();
 187     /**
 188      * We verify transaction is commited to store, container should exists
 189      * in datastore.
 190      */
 191     assertTestContainerExists(storeReadTx);
 192     /**
 193      * We commit third transaction
 194      *
 195      */
 196     assertThreePhaseCommit(thirdDeleteTxCohort);
 197   }
 198
 199   @Test
 200   @Ignore
 201   public void testTransactionConflict() throws InterruptedException, ExecutionException {
 202     DOMStoreReadWriteTransaction txOne = domStore.newReadWriteTransaction();
 203     DOMStoreReadWriteTransaction txTwo = domStore.newReadWriteTransaction();
 204     assertTestContainerWrite(txOne);
 205     assertTestContainerWrite(txTwo);
 206
 207     /**
 208      * Commits transaction
 209      */
 210     assertThreePhaseCommit(txOne.ready());
 211
 212     /**
 213      * Asserts that txTwo could not be commited
 214      */
 215     assertFalse(txTwo.ready().canCommit().get());
 216   }
 217
 218   private static void assertThreePhaseCommit(final DOMStoreThreePhaseCommitCohort cohort)
 219       throws InterruptedException, ExecutionException {
 220     assertTrue(cohort.canCommit().get().booleanValue());
 221     cohort.preCommit().get();
 222     cohort.commit().get();
 223   }
 224
 225   private static Optional<NormalizedNode<?, ?>> assertTestContainerWrite(final DOMStoreReadWriteTransaction writeTx)
 226       throws InterruptedException, ExecutionException {
 227     /**
 228      *
 229      * Writes /test in writeTx
 230      *
 231      */
 232     writeTx.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 233
 234     return assertTestContainerExists(writeTx);
 235   }
 236
 237   /**
 238    * Reads /test from readTx Read should return container.
 239    */
 240   private static Optional<NormalizedNode<?, ?>> assertTestContainerExists(DOMStoreReadTransaction readTx)
 241       throws InterruptedException, ExecutionException {
 242
 243     ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = readTx.read(TestModel.TEST_PATH);
 244     assertTrue(writeTxContainer.get().isPresent());
 245     return writeTxContainer.get();
 246   }
 247
 248 }