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

   1 /*
   2  * Copyright (c) 2015 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.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.mockito.ArgumentMatchers.any;
  14 import static org.mockito.ArgumentMatchers.anyMap;
  15 import static org.mockito.ArgumentMatchers.eq;
  16 import static org.mockito.Mockito.doNothing;
  17 import static org.mockito.Mockito.doReturn;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21 import static org.opendaylight.mdsal.dom.broker.MockingUtilities.captorFor;
  22
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.Map;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.mockito.ArgumentCaptor;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  32 import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
  33 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
  34 import org.opendaylight.mdsal.dom.api.DOMDataTreeListener;
  35 import org.opendaylight.mdsal.dom.api.DOMDataTreeLoopException;
  36 import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
  37 import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
  38 import org.opendaylight.mdsal.dom.api.DOMDataTreeShard;
  39 import org.opendaylight.mdsal.dom.api.DOMDataTreeShardingConflictException;
  40 import org.opendaylight.mdsal.dom.broker.util.TestModel;
  41 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
  42 import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
  43 import org.opendaylight.mdsal.dom.spi.store.DOMStoreTreeChangePublisher;
  44 import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
  45 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  46 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  47 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  48 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  49 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
  50 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
  51 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  52
  53 public class ShardedDOMDataTreeListenerWithProducerTest {
  54
  55
  56     private static final DOMDataTreeIdentifier ROOT_ID = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
  57             YangInstanceIdentifier.EMPTY);
  58     private static final DOMDataTreeIdentifier TEST_ID = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
  59             TestModel.TEST_PATH);
  60
  61     private static final DOMDataTreeIdentifier TEST2_ID = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
  62             TestModel.TEST2_PATH);
  63
  64
  65     private static final Collection<DOMDataTreeIdentifier> SUBTREES_ROOT = Collections.singleton(ROOT_ID);
  66     private static final Collection<DOMDataTreeIdentifier> SUBTREES_TEST = Collections.singleton(TEST_ID);
  67     private static final Collection<DOMDataTreeIdentifier> SUBTREES_TEST2 = Collections.singleton(TEST2_ID);
  68     private static final ContainerNode TEST_CONTAINER = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
  69
  70     private interface ListenableShard extends DOMDataTreeShard, DOMStoreTreeChangePublisher, DOMStore {
  71
  72
  73     }
  74
  75     @Mock(name = "rootShard")
  76     private ListenableShard rootShard;
  77
  78     @Mock(name = "childShard")
  79     private ListenableShard childShard;
  80
  81     @Mock
  82     private ListenerRegistration<?> storeListenerReg;
  83
  84     @Mock(name = "storeWriteTx")
  85     private DOMStoreWriteTransaction writeTxMock;
  86
  87     @Mock(name = "storeTxChain")
  88     private DOMStoreTransactionChain txChainMock;
  89
  90     @Mock
  91     private ShardedDOMDataTreeProducer rootProducer;
  92
  93     private DOMDataTreeService treeService;
  94
  95     private ListenerRegistration<ListenableShard> shardReg;
  96
  97     @Before
  98     public void setUp() throws DOMDataTreeShardingConflictException {
  99         MockitoAnnotations.initMocks(this);
 100         doReturn(Collections.singleton(ROOT_ID)).when(rootProducer).getSubtrees();
 101         doNothing().when(rootProducer).subshardAdded(anyMap());
 102         final ShardedDOMDataTree impl = new ShardedDOMDataTree();
 103         treeService = impl;
 104         shardReg = impl.registerDataTreeShard(ROOT_ID, rootShard, rootProducer);
 105         doReturn("rootShard").when(rootShard).toString();
 106         doReturn("childShard").when(childShard).toString();
 107
 108         doReturn(txChainMock).when(rootShard).createTransactionChain();
 109         doReturn(writeTxMock).when(txChainMock).newWriteOnlyTransaction();
 110         doReturn(TestCommitCohort.ALLWAYS_SUCCESS).when(writeTxMock).ready();
 111
 112         doReturn(storeListenerReg).when(rootShard).registerTreeChangeListener(any(YangInstanceIdentifier.class),
 113                 any(DOMDataTreeChangeListener.class));
 114         doNothing().when(storeListenerReg).close();
 115     }
 116
 117     @Test
 118     public void registerListenerWithOneProducer() throws DOMDataTreeLoopException {
 119         final DOMDataTreeListener listener = mock(DOMDataTreeListener.class);
 120         final DOMDataTreeProducer producer = treeService.createProducer(SUBTREES_TEST2);
 121         treeService.registerListener(listener, SUBTREES_TEST, true, Collections.singleton(producer));
 122     }
 123
 124     @Test(expected = IllegalStateException.class)
 125     public void registerListenerWithAlreadyBoundProducer() throws DOMDataTreeLoopException {
 126         final DOMDataTreeListener listener1 = MockingUtilities.mock(DOMDataTreeListener.class, "listener1");
 127         final DOMDataTreeProducer producer = treeService.createProducer(SUBTREES_TEST2);
 128         treeService.registerListener(listener1, SUBTREES_TEST, true, Collections.singleton(producer));
 129
 130         final DOMDataTreeListener listener2 = MockingUtilities.mock(DOMDataTreeListener.class, "listener2");
 131         treeService.registerListener(listener2, SUBTREES_TEST, true, Collections.singleton(producer));
 132     }
 133
 134     @Test(expected = DOMDataTreeLoopException.class)
 135     public void loopSameSubtree() throws DOMDataTreeLoopException {
 136         final DOMDataTreeListener listener = mock(DOMDataTreeListener.class);
 137         final DOMDataTreeProducer producer = treeService.createProducer(SUBTREES_TEST);
 138         treeService.registerListener(listener, SUBTREES_TEST, true, Collections.singleton(producer));
 139     }
 140
 141     @Test(expected = DOMDataTreeLoopException.class)
 142     public void loopListenParentWritesChild() throws DOMDataTreeLoopException {
 143         final DOMDataTreeListener listener = mock(DOMDataTreeListener.class);
 144         final DOMDataTreeProducer producer = treeService.createProducer(SUBTREES_TEST);
 145         treeService.registerListener(listener, SUBTREES_ROOT, true, Collections.singleton(producer));
 146     }
 147
 148     @Test(expected = DOMDataTreeLoopException.class)
 149     public void loopListenChildWritesParent() throws DOMDataTreeLoopException {
 150         final DOMDataTreeListener listener = mock(DOMDataTreeListener.class);
 151         final DOMDataTreeProducer producer = treeService.createProducer(SUBTREES_ROOT);
 152         treeService.registerListener(listener, SUBTREES_ROOT, true, Collections.singleton(producer));
 153     }
 154
 155     @Test
 156     public void receiveChangeEvent() throws DOMDataTreeLoopException {
 157         final DOMDataTreeListener listener = mock(DOMDataTreeListener.class);
 158         final ArgumentCaptor<DOMDataTreeChangeListener> storeListener =
 159                 ArgumentCaptor.forClass(DOMDataTreeChangeListener.class);
 160         treeService.registerListener(listener, SUBTREES_TEST, true, Collections.<DOMDataTreeProducer>emptyList());
 161         verify(rootShard, times(1)).registerTreeChangeListener(eq(TEST_ID.getRootIdentifier()),
 162                 storeListener.capture());
 163
 164         final DataTreeCandidate sentStoreCandidate =
 165                 DataTreeCandidates.fromNormalizedNode(TEST_ID.getRootIdentifier(), TEST_CONTAINER);
 166         final Collection<DataTreeCandidate> changes = Collections.singleton(sentStoreCandidate);
 167
 168         doNothing().when(listener).onDataTreeChanged(any(), anyMap());
 169         storeListener.getValue().onDataTreeChanged(changes);
 170
 171         final ArgumentCaptor<Collection<DataTreeCandidate>> candidateCapture = captorFor(Collection.class);
 172         final ArgumentCaptor<Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>>> mapCapture = captorFor(Map.class);
 173         verify(listener, times(1)).onDataTreeChanged(candidateCapture.capture(), mapCapture.capture());
 174
 175         final Collection<DataTreeCandidate> receivedCandidate = candidateCapture.getValue();
 176         final Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> receivedMap = mapCapture.getValue();
 177
 178         assertNotNull("receivedCandidate", receivedCandidate);
 179         assertNotNull("receivedMap", receivedMap);
 180         assertFalse("candidate collection must not be empty", receivedCandidate.isEmpty());
 181         assertEquals(1, receivedCandidate.size());
 182         final DataTreeCandidate firstItem = receivedCandidate.iterator().next();
 183         assertEquals(TEST_ID.getRootIdentifier(), firstItem.getRootPath());
 184         assertEquals(TEST_CONTAINER, receivedMap.get(TEST_ID));
 185     }
 186
 187 }