private static final Logger LOG = LoggerFactory.getLogger(RestConnectorProvider.class);
- private final TransactionChainListener transactionListener = new TransactionChainListener() {
+ public static final TransactionChainListener transactionListener = new TransactionChainListener() {
@Override
public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
final AsyncTransaction<?, ?> transaction, final Throwable cause) {
LOG.warn("TransactionChain({}) {} FAILED!", chain, transaction.getIdentifier(), cause);
- chain.close();
resetTransactionChainForAdapaters(chain);
throw new RestconfDocumentedException("TransactionChain(" + chain + ") not committed correctly", cause);
}
};
private ListenerRegistration<SchemaContextListener> listenerRegistration;
- private DOMDataBroker dataBroker;
- private DOMTransactionChain transactionChain;
+ private static DOMDataBroker dataBroker;
+ private static DOMTransactionChain transactionChain;
@Override
public void onSessionInitiated(final ProviderSession session) {
final DOMMountPointServiceHandler domMountPointServiceHandler = new DOMMountPointServiceHandler(
session.getService(DOMMountPointService.class));
- this.dataBroker = session.getService(DOMDataBroker.class);
- final DOMDataBrokerHandler brokerHandler = new DOMDataBrokerHandler(this.dataBroker);
+ dataBroker = session.getService(DOMDataBroker.class);
+ final DOMDataBrokerHandler brokerHandler = new DOMDataBrokerHandler(dataBroker);
- this.transactionChain = this.dataBroker.createTransactionChain(this.transactionListener);
- final TransactionChainHandler transactionChainHandler = new TransactionChainHandler(this.transactionChain);
+ transactionChain = dataBroker.createTransactionChain(transactionListener);
+ final TransactionChainHandler transactionChainHandler = new TransactionChainHandler(transactionChain);
final DOMRpcService rpcService = session.getService(DOMRpcService.class);
final RpcServiceHandler rpcServiceHandler = new RpcServiceHandler(rpcService);
* @param chain
* - old {@link TransactionChain}
*/
- private void resetTransactionChainForAdapaters(final TransactionChain<?, ?> chain) {
- LOG.trace("Resetting TransactionChain({}) to {}", chain, this.transactionChain);
- this.transactionChain = Preconditions.checkNotNull(this.dataBroker)
- .createTransactionChain(this.transactionListener);
+ public static void resetTransactionChainForAdapaters(final TransactionChain<?, ?> chain) {
+ LOG.trace("Resetting TransactionChain({}) to {}", chain, transactionChain);
+ chain.close();
+ transactionChain = Preconditions.checkNotNull(dataBroker).createTransactionChain(transactionListener);
}
@Override
if (this.listenerRegistration != null) {
this.listenerRegistration.close();
}
- if (this.transactionChain != null) {
- this.transactionChain.close();
+ if (transactionChain != null) {
+ transactionChain.close();
}
}
}
}
@Override
- public NormalizedNodeContext readData(final String identifier, final UriInfo uriInfo) {
+ public Response readData(final String identifier, final UriInfo uriInfo) {
return this.delegRestconfDataService.readData(identifier, uriInfo);
}
@Path("/data/{identifier:.+}")
@Produces({ Draft15.MediaTypes.DATA + RestconfConstants.JSON, Draft15.MediaTypes.DATA, MediaType.APPLICATION_JSON,
MediaType.APPLICATION_XML, MediaType.TEXT_XML })
- NormalizedNodeContext readData(@Encoded @PathParam("identifier") String identifier,
+ Response readData(@Encoded @PathParam("identifier") String identifier,
@Context UriInfo uriInfo);
/**
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
import org.opendaylight.netconf.sal.restconf.impl.PATCHContext;
import org.opendaylight.netconf.sal.restconf.impl.PATCHStatusContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
+import org.opendaylight.restconf.RestConnectorProvider;
import org.opendaylight.restconf.common.references.SchemaContextRef;
import org.opendaylight.restconf.handlers.SchemaContextHandler;
import org.opendaylight.restconf.handlers.TransactionChainHandler;
}
@Override
- public NormalizedNodeContext readData(final String identifier, final UriInfo uriInfo) {
+ public Response readData(final String identifier, final UriInfo uriInfo) {
Preconditions.checkNotNull(identifier);
final SchemaContextRef schemaContextRef = new SchemaContextRef(this.schemaContextHandler.get());
- final InstanceIdentifierContext<?> instanceIdentifier = ParserIdentifier.toInstanceIdentifier(identifier, schemaContextRef.get());
+ final InstanceIdentifierContext<?> instanceIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
+ schemaContextRef.get());
final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint();
final String value = uriInfo.getQueryParameters().getFirst(RestconfDataServiceConstant.CONTENT);
- DOMDataReadWriteTransaction transaction = null;
+ DOMTransactionChain transaction = null;
if (mountPoint == null) {
- transaction = this.transactionChainHandler.get().newReadWriteTransaction();
+ transaction = this.transactionChainHandler.get();
} else {
transaction = transactionOfMountPoint(mountPoint);
}
final TransactionVarsWrapper transactionNode = new TransactionVarsWrapper(instanceIdentifier, mountPoint,
transaction);
final NormalizedNode<?, ?> node = ReadDataTransactionUtil.readData(value, transactionNode);
-
- return new NormalizedNodeContext(instanceIdentifier, node);
+ final SimpleDateFormat dateFormatGmt = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss");
+ dateFormatGmt.setTimeZone(TimeZone.getTimeZone("GMT"));
+ final String etag = '"' + node.getNodeType().getModule().getFormattedRevision()
+ + node.getNodeType().getLocalName() + '"';
+ Response resp = null;
+ if ((value == null) || value.contains(RestconfDataServiceConstant.ReadData.CONFIG)) {
+ resp = Response.status(200).entity(new NormalizedNodeContext(instanceIdentifier, node)).header("ETag", etag)
+ .header("Last-Modified", dateFormatGmt.toString()).build();
+ } else {
+ resp = Response.status(200).entity(new NormalizedNodeContext(instanceIdentifier, node)).build();
+ }
+ return resp;
}
@Override
PutDataTransactionUtil.validateListKeysEqualityInPayloadAndUri(payload);
final DOMMountPoint mountPoint = payload.getInstanceIdentifierContext().getMountPoint();
- DOMDataReadWriteTransaction transaction = null;
+ DOMTransactionChain transaction = null;
SchemaContextRef ref = null;
if (mountPoint == null) {
- transaction = this.transactionChainHandler.get().newReadWriteTransaction();
+ transaction = this.transactionChainHandler.get();
ref = new SchemaContextRef(this.schemaContextHandler.get());
} else {
transaction = transactionOfMountPoint(mountPoint);
Preconditions.checkNotNull(payload);
final DOMMountPoint mountPoint = payload.getInstanceIdentifierContext().getMountPoint();
- DOMDataReadWriteTransaction transaction = null;
+ DOMTransactionChain transaction = null;
SchemaContextRef ref = null;
if (mountPoint == null) {
- transaction = this.transactionChainHandler.get().newReadWriteTransaction();
+ transaction = this.transactionChainHandler.get();
ref = new SchemaContextRef(this.schemaContextHandler.get());
} else {
transaction = transactionOfMountPoint(mountPoint);
schemaContextRef.get());
final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint();
- final DOMDataReadWriteTransaction transaction;
+ final DOMTransactionChain transaction;
if (mountPoint == null) {
- transaction = this.transactionChainHandler.get().newReadWriteTransaction();
+ transaction = this.transactionChainHandler.get();
} else {
transaction = transactionOfMountPoint(mountPoint);
}
Preconditions.checkNotNull(context);
final DOMMountPoint mountPoint = context.getInstanceIdentifierContext().getMountPoint();
- final DOMDataReadWriteTransaction transaction;
+ final DOMTransactionChain transaction;
final SchemaContextRef ref;
if (mountPoint == null) {
- transaction = this.transactionChainHandler.get().newReadWriteTransaction();
+ transaction = this.transactionChainHandler.get();
ref = new SchemaContextRef(this.schemaContextHandler.get());
} else {
transaction = transactionOfMountPoint(mountPoint);
* @param mountPoint
* @return {@link DOMDataReadWriteTransaction}
*/
- private static DOMDataReadWriteTransaction transactionOfMountPoint(final DOMMountPoint mountPoint) {
+ private static DOMTransactionChain transactionOfMountPoint(final DOMMountPoint mountPoint) {
final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
if (domDataBrokerService.isPresent()) {
- return domDataBrokerService.get().newReadWriteTransaction();
+ return domDataBrokerService.get().createTransactionChain(RestConnectorProvider.transactionListener);
} else {
final String errMsg = "DOM data broker service isn't available for mount point "
+ mountPoint.getIdentifier();
package org.opendaylight.restconf.restful.transaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
+import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
/**
private final InstanceIdentifierContext<?> instanceIdentifier;
private final DOMMountPoint mountPoint;
private LogicalDatastoreType configuration = null;
- private final DOMDataReadWriteTransaction transaction;
+ private final DOMTransactionChain transactionChain;
/**
* Set base type of variables, which ones we need for transaction.
* - {@link InstanceIdentifierContext} of data for transaction
* @param mountPoint
* - mount point if is present
- * @param transaction
- * - {@link DOMDataReadWriteTransaction} transaction for
- * operations
+ * @param transactionChain
+ * - transaction chain for creating specific type of transaction
+ * in specific operation
*/
public TransactionVarsWrapper(final InstanceIdentifierContext<?> instanceIdentifier, final DOMMountPoint mountPoint,
- final DOMDataReadWriteTransaction transaction) {
+ final DOMTransactionChain transactionChain) {
this.instanceIdentifier = instanceIdentifier;
this.mountPoint = mountPoint;
- this.transaction = transaction;
+ this.transactionChain = transactionChain;
}
/**
}
/**
- * Get specific type of transaction
+ * Get transaction chain for creating specific transaction for specific
+ * operation
*
- * @return specific type transaction
+ * @return transaction chain
*/
- public DOMDataReadWriteTransaction getTransaction() {
- return this.transaction;
+ public DOMTransactionChain getTransactionChain() {
+ return this.transactionChain;
}
}
*/
public static Response deleteData(final TransactionVarsWrapper transactionNode) {
final CheckedFuture<Void, TransactionCommitFailedException> future = submitData(
- transactionNode.getTransaction(), transactionNode.getInstanceIdentifier().getInstanceIdentifier());
+ transactionNode.getTransactionChain().newReadWriteTransaction(),
+ transactionNode.getInstanceIdentifier().getInstanceIdentifier());
final ResponseFactory response = new ResponseFactory();
FutureCallbackTx.addCallback(future, RestconfDataServiceConstant.DeleteData.DELETE_TX_TYPE, response);
return response.build();
import org.opendaylight.netconf.sal.restconf.impl.RestconfError;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorTag;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorType;
+import org.opendaylight.restconf.RestConnectorProvider;
import org.opendaylight.restconf.common.references.SchemaContextRef;
import org.opendaylight.restconf.restful.transaction.TransactionVarsWrapper;
import org.opendaylight.restconf.restful.utils.RestconfDataServiceConstant.PatchData;
final SchemaContextRef schemaContextRef) {
final List<PATCHStatusEntity> editCollection = new ArrayList<>();
int errorCounter = 0;
+ final DOMDataReadWriteTransaction tx = transactionNode.getTransactionChain().newReadWriteTransaction();
for (final PATCHEntity patchEntity : context.getData()) {
final PATCHEditOperation operation = PATCHEditOperation.valueOf(patchEntity.getOperation().toUpperCase());
if (errorCounter == 0) {
try {
createDataWithinTransaction(LogicalDatastoreType.CONFIGURATION,
- patchEntity.getTargetNode(), patchEntity.getNode(),
- transactionNode.getTransaction(), schemaContextRef);
+ patchEntity.getTargetNode(), patchEntity.getNode(), tx, schemaContextRef);
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(), true, null));
} catch (final RestconfDocumentedException e) {
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(),
case DELETE:
if (errorCounter == 0) {
try {
- deleteDataWithinTransaction(LogicalDatastoreType.CONFIGURATION,
- patchEntity.getTargetNode(), transactionNode.getTransaction());
+ deleteDataWithinTransaction(LogicalDatastoreType.CONFIGURATION, patchEntity.getTargetNode(),
+ tx);
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(), true, null));
} catch (final RestconfDocumentedException e) {
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(),
if (errorCounter == 0) {
try {
mergeDataWithinTransaction(LogicalDatastoreType.CONFIGURATION,
- patchEntity.getTargetNode(), patchEntity.getNode(), transactionNode.getTransaction(),
- schemaContextRef);
+ patchEntity.getTargetNode(), patchEntity.getNode(), tx, schemaContextRef);
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(), true, null));
} catch (final RestconfDocumentedException e) {
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(),
if (errorCounter == 0) {
try {
replaceDataWithinTransaction(LogicalDatastoreType.CONFIGURATION,
- patchEntity.getTargetNode(), patchEntity.getNode(), schemaContextRef,
- transactionNode.getTransaction());
+ patchEntity.getTargetNode(), patchEntity.getNode(), schemaContextRef, tx);
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(), true, null));
} catch (final RestconfDocumentedException e) {
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(),
case REMOVE:
if (errorCounter == 0) {
try {
- removeDataWithinTransaction(LogicalDatastoreType.CONFIGURATION,
- patchEntity.getTargetNode(), transactionNode.getTransaction());
+ removeDataWithinTransaction(LogicalDatastoreType.CONFIGURATION, patchEntity.getTargetNode(),
+ tx);
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(), true, null));
} catch (final RestconfDocumentedException e) {
editCollection.add(new PATCHStatusEntity(patchEntity.getEditId(),
// if no errors then submit transaction, otherwise cancel
if (errorCounter == 0) {
final ResponseFactory response = new ResponseFactory();
- final CheckedFuture<Void, TransactionCommitFailedException> future = transactionNode
- .getTransaction().submit();
+ final CheckedFuture<Void, TransactionCommitFailedException> future = tx.submit();
try {
FutureCallbackTx.addCallback(future, PatchData.PATCH_TX_TYPE, response);
return new PATCHStatusContext(context.getPatchId(), ImmutableList.copyOf(editCollection), true, null);
} else {
- transactionNode.getTransaction().cancel();
+ tx.cancel();
+ RestConnectorProvider.resetTransactionChainForAdapaters(transactionNode.getTransactionChain());
return new PATCHStatusContext(context.getPatchId(), ImmutableList.copyOf(editCollection), false, null);
}
}
private static CheckedFuture<Void, TransactionCommitFailedException> submitData(final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data, final TransactionVarsWrapper transactionNode,
final SchemaContext schemaContext) {
- final DOMDataReadWriteTransaction transaction = transactionNode.getTransaction();
+ final DOMDataReadWriteTransaction transaction = transactionNode.getTransactionChain().newReadWriteTransaction();
final NormalizedNode<?, ?> node = ImmutableNodes.fromInstanceId(schemaContext, path);
transaction.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create(node.getIdentifier()), node);
TransactionUtil.ensureParentsByMerge(path, schemaContext, transaction);
final ResponseFactory responseFactory = new ResponseFactory(
ReadDataTransactionUtil.readData(RestconfDataServiceConstant.ReadData.CONFIG, transactionNode));
final CheckedFuture<Void, TransactionCommitFailedException> submitData = submitData(path, schemaCtxRef.get(),
- transactionNode.getTransaction(), payload.getData());
+ transactionNode.getTransactionChain().newWriteOnlyTransaction(), payload.getData());
FutureCallbackTx.addCallback(submitData, RestconfDataServiceConstant.PutData.PUT_TX_TYPE, responseFactory);
return responseFactory.build();
}
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorType;
import org.opendaylight.restconf.restful.transaction.TransactionVarsWrapper;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
private static NormalizedNode<?, ?> readDataViaTransaction(final TransactionVarsWrapper transactionNode) {
if (transactionNode.getLogicalDatastoreType() != null) {
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> listenableFuture = transactionNode
- .getTransaction().read(transactionNode.getLogicalDatastoreType(),
+ .getTransactionChain().newReadOnlyTransaction().read(transactionNode.getLogicalDatastoreType(),
transactionNode.getInstanceIdentifier().getInstanceIdentifier());
final NormalizedNodeFactory dataFactory = new NormalizedNodeFactory();
FutureCallbackTx.addCallback(listenableFuture, RestconfDataServiceConstant.ReadData.READ_TYPE_TX,
final NormalizedNode<?, ?> configDataNode = readDataViaTransaction(transactionNode);
// if no data exists
- if (stateDataNode == null && configDataNode == null) {
+ if ((stateDataNode == null) && (configDataNode == null)) {
throw new RestconfDocumentedException(
"Request could not be completed because the relevant data model content does not exist",
ErrorType.PROTOCOL,
*/
private static NormalizedNode<?, ?> prepareData(final NormalizedNode<?, ?> configDataNode,
final NormalizedNode<?, ?> stateDataNode) {
- final MapNode immutableStateData = ImmutableNodes.mapNodeBuilder(stateDataNode.getNodeType())
+
+ if (configDataNode instanceof MapNode) { // part for lists mapping
+ final MapNode immutableStateData = ImmutableNodes.mapNodeBuilder(stateDataNode.getNodeType())
.addChild((MapEntryNode) stateDataNode).build();
- final MapNode immutableConfigData = ImmutableNodes.mapNodeBuilder(configDataNode.getNodeType())
+ final MapNode immutableConfigData = ImmutableNodes.mapNodeBuilder(configDataNode.getNodeType())
.addChild((MapEntryNode) configDataNode).build();
-
- final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = ImmutableNodes
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = ImmutableNodes
.mapEntryBuilder();
- mapEntryBuilder.withNodeIdentifier((NodeIdentifierWithPredicates) configDataNode.getIdentifier());
+ mapEntryBuilder.withNodeIdentifier((NodeIdentifierWithPredicates) configDataNode.getIdentifier());
- // MAP CONFIG DATA
- mapDataNode(immutableConfigData, mapEntryBuilder);
- // MAP STATE DATA
- mapDataNode(immutableStateData, mapEntryBuilder);
+ // MAP CONFIG DATA
+ mapDataNode(immutableConfigData, mapEntryBuilder);
+ // MAP STATE DATA
+ mapDataNode(immutableStateData, mapEntryBuilder);
+ return ImmutableNodes.mapNodeBuilder(configDataNode.getNodeType()).addChild(mapEntryBuilder.build()).build();
+ } else if (configDataNode instanceof ContainerNode) { // part for
+ // containers
+ // mapping
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
+ .containerBuilder((ContainerNode) configDataNode);
+ // MAP CONFIG DATA
+ mapCont(containerBuilder, ((ContainerNode) configDataNode).getValue());
+ // MAP STATE DATA
+ mapCont(containerBuilder, ((ContainerNode) stateDataNode).getValue());
- return ImmutableNodes.mapNodeBuilder(configDataNode.getNodeType()).addChild(mapEntryBuilder.build()).build();
+ return containerBuilder.build();
+ } else {
+ throw new RestconfDocumentedException("Bad type of node.");
+ }
+ }
+
+ /**
+ * Map data to builder
+ *
+ * @param containerBuilder
+ * - builder for mapping data
+ * @param childs
+ * - childs of data (container)
+ */
+ private static void mapCont(final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder,
+ final Collection<DataContainerChild<? extends PathArgument, ?>> childs) {
+ for (final DataContainerChild<? extends PathArgument, ?> child : childs) {
+ containerBuilder.addChild(child);
+ }
}
/**
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
-
import com.google.common.util.concurrent.Futures;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorTag;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class DeleteDataTransactionUtilTest {
- @Mock DOMDataReadWriteTransaction transaction;
- @Mock InstanceIdentifierContext<?> context;
+ @Mock
+ private DOMTransactionChain transactionChain;
+ @Mock
+ private InstanceIdentifierContext<?> context;
+ @Mock
+ private DOMDataReadWriteTransaction readWrite;
@Before
public void init() throws Exception {
MockitoAnnotations.initMocks(this);
- Mockito.when(this.transaction.submit()).thenReturn(Futures.immediateCheckedFuture(null));
- Mockito.when(context.getInstanceIdentifier()).thenReturn(YangInstanceIdentifier.EMPTY);
+ Mockito.when(this.transactionChain.newReadWriteTransaction()).thenReturn(this.readWrite);
+ Mockito.when(this.readWrite.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ Mockito.when(this.context.getInstanceIdentifier()).thenReturn(YangInstanceIdentifier.EMPTY);
}
/**
@Test
public void deleteData() throws Exception {
// assert that data to delete exists
- Mockito.when(this.transaction.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY))
+ Mockito.when(this.transactionChain.newReadWriteTransaction().exists(LogicalDatastoreType.CONFIGURATION,
+ YangInstanceIdentifier.EMPTY))
.thenReturn(Futures.immediateCheckedFuture(Boolean.TRUE));
// test
final Response response = DeleteDataTransactionUtil.deleteData(
- new TransactionVarsWrapper(this.context, null, this.transaction));
+ new TransactionVarsWrapper(this.context, null, this.transactionChain));
// assert success
assertEquals("Not expected response received", Status.OK.getStatusCode(), response.getStatus());
@Test
public void deleteDataNegativeTest() throws Exception {
// assert that data to delete does NOT exist
- Mockito.when(this.transaction.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY))
+ Mockito.when(this.transactionChain.newReadWriteTransaction().exists(LogicalDatastoreType.CONFIGURATION,
+ YangInstanceIdentifier.EMPTY))
.thenReturn(Futures.immediateCheckedFuture(Boolean.FALSE));
// test and assert error
try {
- DeleteDataTransactionUtil.deleteData(new TransactionVarsWrapper(this.context, null, this.transaction));
+ DeleteDataTransactionUtil.deleteData(new TransactionVarsWrapper(this.context, null, this.transactionChain));
fail("Delete operation should fail due to missing data");
} catch (final RestconfDocumentedException e) {
assertEquals(ErrorType.PROTOCOL, e.getErrors().get(0).getErrorType());