Reduce use of deprecated methods
[controller.git] / opendaylight / md-sal / sal-dom-broker / src / test / java / org / opendaylight / controller / md / sal / dom / broker / impl / DOMDataTreeListenerTest.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.controller.md.sal.dom.broker.impl;
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.junit.Assert.assertTrue;
14 import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
15 import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
16
17 import com.google.common.collect.ImmutableMap;
18 import com.google.common.util.concurrent.ForwardingExecutorService;
19 import com.google.common.util.concurrent.ListeningExecutorService;
20 import com.google.common.util.concurrent.MoreExecutors;
21 import java.util.ArrayList;
22 import java.util.Collection;
23 import java.util.List;
24 import java.util.concurrent.CountDownLatch;
25 import java.util.concurrent.ExecutionException;
26 import java.util.concurrent.ExecutorService;
27 import java.util.concurrent.Executors;
28 import java.util.concurrent.TimeUnit;
29 import javax.annotation.Nonnull;
30 import org.junit.After;
31 import org.junit.Before;
32 import org.junit.Test;
33 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
34 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
35 import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
36 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
37 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
38 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
39 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
40 import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
41 import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
42 import org.opendaylight.controller.sal.core.spi.data.DOMStore;
43 import org.opendaylight.yangtools.concepts.ListenerRegistration;
44 import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
45 import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
46 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
47 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
48 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
49 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
50 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
51 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
52 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
54 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
55 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
56 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
57
58 public class DOMDataTreeListenerTest {
59
60     private SchemaContext schemaContext;
61     private AbstractDOMDataBroker domBroker;
62     private ListeningExecutorService executor;
63     private ExecutorService futureExecutor;
64     private CommitExecutorService commitExecutor;
65
66     private static final DataContainerChild<?, ?> OUTER_LIST = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
67             .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)).build();
68
69     private static final DataContainerChild<?, ?> OUTER_LIST_2 = ImmutableNodes
70             .mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
71             .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 2)).build();
72
73     private static final NormalizedNode<?, ?> TEST_CONTAINER = Builders.containerBuilder()
74             .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)).withChild(OUTER_LIST)
75             .build();
76
77     private static final NormalizedNode<?, ?> TEST_CONTAINER_2 = Builders.containerBuilder()
78             .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)).withChild(OUTER_LIST_2)
79             .build();
80
81     private static DOMDataTreeIdentifier ROOT_DATA_TREE_ID = new DOMDataTreeIdentifier(
82             LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
83
84     private static DOMDataTreeIdentifier OUTER_LIST_DATA_TREE_ID = new DOMDataTreeIdentifier(
85             LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH);
86
87     @Before
88     public void setupStore() {
89         InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", MoreExecutors.newDirectExecutorService());
90         InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG", MoreExecutors.newDirectExecutorService());
91         schemaContext = TestModel.createTestContext();
92
93         operStore.onGlobalContextUpdated(schemaContext);
94         configStore.onGlobalContextUpdated(schemaContext);
95
96         final ImmutableMap<LogicalDatastoreType, DOMStore> stores = ImmutableMap.<LogicalDatastoreType,
97                 DOMStore>builder() //
98                 .put(CONFIGURATION, configStore) //
99                 .put(OPERATIONAL, operStore) //
100                 .build();
101
102         commitExecutor = new CommitExecutorService(Executors.newSingleThreadExecutor());
103         futureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 5, "FCB",
104                 DOMDataTreeListenerTest.class);
105         executor = new DeadlockDetectingListeningExecutorService(commitExecutor,
106                                                                  TransactionCommitDeadlockException
107                                                                          .DEADLOCK_EXCEPTION_SUPPLIER,
108                                                                  futureExecutor);
109         domBroker = new SerializedDOMDataBroker(stores, executor);
110     }
111
112     @After
113     public void tearDown() {
114         if (executor != null) {
115             executor.shutdownNow();
116         }
117
118         if (futureExecutor != null) {
119             futureExecutor.shutdownNow();
120         }
121     }
122
123     @Test
124     public void writeContainerEmptyTreeTest() throws InterruptedException {
125         CountDownLatch latch = new CountDownLatch(1);
126
127         DOMDataTreeChangeService dataTreeChangeService = getDOMDataTreeChangeService();
128         assertNotNull("DOMDataTreeChangeService not found, cannot continue with test!", dataTreeChangeService);
129
130         final TestDataTreeListener listener = new TestDataTreeListener(latch);
131         final ListenerRegistration<TestDataTreeListener> listenerReg = dataTreeChangeService
132                 .registerDataTreeChangeListener(ROOT_DATA_TREE_ID, listener);
133
134         final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
135         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
136         writeTx.commit();
137
138         latch.await(5, TimeUnit.SECONDS);
139
140         assertEquals(1, listener.getReceivedChanges().size());
141         final Collection<DataTreeCandidate> changes = listener.getReceivedChanges().get(0);
142         assertEquals(1, changes.size());
143
144         DataTreeCandidate candidate = changes.iterator().next();
145         assertNotNull(candidate);
146         DataTreeCandidateNode candidateRoot = candidate.getRootNode();
147         checkChange(null, TEST_CONTAINER, ModificationType.WRITE, candidateRoot);
148         listenerReg.close();
149     }
150
151     @Test
152     public void replaceContainerContainerInTreeTest() throws InterruptedException, ExecutionException {
153         final CountDownLatch latch = new CountDownLatch(2);
154
155         DOMDataTreeChangeService dataTreeChangeService = getDOMDataTreeChangeService();
156         assertNotNull("DOMDataTreeChangeService not found, cannot continue with test!", dataTreeChangeService);
157
158         DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
159         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
160         writeTx.commit().get();
161
162         final TestDataTreeListener listener = new TestDataTreeListener(latch);
163         final ListenerRegistration<TestDataTreeListener> listenerReg = dataTreeChangeService
164                 .registerDataTreeChangeListener(ROOT_DATA_TREE_ID, listener);
165         writeTx = domBroker.newWriteOnlyTransaction();
166         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER_2);
167         writeTx.commit();
168
169         latch.await(5, TimeUnit.SECONDS);
170
171         assertEquals(2, listener.getReceivedChanges().size());
172         Collection<DataTreeCandidate> changes = listener.getReceivedChanges().get(0);
173         assertEquals(1, changes.size());
174
175         DataTreeCandidate candidate = changes.iterator().next();
176         assertNotNull(candidate);
177         DataTreeCandidateNode candidateRoot = candidate.getRootNode();
178         checkChange(null, TEST_CONTAINER, ModificationType.WRITE, candidateRoot);
179
180         changes = listener.getReceivedChanges().get(1);
181         assertEquals(1, changes.size());
182
183         candidate = changes.iterator().next();
184         assertNotNull(candidate);
185         candidateRoot = candidate.getRootNode();
186         checkChange(TEST_CONTAINER, TEST_CONTAINER_2, ModificationType.WRITE, candidateRoot);
187         listenerReg.close();
188     }
189
190     @Test
191     public void deleteContainerContainerInTreeTest() throws InterruptedException, ExecutionException {
192         final CountDownLatch latch = new CountDownLatch(2);
193
194         DOMDataTreeChangeService dataTreeChangeService = getDOMDataTreeChangeService();
195         assertNotNull("DOMDataTreeChangeService not found, cannot continue with test!", dataTreeChangeService);
196
197         DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
198         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
199         writeTx.commit().get();
200
201         final TestDataTreeListener listener = new TestDataTreeListener(latch);
202         final ListenerRegistration<TestDataTreeListener> listenerReg = dataTreeChangeService
203                 .registerDataTreeChangeListener(ROOT_DATA_TREE_ID, listener);
204
205         writeTx = domBroker.newWriteOnlyTransaction();
206         writeTx.delete(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
207         writeTx.commit();
208
209         latch.await(5, TimeUnit.SECONDS);
210
211         assertEquals(2, listener.getReceivedChanges().size());
212         Collection<DataTreeCandidate> changes = listener.getReceivedChanges().get(0);
213         assertEquals(1, changes.size());
214
215         DataTreeCandidate candidate = changes.iterator().next();
216         assertNotNull(candidate);
217         DataTreeCandidateNode candidateRoot = candidate.getRootNode();
218         checkChange(null, TEST_CONTAINER, ModificationType.WRITE, candidateRoot);
219
220         changes = listener.getReceivedChanges().get(1);
221         assertEquals(1, changes.size());
222
223         candidate = changes.iterator().next();
224         assertNotNull(candidate);
225         candidateRoot = candidate.getRootNode();
226         checkChange(TEST_CONTAINER, null, ModificationType.DELETE, candidateRoot);
227         listenerReg.close();
228     }
229
230     @Test
231     public void replaceChildListContainerInTreeTest() throws InterruptedException, ExecutionException {
232         final CountDownLatch latch = new CountDownLatch(2);
233
234         DOMDataTreeChangeService dataTreeChangeService = getDOMDataTreeChangeService();
235         assertNotNull("DOMDataTreeChangeService not found, cannot continue with test!", dataTreeChangeService);
236
237         DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
238         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
239         writeTx.commit().get();
240
241         final TestDataTreeListener listener = new TestDataTreeListener(latch);
242         final ListenerRegistration<TestDataTreeListener> listenerReg = dataTreeChangeService
243                 .registerDataTreeChangeListener(ROOT_DATA_TREE_ID, listener);
244
245         writeTx = domBroker.newWriteOnlyTransaction();
246         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH, OUTER_LIST_2);
247         writeTx.commit();
248
249         latch.await(5, TimeUnit.SECONDS);
250
251         assertEquals(2, listener.getReceivedChanges().size());
252         Collection<DataTreeCandidate> changes = listener.getReceivedChanges().get(0);
253         assertEquals(1, changes.size());
254
255         DataTreeCandidate candidate = changes.iterator().next();
256         assertNotNull(candidate);
257         DataTreeCandidateNode candidateRoot = candidate.getRootNode();
258         checkChange(null, TEST_CONTAINER, ModificationType.WRITE, candidateRoot);
259
260         changes = listener.getReceivedChanges().get(1);
261         assertEquals(1, changes.size());
262
263         candidate = changes.iterator().next();
264         assertNotNull(candidate);
265         candidateRoot = candidate.getRootNode();
266         checkChange(TEST_CONTAINER, TEST_CONTAINER_2, ModificationType.SUBTREE_MODIFIED, candidateRoot);
267         final DataTreeCandidateNode modifiedChild = candidateRoot
268                 .getModifiedChild(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME));
269         assertNotNull(modifiedChild);
270         checkChange(OUTER_LIST, OUTER_LIST_2, ModificationType.WRITE, modifiedChild);
271         listenerReg.close();
272     }
273
274     @Test
275     public void rootModificationChildListenerTest() throws InterruptedException, ExecutionException {
276         final CountDownLatch latch = new CountDownLatch(2);
277
278         DOMDataTreeChangeService dataTreeChangeService = getDOMDataTreeChangeService();
279         assertNotNull("DOMDataTreeChangeService not found, cannot continue with test!", dataTreeChangeService);
280
281         DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
282         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
283         writeTx.commit().get();
284
285         final TestDataTreeListener listener = new TestDataTreeListener(latch);
286         final ListenerRegistration<TestDataTreeListener> listenerReg = dataTreeChangeService
287                 .registerDataTreeChangeListener(OUTER_LIST_DATA_TREE_ID, listener);
288
289         writeTx = domBroker.newWriteOnlyTransaction();
290         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER_2);
291         writeTx.commit().get();
292
293         latch.await(1, TimeUnit.SECONDS);
294
295         assertEquals(2, listener.getReceivedChanges().size());
296         Collection<DataTreeCandidate> changes = listener.getReceivedChanges().get(0);
297         assertEquals(1, changes.size());
298
299         DataTreeCandidate candidate = changes.iterator().next();
300         assertNotNull(candidate);
301         DataTreeCandidateNode candidateRoot = candidate.getRootNode();
302         checkChange(null, OUTER_LIST, ModificationType.WRITE, candidateRoot);
303
304         changes = listener.getReceivedChanges().get(1);
305         assertEquals(1, changes.size());
306
307         candidate = changes.iterator().next();
308         assertNotNull(candidate);
309         candidateRoot = candidate.getRootNode();
310         checkChange(OUTER_LIST, OUTER_LIST_2, ModificationType.WRITE, candidateRoot);
311         listenerReg.close();
312     }
313
314     @Test
315     public void listEntryChangeNonRootRegistrationTest() throws InterruptedException, ExecutionException {
316         final CountDownLatch latch = new CountDownLatch(2);
317
318         DOMDataTreeChangeService dataTreeChangeService = getDOMDataTreeChangeService();
319         assertNotNull("DOMDataTreeChangeService not found, cannot continue with test!", dataTreeChangeService);
320
321         DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
322         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, TEST_CONTAINER);
323         writeTx.commit().get();
324
325         final TestDataTreeListener listener = new TestDataTreeListener(latch);
326         final ListenerRegistration<TestDataTreeListener> listenerReg = dataTreeChangeService
327                 .registerDataTreeChangeListener(OUTER_LIST_DATA_TREE_ID, listener);
328
329         final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListEntryId1
330                 = new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
331                                                                           TestModel.ID_QNAME, 1);
332         final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListEntryId2
333                 = new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
334                                                                           TestModel.ID_QNAME, 2);
335         final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListEntryId3
336                 = new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
337                                                                           TestModel.ID_QNAME, 3);
338
339         final MapEntryNode outerListEntry1 = ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1);
340         final MapEntryNode outerListEntry2 = ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 2);
341         final MapEntryNode outerListEntry3 = ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3);
342
343         final MapNode listAfter = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).withChild(outerListEntry2)
344                 .withChild(outerListEntry3).build();
345
346         writeTx = domBroker.newWriteOnlyTransaction();
347         writeTx.delete(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH.node(outerListEntryId1));
348         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH.node(outerListEntryId2),
349                     outerListEntry2);
350         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH.node(outerListEntryId3),
351                     outerListEntry3);
352         writeTx.commit();
353
354         latch.await(5, TimeUnit.SECONDS);
355
356         assertEquals(2, listener.getReceivedChanges().size());
357         Collection<DataTreeCandidate> changes = listener.getReceivedChanges().get(0);
358         assertEquals(1, changes.size());
359
360         DataTreeCandidate candidate = changes.iterator().next();
361         assertNotNull(candidate);
362         DataTreeCandidateNode candidateRoot = candidate.getRootNode();
363         checkChange(null, OUTER_LIST, ModificationType.WRITE, candidateRoot);
364
365         changes = listener.getReceivedChanges().get(1);
366         assertEquals(1, changes.size());
367
368         candidate = changes.iterator().next();
369         assertNotNull(candidate);
370         candidateRoot = candidate.getRootNode();
371         checkChange(OUTER_LIST, listAfter, ModificationType.SUBTREE_MODIFIED, candidateRoot);
372         final DataTreeCandidateNode entry1Canditate = candidateRoot.getModifiedChild(outerListEntryId1);
373         checkChange(outerListEntry1, null, ModificationType.DELETE, entry1Canditate);
374         final DataTreeCandidateNode entry2Canditate = candidateRoot.getModifiedChild(outerListEntryId2);
375         checkChange(null, outerListEntry2, ModificationType.WRITE, entry2Canditate);
376         final DataTreeCandidateNode entry3Canditate = candidateRoot.getModifiedChild(outerListEntryId3);
377         checkChange(null, outerListEntry3, ModificationType.WRITE, entry3Canditate);
378         listenerReg.close();
379     }
380
381     private static void checkChange(final NormalizedNode<?, ?> expectedBefore, final NormalizedNode<?, ?> expectedAfter,
382                                     final ModificationType expectedMod, final DataTreeCandidateNode candidateNode) {
383         if (expectedBefore != null) {
384             assertTrue(candidateNode.getDataBefore().isPresent());
385             assertEquals(expectedBefore, candidateNode.getDataBefore().get());
386         } else {
387             assertFalse(candidateNode.getDataBefore().isPresent());
388         }
389
390         if (expectedAfter != null) {
391             assertTrue(candidateNode.getDataAfter().isPresent());
392             assertEquals(expectedAfter, candidateNode.getDataAfter().get());
393         } else {
394             assertFalse(candidateNode.getDataAfter().isPresent());
395         }
396
397         assertEquals(expectedMod, candidateNode.getModificationType());
398     }
399
400     private DOMDataTreeChangeService getDOMDataTreeChangeService() {
401         final DOMDataBrokerExtension extension = domBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
402         if (extension == null) {
403             return null;
404         }
405         DOMDataTreeChangeService dataTreeChangeService = null;
406         if (extension instanceof DOMDataTreeChangeService) {
407             dataTreeChangeService = (DOMDataTreeChangeService) extension;
408         }
409         return dataTreeChangeService;
410     }
411
412
413     static class CommitExecutorService extends ForwardingExecutorService {
414
415         ExecutorService delegate;
416
417         CommitExecutorService(final ExecutorService delegate) {
418             this.delegate = delegate;
419         }
420
421         @Override
422         protected ExecutorService delegate() {
423             return delegate;
424         }
425     }
426
427     static class TestDataTreeListener implements DOMDataTreeChangeListener {
428
429         private final List<Collection<DataTreeCandidate>> receivedChanges = new ArrayList<>();
430         private final CountDownLatch latch;
431
432         TestDataTreeListener(final CountDownLatch latch) {
433             this.latch = latch;
434         }
435
436         @Override
437         public void onDataTreeChanged(@Nonnull final Collection<DataTreeCandidate> changes) {
438             receivedChanges.add(changes);
439             latch.countDown();
440         }
441
442         public List<Collection<DataTreeCandidate>> getReceivedChanges() {
443             return receivedChanges;
444         }
445     }
446 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.