opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/compat/LegacyDOMDataBrokerAdapterTest.java

   1 /*
   2  * Copyright (c) 2017 Inocybe Technologies 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.cluster.databroker.compat;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.mockito.Matchers.any;
  15 import static org.mockito.Matchers.anyObject;
  16 import static org.mockito.Matchers.eq;
  17 import static org.mockito.Mockito.doAnswer;
  18 import static org.mockito.Mockito.doNothing;
  19 import static org.mockito.Mockito.doReturn;
  20 import static org.mockito.Mockito.inOrder;
  21 import static org.mockito.Mockito.mock;
  22 import static org.mockito.Mockito.verify;
  23
  24 import com.google.common.base.Optional;
  25 import com.google.common.collect.ImmutableMap;
  26 import com.google.common.util.concurrent.CheckedFuture;
  27 import com.google.common.util.concurrent.Futures;
  28 import com.google.common.util.concurrent.MoreExecutors;
  29 import java.util.Arrays;
  30 import java.util.Collection;
  31 import java.util.concurrent.TimeUnit;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.mockito.ArgumentCaptor;
  35 import org.mockito.InOrder;
  36 import org.mockito.Mock;
  37 import org.mockito.MockitoAnnotations;
  38 import org.opendaylight.controller.cluster.databroker.ConcurrentDOMDataBroker;
  39 import org.opendaylight.controller.cluster.datastore.DistributedDataStoreInterface;
  40 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
  41 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
  42 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  43 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
  44 import org.opendaylight.controller.md.sal.common.api.data.DataStoreUnavailableException;
  45 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  46 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
  47 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  48 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  49 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  50 import org.opendaylight.controller.md.sal.dom.api.ClusteredDOMDataTreeChangeListener;
  51 import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
  52 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
  53 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
  54 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
  55 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
  56 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry;
  57 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeIdentifier;
  58 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
  59 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
  60 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohort;
  61 import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistration;
  62 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
  63 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
  64 import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
  65 import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
  66 import org.opendaylight.mdsal.dom.spi.store.DOMStoreTreeChangePublisher;
  67 import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
  68 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  69 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  70 import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException;
  71 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
  72 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
  73 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  74
  75 /**
  76  * Unit tests for LegacyDOMDataBrokerAdapter.
  77  *
  78  * @author Thomas Pantelis
  79  */
  80 public class LegacyDOMDataBrokerAdapterTest {
  81     @Mock
  82     private TestDOMStore mockOperStore;
  83
  84     @Mock
  85     private TestDOMStore mockConfigStore;
  86
  87     @Mock
  88     private DOMStoreReadTransaction mockReadTx;
  89
  90     @Mock
  91     private DOMStoreWriteTransaction mockWriteTx;
  92
  93     @Mock
  94     private DOMStoreReadWriteTransaction mockReadWriteTx;
  95
  96     @Mock
  97     private DOMStoreThreePhaseCommitCohort mockCommitCohort;
  98
  99     private LegacyDOMDataBrokerAdapter adapter;
 100     private NormalizedNode<?,?> dataNode;
 101
 102     @Before
 103     public void setup() {
 104         MockitoAnnotations.initMocks(this);
 105
 106         ConcurrentDOMDataBroker backendBroker = new ConcurrentDOMDataBroker(ImmutableMap.of(
 107                 org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL, mockOperStore,
 108                 org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION, mockConfigStore),
 109                 MoreExecutors.newDirectExecutorService());
 110
 111         adapter = new LegacyDOMDataBrokerAdapter(backendBroker);
 112
 113         doReturn(Futures.immediateFuture(Boolean.TRUE)).when(mockCommitCohort).canCommit();
 114         doReturn(Futures.immediateFuture(null)).when(mockCommitCohort).preCommit();
 115         doReturn(Futures.immediateFuture(null)).when(mockCommitCohort).commit();
 116         doReturn(Futures.immediateFuture(null)).when(mockCommitCohort).abort();
 117
 118         dataNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 119
 120         doReturn(mockWriteTx).when(mockConfigStore).newWriteOnlyTransaction();
 121         doNothing().when(mockWriteTx).write(TestModel.TEST_PATH, dataNode);
 122         doNothing().when(mockWriteTx).merge(TestModel.TEST_PATH, dataNode);
 123         doNothing().when(mockWriteTx).delete(TestModel.TEST_PATH);
 124         doNothing().when(mockWriteTx).close();
 125         doReturn(mockCommitCohort).when(mockWriteTx).ready();
 126
 127         doReturn(mockReadTx).when(mockConfigStore).newReadOnlyTransaction();
 128         doReturn(Futures.immediateCheckedFuture(Optional.of(dataNode))).when(mockReadTx).read(TestModel.TEST_PATH);
 129         doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(mockReadTx).exists(TestModel.TEST_PATH);
 130
 131         doReturn(mockReadWriteTx).when(mockConfigStore).newReadWriteTransaction();
 132         doNothing().when(mockReadWriteTx).write(TestModel.TEST_PATH, dataNode);
 133         doReturn(mockCommitCohort).when(mockReadWriteTx).ready();
 134         doReturn(Futures.immediateCheckedFuture(Optional.of(dataNode))).when(mockReadWriteTx).read(TestModel.TEST_PATH);
 135
 136         DOMStoreTransactionChain mockTxChain = mock(DOMStoreTransactionChain.class);
 137         doReturn(mockReadTx).when(mockTxChain).newReadOnlyTransaction();
 138         doReturn(mockWriteTx).when(mockTxChain).newWriteOnlyTransaction();
 139         doReturn(mockReadWriteTx).when(mockTxChain).newReadWriteTransaction();
 140         doReturn(mockTxChain).when(mockConfigStore).createTransactionChain();
 141
 142         doReturn(mock(DOMStoreTransactionChain.class)).when(mockOperStore).createTransactionChain();
 143     }
 144
 145     @Test
 146     public void testReadOnlyTransaction() throws Exception {
 147         DOMDataReadOnlyTransaction tx = adapter.newReadOnlyTransaction();
 148
 149         // Test successful read
 150
 151         CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture =
 152                 tx.read(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 153         Optional<NormalizedNode<?, ?>> readOptional = readFuture.get();
 154         assertEquals("isPresent", true, readOptional.isPresent());
 155         assertEquals("NormalizedNode", dataNode, readOptional.get());
 156
 157         // Test successful exists
 158
 159         CheckedFuture<Boolean, ReadFailedException> existsFuture =
 160                 tx.exists(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 161         assertEquals("exists", Boolean.TRUE, existsFuture.get());
 162
 163         // Test failed read
 164
 165         String errorMsg = "mock read error";
 166         Throwable cause = new RuntimeException();
 167         doReturn(Futures.immediateFailedCheckedFuture(new org.opendaylight.mdsal.common.api.ReadFailedException(
 168                 errorMsg, cause))).when(mockReadTx).read(TestModel.TEST_PATH);
 169
 170         try {
 171             tx.read(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH).checkedGet();
 172             fail("Expected ReadFailedException");
 173         } catch (ReadFailedException e) {
 174             assertEquals("getMessage", errorMsg, e.getMessage());
 175             assertEquals("getCause", cause, e.getCause());
 176         }
 177
 178         // Test close
 179         tx.close();
 180         verify(mockReadTx).close();
 181     }
 182
 183     @Test
 184     public void testWriteOnlyTransaction() throws Exception {
 185         // Test successful write operations and submit
 186
 187         DOMDataWriteTransaction tx = adapter.newWriteOnlyTransaction();
 188
 189         tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 190         verify(mockWriteTx).write(TestModel.TEST_PATH, dataNode);
 191
 192         tx.merge(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 193         verify(mockWriteTx).merge(TestModel.TEST_PATH, dataNode);
 194
 195         tx.delete(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 196         verify(mockWriteTx).delete(TestModel.TEST_PATH);
 197
 198         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = tx.submit();
 199         submitFuture.get(5, TimeUnit.SECONDS);
 200
 201         InOrder inOrder = inOrder(mockCommitCohort);
 202         inOrder.verify(mockCommitCohort).canCommit();
 203         inOrder.verify(mockCommitCohort).preCommit();
 204         inOrder.verify(mockCommitCohort).commit();
 205
 206         // Test cancel
 207
 208         tx = adapter.newWriteOnlyTransaction();
 209         tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 210         tx.cancel();
 211         verify(mockWriteTx).close();
 212
 213         // Test submit with OptimisticLockFailedException
 214
 215         String errorMsg = "mock OptimisticLockFailedException";
 216         Throwable cause = new ConflictingModificationAppliedException(TestModel.TEST_PATH, "mock");
 217         doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.OptimisticLockFailedException(
 218                 errorMsg, cause))).when(mockCommitCohort).canCommit();
 219
 220         try {
 221             tx = adapter.newWriteOnlyTransaction();
 222             tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 223             submitFuture = tx.submit();
 224             submitFuture.checkedGet(5, TimeUnit.SECONDS);
 225             fail("Expected OptimisticLockFailedException");
 226         } catch (OptimisticLockFailedException e) {
 227             assertEquals("getMessage", errorMsg, e.getMessage());
 228             assertEquals("getCause", cause, e.getCause());
 229         }
 230
 231         // Test submit with TransactionCommitFailedException
 232
 233         errorMsg = "mock TransactionCommitFailedException";
 234         cause = new DataValidationFailedException(TestModel.TEST_PATH, "mock");
 235         doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.TransactionCommitFailedException(
 236                 errorMsg, cause))).when(mockCommitCohort).canCommit();
 237
 238         try {
 239             tx = adapter.newWriteOnlyTransaction();
 240             tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 241             submitFuture = tx.submit();
 242             submitFuture.checkedGet(5, TimeUnit.SECONDS);
 243             fail("Expected TransactionCommitFailedException");
 244         } catch (TransactionCommitFailedException e) {
 245             assertEquals("getMessage", errorMsg, e.getMessage());
 246             assertEquals("getCause", cause, e.getCause());
 247         }
 248
 249         // Test submit with DataStoreUnavailableException
 250
 251         errorMsg = "mock NoShardLeaderException";
 252         cause = new NoShardLeaderException("mock");
 253         doReturn(Futures.immediateFailedFuture(cause)).when(mockCommitCohort).canCommit();
 254
 255         try {
 256             tx = adapter.newWriteOnlyTransaction();
 257             tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 258             submitFuture = tx.submit();
 259             submitFuture.checkedGet(5, TimeUnit.SECONDS);
 260             fail("Expected TransactionCommitFailedException");
 261         } catch (TransactionCommitFailedException e) {
 262             assertEquals("getCause type", DataStoreUnavailableException.class, e.getCause().getClass());
 263             assertEquals("Root cause", cause, e.getCause().getCause());
 264         }
 265
 266         // Test submit with RuntimeException
 267
 268         errorMsg = "mock RuntimeException";
 269         cause = new RuntimeException(errorMsg);
 270         doReturn(Futures.immediateFailedFuture(cause)).when(mockCommitCohort).canCommit();
 271
 272         try {
 273             tx = adapter.newWriteOnlyTransaction();
 274             tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 275             submitFuture = tx.submit();
 276             submitFuture.checkedGet(5, TimeUnit.SECONDS);
 277             fail("Expected TransactionCommitFailedException");
 278         } catch (TransactionCommitFailedException e) {
 279             assertEquals("getCause", cause, e.getCause());
 280         }
 281     }
 282
 283     @Test
 284     public void testReadWriteTransaction() throws Exception {
 285         DOMDataReadWriteTransaction tx = adapter.newReadWriteTransaction();
 286
 287         CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture =
 288                 tx.read(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 289         Optional<NormalizedNode<?, ?>> readOptional = readFuture.get();
 290         assertEquals("isPresent", true, readOptional.isPresent());
 291         assertEquals("NormalizedNode", dataNode, readOptional.get());
 292
 293         tx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 294         verify(mockReadWriteTx).write(TestModel.TEST_PATH, dataNode);
 295
 296         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = tx.submit();
 297         submitFuture.get(5, TimeUnit.SECONDS);
 298
 299         InOrder inOrder = inOrder(mockCommitCohort);
 300         inOrder.verify(mockCommitCohort).canCommit();
 301         inOrder.verify(mockCommitCohort).preCommit();
 302         inOrder.verify(mockCommitCohort).commit();
 303     }
 304
 305     @SuppressWarnings("rawtypes")
 306     @Test
 307     public void testTransactionChain() throws Exception {
 308         TransactionChainListener mockListener = mock(TransactionChainListener.class);
 309         doNothing().when(mockListener).onTransactionChainSuccessful(anyObject());
 310         doNothing().when(mockListener).onTransactionChainFailed(anyObject(), anyObject(), anyObject());
 311
 312         DOMTransactionChain chain = adapter.createTransactionChain(mockListener);
 313
 314         // Test read-only tx
 315
 316         DOMDataReadOnlyTransaction readTx = chain.newReadOnlyTransaction();
 317
 318         CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture =
 319                 readTx.read(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 320         Optional<NormalizedNode<?, ?>> readOptional = readFuture.get();
 321         assertEquals("isPresent", true, readOptional.isPresent());
 322         assertEquals("NormalizedNode", dataNode, readOptional.get());
 323
 324         // Test write-only tx
 325
 326         DOMDataWriteTransaction writeTx = chain.newWriteOnlyTransaction();
 327
 328         writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 329         verify(mockWriteTx).write(TestModel.TEST_PATH, dataNode);
 330         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTx.submit();
 331         submitFuture.get(5, TimeUnit.SECONDS);
 332
 333         InOrder inOrder = inOrder(mockCommitCohort);
 334         inOrder.verify(mockCommitCohort).canCommit();
 335         inOrder.verify(mockCommitCohort).preCommit();
 336         inOrder.verify(mockCommitCohort).commit();
 337
 338         // Test read-write tx
 339
 340         DOMDataReadWriteTransaction readWriteTx = chain.newReadWriteTransaction();
 341
 342         readFuture = readWriteTx.read(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 343         readOptional = readFuture.get();
 344         assertEquals("isPresent", true, readOptional.isPresent());
 345         assertEquals("NormalizedNode", dataNode, readOptional.get());
 346
 347         chain.close();
 348         verify(mockListener).onTransactionChainSuccessful(chain);
 349
 350         // Test failed chain
 351
 352         doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.TransactionCommitFailedException(
 353                 "mock", (Throwable)null))).when(mockCommitCohort).canCommit();
 354
 355         chain = adapter.createTransactionChain(mockListener);
 356
 357         writeTx = chain.newWriteOnlyTransaction();
 358
 359         try {
 360             writeTx.put(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, dataNode);
 361             writeTx.submit().checkedGet(5, TimeUnit.SECONDS);
 362             fail("Expected TransactionCommitFailedException");
 363         } catch (TransactionCommitFailedException e) {
 364             // expected
 365         }
 366
 367         ArgumentCaptor<AsyncTransaction> failedTx = ArgumentCaptor.forClass(AsyncTransaction.class);
 368         verify(mockListener).onTransactionChainFailed(eq(chain), failedTx.capture(),
 369                 any(TransactionCommitFailedException.class));
 370     }
 371
 372     @SuppressWarnings("unchecked")
 373     @Test
 374     public void testDataTreeChangeListener() {
 375         DOMDataTreeChangeService domDTCLService =
 376                 (DOMDataTreeChangeService) adapter.getSupportedExtensions().get(DOMDataTreeChangeService.class);
 377         assertNotNull("DOMDataTreeChangeService not found", domDTCLService);
 378
 379         ArgumentCaptor<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> storeDTCL =
 380                 ArgumentCaptor.forClass(org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener.class);
 381         ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> mockReg =
 382                 mock(ListenerRegistration.class);
 383         doNothing().when(mockReg).close();
 384         doAnswer(invocation -> storeDTCL.getValue()).when(mockReg).getInstance();
 385         doReturn(mockReg).when(mockConfigStore).registerTreeChangeListener(eq(TestModel.TEST_PATH),
 386                 storeDTCL.capture());
 387
 388         DOMDataTreeChangeListener brokerDTCL = mock(DOMDataTreeChangeListener.class);
 389         ListenerRegistration<DOMDataTreeChangeListener> reg = domDTCLService.registerDataTreeChangeListener(
 390                 new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH), brokerDTCL);
 391         assertEquals("getInstance", brokerDTCL, reg.getInstance());
 392
 393         Collection<DataTreeCandidate> changes = Arrays.asList(mock(DataTreeCandidate.class));
 394         storeDTCL.getValue().onDataTreeChanged(changes);
 395         verify(brokerDTCL).onDataTreeChanged(changes);
 396
 397         reg.close();
 398         verify(mockReg).close();
 399
 400         // Test ClusteredDOMDataTreeChangeListener
 401
 402         ArgumentCaptor<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> storeClusteredDTCL =
 403                 ArgumentCaptor.forClass(org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener.class);
 404         mockReg = mock(ListenerRegistration.class);
 405         doReturn(mockReg).when(mockConfigStore).registerTreeChangeListener(eq(TestModel.TEST_PATH),
 406                 storeClusteredDTCL.capture());
 407
 408         final ClusteredDOMDataTreeChangeListener brokerClusteredDTCL = mock(ClusteredDOMDataTreeChangeListener.class);
 409         domDTCLService.registerDataTreeChangeListener(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION,
 410                 TestModel.TEST_PATH), brokerClusteredDTCL);
 411
 412         assertTrue("Expected ClusteredDOMDataTreeChangeListener: " + storeClusteredDTCL.getValue(),
 413                 storeClusteredDTCL.getValue()
 414                     instanceof org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener);
 415         storeClusteredDTCL.getValue().onDataTreeChanged(changes);
 416         verify(brokerClusteredDTCL).onDataTreeChanged(changes);
 417     }
 418
 419     @SuppressWarnings("unchecked")
 420     @Test
 421     public void testDataTreeCommitCohortRegistry() {
 422         DOMDataTreeCommitCohortRegistry domCohortRegistry = (DOMDataTreeCommitCohortRegistry)
 423                 adapter.getSupportedExtensions().get(DOMDataTreeCommitCohortRegistry.class);
 424         assertNotNull("DOMDataTreeCommitCohortRegistry not found", domCohortRegistry);
 425
 426         DOMDataTreeCommitCohort mockCohort = mock(DOMDataTreeCommitCohort.class);
 427         org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier treeId =
 428                 new org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier(
 429                     org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
 430         DOMDataTreeCommitCohortRegistration<DOMDataTreeCommitCohort> mockReg =
 431                 mock(DOMDataTreeCommitCohortRegistration.class);
 432         doReturn(mockReg).when(mockConfigStore).registerCommitCohort(treeId, mockCohort);
 433
 434         DOMDataTreeCommitCohortRegistration<DOMDataTreeCommitCohort> reg = domCohortRegistry.registerCommitCohort(
 435                 treeId, mockCohort);
 436         assertEquals("DOMDataTreeCommitCohortRegistration", mockReg, reg);
 437
 438         verify(mockConfigStore).registerCommitCohort(treeId, mockCohort);
 439     }
 440
 441     @Test
 442     public void testDataChangeListener() {
 443         DOMDataChangeListener listener = mock(DOMDataChangeListener.class);
 444         ListenerRegistration<DOMDataChangeListener> mockReg = mock(ListenerRegistration.class);
 445         doReturn(mockReg).when(mockConfigStore).registerChangeListener(
 446                 TestModel.TEST_PATH, listener, DataChangeScope.ONE);
 447
 448         ListenerRegistration<DOMDataChangeListener> reg = adapter.registerDataChangeListener(
 449                 LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH, listener, DataChangeScope.ONE);
 450         assertEquals("ListenerRegistration<DOMDataChangeListener>", mockReg, reg);
 451
 452         verify(mockConfigStore).registerChangeListener(TestModel.TEST_PATH, listener, DataChangeScope.ONE);
 453     }
 454
 455     private interface TestDOMStore extends DistributedDataStoreInterface, DOMStoreTreeChangePublisher,
 456             org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry {
 457     }
 458 }