dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/ShardedDOMDataWriteTransactionTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.dom.broker;
   9
  10 import static org.junit.Assert.assertFalse;
  11 import static org.junit.Assert.assertNotEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.junit.Assert.fail;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.MockitoAnnotations.initMocks;
  18
  19 import com.google.common.collect.Lists;
  20 import com.google.common.util.concurrent.ListenableFuture;
  21 import java.util.ArrayDeque;
  22 import java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.Deque;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28 import javax.annotation.Nonnull;
  29 import org.junit.Test;
  30 import org.mockito.Mock;
  31 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  32 import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorAwareTransaction;
  33 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
  34 import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
  35 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
  36 import org.opendaylight.mdsal.dom.store.inmemory.DOMDataTreeShardProducer;
  37 import org.opendaylight.mdsal.dom.store.inmemory.DOMDataTreeShardWriteTransaction;
  38 import org.opendaylight.mdsal.dom.store.inmemory.WriteableDOMDataTreeShard;
  39 import org.opendaylight.yangtools.yang.common.QName;
  40 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  42 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  43
  44 public class ShardedDOMDataWriteTransactionTest {
  45     private static final Map<YangInstanceIdentifier, List<NormalizedNode<?, ?>>> TEST_MAP = new HashMap<>();
  46
  47     private static final DOMDataTreeIdentifier ROOT_ID =
  48             new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
  49
  50     @Mock
  51     private WriteableDOMDataTreeShard rootShard;
  52
  53     @Mock
  54     private DOMDataTreeShardProducer mockedProducer;
  55
  56     @Test
  57     public void basicTests() throws Exception {
  58
  59         initMocks(this);
  60
  61         doReturn(new TestDOMShardWriteTransaction()).when(mockedProducer).createTransaction();
  62         doReturn(mockedProducer).when(rootShard).createProducer(any(Collection.class));
  63
  64         final ShardedDOMDataTree shardedDOMDataTree =
  65                 new ShardedDOMDataTree();
  66         final DOMDataTreeProducer shardRegProducer = shardedDOMDataTree.createProducer(Collections.singletonList(ROOT_ID));
  67         shardedDOMDataTree.registerDataTreeShard(ROOT_ID, rootShard, shardRegProducer);
  68         shardRegProducer.close();
  69         final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(QName.create("test"));
  70
  71         final DOMDataTreeProducer producer = shardedDOMDataTree.createProducer(Collections.singletonList(ROOT_ID));
  72         final DOMDataTreeCursorAwareTransaction transaction = producer.createTransaction(false);
  73         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
  74
  75         assertNotNull(cursor);
  76         assertFalse(TEST_MAP.containsKey(yangInstanceIdentifier));
  77         cursor.write(yangInstanceIdentifier.getLastPathArgument(), TestUtils.TEST_CONTAINER);
  78         assertTrue(TEST_MAP.containsKey(yangInstanceIdentifier));
  79
  80         cursor.delete(yangInstanceIdentifier.getLastPathArgument());
  81         assertFalse(TEST_MAP.containsKey(yangInstanceIdentifier));
  82
  83         cursor.merge(yangInstanceIdentifier.getLastPathArgument(), TestUtils.TEST_CONTAINER);
  84         assertTrue(TEST_MAP.get(yangInstanceIdentifier).contains(TestUtils.TEST_CONTAINER));
  85
  86         try {
  87             producer.createTransaction(false);
  88             fail("Should have failed, there's still a tx open");
  89         } catch (final IllegalStateException e) {
  90             assertTrue(e.getMessage().contains("open"));
  91         }
  92
  93         cursor.close();
  94         try {
  95             transaction.createCursor(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY));
  96             fail("Should have failed, config ds not available to this tx");
  97         } catch (final IllegalArgumentException e) {
  98             assertTrue(e.getMessage().contains("not accessible"));
  99         }
 100
 101         assertTrue(transaction.cancel());
 102         assertFalse(transaction.cancel());
 103
 104         final DOMDataTreeCursorAwareTransaction newTx = producer.createTransaction(false);
 105         assertTrue("Transaction identifier incorrect " + transaction.getIdentifier(), ((String) transaction.getIdentifier()).contains("SHARDED-DOM-"));
 106         assertNotEquals(transaction.getIdentifier(),
 107                 newTx.getIdentifier());
 108     }
 109
 110     private final class TestDOMShardWriteTransaction implements DOMDataTreeShardWriteTransaction {
 111
 112         @Nonnull
 113         @Override
 114         public DOMDataTreeWriteCursor createCursor(@Nonnull final DOMDataTreeIdentifier prefix) {
 115             return new TestCursor();
 116         }
 117
 118         @Override
 119         public void ready() {
 120
 121         }
 122
 123         @Override
 124         public void close() {
 125
 126         }
 127
 128         @Override
 129         public ListenableFuture<Void> submit() {
 130             return null;
 131         }
 132
 133         @Override
 134         public ListenableFuture<Boolean> validate() {
 135             return null;
 136         }
 137
 138         @Override
 139         public ListenableFuture<Void> prepare() {
 140             return null;
 141         }
 142
 143         @Override
 144         public ListenableFuture<Void> commit() {
 145             return null;
 146         }
 147     }
 148
 149     private final class TestCursor implements DOMDataTreeWriteCursor {
 150
 151         private final Deque<PathArgument> stack = new ArrayDeque<>();
 152
 153         @Override
 154         public void delete(final PathArgument child) {
 155             final ArrayDeque<PathArgument> newPath = new ArrayDeque<>(stack);
 156             newPath.push(child);
 157             TEST_MAP.remove(YangInstanceIdentifier.create(newPath));
 158         }
 159
 160         @Override
 161         public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
 162             final ArrayDeque<PathArgument> newPath = new ArrayDeque<>(stack);
 163             newPath.push(child);
 164             final List<NormalizedNode<?, ?>> dataList = TEST_MAP.get(YangInstanceIdentifier.create(newPath));
 165             if (dataList != null) {
 166                 dataList.add(data);
 167             } else {
 168                 TEST_MAP.put(YangInstanceIdentifier.create(newPath), Lists.newArrayList(data));
 169             }
 170         }
 171
 172         @Override
 173         public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
 174             final ArrayDeque<PathArgument> newPath = new ArrayDeque<>(stack);
 175             newPath.push(child);
 176             TEST_MAP.put(YangInstanceIdentifier.create(newPath), Lists.newArrayList(data));
 177         }
 178
 179         @Override
 180         public void enter(@Nonnull final PathArgument child) {
 181             stack.push(child);
 182         }
 183
 184         @Override
 185         public void enter(@Nonnull final PathArgument... path) {
 186             for (final PathArgument pathArgument : path) {
 187                 stack.push(pathArgument);
 188             }
 189         }
 190
 191         @Override
 192         public void enter(@Nonnull final Iterable<PathArgument> path) {
 193             path.forEach(stack::push);
 194         }
 195
 196         @Override
 197         public void exit() {
 198             stack.pop();
 199         }
 200
 201         @Override
 202         public void exit(final int depth) {
 203             stack.pop();
 204         }
 205
 206         @Override
 207         public void close() {
 208
 209         }
 210     }
 211 }