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.ArgumentMatchers.any;
  16 import static org.mockito.Mockito.doNothing;
  17 import static org.mockito.Mockito.doReturn;
  18 import static org.mockito.MockitoAnnotations.initMocks;
  19
  20 import com.google.common.collect.Lists;
  21 import com.google.common.util.concurrent.ListenableFuture;
  22 import java.util.ArrayDeque;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.Deque;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  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.spi.shard.DOMDataTreeShardProducer;
  37 import org.opendaylight.mdsal.dom.spi.shard.DOMDataTreeShardWriteTransaction;
  38 import org.opendaylight.mdsal.dom.spi.shard.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         doNothing().when(mockedProducer).close();
  64
  65         final ShardedDOMDataTree shardedDOMDataTree =
  66                 new ShardedDOMDataTree();
  67         final DOMDataTreeProducer shardRegProducer = shardedDOMDataTree.createProducer(
  68                 Collections.singletonList(ROOT_ID));
  69         shardedDOMDataTree.registerDataTreeShard(ROOT_ID, rootShard, shardRegProducer);
  70         shardRegProducer.close();
  71         final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(QName.create("", "test"));
  72
  73         final DOMDataTreeProducer producer = shardedDOMDataTree.createProducer(Collections.singletonList(ROOT_ID));
  74         final DOMDataTreeCursorAwareTransaction transaction = producer.createTransaction(false);
  75         final DOMDataTreeWriteCursor cursor = transaction.createCursor(ROOT_ID);
  76
  77         assertNotNull(cursor);
  78         assertFalse(TEST_MAP.containsKey(yangInstanceIdentifier));
  79         cursor.write(yangInstanceIdentifier.getLastPathArgument(), TestUtils.TEST_CONTAINER);
  80         assertTrue(TEST_MAP.containsKey(yangInstanceIdentifier));
  81
  82         cursor.delete(yangInstanceIdentifier.getLastPathArgument());
  83         assertFalse(TEST_MAP.containsKey(yangInstanceIdentifier));
  84
  85         cursor.merge(yangInstanceIdentifier.getLastPathArgument(), TestUtils.TEST_CONTAINER);
  86         assertTrue(TEST_MAP.get(yangInstanceIdentifier).contains(TestUtils.TEST_CONTAINER));
  87
  88         try {
  89             producer.createTransaction(false);
  90             fail("Should have failed, there's still a tx open");
  91         } catch (final IllegalStateException e) {
  92             assertTrue(e.getMessage().contains("open"));
  93         }
  94
  95         cursor.close();
  96         try {
  97             transaction.createCursor(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION,
  98                     YangInstanceIdentifier.empty()));
  99             fail("Should have failed, config ds not available to this tx");
 100         } catch (final IllegalArgumentException e) {
 101             assertTrue(e.getMessage().contains("not accessible"));
 102         }
 103
 104         assertTrue(transaction.cancel());
 105         assertFalse(transaction.cancel());
 106
 107         final DOMDataTreeCursorAwareTransaction newTx = producer.createTransaction(false);
 108         assertTrue("Transaction identifier incorrect " + transaction.getIdentifier(), (
 109                 (String) transaction.getIdentifier()).contains("SHARDED-DOM-"));
 110         assertNotEquals(transaction.getIdentifier(),
 111                 newTx.getIdentifier());
 112     }
 113
 114     private final class TestDOMShardWriteTransaction implements DOMDataTreeShardWriteTransaction {
 115         @Override
 116         public DOMDataTreeWriteCursor createCursor(final DOMDataTreeIdentifier prefix) {
 117             return new TestCursor();
 118         }
 119
 120         @Override
 121         public void ready() {
 122
 123         }
 124
 125         @Override
 126         public void close() {
 127
 128         }
 129
 130         @Override
 131         public ListenableFuture<Void> submit() {
 132             return null;
 133         }
 134
 135         @Override
 136         public ListenableFuture<Boolean> validate() {
 137             return null;
 138         }
 139
 140         @Override
 141         public ListenableFuture<Void> prepare() {
 142             return null;
 143         }
 144
 145         @Override
 146         public ListenableFuture<Void> commit() {
 147             return null;
 148         }
 149     }
 150
 151     private final class TestCursor implements DOMDataTreeWriteCursor {
 152
 153         private final Deque<PathArgument> stack = new ArrayDeque<>();
 154
 155         @Override
 156         public void delete(final PathArgument child) {
 157             final ArrayDeque<PathArgument> newPath = new ArrayDeque<>(stack);
 158             newPath.push(child);
 159             TEST_MAP.remove(YangInstanceIdentifier.create(newPath));
 160         }
 161
 162         @Override
 163         public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
 164             final ArrayDeque<PathArgument> newPath = new ArrayDeque<>(stack);
 165             newPath.push(child);
 166             final List<NormalizedNode<?, ?>> dataList = TEST_MAP.get(YangInstanceIdentifier.create(newPath));
 167             if (dataList != null) {
 168                 dataList.add(data);
 169             } else {
 170                 TEST_MAP.put(YangInstanceIdentifier.create(newPath), Lists.newArrayList(data));
 171             }
 172         }
 173
 174         @Override
 175         public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
 176             final ArrayDeque<PathArgument> newPath = new ArrayDeque<>(stack);
 177             newPath.push(child);
 178             TEST_MAP.put(YangInstanceIdentifier.create(newPath), Lists.newArrayList(data));
 179         }
 180
 181         @Override
 182         public void enter(final PathArgument child) {
 183             stack.push(child);
 184         }
 185
 186         @Override
 187         public void enter(final PathArgument... path) {
 188             for (final PathArgument pathArgument : path) {
 189                 stack.push(pathArgument);
 190             }
 191         }
 192
 193         @Override
 194         public void enter(final Iterable<PathArgument> path) {
 195             path.forEach(stack::push);
 196         }
 197
 198         @Override
 199         public void exit() {
 200             stack.pop();
 201         }
 202
 203         @Override
 204         public void exit(final int depth) {
 205             stack.pop();
 206         }
 207
 208         @Override
 209         public void close() {
 210
 211         }
 212     }
 213 }