From: Gilles Thouenon Date: Mon, 27 Feb 2023 17:56:40 +0000 (+0100) Subject: Migrate tapi module to JUnit5 X-Git-Tag: 7.0.0~12 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=transportpce.git;a=commitdiff_plain;h=ee81f24e14686bfb96cfa404592ad89117c01aa7 Migrate tapi module to JUnit5 JIRA: TRNSPRTPCE-730 Signed-off-by: Gilles Thouenon Change-Id: Ie52cd9632fcc7bf9d7202782d4699a5e479e9f6c --- diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java index c01c1e153..bb0ae8789 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java @@ -7,7 +7,10 @@ */ package org.opendaylight.transportpce.tapi.connectivity; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; @@ -17,12 +20,11 @@ import java.util.HashMap; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; -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.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.jupiter.MockitoExtension; import org.opendaylight.mdsal.binding.api.NotificationPublishService; import org.opendaylight.transportpce.common.InstanceIdentifiers; import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; @@ -59,49 +61,42 @@ import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +@ExtendWith(MockitoExtension.class) public class TapiConnectivityImplTest extends AbstractTest { @Mock private PathComputationService pathComputationService; - @Mock private RendererServiceOperations rendererServiceOperations; - @Mock private NotificationPublishService notificationPublishService; - @Mock private TapiPceListenerImpl tapipceListenerImpl; - @Mock private TapiRendererListenerImpl tapirendererListenerImpl; - @Mock private TapiServiceHandlerListenerImpl tapiserviceHandlerListenerImpl; - @Mock private PceListenerImpl pceListenerImpl; - @Mock private RendererListenerImpl rendererListenerImpl; - @Mock private NetworkModelListenerImpl networkModelListenerImpl; private static final Logger LOG = LoggerFactory.getLogger(TapiConnectivityImplTest.class); - public static ServiceDataStoreOperations serviceDataStoreOperations; - public static TapiContext tapiContext; - public static TopologyUtils topologyUtils; - public static ConnectivityUtils connectivityUtils; - public static TapiInitialORMapping tapiInitialORMapping; - public static NetworkTransactionService networkTransactionService; - public static TapiLink tapilink; + private static ServiceDataStoreOperations serviceDataStoreOperations; + private static TapiContext tapiContext; + private static TopologyUtils topologyUtils; + private static ConnectivityUtils connectivityUtils; + private static TapiInitialORMapping tapiInitialORMapping; + private static NetworkTransactionService networkTransactionService; + private static TapiLink tapilink; private ListeningExecutorService executorService; private CountDownLatch endSignal; private static final int NUM_THREADS = 5; - @Before - public void setUp() throws InterruptedException, ExecutionException { + @BeforeEach + void setUp() throws InterruptedException, ExecutionException { executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS)); endSignal = new CountDownLatch(1); // Need to have datastore populated to enable the mapping from TAPI to OR @@ -114,8 +109,6 @@ public class TapiConnectivityImplTest extends AbstractTest { TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(), TapiTopologyDataUtils.PORTMAPPING_FILE); - MockitoAnnotations.openMocks(this); - networkTransactionService = new NetworkTransactionImpl(getDataBroker()); tapilink = new TapiLink(networkTransactionService); serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker()); @@ -131,7 +124,7 @@ public class TapiConnectivityImplTest extends AbstractTest { } @Test - public void createConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { + void createConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl, serviceDataStoreOperations); @@ -151,18 +144,18 @@ public class TapiConnectivityImplTest extends AbstractTest { endSignal.await(); RpcResult rpcResult = result.get(); - Assert.assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); + assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); } @Test - public void createConnServiceShouldBeSuccessfulWhenPerformPCESuccessful() + void createConnServiceShouldBeSuccessfulWhenPerformPCESuccessful() throws ExecutionException, InterruptedException { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl, serviceDataStoreOperations); CreateConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceCreateInput(); - Mockito.when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any())); + when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any())); TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, tapipceListenerImpl, tapirendererListenerImpl); @@ -178,11 +171,11 @@ public class TapiConnectivityImplTest extends AbstractTest { endSignal.await(); RpcResult rpcResult = result.get(); - Assert.assertTrue(rpcResult.isSuccessful()); + assertTrue(rpcResult.isSuccessful()); } @Test - public void deleteConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { + void deleteConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl, serviceDataStoreOperations); @@ -202,11 +195,11 @@ public class TapiConnectivityImplTest extends AbstractTest { endSignal.await(); RpcResult rpcResult = result.get(); - Assert.assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); + assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); } @Test - public void deleteConnServiceShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException { + void deleteConnServiceShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException { DeleteConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceDeleteInput1(); OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, @@ -226,12 +219,12 @@ public class TapiConnectivityImplTest extends AbstractTest { endSignal.await(); RpcResult rpcResult = result.get(); - Assert.assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); + assertEquals(ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); } @Test - public void deleteConnServiceShouldBeSuccessForExistingService() throws ExecutionException, InterruptedException { - Mockito.when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any())); + void deleteConnServiceShouldBeSuccessForExistingService() throws ExecutionException, InterruptedException { + when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any())); OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, @@ -257,6 +250,6 @@ public class TapiConnectivityImplTest extends AbstractTest { endSignal.await(); RpcResult rpcResult = result.get(); - Assert.assertTrue(rpcResult.isSuccessful()); + assertTrue(rpcResult.isSuccessful()); } -} +} \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java index c571f2af2..76077e6fb 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java @@ -11,12 +11,11 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; -import org.junit.After; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +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.jupiter.MockitoExtension; import org.opendaylight.mdsal.binding.api.RpcProviderService; import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.common.network.NetworkTransactionService; @@ -37,59 +36,43 @@ import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Tapi import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.TapiConnectivityService; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.TapiTopologyService; +@ExtendWith(MockitoExtension.class) public class TapiProviderTest extends AbstractTest { - public static NetworkTransactionService networkTransactionService; + private static NetworkTransactionService networkTransactionService; @Mock - RpcProviderService rpcProviderRegistry; - + private RpcProviderService rpcProviderRegistry; @Mock - OrgOpenroadmServiceService serviceHandler; - + private OrgOpenroadmServiceService serviceHandler; @Mock - ServiceDataStoreOperations serviceDataStoreOperations; - + private ServiceDataStoreOperations serviceDataStoreOperations; @Mock - TapiListener tapiListener; - + private TapiListener tapiListener; @Mock - TransportpceTapinetworkutilsService tapiNetworkUtils; - + private TransportpceTapinetworkutilsService tapiNetworkUtils; @Mock - TapiPortMappingListener tapiPortMappingListener; - + private TapiPortMappingListener tapiPortMappingListener; @Mock - TapiNetconfTopologyListener topologyListener; - + private TapiNetconfTopologyListener topologyListener; @Mock - TapiOrLinkListener orLinkListener; - + private TapiOrLinkListener orLinkListener; @Mock - TapiPceListenerImpl pceListenerImpl; - + private TapiPceListenerImpl pceListenerImpl; @Mock - TapiRendererListenerImpl rendererListenerImpl; - + private TapiRendererListenerImpl rendererListenerImpl; @Mock - TapiServiceHandlerListenerImpl serviceHandlerListenerImpl; - + private TapiServiceHandlerListenerImpl serviceHandlerListenerImpl; @Mock - TapiNetworkModelListenerImpl networkModelListener; + private TapiNetworkModelListenerImpl networkModelListener; - private AutoCloseable closeable; - @Before - public void openMocks() { - closeable = MockitoAnnotations.openMocks(this); - } - - @BeforeClass - public static void setUp() { + @BeforeAll + static void setUp() { networkTransactionService = new NetworkTransactionImpl(getDataBroker()); } @Test - public void testInitRegisterTapiToRpcRegistry() { + void testInitRegisterTapiToRpcRegistry() { TapiProvider provider = new TapiProvider(getDataBroker(), rpcProviderRegistry, serviceHandler, serviceDataStoreOperations, tapiListener, networkTransactionService, topologyListener, tapiPortMappingListener, tapiNetworkUtils, pceListenerImpl, rendererListenerImpl, @@ -97,16 +80,8 @@ public class TapiProviderTest extends AbstractTest { provider.init(); - verify(rpcProviderRegistry, times(1)) - .registerRpcImplementation(any(), any(TapiConnectivityService.class)); - verify(rpcProviderRegistry, times(2)) - .registerRpcImplementation(any(), any(TapiTopologyService.class)); - verify(rpcProviderRegistry, times(2)) - .registerRpcImplementation(any(), any(TapiCommonService.class)); - } - - @After - public void releaseMocks() throws Exception { - closeable.close(); + verify(rpcProviderRegistry, times(1)).registerRpcImplementation(any(), any(TapiConnectivityService.class)); + verify(rpcProviderRegistry, times(2)).registerRpcImplementation(any(), any(TapiTopologyService.class)); + verify(rpcProviderRegistry, times(2)).registerRpcImplementation(any(), any(TapiCommonService.class)); } -} +} \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java index dca654dfc..272caa5b2 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java @@ -14,10 +14,10 @@ import static org.hamcrest.CoreMatchers.hasItem; import static org.hamcrest.CoreMatchers.hasItems; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import com.google.common.util.concurrent.FluentFuture; import java.nio.charset.Charset; @@ -30,8 +30,8 @@ import java.util.UUID; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; import org.eclipse.jdt.annotation.Nullable; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +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.InstanceIdentifiers; @@ -115,8 +115,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { private static TapiLink tapiLink; private static DataBroker dataBroker = getDataBroker(); - @BeforeClass - public static void setUp() throws InterruptedException, ExecutionException { + @BeforeAll + static void setUp() throws InterruptedException, ExecutionException { TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II); TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), @@ -201,7 +201,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } @Test - public void convertNodeWhenNoStates() { + void convertNodeWhenNoStates() { Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1", null, null); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { @@ -224,12 +224,12 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid)); - assertNull("Administrative State should not be present", enepN.getAdministrativeState()); - assertNull("Operational State should not be present", enepN.getOperationalState()); + assertNull(enepN.getAdministrativeState(), "Administrative State should not be present"); + assertNull(enepN.getOperationalState(), "Operational State should not be present"); OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid)); - assertNull("Administrative State should not be present", inepN.getAdministrativeState()); - assertNull("Operational State should not be present", inepN.getOperationalState()); + assertNull(inepN.getAdministrativeState(), "Administrative State should not be present"); + assertNull(inepN.getOperationalState(), "Operational State should not be present"); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -240,26 +240,26 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid)); - assertNull("Administrative State should not be present", enep.getAdministrativeState()); - assertNull("Operational State should not be present", enep.getOperationalState()); + assertNull(enep.getAdministrativeState(), "Administrative State should not be present"); + assertNull(enep.getOperationalState(), "Operational State should not be present"); Uuid inepUuid = new Uuid( UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid)); - assertNull("Administrative State should not be present", inep.getAdministrativeState()); - assertNull("Operational State should not be present", inep.getOperationalState()); + assertNull(inep.getAdministrativeState(), "Administrative State should not be present"); + assertNull(inep.getOperationalState(), "Operational State should not be present"); Uuid photnepUuid = new Uuid( UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid)); - assertNull("Administrative State should not be present", photnep.getAdministrativeState()); - assertNull("Operational State should not be present", photnep.getOperationalState()); + assertNull(photnep.getAdministrativeState(), "Administrative State should not be present"); + assertNull(photnep.getOperationalState(), "Operational State should not be present"); } @Test - public void convertNodeWhenBadStates1() { + void convertNodeWhenBadStates1() { Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1", AdminStates.OutOfService, State.OutOfService); List networkPortList = new ArrayList<>(); @@ -283,16 +283,14 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, enepN.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, enepN.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, enepN.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, enepN.getOperationalState(), "Operational State should be Disabled"); OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, inepN.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, inepN.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, inepN.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, inepN.getOperationalState(), "Operational State should be Disabled"); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -303,32 +301,29 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, enep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, enep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled"); Uuid inepUuid = new Uuid( UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, inep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, inep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled"); Uuid photnepUuid = new Uuid( UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, photnep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, photnep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, photnep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, photnep.getOperationalState(), "Operational State should be Disabled"); } @Test - public void convertNodeWhenBadStates2() { + void convertNodeWhenBadStates2() { Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", "XPDR1-CLIENT1", AdminStates.Maintenance, State.Degraded); List networkPortList = new ArrayList<>(); @@ -352,16 +347,14 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enetworkNepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, enepN.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, enepN.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, enepN.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, enepN.getOperationalState(), "Operational State should be Disabled"); OwnedNodeEdgePoint inepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inetworkNepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, inepN.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, inepN.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, inepN.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, inepN.getOperationalState(), "Operational State should be Disabled"); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -372,32 +365,29 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, enep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, enep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled"); Uuid inepUuid = new Uuid( UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, inep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, inep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled"); Uuid photnepUuid = new Uuid( UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint photnep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(photnepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, photnep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, photnep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, photnep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, photnep.getOperationalState(), "Operational State should be Disabled"); } @Test - public void convertNodeForTransponder100G() { + void convertNodeForTransponder100G() { ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { @@ -411,8 +401,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2"); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -430,7 +420,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForOtnMuxponder() { + void convertNodeForOtnMuxponder() { ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { @@ -444,8 +434,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1"); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1"); @@ -462,7 +452,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForOtnSwitch() { + void convertNodeForOtnSwitch() { ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) { @@ -476,8 +466,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(4, tapiFactory.getTapiLinks().size(), "Link list size should be 4"); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -495,12 +485,12 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForRoadmWhenNoOtnMuxAttached() { + void convertNodeForRoadmWhenNoOtnMuxAttached() { ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); tapiFactory.convertRoadmNode(roadmA, openroadmNet); - assertEquals("Node list size should be 1", 1, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be empty", 0, tapiFactory.getTapiLinks().size()); + assertEquals(1, tapiFactory.getTapiNodes().size(), "Node list size should be 1"); + assertEquals(0, tapiFactory.getTapiLinks().size(), "Link list size should be empty"); List tapiNodes = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); Uuid roadmNodeUuid = new Uuid(UUID.nameUUIDFromBytes((roadmA.getNodeId().getValue() + "+PHOTONIC_MEDIA") @@ -509,7 +499,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForRoadmWhenRoadmNeighborAttached() { + void convertNodeForRoadmWhenRoadmNeighborAttached() { ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); tapiFactory.convertRoadmNode(roadmA, openroadmNet); tapiFactory.convertRoadmNode(roadmC, openroadmNet); @@ -519,8 +509,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .collect(Collectors.toList()); tapiFactory.convertRdmToRdmLinks(rdmTordmLinkList); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1"); List tapiNodes = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); @@ -549,7 +539,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForRoadmWhenOtnMuxAttached() { + void convertNodeForRoadmWhenOtnMuxAttached() { ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); List networkPortListA = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { @@ -575,8 +565,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .collect(Collectors.toList()); xponderInLinkList.addAll(xponderOutLinkList); tapiFactory.convertXpdrToRdmLinks(xponderInLinkList); - assertEquals("Node list size should be 3", 3, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size()); + assertEquals(3, tapiFactory.getTapiNodes().size(), "Node list size should be 3"); + assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2"); List tapiNodes = tapiFactory.getTapiNodes().values().stream() .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) @@ -606,18 +596,17 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node, - Uuid nodeUuid, String dsrNodeType, String nodeId) { - assertEquals("incorrect node uuid", nodeUuid, node.getUuid()); - assertEquals("incorrect node name", nodeId + "+DSR", node.getName().get( - new NameKey("dsr/odu node name")).getValue()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, node.getAdministrativeState()); - assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState()); - assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState()); + Uuid nodeUuid, String dsrNodeType, String nodeId) { + assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid"); + assertEquals(nodeId + "+DSR", node.getName().get(new NameKey("dsr/odu node name")).getValue(), + "incorrect node name"); + assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(), + "administrative state should be UNLOCKED"); + assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED"); + assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED"); assertThat("one value-name should be 'dsr/odu node name'", new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("dsr/odu node name"))); - assertEquals("dsr node should manage 2 protocol layers : dsr and odu", - 2, node.getLayerProtocolName().size()); + assertEquals(2, node.getLayerProtocolName().size(), "dsr node should manage 2 protocol layers : dsr and odu"); assertThat("dsr node should manage 2 protocol layers : dsr and odu", node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU)); List inepsN = node.nonnullOwnedNodeEdgePoint().values().stream() @@ -635,9 +624,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C"))) .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Switch-DSR node should have 4 eNEPs network", 4, enepsN.size()); - assertEquals("Switch-DSR node should have 4 iNEPs network", 4, inepsN.size()); - assertEquals("Switch-DSR node should have 4 NEPs client", 4, nepsC.size()); + assertEquals(4, enepsN.size(), "Switch-DSR node should have 4 eNEPs network"); + assertEquals(4, inepsN.size(), "Switch-DSR node should have 4 iNEPs network"); + assertEquals(4, nepsC.size(), "Switch-DSR node should have 4 NEPs client"); OwnedNodeEdgePoint nep1 = nepsC.get(2); Uuid client4NepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8"))) @@ -663,9 +652,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C"))) .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Mux-DSR node should have 4 eNEP network", 4, enepsN.size()); - assertEquals("Mux-DSR node should have 1 iNEP network", 1, inepsN.size()); - assertEquals("Mux-DSR node should have 4 NEPs client", 4, nepsC.size()); + assertEquals(4, enepsN.size(), "Mux-DSR node should have 4 eNEP network"); + assertEquals(1, inepsN.size(), "Mux-DSR node should have 1 iNEP network"); + assertEquals(4, nepsC.size(), "Mux-DSR node should have 4 NEPs client"); OwnedNodeEdgePoint nep3 = nepsC.get(2); Uuid client3NepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8"))) @@ -692,9 +681,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr"))) .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Tpdr-DSR node should have 2 eNEPs network", 2, enepsN.size()); - assertEquals("Tpdr-DSR node should have 2 iNEPs network", 2, inepsN.size()); - assertEquals("Tpdr-DSR node should have 2 NEPs client", 2, nepsC.size()); + assertEquals(2, enepsN.size(), "Tpdr-DSR node should have 2 eNEPs network"); + assertEquals(2, inepsN.size(), "Tpdr-DSR node should have 2 iNEPs network"); + assertEquals(2, nepsC.size(), "Tpdr-DSR node should have 2 NEPs client"); OwnedNodeEdgePoint nep5 = nepsC.get(0); Uuid client1NepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT1").getBytes(Charset.forName("UTF-8"))) @@ -725,7 +714,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { private void checkOtsiNode( org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node, Uuid nodeUuid, String otsiNodeType, String nodeId) { - assertEquals("incorrect node uuid", nodeUuid, node.getUuid()); + assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid"); List nepsI = null; List nepsE = null; List nepsP = null; @@ -733,8 +722,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { List nepsOtsimc = null; List nepsPhot = null; if (!otsiNodeType.equals("roadm")) { - assertEquals("incorrect node name", nodeId + "+OTSi", node.getName().get( - new NameKey("otsi node name")).getValue()); + assertEquals(nodeId + "+OTSi", node.getName().get(new NameKey("otsi node name")).getValue(), + "incorrect node name"); assertThat("one value-name should be 'dsr/odu node name'", new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("otsi node name"))); nepsI = node.nonnullOwnedNodeEdgePoint().values().stream() @@ -750,8 +739,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) .collect(Collectors.toList()); } else { - assertEquals("incorrect node name", nodeId + "+PHOTONIC_MEDIA", node.getName().get( - new NameKey("roadm node name")).getValue()); + assertEquals(nodeId + "+PHOTONIC_MEDIA", node.getName().get(new NameKey("roadm node name")).getValue(), + "incorrect node name"); assertThat("one value-name should be 'dsr/odu node name'", new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("roadm node name"))); nepsMc = node.nonnullOwnedNodeEdgePoint().values().stream() @@ -767,20 +756,20 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) .collect(Collectors.toList()); } - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, node.getAdministrativeState()); - assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState()); - assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState()); - assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA", - 1, node.getLayerProtocolName().size()); - assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA", - LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().stream().findFirst().get()); + assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(), + "administrative state should be UNLOCKED"); + assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED"); + assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED"); + assertEquals(1, node.getLayerProtocolName().size(), + "otsi node should manage a single protocol layer : PHOTONIC_MEDIA"); + assertEquals(LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().stream().findFirst().get(), + "otsi node should manage a single protocol layer : PHOTONIC_MEDIA"); switch (otsiNodeType) { case "switch": - assertEquals("Switch-OTSi node should have 4 eNEPs", 4, nepsE.size()); - assertEquals("Switch-OTSi node should have 4 iNEPs", 4, nepsI.size()); - assertEquals("Switch-OTSi node should have 4 photNEPs", 4, nepsP.size()); + assertEquals(4, nepsE.size(), "Switch-OTSi node should have 4 eNEPs"); + assertEquals(4, nepsI.size(), "Switch-OTSi node should have 4 iNEPs"); + assertEquals(4, nepsP.size(), "Switch-OTSi node should have 4 photNEPs"); OwnedNodeEdgePoint nep1 = nepsI.get(1); Uuid inepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8"))) @@ -803,9 +792,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid); break; case "mux": - assertEquals("Mux-OTSi node should have 1 eNEP", 1, nepsE.size()); - assertEquals("Mux-OTSi node should have 1 iNEPs", 1, nepsI.size()); - assertEquals("Mux-OTSi node should have 1 photNEPs", 1, nepsP.size()); + assertEquals(1, nepsE.size(), "Mux-OTSi node should have 1 eNEP"); + assertEquals(1, nepsI.size(), "Mux-OTSi node should have 1 iNEPs"); + assertEquals(1, nepsP.size(), "Mux-OTSi node should have 1 photNEPs"); OwnedNodeEdgePoint nep3 = nepsE.get(0); Uuid enepUuid2 = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) @@ -828,9 +817,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid); break; case "tpdr": - assertEquals("Tpdr-OTSi node should have 2 eNEPs", 2, nepsE.size()); - assertEquals("Tpdr-OTSi node should have 2 iNEPs", 2, nepsI.size()); - assertEquals("Tpdr-OTSi node should have 2 photNEPs", 2, nepsP.size()); + assertEquals(2, nepsE.size(), "Tpdr-OTSi node should have 2 eNEPs"); + assertEquals(2, nepsI.size(), "Tpdr-OTSi node should have 2 iNEPs"); + assertEquals(2, nepsP.size(), "Tpdr-OTSi node should have 2 photNEPs"); OwnedNodeEdgePoint nep5 = nepsE.get(0); Uuid enepUuid3 = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) @@ -853,9 +842,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkNodeRuleGroupForTpdrOTSi(nrgList3, enepUuid3, inepUuid3, nodeUuid); break; case "roadm": - assertEquals("Roadm node should have 10 MC NEPs", 10, nepsMc.size()); - assertEquals("Roadm node should have 10 OTSiMC NEPs", 10, nepsOtsimc.size()); - assertEquals("Roadm node should have 10 PHOT_MEDIA NEPs", 10, nepsPhot.size()); + assertEquals(10, nepsMc.size(), "Roadm node should have 10 MC NEPs"); + assertEquals(10, nepsOtsimc.size(), "Roadm node should have 10 OTSiMC NEPs"); + assertEquals(10, nepsPhot.size(), "Roadm node should have 10 PHOT_MEDIA NEPs"); // For Degree node OwnedNodeEdgePoint nep7 = nepsMc.get(6); Uuid mcnepUuid3 = new Uuid( @@ -902,66 +891,62 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); Name name = nameList.get(0); - assertEquals("value of client nep should be '" + portName + "'", - portName, name.getValue()); - assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", - nepName, name.getValueName()); - assertEquals("Client nep should support 3 kind of cep", - 3, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, name.getValue(), "value of client nep should be '" + portName + "'"); + assertEquals(nepName, name.getValueName(), + "value-name of client nep for '" + portName + "' should be '" + nepName + "'"); + assertEquals(3, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 3 kind of cep"); assertThat("client nep should support 3 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(ODUTYPEODU2.VALUE, ODUTYPEODU2E.VALUE, DIGITALSIGNALTYPE10GigELAN.VALUE)); - assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.DSR, nep.getLayerProtocolName(), "client nep should be of DSR protocol type"); checkCommonPartOfNep(nep, false); } private void checkNepeODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, - boolean withSip) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + boolean withSip) { + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); Name name = nameList.get(0); - assertEquals("value of eODU nep should be '" + portName + "'", - portName, name.getValue()); - assertEquals("value-name of eODU nep for '" + portName + "' should be '" + nepName + "'", - nepName, name.getValueName()); + assertEquals(portName, name.getValue(), "value of eODU nep should be '" + portName + "'"); + assertEquals(nepName, name.getValueName(), + "value-name of eODU nep for '" + portName + "' should be '" + nepName + "'"); // TODO: depending on the type of node there is one type or another assertThat("eODU nep should support 1, 2 or 3 kind of cep, depending on client port", nep.getSupportedCepLayerProtocolQualifier().size(), anyOf(is(1), is(2), is(3))); - assertTrue("eODU nep should support 1 kind of cep", + assertTrue( nep.getSupportedCepLayerProtocolQualifier().stream().anyMatch(splc -> splc.equals(ODUTYPEODU0.VALUE) || splc.equals(ODUTYPEODU2.VALUE) || splc.equals(ODUTYPEODU2E.VALUE) - || splc.equals(ODUTYPEODU4.VALUE))); - assertEquals("eODU nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName()); + || splc.equals(ODUTYPEODU4.VALUE)), + "eODU nep should support 1 kind of cep"); + assertEquals(LayerProtocolName.ODU, nep.getLayerProtocolName(), "eODU nep should be of ODU protocol type"); checkCommonPartOfNep(nep, withSip); } private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, - boolean withSip) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + boolean withSip) { + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); Name name = nameList.get(0); - assertEquals("value of network nep should be '" + portName + "'", - portName, name.getValue()); - assertEquals("value-name of network nep for '" + portName + "' should be '" + nepName + "'", - nepName, name.getValueName()); - assertEquals("Network nep should support 1 kind of cep", - 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, name.getValue(), "value of network nep should be '" + portName + "'"); + assertEquals(nepName, name.getValueName(), + "value-name of network nep for '" + portName + "' should be '" + nepName + "'"); + assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), "Network nep should support 1 kind of cep"); assertThat("network nep should support 1 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItem(ODUTYPEODU4.VALUE)); - assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.ODU, nep.getLayerProtocolName(), "network nep should be of ODU protocol type"); checkCommonPartOfNep(nep, withSip); } private void checkNodeRuleGroupForTpdrDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, - Uuid nodeUuid) { - assertEquals("transponder DSR should contain 2 node rule group", 2, nrgList.size()); + Uuid nodeUuid) { + assertEquals(2, nrgList.size(), "transponder DSR should contain 2 node rule group"); for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals("each node-rule-group should contain 2 NEP for transponder DSR", - 2, nodeRuleGroup.getNodeEdgePoint().size()); + assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), + "each node-rule-group should contain 2 NEP for transponder DSR"); } List nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values()); assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1", @@ -970,26 +955,24 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); - assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node", - nodeEdgePointList.get(0).getNodeUuid(), nodeUuid); - assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node", - nodeEdgePointList.get(1).getNodeUuid(), nodeUuid); + assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid, + "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node"); + assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid, + "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node"); List rule = new ArrayList<>(nrgList.get(1).nonnullRule().values()); - assertEquals("node-rule-group nb 1 should contain a single rule", 1, rule.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", rule.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, rule.get(0).getRuleType()); + assertEquals(1, rule.size(), "node-rule-group nb 1 should contain a single rule"); + assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForMuxDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, - Uuid nodeUuid) { - assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size()); + Uuid nodeUuid) { + assertEquals(4, nrgList.size(), "muxponder DSR should contain 4 node rule group"); for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR", - 2, nodeRuleGroup.getNodeEdgePoint().size()); + assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), + "each node-rule-group should contain 2 NEP for muxponder DSR"); } List nodeEdgePointList = new ArrayList<>(nrgList.get(2).nonnullNodeEdgePoint().values()); assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1", @@ -998,122 +981,112 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); - assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node", - nodeEdgePointList.get(0).getNodeUuid(), nodeUuid); - assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node", - nodeEdgePointList.get(1).getNodeUuid(), nodeUuid); + assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid, + "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node"); + assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid, + "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node"); List rule = new ArrayList<>(nrgList.get(1).nonnullRule().values()); - assertEquals("node-rule-group nb 2 should contain a single rule", 1, rule.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", rule.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, rule.get(0).getRuleType()); + assertEquals(1, rule.size(), "node-rule-group nb 2 should contain a single rule"); + assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForSwitchDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, - Uuid nodeUuid) { - assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size()); - assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size()); + Uuid nodeUuid) { + assertEquals(1, nrgList.size(), "Switch-DSR should contain a single node rule group"); + assertEquals(8, nrgList.get(0).getNodeEdgePoint().size(), "Switch-DSR node-rule-group should contain 8 NEP"); List nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream() .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue() .compareTo(nrg2.getNodeEdgePointUuid().getValue())) .collect(Collectors.toList()); - assertEquals("in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1", - networkNepUuid, nrg.get(6).getNodeEdgePointUuid()); - assertEquals("in the sorted node-rule-group, nep number 4 should be XPDR2-CLIENT4", - clientNepUuid, nrg.get(3).getNodeEdgePointUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nrg.get(4).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nrg.get(3).getNodeUuid()); + assertEquals(networkNepUuid, nrg.get(6).getNodeEdgePointUuid(), + "in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1"); + assertEquals(clientNepUuid, nrg.get(3).getNodeEdgePointUuid(), + "in the sorted node-rule-group, nep number 4 should be XPDR2-CLIENT4"); + assertEquals(nodeUuid, nrg.get(4).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nrg.get(3).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); @Nullable List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForRdm(List nrgList, int nbNeps) { - assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size()); + assertEquals(1, nrgList.size(), "RDM infra node - OTSi should contain a single node rule groups"); if (nbNeps > 0) { List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("RDM infra node -rule-group should contain " + nbNeps + " NEP", - nbNeps, nodeEdgePointList.size()); + assertEquals(nbNeps, nodeEdgePointList.size(), + "RDM infra node -rule-group should contain " + nbNeps + " NEP"); } else { - assertNull("RDM infra node -rule-group should contain no NEP", nrgList.get(0).getNodeEdgePoint()); + assertNull(nrgList.get(0).getNodeEdgePoint(), "RDM infra node -rule-group should contain no NEP"); } List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForTpdrOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, - Uuid nodeUuid) { - assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size()); + Uuid nodeUuid) { + assertEquals(2, nrgList.size(), "Tpdr-OTSi should contain two node rule groups"); List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size()); + assertEquals(2, nodeEdgePointList.size(), "Tpdr-OTSi node-rule-group should contain 2 NEP"); assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(0).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(1).getNodeUuid()); + assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForMuxOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, - Uuid nodeUuid) { - assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size()); + Uuid nodeUuid) { + assertEquals(1, nrgList.size(), "Mux-OTSi should contain a single node rule group"); List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size()); + assertEquals(2, nodeEdgePointList.size(), "Mux-OTSi node-rule-group should contain 2 NEP"); assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(0).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(1).getNodeUuid()); + assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForSwitchOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, - Uuid nodeUuid) { - assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size()); + Uuid nodeUuid) { + assertEquals(4, nrgList.size(), "Switch-OTSi should contain 4 node rule group"); for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi", - 2, nodeRuleGroup.getNodeEdgePoint().size()); + assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), + "each node-rule-group should contain 2 NEP for Switch-OTSi"); } List nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values()); assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2", @@ -1123,130 +1096,123 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); List nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList0.get(0).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList0.get(1).getNodeUuid()); + assertEquals(nodeUuid, nodeEdgePointList0.get(0).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nodeEdgePointList0.get(1).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); List ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList0.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList0.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList0.get(0).getRuleType()); + assertEquals(1, ruleList0.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList0.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList0.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of client nep should be '" + portName + "'", - portName, nameList.get(0).getValue()); - assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", - nepName, nameList.get(0).getValueName()); - assertEquals("Client nep should support 2 kind of cep", - 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, nameList.get(0).getValue(), + "value of client nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), + "value-name of client nep for '" + portName + "' should be '" + nepName + "'"); + assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 2 kind of cep"); assertThat("client nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(ODUTYPEODU4.VALUE, DIGITALSIGNALTYPE100GigE.VALUE)); - assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.DSR, nep.getLayerProtocolName(), "client nep should be of DSR protocol type"); checkCommonPartOfNep(nep, false); } private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of client nep should be '" + portName + "'", - portName, nameList.get(0).getValue()); - assertEquals("value-name of client nep for '" + portName + "' should be 100G-tpdr'", - nepName, nameList.get(0).getValueName()); - assertEquals("Client nep should support 1 kind of cep", - 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, nameList.get(0).getValue(), "value of client nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), + "value-name of client nep for '" + portName + "' should be 100G-tpdr'"); + assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 1 kind of cep"); assertThat("client nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(DIGITALSIGNALTYPE100GigE.VALUE)); - assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.DSR, nep.getLayerProtocolName(), "client nep should be of DSR protocol type"); checkCommonPartOfNep(nep, false); } private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, - boolean withSip) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + boolean withSip) { + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of OTSi nep should be '" + portName + "'", - portName, nameList.get(0).getValue()); - assertEquals("value-name of OTSi nep should be '" + nepName + "'", - nepName, nameList.get(0).getValueName()); - assertEquals("OTSi nep should support 2 kind of cep", - 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, nameList.get(0).getValue(), "value of OTSi nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), "value-name of OTSi nep should be '" + nepName + "'"); + assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), + "OTSi nep should support 2 kind of cep"); assertThat("OTSi nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE, PHOTONICLAYERQUALIFIEROTSi.VALUE)); - assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", - LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(), + "OTSi nep should be of PHOTONIC_MEDIA protocol type"); checkCommonPartOfNep(nep, withSip); } private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, - boolean withSip) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + boolean withSip) { + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of OTSi nep should be '" + portName + "'", - portName, nameList.get(0).getValue()); - assertEquals("value-name of OTSi nep should be '" + nepName + "'", - nepName, nameList.get(0).getValueName()); - assertEquals("OTSi nep of RDM infra node should support only 1 kind of cep", - 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, nameList.get(0).getValue(), + "value of OTSi nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), + "value-name of OTSi nep should be '" + nepName + "'"); + assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), + "OTSi nep of RDM infra node should support only 1 kind of cep"); assertThat("OTSi nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE)); - assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", - LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(), + "OTSi nep should be of PHOTONIC_MEDIA protocol type"); checkCommonPartOfNep(nep, withSip); } private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean withSip) { - assertEquals("link port direction should be DIRECTIONAL", - PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, nep.getAdministrativeState()); - assertEquals("termination state should be TERMINATED BIDIRECTIONAL", - TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState()); - assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, nep.getLifecycleState()); + assertEquals(PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection(), + "link port direction should be DIRECTIONAL"); + assertEquals(AdministrativeState.UNLOCKED, nep.getAdministrativeState(), + "administrative state should be UNLOCKED"); + assertEquals(TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState(), + "termination state should be TERMINATED BIDIRECTIONAL"); + assertEquals(LifecycleState.INSTALLED, nep.getLifecycleState(), "life-cycle state should be INSTALLED"); if (withSip) { - assertEquals("Given nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size()); + assertEquals(1, nep.getMappedServiceInterfacePoint().size(), "Given nep should support 1 SIP"); } - assertEquals("termination direction should be BIDIRECTIONAL", - TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection()); - assertEquals("operational state of client nep should be ENABLED", - OperationalState.ENABLED, nep.getOperationalState()); - assertEquals("link-port-role of client nep should be SYMMETRIC", - PortRole.SYMMETRIC, nep.getLinkPortRole()); + assertEquals(TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection(), + "termination direction should be BIDIRECTIONAL"); + assertEquals(OperationalState.ENABLED, nep.getOperationalState(), + "operational state of client nep should be ENABLED"); + assertEquals(PortRole.SYMMETRIC, nep.getLinkPortRole(), + "link-port-role of client nep should be SYMMETRIC"); } - private void checkTransitionalLink(org.opendaylight.yang.gen.v1 - .urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link, - Uuid node1Uuid, Uuid node2Uuid, String tp1, String tp2, String ietfNodeId) { - Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2) - .getBytes(Charset.forName("UTF-8"))).toString()); - assertEquals("bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2, linkUuid, link.getUuid()); - assertEquals("Available capacity unit should be GBPS", - CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit()); - assertEquals("Available capacity -total size value should be 100", - Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue()); - assertEquals("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA", - 2, link.getTransitionedLayerProtocolName().size()); + private void checkTransitionalLink( + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link, Uuid node1Uuid, + Uuid node2Uuid, String tp1, String tp2, String ietfNodeId) { + Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2).getBytes(Charset.forName("UTF-8"))) + .toString()); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2); + assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(), + "Available capacity unit should be GBPS"); + assertEquals(Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue(), + "Available capacity -total size value should be 100"); + assertEquals(2, link.getTransitionedLayerProtocolName().size(), + "transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA"); assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA", link.getTransitionedLayerProtocolName(), hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName())); - assertEquals("transitional link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), + "transitional link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("transitional links should terminate on DSR node and Photonic node", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); @@ -1263,25 +1229,22 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue()))); } - private void checkOmsLink(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link, - Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, - String linkName) { - assertEquals("bad name for the link", linkName, link.getName().get( - new NameKey("OMS link name")).getValue()); - assertEquals("bad uuid for link", linkUuid, link.getUuid()); - assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA", + Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) { + assertEquals(linkName, link.getName().get(new NameKey("OMS link name")).getValue(), "bad name for the link"); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link"); + assertEquals( LayerProtocolName.PHOTONICMEDIA.getName(), - link.getLayerProtocolName().stream().findFirst().get().getName()); - assertEquals("otn tapi link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + link.getLayerProtocolName().stream().findFirst().get().getName(), + "oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA"); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),"otn tapi link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(2 , nodeEdgePointList.size(), "oms link should be between 2 neps"); + assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("oms links should terminate on two distinct nodes", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); @@ -1296,25 +1259,25 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); } - private void checkXpdrRdmLink(org.opendaylight.yang.gen.v1.urn - .onf.otcc.yang.tapi.topology.rev181210.topology.Link link, - Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, - String linkName) { - assertEquals("bad name for the link", linkName, link.getName().get( - new NameKey("XPDR-RDM link name")).getValue()); - assertEquals("bad uuid for link", linkUuid, link.getUuid()); - assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA", + private void checkXpdrRdmLink( + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link link, Uuid node1Uuid, + Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) { + assertEquals(linkName, link.getName().get(new NameKey("XPDR-RDM link name")).getValue(), + "bad name for the link"); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link"); + assertEquals( LayerProtocolName.PHOTONICMEDIA.getName(), - link.getLayerProtocolName().stream().findFirst().get().getName()); - assertEquals("otn tapi link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + link.getLayerProtocolName().stream().findFirst().get().getName(), + "oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA"); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), + "otn tapi link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(2 , nodeEdgePointList.size(), "oms link should be between 2 neps"); + assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("oms links should terminate on two distinct nodes", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); @@ -1352,4 +1315,4 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { tpdr1Bldr.setTerminationPoint(tps); return new NodeBuilder(initialNode).addAugmentation(tpdr1Bldr.build()).build(); } -} +} \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java index ed2e52638..001e944e0 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java @@ -12,9 +12,9 @@ import static org.hamcrest.CoreMatchers.either; import static org.hamcrest.CoreMatchers.hasItem; import static org.hamcrest.CoreMatchers.hasItems; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.fail; import com.google.common.util.concurrent.FluentFuture; import java.nio.charset.Charset; @@ -28,8 +28,8 @@ import java.util.UUID; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors; import org.eclipse.jdt.annotation.Nullable; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +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.InstanceIdentifiers; @@ -111,8 +111,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { private static TapiLink tapiLink; private static DataBroker dataBroker = getDataBroker(); - @BeforeClass - public static void setUp() throws InterruptedException, ExecutionException { + @BeforeAll + static void setUp() throws InterruptedException, ExecutionException { TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II); TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), @@ -167,7 +167,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } @Test - public void convertNodeWhenNoStates() { + void convertNodeWhenNoStates() { Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", null, null); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { @@ -187,8 +187,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid)); - assertNull("Administrative State should not be present", nepN.getAdministrativeState()); - assertNull("Operational State should not be present", nepN.getOperationalState()); + assertNull(nepN.getAdministrativeState(), "Administrative State should not be present"); + assertNull(nepN.getOperationalState(), "Operational State should not be present"); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -202,16 +202,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid)); - assertNull("Administrative State should not be present", enep.getAdministrativeState()); - assertNull("Operational State should not be present", enep.getOperationalState()); + assertNull(enep.getAdministrativeState(), "Administrative State should not be present"); + assertNull(enep.getOperationalState(), "Operational State should not be present"); OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid)); - assertNull("Administrative State should not be present", inep.getAdministrativeState()); - assertNull("Operational State should not be present", inep.getOperationalState()); + assertNull(inep.getAdministrativeState(), "Administrative State should not be present"); + assertNull(inep.getOperationalState(), "Operational State should not be present"); } @Test - public void convertNodeWhenBadStates1() { + void convertNodeWhenBadStates1() { Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.OutOfService, State.OutOfService); List networkPortList = new ArrayList<>(); @@ -232,10 +232,9 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, nepN.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, nepN.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, nepN.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, nepN.getOperationalState(), "Operational State should be Disabled"); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -249,20 +248,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, enep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, enep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled"); OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, inep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, inep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled"); } @Test - public void convertNodeWhenBadStates2() { + void convertNodeWhenBadStates2() { Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.Maintenance, State.Degraded); List networkPortList = new ArrayList<>(); @@ -283,10 +280,9 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, nepN.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, nepN.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, nepN.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, nepN.getOperationalState(), "Operational State should be Disabled"); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -300,20 +296,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, enep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, enep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, enep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, enep.getOperationalState(), "Operational State should be Disabled"); OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid)); - assertEquals("Administrative State should be Locked", - AdministrativeState.LOCKED, inep.getAdministrativeState()); - assertEquals("Operational State should be Disabled", - OperationalState.DISABLED, inep.getOperationalState()); + assertEquals(AdministrativeState.LOCKED, inep.getAdministrativeState(), + "Administrative State should be Locked"); + assertEquals(OperationalState.DISABLED, inep.getOperationalState(), "Operational State should be Disabled"); } @Test - public void convertOtnLinkWhenNoState() { + void convertOtnLinkWhenNoState() { HashMap otnLinksAlt = new HashMap<>(otnLinks); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link @@ -341,16 +335,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { List tapiLinks = tapiFactory.getTapiLinks().values().stream() .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) .collect(Collectors.toList()); - assertNull("Administrative State should not be present", tapiLinks.get(3).getAdministrativeState()); - assertEquals("Administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState()); - assertNull("Operational State should not be present", tapiLinks.get(3).getOperationalState()); - assertEquals("Operational state should be ENABLED", - OperationalState.ENABLED, tapiLinks.get(0).getOperationalState()); + assertNull(tapiLinks.get(3).getAdministrativeState(), "Administrative State should not be present"); + assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(), + "Administrative state should be UNLOCKED"); + assertNull(tapiLinks.get(3).getOperationalState(), "Operational State should not be present"); + assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(), + "Operational state should be ENABLED"); } @Test - public void convertOtnLinkWhenNoStateOnOppositeLink() { + void convertOtnLinkWhenNoStateOnOppositeLink() { HashMap otnLinksAlt = new HashMap<>(otnLinks); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link @@ -378,16 +372,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { List tapiLinks = tapiFactory.getTapiLinks().values().stream() .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) .collect(Collectors.toList()); - assertNull("Administrative State should not be present", tapiLinks.get(3).getAdministrativeState()); - assertEquals("Administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState()); - assertNull("Operational State should not be present", tapiLinks.get(3).getOperationalState()); - assertEquals("Operational state should be ENABLED", - OperationalState.ENABLED, tapiLinks.get(0).getOperationalState()); + assertNull(tapiLinks.get(3).getAdministrativeState(), "Administrative State should not be present"); + assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(), + "Administrative state should be UNLOCKED"); + assertNull(tapiLinks.get(3).getOperationalState(), "Operational State should not be present"); + assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(), + "Operational state should be ENABLED"); } @Test - public void convertOtnLinkWhenBadState1() { + void convertOtnLinkWhenBadState1() { HashMap otnLinksAlt = new HashMap<>(otnLinks); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link @@ -416,18 +410,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { List tapiLinks = tapiFactory.getTapiLinks().values().stream() .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Administrative state should be LOCKED", - AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState()); - assertEquals("Administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState()); - assertEquals("Operational state should be DISABLED", - OperationalState.DISABLED, tapiLinks.get(3).getOperationalState()); - assertEquals("Operational state should be ENABLED", - OperationalState.ENABLED, tapiLinks.get(0).getOperationalState()); + assertEquals(AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState(), + "Administrative state should be LOCKED"); + assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(), + "Administrative state should be UNLOCKED"); + assertEquals(OperationalState.DISABLED, tapiLinks.get(3).getOperationalState(), + "Operational state should be DISABLED"); + assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(), + "Operational state should be ENABLED"); } @Test - public void convertOtnLinkWhenBadState2() { + void convertOtnLinkWhenBadState2() { HashMap otnLinksAlt = new HashMap<>(otnLinks); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link @@ -456,18 +450,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { List tapiLinks = tapiFactory.getTapiLinks().values().stream() .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Administrative state should be LOCKED", - AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState()); - assertEquals("Administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState()); - assertEquals("Operational state should be DISABLED", - OperationalState.DISABLED, tapiLinks.get(3).getOperationalState()); - assertEquals("Operational state should be ENABLED", - OperationalState.ENABLED, tapiLinks.get(0).getOperationalState()); + assertEquals(AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState(), + "Administrative state should be LOCKED"); + assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(), + "Administrative state should be UNLOCKED"); + assertEquals(OperationalState.DISABLED, tapiLinks.get(3).getOperationalState(), + "Operational state should be DISABLED"); + assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(), + "Operational state should be ENABLED"); } @Test - public void convertOtnLinkWhenBadStateOnOppositeLink() { + void convertOtnLinkWhenBadStateOnOppositeLink() { HashMap otnLinksAlt = new HashMap<>(otnLinks); org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link @@ -496,18 +490,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { List tapiLinks = tapiFactory.getTapiLinks().values().stream() .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Administrative state should be LOCKED", - AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState()); - assertEquals("Administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState()); - assertEquals("Operational state should be DISABLED", - OperationalState.DISABLED, tapiLinks.get(3).getOperationalState()); - assertEquals("Operational state should be ENABLED", - OperationalState.ENABLED, tapiLinks.get(0).getOperationalState()); + assertEquals(AdministrativeState.LOCKED, tapiLinks.get(3).getAdministrativeState(), + "Administrative state should be LOCKED"); + assertEquals(AdministrativeState.UNLOCKED, tapiLinks.get(0).getAdministrativeState(), + "Administrative state should be UNLOCKED"); + assertEquals(OperationalState.DISABLED, tapiLinks.get(3).getOperationalState(), + "Operational state should be DISABLED"); + assertEquals(OperationalState.ENABLED, tapiLinks.get(0).getOperationalState(), + "Operational state should be ENABLED"); } @Test - public void convertNodeForTransponder100G() { + void convertNodeForTransponder100G() { ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { @@ -521,8 +515,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2"); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -539,7 +533,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForOtnMuxponder() { + void convertNodeForOtnMuxponder() { ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { @@ -553,8 +547,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1"); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1+DSR"); @@ -570,7 +564,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } @Test - public void convertNodeForOtnSwitch() { + void convertNodeForOtnSwitch() { ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) { @@ -584,8 +578,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size()); + assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(4, tapiFactory.getTapiLinks().size(), "Link list size should be 4"); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -602,7 +596,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } @Test - public void convertOtnLink() { + void convertOtnLink() { ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink); List networkPortListA = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { @@ -619,7 +613,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } tapiFactory.convertNode(otnMuxC, networkPortListC); tapiFactory.convertLinks(otnLinks); - assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size()); + assertEquals(4, tapiFactory.getTapiLinks().size(), "Link list size should be 4"); Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) .toString()); @@ -654,12 +648,12 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } @Test - public void convertRoadmInfrastructureWhenNoXponderAttached() { + void convertRoadmInfrastructureWhenNoXponderAttached() { ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink); tapiFactory.convertRoadmInfrastructure(); - assertEquals("Node list size should be 1", 1, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be empty", 0, tapiFactory.getTapiLinks().size()); + assertEquals(1, tapiFactory.getTapiNodes().size(), "Node list size should be 1"); + assertEquals(0, tapiFactory.getTapiLinks().size(), "Link list size should be empty"); List tapiNodes = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8"))) @@ -668,7 +662,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { } @Test - public void convertRoadmInfrastructureWhenOtnMuxAttached() { + void convertRoadmInfrastructureWhenOtnMuxAttached() { ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid, tapiLink); List networkPortListA = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { @@ -679,8 +673,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { tapiFactory.convertNode(otnMuxA, networkPortListA); tapiFactory.convertRoadmInfrastructure(); - assertEquals("Node list size should be 3", 3, tapiFactory.getTapiNodes().size()); - assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size()); + assertEquals(3, tapiFactory.getTapiNodes().size(), "Node list size should be 3"); + assertEquals(2, tapiFactory.getTapiLinks().size(), "Link list size should be 2"); List tapiNodes = tapiFactory.getTapiNodes().values().stream() .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) @@ -710,16 +704,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node, Uuid nodeUuid, String dsrNodeType, String nodeId) { - assertEquals("incorrect node uuid", nodeUuid, node.getUuid()); - assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("dsr/odu node name")).getValue()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, node.getAdministrativeState()); - assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState()); - assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState()); + assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid"); + assertEquals(nodeId, node.getName().get(new NameKey("dsr/odu node name")).getValue(), "incorrect node name"); + assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(), + "administrative state should be UNLOCKED"); + assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED"); + assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED"); assertThat("one value-name should be 'dsr/odu node name'", new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("dsr/odu node name"))); - assertEquals("dsr node should manage 2 protocol layers : dsr and odu", - 2, node.getLayerProtocolName().size()); + assertEquals(2, node.getLayerProtocolName().size(), + "dsr node should manage 2 protocol layers : dsr and odu"); assertThat("dsr node should manage 2 protocol layers : dsr and odu", node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU)); List nepsN = node.nonnullOwnedNodeEdgePoint().values().stream() @@ -733,8 +727,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C"))) .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Switch-DSR node should have 4 NEPs network", 4, nepsN.size()); - assertEquals("Switch-DSR node should have 4 NEPs client", 4, nepsC.size()); + assertEquals(4, nepsN.size(), "Switch-DSR node should have 4 NEPs network"); + assertEquals(4, nepsC.size(), "Switch-DSR node should have 4 NEPs client"); OwnedNodeEdgePoint nep1 = nepsC.get(2); Uuid client4NepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR2-CLIENT4") @@ -757,8 +751,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C"))) .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Mux-DSR node should have 1 NEP network", 1, nepsN.size()); - assertEquals("Mux-DSR node should have 4 NEPs client", 4, nepsC.size()); + assertEquals(1, nepsN.size(), "Mux-DSR node should have 1 NEP network"); + assertEquals(4, nepsC.size(), "Mux-DSR node should have 4 NEPs client"); OwnedNodeEdgePoint nep3 = nepsC.get(2); Uuid client3NepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT3") @@ -782,8 +776,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr"))) .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("Tpdr-DSR node should have 2 NEPs network", 2, nepsN.size()); - assertEquals("Tpdr-DSR node should have 2 NEPs client", 2, nepsC.size()); + assertEquals(2, nepsN.size(), "Tpdr-DSR node should have 2 NEPs network"); + assertEquals(2, nepsC.size(), "Tpdr-DSR node should have 2 NEPs client"); OwnedNodeEdgePoint nep5 = nepsC.get(0); Uuid client1NepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT1") @@ -811,19 +805,18 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { private void checkOtsiNode( org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node, Uuid nodeUuid, String otsiNodeType, String nodeId) { - assertEquals("incorrect node uuid", nodeUuid, node.getUuid()); - assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("otsi node name")).getValue()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, node.getAdministrativeState()); - assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState()); - assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState()); + assertEquals(nodeUuid, node.getUuid(), "incorrect node uuid"); + assertEquals(nodeId, node.getName().get(new NameKey("otsi node name")).getValue(), "incorrect node name"); + assertEquals(AdministrativeState.UNLOCKED, node.getAdministrativeState(), + "administrative state should be UNLOCKED"); + assertEquals(LifecycleState.INSTALLED, node.getLifecycleState(), "life-cycle state should be INSTALLED"); + assertEquals(OperationalState.ENABLED, node.getOperationalState(), "operational state should be ENABLED"); assertThat("one value-name should be 'dsr/odu node name'", new ArrayList<>(node.nonnullName().keySet()), hasItem(new NameKey("otsi node name"))); - assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA", - 1, node.getLayerProtocolName().size()); - assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA", - LayerProtocolName.PHOTONICMEDIA, - node.getLayerProtocolName().stream().findFirst().get()); + assertEquals(1, node.getLayerProtocolName().size(), + "otsi node should manage a single protocol layer : PHOTONIC_MEDIA"); + assertEquals(LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().stream().findFirst().get(), + "otsi node should manage a single protocol layer : PHOTONIC_MEDIA"); List nepsI = node.nonnullOwnedNodeEdgePoint().values().stream() .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint"))) .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) @@ -834,8 +827,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { .collect(Collectors.toList()); switch (otsiNodeType) { case "switch": - assertEquals("Switch-OTSi node should have 4 eNEPs", 4, nepsE.size()); - assertEquals("Switch-OTSi node should have 4 iNEPs", 4, nepsI.size()); + assertEquals(4, nepsE.size(), "Switch-OTSi node should have 4 eNEPs"); + assertEquals(4, nepsI.size(), "Switch-OTSi node should have 4 iNEPs"); OwnedNodeEdgePoint nep1 = nepsI.get(1); Uuid inepUuid = new Uuid( UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iOTSi+XPDR2-NETWORK2") @@ -854,8 +847,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid); break; case "mux": - assertEquals("Mux-OTSi node should have 1 eNEP", 1, nepsE.size()); - assertEquals("Mux-OTSi node should have 1 iNEPs", 1, nepsI.size()); + assertEquals(1, nepsE.size(), "Mux-OTSi node should have 1 eNEP"); + assertEquals(1, nepsI.size(), "Mux-OTSi node should have 1 iNEPs"); OwnedNodeEdgePoint nep3 = nepsE.get(0); Uuid enepUuid2 = new Uuid( UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1") @@ -874,8 +867,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid); break; case "tpdr": - assertEquals("Tpdr-OTSi node should have 2 eNEPs", 2, nepsE.size()); - assertEquals("Tpdr-OTSi node should have 2 iNEPs", 2, nepsI.size()); + assertEquals(2, nepsE.size(), "Tpdr-OTSi node should have 2 eNEPs"); + assertEquals(2, nepsI.size(), "Tpdr-OTSi node should have 2 iNEPs"); OwnedNodeEdgePoint nep5 = nepsE.get(0); Uuid enepUuid3 = new Uuid( UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1") @@ -915,48 +908,48 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, String nodeId, String extension) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); Name name = nameList.get(0); - assertEquals("value of client nep should be '" + portName + "'", - String.join("+", nodeId, extension, portName), name.getValue()); - assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", - nepName, name.getValueName()); - assertEquals("Client nep should support 3 kind of cep", - 3, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(String.join("+", nodeId, extension, portName), name.getValue(), + "value of client nep should be '" + portName + "'"); + assertEquals(nepName, name.getValueName(), + "value-name of client nep for '" + portName + "' should be '" + nepName + "'"); + assertEquals(3, nep.getSupportedCepLayerProtocolQualifier().size(), + "Client nep should support 3 kind of cep"); assertThat("client nep should support 3 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(ODUTYPEODU2.VALUE, ODUTYPEODU2E.VALUE, DIGITALSIGNALTYPE10GigELAN.VALUE)); - assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.ETH, nep.getLayerProtocolName(), "client nep should be of ETH protocol type"); checkCommonPartOfNep(nep, false); checkSIP(nep, portName, nodeId, extension); } private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, String nodeId, String extension) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); Name name = nameList.get(0); - assertEquals("value of network nep should be '" + portName + "'", - String.join("+", nodeId, extension, portName), name.getValue()); - assertEquals("value-name of network nep for '" + portName + "' should be '" + nepName + "'", - nepName, name.getValueName()); - assertEquals("Network nep should support 1 kind of cep", - 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(String.join("+", nodeId, extension, portName), name.getValue(), + "value of network nep should be '" + portName + "'"); + assertEquals(nepName, name.getValueName(), + "value-name of network nep for '" + portName + "' should be '" + nepName + "'"); + assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), + "Network nep should support 1 kind of cep"); assertThat("network nep should support 1 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItem(ODUTYPEODU4.VALUE)); - assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.ODU, nep.getLayerProtocolName(), "network nep should be of ODU protocol type"); checkCommonPartOfNep(nep, false); checkSIP(nep, portName, nodeId, extension); } private void checkNodeRuleGroupForTpdrDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, Uuid nodeUuid) { - assertEquals("transponder DSR should contain 2 node rule group", 2, nrgList.size()); + assertEquals(2, nrgList.size(), "transponder DSR should contain 2 node rule group"); for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals("each node-rule-group should contain 2 NEP for transponder DSR", - 2, nodeRuleGroup.getNodeEdgePoint().size()); + assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), + "each node-rule-group should contain 2 NEP for transponder DSR"); } List nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values()); assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1", @@ -965,26 +958,24 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); - assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node", - nodeEdgePointList.get(0).getNodeUuid(), nodeUuid); - assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node", - nodeEdgePointList.get(1).getNodeUuid(), nodeUuid); + assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid, + "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node"); + assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid, + "node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node"); List rule = new ArrayList<>(nrgList.get(1).nonnullRule().values()); - assertEquals("node-rule-group nb 1 should contain a single rule", 1, rule.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", rule.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, rule.get(0).getRuleType()); + assertEquals(1, rule.size(), "node-rule-group nb 1 should contain a single rule"); + assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForMuxDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, Uuid nodeUuid) { - assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size()); + assertEquals(4, nrgList.size(), "muxponder DSR should contain 4 node rule group"); for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR", - 2, nodeRuleGroup.getNodeEdgePoint().size()); + assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), + "each node-rule-group should contain 2 NEP for muxponder DSR"); } List nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values()); assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1", @@ -993,122 +984,112 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); - assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node", - nodeEdgePointList.get(0).getNodeUuid(), nodeUuid); - assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node", - nodeEdgePointList.get(1).getNodeUuid(), nodeUuid); + assertEquals(nodeEdgePointList.get(0).getNodeUuid(), nodeUuid, + "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node"); + assertEquals(nodeEdgePointList.get(1).getNodeUuid(), nodeUuid, + "node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node"); List rule = new ArrayList<>(nrgList.get(1).nonnullRule().values()); - assertEquals("node-rule-group nb 2 should contain a single rule", 1, rule.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", rule.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, rule.get(0).getRuleType()); + assertEquals(1, rule.size(), "node-rule-group nb 2 should contain a single rule"); + assertEquals("forward", rule.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, rule.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForSwitchDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, Uuid nodeUuid) { - assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size()); - assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size()); + assertEquals(1, nrgList.size(), "Switch-DSR should contain a single node rule group"); + assertEquals(8, nrgList.get(0).getNodeEdgePoint().size(), "Switch-DSR node-rule-group should contain 8 NEP"); List nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream() .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue() .compareTo(nrg2.getNodeEdgePointUuid().getValue())) .collect(Collectors.toList()); - assertEquals("in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1", - networkNepUuid, nrg.get(6).getNodeEdgePointUuid()); - assertEquals("in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4", - clientNepUuid, nrg.get(5).getNodeEdgePointUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nrg.get(4).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nrg.get(3).getNodeUuid()); + assertEquals(networkNepUuid, nrg.get(6).getNodeEdgePointUuid(), + "in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1"); + assertEquals(clientNepUuid, nrg.get(5).getNodeEdgePointUuid(), + "in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4"); + assertEquals(nodeUuid, nrg.get(4).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nrg.get(3).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); @Nullable List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForRdmInfra(List nrgList, int nbNeps) { - assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size()); + assertEquals(1, nrgList.size(), "RDM infra node - OTSi should contain a single node rule groups"); if (nbNeps > 0) { List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("RDM infra node -rule-group should contain " + nbNeps + " NEP", - nbNeps, nodeEdgePointList.size()); + assertEquals(nbNeps, nodeEdgePointList.size(), + "RDM infra node -rule-group should contain " + nbNeps + " NEP"); } else { - assertNull("RDM infra node -rule-group should contain no NEP", nrgList.get(0).getNodeEdgePoint()); + assertNull(nrgList.get(0).getNodeEdgePoint(), "RDM infra node -rule-group should contain no NEP"); } List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForTpdrOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, Uuid nodeUuid) { - assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size()); + assertEquals(2, nrgList.size(), "Tpdr-OTSi should contain two node rule groups"); List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size()); + assertEquals(2, nodeEdgePointList.size(), "Tpdr-OTSi node-rule-group should contain 2 NEP"); assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(0).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(1).getNodeUuid()); + assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForMuxOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, Uuid nodeUuid) { - assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size()); + assertEquals(1, nrgList.size(), "Mux-OTSi should contain a single node rule group"); List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size()); + assertEquals(2, nodeEdgePointList.size(), "Mux-OTSi node-rule-group should contain 2 NEP"); assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(0).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList.get(1).getNodeUuid()); + assertEquals(nodeUuid, nodeEdgePointList.get(0).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nodeEdgePointList.get(1).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForSwitchOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, Uuid nodeUuid) { - assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size()); + assertEquals(4, nrgList.size(), "Switch-OTSi should contain 4 node rule group"); for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi", - 2, nodeRuleGroup.getNodeEdgePoint().size()); + assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), + "each node-rule-group should contain 2 NEP for Switch-OTSi"); } List nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values()); assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2", @@ -1118,72 +1099,66 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(), either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); List nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList0.get(0).getNodeUuid()); - assertEquals("any item of the node-rule-group should have the same nodeUuid", - nodeUuid, nodeEdgePointList0.get(1).getNodeUuid()); + assertEquals(nodeUuid, nodeEdgePointList0.get(0).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); + assertEquals(nodeUuid, nodeEdgePointList0.get(1).getNodeUuid(), + "any item of the node-rule-group should have the same nodeUuid"); List ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList0.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList0.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList0.get(0).getRuleType()); + assertEquals(1, ruleList0.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList0.get(0).getLocalId(),"local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList0.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, String nodeId, String extension) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of client nep should be '" + portName + "'", - String.join("+", nodeId, extension, portName), nameList.get(0).getValue()); - assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", - nepName, nameList.get(0).getValueName()); - assertEquals("Client nep should support 2 kind of cep", - 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(String.join("+", nodeId, extension, portName), nameList.get(0).getValue(), + "value of client nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), + "value-name of client nep for '" + portName + "' should be '" + nepName + "'"); + assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 2 kind of cep"); assertThat("client nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(ODUTYPEODU4.VALUE, DIGITALSIGNALTYPE100GigE.VALUE)); - assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.ETH, nep.getLayerProtocolName(), "client nep should be of ETH protocol type"); checkCommonPartOfNep(nep, false); checkSIP(nep, portName, nodeId, extension); } private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, String nodeId, String extension) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of client nep should be '" + portName + "'", - String.join("+", nodeId, extension, portName), nameList.get(0).getValue()); - assertEquals("value-name of client nep for '" + portName + "' should be 100G-tpdr'", - nepName, nameList.get(0).getValueName()); - assertEquals("Client nep should support 1 kind of cep", - 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(String.join("+", nodeId, extension, portName), nameList.get(0).getValue(), + "value of client nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), + "value-name of client nep for '" + portName + "' should be 100G-tpdr'"); + assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), "Client nep should support 1 kind of cep"); assertThat("client nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(DIGITALSIGNALTYPE100GigE.VALUE)); - assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName()); + assertEquals(LayerProtocolName.ETH, nep.getLayerProtocolName(), "client nep should be of ETH protocol type"); checkCommonPartOfNep(nep, false); checkSIP(nep, portName, nodeId, extension); } private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, String nodeId, String extension) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of OTSi nep should be '" + portName + "'", - String.join("+", nodeId, extension, portName), nameList.get(0).getValue()); - assertEquals("value-name of OTSi nep should be '" + nepName + "'", - nepName, nameList.get(0).getValueName()); - assertEquals("OTSi nep should support 2 kind of cep", - 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(String.join("+", nodeId, extension, portName), nameList.get(0).getValue(), + "value of OTSi nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), "value-name of OTSi nep should be '" + nepName + "'"); + assertEquals(2, nep.getSupportedCepLayerProtocolQualifier().size(), "OTSi nep should support 2 kind of cep"); assertThat("OTSi nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE, PHOTONICLAYERQUALIFIEROTSi.VALUE)); - assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", - LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); - assertEquals("OTSi nep should support one SIP", 1, nep.getMappedServiceInterfacePoint().size()); + assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(), + "OTSi nep should be of PHOTONIC_MEDIA protocol type"); + assertEquals(1, nep.getMappedServiceInterfacePoint().size(), "OTSi nep should support one SIP"); checkCommonPartOfNep(nep, false); checkSIP(nep, portName, nodeId, extension); } @@ -1191,70 +1166,71 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { private void checkSIP(OwnedNodeEdgePoint nep, String portName, String nodeId, String extension) { Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeId, extension, portName)) .getBytes(Charset.forName("UTF-8"))).toString()); - assertEquals("service-interface-point-uuid of network nep for '" + portName + "' should be '" - + String.join("+", "SIP", portName) + "'", sipUuid, nep.getMappedServiceInterfacePoint() - .get(new MappedServiceInterfacePointKey(sipUuid)).getServiceInterfacePointUuid()); + assertEquals( + sipUuid, + nep.getMappedServiceInterfacePoint().get(new MappedServiceInterfacePointKey(sipUuid)) + .getServiceInterfacePointUuid(), + "service-interface-point-uuid of network nep for '" + portName + "' should be '" + + String.join("+", "SIP", portName) + "'"); } private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { - assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals(nepUuid, nep.getUuid(), "bad uuid for " + portName); List nameList = new ArrayList<>(nep.nonnullName().values()); - assertEquals("value of OTSi nep should be '" + portName + "'", - portName, nameList.get(0).getValue()); - assertEquals("value-name of OTSi nep should be '" + nepName + "'", - nepName, nameList.get(0).getValueName()); - assertEquals("OTSi nep of RDM infra node should support only 1 kind of cep", - 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertEquals(portName, nameList.get(0).getValue(), "value of OTSi nep should be '" + portName + "'"); + assertEquals(nepName, nameList.get(0).getValueName(), "value-name of OTSi nep should be '" + nepName + "'"); + assertEquals(1, nep.getSupportedCepLayerProtocolQualifier().size(), + "OTSi nep of RDM infra node should support only 1 kind of cep"); assertThat("OTSi nep should support 2 kind of cep", nep.getSupportedCepLayerProtocolQualifier(), hasItems(PHOTONICLAYERQUALIFIEROMS.VALUE)); - assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", - LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); - assertEquals("OTSi nep of RDM infra should support no SIP", 0, nep.nonnullMappedServiceInterfacePoint().size()); + assertEquals(LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName(), + "OTSi nep should be of PHOTONIC_MEDIA protocol type"); + assertEquals(0, nep.nonnullMappedServiceInterfacePoint().size(), "OTSi nep of RDM infra should support no SIP"); checkCommonPartOfNep(nep, true); } private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean isRdm) { - assertEquals("link port direction should be DIRECTIONAL", - PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, nep.getAdministrativeState()); - assertEquals("termination state should be TERMINATED BIDIRECTIONAL", - TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState()); - assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, nep.getLifecycleState()); + assertEquals(PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection(), + "link port direction should be DIRECTIONAL"); + assertEquals(AdministrativeState.UNLOCKED, nep.getAdministrativeState(), + "administrative state should be UNLOCKED"); + assertEquals(TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState(), + "termination state should be TERMINATED BIDIRECTIONAL"); + assertEquals(LifecycleState.INSTALLED, nep.getLifecycleState(), + "life-cycle state should be INSTALLED"); if (!isRdm) { - assertEquals("client nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size()); + assertEquals(1, nep.getMappedServiceInterfacePoint().size(), "client nep should support 1 SIP"); } - assertEquals("termination direction should be BIDIRECTIONAL", - TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection()); - assertEquals("operational state of client nep should be ENABLED", - OperationalState.ENABLED, nep.getOperationalState()); - assertEquals("link-port-role of client nep should be SYMMETRIC", - PortRole.SYMMETRIC, nep.getLinkPortRole()); + assertEquals(TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection(), + "termination direction should be BIDIRECTIONAL"); + assertEquals(OperationalState.ENABLED, nep.getOperationalState(), + "operational state of client nep should be ENABLED"); + assertEquals(PortRole.SYMMETRIC, nep.getLinkPortRole(), "link-port-role of client nep should be SYMMETRIC"); } private void checkTransitionalLink(Link link, Uuid node1Uuid, Uuid node2Uuid, String tp1, String tp2, String ietfNodeId) { Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "to" + tp2) .getBytes(Charset.forName("UTF-8"))).toString()); - assertEquals("bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2, linkUuid, link.getUuid()); - assertEquals("Available capacity unit should be GBPS", - CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit()); - assertEquals("Available capacity -total size value should be 100", - Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue()); - assertEquals("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA", - 2, link.getTransitionedLayerProtocolName().size()); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2); + assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(), + "Available capacity unit should be GBPS"); + assertEquals(Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue(), + "Available capacity -total size value should be 100"); + assertEquals(2, link.getTransitionedLayerProtocolName().size(), + "transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA"); assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA", link.getTransitionedLayerProtocolName(), hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName())); - assertEquals("transitional link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), + "transitional link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("transitional links should terminate on DSR node and Photonic node", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); @@ -1273,39 +1249,40 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { private void checkOtnLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) { - assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("otn link name")).getValue()); - assertEquals("bad uuid for link", linkUuid, link.getUuid()); - assertEquals("Available capacity unit should be MBPS", - CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit()); + assertEquals(linkName, link.getName().get(new NameKey("otn link name")).getValue(), "bad name for the link"); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link"); + assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(), + "Available capacity unit should be MBPS"); String prefix = linkName.split("-")[0]; if ("OTU4".equals(prefix)) { - assertEquals("Available capacity -total size value should be 0", - Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue()); + assertEquals(Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue(), + "Available capacity -total size value should be 0"); } else if ("ODTU4".equals(prefix)) { - assertEquals("Available capacity -total size value should be 100 000", - Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue()); + assertEquals(Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue(), + "Available capacity -total size value should be 100 000"); } - assertEquals("Total capacity unit should be GBPS", - CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit()); - assertEquals("Total capacity -total size value should be 100", - Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue()); + assertEquals(CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit(), + "Total capacity unit should be GBPS"); + assertEquals(Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue(), + "Total capacity -total size value should be 100"); if ("OTU4".equals(prefix)) { - assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA", + assertEquals( LayerProtocolName.PHOTONICMEDIA.getName(), - link.getLayerProtocolName().stream().findFirst().get().getName()); + link.getLayerProtocolName().stream().findFirst().get().getName(), + "otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA"); } else if ("ODTU4".equals(prefix)) { - assertEquals("otn link should be between 2 nodes of protocol layers ODU", + assertEquals( LayerProtocolName.ODU.getName(), - link.getLayerProtocolName().stream().findFirst().get().getName()); + link.getLayerProtocolName().stream().findFirst().get().getName(), + "otn link should be between 2 nodes of protocol layers ODU"); } - assertEquals("otn tapi link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), "otn tapi link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("otn links should terminate on two distinct nodes", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); @@ -1318,28 +1295,27 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest { assertThat("otn links should terminate on two distinct tps", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); - assertEquals("operational state should be ENABLED", - OperationalState.ENABLED, link.getOperationalState()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, link.getAdministrativeState()); + assertEquals(OperationalState.ENABLED, link.getOperationalState(), "operational state should be ENABLED"); + assertEquals(AdministrativeState.UNLOCKED, link.getAdministrativeState(), + "administrative state should be UNLOCKED"); } private void checkOmsLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) { - assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("OMS link name")).getValue()); - assertEquals("bad uuid for link", linkUuid, link.getUuid()); - assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA", + assertEquals(linkName, link.getName().get(new NameKey("OMS link name")).getValue(), "bad name for the link"); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link"); + assertEquals( LayerProtocolName.PHOTONICMEDIA.getName(), - link.getLayerProtocolName().stream().findFirst().get().getName()); - assertEquals("otn tapi link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + link.getLayerProtocolName().stream().findFirst().get().getName(), + "oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA"); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), "otn tapi link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topologyUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(2, nodeEdgePointList.size(), "oms link should be between 2 neps"); + assertEquals(topologyUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topologyUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("oms links should terminate on two distinct nodes", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java index 9f4f466e7..31556e8c5 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplExceptionTest.java @@ -7,7 +7,7 @@ */ package org.opendaylight.transportpce.tapi.topology; -import static org.junit.Assert.assertNull; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -17,7 +17,7 @@ import com.google.common.util.concurrent.ListenableFuture; import java.util.Optional; import java.util.concurrent.ExecutionException; import org.eclipse.jdt.annotation.NonNull; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.mockito.Mock; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -39,14 +39,14 @@ import org.opendaylight.yangtools.yang.common.RpcResult; public class TapiTopologyImplExceptionTest { @Mock - TapiContext tapiContext; + private TapiContext tapiContext; @Mock - TopologyUtils topologyUtils; + private TopologyUtils topologyUtils; @Mock - TapiLink tapiLink; + private TapiLink tapiLink; @Test - public void getTopologyDetailsWithExceptionTest() throws InterruptedException, ExecutionException { + void getTopologyDetailsWithExceptionTest() throws InterruptedException, ExecutionException { DataBroker dataBroker = mock(DataBroker.class); when(dataBroker.newReadOnlyTransaction()) .thenReturn(new ReadTransactionMock()); @@ -70,9 +70,9 @@ public class TapiTopologyImplExceptionTest { RpcResult rpcResult = result.get(); if (rpcResult.isSuccessful()) { Topology topology = rpcResult.getResult().getTopology(); - assertNull("Topology should be null", topology); + assertNull(topology, "Topology should be null"); } else { - assertNull("Topology should be null", null); + assertNull(null, "Topology should be null"); } } @@ -102,5 +102,4 @@ public class TapiTopologyImplExceptionTest { // TODO Auto-generated method stub } } - -} +} \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java index a78040dc0..fd339a28b 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java @@ -10,8 +10,8 @@ package org.opendaylight.transportpce.tapi.topology; import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.either; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ListeningExecutorService; @@ -27,8 +27,8 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.stream.Collectors; import org.eclipse.jdt.annotation.Nullable; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.opendaylight.transportpce.common.InstanceIdentifiers; import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.common.network.NetworkTransactionService; @@ -84,16 +84,16 @@ public class TapiTopologyImplTest extends AbstractTest { private static ListeningExecutorService executorService; private static CountDownLatch endSignal; private static final int NUM_THREADS = 3; - public static NetworkTransactionService networkTransactionService; - public static TapiContext tapiContext; - public static TopologyUtils topologyUtils; - public static ConnectivityUtils connectivityUtils; - public static ServiceDataStoreOperations serviceDataStoreOperations; - public static TapiInitialORMapping tapiInitialORMapping; - public static TapiLink tapiLink; + private static NetworkTransactionService networkTransactionService; + private static TapiContext tapiContext; + private static TopologyUtils topologyUtils; + private static ConnectivityUtils connectivityUtils; + private static ServiceDataStoreOperations serviceDataStoreOperations; + private static TapiInitialORMapping tapiInitialORMapping; + private static TapiLink tapiLink; - @BeforeClass - public static void setUp() throws InterruptedException, ExecutionException { + @BeforeAll + static void setUp() throws InterruptedException, ExecutionException { executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS)); endSignal = new CountDownLatch(1); TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), @@ -119,7 +119,7 @@ public class TapiTopologyImplTest extends AbstractTest { } @Test - public void getTopologyDetailsForTransponder100GTopologyWhenSuccessful() + void getTopologyDetailsForTransponder100GTopologyWhenSuccessful() throws ExecutionException, InterruptedException { GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( TapiStringConstants.TPDR_100G); @@ -135,37 +135,35 @@ public class TapiTopologyImplTest extends AbstractTest { RpcResult rpcResult = result.get(); @Nullable Topology topology = rpcResult.getResult().getTopology(); - assertNotNull("Topology should not be null", topology); + assertNotNull(topology, "Topology should not be null"); Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.TPDR_100G.getBytes(StandardCharsets.UTF_8)) .toString()); - assertEquals("incorrect topology uuid", topoUuid, topology.getUuid()); - assertEquals("Node list size should be 1", 1, topology.getNode().size()); + assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid"); + assertEquals(1, topology.getNode().size(), "Node list size should be 1"); Name nodeName = topology.getNode().values().stream().findFirst().get().getName() .get(new NameKey("Tpdr100g node name")); - assertEquals("Node name should be 'Tpdr100g over WDM node'", "Tpdr100g over WDM node", nodeName.getValue()); + assertEquals("Tpdr100g over WDM node", nodeName.getValue(), "Node name should be 'Tpdr100g over WDM node'"); Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(nodeName.getValue().getBytes(StandardCharsets.UTF_8)) .toString()); - assertEquals("incorrect node uuid", nodeUuid, topology.getNode().values().stream().findFirst().get().getUuid()); + assertEquals(nodeUuid, topology.getNode().values().stream().findFirst().get().getUuid(), "incorrect node uuid"); long nb = topology.getNode().values().stream().findFirst().get().getOwnedNodeEdgePoint().size(); - assertEquals("'Transponder 100GE' node should have 2 neps", 2, nb); + assertEquals(2, nb, "'Transponder 100GE' node should have 2 neps"); List nrgList = topology.getNode().values().stream().findFirst().get().nonnullNodeRuleGroup() .values().stream().sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) .collect(Collectors.toList()); - assertEquals("'Transponder 100GE' node should contain a single node rule groups", 1, nrgList.size()); + assertEquals(1, nrgList.size(), "'Transponder 100GE' node should contain a single node rule groups"); List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals("'Transponder 100GE' node -rule-group should contain 2 NEPs", nb, nodeEdgePointList.size()); + assertEquals(nb, nodeEdgePointList.size(), "'Transponder 100GE' node -rule-group should contain 2 NEPs"); List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals("node-rule-group should contain a single rule", 1, ruleList.size()); - assertEquals("local-id of the rule should be 'forward'", - "forward", ruleList.get(0).getLocalId()); - assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", - ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule()); - assertEquals("the rule type should be 'FORWARDING'", - RuleType.FORWARDING, ruleList.get(0).getRuleType()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType(), "the rule type should be 'FORWARDING'"); } @Test - public void getTopologyDetailsForOtnTopologyWithOtnLinksWhenSuccessful() + void getTopologyDetailsForOtnTopologyWithOtnLinksWhenSuccessful() throws ExecutionException, InterruptedException { GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( TapiStringConstants.T0_MULTILAYER); @@ -181,8 +179,8 @@ public class TapiTopologyImplTest extends AbstractTest { RpcResult rpcResult = result.get(); @Nullable Topology topology = rpcResult.getResult().getTopology(); - assertNotNull("Topology should not be null", topology); - assertEquals("Node list size should be 13", 13, topology.getNode().size()); + assertNotNull(topology, "Topology should not be null"); + assertEquals(13, topology.getNode().size(), "Node list size should be 13"); long nb1 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue() @@ -190,7 +188,7 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr")))) .count(); - assertEquals("XPDR-A1-XPDR1 should only have one client nep", 1, nb1); + assertEquals(1, nb1, "XPDR-A1-XPDR1 should only have one client nep"); long nb2 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue() @@ -198,7 +196,7 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C")))) .count(); - assertEquals("SPDR-SA1-XPDR1 (mux) should have 4 client neps", 4, nb2); + assertEquals(4, nb2, "SPDR-SA1-XPDR1 (mux) should have 4 client neps"); long nb3 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue() @@ -206,7 +204,7 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N")))) .count(); - assertEquals("SPDR-SA1-XPDR1 (mux) should have a single network nep", 1, nb3); + assertEquals(1, nb3, "SPDR-SA1-XPDR1 (mux) should have a single network nep"); long nb4 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue() @@ -214,7 +212,7 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C")))) .count(); - assertEquals("SPDR-SA1-XPDR2 (switch) should have 4 client neps", 4, nb4); + assertEquals(4, nb4, "SPDR-SA1-XPDR2 (switch) should have 4 client neps"); long nb5 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue() @@ -222,29 +220,30 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N")))) .count(); - assertEquals("SPDR-SA1-XPDR2 (switch) should have 2 network neps", 2, nb5); - assertEquals("Link list size should be 18", 18, topology.getLink().size()); + assertEquals(2, nb5, "SPDR-SA1-XPDR2 (switch) should have 2 network neps"); + assertEquals(18, topology.getLink().size(), "Link list size should be 18"); Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Multi-layer topology".getBytes()).toString()); - assertEquals("incorrect topology uuid", topoUuid, topology.getUuid()); - assertEquals("topology name should be T0 - Multi-layer topology", + assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid"); + assertEquals( "T0 - Multi-layer topology", - topology.nonnullName().values().stream().findFirst().get().getValue()); + topology.nonnullName().values().stream().findFirst().get().getValue(), + "topology name should be T0 - Multi-layer topology"); long nbDsrOduNodes = topology.nonnullNode().values().stream() .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count(); long nbPhotonicNodes = topology.nonnullNode().values().stream() .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count(); - assertEquals("Node list should contain 6 DSR-ODU nodes", 6, nbDsrOduNodes); - assertEquals("Node list should contain 7 Photonics nodes", 7, nbPhotonicNodes); + assertEquals(6, nbDsrOduNodes, "Node list should contain 6 DSR-ODU nodes"); + assertEquals(7, nbPhotonicNodes, "Node list should contain 7 Photonics nodes"); long nbTransititionalLinks = topology.getLink().values().stream() .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count(); long nbOmsLinks = topology.getLink().values().stream() .filter(l -> l.getName().containsKey(new NameKey("OMS link name"))).count(); long nbOtnLinks = topology.getLink().values().stream() .filter(l -> l.getName().containsKey(new NameKey("otn link name"))).count(); - assertEquals("Link list should contain 8 transitional links", 8, nbTransititionalLinks); - assertEquals("Link list should contain 8 transitional links", 8, nbOmsLinks); - assertEquals("Link list should contain 2 OTN links", 2, nbOtnLinks); + assertEquals(8, nbTransititionalLinks, "Link list should contain 8 transitional links"); + assertEquals(8, nbOmsLinks, "Link list should contain 8 transitional links"); + assertEquals(2, nbOtnLinks, "Link list should contain 2 OTN links"); Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8)) .toString()); @@ -280,7 +279,7 @@ public class TapiTopologyImplTest extends AbstractTest { } @Test - public void getTopologyDetailsForFullTapiTopologyWithLinksWhenSuccessful() + void getTopologyDetailsForFullTapiTopologyWithLinksWhenSuccessful() throws ExecutionException, InterruptedException { GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( TapiStringConstants.T0_FULL_MULTILAYER); @@ -296,9 +295,9 @@ public class TapiTopologyImplTest extends AbstractTest { RpcResult rpcResult = result.get(); @Nullable Topology topology = rpcResult.getResult().getTopology(); - assertNotNull("Topology should not be null", topology); + assertNotNull(topology, "Topology should not be null"); // 2 Nodes per Xpdr/Spdr node (DSR-ODU & PHOT) + 1 Node per Roadm - assertEquals("Node list size should be 18", 18, topology.getNode().size()); + assertEquals(18, topology.getNode().size(), "Node list size should be 18"); long nb1 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR")) @@ -306,63 +305,63 @@ public class TapiTopologyImplTest extends AbstractTest { .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr")))) .count(); // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs - assertEquals("XPDR-A1-XPDR1+DSR should only have two client neps", 2, nb1); + assertEquals(2, nb1, "XPDR-A1-XPDR1+DSR should only have two client neps"); long inb1 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N")))) .count(); - assertEquals("XPDR-A1-XPDR1+DSR should only have two internal network neps", 2, inb1); + assertEquals(2, inb1, "XPDR-A1-XPDR1+DSR should only have two internal network neps"); long enb1 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N")))) .count(); - assertEquals("XPDR-A1-XPDR1+DSR should only have two external network neps", 2, enb1); + assertEquals(2, enb1, "XPDR-A1-XPDR1+DSR should only have two external network neps"); long nb2 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C")))) .count(); - assertEquals("SPDR-SA1-XPDR1+DSR (mux) should have 4 client neps", 4, nb2); + assertEquals(4, nb2, "SPDR-SA1-XPDR1+DSR (mux) should have 4 client neps"); long inb3 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N")))) .count(); - assertEquals("SPDR-SA1-XPDR1+DSR (mux) should have a single internal network nep", 1, inb3); + assertEquals(1, inb3, "SPDR-SA1-XPDR1+DSR (mux) should have a single internal network nep"); long enb3 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N")))) .count(); - assertEquals("SPDR-SA1-XPDR1+DSR (mux) should have 4 external network nep", 4, enb3); + assertEquals(4, enb3, "SPDR-SA1-XPDR1+DSR (mux) should have 4 external network nep"); long nb4 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C")))) .count(); - assertEquals("SPDR-SA1-XPDR2+DSR (switch) should have 4 client neps", 4, nb4); + assertEquals(4, nb4, "SPDR-SA1-XPDR2+DSR (switch) should have 4 client neps"); long inb5 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N")))) .count(); - assertEquals("SPDR-SA1-XPDR2+DSR (switch) should have 4 internal network neps", 4, inb5); + assertEquals(4, inb5, "SPDR-SA1-XPDR2+DSR (switch) should have 4 internal network neps"); long enb5 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N")))) .count(); - assertEquals("SPDR-SA1-XPDR2+DSR (switch) should have 4 external network neps", 4, enb5); + assertEquals(4, enb5, "SPDR-SA1-XPDR2+DSR (switch) should have 4 external network neps"); // Now lets check for the Photonic media nodes (same nodes as for DSR + 1 Roadm node) nb1 = topology.getNode().values().stream() @@ -372,63 +371,63 @@ public class TapiTopologyImplTest extends AbstractTest { .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint")))) .count(); // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs - assertEquals("XPDR-A1-XPDR1+OTSi should only have two internal network neps", 2, nb1); + assertEquals(2, nb1, "XPDR-A1-XPDR1+OTSi should only have two internal network neps"); inb1 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint")))) .count(); - assertEquals("XPDR-A1-XPDR1+OTSi should only have two external network neps", 2, inb1); + assertEquals(2, inb1, "XPDR-A1-XPDR1+OTSi should only have two external network neps"); enb1 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint")))) .count(); - assertEquals("XPDR-A1-XPDR1+OTSi should only have two photonic network neps", 2, enb1); + assertEquals(2, enb1, "XPDR-A1-XPDR1+OTSi should only have two photonic network neps"); nb2 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint")))) .count(); - assertEquals("SPDR-SA1-XPDR1+OTSi (mux) should have a single internal network nep", 1, nb2); + assertEquals(1, nb2, "SPDR-SA1-XPDR1+OTSi (mux) should have a single internal network nep"); inb3 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint")))) .count(); - assertEquals("SPDR-SA1-XPDR1+OTSi (mux) should have a single external network nep", 1, inb3); + assertEquals(1, inb3, "SPDR-SA1-XPDR1+OTSi (mux) should have a single external network nep"); enb3 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint")))) .count(); - assertEquals("SPDR-SA1-XPDR1+OTSi (mux) should have a single photonic network nep", 1, enb3); + assertEquals(1, enb3, "SPDR-SA1-XPDR1+OTSi (mux) should have a single photonic network nep"); nb4 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint")))) .count(); - assertEquals("SPDR-SA1-XPDR2+OTSi (switch) should have 4 internal network neps", 4, nb4); + assertEquals(4, nb4, "SPDR-SA1-XPDR2+OTSi (switch) should have 4 internal network neps"); inb5 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint")))) .count(); - assertEquals("SPDR-SA1-XPDR2+OTSi (switch) should have 4 external network neps", 4, inb5); + assertEquals(4, inb5, "SPDR-SA1-XPDR2+OTSi (switch) should have 4 external network neps"); enb5 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+OTSi")) .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().containsKey(new NameKey("PhotMedNodeEdgePoint")))) .count(); - assertEquals("SPDR-SA1-XPDR2+OTSi (switch) should have 4 photonic network neps", 4, enb5); + assertEquals(4, enb5, "SPDR-SA1-XPDR2+OTSi (switch) should have 4 photonic network neps"); // We should have 3 neps per DEGREE-TTP port and 3 neps per SRG-PP port long inb6 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) @@ -437,7 +436,7 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().values().stream().findFirst().get().getValue().contains("DEG"))) .count(); - assertEquals("ROADM-A1+PHOTONIC_MEDIA (DEGREE) should have 6 network neps", 6, inb6); + assertEquals(6, inb6, "ROADM-A1+PHOTONIC_MEDIA (DEGREE) should have 6 network neps"); long enb6 = topology.getNode().values().stream() .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals( @@ -445,25 +444,26 @@ public class TapiTopologyImplTest extends AbstractTest { .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() .filter(nep -> nep.getName().values().stream().findFirst().get().getValue().contains("SRG"))) .count(); - assertEquals("ROADM-A1+PHOTONIC_MEDIA (SRG) should have 24 network neps", 24, enb6); + assertEquals(24, enb6, "ROADM-A1+PHOTONIC_MEDIA (SRG) should have 24 network neps"); // Links in openroadm topology which include Roadm-to-Roadm and Xpdr-to-Roadm (ortopo / 2) // + transitional links -> 1 per network port of Xpdr + OTN links / 2 - assertEquals("Link list size should be 25", 25, topology.getLink().size()); + assertEquals(25, topology.getLink().size(), "Link list size should be 25"); Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Full Multi-layer topology".getBytes()).toString()); - assertEquals("incorrect topology uuid", topoUuid, topology.getUuid()); - assertEquals("topology name should be T0 - Full Multi-layer topology", + assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid"); + assertEquals( "T0 - Full Multi-layer topology", - topology.nonnullName().values().stream().findFirst().get().getValue()); + topology.nonnullName().values().stream().findFirst().get().getValue(), + "topology name should be T0 - Full Multi-layer topology"); long nbDsrOduNodes = topology.nonnullNode().values().stream() .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count(); long nbPhotonicNodes = topology.nonnullNode().values().stream() .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count(); // In DSR/ODU we create one node per Xpdr (no filtering out) - assertEquals("Node list should contain 8 DSR-ODU nodes", 8, nbDsrOduNodes); + assertEquals(8, nbDsrOduNodes, "Node list should contain 8 DSR-ODU nodes"); // We need to add the Roadms as Photonic nodes. Instead of 1 node as roadm infra we have 2 roadm nodes - assertEquals("Node list should contain 8 Photonics nodes", 8, nbPhotonicNodes); + assertEquals(8, nbPhotonicNodes, "Node list should contain 8 Photonics nodes"); long nbTransititionalLinks = topology.getLink().values().stream() .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count(); // Roadm-to-Roadm @@ -473,13 +473,13 @@ public class TapiTopologyImplTest extends AbstractTest { long nbOmsLinks1 = topology.getLink().values().stream() .filter(l -> l.getName().containsKey(new NameKey("XPDR-RDM link name"))).count(); // 1 transitional link per NETWORK port - assertEquals("Link list should contain 16 transitional links", 16, nbTransititionalLinks); + assertEquals(16, nbTransititionalLinks, "Link list should contain 16 transitional links"); // 1 OMS per ROADM-to-ROADM link + Existing XPDR-tp-ROADM link in openroadm topology - assertEquals("Link list should contain 9 OMS links", 9, nbOmsLinks + nbOmsLinks1); + assertEquals(9, nbOmsLinks + nbOmsLinks1, "Link list should contain 9 OMS links"); } @Test - public void getNodeAndNepsDetailsWhenSuccessful() + void getNodeAndNepsDetailsWhenSuccessful() throws ExecutionException, InterruptedException { GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( TapiStringConstants.T0_FULL_MULTILAYER); @@ -510,7 +510,7 @@ public class TapiTopologyImplTest extends AbstractTest { RpcResult rpcResult1 = result1.get(); @Nullable Node node1 = rpcResult1.getResult().getNode(); - assertNotNull("Node should not be null", node1); + assertNotNull(node1, "Node should not be null"); for (OwnedNodeEdgePoint onep:node1.getOwnedNodeEdgePoint().values()) { String onepName = onep.getName().values().stream().findFirst().get().getValue(); GetNodeEdgePointDetailsInput input2 = TapiTopologyDataUtils.buildGetNodeEdgePointDetailsInput( @@ -528,13 +528,13 @@ public class TapiTopologyImplTest extends AbstractTest { org.opendaylight.yang.gen.v1 .urn.onf.otcc.yang.tapi.topology.rev181210.get.node.edge.point.details.output.NodeEdgePoint onep1 = rpcResult2.getResult().getNodeEdgePoint(); - assertNotNull("Node Edge Point should not be null", onep1); + assertNotNull(onep1, "Node Edge Point should not be null"); } } } @Test - public void getLinkDetailsWhenSuccessful() + void getLinkDetailsWhenSuccessful() throws ExecutionException, InterruptedException { GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( TapiStringConstants.T0_FULL_MULTILAYER); @@ -565,12 +565,12 @@ public class TapiTopologyImplTest extends AbstractTest { RpcResult rpcResult1 = result1.get(); org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.link.details.output.Link link1 = rpcResult1.getResult().getLink(); - assertNotNull("Link should not be null", link1); + assertNotNull(link1, "Link should not be null"); } } @Test - public void getSipDetailsWhenSuccessful() + void getSipDetailsWhenSuccessful() throws ExecutionException, InterruptedException { GetServiceInterfacePointListInput input = TapiTopologyDataUtils.buildServiceInterfacePointListInput(); TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils, tapiLink); @@ -602,28 +602,28 @@ public class TapiTopologyImplTest extends AbstractTest { org.opendaylight.yang.gen.v1 .urn.onf.otcc.yang.tapi.common.rev181210.get.service._interface.point.details.output.Sip sip1 = rpcResult1.getResult().getSip(); - assertNotNull("Sip should not be null", sip1); + assertNotNull(sip1, "Sip should not be null"); } } private void checkOtnLink(Link link, Uuid topoUuid, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid, String linkName) { - assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("otn link name")).getValue()); - assertEquals("bad uuid for link", linkUuid, link.getUuid()); - assertEquals("Available capacity unit should be MBPS", - CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit()); + assertEquals(linkName, link.getName().get(new NameKey("otn link name")).getValue(), "bad name for the link"); + assertEquals(linkUuid, link.getUuid(), "bad uuid for link"); + assertEquals(CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit(), + "Available capacity unit should be MBPS"); String prefix = linkName.split("-")[0]; if ("OTU4".equals(prefix)) { - assertEquals("Available capacity -total size value should be 0", - Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue()); + assertEquals(Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue(), + "Available capacity -total size value should be 0"); } else if ("ODTU4".equals(prefix)) { - assertEquals("Available capacity -total size value should be 100 000", - Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue()); + assertEquals(Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue(), + "Available capacity -total size value should be 100 000"); } - assertEquals("Total capacity unit should be GBPS", - CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit()); - assertEquals("Total capacity -total size value should be 100", - Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue()); + assertEquals(CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit(), + "Total capacity unit should be GBPS"); + assertEquals(Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue(), + "Total capacity -total size value should be 100"); if ("OTU4".equals(prefix)) { assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA", LayerProtocolName.PHOTONICMEDIA.getName(), @@ -633,14 +633,14 @@ public class TapiTopologyImplTest extends AbstractTest { LayerProtocolName.ODU.getName(), link.getLayerProtocolName().stream().findFirst().get().getName()); } - assertEquals("transitional link should be BIDIRECTIONAL", - ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(), + "transitional link should be BIDIRECTIONAL"); List nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topoUuid, nodeEdgePointList.get(0).getTopologyUuid()); - assertEquals("topology uuid should be the same for the two termination point of the link", - topoUuid, nodeEdgePointList.get(1).getTopologyUuid()); + assertEquals(topoUuid, nodeEdgePointList.get(0).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); + assertEquals(topoUuid, nodeEdgePointList.get(1).getTopologyUuid(), + "topology uuid should be the same for the two termination point of the link"); assertThat("otn links should terminate on two distinct nodes", nodeEdgePointList.get(0).getNodeUuid().getValue(), either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); @@ -653,9 +653,8 @@ public class TapiTopologyImplTest extends AbstractTest { assertThat("otn links should terminate on two distinct tps", nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); - assertEquals("operational state should be ENABLED", - OperationalState.ENABLED, link.getOperationalState()); - assertEquals("administrative state should be UNLOCKED", - AdministrativeState.UNLOCKED, link.getAdministrativeState()); + assertEquals(OperationalState.ENABLED, link.getOperationalState(), "operational state should be ENABLED"); + assertEquals(AdministrativeState.UNLOCKED, link.getAdministrativeState(), + "administrative state should be UNLOCKED"); } -} +} \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java index a5277619b..cd4347f02 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java @@ -117,7 +117,6 @@ public final class TapiConnectivityDataUtils { } public static ServiceCreateInput buildServiceCreateInput() { - return new ServiceCreateInputBuilder() .setCommonId("commonId") .setConnectionType(ConnectionType.Service) diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java index 32cbbf19e..8b5b655a9 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiTopologyDataUtils.java @@ -29,44 +29,45 @@ public final class TapiTopologyDataUtils { public static final String PORTMAPPING_FILE = "src/test/resources/portmapping.xml"; public static GetTopologyDetailsInput buildGetTopologyDetailsInput(String topoName) { - GetTopologyDetailsInputBuilder builtInput = new GetTopologyDetailsInputBuilder(); - builtInput.setTopologyIdOrName(topoName); - return builtInput.build(); + return new GetTopologyDetailsInputBuilder() + .setTopologyIdOrName(topoName) + .build(); } public static GetNodeDetailsInput buildGetNodeDetailsInput(String topoName, String nodeName) { - GetNodeDetailsInputBuilder builtInput = new GetNodeDetailsInputBuilder(); - builtInput.setTopologyIdOrName(topoName); - builtInput.setNodeIdOrName(nodeName); - return builtInput.build(); + return new GetNodeDetailsInputBuilder() + .setTopologyIdOrName(topoName) + .setNodeIdOrName(nodeName) + .build(); } public static GetLinkDetailsInput buildGetLinkDetailsInput(String topoName, String linkName) { - GetLinkDetailsInputBuilder builtInput = new GetLinkDetailsInputBuilder(); - builtInput.setTopologyIdOrName(topoName); - builtInput.setLinkIdOrName(linkName); - return builtInput.build(); + return new GetLinkDetailsInputBuilder() + .setTopologyIdOrName(topoName) + .setLinkIdOrName(linkName) + .build(); } public static GetServiceInterfacePointListInput buildServiceInterfacePointListInput() { - return new GetServiceInterfacePointListInputBuilder().build(); + return new GetServiceInterfacePointListInputBuilder() + .build(); } public static GetServiceInterfacePointDetailsInput buildGetServiceInterfacePointDetailsInput(Uuid sipUuid) { - GetServiceInterfacePointDetailsInputBuilder builtInput = new GetServiceInterfacePointDetailsInputBuilder(); - builtInput.setSipIdOrName(sipUuid.getValue()); - return builtInput.build(); + return new GetServiceInterfacePointDetailsInputBuilder() + .setSipIdOrName(sipUuid.getValue()) + .build(); } - public static GetNodeEdgePointDetailsInput buildGetNodeEdgePointDetailsInput(String topoName, - String nodeName, String onepName) { - GetNodeEdgePointDetailsInputBuilder builtInput = new GetNodeEdgePointDetailsInputBuilder(); - builtInput.setTopologyIdOrName(topoName); - builtInput.setNodeIdOrName(nodeName); - builtInput.setEpIdOrName(onepName); - return builtInput.build(); + public static GetNodeEdgePointDetailsInput buildGetNodeEdgePointDetailsInput(String topoName, String nodeName, + String onepName) { + return new GetNodeEdgePointDetailsInputBuilder() + .setTopologyIdOrName(topoName) + .setNodeIdOrName(nodeName) + .setEpIdOrName(onepName) + .build(); } private TapiTopologyDataUtils() { } -} +} \ No newline at end of file