import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import org.junit.After;
-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.MockitoAnnotations;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.renderer.rpcs.DeviceRendererRPCImpl;
import org.opendaylight.transportpce.renderer.rpcs.TransportPCEServicePathRPCImpl;
import org.opendaylight.transportpce.test.AbstractTest;
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
+@ExtendWith(MockitoExtension.class)
public class RendererProviderTest extends AbstractTest {
@Mock
private RendererServiceOperations rendererServiceOperations;
@Mock
DeviceRendererRPCImpl deviceRendererRPC;
- private AutoCloseable closeable;
-
- @Before
- public void openMocks() {
- closeable = MockitoAnnotations.openMocks(this);
- }
@Test
- public void testInitMethodRegistersRendererToRpcService() {
+ void testInitMethodRegistersRendererToRpcService() {
RendererProvider provider =
new RendererProvider(rpcProviderService, deviceRendererRPC, rendererServiceOperations);
provider.init();
verify(rpcProviderService, times(1))
- .registerRpcImplementation(any(), any(TransportPCEServicePathRPCImpl.class));
+ .registerRpcImplementation(any(), any(TransportPCEServicePathRPCImpl.class));
verify(rpcProviderService, times(1))
- .registerRpcImplementation(any(), any(DeviceRendererRPCImpl.class));
- }
-
- @After
- public void releaseMocks() throws Exception {
- closeable.close();
+ .registerRpcImplementation(any(), any(DeviceRendererRPCImpl.class));
}
}
*/
package org.opendaylight.transportpce.renderer;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.RollbackProcessor;
public class RollbackProcessorTest {
@Test
- public void rollbackIfNecessaryTest() throws Exception {
+ void rollbackIfNecessaryTest() throws Exception {
int rolledBack = -1;
RollbackProcessor rollbackProcessor = new RollbackProcessor();
rollbackProcessor.addTask(new TestRollbackTask("task1", false));
rollbackProcessor.addTask(new TestRollbackTask("task2", false));
rolledBack = rollbackProcessor.rollbackAllIfNecessary();
- Assert.assertEquals(0, rolledBack);
+ assertEquals(0, rolledBack);
rollbackProcessor.addTask(new TestRollbackTask("task3", true));
rollbackProcessor.addTask(new TestRollbackTask("task4", false));
rolledBack = rollbackProcessor.rollbackAllIfNecessary();
- Assert.assertEquals(4, rolledBack);
+ assertEquals(4, rolledBack);
rolledBack = rollbackProcessor.rollbackAllIfNecessary();
- Assert.assertEquals(0, rolledBack);
+ assertEquals(0, rolledBack);
}
@Test
- public void rollbackAllTest() throws Exception {
+ void rollbackAllTest() throws Exception {
RollbackProcessor rollbackProcessor = new RollbackProcessor();
rollbackProcessor.addTask(new TestRollbackTask("task1", false));
rollbackProcessor.addTask(new TestRollbackTask("task2", false));
rollbackProcessor.addTask(new TestRollbackTask("task4", false));
int rolledBack = -1;
rolledBack = rollbackProcessor.rollbackAll();
- Assert.assertEquals(4, rolledBack);
+ assertEquals(4, rolledBack);
rolledBack = rollbackProcessor.rollbackAll();
- Assert.assertEquals(0, rolledBack);
+ assertEquals(0, rolledBack);
}
-
-}
+}
\ No newline at end of file
*/
package org.opendaylight.transportpce.renderer.openroadminterface;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+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.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
import java.math.BigDecimal;
import java.util.Arrays;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
public class OpenRoadMInterface221Test extends AbstractTest {
- private final PortMapping portMapping = Mockito.mock(PortMapping.class);
+ private final PortMapping portMapping = mock(PortMapping.class);
private OpenRoadmInterface221 openRoadMInterface221;
private final String nodeId = "node1";
- @Before
- public void setup() {
- OpenRoadmInterfaces openRoadmInterfaces = Mockito.spy(OpenRoadmInterfaces.class);
+ @BeforeEach
+ void setup() {
+ OpenRoadmInterfaces openRoadmInterfaces = spy(OpenRoadmInterfaces.class);
this.openRoadMInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces);
}
@Test
- public void testCreateOpenRoadmEthInterface() throws OpenRoadmInterfaceException {
+ void testCreateOpenRoadmEthInterface() throws OpenRoadmInterfaceException {
String logicalConnPoint = "logicalConnPoint";
- Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint))
+ when(portMapping.getMapping(nodeId, logicalConnPoint))
.thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
.setLogicalConnectionPoint(logicalConnPoint).build());
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint),
- logicalConnPoint + "-ETHERNET");
+ assertEquals(openRoadMInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint),
+ logicalConnPoint + "-ETHERNET");
}
- @Test(expected = Exception.class)
- public void testCreateOpenRoadmEthInterfaceThrowsExcpetion() throws OpenRoadmInterfaceException {
-
- String logicalConnPoint = "logicalConnPoint";
- Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint)).thenReturn(null);
- openRoadMInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
+ @Test
+ void testCreateOpenRoadmEthInterfaceThrowsExcpetion() throws OpenRoadmInterfaceException {
+ when(portMapping.getMapping(eq(nodeId), any())).thenReturn(null);
+ Exception exception = assertThrows(OpenRoadmInterfaceException.class, () -> {
+ openRoadMInterface221.createOpenRoadmEthInterface(nodeId, "logicalConnPoint");
+ });
+ assertEquals(
+ "Unable to get mapping from PortMapping for node node1 and logical connection port logicalConnPoint",
+ exception.getMessage());
}
@Test
- public void testCreateFlexOCH() throws OpenRoadmInterfaceException {
-
+ void testCreateFlexOCH() throws OpenRoadmInterfaceException {
String logicalConnPoint = "logicalConnPoint";
- Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint))
+ when(portMapping.getMapping(nodeId, logicalConnPoint))
.thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
.setLogicalConnectionPoint(logicalConnPoint).build());
SpectrumInformation spectrumInformation = new SpectrumInformation();
spectrumInformation.setLowerSpectralSlotNumber(761);
spectrumInformation.setHigherSpectralSlotNumber(768);
spectrumInformation.setCenterFrequency(BigDecimal.valueOf(195.8));
- Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation));
- Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
- Arrays.asList(logicalConnPoint + "-nmc-761:768"));
+ assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation));
+ assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
+ Arrays.asList(logicalConnPoint + "-nmc-761:768"));
}
@Test
- public void testCreateFlexOCHReturnsMoreThanOneElement() throws OpenRoadmInterfaceException {
+ void testCreateFlexOCHReturnsMoreThanOneElement() throws OpenRoadmInterfaceException {
String logicalConnPoint = "logicalConnPointDEG";
- Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint))
+ when(portMapping.getMapping(nodeId, logicalConnPoint))
.thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
.setLogicalConnectionPoint(logicalConnPoint).build());
SpectrumInformation spectrumInformation = new SpectrumInformation();
spectrumInformation.setCenterFrequency(BigDecimal.valueOf(195.8));
spectrumInformation.setMinFrequency(BigDecimal.valueOf(195.775));
spectrumInformation.setMaxFrequency(BigDecimal.valueOf(195.825));
- Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint,spectrumInformation));
- Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
- Arrays.asList(logicalConnPoint + "-mc-761:768", logicalConnPoint + "-nmc-761:768"));
+ assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint,spectrumInformation));
+ assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
+ Arrays.asList(logicalConnPoint + "-mc-761:768", logicalConnPoint + "-nmc-761:768"));
}
@Test
- public void testCreateOpenRoadmOchInterface() throws OpenRoadmInterfaceException {
-
+ void testCreateOpenRoadmOchInterface() throws OpenRoadmInterfaceException {
String logicalConnPoint = "logicalConnPoint";
- Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint))
- .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
- .setLogicalConnectionPoint(logicalConnPoint).build());
+ when(portMapping.getMapping(nodeId, logicalConnPoint))
+ .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
+ .setLogicalConnectionPoint(logicalConnPoint).build());
SpectrumInformation spectrumInformation = new SpectrumInformation();
spectrumInformation.setWaveLength(Uint32.valueOf(1));
spectrumInformation.setLowerSpectralSlotNumber(761);
spectrumInformation.setHigherSpectralSlotNumber(768);
spectrumInformation.setCenterFrequency(BigDecimal.valueOf(195.8));
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
- spectrumInformation), logicalConnPoint + "-761:768");
+ assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
+ spectrumInformation), logicalConnPoint + "-761:768");
}
@Test
- public void testCreateOpenRoadmOtu4Interface() throws OpenRoadmInterfaceException {
-
+ void testCreateOpenRoadmOtu4Interface() throws OpenRoadmInterfaceException {
String logicalConnPoint = "logicalConnPoint";
String supportOchInterface = "supportOchInterface";
- Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint))
+ when(portMapping.getMapping(nodeId, logicalConnPoint))
.thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
.setLogicalConnectionPoint(logicalConnPoint).build());
- Assert.assertEquals(openRoadMInterface221
- .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface, null, null),
+ assertEquals(
+ openRoadMInterface221.createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface, null,
+ null),
logicalConnPoint + "-OTU");
-
}
@Test
- public void testCreateOpenRoadmOchInterfaceName() {
-
+ void testCreateOpenRoadmOchInterfaceName() {
String logicalConnPoint = "logicalConnPoint";
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterfaceName(logicalConnPoint, "761:768"),
- logicalConnPoint + "-761:768");
-
+ assertEquals(openRoadMInterface221.createOpenRoadmOchInterfaceName(logicalConnPoint, "761:768"),
+ logicalConnPoint + "-761:768");
}
@Test
- public void testCreateOpenRoadmOmsInterfaceSupportingOtsNotNull() throws OpenRoadmInterfaceException {
+ void testCreateOpenRoadmOmsInterfaceSupportingOtsNotNull() throws OpenRoadmInterfaceException {
String logicalConnPoint = "logicalConnPoint";
String supportingOts = "supportingOts";
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmOmsInterface(nodeId,
- new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
- .setLogicalConnectionPoint(logicalConnPoint).setSupportingOts(supportingOts).build()),
- "OMS-" + logicalConnPoint);
+ assertEquals(
+ openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
+ .setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
+ .setLogicalConnectionPoint(logicalConnPoint).setSupportingOts(supportingOts).build()),
+ "OMS-" + logicalConnPoint);
}
@Test
- public void testCreateOpenRoadmOmsInterfaceSupportingOmsNotNullException() throws OpenRoadmInterfaceException {
-
- Assert.assertNull(openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
- .setLogicalConnectionPoint("logicalConnPoint").build()));
+ void testCreateOpenRoadmOmsInterfaceSupportingOmsNotNullException() throws OpenRoadmInterfaceException {
+ assertNull(openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
+ .setLogicalConnectionPoint("logicalConnPoint").build()));
}
@Test
- public void testCreateOpenRoadmOmsInterfaceSupportingOmsNull() throws OpenRoadmInterfaceException {
-
+ void testCreateOpenRoadmOmsInterfaceSupportingOmsNull() throws OpenRoadmInterfaceException {
String supportingOts = "supportingOts";
String logicalConnPoint = "logicalConnPoint";
- Assert.assertEquals(
- openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
- .setLogicalConnectionPoint(logicalConnPoint).setSupportingOts(supportingOts).build()),
- "OMS-" + logicalConnPoint);
+ assertEquals(
+ openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
+ .setLogicalConnectionPoint(logicalConnPoint).setSupportingOts(supportingOts).build()),
+ "OMS-" + logicalConnPoint);
}
-
}
package org.opendaylight.transportpce.renderer.provisiondevice;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
-import org.junit.Assert;
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl221;
private CrossConnectImpl710 crossConnectImpl710;
- private final PortMapping portMapping = Mockito.mock(PortMapping.class);
+ private final PortMapping portMapping = mock(PortMapping.class);
private void setMountPoint(MountPoint mountPoint) {
MountPointService mountPointService = new MountPointServiceStub(mountPoint);
this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
this.mappingUtils = new MappingUtilsImpl(getDataBroker());
- this.mappingUtils = Mockito.spy(MappingUtils.class);
+ this.mappingUtils = spy(MappingUtils.class);
- Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(mappingUtils)
- .getOpenRoadmVersion(Mockito.anyString());
+ doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(mappingUtils).getOpenRoadmVersion(anyString());
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils,
openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710);
- this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces);
+ this.openRoadmInterfaces = spy(this.openRoadmInterfaces);
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces);
this.crossConnectImpl221 = new CrossConnectImpl221(this.deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager, this.mappingUtils,
this.crossConnectImpl121, this.crossConnectImpl221, this.crossConnectImpl710);
- this.crossConnect = Mockito.spy(this.crossConnect);
+ this.crossConnect = spy(this.crossConnect);
this.deviceRendererService = new DeviceRendererServiceImpl(getDataBroker(),
this.deviceTransactionManager, this.openRoadmInterfaceFactory, this.openRoadmInterfaces,
this.crossConnect, portMapping);
}
@Test
- public void testCreateOtsOmsWhenDeviceIsNotMounted() throws OpenRoadmInterfaceException {
+ void testCreateOtsOmsWhenDeviceIsNotMounted() throws OpenRoadmInterfaceException {
setMountPoint(null);
CreateOtsOmsInput input = CreateOtsOmsDataUtils.buildCreateOtsOms();
CreateOtsOmsOutput result = this.deviceRendererService.createOtsOms(input);
- Assert.assertFalse(result.getSuccess());
- Assert.assertEquals("node 1 is not mounted on the controller",
- result.getResult());
+ assertFalse(result.getSuccess());
+ assertEquals("node 1 is not mounted on the controller", result.getResult());
}
@Test
- public void testCreateOtsOmsWhenDeviceIsMountedWithNoMapping() throws OpenRoadmInterfaceException {
+ void testCreateOtsOmsWhenDeviceIsMountedWithNoMapping() throws OpenRoadmInterfaceException {
setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
CreateOtsOmsInput input = CreateOtsOmsDataUtils.buildCreateOtsOms();
CreateOtsOmsOutput result = this.deviceRendererService.createOtsOms(input);
- Assert.assertFalse(result.getSuccess());
+ assertFalse(result.getSuccess());
}
@Test
- public void testCreateOtsOmsWhenDeviceIsMountedWithMapping()
+ void testCreateOtsOmsWhenDeviceIsMountedWithMapping()
throws OpenRoadmInterfaceException, InterruptedException, ExecutionException {
InstanceIdentifier<NodeInfo> nodeInfoIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
new NodesKey("node 1")).child(NodeInfo.class).build();
setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
CreateOtsOmsInput input = CreateOtsOmsDataUtils.buildCreateOtsOms();
Mapping mapping = MountPointUtils.createMapping(input.getNodeId(), input.getLogicalConnectionPoint());
- Mockito.when(portMapping.getMapping(Mockito.anyString(), Mockito.anyString())).thenReturn(mapping);
+ when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
CreateOtsOmsOutput result = this.deviceRendererService.createOtsOms(input);
- Assert.assertTrue(result.getSuccess());
+ assertTrue(result.getSuccess());
}
-
-}
+}
\ No newline at end of file
package org.opendaylight.transportpce.renderer.provisiondevice;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
private DeviceTransactionManager deviceTransactionManager;
private RendererServiceOperationsImpl rendererServiceOperations;
- private final DeviceRendererService deviceRenderer = Mockito.mock(DeviceRendererService.class);
- private final OtnDeviceRendererService otnDeviceRendererService = Mockito.mock(OtnDeviceRendererService.class);
- private final PortMapping portMapping = Mockito.mock(PortMapping.class);
- private final CrossConnect crossConnect = Mockito.mock(CrossConnect.class);
+ private final DeviceRendererService deviceRenderer = mock(DeviceRendererService.class);
+ private final OtnDeviceRendererService otnDeviceRendererService = mock(OtnDeviceRendererService.class);
+ private final PortMapping portMapping = mock(PortMapping.class);
+ private final CrossConnect crossConnect = mock(CrossConnect.class);
private TransportpceOlmService olmService;
private void setMountPoint(MountPoint mountPoint) {
this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
}
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
setMountPoint(new MountPointStub(getDataBroker()));
this.olmService = new OlmServiceStub();
- this.olmService = Mockito.spy(this.olmService);
+ this.olmService = spy(this.olmService);
NotificationPublishService notificationPublishService = new NotificationPublishServiceMock();
this.rendererServiceOperations = new RendererServiceOperationsImpl(deviceRenderer,
otnDeviceRendererService, olmService, getDataBroker(), notificationPublishService, portMapping);
@Test
- public void serviceDeleteOperationPp() throws ExecutionException, InterruptedException, TimeoutException {
+ void serviceDeleteOperationPp() throws ExecutionException, InterruptedException, TimeoutException {
writePathDescription();
ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder();
serviceDeleteInputBuilder.setServiceName("service 1");
serviceDeleteInputBuilder.setServiceHandlerHeader((new ServiceHandlerHeaderBuilder())
.setRequestId("request1").build());
- Mockito.doReturn(Collections.emptyList()).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(),
- Mockito.anyString(), Mockito.eq(false));
+ doReturn(Collections.emptyList())
+ .when(this.crossConnect).deleteCrossConnect(anyString(), anyString(), eq(false));
ServiceAEnd serviceAEnd = new ServiceAEndBuilder()
.setServiceFormat(ServiceFormat.Ethernet)
.setServiceRate(Uint32.valueOf("100"))
.setConnectionType(ConnectionType.Service)
.setServiceAEnd(serviceAEnd)
.build();
- Mockito.when(portMapping.getMapping(Mockito.anyString(), Mockito.anyString()))
- .thenReturn(null);
- Mockito.when(deviceRenderer.deleteServicePath(Mockito.any()))
+ when(portMapping.getMapping(anyString(), anyString())).thenReturn(null);
+ when(deviceRenderer.deleteServicePath(any()))
.thenReturn(new ServicePathOutputBuilder().setSuccess(true).build());
- ServiceDeleteOutput serviceDeleteOutput
- = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build(), service).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK,
- serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
+ ServiceDeleteOutput serviceDeleteOutput = this.rendererServiceOperations
+ .serviceDelete(serviceDeleteInputBuilder.build(), service).get();
+ assertEquals(ResponseCodes.RESPONSE_OK, serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceDeleteOperationNoDescription() throws InterruptedException, ExecutionException {
+ void serviceDeleteOperationNoDescription() throws InterruptedException, ExecutionException {
ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder();
serviceDeleteInputBuilder.setServiceName("service 1");
Services service = new ServicesBuilder()
.setServiceAEnd(new ServiceAEndBuilder()
.setServiceFormat(ServiceFormat.Ethernet)
.setServiceRate(Uint32.valueOf(100))
- .setTxDirection(Map.of(new TxDirectionKey(Uint8.ZERO),
- new TxDirectionBuilder().setIndex(Uint8.ZERO).setPort(new PortBuilder().setPortName("port-name")
- .build()).build()))
+ .setTxDirection(Map.of(
+ new TxDirectionKey(Uint8.ZERO),
+ new TxDirectionBuilder().setIndex(Uint8.ZERO).setPort(new PortBuilder()
+ .setPortName("port-name").build()).build()))
.setNodeId(new NodeIdType("optical-node1"))
.build())
.build();
- Mockito.when(portMapping.getMapping(Mockito.anyString(), Mockito.anyString()))
- .thenReturn(null);
- Mockito.doReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
- .setResult("Failed").build()).buildFuture()).when(this.olmService).servicePowerTurndown(Mockito.any());
+ when(portMapping.getMapping(anyString(), anyString())).thenReturn(null);
+ doReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
+ .setResult("Failed").build()).buildFuture()).when(this.olmService).servicePowerTurndown(any());
ServiceDeleteOutput serviceDeleteOutput
= this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build(), service).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
+ assertEquals(
+ ResponseCodes.RESPONSE_FAILED,
serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
- Mockito.verify(this.crossConnect, Mockito.times(0))
- .deleteCrossConnect(Mockito.any(), Mockito.any(), Mockito.eq(false));
+ verify(this.crossConnect, times(0)).deleteCrossConnect(any(), any(), eq(false));
}
@Test
- public void serviceDeleteOperationTearDownFailedAtoZ() throws ExecutionException, InterruptedException {
- Mockito.doReturn(Collections.emptyList()).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(),
- Mockito.anyString(), Mockito.eq(false));
- Mockito.doReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
- .setResult("Failed").build()).buildFuture()).when(this.olmService).servicePowerTurndown(Mockito.any());
+ void serviceDeleteOperationTearDownFailedAtoZ() throws ExecutionException, InterruptedException {
+ doReturn(Collections.emptyList())
+ .when(this.crossConnect).deleteCrossConnect(anyString(),anyString(), eq(false));
+ doReturn(RpcResultBuilder.success(new ServicePowerTurndownOutputBuilder().setResult("Failed").build())
+ .buildFuture())
+ .when(this.olmService).servicePowerTurndown(any());
writePathDescription();
- ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder();
- serviceDeleteInputBuilder.setServiceName("service 1");
- serviceDeleteInputBuilder.setServiceHandlerHeader((new ServiceHandlerHeaderBuilder())
- .setRequestId("request1").build());
- ServiceAEnd serviceAEnd = new ServiceAEndBuilder()
- .setServiceFormat(ServiceFormat.Ethernet)
- .setServiceRate(Uint32.valueOf("100"))
- .setTxDirection(Map.of(new TxDirectionKey(Uint8.ZERO),
- new TxDirectionBuilder().setIndex(Uint8.ZERO).setPort(new PortBuilder().setPortName("port-name")
- .build()).build()))
- .setNodeId(new NodeIdType("optical-node1"))
- .build();
Services service = new ServicesBuilder()
.setServiceName("service 1")
.setConnectionType(ConnectionType.Service)
- .setServiceAEnd(serviceAEnd)
+ .setServiceAEnd(new ServiceAEndBuilder()
+ .setServiceFormat(ServiceFormat.Ethernet)
+ .setServiceRate(Uint32.valueOf("100"))
+ .setTxDirection(Map.of(
+ new TxDirectionKey(Uint8.ZERO),
+ new TxDirectionBuilder()
+ .setIndex(Uint8.ZERO)
+ .setPort(new PortBuilder().setPortName("port-name").build())
+ .build()))
+ .setNodeId(new NodeIdType("optical-node1"))
+ .build())
.build();
- Mockito.when(portMapping.getMapping(Mockito.anyString(), Mockito.anyString()))
+ when(portMapping.getMapping(anyString(), anyString()))
.thenReturn(null);
- ListenableFuture<ServiceDeleteOutput> serviceDeleteOutput
- = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build(), service);
+ ListenableFuture<ServiceDeleteOutput> serviceDeleteOutput = this.rendererServiceOperations
+ .serviceDelete(
+ new ServiceDeleteInputBuilder()
+ .setServiceName("service 1")
+ .setServiceHandlerHeader((new ServiceHandlerHeaderBuilder()).setRequestId("request1").build())
+ .build(),
+ service);
ServiceDeleteOutput output = serviceDeleteOutput.get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
+ assertEquals(ResponseCodes.RESPONSE_FAILED,
output.getConfigurationResponseCommon().getResponseCode());
- Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node1"), Mockito.any(),
- Mockito.eq(false));
- Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node2"), Mockito.any(),
- Mockito.eq(false));
+ verify(this.crossConnect, times(0)).deleteCrossConnect(eq("node1"), any(), eq(false));
+ verify(this.crossConnect, times(0)).deleteCrossConnect(eq("node2"), any(), eq(false));
}
@Test
- public void serviceDeleteOperationTearDownFailedZtoA() throws ExecutionException, InterruptedException {
- Mockito.doReturn(Collections.emptyList()).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(),
- Mockito.anyString(), Mockito.eq(false));
- Mockito.when(this.olmService.servicePowerTurndown(Mockito.any()))
- .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
- .setResult("Success").build()).buildFuture())
- .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
- .setResult("Failed").build()).buildFuture());
+ void serviceDeleteOperationTearDownFailedZtoA() throws ExecutionException, InterruptedException {
+ doReturn(Collections.emptyList())
+ .when(this.crossConnect).deleteCrossConnect(anyString(), anyString(), eq(false));
+ when(this.olmService.servicePowerTurndown(any()))
+ .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()).setResult("Success").build())
+ .buildFuture())
+ .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()).setResult("Failed").build())
+ .buildFuture());
writePathDescription();
- ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder();
- serviceDeleteInputBuilder.setServiceName("service 1");
- serviceDeleteInputBuilder.setServiceHandlerHeader((new ServiceHandlerHeaderBuilder())
- .setRequestId("request1").build());
- ServiceAEnd serviceAEnd = new ServiceAEndBuilder()
- .setServiceFormat(ServiceFormat.Ethernet)
- .setServiceRate(Uint32.valueOf("100"))
- .setTxDirection(Map.of(new TxDirectionKey(Uint8.ZERO),
- new TxDirectionBuilder().setIndex(Uint8.ZERO).setPort(new PortBuilder().setPortName("port-name")
- .build()).build()))
- .setNodeId(new NodeIdType("optical-node1"))
- .build();
- Services service = new ServicesBuilder()
- .setServiceName("service 1")
- .setConnectionType(ConnectionType.Service)
- .setServiceAEnd(serviceAEnd)
- .build();
- Mockito.when(portMapping.getMapping(Mockito.anyString(), Mockito.anyString()))
+ when(portMapping.getMapping(anyString(), anyString()))
.thenReturn(null);
- ServiceDeleteOutput serviceDeleteOutput =
- this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build(), service).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
+ ServiceDeleteOutput serviceDeleteOutput = this.rendererServiceOperations.serviceDelete(
+ new ServiceDeleteInputBuilder()
+ .setServiceName("service 1")
+ .setServiceHandlerHeader((new ServiceHandlerHeaderBuilder()).setRequestId("request1").build())
+ .build(),
+ new ServicesBuilder()
+ .setServiceName("service 1")
+ .setConnectionType(ConnectionType.Service)
+ .setServiceAEnd(new ServiceAEndBuilder()
+ .setServiceFormat(ServiceFormat.Ethernet)
+ .setServiceRate(Uint32.valueOf("100"))
+ .setTxDirection(Map.of(
+ new TxDirectionKey(Uint8.ZERO),
+ new TxDirectionBuilder()
+ .setIndex(Uint8.ZERO)
+ .setPort(new PortBuilder().setPortName("port-name").build())
+ .build()))
+ .setNodeId(new NodeIdType("optical-node1"))
+ .build())
+ .build())
+ .get();
+ assertEquals(ResponseCodes.RESPONSE_FAILED,
serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
- Mockito.verify(this.olmService, Mockito.times(2)).servicePowerTurndown(Mockito.any());
- Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node1"), Mockito.any(),
- Mockito.eq(false));
- Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node2"), Mockito.any(),
- Mockito.eq(false));
+ verify(this.olmService, times(2)).servicePowerTurndown(any());
+ verify(this.crossConnect, times(0)).deleteCrossConnect(eq("node1"), any(),eq(false));
+ verify(this.crossConnect, times(0)).deleteCrossConnect(eq("node2"), any(),eq(false));
}
private void writePathDescription() throws ExecutionException, InterruptedException {
- ServicePathsBuilder servicePathsBuilder = new ServicePathsBuilder();
- servicePathsBuilder.setPathDescription(ServiceDeleteDataUtils
- .createTransactionPathDescription(StringConstants.PP_TOKEN));
- servicePathsBuilder.setServiceAEnd(ServiceDeleteDataUtils.getServiceAEndBuild().build())
- .setServiceZEnd(ServiceDeleteDataUtils.getServiceZEndBuild().build());
- servicePathsBuilder.withKey(new ServicePathsKey("service 1"));
- servicePathsBuilder.setServiceHandlerHeader(new ServiceHandlerHeaderBuilder().setRequestId("Request 1")
- .build());
- InstanceIdentifier<ServicePaths> servicePathsInstanceIdentifier = InstanceIdentifier.create(
- ServicePathList.class).child(ServicePaths.class, new ServicePathsKey("service 1"));
TransactionUtils.writeTransaction(
- this.deviceTransactionManager,
- "node1" + StringConstants.PP_TOKEN,
- LogicalDatastoreType.OPERATIONAL,
- servicePathsInstanceIdentifier,
- servicePathsBuilder.build());
+ this.deviceTransactionManager,
+ "node1" + StringConstants.PP_TOKEN,
+ LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(ServicePathList.class)
+ .child(ServicePaths.class, new ServicePathsKey("service 1")),
+ new ServicePathsBuilder()
+ .setPathDescription(ServiceDeleteDataUtils
+ .createTransactionPathDescription(StringConstants.PP_TOKEN))
+ .setServiceAEnd(ServiceDeleteDataUtils.getServiceAEndBuild().build())
+ .setServiceZEnd(ServiceDeleteDataUtils.getServiceZEndBuild().build())
+ .withKey(new ServicePathsKey("service 1"))
+ .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder().setRequestId("Request 1").build())
+ .build());
}
-}
+}
\ No newline at end of file
*/
package org.opendaylight.transportpce.renderer.provisiondevice;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
private MountPointService mountPointService;
private DeviceTransactionManager deviceTransactionManager;
- private final DeviceRendererService deviceRenderer = Mockito.mock(DeviceRendererService.class);
- private final OtnDeviceRendererService otnDeviceRendererService = Mockito.mock(OtnDeviceRendererService.class);
- private final PortMapping portMapping = Mockito.mock(PortMapping.class);
+ private final DeviceRendererService deviceRenderer = mock(DeviceRendererService.class);
+ private final OtnDeviceRendererService otnDeviceRendererService = mock(OtnDeviceRendererService.class);
+ private final PortMapping portMapping = mock(PortMapping.class);
private RendererServiceOperationsImpl rendererServiceOperations;
private OpenRoadmInterfaces openRoadmInterfaces;
private TransportpceOlmService olmService;
this.mappingUtils = new MappingUtilsImpl(getDataBroker());
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils,
openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710);
- this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces);
+ this.openRoadmInterfaces = spy(this.openRoadmInterfaces);
}
- @Before
- public void setUp() throws OpenRoadmInterfaceException {
+ @BeforeEach
+ void setUp() throws OpenRoadmInterfaceException {
setMountPoint(new MountPointStub(getDataBroker()));
this.olmService = new OlmServiceStub();
- Mockito.doNothing().when(this.openRoadmInterfaces).postEquipmentState(Mockito.anyString(),
- Mockito.anyString(), Mockito.anyBoolean());
+ doNothing().when(this.openRoadmInterfaces).postEquipmentState(anyString(), anyString(), anyBoolean());
NotificationPublishService notificationPublishService = new NotificationPublishServiceMock();
- this.olmService = Mockito.spy(this.olmService);
- this.rendererServiceOperations = new RendererServiceOperationsImpl(deviceRenderer,
- otnDeviceRendererService, this.olmService, getDataBroker(), notificationPublishService, portMapping);
+ this.olmService = spy(this.olmService);
+ this.rendererServiceOperations = new RendererServiceOperationsImpl(deviceRenderer, otnDeviceRendererService,
+ this.olmService, getDataBroker(), notificationPublishService, portMapping);
}
@Test
- public void serviceImplementationTerminationPointAsResourceTtp() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationTerminationPointAsResourceTtp() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.TTP_TOKEN);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationTerminationPointAsResourceTtp2() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationTerminationPointAsResourceTtp2() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.TTP_TOKEN);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
- Mockito.doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService)
- .servicePowerSetup(Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
+ doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService).servicePowerSetup(any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationTerminationPointAsResourcePp() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationTerminationPointAsResourcePp() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.PP_TOKEN);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationTerminationPointAsResourceNetwork()
- throws InterruptedException, ExecutionException {
-
+ void serviceImplementationTerminationPointAsResourceNetwork() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationTerminationPointAsResourceClient()
- throws InterruptedException, ExecutionException {
-
+ void serviceImplementationTerminationPointAsResourceClient() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.CLIENT_TOKEN);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationTerminationPointAsResourceNoMapping()
- throws InterruptedException, ExecutionException {
-
+ void serviceImplementationTerminationPointAsResourceNoMapping() throws InterruptedException, ExecutionException {
String[] interfaceTokens = {
StringConstants.NETWORK_TOKEN,
StringConstants.CLIENT_TOKEN,
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("failed")
.setSuccess(false);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
for (String tpToken : interfaceTokens) {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(tpToken);
- ServiceImplementationRequestOutput result =
- this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
- result.getConfigurationResponseCommon().getResponseCode());
+ ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input)
+ .get();
+ assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
}
}
@Test
- public void serviceImplementationRollbackAllNecessary() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationRollbackAllNecessary() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
// writePortMapping(input, StringConstants.NETWORK_TOKEN);
- Mockito.doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService)
- .servicePowerSetup(Mockito.any());
+ doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService).servicePowerSetup(any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
-
- }
-
- private GetPmInput createGetPmInput(String nodeId, String tp) {
- GetPmInputBuilder getPmIpBldr = new GetPmInputBuilder();
- getPmIpBldr.setNodeId(nodeId);
- getPmIpBldr.setGranularity(PmGranularity._15min);
- ResourceIdentifierBuilder rsrcBldr = new ResourceIdentifierBuilder();
- rsrcBldr.setResourceName(tp + "-OTU");
- getPmIpBldr.setResourceIdentifier(rsrcBldr.build());
- getPmIpBldr.setResourceType(ResourceTypeEnum.Interface);
- return getPmIpBldr.build();
+ assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceInActive() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationServiceInActive() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
- Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks")
- .setPmparameterValue("1").build();
List<Measurements> measurementsList = new ArrayList<Measurements>();
- measurementsList.add(measurements);
+ measurementsList.add(new MeasurementsBuilder()
+ .setPmparameterName("FECUncorrectableBlocks")
+ .setPmparameterValue("1")
+ .build());
GetPmOutput getPmOutput = new GetPmOutputBuilder()
- .setNodeId("node1").setMeasurements(measurementsList).build();
- Mockito.doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService)
- .getPm(Mockito.any());
+ .setNodeId("node1")
+ .setMeasurements(measurementsList)
+ .build();
+ doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService).getPm(any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceInActive2() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationServiceInActive2() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
- Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks")
- .setPmparameterValue("1").build();
List<Measurements> measurementsList = new ArrayList<Measurements>();
- measurementsList.add(measurements);
+ measurementsList.add(new MeasurementsBuilder()
+ .setPmparameterName("FECUncorrectableBlocks")
+ .setPmparameterValue("1")
+ .build());
GetPmOutput getPmOutput = new GetPmOutputBuilder()
- .setNodeId("node1").setMeasurements(measurementsList).build();
+ .setNodeId("node1")
+ .setMeasurements(measurementsList)
+ .build();
- Mockito.when(this.olmService.getPm(Mockito.any()))
- .thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
+ when(this.olmService.getPm(any())).thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceInActive3() throws InterruptedException, ExecutionException {
-
- Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks")
- .setPmparameterValue("1").build();
+ void serviceImplementationServiceInActive3() throws InterruptedException, ExecutionException {
List<Measurements> measurementsList = new ArrayList<Measurements>();
- measurementsList.add(measurements);
- GetPmOutput getPmOutput = new GetPmOutputBuilder()
- .setNodeId("node1").setMeasurements(measurementsList).build();
- GetPmOutput getPmOutput2 = new GetPmOutputBuilder()
- .setNodeId("node1").setMeasurements(new ArrayList<>()).build();
-
- GetPmInput getPmInputZ = createGetPmInput("XPONDER-2-3",
- StringConstants.NETWORK_TOKEN);
- GetPmInput getPmInputA = createGetPmInput("XPONDER-1-2",
- StringConstants.NETWORK_TOKEN);
-
- Mockito.when(this.olmService.getPm(Mockito.eq(getPmInputZ)))
- .thenReturn(RpcResultBuilder.success(getPmOutput2).buildFuture());
- Mockito.when(this.olmService.getPm(Mockito.eq(getPmInputA)))
- .thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
+ measurementsList.add(new MeasurementsBuilder()
+ .setPmparameterName("FECUncorrectableBlocks")
+ .setPmparameterValue("1")
+ .build());
+ GetPmOutput getPmOutput = new GetPmOutputBuilder().setNodeId("node1").setMeasurements(measurementsList).build();
+ GetPmOutput getPmOutput2 = new GetPmOutputBuilder().setNodeId("node1").setMeasurements(new ArrayList<>())
+ .build();
+
+ GetPmInput getPmInputZ = createGetPmInput("XPONDER-2-3", StringConstants.NETWORK_TOKEN);
+ GetPmInput getPmInputA = createGetPmInput("XPONDER-1-2", StringConstants.NETWORK_TOKEN);
+
+ when(this.olmService.getPm(eq(getPmInputZ))).thenReturn(RpcResultBuilder.success(getPmOutput2).buildFuture());
+ when(this.olmService.getPm(eq(getPmInputA))).thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceActive() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationServiceActive() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
GetPmOutput getPmOutput1 = null;
- Mockito.when(this.olmService.getPm(Mockito.any())).thenReturn(RpcResultBuilder.success(getPmOutput1)
- .buildFuture());
+ when(this.olmService.getPm(any())).thenReturn(RpcResultBuilder.success(getPmOutput1).buildFuture());
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceActive2() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationServiceActive2() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
GetPmOutput getPmOutput = new GetPmOutputBuilder().setMeasurements(new ArrayList<>()).build();
- Mockito.when(this.olmService.getPm(Mockito.any())).thenReturn(RpcResultBuilder.success(getPmOutput)
- .buildFuture());
+ when(this.olmService.getPm(any())).thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceInActive4() throws InterruptedException, ExecutionException {
-
- Measurements measurements = new MeasurementsBuilder().setPmparameterName("preFECCorrectedErrors")
- .setPmparameterValue("1").build();
+ void serviceImplementationServiceInActive4() throws InterruptedException, ExecutionException {
List<Measurements> measurementsList = new ArrayList<Measurements>();
- measurementsList.add(measurements);
+ measurementsList.add(new MeasurementsBuilder()
+ .setPmparameterName("preFECCorrectedErrors")
+ .setPmparameterValue("1")
+ .build());
GetPmOutput getPmOutput = new GetPmOutputBuilder()
- .setNodeId("node1").setMeasurements(measurementsList).build();
+ .setNodeId("node1")
+ .setMeasurements(measurementsList)
+ .build();
- Mockito.doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService)
- .getPm(Mockito.any());
+ doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService).getPm(any());
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
- Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
- Mockito.any());
+ doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(any(), any());
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
-
+ assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
}
@Test
- public void serviceImplementationServiceInActive5() throws InterruptedException, ExecutionException {
-
+ void serviceImplementationServiceInActive5() throws InterruptedException, ExecutionException {
ServiceImplementationRequestInput input = ServiceDataUtils
.buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
- Measurements measurements = new MeasurementsBuilder().setPmparameterName("preFECCorrectedErrors")
- .setPmparameterValue("112000000000d").build();
List<Measurements> measurementsList = new ArrayList<Measurements>();
- measurementsList.add(measurements);
+ measurementsList.add(new MeasurementsBuilder()
+ .setPmparameterName("preFECCorrectedErrors")
+ .setPmparameterValue("112000000000d")
+ .build());
GetPmOutput getPmOutput = new GetPmOutputBuilder()
- .setNodeId("node1").setMeasurements(measurementsList).build();
+ .setNodeId("node1")
+ .setMeasurements(measurementsList)
+ .build();
- Mockito.doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService)
- .getPm(Mockito.any());
+ doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService).getPm(any());
ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
- Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
+ assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
+ }
+ private GetPmInput createGetPmInput(String nodeId, String tp) {
+ return new GetPmInputBuilder()
+ .setNodeId(nodeId)
+ .setGranularity(PmGranularity._15min)
+ .setResourceIdentifier(new ResourceIdentifierBuilder().setResourceName(tp + "-OTU").build())
+ .setResourceType(ResourceTypeEnum.Interface)
+ .build();
}
-}
+}
\ No newline at end of file
*/
package org.opendaylight.transportpce.renderer.rpcs;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.RendererRollbackOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathInput;
+
public class DeviceRendererRPCImplTest extends AbstractTest {
- private final DeviceRendererService deviceRenderer = Mockito.mock(DeviceRendererService.class);
- private final OtnDeviceRendererService otnDeviceRenderer = Mockito.mock(OtnDeviceRendererService.class);
- private final ServicePathInput servicePathInput = Mockito.spy(ServicePathInput.class);
- private final CreateOtsOmsInput createOtsOmsInput = Mockito.mock(CreateOtsOmsInput.class);
- private final RendererRollbackInput rendererRollbackInput = Mockito.mock(RendererRollbackInput.class);
+ private final DeviceRendererService deviceRenderer = mock(DeviceRendererService.class);
+ private final OtnDeviceRendererService otnDeviceRenderer = mock(OtnDeviceRendererService.class);
+ private final ServicePathInput servicePathInput = spy(ServicePathInput.class);
+ private final CreateOtsOmsInput createOtsOmsInput = mock(CreateOtsOmsInput.class);
+ private final RendererRollbackInput rendererRollbackInput = mock(RendererRollbackInput.class);
private DeviceRendererRPCImpl deviceRendererRPC = null;
- @Before
- public void setup() {
-
+ @BeforeEach
+ void setup() {
deviceRendererRPC = new DeviceRendererRPCImpl(deviceRenderer, otnDeviceRenderer);
}
-
@Test
- public void testServicePathCreateOption() {
-
- Mockito.when(servicePathInput.getOperation()).thenReturn(Action.Create);
+ void testServicePathCreateOption() {
+ when(servicePathInput.getOperation()).thenReturn(Action.Create);
deviceRendererRPC.servicePath(servicePathInput);
- Mockito.verify(deviceRenderer, Mockito.times(1)).setupServicePath(servicePathInput, null);
-
+ verify(deviceRenderer, times(1)).setupServicePath(servicePathInput, null);
}
@Test
- public void testServicePathDeleteOption() {
-
- Mockito.when(servicePathInput.getOperation()).thenReturn(Action.Delete);
+ void testServicePathDeleteOption() {
+ when(servicePathInput.getOperation()).thenReturn(Action.Delete);
deviceRendererRPC.servicePath(servicePathInput);
- Mockito.verify(deviceRenderer, Mockito.times(1)).deleteServicePath(servicePathInput);
-
+ verify(deviceRenderer, times(1)).deleteServicePath(servicePathInput);
}
@Test
- public void testRendererRollback() {
- Mockito.when(deviceRenderer.rendererRollback(rendererRollbackInput))
- .thenReturn(new RendererRollbackOutputBuilder().build());
+ void testRendererRollback() {
+ when(deviceRenderer.rendererRollback(rendererRollbackInput))
+ .thenReturn(new RendererRollbackOutputBuilder().build());
deviceRendererRPC.rendererRollback(rendererRollbackInput);
- Mockito.verify(deviceRenderer, Mockito.times(1)).rendererRollback(rendererRollbackInput);
+ verify(deviceRenderer, times(1)).rendererRollback(rendererRollbackInput);
}
@Test
- public void testCreateOtsOms() throws OpenRoadmInterfaceException {
-
- Mockito.when(createOtsOmsInput.getNodeId()).thenReturn("nodeId");
- Mockito.when(createOtsOmsInput.getLogicalConnectionPoint()).thenReturn("logicalConnectionPoint");
- Mockito.when(deviceRenderer.createOtsOms(createOtsOmsInput)).thenReturn(null);
+ void testCreateOtsOms() throws OpenRoadmInterfaceException {
+ when(createOtsOmsInput.getNodeId()).thenReturn("nodeId");
+ when(createOtsOmsInput.getLogicalConnectionPoint()).thenReturn("logicalConnectionPoint");
+ when(deviceRenderer.createOtsOms(createOtsOmsInput)).thenReturn(null);
deviceRendererRPC.createOtsOms(createOtsOmsInput);
- Mockito.verify(deviceRenderer, Mockito.times(1)).createOtsOms(createOtsOmsInput);
-
-
+ verify(deviceRenderer, times(1)).createOtsOms(createOtsOmsInput);
}
@Test
- public void testCreateOtsOmsReturnException() throws OpenRoadmInterfaceException {
-
- Mockito.when(createOtsOmsInput.getNodeId()).thenReturn("nodeId");
- Mockito.when(createOtsOmsInput.getLogicalConnectionPoint()).thenReturn("logicalConnectionPoint");
- Mockito.when(deviceRenderer.createOtsOms(createOtsOmsInput)).thenThrow(OpenRoadmInterfaceException.class);
- Assert.assertNull(deviceRendererRPC.createOtsOms(createOtsOmsInput));
-
-
+ void testCreateOtsOmsReturnException() throws OpenRoadmInterfaceException {
+ when(createOtsOmsInput.getNodeId()).thenReturn("nodeId");
+ when(createOtsOmsInput.getLogicalConnectionPoint()).thenReturn("logicalConnectionPoint");
+ when(deviceRenderer.createOtsOms(createOtsOmsInput)).thenThrow(OpenRoadmInterfaceException.class);
+ assertNull(deviceRendererRPC.createOtsOms(createOtsOmsInput));
}
-
-
}
package org.opendaylight.transportpce.renderer.utils;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
-import org.mockito.Mockito;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.transportpce.test.stub.MountPointStub;
public final class MountPointUtils {
public static MountPointStub getMountPoint(List<Ports> ports, DataBroker dataBroker) {
- RpcConsumerRegistry rpcConsumerRegistry = Mockito.spy(RpcConsumerRegistry.class);
- OrgOpenroadmDeviceService orgOpenroadmDeviceService = Mockito.spy(OrgOpenroadmDeviceService.class);
+ RpcConsumerRegistry rpcConsumerRegistry = spy(RpcConsumerRegistry.class);
+ OrgOpenroadmDeviceService orgOpenroadmDeviceService = spy(OrgOpenroadmDeviceService.class);
GetConnectionPortTrailOutputBuilder getConnectionPortTrailOutputBldr
= new GetConnectionPortTrailOutputBuilder();
getConnectionPortTrailOutputBldr.setPorts(ports);
ListenableFuture<RpcResult<GetConnectionPortTrailOutput>> rpcResultFuture =
RpcResultBuilder.success(getConnectionPortTrailOutputBldr.build()).buildFuture();
- Mockito.doReturn(rpcResultFuture).when(orgOpenroadmDeviceService).getConnectionPortTrail(Mockito.any());
- Mockito.doReturn(orgOpenroadmDeviceService).when(rpcConsumerRegistry).getRpcService(Mockito.any());
+ doReturn(rpcResultFuture).when(orgOpenroadmDeviceService).getConnectionPortTrail(any());
+ doReturn(orgOpenroadmDeviceService).when(rpcConsumerRegistry).getRpcService(any());
MountPointStub mountPoint = new MountPointStub(dataBroker);
mountPoint.setRpcConsumerRegistry(rpcConsumerRegistry);
return mountPoint;
Code Review / transportpce.git / commitdiff