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