From: Javier Errea Date: Tue, 29 Jun 2021 10:03:58 +0000 (+0200) Subject: Junit tests for new TAPI module X-Git-Tag: 4.1.0~27 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=transportpce.git;a=commitdiff_plain;h=2bc492b9e47dbc3122948d32b132ca3a939b5834 Junit tests for new TAPI module - TAPI convert OR to TAPI test - TAPI topology tests + utils - TAPI Connectivity tests + utils - TAPI provider test - Fix TapiConnectivityImpl and TapiContext to enable tests - Fix ConvertFullTopo OMS link creation JIRA: TRNSPRTPCE-563 Signed-off-by: errea Change-Id: Ie0796a438c26fed89997dbd2a73b979ede160517 --- diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java index 7011804a8..cd5d1da72 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java @@ -271,27 +271,36 @@ public class TapiConnectivityImpl implements TapiConnectivityService { DeleteConnectivityServiceInput input) { //TODO Auto-generated method stub // TODO add try - Uuid serviceUuid = new Uuid(input.getServiceIdOrName()); - this.tapiContext.deleteConnectivityService(serviceUuid); - ListenableFuture> output = - this.serviceHandler.serviceDelete(new ServiceDeleteInputBuilder() - .setServiceDeleteReqInfo(new ServiceDeleteReqInfoBuilder() - .setServiceName(input.getServiceIdOrName()) - .setTailRetention(ServiceDeleteReqInfo.TailRetention.No) - .build()) - .setSdncRequestHeader(new SdncRequestHeaderBuilder() - .setRequestId("request-1") - .setRpcAction(RpcActions.ServiceDelete) - .setNotificationUrl("notification url") - .setRequestSystemId("appname") - .build()) - .build()); - if (output == null) { - return RpcResultBuilder.failed().withError(RpcError.ErrorType.RPC, - "Failed to delete Link").buildFuture(); + if (input.getServiceIdOrName() != null) { + try { + Uuid serviceUuid = new Uuid(input.getServiceIdOrName()); + this.tapiContext.deleteConnectivityService(serviceUuid); + ListenableFuture> output = + this.serviceHandler.serviceDelete(new ServiceDeleteInputBuilder() + .setServiceDeleteReqInfo(new ServiceDeleteReqInfoBuilder() + .setServiceName(input.getServiceIdOrName()) + .setTailRetention(ServiceDeleteReqInfo.TailRetention.No) + .build()) + .setSdncRequestHeader(new SdncRequestHeaderBuilder() + .setRequestId("request-1") + .setRpcAction(RpcActions.ServiceDelete) + .setNotificationUrl("notification url") + .setRequestSystemId("appname") + .build()) + .build()); + RpcResult rpcResult = output.get(); + if (!rpcResult.getResult().getConfigurationResponseCommon().getResponseCode() + .equals(ResponseCodes.RESPONSE_FAILED)) { + LOG.info("Service is being deleted and devices are being rolled back"); + return RpcResultBuilder.success(new DeleteConnectivityServiceOutputBuilder().build()).buildFuture(); + } + LOG.error("Failed to delete service. Deletion process failed"); + } catch (InterruptedException | ExecutionException e) { + LOG.error("Failed to delete service.", e); + } } - LOG.info("Service is being deleted and devices are being rolled back"); - return RpcResultBuilder.success(new DeleteConnectivityServiceOutputBuilder().build()).buildFuture(); + return RpcResultBuilder.failed().withError(RpcError.ErrorType.RPC, + "Failed to delete Service").buildFuture(); } @Override diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiFullTopo.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiFullTopo.java index 4c97d01b2..ec7408eb0 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiFullTopo.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiFullTopo.java @@ -1263,7 +1263,7 @@ public class ConvertORTopoToTapiFullTopo { String sourceNode = getIdBasedOnModelVersion(link.getSource().getSourceNode().getValue()); String sourceTp = link.getSource().getSourceTp().getValue(); String destNode = getIdBasedOnModelVersion(link.getDestination().getDestNode().getValue()); - String destTp = link.getDestination().getDestTp().toString(); + String destTp = link.getDestination().getDestTp().getValue(); AdminStates oppositeLinkAdminState = null; State oppositeLinkOperState = null; if (oppositeLink != null) { diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java index 14fdb46df..cd48f0f61 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java @@ -399,6 +399,7 @@ public class TapiContext { try { this.networkTransactionService.delete(LogicalDatastoreType.OPERATIONAL, connectivityServIID); this.networkTransactionService.commit().get(); + LOG.info("Connectivity service deleted"); } catch (InterruptedException | ExecutionException e) { LOG.error("Failed to delete Connectivity service", e); } 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 new file mode 100644 index 000000000..013abb376 --- /dev/null +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java @@ -0,0 +1,269 @@ +/* + * Copyright © 2021 Nokia, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.tapi.connectivity; + +import static org.mockito.ArgumentMatchers.any; + +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +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.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.opendaylight.mdsal.binding.api.NotificationPublishService; +import org.opendaylight.transportpce.common.InstanceIdentifiers; +import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; +import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.transportpce.common.network.RequestProcessor; +import org.opendaylight.transportpce.pce.service.PathComputationService; +import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; +import org.opendaylight.transportpce.servicehandler.impl.ServicehandlerImpl; +import org.opendaylight.transportpce.servicehandler.listeners.NetworkModelListenerImpl; +import org.opendaylight.transportpce.servicehandler.listeners.PceListenerImpl; +import org.opendaylight.transportpce.servicehandler.listeners.RendererListenerImpl; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl; +import org.opendaylight.transportpce.tapi.listeners.TapiPceListenerImpl; +import org.opendaylight.transportpce.tapi.listeners.TapiRendererListenerImpl; +import org.opendaylight.transportpce.tapi.listeners.TapiServiceHandlerListenerImpl; +import org.opendaylight.transportpce.tapi.topology.TopologyUtils; +import org.opendaylight.transportpce.tapi.utils.TapiConnectivityDataUtils; +import org.opendaylight.transportpce.tapi.utils.TapiContext; +import org.opendaylight.transportpce.tapi.utils.TapiInitialORMapping; +import org.opendaylight.transportpce.tapi.utils.TapiTopologyDataUtils; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.transportpce.test.utils.TopologyDataUtils; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.OrgOpenroadmServiceService; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.CreateConnectivityServiceInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.CreateConnectivityServiceInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.CreateConnectivityServiceOutput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.DeleteConnectivityServiceInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.DeleteConnectivityServiceInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.DeleteConnectivityServiceOutput; +import org.opendaylight.yangtools.yang.common.RpcError; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +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; + private ListeningExecutorService executorService; + private CountDownLatch endSignal; + private static final int NUM_THREADS = 5; + private boolean callbackRan; + + @Before + public 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 + TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II); + TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.OPENROADM_NETWORK_FILE, InstanceIdentifiers.UNDERLAY_NETWORK_II); + TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II); + TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.PORTMAPPING_FILE); + + callbackRan = false; + MockitoAnnotations.openMocks(this); + + networkTransactionService = new NetworkTransactionImpl( + new RequestProcessor(getDataStoreContextUtil().getDataBroker())); + serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker()); + tapiContext = new TapiContext(networkTransactionService); + topologyUtils = new TopologyUtils(networkTransactionService, getDataStoreContextUtil().getDataBroker()); + connectivityUtils = new ConnectivityUtils(serviceDataStoreOperations, new HashMap<>(), tapiContext); + tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, connectivityUtils, + tapiContext, serviceDataStoreOperations); + tapiInitialORMapping.performTopoInitialMapping(); + LOG.info("setup done"); + } + + @Test + public void createConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { + OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations); + + TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, + tapipceListenerImpl, tapirendererListenerImpl, tapiserviceHandlerListenerImpl); + + ListenableFuture> result = + tapiConnectivity.createConnectivityService(new CreateConnectivityServiceInputBuilder().build()); + result.addListener(new Runnable() { + @Override + public void run() { + callbackRan = true; + endSignal.countDown(); + } + }, executorService); + + endSignal.await(); + + RpcResult rpcResult = result.get(); + Assert.assertEquals( + RpcError.ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); + } + + @Test + public 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())); + + TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, + tapipceListenerImpl, tapirendererListenerImpl, tapiserviceHandlerListenerImpl); + ListenableFuture> result = + tapiConnectivity.createConnectivityService(input); + result.addListener(new Runnable() { + @Override + public void run() { + callbackRan = true; + endSignal.countDown(); + } + }, executorService); + + endSignal.await(); + + RpcResult rpcResult = result.get(); + Assert.assertTrue(rpcResult.isSuccessful()); + } + + @Test + public void deleteConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { + OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations); + + TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, + tapipceListenerImpl, tapirendererListenerImpl, tapiserviceHandlerListenerImpl); + + ListenableFuture> result = + tapiConnectivity.deleteConnectivityService(new DeleteConnectivityServiceInputBuilder().build()); + result.addListener(new Runnable() { + @Override + public void run() { + callbackRan = true; + endSignal.countDown(); + } + }, executorService); + + endSignal.await(); + + RpcResult rpcResult = result.get(); + Assert.assertEquals( + RpcError.ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); + } + + @Test + public void deleteConnServiceShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException { + DeleteConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceDeleteInput1(); + OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations); + + TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, + tapipceListenerImpl, tapirendererListenerImpl, tapiserviceHandlerListenerImpl); + ListenableFuture> result = + tapiConnectivity.deleteConnectivityService(input); + result.addListener(new Runnable() { + @Override + public void run() { + callbackRan = true; + endSignal.countDown(); + } + }, executorService); + + endSignal.await(); + + RpcResult rpcResult = result.get(); + Assert.assertEquals( + RpcError.ErrorType.RPC, rpcResult.getErrors().get(0).getErrorType()); + } + + @Test + public void deleteConnServiceShouldBeSuccessForExistingService() throws ExecutionException, InterruptedException { + Mockito.when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any())); + + OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(getNewDataBroker(), pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations); + + TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, + tapipceListenerImpl, tapirendererListenerImpl, tapiserviceHandlerListenerImpl); + + ServiceCreateInput createInput = TapiConnectivityDataUtils.buildServiceCreateInput(); + serviceDataStoreOperations.createService(createInput); + tapiContext.updateConnectivityContext(TapiConnectivityDataUtils.createConnService(), new HashMap<>()); + + DeleteConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceDeleteInput(); + ListenableFuture> result = + tapiConnectivity.deleteConnectivityService(input); + result.addListener(new Runnable() { + @Override + public void run() { + callbackRan = true; + endSignal.countDown(); + } + }, executorService); + + endSignal.await(); + + RpcResult rpcResult = result.get(); + Assert.assertTrue(rpcResult.isSuccessful()); + } +} 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 new file mode 100644 index 000000000..878c7633e --- /dev/null +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/provider/TapiProviderTest.java @@ -0,0 +1,106 @@ +/* + * Copyright © 2021 Nokia, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.tapi.provider; + +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.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.opendaylight.mdsal.binding.api.RpcProviderService; +import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; +import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.transportpce.common.network.RequestProcessor; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.tapi.impl.TapiProvider; +import org.opendaylight.transportpce.tapi.listeners.TapiPceListenerImpl; +import org.opendaylight.transportpce.tapi.listeners.TapiRendererListenerImpl; +import org.opendaylight.transportpce.tapi.listeners.TapiServiceHandlerListenerImpl; +import org.opendaylight.transportpce.tapi.topology.TapiNetconfTopologyListener; +import org.opendaylight.transportpce.tapi.topology.TapiPortMappingListener; +import org.opendaylight.transportpce.tapi.utils.TapiListener; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.TransportpceTapinetworkutilsService; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.OrgOpenroadmServiceService; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TapiCommonService; +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; + +public class TapiProviderTest extends AbstractTest { + public static NetworkTransactionService networkTransactionService; + + @Mock + RpcProviderService rpcProviderRegistry; + + @Mock + OrgOpenroadmServiceService serviceHandler; + + @Mock + ServiceDataStoreOperations serviceDataStoreOperations; + + @Mock + TapiListener tapiListener; + + @Mock + TransportpceTapinetworkutilsService tapiNetworkUtils; + + @Mock + TapiPortMappingListener tapiPortMappingListener; + + @Mock + TapiNetconfTopologyListener topologyListener; + + @Mock + TapiPceListenerImpl pceListenerImpl; + + @Mock + TapiRendererListenerImpl rendererListenerImpl; + + @Mock + TapiServiceHandlerListenerImpl serviceHandlerListenerImpl; + + private AutoCloseable closeable; + + @Before + public void openMocks() { + closeable = MockitoAnnotations.openMocks(this); + } + + @BeforeClass + public static void setUp() { + networkTransactionService = new NetworkTransactionImpl( + new RequestProcessor(getDataBroker())); + } + + @Test + public void testInitRegisterTapiToRpcRegistry() { + TapiProvider provider = new TapiProvider(getDataBroker(), rpcProviderRegistry, serviceHandler, + serviceDataStoreOperations, tapiListener, networkTransactionService, topologyListener, + tapiPortMappingListener, tapiNetworkUtils, pceListenerImpl, rendererListenerImpl, + serviceHandlerListenerImpl, getNotificationService()); + + 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(); + } +} 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 new file mode 100644 index 000000000..6e5331e3a --- /dev/null +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java @@ -0,0 +1,1637 @@ +/* + * Copyright © 2021 Nokia, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.tapi.topology; + +import static org.hamcrest.CoreMatchers.containsString; +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 com.google.common.util.concurrent.FluentFuture; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +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.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.InstanceIdentifiers; +import org.opendaylight.transportpce.tapi.utils.TapiTopologyDataUtils; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.transportpce.test.utils.TopologyDataUtils; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE100GigE; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE10GigELAN; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2E; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU4; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROMS; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROTSi; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.ForwardingRule; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.RuleType; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroup; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.Rule; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; +import org.opendaylight.yangtools.yang.common.Uint64; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { + private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToFullTapiTopoTest.class); + + private static Node otnMuxA; + private static Node otnMuxC; + private static Node otnSwitch; + private static Node tpdr100G; + private static Node roadmA; + private static Node roadmC; + private static Network openroadmNet; + private static Map otnLinks; + private static Map ortopoLinks; + private static Uuid topologyUuid; + private static DataBroker dataBroker = getDataBroker(); + + @BeforeClass + public static void setUp() throws InterruptedException, ExecutionException { + TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II); + TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.OPENROADM_NETWORK_FILE, InstanceIdentifiers.UNDERLAY_NETWORK_II); + TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II); + TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(), + TapiTopologyDataUtils.PORTMAPPING_FILE); + + KeyedInstanceIdentifier muxAIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("otn-topology"))) + .child(Node.class, new NodeKey(new NodeId("SPDR-SA1-XPDR1"))); + FluentFuture> muxAFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, muxAIID); + otnMuxA = muxAFuture.get().get(); + KeyedInstanceIdentifier muxCIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("otn-topology"))) + .child(Node.class, new NodeKey(new NodeId("SPDR-SC1-XPDR1"))); + FluentFuture> muxCFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, muxCIID); + otnMuxC = muxCFuture.get().get(); + KeyedInstanceIdentifier switchIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("otn-topology"))) + .child(Node.class, new NodeKey(new NodeId("SPDR-SA1-XPDR2"))); + FluentFuture> switchFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, switchIID); + otnSwitch = switchFuture.get().get(); + KeyedInstanceIdentifier roadmaIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("openroadm-network"))) + .child(Node.class, new NodeKey(new NodeId("ROADM-A1"))); + FluentFuture> roadmaFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, roadmaIID); + roadmA = roadmaFuture.get().get(); + KeyedInstanceIdentifier roadmcIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("openroadm-network"))) + .child(Node.class, new NodeKey(new NodeId("ROADM-C1"))); + FluentFuture> roadmcFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, roadmcIID); + roadmC = roadmcFuture.get().get(); + + KeyedInstanceIdentifier tpdrIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("otn-topology"))) + .child(Node.class, new NodeKey(new NodeId("XPDR-A1-XPDR1"))); + FluentFuture> tpdrFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, tpdrIID); + tpdr100G = tpdrFuture.get().get(); + + InstanceIdentifier linksIID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("otn-topology"))) + .augmentation(Network1.class); + FluentFuture> linksFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, linksIID); + otnLinks = linksFuture.get().get().getLink(); + + InstanceIdentifier links1IID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("openroadm-topology"))) + .augmentation(Network1.class); + FluentFuture> links1Future = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, links1IID); + ortopoLinks = links1Future.get().get().getLink(); + + InstanceIdentifier ortopo1IID = InstanceIdentifier.create(Networks.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + .class, new NetworkKey(new NetworkId("openroadm-topology"))); + FluentFuture> ortopoFuture = dataBroker.newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, ortopo1IID); + openroadmNet = ortopoFuture.get().get(); + + topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER.getBytes( + Charset.forName("UTF-8"))).toString()); + LOG.info("TEST SETUP READY"); + } + + @Test + public void convertNodeWhenNoStates() { + Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", null, null); + List networkPortList = new ArrayList<>(); + for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortList.add(tp.getTpId().getValue()); + } + } + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + tapiFactory.convertNode(tpdr, networkPortList); + + Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node dsrNode = tapiFactory + .getTapiNodes().get(new + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid)); + Uuid enetworkNepUuid = new Uuid( + UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid inetworkNepUuid = new Uuid( + 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()); + + 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()); + + Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node otsiNode = tapiFactory + .getTapiNodes().get(new + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid)); + Uuid enepUuid = new Uuid( + 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()); + + 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()); + + 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()); + } + + @Test + public void convertNodeWhenBadStates1() { + Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.OutOfService, + State.OutOfService); + List networkPortList = new ArrayList<>(); + for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortList.add(tp.getTpId().getValue()); + } + } + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + tapiFactory.convertNode(tpdr, networkPortList); + + Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node dsrNode = tapiFactory + .getTapiNodes().get(new + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid)); + Uuid enetworkNepUuid = new Uuid( + UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid inetworkNepUuid = new Uuid( + 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()); + + 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()); + + Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node otsiNode = tapiFactory + .getTapiNodes().get(new + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid)); + Uuid enepUuid = new Uuid( + 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()); + + 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()); + + 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()); + } + + @Test + public void convertNodeWhenBadStates2() { + Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.Maintenance, + State.Degraded); + List networkPortList = new ArrayList<>(); + for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortList.add(tp.getTpId().getValue()); + } + } + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + tapiFactory.convertNode(tpdr, networkPortList); + + Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node dsrNode = tapiFactory + .getTapiNodes().get(new + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid)); + Uuid enetworkNepUuid = new Uuid( + UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid inetworkNepUuid = new Uuid( + 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()); + + 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()); + + Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node otsiNode = tapiFactory + .getTapiNodes().get(new + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid)); + Uuid enepUuid = new Uuid( + 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()); + + 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()); + + 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()); + } + + @Test + public 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 + link = changeOtnLinkState(otnLinks.get(new LinkKey( + new LinkId("ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"))), null, null); + otnLinksAlt.replace(link.key(), link); + + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + List networkPortListC = new ArrayList<>(); + for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListC.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxC, networkPortListC); + tapiFactory.convertLinks(otnLinksAlt); + + 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(0).getAdministrativeState()); + assertEquals("Administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState()); + assertNull("Operational State should not be present", tapiLinks.get(0).getOperationalState()); + assertEquals("Operational state should be ENABLED", + OperationalState.ENABLED, tapiLinks.get(2).getOperationalState()); + } + + @Test + public 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 + link = changeOtnLinkState(otnLinks.get(new LinkKey( + new LinkId("ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1"))), null, null); + otnLinksAlt.replace(link.key(), link); + + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + List networkPortListC = new ArrayList<>(); + for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListC.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxC, networkPortListC); + tapiFactory.convertLinks(otnLinksAlt); + + 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(0).getAdministrativeState()); + assertEquals("Administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState()); + assertNull("Operational State should not be present", tapiLinks.get(0).getOperationalState()); + assertEquals("Operational state should be ENABLED", + OperationalState.ENABLED, tapiLinks.get(2).getOperationalState()); + } + + @Test + public 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 + link = changeOtnLinkState(otnLinks.get(new LinkKey( + new LinkId("ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"))), + AdminStates.OutOfService, State.OutOfService); + otnLinksAlt.replace(link.key(), link); + + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + List networkPortListC = new ArrayList<>(); + for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListC.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxC, networkPortListC); + tapiFactory.convertLinks(otnLinksAlt); + + 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(0).getAdministrativeState()); + assertEquals("Administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState()); + assertEquals("Operational state should be DISABLED", + OperationalState.DISABLED, tapiLinks.get(0).getOperationalState()); + assertEquals("Operational state should be ENABLED", + OperationalState.ENABLED, tapiLinks.get(2).getOperationalState()); + } + + @Test + public 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 + link = changeOtnLinkState(otnLinks.get(new LinkKey( + new LinkId("ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"))), + AdminStates.Maintenance, State.Degraded); + otnLinksAlt.replace(link.key(), link); + + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + List networkPortListC = new ArrayList<>(); + for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListC.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxC, networkPortListC); + tapiFactory.convertLinks(otnLinksAlt); + + 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(0).getAdministrativeState()); + assertEquals("Administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState()); + assertEquals("Operational state should be DISABLED", + OperationalState.DISABLED, tapiLinks.get(0).getOperationalState()); + assertEquals("Operational state should be ENABLED", + OperationalState.ENABLED, tapiLinks.get(2).getOperationalState()); + } + + @Test + public 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 + link = changeOtnLinkState(otnLinks.get(new LinkKey( + new LinkId("ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1"))), + AdminStates.OutOfService, State.OutOfService); + otnLinksAlt.replace(link.key(), link); + + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + List networkPortListC = new ArrayList<>(); + for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListC.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxC, networkPortListC); + tapiFactory.convertLinks(otnLinksAlt); + + 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(0).getAdministrativeState()); + assertEquals("Administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState()); + assertEquals("Operational state should be DISABLED", + OperationalState.DISABLED, tapiLinks.get(0).getOperationalState()); + assertEquals("Operational state should be ENABLED", + OperationalState.ENABLED, tapiLinks.get(2).getOperationalState()); + } + + @Test + public void convertNodeForTransponder100G() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortList = new ArrayList<>(); + for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortList.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(tpdr100G, networkPortList); + List tapiNodes + = tapiFactory.getTapiNodes().values().stream() + .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()); + + Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkDsrNode(tapiNodes.get(1), dsrNodeUuid, "tpdr", "XPDR-A1-XPDR1"); + Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkOtsiNode(tapiNodes.get(0), otsiNodeUuid, "tpdr", "XPDR-A1-XPDR1"); + + List tapiLinks + = tapiFactory.getTapiLinks().values().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + checkTransitionalLink(tapiLinks.get(1), dsrNodeUuid, otsiNodeUuid, + "XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1", "XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1", "XPDR-A1-XPDR1"); + } + + @Test + public void convertNodeForOtnMuxponder() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortList = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortList.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortList); + List tapiNodes + = tapiFactory.getTapiNodes().values().stream() + .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()); + 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"); + Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "mux", "SPDR-SA1-XPDR1"); + + List tapiLinks + = tapiFactory.getTapiLinks().values().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + checkTransitionalLink(tapiLinks.get(0), dsrNodeUuid, otsiNodeUuid, + "SPDR-SA1-XPDR1+iODU+XPDR1-NETWORK1", "SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1", "SPDR-SA1-XPDR1"); + } + + @Test + public void convertNodeForOtnSwitch() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortList = new ArrayList<>(); + for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortList.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnSwitch, networkPortList); + List tapiNodes + = tapiFactory.getTapiNodes().values().stream() + .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()); + + Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "switch", "SPDR-SA1-XPDR2"); + Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "switch", "SPDR-SA1-XPDR2"); + + List tapiLinks + = tapiFactory.getTapiLinks().values().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + checkTransitionalLink(tapiLinks.get(1), dsrNodeUuid, otsiNodeUuid, + "SPDR-SA1-XPDR2+iODU+XPDR2-NETWORK4", "SPDR-SA1-XPDR2+iOTSi+XPDR2-NETWORK4", "SPDR-SA1-XPDR2"); + } + + @Test + public void convertOtnLink() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + List networkPortListC = new ArrayList<>(); + for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListC.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxC, networkPortListC); + tapiFactory.convertLinks(otnLinks); + assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size()); + + Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+eODU+XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+eODU+XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid tp3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid tp4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid link1Uuid = + new Uuid(UUID.nameUUIDFromBytes("ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid link2Uuid = + new Uuid(UUID.nameUUIDFromBytes("OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + + List links + = tapiFactory.getTapiLinks().values().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + checkOtnLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, link1Uuid, + "ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"); + checkOtnLink(links.get(3), node3Uuid, node4Uuid, tp3Uuid, tp4Uuid, link2Uuid, + "OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"); + } + + @Test + public void convertNodeForRoadmWhenNoOtnMuxAttached() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + 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()); + List tapiNodes + = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); + Uuid roadmNodeUuid = new Uuid(UUID.nameUUIDFromBytes((roadmA.getNodeId().getValue() + "+PHOTONIC_MEDIA") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkOtsiNode(tapiNodes.get(0), roadmNodeUuid, "roadm", "ROADM-A1"); + } + + @Test + public void convertNodeForRoadmWhenRoadmNeighborAttached() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + tapiFactory.convertRoadmNode(roadmA, openroadmNet); + tapiFactory.convertRoadmNode(roadmC, openroadmNet); + + List rdmTordmLinkList = ortopoLinks.values().stream() + .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.ROADMTOROADM)) + .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()); + + List tapiNodes + = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); + Uuid roadmaNodeUuid = new Uuid(UUID.nameUUIDFromBytes((roadmA.getNodeId().getValue() + "+PHOTONIC_MEDIA") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkOtsiNode(tapiNodes.get(1), roadmaNodeUuid, "roadm", "ROADM-A1"); + + List links + = tapiFactory.getTapiLinks().values().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-A1+PHOTONIC_MEDIA".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-C1+PHOTONIC_MEDIA".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-A1+PHOTONIC_MEDIA+DEG2-TTP-TXRX" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes(("ROADM-C1+PHOTONIC_MEDIA+DEG1-TTP-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid linkUuid = + new Uuid(UUID.nameUUIDFromBytes("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX" + .getBytes(Charset.forName("UTF-8"))).toString()); + checkOmsLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, linkUuid, + "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX"); + } + + @Test + public void convertNodeForRoadmWhenOtnMuxAttached() { + ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid); + List networkPortListA = new ArrayList<>(); + for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { + if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { + networkPortListA.add(tp.getTpId().getValue()); + } + } + tapiFactory.convertNode(otnMuxA, networkPortListA); + tapiFactory.convertRoadmNode(roadmA, openroadmNet); + List xponderOutLinkList = ortopoLinks.values().stream() + .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDEROUTPUT)) + .filter(lk1 -> ((lk1.getSource().getSourceNode().equals(otnMuxA.getNodeId()) + || lk1.getSource().getSourceNode().getValue().contains(roadmA.getNodeId().getValue())) + && (lk1.getDestination().getDestNode().equals(otnMuxA.getNodeId()) + || lk1.getDestination().getDestNode().getValue().contains(roadmA.getNodeId().getValue())))) + .collect(Collectors.toList()); + List xponderInLinkList = ortopoLinks.values().stream() + .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDERINPUT)) + .filter(lk1 -> ((lk1.getSource().getSourceNode().equals(otnMuxA.getNodeId()) + || lk1.getSource().getSourceNode().getValue().contains(roadmA.getNodeId().getValue())) + && (lk1.getDestination().getDestNode().equals(otnMuxA.getNodeId()) + || lk1.getDestination().getDestNode().getValue().contains(roadmA.getNodeId().getValue())))) + .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()); + List tapiNodes + = tapiFactory.getTapiNodes().values().stream() + .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) + .collect(Collectors.toList()); + Uuid roadmNodeUuid = new Uuid(UUID.nameUUIDFromBytes((roadmA.getNodeId().getValue() + "+PHOTONIC_MEDIA") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkOtsiNode(tapiNodes.get(1), roadmNodeUuid, "roadm", "ROADM-A1"); + + List links + = tapiFactory.getTapiLinks().values().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-A1+PHOTONIC_MEDIA".getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+PHOTONIC_MEDIA+XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes(("ROADM-A1+PHOTONIC_MEDIA+SRG1-PP2-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid linkUuid = + new Uuid(UUID.nameUUIDFromBytes("ROADM-A1-SRG1-SRG1-PP2-TXRXtoSPDR-SA1-XPDR1-XPDR1-NETWORK1" + .getBytes(Charset.forName("UTF-8"))).toString()); + checkXpdrRdmLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, linkUuid, + "ROADM-A1-SRG1-SRG1-PP2-TXRXtoSPDR-SA1-XPDR1-XPDR1-NETWORK1"); + } + + 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()); + assertEquals("value-name should be 'dsr/odu node name'", + "dsr/odu node name", node.nonnullName().values().stream().findFirst().get().getValueName()); + assertEquals("dsr node should manage 2 protocol layers : dsr and odu", + 2, node.getLayerProtocolName().size()); + assertThat("dsr node should manage 2 protocol layers : dsr and odu", + node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU)); + List inepsN = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint_N"))) + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + List enepsN = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("eNodeEdgePoint_N"))) + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + List nepsC; + switch (dsrNodeType) { + case "switch": + nepsC = node.nonnullOwnedNodeEdgePoint().values().stream() + .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()); + OwnedNodeEdgePoint nep1 = nepsC.get(2); + Uuid client4NepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepClient100GSwitch(nep1, client4NepUuid, nodeId + "+DSR+XPDR2-CLIENT4", "NodeEdgePoint_C"); + OwnedNodeEdgePoint enep2 = enepsN.get(3); + OwnedNodeEdgePoint inep2 = inepsN.get(3); + Uuid enetworkNepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+eODU+XPDR2-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid inetworkNepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+iODU+XPDR2-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepNetworkODU4(enep2, enetworkNepUuid, nodeId + "+eODU+XPDR2-NETWORK1", "eNodeEdgePoint_N", true); + checkNepNetworkODU4(inep2, inetworkNepUuid, nodeId + "+iODU+XPDR2-NETWORK1", "iNodeEdgePoint_N", false); + List nrgList = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, enetworkNepUuid, nodeUuid); + break; + case "mux": + nepsC = node.nonnullOwnedNodeEdgePoint().values().stream() + .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 eNEP network", 1, 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()); + OwnedNodeEdgePoint nep3 = nepsC.get(2); + Uuid client3NepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepClient10G(nep3, client3NepUuid, nodeId + "+DSR+XPDR1-CLIENT3", "NodeEdgePoint_C"); + + OwnedNodeEdgePoint enep4 = enepsN.get(0); + OwnedNodeEdgePoint inep4 = inepsN.get(0); + Uuid enetworkNepUuid2 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+eODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid inetworkNepUuid2 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepNetworkODU4(enep4, enetworkNepUuid2, nodeId + "+eODU+XPDR1-NETWORK1", "eNodeEdgePoint_N", true); + checkNepNetworkODU4(inep4, inetworkNepUuid2, nodeId + "+iODU+XPDR1-NETWORK1", "iNodeEdgePoint_N", + false); + List nrgList2 = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForMuxDSR(nrgList2, client3NepUuid, enetworkNepUuid2, nodeUuid); + break; + case "tpdr": + nepsC = node.nonnullOwnedNodeEdgePoint().values().stream() + .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()); + OwnedNodeEdgePoint nep5 = nepsC.get(0); + Uuid client1NepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepClient100GTpdr(nep5, client1NepUuid, nodeId + "+DSR+XPDR1-CLIENT1", "100G-tpdr"); + + OwnedNodeEdgePoint enep6 = enepsN.get(0); + OwnedNodeEdgePoint inep6 = inepsN.get(1); + Uuid enetworkNepUuid3 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+eODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + Uuid inetworkNepUuid3 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepNetworkODU4(enep6, enetworkNepUuid3, nodeId + "+eODU+XPDR1-NETWORK1", "eNodeEdgePoint_N", true); + checkNepNetworkODU4(inep6, inetworkNepUuid3, nodeId + "+iODU+XPDR1-NETWORK1", "iNodeEdgePoint_N", + false); + List nrgList3 = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForTpdrDSR(nrgList3, client1NepUuid, enetworkNepUuid3, nodeUuid); + break; + default: + fail(); + break; + } + } + + 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()); + List nepsI = null; + List nepsE = null; + List nepsP = null; + List nepsMc = null; + 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("value-name should be 'dsr/odu node name'", + "otsi node name", node.nonnullName().values().stream().findFirst().get().getValueName()); + nepsI = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint"))) + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + nepsE = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("eNodeEdgePoint"))) + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + nepsP = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("PhotMedNodeEdgePoint"))) + .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("value-name should be 'dsr/odu node name'", + "roadm node name", node.nonnullName().values().stream().findFirst().get().getValueName()); + nepsMc = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("MEDIA_CHANNELNodeEdgePoint"))) + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + nepsOtsimc = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("OTSi_MEDIA_CHANNELNodeEdgePoint"))) + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + nepsPhot = node.nonnullOwnedNodeEdgePoint().values().stream() + .filter(n -> n.getName().containsKey(new NameKey("PHOTONIC_MEDIANodeEdgePoint"))) + .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().get(0)); + + 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()); + OwnedNodeEdgePoint nep1 = nepsI.get(1); + Uuid inepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiNode(nep1, inepUuid, nodeId + "+iOTSi+XPDR2-NETWORK2", "iNodeEdgePoint", true); + OwnedNodeEdgePoint nep2 = nepsE.get(0); + Uuid enepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiNode(nep2, enepUuid, nodeId + "+eOTSi+XPDR2-NETWORK2", "eNodeEdgePoint", false); + OwnedNodeEdgePoint photNep = nepsP.get(1); + Uuid pnepUuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+PHOTONIC_MEDIA+XPDR2-NETWORK2") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(photNep, pnepUuid, nodeId + "+PHOTONIC_MEDIA+XPDR2-NETWORK2", "PhotMedNodeEdgePoint", + false); + List nrgList = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + 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()); + OwnedNodeEdgePoint nep3 = nepsE.get(0); + Uuid enepUuid2 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiNode(nep3, enepUuid2, nodeId + "+eOTSi+XPDR1-NETWORK1", "eNodeEdgePoint", false); + OwnedNodeEdgePoint nep4 = nepsI.get(0); + Uuid inepUuid2 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiNode(nep4, inepUuid2, nodeId + "+iOTSi+XPDR1-NETWORK1", "iNodeEdgePoint", true); + OwnedNodeEdgePoint photNep1 = nepsP.get(0); + Uuid pnep1Uuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+PHOTONIC_MEDIA+XPDR1-NETWORK1") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(photNep1, pnep1Uuid, nodeId + "+PHOTONIC_MEDIA+XPDR1-NETWORK1", "PhotMedNodeEdgePoint", + false); + List nrgList2 = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + 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()); + OwnedNodeEdgePoint nep5 = nepsE.get(0); + Uuid enepUuid3 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiNode(nep5, enepUuid3, nodeId + "+eOTSi+XPDR1-NETWORK1", "eNodeEdgePoint", false); + OwnedNodeEdgePoint nep6 = nepsI.get(0); + Uuid inepUuid3 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiNode(nep6, inepUuid3, nodeId + "+iOTSi+XPDR1-NETWORK1", "iNodeEdgePoint", true); + OwnedNodeEdgePoint photNep2 = nepsP.get(0); + Uuid pnep2Uuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+PHOTONIC_MEDIA+XPDR1-NETWORK1") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(photNep2, pnep2Uuid, nodeId + "+PHOTONIC_MEDIA+XPDR1-NETWORK1", "PhotMedNodeEdgePoint", + false); + List nrgList3 = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + 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()); + // For Degree node + OwnedNodeEdgePoint nep7 = nepsMc.get(6); + Uuid mcnepUuid3 = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+MEDIA_CHANNEL+DEG1-TTP-TXRX").getBytes(Charset.forName("UTF-8"))) + .toString()); + checkNepOtsiRdmNode(nep7, mcnepUuid3, nodeId + "+MEDIA_CHANNEL+DEG1-TTP-TXRX", + "MEDIA_CHANNELNodeEdgePoint", false); + OwnedNodeEdgePoint nep8 = nepsOtsimc.get(0); + Uuid otmcnepUuid3 = new Uuid(UUID.nameUUIDFromBytes((nodeId + "+OTSi_MEDIA_CHANNEL+DEG1-TTP-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiRdmNode(nep8, otmcnepUuid3, nodeId + "+OTSi_MEDIA_CHANNEL+DEG1-TTP-TXRX", + "OTSi_MEDIA_CHANNELNodeEdgePoint", false); + OwnedNodeEdgePoint photNep3 = nepsPhot.get(3); + Uuid pnep3Uuid = new Uuid( + UUID.nameUUIDFromBytes((nodeId + "+PHOTONIC_MEDIA+DEG1-TTP-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiRdmNode(photNep3, pnep3Uuid, nodeId + "+PHOTONIC_MEDIA+DEG1-TTP-TXRX", + "PHOTONIC_MEDIANodeEdgePoint", false); + // For srg node + OwnedNodeEdgePoint nep9 = nepsMc.get(0); + Uuid mcnepUuid4 = new Uuid(UUID.nameUUIDFromBytes((nodeId + "+MEDIA_CHANNEL+SRG1-PP1-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiRdmNode(nep9, mcnepUuid4, nodeId + "+MEDIA_CHANNEL+SRG1-PP1-TXRX", + "MEDIA_CHANNELNodeEdgePoint", true); + OwnedNodeEdgePoint nep10 = nepsOtsimc.get(9); + Uuid otmcnepUuid4 = new Uuid(UUID.nameUUIDFromBytes((nodeId + "+OTSi_MEDIA_CHANNEL+SRG1-PP1-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiRdmNode(nep10, otmcnepUuid4, nodeId + "+OTSi_MEDIA_CHANNEL+SRG1-PP1-TXRX", + "OTSi_MEDIA_CHANNELNodeEdgePoint", false); + OwnedNodeEdgePoint photNep4 = nepsPhot.get(4); + Uuid pnep4Uuid = new Uuid(UUID.nameUUIDFromBytes((nodeId + "+PHOTONIC_MEDIA+SRG1-PP1-TXRX") + .getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiRdmNode(photNep4, pnep4Uuid, nodeId + "+PHOTONIC_MEDIA+SRG1-PP1-TXRX", + "PHOTONIC_MEDIANodeEdgePoint", false); + List nrgList4 = node.nonnullNodeRuleGroup().values().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForRdm(nrgList4, 30); + break; + default: + fail(); + break; + } + } + + private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + 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()); + assertThat("client nep should support 3 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(ODUTYPEODU2.class, ODUTYPEODU2E.class, DIGITALSIGNALTYPE10GigELAN.class)); + assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep, false); + } + + private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, + boolean withSip) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + 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()); + assertThat("network nep should support 1 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItem(ODUTYPEODU4.class)); + assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName()); + 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()); + for (NodeRuleGroup nodeRuleGroup : nrgList) { + assertEquals("each node-rule-group should contain 2 NEP for transponder DSR", + 2, nodeRuleGroup.getNodeEdgePoint().size()); + } + List nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values()); + assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1", + nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), + either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); + 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); + 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()); + } + + private void checkNodeRuleGroupForMuxDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, + Uuid nodeUuid) { + assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size()); + for (NodeRuleGroup nodeRuleGroup : nrgList) { + assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR", + 2, nodeRuleGroup.getNodeEdgePoint().size()); + } + List nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values()); + 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()))); + 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); + 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()); + } + + 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()); + 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(7).getNodeEdgePointUuid()); + assertEquals("in the sorted node-rule-group, nep number 4 should be XPDR2-CLIENT4", + clientNepUuid, nrg.get(4).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()); + @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()); + } + + private void checkNodeRuleGroupForRdm(List nrgList, int nbNeps) { + assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size()); + 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()); + } else { + assertNull("RDM infra node -rule-group should contain no NEP", nrgList.get(0).getNodeEdgePoint()); + } + 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()); + } + + private void checkNodeRuleGroupForTpdrOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, + Uuid nodeUuid) { + assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size()); + List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); + assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size()); + 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()); + 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()); + } + + private void checkNodeRuleGroupForMuxOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, + Uuid nodeUuid) { + assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size()); + List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); + assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size()); + 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()); + 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()); + } + + private void checkNodeRuleGroupForSwitchOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, + Uuid nodeUuid) { + assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size()); + for (NodeRuleGroup nodeRuleGroup : nrgList) { + assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi", + 2, nodeRuleGroup.getNodeEdgePoint().size()); + } + 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", + nodeEdgePointList1.get(0).getNodeEdgePointUuid().getValue(), + either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); + assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2", + 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()); + 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()); + } + + private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + 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()); + assertThat("client nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(ODUTYPEODU4.class, DIGITALSIGNALTYPE100GigE.class)); + assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep, false); + } + + private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + 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()); + assertThat("client nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(DIGITALSIGNALTYPE100GigE.class)); + assertEquals("client nep should be of DSR protocol type", LayerProtocolName.DSR, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep, false); + } + + private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, + boolean withSip) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + 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()); + assertThat("OTSi nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(PHOTONICLAYERQUALIFIEROMS.class, PHOTONICLAYERQUALIFIEROTSi.class)); + assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", + LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep, withSip); + } + + private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName, + boolean withSip) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + 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()); + assertThat("OTSi nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(PHOTONICLAYERQUALIFIEROMS.class)); + assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", + LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); + 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()); + if (withSip) { + assertEquals("Given nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size()); + } + 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()); + } + + 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((ietfNodeId + "--" + tp1 + "--" + 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()); + 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()); + 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()); + assertThat("transitional links should terminate on DSR node and Photonic node", + nodeEdgePointList.get(0).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("transitional links should terminate on DSR node and Photonic node", + nodeEdgePointList.get(1).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + Uuid nep1Uuid = new Uuid(UUID.nameUUIDFromBytes(tp1.getBytes(Charset.forName("UTF-8"))).toString()); + Uuid nep2Uuid = new Uuid(UUID.nameUUIDFromBytes(tp2.getBytes(Charset.forName("UTF-8"))).toString()); + assertThat("transitional links should terminate on " + tp1 + " and " + tp2 + " neps", + nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), + either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue()))); + assertThat("transitional links should terminate on DSR node and Photonic node", + nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), + either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue()))); + } + + private void checkOtnLink(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("otn link name")).getValue()); + assertEquals("bad uuid for link", linkUuid, link.getUuid()); + assertEquals("Available capacity unit should be MBPS", + CapacityUnit.MBPS, link.getAvailableCapacity().getTotalSize().getUnit()); + 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()); + } else if ("ODU4".equals(prefix)) { + assertEquals("Available capacity -total size value should be 100 000", + Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue()); + } + 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()); + if ("OTU4".equals(prefix)) { + assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA", + LayerProtocolName.PHOTONICMEDIA.getName(), link.getLayerProtocolName().get(0).getName()); + } else if ("ODU4".equals(prefix)) { + assertEquals("otn link should be between 2 nodes of protocol layers ODU", + LayerProtocolName.ODU.getName(), link.getLayerProtocolName().get(0).getName()); + } + assertEquals("otn tapi link should be BIDIRECTIONAL", + ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + 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()); + assertThat("otn links should terminate on two distinct nodes", + nodeEdgePointList.get(0).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("otn links should terminate on two distinct nodes", + nodeEdgePointList.get(1).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("otn links should terminate on two distinct tps", + nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), + either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); + 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()); + } + + 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", + LayerProtocolName.PHOTONICMEDIA.getName(), link.getLayerProtocolName().get(0).getName()); + assertEquals("otn tapi link should be BIDIRECTIONAL", + ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + 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()); + assertThat("oms links should terminate on two distinct nodes", + nodeEdgePointList.get(0).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("oms links should terminate on two distinct nodes", + nodeEdgePointList.get(1).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("oms links should terminate on two distinct tps", + nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), + either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); + assertThat("oms links should terminate on two distinct tps", + nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), + 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", + LayerProtocolName.PHOTONICMEDIA.getName(), link.getLayerProtocolName().get(0).getName()); + assertEquals("otn tapi link should be BIDIRECTIONAL", + ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + 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()); + assertThat("oms links should terminate on two distinct nodes", + nodeEdgePointList.get(0).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("oms links should terminate on two distinct nodes", + nodeEdgePointList.get(1).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("oms links should terminate on two distinct tps", + nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(), + either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); + assertThat("oms links should terminate on two distinct tps", + nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(), + either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue()))); + } + + private Node changeTerminationPointState(Node initialNode, String tpid, AdminStates admin, State oper) { + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder tpdr1Bldr + = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder( + initialNode.augmentation(Node1.class)); + Map tps = new HashMap<>(tpdr1Bldr.getTerminationPoint()); + TerminationPointBuilder tpBldr = new TerminationPointBuilder( + tps.get(new TerminationPointKey(new TpId(tpid)))); + tpBldr.addAugmentation(new TerminationPoint1Builder(tpBldr.augmentation(TerminationPoint1.class)) + .setAdministrativeState(admin) + .setOperationalState(oper) + .build()); + tps.replace(tpBldr.key(), tpBldr.build()); + tpdr1Bldr.setTerminationPoint(tps); + return new NodeBuilder(initialNode).addAugmentation(tpdr1Bldr.build()).build(); + } + + private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang + .ietf.network.topology.rev180226.networks.network.Link changeOtnLinkState( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network + .Link initiallink, AdminStates admin, State oper) { + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network + .LinkBuilder linkBldr = new + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network + .LinkBuilder(initiallink); + linkBldr.addAugmentation(new Link1Builder(linkBldr.augmentation(Link1.class)) + .setAdministrativeState(admin) + .setOperationalState(oper) + .build()); + return linkBldr.build(); + } +} 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 96d709e01..94ff0c67f 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 @@ -16,10 +16,11 @@ import static org.junit.Assert.assertNotNull; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ListeningExecutorService; import com.google.common.util.concurrent.MoreExecutors; -import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.UUID; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; @@ -43,17 +44,31 @@ import org.opendaylight.transportpce.test.utils.TopologyDataUtils; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointDetailsOutput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointListInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointListOutput; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.get.service._interface.point.list.output.Sip; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.get.service._interface.point.list.output.SipKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.ForwardingRule; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetLinkDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetLinkDetailsOutput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeDetailsOutput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeEdgePointDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeEdgePointDetailsOutput; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetTopologyDetailsInput; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetTopologyDetailsOutput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.Node; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.RuleType; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.topology.details.output.Topology; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroup; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.Rule; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link; @@ -116,14 +131,14 @@ public class TapiTopologyImplTest extends AbstractTest { @Nullable Topology topology = rpcResult.getResult().getTopology(); assertNotNull("Topology should not be null", topology); - Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.TPDR_100G.getBytes(Charset.forName("UTF-8"))) + Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.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()); 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()); - Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(nodeName.getValue().getBytes(Charset.forName("UTF-8"))) + 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()); long nb = topology.getNode().values().stream().findFirst().get().getOwnedNodeEdgePoint().size(); @@ -146,7 +161,7 @@ public class TapiTopologyImplTest extends AbstractTest { @Test public void getTopologyDetailsForOtnTopologyWithOtnLinksWhenSuccessful() - throws ExecutionException, InterruptedException { + throws ExecutionException, InterruptedException { GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(TopologyUtils.T0_MULTILAYER); TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils); ListenableFuture> result = tapiTopoImpl.getTopologyDetails(input); @@ -220,28 +235,28 @@ public class TapiTopologyImplTest extends AbstractTest { assertEquals("Link list should contain 8 transitional links", 8, nbOmsLinks); assertEquals("Link list should contain 2 OTN links", 2, nbOtnLinks); - Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8)) .toString()); - Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8)) .toString()); - Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(StandardCharsets.UTF_8)) .toString()); - Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+OTSi".getBytes(StandardCharsets.UTF_8)) .toString()); Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR+XPDR1-NETWORK1" - .getBytes(Charset.forName("UTF-8"))).toString()); + .getBytes(StandardCharsets.UTF_8)).toString()); Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR+XPDR1-NETWORK1" - .getBytes(Charset.forName("UTF-8"))).toString()); + .getBytes(StandardCharsets.UTF_8)).toString()); Uuid tp3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1" - .getBytes(Charset.forName("UTF-8"))).toString()); + .getBytes(StandardCharsets.UTF_8)).toString()); Uuid tp4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1" - .getBytes(Charset.forName("UTF-8"))).toString()); + .getBytes(StandardCharsets.UTF_8)).toString()); Uuid link1Uuid = new Uuid(UUID.nameUUIDFromBytes("ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1" - .getBytes(Charset.forName("UTF-8"))).toString()); + .getBytes(StandardCharsets.UTF_8)).toString()); Uuid link2Uuid = new Uuid(UUID.nameUUIDFromBytes("OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1" - .getBytes(Charset.forName("UTF-8"))).toString()); + .getBytes(StandardCharsets.UTF_8)).toString()); List links = topology.nonnullLink().values().stream() .filter(l -> l.getName().containsKey(new NameKey("otn link name"))) @@ -253,8 +268,371 @@ public class TapiTopologyImplTest extends AbstractTest { "OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"); } + @Test + public void getTopologyDetailsForFullTapiTopologyWithLinksWhenSuccessful() + throws ExecutionException, InterruptedException { + GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( + TopologyUtils.T0_FULL_MULTILAYER); + TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils); + ListenableFuture> result = tapiTopoImpl.getTopologyDetails(input); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult = result.get(); + @Nullable + Topology topology = rpcResult.getResult().getTopology(); + assertNotNull("Topology should not be null", topology); + // 2 Nodes per Xpdr/Spdr node (DSR-ODU & PHOT) + 1 Node per Roadm + assertEquals("Node list size should be 18", 18, topology.getNode().size()); + 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")) + .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream() + .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); + 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); + 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); + 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); + 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); + 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 a single external network nep", 1, enb3); + 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); + 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); + 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); + + // Now lets check for the Photonic media nodes (same nodes as for DSR + 1 Roadm node) + nb1 = 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("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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + // 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)) + .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals( + "ROADM-A1+PHOTONIC_MEDIA")) + .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); + long enb6 = topology.getNode().values().stream() + .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)) + .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals( + "ROADM-A1+PHOTONIC_MEDIA")) + .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); + + // 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 27", 27, topology.getLink().size()); + 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", + "T0 - Full Multi-layer topology", + topology.nonnullName().values().stream().findFirst().get().getValue()); + + 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); + // 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); + long nbTransititionalLinks = topology.getLink().values().stream() + .filter(l -> l.getName().containsKey(new NameKey("transitional link name"))).count(); + // Roadm-to-Roadm + long nbOmsLinks = topology.getLink().values().stream() + .filter(l -> l.getName().containsKey(new NameKey("OMS link name"))).count(); + // Xpdr-to-Roadm + long nbOmsLinks1 = topology.getLink().values().stream() + .filter(l -> l.getName().containsKey(new NameKey("XPDR-RDM link name"))).count(); + long nbOtnLinks = topology.getLink().values().stream() + .filter(l -> l.getName().containsKey(new NameKey("otn link name"))).count(); + // 1 transitional link per NETWORK port + assertEquals("Link list should contain 16 transitional links", 16, nbTransititionalLinks); + // 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); + // Should we consider OTN links as links or connections?? + assertEquals("Link list should contain 2 OTN links", 2, nbOtnLinks); + + Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8)) + .toString()); + Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR".getBytes(StandardCharsets.UTF_8)) + .toString()); + Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(StandardCharsets.UTF_8)) + .toString()); + Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+OTSi".getBytes(StandardCharsets.UTF_8)) + .toString()); + Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+eODU+XPDR1-NETWORK1" + .getBytes(StandardCharsets.UTF_8)).toString()); + Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+eODU+XPDR1-NETWORK1" + .getBytes(StandardCharsets.UTF_8)).toString()); + Uuid tp3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1" + .getBytes(StandardCharsets.UTF_8)).toString()); + Uuid tp4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1" + .getBytes(StandardCharsets.UTF_8)).toString()); + Uuid link1Uuid = + new Uuid(UUID.nameUUIDFromBytes("ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1" + .getBytes(StandardCharsets.UTF_8)).toString()); + Uuid link2Uuid = + new Uuid(UUID.nameUUIDFromBytes("OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1" + .getBytes(StandardCharsets.UTF_8)).toString()); + + List links = topology.nonnullLink().values().stream() + .filter(l -> l.getName().containsKey(new NameKey("otn link name"))) + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + checkOtnLink(links.get(0), topoUuid, node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, link1Uuid, + "ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"); + checkOtnLink(links.get(1), topoUuid, node3Uuid, node4Uuid, tp3Uuid, tp4Uuid, link2Uuid, + "OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"); + } + + @Test + public void getNodeAndNepsDetailsWhenSuccessful() + throws ExecutionException, InterruptedException { + GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( + TopologyUtils.T0_FULL_MULTILAYER); + TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils); + ListenableFuture> result = tapiTopoImpl.getTopologyDetails(input); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult = result.get(); + @Nullable + Topology topology = rpcResult.getResult().getTopology(); + for (Node node:topology.getNode().values()) { + String nodeName = node.getName().values().stream().findFirst().get().getValue(); + GetNodeDetailsInput input1 = TapiTopologyDataUtils.buildGetNodeDetailsInput( + TopologyUtils.T0_FULL_MULTILAYER, nodeName); + ListenableFuture> result1 = tapiTopoImpl.getNodeDetails(input1); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult1 = result1.get(); + @Nullable + Node node1 = rpcResult1.getResult().getNode(); + assertNotNull("Node should not be null", node1); + for (OwnedNodeEdgePoint onep:node1.getOwnedNodeEdgePoint().values()) { + String onepName = onep.getName().values().stream().findFirst().get().getValue(); + GetNodeEdgePointDetailsInput input2 = TapiTopologyDataUtils.buildGetNodeEdgePointDetailsInput( + TopologyUtils.T0_FULL_MULTILAYER, nodeName, onepName); + ListenableFuture> result2 + = tapiTopoImpl.getNodeEdgePointDetails(input2); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult2 = result2.get(); + 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); + } + } + } + + @Test + public void getLinkDetailsWhenSuccessful() + throws ExecutionException, InterruptedException { + GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput( + TopologyUtils.T0_FULL_MULTILAYER); + TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils); + ListenableFuture> result = tapiTopoImpl.getTopologyDetails(input); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult = result.get(); + @Nullable + Topology topology = rpcResult.getResult().getTopology(); + for (Link link:topology.getLink().values()) { + String linkName = link.getName().values().stream().findFirst().get().getValue(); + GetLinkDetailsInput input1 = TapiTopologyDataUtils.buildGetLinkDetailsInput( + TopologyUtils.T0_FULL_MULTILAYER, linkName); + ListenableFuture> result1 = tapiTopoImpl.getLinkDetails(input1); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + 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); + } + } + + @Test + public void getSipDetailsWhenSuccessful() + throws ExecutionException, InterruptedException { + GetServiceInterfacePointListInput input = TapiTopologyDataUtils.buildServiceInterfacePointListInput(); + TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(getDataBroker(), tapiContext, topologyUtils); + ListenableFuture> result = tapiTopoImpl + .getServiceInterfacePointList(input); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult = result.get(); + Map sipMap = rpcResult.getResult().getSip(); + for (Sip sip:sipMap.values()) { + Uuid sipUuid = sip.getUuid(); + GetServiceInterfacePointDetailsInput input1 = TapiTopologyDataUtils + .buildGetServiceInterfacePointDetailsInput(sipUuid); + ListenableFuture> result1 + = tapiTopoImpl.getServiceInterfacePointDetails(input1); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult1 = result1.get(); + 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); + } + } + private void checkOtnLink(Link link, Uuid topoUuid, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, - Uuid linkUuid, String linkName) { + 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", 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 new file mode 100644 index 000000000..0384dcf31 --- /dev/null +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TapiConnectivityDataUtils.java @@ -0,0 +1,217 @@ +/* + * Copyright © 2021 Nokia, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.tapi.utils; + +import java.nio.charset.StandardCharsets; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.node.types.rev181130.NodeIdType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ConnectionType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.RpcActions; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.sdnc.request.header.SdncRequestHeaderBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.RxDirection; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.RxDirectionBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.TxDirection; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.TxDirectionBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.lgx.LgxBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.port.PortBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceAEndBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceZEndBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.TotalSizeBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.local._class.Name; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.local._class.NameBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.CreateConnectivityServiceInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.CreateConnectivityServiceInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.DeleteConnectivityServiceInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.DeleteConnectivityServiceInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ProtectionRole; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ServiceType; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.constraint.RequestedCapacityBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityService; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.Connection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.ConnectionBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.ConnectionKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.end.point.ServiceInterfacePointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.create.connectivity.service.input.ConnectivityConstraintBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.create.connectivity.service.input.EndPoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.create.connectivity.service.input.EndPointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.create.connectivity.service.input.EndPointKey; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.opendaylight.yangtools.yang.common.Uint64; + +public final class TapiConnectivityDataUtils { + public static CreateConnectivityServiceInput buildConnServiceCreateInput() { + + EndPoint endPoint1 = getEndPoint1Builder().build(); + EndPoint endPoint2 = getEndPoint2Builder().build(); + Map endPointMap = new HashMap<>(); + endPointMap.put(endPoint1.key(), endPoint1); + endPointMap.put(endPoint2.key(), endPoint2); + + return new CreateConnectivityServiceInputBuilder() + .setEndPoint(endPointMap) + .setConnectivityConstraint(new ConnectivityConstraintBuilder().setServiceLayer(LayerProtocolName.DSR) + .setServiceType(ServiceType.POINTTOPOINTCONNECTIVITY).setServiceLevel("some service-level") + .setRequestedCapacity(new RequestedCapacityBuilder() + .setTotalSize(new TotalSizeBuilder().setUnit(CapacityUnit.GBPS) + .setValue(Uint64.valueOf(10)).build()).build()).build()) + .setState("some state") + .build(); + } + + public static DeleteConnectivityServiceInput buildConnServiceDeleteInput() { + return new DeleteConnectivityServiceInputBuilder() + .setServiceIdOrName(UUID.nameUUIDFromBytes("service 1".getBytes(StandardCharsets.UTF_8)).toString()) + .build(); + } + + private static EndPointBuilder getEndPoint2Builder() { + Name name = new NameBuilder().setValueName("OpenROADM node id").setValue("SPDR-SC1-XPDR1").build(); + return new EndPointBuilder().setLayerProtocolName(LayerProtocolName.DSR) + .setAdministrativeState(AdministrativeState.UNLOCKED) + .setOperationalState(OperationalState.ENABLED) + .setDirection(PortDirection.BIDIRECTIONAL) + .setRole(PortRole.SYMMETRIC) + .setProtectionRole(ProtectionRole.NA) + .setLocalId("SPDR-SC1-XPDR1") + .setName(Map.of(name.key(), name)) + .setServiceInterfacePoint(new ServiceInterfacePointBuilder().setServiceInterfacePointUuid( + new Uuid("25812ef2-625d-3bf8-af55-5e93946d1c22")).build()); + } + + private static EndPointBuilder getEndPoint1Builder() { + Name name = new NameBuilder().setValueName("OpenROADM node id").setValue("SPDR-SA1-XPDR1").build(); + return new EndPointBuilder().setLayerProtocolName(LayerProtocolName.DSR) + .setAdministrativeState(AdministrativeState.UNLOCKED) + .setOperationalState(OperationalState.ENABLED) + .setDirection(PortDirection.BIDIRECTIONAL) + .setRole(PortRole.SYMMETRIC) + .setProtectionRole(ProtectionRole.NA) + .setLocalId("SPDR-SA1-XPDR1") + .setName(Map.of(name.key(), name)) + .setServiceInterfacePoint(new ServiceInterfacePointBuilder().setServiceInterfacePointUuid( + new Uuid("c14797a0-adcc-3875-a1fe-df8949d1a2d7")).build()); + } + + public static ServiceCreateInput buildServiceCreateInput() { + + return new ServiceCreateInputBuilder() + .setCommonId("commonId") + .setConnectionType(ConnectionType.Service) + .setCustomer("Customer") + .setServiceName(UUID.nameUUIDFromBytes("service 1".getBytes(StandardCharsets.UTF_8)).toString()) + .setServiceAEnd(getServiceAEndBuild().build()) + .setServiceZEnd(getServiceZEndBuild().build()) + .setSdncRequestHeader(new SdncRequestHeaderBuilder().setRequestId("request 1") + .setRpcAction(RpcActions.ServiceCreate).setNotificationUrl("notification url").build()) + .build(); + } + + public static ServiceAEndBuilder getServiceAEndBuild() { + return new ServiceAEndBuilder() + .setClli("NodeSA").setServiceFormat(ServiceFormat.Ethernet).setServiceRate(Uint32.valueOf(10)) + .setNodeId(new NodeIdType("SPDR-SA1")) + .setTxDirection(getTxDirection()) + .setRxDirection(getRxDirection()); + } + + public static ServiceZEndBuilder getServiceZEndBuild() { + return new ServiceZEndBuilder() + .setClli("NodeSC").setServiceFormat(ServiceFormat.Ethernet).setServiceRate(Uint32.valueOf(10)) + .setNodeId(new NodeIdType("SPDR-SC1")) + .setTxDirection(getTxDirection()) + .setRxDirection(getRxDirection()); + } + + private static TxDirection getTxDirection() { + return new TxDirectionBuilder().setPort(new PortBuilder().setPortDeviceName("device name") + .setPortName("port name").setPortRack("port rack").setPortShelf("port shelf") + .setPortSlot("port slot").setPortSubSlot("port subslot").setPortType("port type").build()) + .setLgx(new LgxBuilder().setLgxDeviceName("lgx device name").setLgxPortName("lgx port name") + .setLgxPortRack("lgx port rack").setLgxPortShelf("lgx port shelf").build()) + .build(); + } + + private static RxDirection getRxDirection() { + return new RxDirectionBuilder() + .setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name") + .setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot") + .setPortSubSlot("port subslot").setPortType("port type").build()) + .setLgx(new LgxBuilder().setLgxDeviceName("lgx device name") + .setLgxPortName("lgx port name").setLgxPortRack("lgx port rack") + .setLgxPortShelf("lgx port shelf").build()) + .build(); + } + + public static Map createConnService() { + EndPoint endPoint1 = getEndPoint1Builder().build(); + EndPoint endPoint2 = getEndPoint2Builder().build(); + + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPoint + endPoint11 = new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPointBuilder(endPoint1).build(); + + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPoint + endPoint12 = new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPointBuilder(endPoint2).build(); + + Map + endPointMap = new HashMap<>(); + endPointMap.put(endPoint11.key(), endPoint11); + endPointMap.put(endPoint12.key(), endPoint12); + + Map connectionMap = new HashMap<>(); + Connection connection = new ConnectionBuilder().setConnectionUuid(new Uuid(UUID.randomUUID().toString())) + .build(); + connectionMap.put(connection.key(), connection); + + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name name = + new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder() + .setValueName("Connectivity Service Name").setValue("service 1") + .build(); + ConnectivityService connServ = new ConnectivityServiceBuilder() + .setAdministrativeState(AdministrativeState.LOCKED) + .setOperationalState(OperationalState.DISABLED) + .setLifecycleState(LifecycleState.PLANNED) + .setUuid(new Uuid(UUID.nameUUIDFromBytes("service 1".getBytes(StandardCharsets.UTF_8)).toString())) + .setServiceLayer(LayerProtocolName.DSR) + .setServiceType(ServiceType.POINTTOPOINTCONNECTIVITY) + .setConnectivityDirection(ForwardingDirection.BIDIRECTIONAL) + .setName(Map.of(name.key(), name)) + .setConnection(connectionMap) + .setEndPoint(endPointMap) + .build(); + Map connMap = new HashMap<>(); + connMap.put(connServ.key(), connServ); + return connMap; + } + + public static DeleteConnectivityServiceInput buildConnServiceDeleteInput1() { + return new DeleteConnectivityServiceInputBuilder() + .setServiceIdOrName("random-service").build(); + } + + private TapiConnectivityDataUtils() { + } +} 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 7448329d3..32cbbf19e 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 @@ -8,6 +8,17 @@ package org.opendaylight.transportpce.tapi.utils; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointDetailsInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointListInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.GetServiceInterfacePointListInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetLinkDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetLinkDetailsInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeDetailsInputBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeEdgePointDetailsInput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetNodeEdgePointDetailsInputBuilder; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetTopologyDetailsInput; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetTopologyDetailsInputBuilder; @@ -23,7 +34,39 @@ public final class TapiTopologyDataUtils { return builtInput.build(); } - private TapiTopologyDataUtils() { + public static GetNodeDetailsInput buildGetNodeDetailsInput(String topoName, String nodeName) { + GetNodeDetailsInputBuilder builtInput = new GetNodeDetailsInputBuilder(); + builtInput.setTopologyIdOrName(topoName); + builtInput.setNodeIdOrName(nodeName); + return builtInput.build(); + } + + public static GetLinkDetailsInput buildGetLinkDetailsInput(String topoName, String linkName) { + GetLinkDetailsInputBuilder builtInput = new GetLinkDetailsInputBuilder(); + builtInput.setTopologyIdOrName(topoName); + builtInput.setLinkIdOrName(linkName); + return builtInput.build(); + } + + public static GetServiceInterfacePointListInput buildServiceInterfacePointListInput() { + return new GetServiceInterfacePointListInputBuilder().build(); } + public static GetServiceInterfacePointDetailsInput buildGetServiceInterfacePointDetailsInput(Uuid sipUuid) { + GetServiceInterfacePointDetailsInputBuilder builtInput = new GetServiceInterfacePointDetailsInputBuilder(); + builtInput.setSipIdOrName(sipUuid.getValue()); + return builtInput.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(); + } + + private TapiTopologyDataUtils() { + } }