From: Gilles Thouenon Date: Thu, 4 Jun 2020 08:15:22 +0000 (+0200) Subject: Junit tests for network model X-Git-Tag: 2.0.0~108 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=transportpce.git;a=commitdiff_plain;h=29e64054b07584f432b8f23a8bfd2cab2cad0427 Junit tests for network model Add new Junit unitary tests for package org.opendaylight.transportpce.networkmodel.util JIRA: TRNSPRTPCE-270 Signed-off-by: Gilles Thouenon Co-authored-by: Emmanuelle Delfour Change-Id: Ia93aa3b37bc5a2df8981e862ebffd164bcd5d852 --- diff --git a/networkmodel/pom.xml b/networkmodel/pom.xml index 66a36d903..5b78bf37c 100644 --- a/networkmodel/pom.xml +++ b/networkmodel/pom.xml @@ -22,6 +22,18 @@ and is available at http://www.eclipse.org/legal/epl-v10.html 2.0.0-SNAPSHOT bundle + + + + org.opendaylight.mdsal + mdsal-artifacts + 5.0.10 + import + pom + + + + ${project.groupId} @@ -36,6 +48,25 @@ and is available at http://www.eclipse.org/legal/epl-v10.html 3.0.2 true + + + + ${project.groupId} + test-common + ${project.version} + test + + + org.opendaylight.mdsal + mdsal-binding-dom-adapter + test + + + org.opendaylight.mdsal + mdsal-binding-dom-adapter + test + test-jar + diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetworkModelProviderTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetworkModelProviderTest.java new file mode 100644 index 000000000..c2ea4b72d --- /dev/null +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetworkModelProviderTest.java @@ -0,0 +1,61 @@ +/* + * Copyright © 2020 Orange, 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.networkmodel; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.common.util.concurrent.FluentFuture; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.stubbing.Answer; +import org.opendaylight.mdsal.binding.api.RpcProviderService; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev170818.TransportpceNetworkutilsService; + + +@RunWith(MockitoJUnitRunner.StrictStubs.class) +public class NetworkModelProviderTest extends AbstractTest { + @Mock + NetworkTransactionService networkTransactionService; + @Mock + RpcProviderService rpcProviderService; + @Mock + TransportpceNetworkutilsService networkutilsService; + @Mock + NetConfTopologyListener topologyListener; + + + @Test + public void networkmodelProviderInitTest() { + NetworkModelProvider provider = new NetworkModelProvider(networkTransactionService, getDataBroker(), + rpcProviderService, networkutilsService, topologyListener); + Answer> answer = new Answer>() { + + @Override + public FluentFuture answer(InvocationOnMock invocation) throws Throwable { + return CommitInfo.emptyFluentFuture(); + } + + }; + when(networkTransactionService.commit()).then(answer); + + provider.init(); + + verify(rpcProviderService, times(1)) + .registerRpcImplementation(any(), any(TransportpceNetworkutilsService.class)); + } + +} diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetworkModelTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetworkModelTest.java deleted file mode 100644 index 5002d5749..000000000 --- a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetworkModelTest.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright © 2017 AT&T 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.networkmodel; - -import org.junit.Test; - -public class NetworkModelTest { - @Test - public void init() throws Exception { - //TODO implement test - } - -} diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/ClliNetworkTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/ClliNetworkTest.java new file mode 100644 index 000000000..a4a5bd767 --- /dev/null +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/ClliNetworkTest.java @@ -0,0 +1,79 @@ +/* + * Copyright © 2020 Orange Labs, 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.networkmodel.util; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.Test; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfo; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfo.OpenroadmVersion; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfoBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.Node1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.NodeTypes; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; +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.Node; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey; + +public class ClliNetworkTest { + + @Test + public void createNodeTest() { + //prepare data test + NodeInfo nodeInfo = computeNodeInfoBuilder().build(); + Node1 clliAugmentation = new Node1Builder() + .setClli(nodeInfo .getNodeClli()) + .build(); + + //run test + Node createdNode = ClliNetwork.createNode("XPDRA01", nodeInfo); + assertNull("SupportingNode should be null", createdNode.getSupportingNode()); + assertEquals("Node key should be equals to NodeClliId ", new NodeKey(new NodeId("NodeClliId")), + createdNode.key()); + assertEquals("Expect org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.Node1 augmentation", + clliAugmentation, createdNode.augmentation(Node1.class)); + } + + @Test + public void createNodeWithNullDeviceIdTest() { + Node createdNode = ClliNetwork.createNode(null, computeNodeInfoBuilder().build()); + assertNull("SupportingNode should be null", createdNode.getSupportingNode()); + assertEquals("Node id should be equals to NodeClliId ", new NodeId("NodeClliId"), createdNode.getNodeId()); + } + + @Test + public void createNodeWithNullClliTest() { + NodeInfoBuilder nodeBldr = computeNodeInfoBuilderWithoutClli(); + Node createdNode = ClliNetwork.createNode("XPDRA01", nodeBldr.build()); + assertNull("Node id should be null", createdNode.getNodeId()); + } + + private NodeInfoBuilder computeNodeInfoBuilder() { + NodeInfoBuilder nodeBldr = new NodeInfoBuilder() + .setNodeClli("NodeClliId") + .setNodeModel("NodeModel") + .setNodeIpAddress(new IpAddress(new Ipv4Address("127.0.0.1"))) + .setNodeType(NodeTypes.Xpdr) + .setNodeVendor("VendorA") + .setOpenroadmVersion(OpenroadmVersion._121); + return nodeBldr; + } + + private NodeInfoBuilder computeNodeInfoBuilderWithoutClli() { + NodeInfoBuilder nodeBldr = new NodeInfoBuilder() + .setNodeModel("NodeModel") + .setNodeIpAddress(new IpAddress(new Ipv4Address("127.0.0.1"))) + .setNodeType(NodeTypes.Xpdr) + .setNodeVendor("VendorA") + .setOpenroadmVersion(OpenroadmVersion._121); + return nodeBldr; + } +} diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmNetworkTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmNetworkTest.java new file mode 100644 index 000000000..9c022434c --- /dev/null +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmNetworkTest.java @@ -0,0 +1,95 @@ +/* + * Copyright © 2020 Orange Labs, 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.networkmodel.util; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.Ignore; +import org.junit.Test; +import org.opendaylight.transportpce.common.NetworkUtils; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfo; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfo.OpenroadmVersion; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfoBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.NodeTypes; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; +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.NodeId; +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.node.SupportingNode; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder; + +public class OpenRoadmNetworkTest { + + @Test + public void createXpdrNodeTest() { + NodeInfo nodeInfo = computeNodeInfo(NodeTypes.Xpdr, "nodeA"); + Node createdNode = OpenRoadmNetwork.createNode("XPDRA01", nodeInfo); + assertEquals("XPDRA01", createdNode.getNodeId().getValue()); + assertEquals("XPONDER", createdNode.augmentation(Node1.class).getNodeType().getName()); + + supportingNodeTest(nodeInfo.getNodeClli(), createdNode); + } + + @Test + public void createRdmNodeTest() { + NodeInfo nodeInfo = computeNodeInfo(NodeTypes.Rdm, "nodeA"); + Node createdNode = OpenRoadmNetwork.createNode("XPDRA01", nodeInfo); + assertEquals("XPDRA01", createdNode.getNodeId().getValue()); + assertEquals("ROADM", createdNode.augmentation(Node1.class).getNodeType().getName()); + + supportingNodeTest(nodeInfo.getNodeClli(), createdNode); + } + + @Test + public void createNodeWithBadNodeTypeTest() { + NodeInfo nodeInfo = computeNodeInfo(NodeTypes.Ila, "nodeA"); + Node createdNode = OpenRoadmNetwork.createNode("XPDRA01", nodeInfo); + assertEquals("XPDRA01", createdNode.getNodeId().getValue()); + assertNull("NodeType should be ROADM or XPONDER", createdNode.augmentation(Node1.class).getNodeType()); + + supportingNodeTest(nodeInfo.getNodeClli(), createdNode); + } + + @Ignore + @Test + public void createNodeWithoutClliTest() { + NodeInfo nodeInfo = computeNodeInfo(NodeTypes.Xpdr, null); + Node createdNode = OpenRoadmNetwork.createNode("XPDRA01", nodeInfo); + assertEquals("XPDRA01", createdNode.getNodeId().getValue()); + assertEquals("XPONDER", createdNode.augmentation(Node1.class).getNodeType().getName()); + assertEquals(0, createdNode.getSupportingNode().size()); + } + + private NodeInfo computeNodeInfo(NodeTypes nodeType, String clli) { + return new NodeInfoBuilder() + .setNodeModel("NodeModel") + .setNodeIpAddress(new IpAddress(new Ipv4Address("127.0.0.1"))) + .setNodeType(nodeType) + .setNodeClli(clli) + .setNodeVendor("VendorA") + .setOpenroadmVersion(OpenroadmVersion._121) + .build(); + } + + private SupportingNode computeSupportingNode(String clli) { + return new SupportingNodeBuilder() + .setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)) + .setNodeRef(new NodeId(clli)) + .build(); + } + + private void supportingNodeTest(String clli, Node createdNode) { + SupportingNode supportingNode = computeSupportingNode(clli); + assertEquals(1, createdNode.getSupportingNode().size()); + assertEquals(supportingNode, createdNode.getSupportingNode().get(0)); + } +} \ No newline at end of file diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopologyTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopologyTest.java new file mode 100644 index 000000000..fa9073978 --- /dev/null +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopologyTest.java @@ -0,0 +1,447 @@ +/* + * Copyright © 2020 Orange Labs, 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.networkmodel.util; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.common.util.concurrent.FluentFuture; +import com.google.common.util.concurrent.ListenableFuture; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executor; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.stream.Collectors; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.stubbing.Answer; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.NetworkUtils; +import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.transportpce.networkmodel.dto.TopologyShard; +import org.opendaylight.transportpce.networkmodel.util.test.NetworkmodelTestUtil; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.Nodes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Link1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev181130.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.XpdrNodeTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.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.node.SupportingNode; +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.networks.network.Link; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkBuilder; +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.link.DestinationBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.link.SourceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.Uint16; + + +@RunWith(MockitoJUnitRunner.StrictStubs.class) +public class OpenRoadmTopologyTest { + @Mock + private NetworkTransactionService networkTransactionService; + + @Test + public void createTopologyShardForDegreeTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForRdm("ROADMA01", "nodeA", 2, 0); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + assertEquals("Should contain 2 Degree nodes only", 2, topologyShard.getNodes().size()); + assertEquals("Should contain 2 links", 2, topologyShard.getLinks().size()); + List nodes = topologyShard.getNodes().stream() + .sorted((n1, n2) -> n1.getNodeId().getValue().compareTo(n2.getNodeId().getValue())) + .collect(Collectors.toList()); + for (Node node : nodes) { + String nodeNb = node.getNodeId().getValue().substring(node.getNodeId().getValue().length() - 1); + checkDegreeNode(nodeNb, node); + } + + List links = topologyShard.getLinks().stream() + .sorted((l1, l2) -> l1.getLinkId().getValue().compareTo(l2.getLinkId().getValue())) + .collect(Collectors.toList()); + assertEquals("Should contain 2 express links", 2, links.size()); + assertEquals("ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX", links.get(0).getLinkId().getValue()); + assertEquals("ROADMA01-DEG1", links.get(0).getSource().getSourceNode().getValue()); + assertEquals("DEG1-CTP-TXRX", links.get(0).getSource().getSourceTp()); + assertEquals("ROADMA01-DEG2", links.get(0).getDestination().getDestNode().getValue()); + assertEquals("DEG2-CTP-TXRX", links.get(0).getDestination().getDestTp()); + assertEquals("ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX", links.get(1).getLinkId().getValue()); + assertEquals("ROADMA01-DEG2", links.get(1).getSource().getSourceNode().getValue()); + assertEquals("DEG2-CTP-TXRX", links.get(1).getSource().getSourceTp()); + assertEquals("ROADMA01-DEG1", links.get(1).getDestination().getDestNode().getValue()); + assertEquals("DEG1-CTP-TXRX", links.get(1).getDestination().getDestTp()); + } + + @Test + public void createTopologyShardForSrgTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForRdm("ROADMA01", "nodeA", 0, 1); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + List nodes = topologyShard.getNodes(); + assertEquals("Should contain 1 SRG node only", 1, nodes.size()); + assertEquals("Should contain 0 link", 0, topologyShard.getLinks().size()); + checkSrgNode("1", nodes.get(0)); + } + + @Test + public void createTopologyShardForCompleteRdmNodeTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForRdm("ROADMA01", "nodeA", 2, 2); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + assertEquals("Should contain 2 Deg and 2 SRG nodes", 4, topologyShard.getNodes().size()); + List addLinks = topologyShard.getLinks().stream() + .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.ADDLINK)) + .collect(Collectors.toList()); + assertEquals("Should contain 4 add links", 4, addLinks.size()); + List dropLinks = topologyShard.getLinks().stream() + .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.DROPLINK)) + .collect(Collectors.toList()); + assertEquals("Should contain 4 drop links", 4, dropLinks.size()); + List expressLinks = topologyShard.getLinks().stream() + .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.EXPRESSLINK)) + .collect(Collectors.toList()); + assertEquals("Should contain 2 express links", 2, expressLinks.size()); + } + + @Test + public void createTopologyShardForTpdrNodeTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForXpdr("XPDRA01", "nodeA", 2, 2, null); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + assertEquals("Should contain a single node", 1, topologyShard.getNodes().size()); + assertEquals("Should contain 0 link", 0, topologyShard.getLinks().size()); + checkTpdrNode(topologyShard.getNodes().get(0)); + } + + @Test + public void createTopologyShardForTpdrNode2Test() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForXpdr("XPDRA01", "nodeA", 2, 2, XpdrNodeTypes.Tpdr); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + assertEquals("Should contain a single node", 1, topologyShard.getNodes().size()); + assertEquals("Should contain 0 link", 0, topologyShard.getLinks().size()); + checkTpdrNode(topologyShard.getNodes().get(0)); + } + + @Test + public void createTopologyShardForMpdrNodeTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForXpdr("XPDRA01", "nodeA", 2, 2, XpdrNodeTypes.Mpdr); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + assertEquals("Should contain a single node", 1, topologyShard.getNodes().size()); + assertEquals("Should contain 0 link", 0, topologyShard.getLinks().size()); + checkOtnXpdrNode(topologyShard.getNodes().get(0)); + } + + @Test + public void createTopologyShardForSwitchNodeTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForXpdr("XPDRA01", "nodeA", 2, 2, XpdrNodeTypes.Switch); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNotNull(topologyShard); + assertEquals("Should contain a single node", 1, topologyShard.getNodes().size()); + assertEquals("Should contain 0 link", 0, topologyShard.getLinks().size()); + checkOtnXpdrNode(topologyShard.getNodes().get(0)); + } + + @Ignore + @Test + public void createTopologyShardForRdmWithoutClliTest() { + Nodes mappingNode = NetworkmodelTestUtil.createMappingForRdm("ROADMA01", null, 2, 0); + TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(mappingNode); + assertNull("clli must not be null", topologyShard); + } + + @Test + public void deleteLinkOkTest() throws InterruptedException, ExecutionException { + String srcNode = "ROADM-A1-DEG1"; + String dstNode = "ROADM-A1-SRG1"; + String srcTp = "DEG1-CTP-TXRX"; + String destTp = "SRG1-CP-TXRX"; + LinkId linkId = LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp); + org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1 link1 = + new Link1Builder().setAdministrativeState(State.InService).build(); + Link link = new LinkBuilder() + .setLinkId(linkId) + .setSource(new SourceBuilder().setSourceNode(new NodeId(srcNode)).setSourceTp(srcTp).build()) + .setDestination(new DestinationBuilder().setDestNode(new NodeId(dstNode)).setDestTp(destTp).build()) + .addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1.class, link1) + .build(); + InstanceIdentifier linkIID = InstanceIdentifier.builder(Networks.class).child(Network.class, + new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).augmentation(Network1.class) + .child(Link.class, new LinkKey(linkId)).build(); + when(networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, linkIID)) + .thenReturn(new LinkFuture(link)); + + Answer> answer = new Answer>() { + + @Override + public FluentFuture answer(InvocationOnMock invocation) throws Throwable { + return CommitInfo.emptyFluentFuture(); + } + + }; + when(networkTransactionService.commit()).then(answer); + + boolean result = OpenRoadmTopology.deleteLink("ROADM-A1-DEG1", "ROADM-A1-SRG1", "DEG1-CTP-TXRX", "SRG1-CP-TXRX", + networkTransactionService); + assertTrue("link deletion should be ok", result); + } + + @Test + public void deleteLinkNotOkTest() throws InterruptedException, ExecutionException { + String srcNode = "ROADM-A1-DEG1"; + String dstNode = "ROADM-A1-SRG1"; + String srcTp = "DEG1-CTP-TXRX"; + String destTp = "SRG1-CP-TXRX"; + LinkId linkId = LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp); + + InstanceIdentifier linkIID = InstanceIdentifier.builder(Networks.class).child(Network.class, + new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).augmentation(Network1.class) + .child(Link.class, new LinkKey(linkId)).build(); + when(networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, linkIID)).thenReturn(new LinkFuture()); + + boolean result = OpenRoadmTopology.deleteLink("ROADM-A1-DEG1", "ROADM-A1-SRG1", "DEG1-CTP-TXRX", "SRG1-CP-TXRX", + networkTransactionService); + assertFalse("link deletion should not be ok", result); + } + + @Test + public void deleteLinkExceptionTest() throws InterruptedException, ExecutionException { + String srcNode = "ROADM-A1-DEG1"; + String dstNode = "ROADM-A1-SRG1"; + String srcTp = "DEG1-CTP-TXRX"; + String destTp = "SRG1-CP-TXRX"; + LinkId linkId = LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp); + + InstanceIdentifier linkIID = InstanceIdentifier.builder(Networks.class) + .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))) + .augmentation(Network1.class).child(Link.class, new LinkKey(linkId)).build(); + when(networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, linkIID)) + .thenReturn(new InterruptedLinkFuture()); + boolean result = OpenRoadmTopology.deleteLink("ROADM-A1-DEG1", "ROADM-A1-SRG1", "DEG1-CTP-TXRX", "SRG1-CP-TXRX", + networkTransactionService); + verify(networkTransactionService, never()).merge(any(), any(), any()); + assertFalse("Result should be false du to InterruptedException", result); + } + + private void checkDegreeNode(String nodeNb, Node node) { + assertEquals("ROADMA01-DEG" + nodeNb, node.getNodeId().getValue()); + List supportingNodes = node.getSupportingNode().stream() + .sorted((sn1, sn2) -> sn1.getNetworkRef().getValue().compareTo(sn2.getNetworkRef().getValue())) + .collect(Collectors.toList()); + assertEquals(2, supportingNodes.size()); + assertEquals("clli-network", supportingNodes.get(0).getNetworkRef().getValue()); + assertEquals("nodeA", supportingNodes.get(0).getNodeRef().getValue()); + assertEquals("openroadm-network", supportingNodes.get(1).getNetworkRef().getValue()); + assertEquals("ROADMA01", supportingNodes.get(1).getNodeRef().getValue()); + assertEquals(OpenroadmNodeType.DEGREE, node.augmentation(Node1.class).getNodeType()); + assertEquals(Uint16.valueOf(nodeNb), node.augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1.class) + .getDegreeAttributes().getDegreeNumber()); + assertEquals(96, node.augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1.class) + .getDegreeAttributes().getAvailableWavelengths().size()); + List tps = node.augmentation( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class) + .getTerminationPoint().stream() + .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue())) + .collect(Collectors.toList()); + assertEquals(2, tps.size()); + assertEquals("DEG" + nodeNb + "-CTP-TXRX", tps.get(0).getTpId().getValue()); + assertEquals(OpenroadmTpType.DEGREETXRXCTP, tps.get(0).augmentation(TerminationPoint1.class).getTpType()); + assertEquals("DEG" + nodeNb + "-TTP-TXRX", tps.get(1).getTpId().getValue()); + assertEquals(OpenroadmTpType.DEGREETXRXTTP, tps.get(1).augmentation(TerminationPoint1.class).getTpType()); + } + + private void checkSrgNode(String nodeNb, Node node) { + assertEquals("ROADMA01-SRG" + nodeNb, node.getNodeId().getValue()); + List supportingNodes = node.getSupportingNode().stream() + .sorted((sn1, sn2) -> sn1.getNetworkRef().getValue().compareTo(sn2.getNetworkRef().getValue())) + .collect(Collectors.toList()); + assertEquals(2, supportingNodes.size()); + assertEquals("clli-network", supportingNodes.get(0).getNetworkRef().getValue()); + assertEquals("nodeA", supportingNodes.get(0).getNodeRef().getValue()); + assertEquals("openroadm-network", supportingNodes.get(1).getNetworkRef().getValue()); + assertEquals("ROADMA01", supportingNodes.get(1).getNodeRef().getValue()); + assertEquals(OpenroadmNodeType.SRG, node.augmentation(Node1.class).getNodeType()); + assertEquals(96, node.augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1.class) + .getSrgAttributes().getAvailableWavelengths().size()); + List tps = node.augmentation( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class) + .getTerminationPoint().stream() + .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue())) + .collect(Collectors.toList()); + assertEquals(5, tps.size()); + assertEquals("SRG" + nodeNb + "-CP-TXRX", tps.get(0).getTpId().getValue()); + assertEquals(OpenroadmTpType.SRGTXRXCP, tps.get(0).augmentation(TerminationPoint1.class).getTpType()); + assertEquals("SRG" + nodeNb + "-PP3-TXRX", tps.get(3).getTpId().getValue()); + assertEquals(OpenroadmTpType.SRGTXRXPP, tps.get(3).augmentation(TerminationPoint1.class).getTpType()); + } + + private void checkTpdrNode(Node node) { + assertEquals("XPDRA01-XPDR1", node.getNodeId().getValue()); + List supportingNodes = node.getSupportingNode().stream() + .sorted((sn1, sn2) -> sn1.getNetworkRef().getValue().compareTo(sn2.getNetworkRef().getValue())) + .collect(Collectors.toList()); + assertEquals(2, supportingNodes.size()); + assertEquals("clli-network", supportingNodes.get(0).getNetworkRef().getValue()); + assertEquals("nodeA", supportingNodes.get(0).getNodeRef().getValue()); + assertEquals("openroadm-network", supportingNodes.get(1).getNetworkRef().getValue()); + assertEquals("XPDRA01", supportingNodes.get(1).getNodeRef().getValue()); + assertEquals(OpenroadmNodeType.XPONDER, node.augmentation(Node1.class).getNodeType()); + List tps = node.augmentation( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class) + .getTerminationPoint().stream() + .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue())) + .collect(Collectors.toList()); + assertEquals(4, tps.size()); + assertEquals("XPDR1-CLIENT1", tps.get(0).getTpId().getValue()); + assertEquals(OpenroadmTpType.XPONDERCLIENT, tps.get(0).augmentation(TerminationPoint1.class).getTpType()); + assertEquals("XPDR1-NETWORK1", tps.get(0).augmentation( + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129.TerminationPoint1.class) + .getAssociatedConnectionMapPort()); + assertEquals("XPDR1-NETWORK1", tps.get(2).getTpId().getValue()); + assertEquals(OpenroadmTpType.XPONDERNETWORK, tps.get(2).augmentation(TerminationPoint1.class).getTpType()); + assertEquals("XPDR1-CLIENT1", tps.get(2).augmentation( + org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129.TerminationPoint1.class) + .getAssociatedConnectionMapPort()); + } + + private void checkOtnXpdrNode(Node node) { + assertEquals("XPDRA01-XPDR1", node.getNodeId().getValue()); + List supportingNodes = node.getSupportingNode().stream() + .sorted((sn1, sn2) -> sn1.getNetworkRef().getValue().compareTo(sn2.getNetworkRef().getValue())) + .collect(Collectors.toList()); + assertEquals(2, supportingNodes.size()); + assertEquals("clli-network", supportingNodes.get(0).getNetworkRef().getValue()); + assertEquals("nodeA", supportingNodes.get(0).getNodeRef().getValue()); + assertEquals("openroadm-network", supportingNodes.get(1).getNetworkRef().getValue()); + assertEquals("XPDRA01", supportingNodes.get(1).getNodeRef().getValue()); + assertEquals(OpenroadmNodeType.XPONDER, node.augmentation(Node1.class).getNodeType()); + List tps = node.augmentation( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class) + .getTerminationPoint().stream() + .sorted((tp1, tp2) -> tp1.getTpId().getValue().compareTo(tp2.getTpId().getValue())) + .collect(Collectors.toList()); + assertEquals(2, tps.size()); + assertEquals("XPDR1-NETWORK1", tps.get(0).getTpId().getValue()); + assertEquals(OpenroadmTpType.XPONDERNETWORK, tps.get(0).augmentation(TerminationPoint1.class).getTpType()); + } + + private class LinkFuture implements ListenableFuture> { + + private Link link; + + LinkFuture() { + } + + LinkFuture(Link link) { + this.link = link; + } + + @Override + public boolean cancel(boolean arg0) { + return false; + } + + @Override + public Optional get() throws InterruptedException, ExecutionException { + if (link != null) { + return Optional.of(link); + } else { + return Optional.empty(); + } + } + + @Override + public Optional get(long arg0, TimeUnit arg1) + throws InterruptedException, ExecutionException, TimeoutException { + if (link != null) { + return Optional.of(link); + } else { + return Optional.empty(); + } + } + + @Override + public boolean isCancelled() { + return false; + } + + @Override + public boolean isDone() { + return false; + } + + @Override + public void addListener(Runnable listener, Executor executor) { + } + } + + private class InterruptedLinkFuture implements ListenableFuture> { + + @Override + public boolean cancel(boolean arg0) { + return false; + } + + @Override + public Optional get() throws InterruptedException, ExecutionException { + throw new InterruptedException("Interrupted"); + } + + @Override + public Optional get(long arg0, TimeUnit arg1) + throws InterruptedException, ExecutionException, TimeoutException { + throw new InterruptedException("Interrupted"); + } + + @Override + public boolean isCancelled() { + return false; + } + + @Override + public boolean isDone() { + return false; + } + + @Override + public void addListener(Runnable listener, Executor executor) { + } + } +} diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/TpceNetworkTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/TpceNetworkTest.java new file mode 100644 index 000000000..939592970 --- /dev/null +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/TpceNetworkTest.java @@ -0,0 +1,114 @@ +/* + * Copyright © 2020 Orange, 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.networkmodel.util; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.concurrent.ExecutionException; +import org.junit.Test; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; +import org.opendaylight.transportpce.common.network.RequestProcessor; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.NetworkTypes1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.NetworkTypes1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.clli.network.rev181130.networks.network.network.types.ClliNetworkBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.networks.network.network.types.OpenroadmCommonNetworkBuilder; +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.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.NetworkTypes; +import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + + +public class TpceNetworkTest extends AbstractTest { + TpceNetwork tpceNetwork = new TpceNetwork(new NetworkTransactionImpl(new RequestProcessor(getDataBroker()))); + + @Test + public void createLayerClliTest() throws InterruptedException, ExecutionException { + tpceNetwork.createLayer("clli-network"); + InstanceIdentifier nwIID = InstanceIdentifier.create(Networks.class) + .child(Network.class, new NetworkKey(new NetworkId("clli-network"))); + Network createdClli = getDataBroker().newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, nwIID).get().get(); + assertNotNull("Clli layer should be created and not null", createdClli); + + Augmentation ordClli = new NetworkTypes1Builder() + .setClliNetwork(new ClliNetworkBuilder().build()) + .build(); + assertNotNull("clli augmentation should not be null", createdClli.getNetworkTypes() + .augmentation(NetworkTypes1.class)); + assertEquals("bad clli augmentation for network-types", ordClli, + createdClli.getNetworkTypes().augmentation(NetworkTypes1.class)); + } + + @Test + public void createLayerNetworkTest() throws InterruptedException, ExecutionException { + tpceNetwork.createLayer("openroadm-network"); + InstanceIdentifier nwIID = InstanceIdentifier.create(Networks.class) + .child(Network.class, new NetworkKey(new NetworkId("openroadm-network"))); + Network createdOrdNetwork = getDataBroker().newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, nwIID).get().get(); + assertNotNull("openroadm-network layer should be created and not null", createdOrdNetwork); + commonNetworkAugmentationTest(createdOrdNetwork); + } + + @Test + public void createLayerTopologyTest() throws InterruptedException, ExecutionException { + tpceNetwork.createLayer("openroadm-topology"); + InstanceIdentifier nwIID = InstanceIdentifier.create(Networks.class) + .child(Network.class, new NetworkKey(new NetworkId("openroadm-topology"))); + Network createdOrdNetwork = getDataBroker().newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, nwIID).get().get(); + assertNotNull("openroadm-logpology layer should be created and not null", createdOrdNetwork); + commonNetworkAugmentationTest(createdOrdNetwork); + } + + @Test + public void createLayerOtnTest() throws InterruptedException, ExecutionException { + tpceNetwork.createLayer("otn-topology"); + InstanceIdentifier nwIID = InstanceIdentifier.create(Networks.class) + .child(Network.class, new NetworkKey(new NetworkId("otn-topology"))); + Network createdOrdNetwork = getDataBroker().newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, nwIID).get().get(); + assertNotNull("otn-logpology layer should be created and not null", createdOrdNetwork); + commonNetworkAugmentationTest(createdOrdNetwork); + } + + @Test + public void createBadLayerTest() throws InterruptedException, ExecutionException { + tpceNetwork.createLayer("toto"); + InstanceIdentifier nwIID = InstanceIdentifier.create(Networks.class) + .child(Network.class, new NetworkKey(new NetworkId("toto"))); + Network createdOrdNetwork = getDataBroker().newReadOnlyTransaction() + .read(LogicalDatastoreType.CONFIGURATION, nwIID).get().get(); + assertNotNull("toto layer should be created and not null", createdOrdNetwork); + assertNull("toto layer should not have any network-type augmentation", createdOrdNetwork.getNetworkTypes() + .augmentation(NetworkTypes1.class)); + assertNull("toto layer should not have any network-type augmentation", createdOrdNetwork.getNetworkTypes() + .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130 + .NetworkTypes1.class)); + } + + private void commonNetworkAugmentationTest(Network createdOrdNetwork) { + Augmentation ordComNet + = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.NetworkTypes1Builder() + .setOpenroadmCommonNetwork(new OpenroadmCommonNetworkBuilder().build()) + .build(); + assertNotNull("common-network augmentation should not be null", createdOrdNetwork.getNetworkTypes() + .augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.NetworkTypes1.class)); + assertEquals("bad common-network augmentation for network-types", ordComNet, createdOrdNetwork.getNetworkTypes() + .augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.NetworkTypes1.class)); + } +} diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/test/NetworkmodelTestUtil.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/test/NetworkmodelTestUtil.java new file mode 100644 index 000000000..90e7d3831 --- /dev/null +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/util/test/NetworkmodelTestUtil.java @@ -0,0 +1,123 @@ +/* + * Copyright © 2020 Orange Labs, 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.networkmodel.util.test; + + +import java.util.ArrayList; +import java.util.List; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.Nodes; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.NodesBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.MappingBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.NodeInfoBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.NodeTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PortQual; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.XpdrNodeTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.If100GE; +import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.IfOCH; +import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.SupportedIfCapability; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class NetworkmodelTestUtil { + + private static final Logger LOG = LoggerFactory.getLogger(NetworkmodelTestUtil.class); + + public static Nodes createMappingForRdm(String nodeId, String clli, int degNb, int srgNb) { + List mappingList = new ArrayList<>(); + createDegreeMappings(mappingList, 1, degNb); + createSrgMappings(mappingList, 1, srgNb); + Nodes mappingNode = new NodesBuilder() + .setNodeId(nodeId) + .setNodeInfo(new NodeInfoBuilder().setNodeType(NodeTypes.Rdm).setNodeClli(clli).build()) + .setMapping(mappingList) + .build(); + return mappingNode; + } + + public static Nodes createMappingForXpdr(String nodeId, String clli, int networkPortNb, int clientPortNb, + XpdrNodeTypes xpdrNodeType) { + List mappingList = new ArrayList<>(); + createXpdrMappings(mappingList, networkPortNb, clientPortNb, xpdrNodeType); + Nodes mappingNode = new NodesBuilder() + .setNodeId(nodeId) + .setNodeInfo(new NodeInfoBuilder().setNodeType(NodeTypes.Xpdr).setNodeClli(clli).build()) + .setMapping(mappingList) + .build(); + LOG.info("mapping = {}", mappingNode.toString()); + return mappingNode; + } + + private static List createDegreeMappings(List mappingList, int degNbStart, int degNbStop) { + for (int i = degNbStart; i <= degNbStop; i++) { + Mapping mapping = new MappingBuilder() + .setLogicalConnectionPoint("DEG" + i + "-TTP-TXRX") + .setPortDirection("bidirectional") + .setSupportingPort("L1") + .setSupportingCircuitPackName(i + "/0") + .setSupportingOts("OTS-DEG" + i + "-TTP-TXRX") + .setSupportingOms("OMS-DEG" + i + "-TTP-TXRX") + .build(); + mappingList.add(mapping); + } + return mappingList; + } + + private static List createSrgMappings(List mappingList, int srgNbStart, int srgNbStop) { + for (int i = srgNbStart; i <= srgNbStop; i++) { + for (int j = 1; j <= 4; j++) { + Mapping mapping = new MappingBuilder() + .setLogicalConnectionPoint("SRG" + i + "-PP" + j + "-TXRX") + .setPortDirection("bidirectional") + .setSupportingPort("C" + j) + .setSupportingCircuitPackName(3 + i + "/0") + .build(); + mappingList.add(mapping); + } + } + return mappingList; + } + + private static List createXpdrMappings(List mappingList, int networkPortNb, int clientPortNb, + XpdrNodeTypes xpdrNodeType) { + for (int i = 1; i <= networkPortNb; i++) { + List> supportedIntf = new ArrayList<>(); + supportedIntf.add(IfOCH.class); + MappingBuilder mappingBldr = new MappingBuilder() + .setLogicalConnectionPoint("XPDR1-NETWORK" + i) + .setPortDirection("bidirectional") + .setSupportingPort("1") + .setSupportedInterfaceCapability(supportedIntf) + .setConnectionMapLcp("XPDR1-CLIENT" + i) + .setPortQual(PortQual.XpdrNetwork.getName()) + .setSupportingCircuitPackName("1/0/" + i + "-PLUG-NET"); + if (xpdrNodeType != null) { + mappingBldr.setXponderType(xpdrNodeType); + } + mappingList.add(mappingBldr.build()); + } + for (int i = 1; i <= clientPortNb; i++) { + List> supportedIntf = new ArrayList<>(); + supportedIntf.add(If100GE.class); + Mapping mapping = new MappingBuilder() + .setLogicalConnectionPoint("XPDR1-CLIENT" + i) + .setPortDirection("bidirectional") + .setSupportingPort("C1") + .setSupportedInterfaceCapability(supportedIntf) + .setConnectionMapLcp("XPDR1-NETWORK" + i) + .setPortQual(PortQual.XpdrClient.getName()) + .setSupportingCircuitPackName("1/0/" + i + "-PLUG-CLIENT") + .build(); + mappingList.add(mapping); + } + return mappingList; + } + + private NetworkmodelTestUtil() { + } +}