2 * Copyright © 2018 Red Hat, Inc. and others.
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.mdsal.binding.util;
10 import static org.hamcrest.CoreMatchers.instanceOf;
11 import static org.hamcrest.MatcherAssert.assertThat;
12 import static org.junit.Assert.assertEquals;
13 import static org.junit.Assert.assertThrows;
14 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.TOP_FOO_KEY;
15 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.path;
16 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.topLevelList;
17 import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
19 import java.util.Optional;
20 import java.util.concurrent.ExecutionException;
21 import java.util.concurrent.Future;
22 import org.junit.Before;
23 import org.junit.Test;
24 import org.opendaylight.mdsal.binding.api.DataBroker;
25 import org.opendaylight.mdsal.binding.api.ReadTransaction;
26 import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
27 import org.opendaylight.mdsal.binding.testutils.DataBrokerFailuresImpl;
28 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.complex.from.grouping.ContainerWithUsesBuilder;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
33 import org.opendaylight.yangtools.yang.binding.DataObject;
34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
37 * Test for {@link TransactionAdapter}.
40 public class TransactionAdapterTest extends AbstractConcurrentDataBrokerTest {
42 private static final InstanceIdentifier<TopLevelList> TEST_PATH = path(TOP_FOO_KEY);
44 private ManagedNewTransactionRunner managedNewTransactionRunner;
45 private DataBrokerFailuresImpl testableDataBroker;
47 private ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(final DataBroker dataBroker) {
48 return new ManagedNewTransactionRunnerImpl(dataBroker);
52 public void beforeTest() throws Exception {
54 testableDataBroker = new DataBrokerFailuresImpl(getDataBroker());
55 managedNewTransactionRunner = createManagedNewTransactionRunnerToTest(testableDataBroker);
59 public void testAdaptedWriteTransactionPutsSuccessfully() throws Exception {
60 TopLevelList data = newTestDataObject();
61 managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
62 writeTx -> TransactionAdapter.toWriteTransaction(writeTx).put(LogicalDatastoreType.OPERATIONAL,
63 TEST_PATH, data)).get();
64 assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
68 public void testAdaptedReadWriteTransactionPutsSuccessfully() throws Exception {
69 TopLevelList data = newTestDataObject();
70 managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
71 writeTx -> TransactionAdapter.toReadWriteTransaction(writeTx).put(LogicalDatastoreType.OPERATIONAL,
72 TEST_PATH, data)).get();
73 assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
77 public void testAdaptedWriteTransactionFailsOnInvalidDatastore() throws Exception {
78 Future<?> future = managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
79 writeTx -> TransactionAdapter.toWriteTransaction(writeTx).put(LogicalDatastoreType.CONFIGURATION,
80 TEST_PATH, newTestDataObject()));
81 ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
82 assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
83 assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
87 public void testAdaptedReadWriteTransactionFailsOnInvalidDatastore() throws Exception {
88 Future<?> future = managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
89 writeTx -> TransactionAdapter.toReadWriteTransaction(writeTx).put(LogicalDatastoreType.CONFIGURATION,
90 TEST_PATH, newTestDataObject()));
91 ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
92 assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
93 assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
96 @Test(expected = ExecutionException.class)
97 public void testAdaptedWriteTransactionCannotCommit() throws Exception {
98 managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
99 tx -> TransactionAdapter.toWriteTransaction(tx).commit()).get();
102 @Test(expected = ExecutionException.class)
103 public void testAdaptedReadWriteTransactionCannotCommit() throws Exception {
104 managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
105 tx -> TransactionAdapter.toReadWriteTransaction(tx).commit()).get();
108 @Test(expected = ExecutionException.class)
109 public void testAdaptedWriteTransactionCannotCancel() throws Exception {
110 managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
111 tx -> TransactionAdapter.toWriteTransaction(tx).cancel()).get();
114 @Test(expected = ExecutionException.class)
115 public void testAdaptedReadWriteTransactionCannotCancel() throws Exception {
116 managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
117 tx -> TransactionAdapter.toReadWriteTransaction(tx).cancel()).get();
120 private static TopLevelList newTestDataObject() {
121 TreeComplexUsesAugment fooAugment = new TreeComplexUsesAugmentBuilder()
122 .setContainerWithUses(new ContainerWithUsesBuilder().setLeafFromGrouping("foo").build()).build();
123 return topLevelList(TOP_FOO_KEY, fooAugment);
126 private <T extends DataObject> Optional<T> syncReadOptional(final LogicalDatastoreType datastoreType,
127 final InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
128 try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
129 return tx.read(datastoreType, path).get();
133 private <T extends DataObject> T syncRead(final LogicalDatastoreType datastoreType,
134 final InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
135 return syncReadOptional(datastoreType, path).get();