*/
package org.opendaylight.restconf.nb.rfc8040.handlers;
-import java.util.Objects;
+import static java.util.Objects.requireNonNull;
+
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import javax.annotation.PreDestroy;
*/
@Inject
public TransactionChainHandler(final DOMDataBroker dataBroker) {
- this.dataBroker = Objects.requireNonNull(dataBroker);
+ this.dataBroker = requireNonNull(dataBroker);
this.transactionChainList = new ConcurrentLinkedQueue<>();
}
* @param transactionChain object to check.
* @return true if object still exist in {@link TransactionChainHandler}.
*/
- boolean verifyIfExistTransactionChain(DOMTransactionChain transactionChain) {
+ boolean verifyIfExistTransactionChain(final DOMTransactionChain transactionChain) {
return this.transactionChainList.contains(transactionChain);
}
}
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040;
import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfDataService;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
private final SubscribeToStreamUtil streamUtils;
private final SchemaContextHandler schemaContextHandler;
- private final TransactionChainHandler transactionChainHandler;
private final DOMMountPointService mountPointService;
private final DOMActionService actionService;
+ private final DOMDataBroker dataBroker;
public RestconfDataServiceImpl(final SchemaContextHandler schemaContextHandler,
- final TransactionChainHandler transactionChainHandler,
- final DOMMountPointService mountPointService,
+ final DOMDataBroker dataBroker, final DOMMountPointService mountPointService,
final RestconfStreamsSubscriptionService delegRestconfSubscrService,
- final DOMActionService actionService,
- final Configuration configuration) {
- this.actionService = requireNonNull(actionService);
+ final DOMActionService actionService, final Configuration configuration) {
this.schemaContextHandler = requireNonNull(schemaContextHandler);
- this.transactionChainHandler = requireNonNull(transactionChainHandler);
+ this.dataBroker = requireNonNull(dataBroker);
this.mountPointService = requireNonNull(mountPointService);
this.delegRestconfSubscrService = requireNonNull(delegRestconfSubscrService);
+ this.actionService = requireNonNull(actionService);
streamUtils = configuration.isUseSSE() ? SubscribeToStreamUtil.serverSentEvents()
: SubscribeToStreamUtil.webSockets();
}
// FIXME: why is this synchronized?
public synchronized RestconfStrategy getRestconfStrategy(final DOMMountPoint mountPoint) {
if (mountPoint == null) {
- return new MdsalRestconfStrategy(transactionChainHandler);
+ return new MdsalRestconfStrategy(dataBroker);
}
return RestconfStrategy.forMountPoint(mountPoint).orElseThrow(() -> {
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadOperations;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
this.outstanding = total;
}
- static BatchedExistenceCheck start(final DOMTransactionChain transactionChain,
+ static BatchedExistenceCheck start(final DOMDataTreeReadOperations tx,
final LogicalDatastoreType datastore, final YangInstanceIdentifier parentPath,
final Collection<? extends NormalizedNode<?, ?>> children) {
final BatchedExistenceCheck ret = new BatchedExistenceCheck(children.size());
- try (DOMDataTreeReadTransaction tx = transactionChain.newReadOnlyTransaction()) {
- for (NormalizedNode<?, ?> child : children) {
- final YangInstanceIdentifier path = parentPath.node(child.getIdentifier());
- tx.exists(datastore, path).addCallback(new FutureCallback<Boolean>() {
- @Override
- public void onSuccess(final Boolean result) {
- ret.complete(path, result);
- }
-
- @Override
- @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
- public void onFailure(final Throwable throwable) {
- final Exception e;
- if (throwable instanceof Exception) {
- e = (Exception) throwable;
- } else {
- e = new ExecutionException(throwable);
- }
+ for (NormalizedNode<?, ?> child : children) {
+ final YangInstanceIdentifier path = parentPath.node(child.getIdentifier());
+ tx.exists(datastore, path).addCallback(new FutureCallback<Boolean>() {
+ @Override
+ public void onSuccess(final Boolean result) {
+ ret.complete(path, result);
+ }
- ret.complete(path, ReadFailedException.MAPPER.apply(e));
+ @Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
+ public void onFailure(final Throwable throwable) {
+ final Exception e;
+ if (throwable instanceof Exception) {
+ e = (Exception) throwable;
+ } else {
+ e = new ExecutionException(throwable);
}
- }, MoreExecutors.directExecutor());
- }
- return ret;
+
+ ret.complete(path, ReadFailedException.MAPPER.apply(e));
+ }
+ }, MoreExecutors.directExecutor());
}
+ return ret;
}
Entry<YangInstanceIdentifier, ReadFailedException> getFailure() throws InterruptedException {
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @see DOMDataTreeReadWriteTransaction
*/
public final class MdsalRestconfStrategy extends RestconfStrategy {
- private final DOMTransactionChain transactionChain;
+ private final DOMDataBroker dataBroker;
public MdsalRestconfStrategy(final DOMDataBroker dataBroker) {
- this(new TransactionChainHandler(dataBroker));
- }
-
- public MdsalRestconfStrategy(final TransactionChainHandler transactionChainHandler) {
- transactionChain = requireNonNull(transactionChainHandler).get();
+ this.dataBroker = requireNonNull(dataBroker);
}
@Override
public RestconfTransaction prepareWriteExecution() {
- return new MdsalRestconfTransaction(transactionChain);
+ return new MdsalRestconfTransaction(dataBroker);
}
@Override
public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
- try (DOMDataTreeReadTransaction tx = transactionChain.newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
return tx.read(store, path);
}
}
@Override
public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
- try (DOMDataTreeReadTransaction tx = transactionChain.newReadOnlyTransaction()) {
+ try (DOMDataTreeReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
return tx.exists(store, path);
}
}
-
- @Override
- public void close() {
- transactionChain.close();
- }
}
package org.opendaylight.restconf.nb.rfc8040.rests.transactions;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.DeleteDataTransactionUtil.DELETE_TX_TYPE;
import static org.opendaylight.restconf.nb.rfc8040.rests.utils.PostDataTransactionUtil.checkItemDoesNotExists;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.nb.rfc8040.rests.utils.DeleteDataTransactionUtil;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final class MdsalRestconfTransaction extends RestconfTransaction {
- private final DOMTransactionChain transactionChain;
private DOMDataTreeReadWriteTransaction rwTx;
- MdsalRestconfTransaction(DOMTransactionChain transactionChain) {
- this.transactionChain = requireNonNull(transactionChain);
- this.rwTx = transactionChain.newReadWriteTransaction();
+ MdsalRestconfTransaction(final DOMDataBroker dataBroker) {
+ this.rwTx = dataBroker.newReadWriteTransaction();
}
@Override
rwTx.cancel();
rwTx = null;
}
- transactionChain.close();
}
@Override
final Collection<? extends NormalizedNode<?, ?>> children =
((NormalizedNodeContainer<?, ?, ?>) data).getValue();
final BatchedExistenceCheck check =
- BatchedExistenceCheck.start(transactionChain, LogicalDatastoreType.CONFIGURATION, path, children);
+ BatchedExistenceCheck.start(verifyNotNull(rwTx), LogicalDatastoreType.CONFIGURATION, path, children);
for (final NormalizedNode<?, ?> child : children) {
final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
MoreExecutors.directExecutor());
}
- @Override
- public void close() {
- }
-
private static <T> FluentFuture<T> remapException(final ListenableFuture<T> input) {
final SettableFuture<T> ret = SettableFuture.create();
Futures.addCallback(input, new FutureCallback<T>() {
*/
// FIXME: it seems the first three operations deal with lifecycle of a transaction, while others invoke various
// operations. This should be handled through proper allocation indirection.
-public abstract class RestconfStrategy implements AutoCloseable {
+public abstract class RestconfStrategy {
RestconfStrategy() {
// Hidden on purpose
}
* @param fields paths to selected fields relative to parent path
* @return a ListenableFuture containing the result of the read
*/
- public abstract ListenableFuture<Optional<NormalizedNode<?, ?>>> read(LogicalDatastoreType store,
+ public abstract ListenableFuture<Optional<NormalizedNode<?, ?>>> read(LogicalDatastoreType store,
YangInstanceIdentifier path, List<YangInstanceIdentifier> fields);
/**
* @return a FluentFuture containing the result of the check
*/
public abstract FluentFuture<Boolean> exists(LogicalDatastoreType store, YangInstanceIdentifier path);
-
- @Override
- public abstract void close();
}
static <T> void addCallback(final ListenableFuture<T> listenableFuture, final String txType,
final FutureDataFactory<? super T> dataFactory,
@Nullable final RestconfStrategy strategy,
- final YangInstanceIdentifier path)
- throws RestconfDocumentedException {
-
+ final YangInstanceIdentifier path) throws RestconfDocumentedException {
try {
final T result = listenableFuture.get();
dataFactory.setResult(result);
} else {
throw new RestconfDocumentedException("Transaction failed", e);
}
- } finally {
- if (strategy != null) {
- strategy.close();
- }
}
}
}
case RestconfDataServiceConstant.ReadData.ALL:
return readAllData(strategy, path, withDefa, ctx);
default:
- strategy.close();
throw new RestconfDocumentedException(
new RestconfError(RestconfError.ErrorType.PROTOCOL, RestconfError.ErrorTag.INVALID_VALUE,
"Invalid content parameter: " + valueOfContent, null,
case RestconfDataServiceConstant.ReadData.ALL:
return readAllData(strategy, path, withDefa, ctx, fields);
default:
- strategy.close();
throw new RestconfDocumentedException(new RestconfError(RestconfError.ErrorType.PROTOCOL,
RestconfError.ErrorTag.INVALID_VALUE, "Invalid content parameter: " + valueOfContent, null,
"The content parameter value must be either config, nonconfig or all (default)"));
yangTextSourceProvider);
RestconfStreamsSubscriptionService restconfSubscrService = new RestconfStreamsSubscriptionServiceImpl(
dataBroker, notificationService, schemaCtxHandler, transactionChainHandler, configuration);
- RestconfDataService restconfDataService = new RestconfDataServiceImpl(schemaCtxHandler, transactionChainHandler,
+ RestconfDataService restconfDataService = new RestconfDataServiceImpl(schemaCtxHandler, dataBroker,
mountPointService, restconfSubscrService, actionService, configuration);
RestconfInvokeOperationsService restconfInvokeOpsService = new RestconfInvokeOperationsServiceImpl(rpcService,
schemaCtxHandler);
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.CREATE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.DELETE;
import static org.opendaylight.restconf.common.patch.PatchEditOperation.REMOVE;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
import java.util.Optional;
+import java.util.Set;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
private ContainerNode buildPlayerCont;
private ContainerNode buildLibraryCont;
private MapNode buildPlaylistList;
- private TransactionChainHandler transactionChainHandler;
@Mock
private DOMTransactionChain domTransactionChain;
@Mock
private DOMActionService actionService;
@Mock
- private DOMTransactionChain mountTransactionChain;
- @Mock
private RestconfStreamsSubscriptionService delegRestconfSubscrService;
@Mock
private Configuration configuration;
+ @Mock
+ private MultivaluedMap<String, String> queryParamenters;
@Before
public void setUp() throws Exception {
- final MultivaluedMap<String, String> value = Mockito.mock(MultivaluedMap.class);
- Mockito.when(value.entrySet()).thenReturn(new HashSet<>());
- Mockito.when(this.uriInfo.getQueryParameters()).thenReturn(value);
+ doReturn(Set.of()).when(queryParamenters).entrySet();
+ doReturn(queryParamenters).when(this.uriInfo).getQueryParameters();
this.baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
this.containerPlayerQname = QName.create(this.baseQName, "player");
doReturn(CommitInfo.emptyFluentFuture()).when(this.write).commit();
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
- doReturn(this.read).when(domTransactionChain).newReadOnlyTransaction();
- doReturn(this.readWrite).when(domTransactionChain).newReadWriteTransaction();
doReturn(this.write).when(domTransactionChain).newWriteOnlyTransaction();
- DOMDataBroker mockDataBroker = Mockito.mock(DOMDataBroker.class);
- Mockito.doReturn(domTransactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
-
- transactionChainHandler = new TransactionChainHandler(mockDataBroker);
+ DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
+ doReturn(this.read).when(mockDataBroker).newReadOnlyTransaction();
+ doReturn(this.readWrite).when(mockDataBroker).newReadWriteTransaction();
+ doReturn(domTransactionChain).when(mockDataBroker).createTransactionChain(any());
- final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(transactionChainHandler,
- Mockito.mock(DOMSchemaService.class));
+ final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(
+ new TransactionChainHandler(mockDataBroker), mock(DOMSchemaService.class));
schemaContextHandler.onModelContextUpdated(this.contextRef);
- this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler,
- mountPointService, this.delegRestconfSubscrService,
- this.actionService, configuration);
+ this.dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker, mountPointService,
+ this.delegRestconfSubscrService, this.actionService, configuration);
doReturn(Optional.of(this.mountPoint)).when(this.mountPointService)
.getMountPoint(any(YangInstanceIdentifier.class));
doReturn(Optional.of(FixedDOMSchemaService.of(this.contextRef))).when(this.mountPoint)
.getService(DOMSchemaService.class);
doReturn(Optional.of(this.mountDataBroker)).when(this.mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.empty()).when(this.mountPoint).getService(NetconfDataTreeService.class);
- doReturn(this.mountTransactionChain).when(this.mountDataBroker)
- .createTransactionChain(any(DOMTransactionChainListener.class));
- doReturn(this.read).when(this.mountTransactionChain).newReadOnlyTransaction();
- doReturn(this.readWrite).when(this.mountTransactionChain).newReadWriteTransaction();
+ doReturn(this.read).when(this.mountDataBroker).newReadOnlyTransaction();
+ doReturn(this.readWrite).when(this.mountDataBroker).newReadWriteTransaction();
}
@Test
@Test
public void testReadDataConfigTest() {
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
- parameters.put("content", Collections.singletonList("config"));
+ parameters.put("content", List.of("config"));
doReturn(parameters).when(this.uriInfo).getQueryParameters();
doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
@Test
public void testReadDataOperationalTest() {
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
- parameters.put("content", Collections.singletonList("nonconfig"));
+ parameters.put("content", List.of("nonconfig"));
doReturn(parameters).when(this.uriInfo).getQueryParameters();
doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
@Test
public void testPutDataWithMountPoint() {
-// final DOMDataBroker dataBroker = Mockito.mock(DOMDataBroker.class);
-// doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
-// doReturn(this.transactionChainHandler.get()).when(dataBroker)
-// .createTransactionChain(RestConnectorProvider.TRANSACTION_CHAIN_LISTENER);
final InstanceIdentifierContext<DataSchemaNode> iidContext =
new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, mountPoint, this.contextRef);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
doReturn(immediateFalseFluentFuture())
- .when(this.read).exists(LogicalDatastoreType.CONFIGURATION, node);
+ .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(this.uriInfo).getBaseUriBuilder();
@Test
public void testGetRestconfStrategy() {
- final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(
- this.iidBase, this.schemaNode, this.mountPoint, this.contextRef);
-
RestconfStrategy restconfStrategy = this.dataService.getRestconfStrategy(this.mountPoint);
assertTrue(restconfStrategy instanceof MdsalRestconfStrategy);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class DeleteDataTransactionUtilTest {
- @Mock
- private DOMTransactionChain transactionChain;
@Mock
private InstanceIdentifierContext<?> context;
@Mock
@Mock
private NetconfDataTreeService netconfService;
- private TransactionChainHandler transactionChainHandler;
-
@Before
public void init() {
- Mockito.when(this.transactionChain.newReadWriteTransaction()).thenReturn(this.readWrite);
- Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).discardChanges();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
+ doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).discardChanges();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
.delete(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
- Mockito.when(this.context.getInstanceIdentifier()).thenReturn(YangInstanceIdentifier.empty());
-
- Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
- transactionChainHandler = new TransactionChainHandler(mockDataBroker);
+ doReturn(YangInstanceIdentifier.empty()).when(this.context).getInstanceIdentifier();
+ doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
}
/**
@Test
public void deleteData() {
// assert that data to delete exists
- Mockito.when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty()))
+ when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty()))
.thenReturn(immediateTrueFluentFuture());
// test
- delete(new MdsalRestconfStrategy(transactionChainHandler));
+ delete(new MdsalRestconfStrategy(mockDataBroker));
delete(new NetconfRestconfStrategy(netconfService));
}
@Test
public void deleteDataNegativeTest() {
// assert that data to delete does NOT exist
- Mockito.when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty()))
+ when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty()))
.thenReturn(immediateFalseFluentFuture());
final NetconfDocumentedException exception = new NetconfDocumentedException("id",
DocumentedException.ErrorType.RPC, DocumentedException.ErrorTag.from("data-missing"),
ret.setException(new TransactionCommitFailedException(
String.format("Commit of transaction %s failed", this), exception));
- Mockito.when(this.netconfService.commit()).thenAnswer(invocation -> ret);
+ doReturn(ret).when(this.netconfService).commit();
// test and assert error
- deleteFail(new MdsalRestconfStrategy(transactionChainHandler));
+ deleteFail(new MdsalRestconfStrategy(mockDataBroker));
deleteFail(new NetconfRestconfStrategy(netconfService));
}
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.DocumentedException;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
import org.opendaylight.restconf.common.patch.PatchStatusEntity;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
public class PatchDataTransactionUtilTest {
private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
@Mock
- private DOMTransactionChain transactionChain;
- @Mock
private DOMDataTreeReadWriteTransaction rwTransaction;
@Mock
private DOMDataBroker mockDataBroker;
@Mock
private NetconfDataTreeService netconfService;
- private TransactionChainHandler transactionChainHandler;
private EffectiveModelContext refSchemaCtx;
private YangInstanceIdentifier instanceIdContainer;
private YangInstanceIdentifier instanceIdCreateAndDelete;
@Before
public void setUp() throws Exception {
- doReturn(transactionChain).when(mockDataBroker).createTransactionChain(any());
- transactionChainHandler = new TransactionChainHandler(mockDataBroker);
-
this.refSchemaCtx = YangParserTestUtils.parseYangFiles(
TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
final QName baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
.build();
/* Mocks */
- doReturn(this.rwTransaction).when(this.transactionChain).newReadWriteTransaction();
+ doReturn(this.rwTransaction).when(this.mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(this.rwTransaction).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).discardChanges();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
.remove(LogicalDatastoreType.CONFIGURATION, targetNodeMerge);
- patch(patchContext, new MdsalRestconfStrategy(transactionChainHandler), false);
+ patch(patchContext, new MdsalRestconfStrategy(mockDataBroker), false);
patch(patchContext, new NetconfRestconfStrategy(netconfService), false);
}
final InstanceIdentifierContext<? extends SchemaNode> iidContext =
new InstanceIdentifierContext<>(this.instanceIdCreateAndDelete, null, null, this.refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchCD");
- patch(patchContext, new MdsalRestconfStrategy(transactionChainHandler), true);
+ patch(patchContext, new MdsalRestconfStrategy(mockDataBroker), true);
patch(patchContext, new NetconfRestconfStrategy(netconfService), true);
}
ret.setException(new TransactionCommitFailedException(
String.format("Commit of transaction %s failed", this), exception));
- Mockito.when(this.netconfService.commit()).thenAnswer(invocation -> ret);
+ doReturn(ret).when(this.netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
.delete(LogicalDatastoreType.CONFIGURATION, this.targetNodeForCreateAndDelete);
final InstanceIdentifierContext<? extends SchemaNode> iidContext =
new InstanceIdentifierContext<>(this.instanceIdCreateAndDelete, null, null, this.refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchD");
- deleteMdsal(patchContext, new MdsalRestconfStrategy(transactionChainHandler));
+ deleteMdsal(patchContext, new MdsalRestconfStrategy(mockDataBroker));
deleteNetconf(patchContext, new NetconfRestconfStrategy(netconfService));
}
final InstanceIdentifierContext<? extends SchemaNode> iidContext =
new InstanceIdentifierContext<>(this.instanceIdCreateAndDelete, null, null, this.refSchemaCtx);
final PatchContext patchContext = new PatchContext(iidContext, entities, "patchM");
- patch(patchContext, new MdsalRestconfStrategy(transactionChainHandler), false);
+ patch(patchContext, new MdsalRestconfStrategy(mockDataBroker), false);
patch(patchContext, new NetconfRestconfStrategy(netconfService), false);
}
patchStatusContext.getEditCollection().get(0).getEditErrors().get(0).getErrorTag());
}
- private void deleteNetconf(PatchContext patchContext, RestconfStrategy strategy) {
+ private void deleteNetconf(final PatchContext patchContext, final RestconfStrategy strategy) {
final PatchStatusContext patchStatusContext =
PatchDataTransactionUtil.patchData(patchContext, strategy, this.refSchemaCtx);
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
import org.opendaylight.yangtools.yang.common.QName;
public class PlainPatchDataTransactionUtilTest {
private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
@Mock
- private DOMTransactionChain transactionChain;
- @Mock
private DOMDataTreeReadWriteTransaction readWrite;
@Mock
private DOMDataTreeReadTransaction read;
@Mock
private NetconfDataTreeService netconfService;
- private TransactionChainHandler transactionChainHandler;
private LeafNode<?> leafGap;
private ContainerNode jukeboxContainerWithPlayer;
private ContainerNode jukeboxContainerWithPlaylist;
.withChild(listBands)
.build();
- Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
- transactionChainHandler = new TransactionChainHandler(mockDataBroker);
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
}
@Test
new InstanceIdentifierContext<>(this.iidJukebox, this.schemaNodeForJukebox, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.jukeboxContainerWithPlayer);
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
- .merge(any(), any(),any(),any());
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).merge(any(), any(),any(),
+ any());
- PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(transactionChainHandler),
- this.schema);
+ PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), this.schema);
verify(this.readWrite).merge(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
new InstanceIdentifierContext<>(this.iidGap, this.schemaNodeForGap, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.leafGap);
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
.merge(any(), any(), any(), any());
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
- PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(transactionChainHandler),
- this.schema);
+ PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), this.schema);
verify(this.readWrite).merge(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
new InstanceIdentifierContext<>(this.iidJukebox, this.schemaNodeForJukebox, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.jukeboxContainerWithPlaylist);
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
.merge(any(), any(),any(),any());
- PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(transactionChainHandler),
- this.schema);
+ PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), this.schema);
verify(this.readWrite).merge(LogicalDatastoreType.CONFIGURATION, this.iidJukebox, payload.getData());
PlainPatchDataTransactionUtil.patchData(payload, new NetconfRestconfStrategy(netconfService),
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
import org.opendaylight.yangtools.yang.common.QName;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class PostDataTransactionUtilTest {
-
private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
- @Mock
- private DOMTransactionChain transactionChain;
@Mock
private DOMDataTreeReadWriteTransaction readWrite;
@Mock
- private DOMDataTreeReadTransaction read;
- @Mock
private UriInfo uriInfo;
@Mock
private DOMDataBroker mockDataBroker;
@Mock
private NetconfDataTreeService netconfService;
- private TransactionChainHandler transactionChainHandler;
private ContainerNode buildBaseCont;
private EffectiveModelContext schema;
private YangInstanceIdentifier iid2;
.build();
doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/16/")).when(this.uriInfo).getBaseUriBuilder();
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
- Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
- transactionChainHandler = new TransactionChainHandler(mockDataBroker);
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
}
@Test
payload.getData(), Optional.empty());
Response response = PostDataTransactionUtil.postData(this.uriInfo, payload,
- new MdsalRestconfStrategy(transactionChainHandler), this.schema, null, null);
+ new MdsalRestconfStrategy(mockDataBroker), this.schema, null, null);
assertEquals(201, response.getStatus());
verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
final NodeIdentifierWithPredicates identifier = entryNode.getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
- doReturn(read).when(this.transactionChain).newReadOnlyTransaction();
- doReturn(immediateFalseFluentFuture()).when(this.read).exists(LogicalDatastoreType.CONFIGURATION, node);
+ doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService)
LogicalDatastoreType.CONFIGURATION, node, entryNode, Optional.empty());
Response response = PostDataTransactionUtil.postData(this.uriInfo, payload,
- new MdsalRestconfStrategy(transactionChainHandler), this.schema, null, null);
+ new MdsalRestconfStrategy(mockDataBroker), this.schema, null, null);
assertEquals(201, response.getStatus());
assertThat(URLDecoder.decode(response.getLocation().toString(), StandardCharsets.UTF_8),
containsString(identifier.getValue(identifier.keySet().iterator().next()).toString()));
- verify(this.read).exists(LogicalDatastoreType.CONFIGURATION, node);
+ verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
response = PostDataTransactionUtil.postData(this.uriInfo, payload,
try {
PostDataTransactionUtil.postData(this.uriInfo, payload,
- new MdsalRestconfStrategy(transactionChainHandler), this.schema, null, null);
+ new MdsalRestconfStrategy(mockDataBroker), this.schema, null, null);
fail("Expected RestconfDocumentedException");
} catch (final RestconfDocumentedException e) {
assertEquals(1, e.getErrors().size());
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.NormalizedNodeContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
import org.opendaylight.yangtools.yang.common.QName;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class PutDataTransactionUtilTest {
private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
- @Mock
- private DOMTransactionChain transactionChain;
+
@Mock
private DOMDataTreeReadWriteTransaction readWrite;
@Mock
@Mock
private NetconfDataTreeService netconfService;
- private TransactionChainHandler transactionChainHandler;
private LeafNode<?> buildLeaf;
private ContainerNode buildBaseCont;
private ContainerNode buildBaseContWithList;
.withChild(buildList)
.build();
- Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
- transactionChainHandler = new TransactionChainHandler(mockDataBroker);
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
- Mockito.doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock();
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock();
}
@Test
new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
- doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
+ doReturn(this.read).when(this.mockDataBroker).newReadOnlyTransaction();
doReturn(immediateFalseFluentFuture())
.when(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
- PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(transactionChainHandler),
- null, null);
+ PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(mockDataBroker), null, null);
verify(this.read).exists(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier());
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
- doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
+ doReturn(this.read).when(this.mockDataBroker).newReadOnlyTransaction();
doReturn(immediateFalseFluentFuture())
.when(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
- PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(transactionChainHandler),
- null, null);
+ PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(mockDataBroker), null, null);
verify(this.read).exists(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier());
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList);
- doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
- doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction();
+ doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction();
+ doReturn(this.read).when(this.mockDataBroker).newReadOnlyTransaction();
doReturn(immediateFalseFluentFuture())
.when(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
- PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(transactionChainHandler),
- null, null);
+ PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(mockDataBroker), null, null);
verify(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iid2, payload.getData());
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
import com.google.common.collect.ImmutableList;
-import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
-import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.context.WriterParameters;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorTag;
import org.opendaylight.restconf.common.errors.RestconfError.ErrorType;
-import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
@Mock
private NetconfDataTreeService netconfService;
@Mock
- private DOMTransactionChain transactionChain;
- @Mock
private InstanceIdentifierContext<ContainerSchemaNode> context;
@Mock
private DOMDataTreeReadTransaction read;
public void setUp() {
containerChildQName = QName.create("ns", "2016-02-28", "container-child");
- when(transactionChain.newReadOnlyTransaction()).thenReturn(read);
when(context.getSchemaContext()).thenReturn(schemaContext);
when(context.getSchemaNode()).thenReturn(containerSchemaNode);
when(containerSchemaNode.getQName()).thenReturn(NODE_IDENTIFIER.getNodeType());
when(containerChildNode.getQName()).thenReturn(containerChildQName);
when(containerSchemaNode.dataChildByName(containerChildQName)).thenReturn(containerChildNode);
- DOMDataBroker mockDataBroker = Mockito.mock(DOMDataBroker.class);
- Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
- mdsalStrategy = new MdsalRestconfStrategy(new TransactionChainHandler(mockDataBroker));
+ DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
+ doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
+ mdsalStrategy = new MdsalRestconfStrategy(mockDataBroker);
netconfStrategy = new NetconfRestconfStrategy(this.netconfService);
}
*/
@Test
public void parseUriParametersDefaultTest() {
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
// no parameters, default values should be used
*/
@Test
public void parseUriParametersUserDefinedTest() {
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
final String content = "config";
final String depth = "10";
final String fields = containerChildQName.getLocalName();
- parameters.put("content", Collections.singletonList(content));
- parameters.put("depth", Collections.singletonList(depth));
- parameters.put("fields", Collections.singletonList(fields));
+ parameters.put("content", List.of(content));
+ parameters.put("depth", List.of(depth));
+ parameters.put("fields", List.of(fields));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
*/
@Test
public void parseUriParametersContentParameterNegativeTest() {
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
- parameters.put("content", Collections.singletonList("not-allowed-parameter-value"));
+ parameters.put("content", List.of("not-allowed-parameter-value"));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
try {
*/
@Test
public void parseUriParametersDepthParameterNegativeTest() {
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
// inserted value is not allowed
- parameters.put("depth", Collections.singletonList("bounded"));
+ parameters.put("depth", List.of("bounded"));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
try {
*/
@Test
public void parseUriParametersDepthMinimalParameterNegativeTest() {
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
// inserted value is too low
parameters.put(
- "depth", Collections.singletonList(String.valueOf(RestconfDataServiceConstant.ReadData.MIN_DEPTH - 1)));
+ "depth", List.of(String.valueOf(RestconfDataServiceConstant.ReadData.MIN_DEPTH - 1)));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
try {
*/
@Test
public void parseUriParametersDepthMaximalParameterNegativeTest() {
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
// inserted value is too high
parameters.put(
- "depth", Collections.singletonList(String.valueOf(RestconfDataServiceConstant.ReadData.MAX_DEPTH + 1)));
+ "depth", List.of(String.valueOf(RestconfDataServiceConstant.ReadData.MAX_DEPTH + 1)));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
try {
@Test
public void parseUriParametersWithDefaultAndNonTaggedTest() {
// preparation of input data
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
- parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, Collections.singletonList("explicit"));
+ parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, List.of("explicit"));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
@Test
public void parseUriParametersWithDefaultInvalidTest() {
// preparation of input data
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
- parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, Collections.singletonList("invalid"));
+ parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, List.of("invalid"));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
final RestconfDocumentedException ex = assertThrows(RestconfDocumentedException.class,
@Test
public void parseUriParametersWithDefaultAndTaggedTest() {
// preparation of input data
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS,
- Collections.singletonList(ReadData.WithDefaults.REPORT_ALL_TAGGED.value()));
+ List.of(ReadData.WithDefaults.REPORT_ALL_TAGGED.value()));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
@Test
public void parseUriParametersWithDefaultAndReportAllTest() {
// preparation of input data
- final UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ final UriInfo uriInfo = mock(UriInfo.class);
final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS,
- Collections.singletonList(ReadData.WithDefaults.REPORT_ALL.value()));
+ List.of(ReadData.WithDefaults.REPORT_ALL.value()));
when(uriInfo.getQueryParameters()).thenReturn(parameters);
final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo);
Code Review / netconf.git / commitdiff