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 <errea@eurecom.fr>
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 7011804a85fc278ba46bc87081fd852f69f9bcba..cd5d1da72a2609f76cdf9bf07f60f8bd76dfb56f 100644 (file)
--- 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<RpcResult<ServiceDeleteOutput>> 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.<DeleteConnectivityServiceOutput>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<RpcResult<ServiceDeleteOutput>> 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<ServiceDeleteOutput> 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.<DeleteConnectivityServiceOutput>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 4c97d01b2f6d70d35b2bd0d1bd27506222616119..ec7408eb0ac63aacdd6a956c6eeb6b63641fbef2 100644 (file)
--- 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 14fdb46df990f45c6776d470db1309b71c9001bc..cd48f0f61f4bd8f25c57b50a20b0ab99dd27a668 100644 (file)
--- 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 (file)
index 0000000..013abb3
--- /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<RpcResult<CreateConnectivityServiceOutput>> result =
+            tapiConnectivity.createConnectivityService(new CreateConnectivityServiceInputBuilder().build());
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                callbackRan = true;
+                endSignal.countDown();
+            }
+        }, executorService);
+
+        endSignal.await();
+
+        RpcResult<CreateConnectivityServiceOutput> 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<RpcResult<CreateConnectivityServiceOutput>> result =
+            tapiConnectivity.createConnectivityService(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                callbackRan = true;
+                endSignal.countDown();
+            }
+        }, executorService);
+
+        endSignal.await();
+
+        RpcResult<CreateConnectivityServiceOutput> 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<RpcResult<DeleteConnectivityServiceOutput>> result =
+            tapiConnectivity.deleteConnectivityService(new DeleteConnectivityServiceInputBuilder().build());
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                callbackRan = true;
+                endSignal.countDown();
+            }
+        }, executorService);
+
+        endSignal.await();
+
+        RpcResult<DeleteConnectivityServiceOutput> 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<RpcResult<DeleteConnectivityServiceOutput>> result =
+            tapiConnectivity.deleteConnectivityService(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                callbackRan = true;
+                endSignal.countDown();
+            }
+        }, executorService);
+
+        endSignal.await();
+
+        RpcResult<DeleteConnectivityServiceOutput> 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<RpcResult<DeleteConnectivityServiceOutput>> result =
+            tapiConnectivity.deleteConnectivityService(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                callbackRan = true;
+                endSignal.countDown();
+            }
+        }, executorService);
+
+        endSignal.await();
+
+        RpcResult<DeleteConnectivityServiceOutput> 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 (file)
index 0000000..878c763
--- /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 (file)
index 0000000..6e5331e
--- /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<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+        .networks.network.Link> otnLinks;
+    private static Map<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+        .networks.network.Link> 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<Node, NodeKey> 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<Optional<Node>> muxAFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, muxAIID);
+        otnMuxA = muxAFuture.get().get();
+        KeyedInstanceIdentifier<Node, NodeKey> 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<Optional<Node>> muxCFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, muxCIID);
+        otnMuxC = muxCFuture.get().get();
+        KeyedInstanceIdentifier<Node, NodeKey> 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<Optional<Node>> switchFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, switchIID);
+        otnSwitch = switchFuture.get().get();
+        KeyedInstanceIdentifier<Node, NodeKey> 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<Optional<Node>> roadmaFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, roadmaIID);
+        roadmA = roadmaFuture.get().get();
+        KeyedInstanceIdentifier<Node, NodeKey> 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<Optional<Node>> roadmcFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, roadmcIID);
+        roadmC = roadmcFuture.get().get();
+
+        KeyedInstanceIdentifier<Node, NodeKey> 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<Optional<Node>> tpdrFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, tpdrIID);
+        tpdr100G = tpdrFuture.get().get();
+
+        InstanceIdentifier<Network1> 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<Optional<Network1>> linksFuture = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, linksIID);
+        otnLinks = linksFuture.get().get().getLink();
+
+        InstanceIdentifier<Network1> 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<Optional<Network1>> links1Future = dataBroker.newReadOnlyTransaction()
+            .read(LogicalDatastoreType.CONFIGURATION, links1IID);
+        ortopoLinks = links1Future.get().get().getLink();
+
+        InstanceIdentifier<Network> 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<Optional<Network>> 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<String> 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<String> 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<String> 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<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+            .networks.network.Link> 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<String> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+            .networks.network.Link> 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<String> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+            .networks.network.Link> 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<String> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+            .networks.network.Link> 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<String> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+            .networks.network.Link> 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<String> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<String> 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<String> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> 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<Link> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<String> 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<Link> 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<Link> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link> 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<OwnedNodeEdgePoint> 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<OwnedNodeEdgePoint> 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<OwnedNodeEdgePoint> 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<NodeRuleGroup> 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<NodeRuleGroup> 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<NodeRuleGroup> 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<OwnedNodeEdgePoint> nepsI = null;
+        List<OwnedNodeEdgePoint> nepsE = null;
+        List<OwnedNodeEdgePoint> nepsP = null;
+        List<OwnedNodeEdgePoint> nepsMc = null;
+        List<OwnedNodeEdgePoint> nepsOtsimc = null;
+        List<OwnedNodeEdgePoint> 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<NodeRuleGroup> 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<NodeRuleGroup> 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<NodeRuleGroup> 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<NodeRuleGroup> 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<Name> 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<Name> 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<NodeRuleGroup> 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<NodeEdgePoint> 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> 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<NodeRuleGroup> 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<NodeEdgePoint> 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> 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<NodeRuleGroup> 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<NodeEdgePoint> 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<Rule> 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<NodeRuleGroup> nrgList, int nbNeps) {
+        assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size());
+        if (nbNeps > 0) {
+            List<NodeEdgePoint> 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<Rule> 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<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
+                                               Uuid nodeUuid) {
+        assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size());
+        List<NodeEdgePoint> 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<Rule> 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<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
+                                              Uuid nodeUuid) {
+        assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size());
+        List<NodeEdgePoint> 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<Rule> 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<NodeRuleGroup> 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<NodeEdgePoint> 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<NodeEdgePoint> 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<Rule> 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<Name> 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<Name> 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<Name> 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<Name> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
+            .link.NodeEdgePoint> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
+            .link.NodeEdgePoint> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
+            .link.NodeEdgePoint> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
+            .link.NodeEdgePoint> 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<TerminationPointKey, TerminationPoint> 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 96d709e016c774980fe982df14841e048c5f7249..94ff0c67f21e9b2ceba3e5faba468cc14c9287b7 100644 (file)
--- 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<RpcResult<GetTopologyDetailsOutput>> 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<Link> 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<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                endSignal.countDown();
+            }
+        }, executorService);
+        endSignal.await();
+        RpcResult<GetTopologyDetailsOutput> 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<Link> 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<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                endSignal.countDown();
+            }
+        }, executorService);
+        endSignal.await();
+        RpcResult<GetTopologyDetailsOutput> 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<RpcResult<GetNodeDetailsOutput>> result1 = tapiTopoImpl.getNodeDetails(input1);
+            result.addListener(new Runnable() {
+                @Override
+                public void run() {
+                    endSignal.countDown();
+                }
+            }, executorService);
+            endSignal.await();
+            RpcResult<GetNodeDetailsOutput> 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<RpcResult<GetNodeEdgePointDetailsOutput>> result2
+                    = tapiTopoImpl.getNodeEdgePointDetails(input2);
+                result.addListener(new Runnable() {
+                    @Override
+                    public void run() {
+                        endSignal.countDown();
+                    }
+                }, executorService);
+                endSignal.await();
+                RpcResult<GetNodeEdgePointDetailsOutput> 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<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                endSignal.countDown();
+            }
+        }, executorService);
+        endSignal.await();
+        RpcResult<GetTopologyDetailsOutput> 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<RpcResult<GetLinkDetailsOutput>> result1 = tapiTopoImpl.getLinkDetails(input1);
+            result.addListener(new Runnable() {
+                @Override
+                public void run() {
+                    endSignal.countDown();
+                }
+            }, executorService);
+            endSignal.await();
+            RpcResult<GetLinkDetailsOutput> 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<RpcResult<GetServiceInterfacePointListOutput>> result = tapiTopoImpl
+            .getServiceInterfacePointList(input);
+        result.addListener(new Runnable() {
+            @Override
+            public void run() {
+                endSignal.countDown();
+            }
+        }, executorService);
+        endSignal.await();
+        RpcResult<GetServiceInterfacePointListOutput> rpcResult = result.get();
+        Map<SipKey, Sip> sipMap = rpcResult.getResult().getSip();
+        for (Sip sip:sipMap.values()) {
+            Uuid sipUuid = sip.getUuid();
+            GetServiceInterfacePointDetailsInput input1 = TapiTopologyDataUtils
+                .buildGetServiceInterfacePointDetailsInput(sipUuid);
+            ListenableFuture<RpcResult<GetServiceInterfacePointDetailsOutput>> result1
+                = tapiTopoImpl.getServiceInterfacePointDetails(input1);
+            result.addListener(new Runnable() {
+                @Override
+                public void run() {
+                    endSignal.countDown();
+                }
+            }, executorService);
+            endSignal.await();
+            RpcResult<GetServiceInterfacePointDetailsOutput> 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 (file)
index 0000000..0384dcf
--- /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<EndPointKey, EndPoint> 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<ConnectivityServiceKey, ConnectivityService> 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<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPointKey,
+            org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPoint>
+                endPointMap = new HashMap<>();
+        endPointMap.put(endPoint11.key(), endPoint11);
+        endPointMap.put(endPoint12.key(), endPoint12);
+
+        Map<ConnectionKey, Connection> 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<ConnectivityServiceKey, ConnectivityService> 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 7448329d328b7443be02d33ab350a5e1da2b00f3..32cbbf19ed9acf8bcda4db2331f854b94fa0bef3 100644 (file)
--- 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() {
+    }
 }