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