2 * Copyright (c) 2017 Inocybe Technologies and others. All rights reserved.
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
8 package org.opendaylight.controller.sal.core.compat;
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;
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;
80 * Unit tests for LegacyDOMDataBrokerAdapter.
82 * @author Thomas Pantelis
84 public class LegacyDOMDataBrokerAdapterTest {
85 public static final QName TEST_QNAME = QName.create("test", "2018-07-11", "test");
86 private static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
89 private TestDOMStore mockOperStore;
92 private TestDOMStore mockConfigStore;
95 private DOMStoreReadTransaction mockConfigReadTx;
98 private DOMStoreWriteTransaction mockConfigWriteTx;
101 private DOMStoreReadWriteTransaction mockConfigReadWriteTx;
104 private DOMStoreThreePhaseCommitCohort mockConfigCommitCohort;
107 private DOMStoreReadTransaction mockOperReadTx;
110 private DOMStoreWriteTransaction mockOperWriteTx;
113 private DOMStoreReadWriteTransaction mockOperReadWriteTx;
116 private DOMStoreThreePhaseCommitCohort mockOperCommitCohort;
119 private DOMDataTreeCommitCohortRegistry mockCommitCohortRegistry;
121 private LegacyDOMDataBrokerAdapter adapter;
122 private NormalizedNode<?,?> dataNode;
125 public void setup() {
126 MockitoAnnotations.initMocks(this);
128 SerializedDOMDataBroker backendBroker = new SerializedDOMDataBroker(ImmutableMap.of(
129 org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL, mockOperStore,
130 org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION, mockConfigStore),
131 MoreExecutors.newDirectExecutorService()) {
133 public ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
134 return ImmutableClassToInstanceMap.<DOMDataBrokerExtension>builder().putAll(super.getExtensions())
135 .put(DOMDataTreeCommitCohortRegistry.class, mockCommitCohortRegistry).build();
139 adapter = new LegacyDOMDataBrokerAdapter(backendBroker);
141 doReturn(Futures.immediateFuture(Boolean.TRUE)).when(mockConfigCommitCohort).canCommit();
142 doReturn(Futures.immediateFuture(null)).when(mockConfigCommitCohort).preCommit();
143 doReturn(Futures.immediateFuture(null)).when(mockConfigCommitCohort).commit();
144 doReturn(Futures.immediateFuture(null)).when(mockConfigCommitCohort).abort();
146 dataNode = ImmutableNodes.containerNode(TEST_QNAME);
148 doReturn(mockConfigWriteTx).when(mockConfigStore).newWriteOnlyTransaction();
149 doNothing().when(mockConfigWriteTx).write(TEST_PATH, dataNode);
150 doNothing().when(mockConfigWriteTx).merge(TEST_PATH, dataNode);
151 doNothing().when(mockConfigWriteTx).delete(TEST_PATH);
152 doNothing().when(mockConfigWriteTx).close();
153 doReturn(mockConfigCommitCohort).when(mockConfigWriteTx).ready();
155 doReturn(mockConfigReadTx).when(mockConfigStore).newReadOnlyTransaction();
156 doReturn(FluentFutures.immediateFluentFuture(Optional.of(dataNode))).when(mockConfigReadTx).read(TEST_PATH);
157 doReturn(FluentFutures.immediateFluentFuture(Boolean.TRUE)).when(mockConfigReadTx).exists(TEST_PATH);
159 doReturn(mockConfigReadWriteTx).when(mockConfigStore).newReadWriteTransaction();
160 doNothing().when(mockConfigReadWriteTx).write(TEST_PATH, dataNode);
161 doReturn(mockConfigCommitCohort).when(mockConfigReadWriteTx).ready();
162 doReturn(FluentFutures.immediateFluentFuture(Optional.of(dataNode)))
163 .when(mockConfigReadWriteTx).read(TEST_PATH);
165 DOMStoreTransactionChain mockTxChain = mock(DOMStoreTransactionChain.class);
166 doReturn(mockConfigReadTx).when(mockTxChain).newReadOnlyTransaction();
167 doReturn(mockConfigWriteTx).when(mockTxChain).newWriteOnlyTransaction();
168 doReturn(mockConfigReadWriteTx).when(mockTxChain).newReadWriteTransaction();
169 doReturn(mockTxChain).when(mockConfigStore).createTransactionChain();
171 doReturn(mock(DOMStoreTransactionChain.class)).when(mockOperStore).createTransactionChain();
173 doReturn(Futures.immediateFuture(Boolean.TRUE)).when(mockOperCommitCohort).canCommit();
174 doReturn(Futures.immediateFuture(null)).when(mockOperCommitCohort).preCommit();
175 doReturn(Futures.immediateFuture(null)).when(mockOperCommitCohort).commit();
176 doReturn(Futures.immediateFuture(null)).when(mockOperCommitCohort).abort();
178 doReturn(mockOperReadTx).when(mockOperStore).newReadOnlyTransaction();
180 doReturn(mockOperWriteTx).when(mockOperStore).newWriteOnlyTransaction();
181 doReturn(mockOperCommitCohort).when(mockOperWriteTx).ready();
183 doReturn(mockOperReadWriteTx).when(mockOperStore).newReadWriteTransaction();
184 doReturn(mockOperCommitCohort).when(mockOperReadWriteTx).ready();
186 DOMStoreTransactionChain mockOperTxChain = mock(DOMStoreTransactionChain.class);
187 doReturn(mockOperReadTx).when(mockOperTxChain).newReadOnlyTransaction();
188 doReturn(mockOperWriteTx).when(mockOperTxChain).newWriteOnlyTransaction();
189 doReturn(mockOperReadWriteTx).when(mockOperTxChain).newReadWriteTransaction();
190 doReturn(mockOperTxChain).when(mockOperStore).createTransactionChain();
194 public void testReadOnlyTransaction() throws Exception {
195 DOMDataReadOnlyTransaction tx = adapter.newReadOnlyTransaction();
197 // Test successful read
199 CheckedFuture<com.google.common.base.Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture =
200 tx.read(LogicalDatastoreType.CONFIGURATION, TEST_PATH);
201 com.google.common.base.Optional<NormalizedNode<?, ?>> readOptional = readFuture.get();
202 assertEquals("isPresent", true, readOptional.isPresent());
203 assertEquals("NormalizedNode", dataNode, readOptional.get());
205 // Test successful exists
207 CheckedFuture<Boolean, ReadFailedException> existsFuture =
208 tx.exists(LogicalDatastoreType.CONFIGURATION, TEST_PATH);
209 assertEquals("exists", Boolean.TRUE, existsFuture.get());
213 String errorMsg = "mock read error";
214 Throwable cause = new RuntimeException();
215 doReturn(FluentFutures.immediateFailedFluentFuture(new org.opendaylight.mdsal.common.api.ReadFailedException(
216 errorMsg, cause))).when(mockConfigReadTx).read(TEST_PATH);
219 tx.read(LogicalDatastoreType.CONFIGURATION, TEST_PATH).checkedGet();
220 fail("Expected ReadFailedException");
221 } catch (ReadFailedException e) {
222 assertEquals("getMessage", errorMsg, e.getMessage());
223 assertEquals("getCause", cause, e.getCause());
228 verify(mockConfigReadTx).close();
232 public void testWriteOnlyTransaction() throws Exception {
233 // Test successful write operations and submit
235 DOMDataWriteTransaction tx = adapter.newWriteOnlyTransaction();
237 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
238 verify(mockConfigWriteTx).write(TEST_PATH, dataNode);
240 tx.merge(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
241 verify(mockConfigWriteTx).merge(TEST_PATH, dataNode);
243 tx.delete(LogicalDatastoreType.CONFIGURATION, TEST_PATH);
244 verify(mockConfigWriteTx).delete(TEST_PATH);
246 tx.commit().get(5, TimeUnit.SECONDS);
248 InOrder inOrder = inOrder(mockConfigCommitCohort);
249 inOrder.verify(mockConfigCommitCohort).canCommit();
250 inOrder.verify(mockConfigCommitCohort).preCommit();
251 inOrder.verify(mockConfigCommitCohort).commit();
255 tx = adapter.newWriteOnlyTransaction();
256 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
258 verify(mockConfigWriteTx).close();
260 // Test submit with OptimisticLockFailedException
262 String errorMsg = "mock OptimisticLockFailedException";
263 Throwable cause = new ConflictingModificationAppliedException(TEST_PATH, "mock");
264 doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.OptimisticLockFailedException(
265 errorMsg, cause))).when(mockConfigCommitCohort).canCommit();
268 tx = adapter.newWriteOnlyTransaction();
269 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
271 fail("Expected OptimisticLockFailedException");
272 } catch (OptimisticLockFailedException e) {
273 assertEquals("getMessage", errorMsg, e.getMessage());
274 assertEquals("getCause", cause, e.getCause());
277 // Test submit with TransactionCommitFailedException
279 errorMsg = "mock TransactionCommitFailedException";
280 cause = new DataValidationFailedException(TEST_PATH, "mock");
281 doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.TransactionCommitFailedException(
282 errorMsg, cause))).when(mockConfigCommitCohort).canCommit();
285 tx = adapter.newWriteOnlyTransaction();
286 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
288 fail("Expected TransactionCommitFailedException");
289 } catch (TransactionCommitFailedException e) {
290 assertEquals("getMessage", errorMsg, e.getMessage());
291 assertEquals("getCause", cause, e.getCause());
294 // Test submit with DataStoreUnavailableException
296 errorMsg = "mock NoShardLeaderException";
297 cause = new DataStoreUnavailableException("mock", new RuntimeException());
298 doReturn(Futures.immediateFailedFuture(cause)).when(mockConfigCommitCohort).canCommit();
301 tx = adapter.newWriteOnlyTransaction();
302 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
304 fail("Expected TransactionCommitFailedException");
305 } catch (TransactionCommitFailedException e) {
306 assertEquals("getCause type", DataStoreUnavailableException.class, e.getCause().getClass());
309 // Test submit with RuntimeException
311 errorMsg = "mock RuntimeException";
312 cause = new RuntimeException(errorMsg);
313 doReturn(Futures.immediateFailedFuture(cause)).when(mockConfigCommitCohort).canCommit();
316 tx = adapter.newWriteOnlyTransaction();
317 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
319 fail("Expected TransactionCommitFailedException");
320 } catch (TransactionCommitFailedException e) {
321 assertEquals("getCause", cause, e.getCause());
326 public void testReadWriteTransaction() throws Exception {
327 DOMDataReadWriteTransaction tx = adapter.newReadWriteTransaction();
329 CheckedFuture<com.google.common.base.Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture =
330 tx.read(LogicalDatastoreType.CONFIGURATION, TEST_PATH);
331 com.google.common.base.Optional<NormalizedNode<?, ?>> readOptional = readFuture.get();
332 assertEquals("isPresent", true, readOptional.isPresent());
333 assertEquals("NormalizedNode", dataNode, readOptional.get());
335 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
336 verify(mockConfigReadWriteTx).write(TEST_PATH, dataNode);
338 tx.commit().get(5, TimeUnit.SECONDS);
340 InOrder inOrder = inOrder(mockConfigCommitCohort);
341 inOrder.verify(mockConfigCommitCohort).canCommit();
342 inOrder.verify(mockConfigCommitCohort).preCommit();
343 inOrder.verify(mockConfigCommitCohort).commit();
346 @SuppressWarnings("rawtypes")
348 public void testTransactionChain() throws Exception {
349 TransactionChainListener mockListener = mock(TransactionChainListener.class);
350 doNothing().when(mockListener).onTransactionChainSuccessful(anyObject());
351 doNothing().when(mockListener).onTransactionChainFailed(anyObject(), anyObject(), anyObject());
353 DOMTransactionChain chain = adapter.createTransactionChain(mockListener);
357 DOMDataReadOnlyTransaction readTx = chain.newReadOnlyTransaction();
359 CheckedFuture<com.google.common.base.Optional<NormalizedNode<?, ?>>, ReadFailedException> readFuture =
360 readTx.read(LogicalDatastoreType.CONFIGURATION, TEST_PATH);
361 com.google.common.base.Optional<NormalizedNode<?, ?>> readOptional = readFuture.get();
362 assertEquals("isPresent", true, readOptional.isPresent());
363 assertEquals("NormalizedNode", dataNode, readOptional.get());
365 // Test write-only tx
367 DOMDataWriteTransaction writeTx = chain.newWriteOnlyTransaction();
369 writeTx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
370 verify(mockConfigWriteTx).write(TEST_PATH, dataNode);
371 writeTx.commit().get(5, TimeUnit.SECONDS);
373 InOrder inOrder = inOrder(mockConfigCommitCohort);
374 inOrder.verify(mockConfigCommitCohort).canCommit();
375 inOrder.verify(mockConfigCommitCohort).preCommit();
376 inOrder.verify(mockConfigCommitCohort).commit();
378 // Test read-write tx
380 DOMDataReadWriteTransaction readWriteTx = chain.newReadWriteTransaction();
382 readFuture = readWriteTx.read(LogicalDatastoreType.CONFIGURATION, TEST_PATH);
383 readOptional = readFuture.get();
384 assertEquals("isPresent", true, readOptional.isPresent());
385 assertEquals("NormalizedNode", dataNode, readOptional.get());
388 verify(mockListener).onTransactionChainSuccessful(chain);
392 doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.TransactionCommitFailedException(
393 "mock", (Throwable)null))).when(mockConfigCommitCohort).canCommit();
395 chain = adapter.createTransactionChain(mockListener);
397 writeTx = chain.newWriteOnlyTransaction();
400 writeTx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
402 fail("Expected TransactionCommitFailedException");
403 } catch (TransactionCommitFailedException e) {
407 ArgumentCaptor<AsyncTransaction> failedTx = ArgumentCaptor.forClass(AsyncTransaction.class);
408 verify(mockListener).onTransactionChainFailed(eq(chain), failedTx.capture(),
409 any(TransactionCommitFailedException.class));
412 @SuppressWarnings("unchecked")
414 public void testDataTreeChangeListener() {
415 DOMDataTreeChangeService domDTCLService =
416 (DOMDataTreeChangeService) adapter.getSupportedExtensions().get(DOMDataTreeChangeService.class);
417 assertNotNull("DOMDataTreeChangeService not found", domDTCLService);
419 ArgumentCaptor<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> storeDTCL =
420 ArgumentCaptor.forClass(org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener.class);
421 ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> mockReg =
422 mock(ListenerRegistration.class);
423 doNothing().when(mockReg).close();
424 doAnswer(invocation -> storeDTCL.getValue()).when(mockReg).getInstance();
425 doReturn(mockReg).when(mockConfigStore).registerTreeChangeListener(eq(TEST_PATH),
426 storeDTCL.capture());
428 DOMDataTreeChangeListener brokerDTCL = mock(DOMDataTreeChangeListener.class);
429 ListenerRegistration<DOMDataTreeChangeListener> reg = domDTCLService.registerDataTreeChangeListener(
430 new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, TEST_PATH), brokerDTCL);
431 assertEquals("getInstance", brokerDTCL, reg.getInstance());
433 Collection<DataTreeCandidate> changes = Arrays.asList(mock(DataTreeCandidate.class));
434 storeDTCL.getValue().onDataTreeChanged(changes);
435 verify(brokerDTCL).onDataTreeChanged(changes);
438 verify(mockReg).close();
440 // Test ClusteredDOMDataTreeChangeListener
442 ArgumentCaptor<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener> storeClusteredDTCL =
443 ArgumentCaptor.forClass(org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener.class);
444 mockReg = mock(ListenerRegistration.class);
445 doReturn(mockReg).when(mockConfigStore).registerTreeChangeListener(eq(TEST_PATH),
446 storeClusteredDTCL.capture());
448 final ClusteredDOMDataTreeChangeListener brokerClusteredDTCL = mock(ClusteredDOMDataTreeChangeListener.class);
449 domDTCLService.registerDataTreeChangeListener(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION,
450 TEST_PATH), brokerClusteredDTCL);
452 assertTrue("Expected ClusteredDOMDataTreeChangeListener: " + storeClusteredDTCL.getValue(),
453 storeClusteredDTCL.getValue()
454 instanceof org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener);
455 storeClusteredDTCL.getValue().onDataTreeChanged(changes);
456 verify(brokerClusteredDTCL).onDataTreeChanged(changes);
459 @SuppressWarnings("unchecked")
461 public void testDataTreeCommitCohortRegistry() {
462 org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry domCohortRegistry =
463 (org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry)
464 adapter.getSupportedExtensions().get(
465 org.opendaylight.controller.md.sal.dom.api.DOMDataTreeCommitCohortRegistry.class);
466 assertNotNull("DOMDataTreeCommitCohortRegistry not found", domCohortRegistry);
468 DOMDataTreeCommitCohort mockCohort = mock(DOMDataTreeCommitCohort.class);
469 org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier treeId =
470 new org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier(
471 org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION, TEST_PATH);
472 DOMDataTreeCommitCohortRegistration<DOMDataTreeCommitCohort> mockReg =
473 mock(DOMDataTreeCommitCohortRegistration.class);
474 doReturn(mockReg).when(mockCommitCohortRegistry).registerCommitCohort(treeId, mockCohort);
476 DOMDataTreeCommitCohortRegistration<DOMDataTreeCommitCohort> reg = domCohortRegistry.registerCommitCohort(
478 assertEquals("DOMDataTreeCommitCohortRegistration", mockReg, reg);
480 verify(mockCommitCohortRegistry).registerCommitCohort(treeId, mockCohort);
485 public void testSubmit() throws Exception {
486 DOMDataWriteTransaction tx = adapter.newWriteOnlyTransaction();
488 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
489 verify(mockConfigWriteTx).write(TEST_PATH, dataNode);
491 tx.submit().get(5, TimeUnit.SECONDS);
493 InOrder inOrder = inOrder(mockConfigCommitCohort);
494 inOrder.verify(mockConfigCommitCohort).canCommit();
495 inOrder.verify(mockConfigCommitCohort).preCommit();
496 inOrder.verify(mockConfigCommitCohort).commit();
498 String errorMsg = "mock OptimisticLockFailedException";
499 Throwable cause = new ConflictingModificationAppliedException(TEST_PATH, "mock");
500 doReturn(Futures.immediateFailedFuture(new org.opendaylight.mdsal.common.api.TransactionCommitFailedException(
501 errorMsg, cause))).when(mockConfigCommitCohort).canCommit();
504 tx = adapter.newWriteOnlyTransaction();
505 tx.put(LogicalDatastoreType.CONFIGURATION, TEST_PATH, dataNode);
507 fail("Expected TransactionCommitFailedException");
508 } catch (TransactionCommitFailedException e) {
509 assertEquals("getMessage", errorMsg, e.getMessage());
510 assertEquals("getCause", cause, e.getCause());
514 @SuppressWarnings("checkstyle:AvoidHidingCauseException")
515 private static void commit(final DOMDataWriteTransaction tx)
516 throws TransactionCommitFailedException, InterruptedException, TimeoutException {
518 tx.commit().get(5, TimeUnit.SECONDS);
519 } catch (ExecutionException e) {
520 assertTrue("Expected TransactionCommitFailedException. Actual: " + e.getCause(),
521 e.getCause() instanceof TransactionCommitFailedException);
522 throw (TransactionCommitFailedException)e.getCause();
526 private interface TestDOMStore extends DOMStore, DOMStoreTreeChangePublisher,
527 org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry {