package org.opendaylight.transportpce.olm;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.MountPointService;
private PortMappingVersion221 portMappingVersion22;
private PortMappingVersion121 portMappingVersion121;
- @Before
+ @BeforeEach
public void setUp() {
this.mountPoint = new MountPointStub(getDataBroker());
this.mountPointService = new MountPointServiceStub(mountPoint);
GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput();
//TODO
// ListenableFuture<RpcResult<GetPmOutput>> output = this.olmPowerServiceRpc.getPm(input);
-// Assert.assertEquals(new GetPmOutputBuilder().build(), output.get().getResult());
-// Assert.assertEquals(null, output.get().getResult().getResourceId());
-// Assert.assertEquals(null, output.get().getResult().getMeasurements());
-// Assert.assertEquals(null, output.get().getResult().getGranularity());
-// Assert.assertEquals(null, output.get().getResult().getNodeId());
-// Assert.assertEquals(null, output.get().getResult().getResourceIdentifier());
-// Assert.assertEquals(null, output.get().getResult().getResourceType());
+// assertEquals(new GetPmOutputBuilder().build(), output.get().getResult());
+// assertEquals(null, output.get().getResult().getResourceId());
+// assertEquals(null, output.get().getResult().getMeasurements());
+// assertEquals(null, output.get().getResult().getGranularity());
+// assertEquals(null, output.get().getResult().getNodeId());
+// assertEquals(null, output.get().getResult().getResourceIdentifier());
+// assertEquals(null, output.get().getResult().getResourceType());
}
@Test
ListenableFuture<RpcResult<GetPmOutput>> output = this.olmPowerServiceRpc.getPm(input);
//TODO
-// Assert.assertEquals(new GetPmOutputBuilder().build(), output.get().getResult());
-// Assert.assertEquals(null, output.get().getResult().getResourceId());
+// assertEquals(new GetPmOutputBuilder().build(), output.get().getResult());
+// assertEquals(null, output.get().getResult().getResourceId());
}
// @Test
//
// Mockito.doReturn(pmOutputBuilder.build()).when(this.olmPowerService).getPm(Mockito.any());
// ListenableFuture<RpcResult<GetPmOutput>> output = this.olmPowerServiceRpc.getPm(input);
-// Assert.assertEquals(pmOutputBuilder.build(), output.get().getResult());
-// Assert.assertEquals(true, output.get().isSuccessful());
+// assertEquals(pmOutputBuilder.build(), output.get().getResult());
+// assertEquals(true, output.get().isSuccessful());
// }
@Test
GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput();
ListenableFuture<RpcResult<GetPmOutput>> output = this.olmPowerServiceRpc.getPm(input);
//TODO
-// Assert.assertEquals(new GetPmOutputBuilder().build(), output.get().getResult());
-// Assert.assertEquals(null, output.get().getResult().getResourceId());
-// Assert.assertEquals(null, output.get().getResult().getMeasurements());
-// Assert.assertEquals(null, output.get().getResult().getGranularity());
-// Assert.assertEquals(null, output.get().getResult().getNodeId());
-// Assert.assertEquals(null, output.get().getResult().getResourceIdentifier());
-// Assert.assertEquals(null, output.get().getResult().getResourceType());
+// assertEquals(new GetPmOutputBuilder().build(), output.get().getResult());
+// assertEquals(null, output.get().getResult().getResourceId());
+// assertEquals(null, output.get().getResult().getMeasurements());
+// assertEquals(null, output.get().getResult().getGranularity());
+// assertEquals(null, output.get().getResult().getNodeId());
+// assertEquals(null, output.get().getResult().getResourceIdentifier());
+// assertEquals(null, output.get().getResult().getResourceType());
}
@Test
.thenReturn(RpcResultBuilder.success(new ServicePowerSetupOutputBuilder()
.setResult("Success").build()).buildFuture());
ListenableFuture<RpcResult<ServicePowerSetupOutput>> output = this.olmPowerServiceRpc.servicePowerSetup(input);
- Assert.assertEquals(new ServicePowerSetupOutputBuilder().setResult("Success").build(), output.get()
+ assertEquals(new ServicePowerSetupOutputBuilder().setResult("Success").build(), output.get()
.getResult());
- Assert.assertEquals("Success", output.get().getResult().getResult());
- Assert.assertEquals(true, output.get().isSuccessful());
+ assertEquals("Success", output.get().getResult().getResult());
+ assertEquals(true, output.get().isSuccessful());
}
.setResult("Success").build()).buildFuture());
ListenableFuture<RpcResult<ServicePowerTurndownOutput>> output = this.olmPowerServiceRpc
.servicePowerTurndown(input);
- Assert.assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Success").build(), output.get()
+ assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Success").build(), output.get()
.getResult());
- Assert.assertEquals("Success", output.get().getResult().getResult());
- Assert.assertEquals(true, output.get().isSuccessful());
+ assertEquals("Success", output.get().getResult().getResult());
+ assertEquals(true, output.get().isSuccessful());
}
/*
.setResult("Failed").build()).buildFuture());
ListenableFuture<RpcResult<CalculateSpanlossBaseOutput>> output = this.olmPowerServiceRpc
.calculateSpanlossBase(input);
- Assert.assertEquals(new CalculateSpanlossBaseOutputBuilder().setResult("Failed").build(),
+ assertEquals(new CalculateSpanlossBaseOutputBuilder().setResult("Failed").build(),
output.get().getResult());
- Assert.assertEquals("Failed", output.get().getResult().getResult());
- Assert.assertEquals(true, output.get().isSuccessful());
+ assertEquals("Failed", output.get().getResult().getResult());
+ assertEquals(true, output.get().isSuccessful());
}*/
//TODO
.setResult("success").build()).buildFuture());
ListenableFuture<RpcResult<CalculateSpanlossCurrentOutput>> output = this.olmPowerServiceRpc
.calculateSpanlossCurrent(input);
- Assert.assertEquals(null, output.get().getResult());
- Assert.assertEquals(true, output.get().isSuccessful());
+ assertEquals(null, output.get().getResult());
+ assertEquals(true, output.get().isSuccessful());
}
@Test
.setResult(null).build()).buildFuture());
ListenableFuture<RpcResult<ServicePowerResetOutput>> output = this.olmPowerServiceRpc
.servicePowerReset(input);
- Assert.assertEquals(null, output.get().getResult());
- Assert.assertEquals(true, output.get().isSuccessful());
+ assertEquals(null, output.get().getResult());
+ assertEquals(true, output.get().isSuccessful());
}
**/
}
package org.opendaylight.transportpce.olm.power;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.OtsBuilder;
import org.opendaylight.yangtools.yang.common.Decimal64;
-@Ignore
+@Disabled
public class PowerMgmtPowerMockTest extends AbstractTest {
private MountPoint mountPoint;
private PortMappingVersion221 portMappingVersion22;
private PortMappingVersion121 portMappingVersion121;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
this.mountPoint = new MountPointStub(getDataBroker());
this.mountPointService = new MountPointServiceStub(mountPoint);
this.mappingUtils = new MappingUtilsImpl(getDataBroker());
}
@Test
- public void testSetPowerMockingUtil() {
+ void testSetPowerMockingUtil() {
Mockito.mockStatic(OlmUtils.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(getXpdrNodesFromNodesBuilderDeg());
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput2();
boolean output = this.powerMgmt.setPower(input);
- Assert.assertEquals(false, output);
+ assertEquals(false, output);
}
@Test
- public void testSetPowerMockingUtilNetwokType() throws OpenRoadmInterfaceException {
+ void testSetPowerMockingUtilNetwokType() throws OpenRoadmInterfaceException {
Mockito.mockStatic(OlmUtils.class);
Mockito.mockStatic(PowerMgmtVersion121.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(Optional.empty());
PowerMgmtImpl powerMgmtImpl = getNewPowerMgmt(openRoadmInterfacesImpl121Spy,this.crossConnect);
boolean output = powerMgmtImpl.setPower(input);
- Assert.assertEquals(true, output);
+ assertEquals(true, output);
}
@Test
- public void testSetPowerMockingUtilNetwokTypeMoreThanOneNode() throws OpenRoadmInterfaceException {
+ void testSetPowerMockingUtilNetwokTypeMoreThanOneNode() throws OpenRoadmInterfaceException {
Mockito.mockStatic(OlmUtils.class);
Mockito.mockStatic(PowerMgmtVersion121.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(Optional.empty());
PowerMgmtImpl powerMgmtImpl = getNewPowerMgmt(openRoadmInterfacesImpl121Spy,this.crossConnect);
boolean output = powerMgmtImpl.setPower(input);
- Assert.assertEquals(true, output);
+ assertEquals(true, output);
}
@Test
- public void testSetPowerXpdrNodes() {
+ void testSetPowerXpdrNodes() {
Mockito.mockStatic(OlmUtils.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(getXpdrNodesFromNodesBuilderDeg());
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput3();
boolean output = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, output);
+ assertEquals(true, output);
}
@Test
- public void testSetPowerRdmNodesReturnInterfaceEmpty() throws OpenRoadmInterfaceException {
+ void testSetPowerRdmNodesReturnInterfaceEmpty() throws OpenRoadmInterfaceException {
Mockito.mockStatic(OlmUtils.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(getRdmNodesFromNodesBuilder());
.thenReturn(Optional.empty());
PowerMgmtImpl powerMgmtImpl = getNewPowerMgmt(openRoadmInterfacesImpl121Spy,this.crossConnect);
boolean output = powerMgmtImpl.setPower(input);
- Assert.assertEquals(false, output);
+ assertEquals(false, output);
}
@Test
- public void testSetPowerRdmNodesThrowsException() throws OpenRoadmInterfaceException {
+ void testSetPowerRdmNodesThrowsException() throws OpenRoadmInterfaceException {
Mockito.mockStatic(OlmUtils.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(getRdmNodesFromNodesBuilder());
.thenThrow(new OpenRoadmInterfaceException("error thrown by unit tests "));
PowerMgmtImpl powerMgmtImpl = getNewPowerMgmt(openRoadmInterfacesImpl121Spy,this.crossConnect);
boolean output = powerMgmtImpl.setPower(input);
- Assert.assertEquals(false, output);
+ assertEquals(false, output);
}
@Test
- public void testSetPowerRdmNodesReturnInterface() throws OpenRoadmInterfaceException {
+ void testSetPowerRdmNodesReturnInterface() throws OpenRoadmInterfaceException {
Mockito.mockStatic(OlmUtils.class);
Mockito.when(this.portMapping.getNode(Mockito.anyString()))
.thenReturn(getRdmNodesFromNodesBuilder());
Mockito.anyString())).thenReturn(true);
PowerMgmtImpl powerMgmtImpl = getNewPowerMgmt(openRoadmInterfacesImpl121Spy,crossConnectMock);
boolean output = powerMgmtImpl.setPower(input);
- Assert.assertEquals(true, output);
+ assertEquals(true, output);
}
private PowerMgmtImpl getNewPowerMgmt(OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121Spy,
package org.opendaylight.transportpce.olm.power;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import java.util.List;
import java.util.Map;
import java.util.Optional;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.opendaylight.mdsal.binding.api.DataBroker;
private PortMapping portMapping;
private PowerMgmt powerMgmt;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
this.dataBroker = Mockito.mock(DataBroker.class);
this.openRoadmInterfaces = Mockito.mock(OpenRoadmInterfaces.class);
this.crossConnect = Mockito.mock((CrossConnectImpl.class));
}
@Test
- public void testSetPowerWhenMappingReturnNull() {
+ void testSetPowerWhenMappingReturnNull() {
Mockito.when(this.portMapping.getNode(Mockito.anyString())).thenReturn(null);
boolean output = this.powerMgmt.setPower(OlmPowerServiceRpcImplUtil.getServicePowerSetupInput());
- Assert.assertEquals(false, output);
+ assertEquals(false, output);
}
@Test
- public void testSetPowerForTransponderAEnd() throws OpenRoadmInterfaceException {
+ void testSetPowerForTransponderAEnd() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("xpdr-A"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
List.of("network-A")));
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
}
@Test
- public void testSetPowerForTransponderZEnd() throws OpenRoadmInterfaceException {
+ void testSetPowerForTransponderZEnd() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("xpdr-C"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-C", OpenroadmNodeVersion._121,
List.of("client-C")));
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
.getServicePowerSetupInputForOneNode("xpdr-C", "network-C", "client-C");
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
}
@Test
- public void testSetPowerForRoadmAEnd() throws OpenRoadmInterfaceException {
+ void testSetPowerForRoadmAEnd() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("roadm-A"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
List.of("srg1-A", "deg2-A")));
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
.getServicePowerSetupInputForOneNode("roadm-A", "srg1-A", "deg2-A");
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
Mockito.matches(OpticalControlMode.Power.getName()), eq(Decimal64.valueOf("-3.00")),
Mockito.matches("srg1-A-deg2-A-761:768"));
}
@Test
- public void testSetPowerForRoadmZEnd() throws OpenRoadmInterfaceException {
+ void testSetPowerForRoadmZEnd() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("roadm-C"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-C", OpenroadmNodeVersion._121,
List.of("deg1-C", "srg1-C")));
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
.getServicePowerSetupInputForOneNode("roadm-C", "deg1-C", "srg1-C");
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-C"),
Mockito.matches(OpticalControlMode.Power.getName()), Mockito.isNull(),
Mockito.matches("deg1-C-srg1-C-761:768"));
}
@Test
- public void testSetPowerForTransponderWhenNoTransponderPort() throws OpenRoadmInterfaceException {
+ void testSetPowerForTransponderWhenNoTransponderPort() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("xpdr-A"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
List.of("network-A")));
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
pmv121.verify(() -> PowerMgmtVersion121.setTransponderPower(Mockito.matches("xpdr-A"),
Mockito.anyString(), eq(new BigDecimal("-5")), Mockito.any(), Mockito.any()));
verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
}
@Test
- public void testSetPowerForTransponderAEndWithRoadmPort() throws OpenRoadmInterfaceException {
+ void testSetPowerForTransponderAEndWithRoadmPort() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("xpdr-A"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
List.of("network-A")));
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
pmv121.verify(() -> PowerMgmtVersion121.setTransponderPower(Mockito.matches("xpdr-A"),
Mockito.anyString(), eq(new BigDecimal("-4.20000000000000017763568394002504646778106689453125")),
Mockito.any(), Mockito.any()));
}
@Test
- public void testSetPowerWithoutNode() {
+ void testSetPowerWithoutNode() {
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputWthoutNode();
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(false, result);
+ assertEquals(false, result);
verifyNoInteractions(this.crossConnect);
}
@Test
- public void testSetPowerForBadNodeType() throws OpenRoadmInterfaceException {
+ void testSetPowerForBadNodeType() throws OpenRoadmInterfaceException {
Mockito.when(this.portMapping.getNode("ila node"))
.thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeIla());
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
.getServicePowerSetupInputForOneNode("ila node", "rx-port", "tx-port");
boolean result = this.powerMgmt.setPower(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
verifyNoInteractions(this.crossConnect);
verifyNoInteractions(this.openRoadmInterfaces);
}
@Test
- public void testPowerTurnDownWhenSuccess() {
+ void testPowerTurnDownWhenSuccess() {
Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
Mockito.anyString()))
.thenReturn(true);
ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
boolean result = this.powerMgmt.powerTurnDown(input);
- Assert.assertEquals(true, result);
+ assertEquals(true, result);
verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-C"),
Mockito.matches(OpticalControlMode.Off.getName()), Mockito.isNull(), Mockito.anyString());
verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
}
@Test
- public void testPowerTurnDownWhenFailure() {
+ void testPowerTurnDownWhenFailure() {
Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
Mockito.anyString()))
.thenReturn(false);
ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
boolean result = this.powerMgmt.powerTurnDown(input);
- Assert.assertEquals(false, result);
+ assertEquals(false, result);
verify(this.crossConnect, times(2))
.setPowerLevel(Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.anyString());
}
package org.opendaylight.transportpce.olm.service;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import java.util.Optional;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
private OlmPowerService olmPowerService;
private DataBroker dataBroker;
- @Before
- public void setUp() throws OpenRoadmInterfaceException {
- this.openRoadmInterfacesImpl121 = Mockito.mock(OpenRoadmInterfacesImpl121.class);
- this.openRoadmInterfacesImpl221 = Mockito.mock(OpenRoadmInterfacesImpl221.class);
- this.mappingUtils = Mockito.mock(MappingUtilsImpl.class);
- this.portMapping = Mockito.mock(PortMappingImpl.class);
- this.deviceTransactionManager = Mockito.mock(DeviceTransactionManagerImpl.class);
- this.powerMgmt = Mockito.mock(PowerMgmtImpl.class);
+ @BeforeEach
+ void setUp() throws OpenRoadmInterfaceException {
+ this.openRoadmInterfacesImpl121 = mock(OpenRoadmInterfacesImpl121.class);
+ this.openRoadmInterfacesImpl221 = mock(OpenRoadmInterfacesImpl221.class);
+ this.mappingUtils = mock(MappingUtilsImpl.class);
+ this.portMapping = mock(PortMappingImpl.class);
+ this.deviceTransactionManager = mock(DeviceTransactionManagerImpl.class);
+ this.powerMgmt = mock(PowerMgmtImpl.class);
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(this.deviceTransactionManager, this.mappingUtils,
this.openRoadmInterfacesImpl121, this.openRoadmInterfacesImpl221, this.openRoadmInterfacesImpl710);
this.olmPowerService = new OlmPowerServiceImpl(getDataBroker(), this.powerMgmt,
this.deviceTransactionManager, this.portMapping, this.mappingUtils, this.openRoadmInterfaces);
this.dataBroker = getDataBroker();
- MockitoAnnotations.openMocks(this);
- Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_2_2_1).when(this.mappingUtils)
- .getOpenRoadmVersion(Mockito.anyString());
+ doReturn(StringConstants.OPENROADM_DEVICE_VERSION_2_2_1)
+ .when(this.mappingUtils).getOpenRoadmVersion(anyString());
- Mockito.when(this.portMapping.getMapping("ROADM-A1", "DEG2-TTP-TXRX"))
- .thenReturn(OlmTransactionUtils.getMapping1());
- Mockito.when(this.portMapping.getMapping("ROADM-C1", "DEG1-TTP-TXRX"))
- .thenReturn(OlmTransactionUtils.getMapping2());
+ when(this.portMapping.getMapping("ROADM-A1", "DEG2-TTP-TXRX")).thenReturn(OlmTransactionUtils.getMapping1());
+ when(this.portMapping.getMapping("ROADM-C1", "DEG1-TTP-TXRX")).thenReturn(OlmTransactionUtils.getMapping2());
InstanceIdentifier<CurrentPmList> iidCurrentPmList = InstanceIdentifier.create(CurrentPmList.class);
- Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-A1", LogicalDatastoreType.OPERATIONAL,
- iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT,
- Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(OlmTransactionUtils.getCurrentPmListA());
- Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-C1", LogicalDatastoreType.OPERATIONAL,
- iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT,
- Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(OlmTransactionUtils.getCurrentPmListC());
+ when(this.deviceTransactionManager.getDataFromDevice("ROADM-A1", LogicalDatastoreType.OPERATIONAL,
+ iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+ .thenReturn(OlmTransactionUtils.getCurrentPmListA());
+ when(this.deviceTransactionManager.getDataFromDevice("ROADM-C1", LogicalDatastoreType.OPERATIONAL,
+ iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+ .thenReturn(OlmTransactionUtils.getCurrentPmListC());
InstanceIdentifier<Interface> interfacesIIDA = InstanceIdentifier
.builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
.build();
Optional<Interface> interfaceA = Optional.of(new InterfaceBuilder().setName("OTS-DEG2-TTP-TXRX").build());
Optional<Interface> interfaceC = Optional.of(new InterfaceBuilder().setName("OTS-DEG1-TTP-TXRX").build());
- Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-A1", LogicalDatastoreType.CONFIGURATION,
- interfacesIIDA, Timeouts.DEVICE_READ_TIMEOUT,
- Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(interfaceA);
- Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-C1", LogicalDatastoreType.CONFIGURATION,
- interfacesIIDC, Timeouts.DEVICE_READ_TIMEOUT,
- Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(interfaceC);
+ when(this.deviceTransactionManager.getDataFromDevice("ROADM-A1", LogicalDatastoreType.CONFIGURATION,
+ interfacesIIDA, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+ .thenReturn(interfaceA);
+ when(this.deviceTransactionManager.getDataFromDevice("ROADM-C1", LogicalDatastoreType.CONFIGURATION,
+ interfacesIIDC, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
+ .thenReturn(interfaceC);
Ots otsValue = new OtsBuilder()
.setSpanLossTransmit(new RatioDB(Decimal64.valueOf("25")))
.addAugmentation(ots).build();
Optional<Interface> interOptA = Optional.of(interA);
Optional<Interface> interOptC = Optional.of(interC);
- Mockito.when(this.openRoadmInterfacesImpl221.getInterface("ROADM-A1", "OTS-DEG2-TTP-TXRX"))
- .thenReturn(interOptA);
- Mockito.when(this.openRoadmInterfacesImpl221.getInterface("ROADM-C1", "OTS-DEG1-TTP-TXRX"))
- .thenReturn(interOptC);
+ when(this.openRoadmInterfacesImpl221.getInterface("ROADM-A1", "OTS-DEG2-TTP-TXRX")).thenReturn(interOptA);
+ when(this.openRoadmInterfacesImpl221.getInterface("ROADM-C1", "OTS-DEG1-TTP-TXRX")).thenReturn(interOptC);
InterfaceBuilder ifABldr = new InterfaceBuilder();
- Mockito.doNothing().when(this.openRoadmInterfacesImpl221).postInterface("ROADM-A1", ifABldr);
- Mockito.doNothing().when(this.openRoadmInterfacesImpl221).postInterface("ROADM-C1", ifABldr);
+ doNothing().when(this.openRoadmInterfacesImpl221).postInterface("ROADM-A1", ifABldr);
+ doNothing().when(this.openRoadmInterfacesImpl221).postInterface("ROADM-C1", ifABldr);
}
@Test
- public void testCalculateSpanlossBaseLink() {
+ void testCalculateSpanlossBaseLink() {
// initialise and store openroadm-topology in datastore
NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID));
InstanceIdentifier<Network> ietfNetworkIID = InstanceIdentifier.builder(Networks.class)
CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInputLink();
CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input);
- Assert.assertEquals("Success", output.getResult());
- Assert.assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue());
- Assert.assertEquals("14.6", output.getSpans().get(0).getSpanloss());
+ assertEquals("Success", output.getResult());
+ assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue());
+ assertEquals("14.6", output.getSpans().get(0).getSpanloss());
}
@Test
- public void testCalculateSpanlossBaseAll() {
+ void testCalculateSpanlossBaseAll() {
// initialise and store openroadm-topology in datastore
NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID));
CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInputAll();
CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input);
- Assert.assertEquals("Success", output.getResult());
- Assert.assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue());
- Assert.assertEquals("14.6", output.getSpans().get(0).getSpanloss());
+ assertEquals("Success", output.getResult());
+ assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue());
+ assertEquals("14.6", output.getSpans().get(0).getSpanloss());
}
}
package org.opendaylight.transportpce.olm.service;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import java.util.Optional;
-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.DataBroker;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
private OlmPowerService olmPowerService;
private DataBroker dataBroker;
- @Before
- public void setUp() {
- this.dataBroker = Mockito.mock(DataBroker.class);
- this.powerMgmt = Mockito.mock(PowerMgmtImpl.class);
- this.deviceTransactionManager = Mockito.mock(DeviceTransactionManager.class);
- this.portMapping = Mockito.mock(PortMapping.class);
- this.mappingUtils = Mockito.mock(MappingUtils.class);
- this.openRoadmInterfaces = Mockito.mock(OpenRoadmInterfaces.class);
- this.olmPowerService = new OlmPowerServiceImpl(this.dataBroker, this.powerMgmt,
- this.deviceTransactionManager, this.portMapping, this.mappingUtils, this.openRoadmInterfaces);
+ @BeforeEach
+ void setUp() {
+ this.dataBroker = mock(DataBroker.class);
+ this.powerMgmt = mock(PowerMgmtImpl.class);
+ this.deviceTransactionManager = mock(DeviceTransactionManager.class);
+ this.portMapping = mock(PortMapping.class);
+ this.mappingUtils = mock(MappingUtils.class);
+ this.openRoadmInterfaces = mock(OpenRoadmInterfaces.class);
+ this.olmPowerService = new OlmPowerServiceImpl(this.dataBroker, this.powerMgmt, this.deviceTransactionManager,
+ this.portMapping, this.mappingUtils, this.openRoadmInterfaces);
}
@Test
- public void dummyTest() {
+ void dummyTest() {
OlmPowerServiceImpl olmPowerServiceImpl = (OlmPowerServiceImpl) this.olmPowerService;
olmPowerServiceImpl.init();
olmPowerServiceImpl.close();
}
@Test
- public void testGetPm() {
- Mockito.when(this.mappingUtils.getOpenRoadmVersion(Mockito.anyString()))
- .thenReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1);
- Mockito.when(this.deviceTransactionManager.getDataFromDevice(Mockito.anyString(), Mockito.any(),
- Mockito.any(), Mockito.anyLong(), Mockito.any()))
+ void testGetPm() {
+ when(this.mappingUtils.getOpenRoadmVersion(anyString()))
+ .thenReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1);
+ when(this.deviceTransactionManager.getDataFromDevice(anyString(), any(), any(), anyLong(), any()))
.thenReturn(Optional.of(OlmPowerServiceRpcImplUtil.getCurrentPmList121()));
GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput();
GetPmOutput result = this.olmPowerService.getPm(input);
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev220926.PmGranularity._15min,
- result.getGranularity());
- Assert.assertEquals(PmNamesEnum.OpticalPowerInput.toString(),
- result.getMeasurements().stream().findFirst().get().getPmparameterName());
- Assert.assertEquals(String.valueOf(3.0),
- result.getMeasurements().stream().findFirst().get().getPmparameterValue());
- Assert.assertEquals("ots-deg1",
- result.getResourceIdentifier().getResourceName());
+ assertEquals(
+ org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev220926.PmGranularity._15min,
+ result.getGranularity());
+ assertEquals(
+ PmNamesEnum.OpticalPowerInput.toString(),
+ result.getMeasurements().stream().findFirst().get().getPmparameterName());
+ assertEquals(
+ String.valueOf(3.0),
+ result.getMeasurements().stream().findFirst().get().getPmparameterValue());
+ assertEquals(
+ "ots-deg1",
+ result.getResourceIdentifier().getResourceName());
}
@Test
- public void testServicePowerSetupSuccess() {
+ void testServicePowerSetupSuccess() {
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput();
- Mockito.when(this.powerMgmt.setPower(Mockito.any())).thenReturn(true);
+ when(this.powerMgmt.setPower(any())).thenReturn(true);
ServicePowerSetupOutput result = this.olmPowerService.servicePowerSetup(input);
- Assert.assertEquals(new ServicePowerSetupOutputBuilder().setResult("Success").build(), result);
- Assert.assertEquals("Success", result.getResult());
+ assertEquals(new ServicePowerSetupOutputBuilder().setResult("Success").build(), result);
+ assertEquals("Success", result.getResult());
}
@Test
- public void testServicePowerSetupFailed() {
+ void testServicePowerSetupFailed() {
ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput();
- Mockito.when(this.powerMgmt.setPower(Mockito.any())).thenReturn(false);
+ when(this.powerMgmt.setPower(any())).thenReturn(false);
ServicePowerSetupOutput output = this.olmPowerService.servicePowerSetup(input);
- Assert.assertEquals("Failed", output.getResult());
+ assertEquals("Failed", output.getResult());
}
@Test
- public void testServicePowerTurnDownSuccess() {
+ void testServicePowerTurnDownSuccess() {
ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
- Mockito.when(this.powerMgmt.powerTurnDown(Mockito.any())).thenReturn(true);
+ when(this.powerMgmt.powerTurnDown(any())).thenReturn(true);
ServicePowerTurndownOutput output = this.olmPowerService.servicePowerTurndown(input);
- Assert.assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Success").build(), output);
- Assert.assertEquals("Success", output.getResult());
+ assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Success").build(), output);
+ assertEquals("Success", output.getResult());
}
@Test
- public void testServicePowerTurnDownFailed() {
+ void testServicePowerTurnDownFailed() {
ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
- Mockito.when(this.powerMgmt.powerTurnDown(Mockito.any())).thenReturn(false);
+ when(this.powerMgmt.powerTurnDown(any())).thenReturn(false);
ServicePowerTurndownOutput output = this.olmPowerService.servicePowerTurndown(input);
- Assert.assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Failed").build(), output);
- Assert.assertEquals("Failed", output.getResult());
+ assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Failed").build(), output);
+ assertEquals("Failed", output.getResult());
}
@Test
- public void testServicePowerReset() {
+ void testServicePowerReset() {
ServicePowerResetInput input = OlmPowerServiceRpcImplUtil.getServicePowerResetInput();
ServicePowerResetOutput output = this.olmPowerService.servicePowerReset(input);
- Assert.assertEquals(null, output);
+ assertEquals(null, output);
}
}
package org.opendaylight.transportpce.olm.util;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
public class OtsPmHolderTest {
@Test
- public void test() {
+ void test() {
OtsPmHolder otspmholder0 = new OtsPmHolder("name", Double.valueOf(12), "interface");
- Assert.assertEquals("name", otspmholder0.getOtsParameterName());
- Assert.assertEquals(Double.valueOf(12), otspmholder0.getOtsParameterVal());
- Assert.assertEquals("interface", otspmholder0.getOtsInterfaceName());
+ assertEquals("name", otspmholder0.getOtsParameterName());
+ assertEquals(Double.valueOf(12), otspmholder0.getOtsParameterVal());
+ assertEquals("interface", otspmholder0.getOtsInterfaceName());
otspmholder0.setOtsParameterName("name 2");
otspmholder0.setOtsParameterVal(Double.valueOf(120));
otspmholder0.setOtsInterfaceName("interface 2");
- Assert.assertEquals("name 2", otspmholder0.getOtsParameterName());
- Assert.assertEquals(Double.valueOf(120), otspmholder0.getOtsParameterVal());
- Assert.assertEquals("interface 2", otspmholder0.getOtsInterfaceName());
+ assertEquals("name 2", otspmholder0.getOtsParameterName());
+ assertEquals(Double.valueOf(120), otspmholder0.getOtsParameterVal());
+ assertEquals("interface 2", otspmholder0.getOtsInterfaceName());
}
}
Code Review / transportpce.git / commitdiff