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