dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/ShardedDOMDataTreeListenerTest.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.Matchers.any;
  14 import static org.mockito.Matchers.anyMap;
  15 import static org.mockito.Matchers.eq;
  16 import static org.mockito.Mockito.doNothing;
  17 import static org.mockito.Mockito.doReturn;
  18 import static org.mockito.Mockito.times;
  19 import static org.mockito.Mockito.verify;
  20 import static org.opendaylight.mdsal.dom.broker.MockingUtilities.captorFor;
  21
  22 import java.util.Collection;
  23 import java.util.Collections;
  24 import java.util.Map;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.mockito.ArgumentCaptor;
  28 import org.mockito.Mock;
  29 import org.mockito.Mockito;
  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.DOMStoreTreeChangePublisher;
  42 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  43 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  44 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  45 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  46 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
  47 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
  48 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  49
  50 public class ShardedDOMDataTreeListenerTest {
  51
  52
  53     private static final DOMDataTreeIdentifier ROOT_ID = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
  54             YangInstanceIdentifier.EMPTY);
  55     private static final DOMDataTreeIdentifier TEST_ID = new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
  56             TestModel.TEST_PATH);
  57
  58     private static final Collection<DOMDataTreeIdentifier> SUBTREES_ROOT = Collections.singleton(ROOT_ID);
  59     private static final Collection<DOMDataTreeIdentifier> SUBTREES_TEST = Collections.singleton(TEST_ID);
  60     private static final ContainerNode TEST_CONTAINER = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
  61
  62     private interface ListenableShard extends DOMDataTreeShard, DOMStoreTreeChangePublisher {
  63
  64
  65     }
  66
  67     @Mock(name = "rootShard")
  68     private ListenableShard rootShard;
  69
  70     @Mock(name = "childShard")
  71     private ListenableShard childShard;
  72
  73     @Mock(name = "listener")
  74     private DOMDataTreeListener listener;
  75
  76     @Mock
  77     private ShardedDOMDataTreeProducer producer;
  78
  79     @Mock
  80     private ListenerRegistration<?> storeListenerReg;
  81
  82     private DOMDataTreeService treeService;
  83     private ListenerRegistration<ListenableShard> shardReg;
  84
  85     @Before
  86     public void setUp() throws DOMDataTreeShardingConflictException {
  87         MockitoAnnotations.initMocks(this);
  88         final ShardedDOMDataTree impl = new ShardedDOMDataTree();
  89         doReturn(Collections.singleton(ROOT_ID)).when(producer).getSubtrees();
  90         doNothing().when(producer).subshardAdded(anyMap());
  91         treeService = impl;
  92         shardReg = impl.registerDataTreeShard(ROOT_ID, rootShard, producer);
  93         doReturn("rootShard").when(rootShard).toString();
  94         doReturn("childShard").when(childShard).toString();
  95
  96         doReturn(storeListenerReg).when(rootShard).registerTreeChangeListener(any(YangInstanceIdentifier.class),
  97                 any(DOMDataTreeChangeListener.class));
  98         doNothing().when(storeListenerReg).close();
  99     }
 100
 101     @Test(expected = IllegalArgumentException.class)
 102     public void registerListenerWithEmptySubtrees() throws DOMDataTreeLoopException {
 103         treeService.registerListener(listener, Collections.<DOMDataTreeIdentifier>emptyList(), true,
 104                 Collections.<DOMDataTreeProducer>emptyList());
 105     }
 106
 107     @Test
 108     public void registerRootListener() throws DOMDataTreeLoopException {
 109         treeService.registerListener(listener, SUBTREES_ROOT, true, Collections.<DOMDataTreeProducer>emptyList());
 110         verify(rootShard, times(1)).registerTreeChangeListener(eq(ROOT_ID.getRootIdentifier()),
 111                 any(DOMDataTreeChangeListener.class));
 112     }
 113
 114     @Test
 115     public void registerTreeListener() throws DOMDataTreeLoopException {
 116         treeService.registerListener(listener, SUBTREES_TEST, true, Collections.<DOMDataTreeProducer>emptyList());
 117         verify(rootShard, times(1)).registerTreeChangeListener(eq(TEST_ID.getRootIdentifier()),
 118                 any(DOMDataTreeChangeListener.class));
 119     }
 120
 121     @Test
 122     public void registerAndCloseListener() throws DOMDataTreeLoopException {
 123         final ListenerRegistration<DOMDataTreeListener> reg =
 124                 treeService.registerListener(listener, SUBTREES_TEST, true,
 125                         Collections.<DOMDataTreeProducer>emptyList());
 126         reg.close();
 127         verify(storeListenerReg, times(1)).close();
 128     }
 129
 130     @Test
 131     public void receiveChangeEvent() throws DOMDataTreeLoopException {
 132         final ArgumentCaptor<DOMDataTreeChangeListener> storeListener =
 133                 ArgumentCaptor.forClass(DOMDataTreeChangeListener.class);
 134         treeService.registerListener(listener, SUBTREES_TEST, true, Collections.<DOMDataTreeProducer>emptyList());
 135         verify(rootShard, times(1)).registerTreeChangeListener(eq(TEST_ID.getRootIdentifier()),
 136                 storeListener.capture());
 137
 138         final DataTreeCandidate sentStoreCandidate =
 139                 DataTreeCandidates.fromNormalizedNode(TEST_ID.getRootIdentifier(), TEST_CONTAINER);
 140         final Collection<DataTreeCandidate> changes = Collections.singleton(sentStoreCandidate);
 141
 142         doNothing().when(listener).onDataTreeChanged(Mockito.<Collection<DataTreeCandidate>>any(), Mockito.anyMap());
 143         storeListener.getValue().onDataTreeChanged(changes);
 144
 145         final ArgumentCaptor<Collection<DataTreeCandidate>> candidateCapture = captorFor(Collection.class);
 146         final ArgumentCaptor<Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>>> mapCapture = captorFor(Map.class);
 147         verify(listener, times(1)).onDataTreeChanged(candidateCapture.capture(), mapCapture.capture());
 148
 149         final Collection<DataTreeCandidate> receivedCandidate = candidateCapture.getValue();
 150         final Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> receivedMap = mapCapture.getValue();
 151
 152         assertNotNull("receivedCandidate", receivedCandidate);
 153         assertNotNull("receivedMap", receivedMap);
 154         assertFalse("candidate collection must not be empty", receivedCandidate.isEmpty());
 155         assertEquals(1, receivedCandidate.size());
 156         final DataTreeCandidate firstItem = receivedCandidate.iterator().next();
 157         assertEquals(TEST_ID.getRootIdentifier(), firstItem.getRootPath());
 158         assertEquals(TEST_CONTAINER, receivedMap.get(TEST_ID));
 159     }
 160
 161 }