import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
+import com.google.common.collect.ImmutableMap;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.restconf.api.ApiPath;
+import org.opendaylight.restconf.api.ErrorMessage;
import org.opendaylight.restconf.api.query.ContentParam;
import org.opendaylight.restconf.api.query.WithDefaultsParam;
-import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy.StrategyAndTail;
+import org.opendaylight.restconf.server.api.DataPutResult;
import org.opendaylight.restconf.server.api.DatabindContext;
import org.opendaylight.restconf.server.api.PatchStatusContext;
import org.opendaylight.restconf.server.api.PatchStatusEntity;
+import org.opendaylight.restconf.server.api.ServerException;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.DOMException;
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public final class MdsalRestconfStrategyTest extends AbstractRestconfStrategyTest {
+@ExtendWith(MockitoExtension.class)
+final class MdsalRestconfStrategyTest extends AbstractRestconfStrategyTest {
private static final DatabindContext MODULES_DATABIND = DatabindContext.ofModel(
YangParserTestUtils.parseYangResourceDirectory("/modules"));
@Mock
private NetconfDataTreeService netconfService;
- @Before
- public void before() {
- doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
- }
-
@Override
RestconfStrategy newStrategy(final DatabindContext databind) {
- return new MdsalRestconfStrategy(databind, dataBroker, rpcService, null, null, mountPointService);
+ return new MdsalRestconfStrategy(databind, dataBroker, ImmutableMap.of(), rpcService, null, null,
+ mountPointService);
}
private @NonNull RestconfStrategy modulesStrategy() {
@Override
RestconfStrategy testDeleteDataStrategy() {
// assert that data to delete exists
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
+ doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of()))
.thenReturn(immediateTrueFluentFuture());
return jukeboxStrategy();
@Override
RestconfStrategy testNegativeDeleteDataStrategy() {
// assert that data to delete does NOT exist
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
when(readWrite.exists(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of()))
.thenReturn(immediateFalseFluentFuture());
return jukeboxStrategy();
@Override
RestconfStrategy testPostListDataStrategy(final MapEntryNode entryNode, final YangInstanceIdentifier node) {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
@Override
RestconfStrategy testPostDataFailStrategy(final DOMException domException) {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
doReturn(immediateFailedFluentFuture(domException)).when(readWrite).commit();
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
}
@Test
- public void testPutContainerData() {
+ void testPutContainerData() {
doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(read).when(dataBroker).newReadOnlyTransaction();
doReturn(immediateFalseFluentFuture()).when(read).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- jukeboxStrategy().putData(JUKEBOX_IID, EMPTY_JUKEBOX, null);
+ jukeboxStrategy().putData(dataPutRequest, JUKEBOX_IID, EMPTY_JUKEBOX, null);
verify(read).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
+ verify(dataPutRequest).completeWith(any(DataPutResult.class));
}
@Test
- public void testPutLeafData() {
+ void testPutLeafData() {
doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(read).when(dataBroker).newReadOnlyTransaction();
doReturn(immediateFalseFluentFuture()).when(read).exists(LogicalDatastoreType.CONFIGURATION, GAP_IID);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- jukeboxStrategy().putData(GAP_IID, GAP_LEAF, null);
+ jukeboxStrategy().putData(dataPutRequest, GAP_IID, GAP_LEAF, null);
verify(read).exists(LogicalDatastoreType.CONFIGURATION, GAP_IID);
verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, GAP_IID, GAP_LEAF);
+ verify(dataPutRequest).completeWith(any(DataPutResult.class));
}
-
@Test
- public void testPutListData() {
+ void testPutListData() {
doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(read).when(dataBroker).newReadOnlyTransaction();
doReturn(immediateFalseFluentFuture())
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
- jukeboxStrategy().putData(JUKEBOX_IID, JUKEBOX_WITH_BANDS, null);
+ jukeboxStrategy().putData(dataPutRequest, JUKEBOX_IID, JUKEBOX_WITH_BANDS, null);
verify(read).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, JUKEBOX_WITH_BANDS);
+ verify(dataPutRequest).completeWith(any(DataPutResult.class));
}
@Override
RestconfStrategy testPostContainerDataStrategy() {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, JUKEBOX_IID, EMPTY_JUKEBOX);
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
@Override
RestconfStrategy testPatchDataReplaceMergeAndRemoveStrategy() {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
+ doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
return jukeboxStrategy();
}
@Override
RestconfStrategy testPatchDataCreateAndDeleteStrategy() {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
+ doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, PLAYER_IID);
doReturn(immediateTrueFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION,
CREATE_AND_DELETE_TARGET);
@Override
RestconfStrategy testPatchMergePutContainerStrategy() {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
+ doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
return jukeboxStrategy();
}
@Override
RestconfStrategy deleteNonexistentDataTestStrategy() {
+ doReturn(readWrite).when(dataBroker).newReadWriteTransaction();
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION,
CREATE_AND_DELETE_TARGET);
return jukeboxStrategy();
final var editErrors = edit.getEditErrors();
assertEquals(1, editErrors.size());
final var editError = editErrors.get(0);
- assertEquals("Data does not exist", editError.getErrorMessage());
- assertEquals(ErrorType.PROTOCOL, editError.getErrorType());
- assertEquals(ErrorTag.DATA_MISSING, editError.getErrorTag());
+ assertEquals(new ErrorMessage("Data does not exist"), editError.message());
+ assertEquals(ErrorType.PROTOCOL, editError.type());
+ assertEquals(ErrorTag.DATA_MISSING, editError.tag());
}
@Override
}
@Test
- public void readLeafWithDefaultParameters() {
+ void readLeafWithDefaultParameters() {
final var data = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new NodeIdentifier(CONT_QNAME))
.withChild(ImmutableNodes.leafNode(QName.create(BASE, "exampleLeaf"), "i am leaf"))
}
@Test
- public void readContainerWithDefaultParameters() {
+ void readContainerWithDefaultParameters() {
final var exampleList = new NodeIdentifier(QName.create(BASE, "exampleList"));
final var data = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new NodeIdentifier(CONT_QNAME))
}
@Test
- public void readLeafInListWithDefaultParameters() {
+ void readLeafInListWithDefaultParameters() {
final var exampleList = new NodeIdentifier(QName.create(BASE, "exampleList"));
final var content = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new NodeIdentifier(CONT_QNAME))
}
@Test
- public void testGetRestconfStrategyLocal() {
+ void testGetRestconfStrategyLocal() throws Exception {
final var strategy = jukeboxStrategy();
assertEquals(new StrategyAndTail(strategy, ApiPath.empty()), strategy.resolveStrategy(ApiPath.empty()));
}
@Test
- public void testGetRestconfStrategyMountDataBroker() throws Exception {
+ void testGetRestconfStrategyMountDataBroker() throws Exception {
doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
}
@Test
- public void testGetRestconfStrategyMountNetconfService() throws Exception {
+ void testGetRestconfStrategyMountNetconfService() throws Exception {
doReturn(Optional.of(netconfService)).when(mountPoint).getService(NetconfDataTreeService.class);
doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
doReturn(Optional.of(new FixedDOMSchemaService(JUKEBOX_SCHEMA))).when(mountPoint)
}
@Test
- public void testGetRestconfStrategyMountNone() throws Exception {
+ void testGetRestconfStrategyMountNone() throws Exception {
doReturn(JUKEBOX_IID).when(mountPoint).getIdentifier();
doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
doReturn(Optional.empty()).when(mountPoint).getService(DOMDataBroker.class);
final var strategy = jukeboxStrategy();
final var mountPath = ApiPath.parse("yang-ext:mount");
- final var ex = assertThrows(RestconfDocumentedException.class, () -> strategy.resolveStrategy(mountPath));
- final var errors = ex.getErrors();
+ final var errors = assertThrows(ServerException.class, () -> strategy.resolveStrategy(mountPath)).errors();
assertEquals(1, errors.size());
final var error = errors.get(0);
- assertEquals(ErrorType.APPLICATION, error.getErrorType());
- assertEquals(ErrorTag.OPERATION_FAILED, error.getErrorTag());
- assertEquals("Could not find a supported access interface in mount point", error.getErrorMessage());
- assertEquals(JUKEBOX_IID, error.getErrorPath());
+ assertEquals(ErrorType.APPLICATION, error.type());
+ assertEquals(ErrorTag.OPERATION_FAILED, error.tag());
+ assertEquals(new ErrorMessage("Could not find a supported access interface in mount point"), error.message());
+ final var path = error.path();
+ assertNotNull(path);
+ assertEquals(JUKEBOX_IID, path.path());
}
}
Code Review / netconf.git / blobdiff