X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=tapi%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Ftapi%2Ftopology%2FConvertORTopoToFullTapiTopoTest.java;h=57e4ba097f17b7dcdac1e6dc6ee8ea69e2f853a5;hb=652c9098f8d97e6f5a723a7c55929f9351bffb5b;hp=09960dc33c85631a33947d28e19c9b1212db2f09;hpb=db87ba733190c2e59997e00e0fe9199c9c74234d;p=transportpce.git diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java index 09960dc33..57e4ba097 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToFullTapiTopoTest.java @@ -14,6 +14,7 @@ import static org.hamcrest.CoreMatchers.hasItem; import static org.hamcrest.CoreMatchers.hasItems; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -86,6 +87,7 @@ import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev221121.DIGITAL import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROMS; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTS; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTSi; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULECANNOTFORWARDACROSSGROUP; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULEMAYFORWARDACROSSGROUP; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.RuleType; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup; @@ -209,7 +211,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { networkPortList.add(tp.getTpId().getValue()); } } - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); tapiFactory.convertNode(tpdr, networkPortList); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+XPONDER".getBytes(Charset.forName("UTF-8"))) @@ -242,7 +244,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { networkPortList.add(tp.getTpId().getValue()); } } - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); tapiFactory.convertNode(tpdr, networkPortList); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+XPONDER".getBytes(Charset.forName("UTF-8"))) @@ -277,7 +279,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { networkPortList.add(tp.getTpId().getValue()); } } - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); tapiFactory.convertNode(tpdr, networkPortList); Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+XPONDER".getBytes(Charset.forName("UTF-8"))) @@ -305,7 +307,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { @Test void convertNodeForTransponder100G() { - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) { if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { @@ -328,7 +330,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { @Test void convertNodeForOtnMuxponder() { - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { @@ -350,7 +352,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { @Test void convertNodeForOtnSwitch() { - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); List networkPortList = new ArrayList<>(); for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) { if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { @@ -373,13 +375,13 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { @Test void convertNodeForRoadmWhenNoOtnMuxAttached() { - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); - tapiFactory.convertRoadmNode(roadmA, openroadmNet); + ConvertORTopoToTapiFullTopo tapiFullFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + tapiFullFactory.convertRoadmNode(roadmA, openroadmNet, "Full"); - assertEquals(1, tapiFactory.getTapiNodes().size(), "Node list size should be 1"); - assertEquals(0, tapiFactory.getTapiLinks().size(), "Link list size should be empty"); + assertEquals(1, tapiFullFactory.getTapiNodes().size(), "Node list size should be 1"); + assertEquals(0, tapiFullFactory.getTapiLinks().size(), "Link list size should be empty"); List tapiNodes - = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); + = tapiFullFactory.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(getNodeRank("ROADM-A1", tapiNodes)), roadmNodeUuid, "roadm", "ROADM-A1"); @@ -387,20 +389,20 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { @Test void convertNodeForRoadmWhenRoadmNeighborAttached() { - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); - tapiFactory.convertRoadmNode(roadmA, openroadmNet); - tapiFactory.convertRoadmNode(roadmC, openroadmNet); + ConvertORTopoToTapiFullTopo tapiFullFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + tapiFullFactory.convertRoadmNode(roadmA, openroadmNet, "Full"); + tapiFullFactory.convertRoadmNode(roadmC, openroadmNet, "Full"); List rdmTordmLinkList = ortopoLinks.values().stream() .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.ROADMTOROADM)) .collect(Collectors.toList()); - tapiFactory.convertRdmToRdmLinks(rdmTordmLinkList); + tapiFullFactory.convertRdmToRdmLinks(rdmTordmLinkList); - assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2"); - assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1"); + assertEquals(2, tapiFullFactory.getTapiNodes().size(), "Node list size should be 2"); + assertEquals(1, tapiFullFactory.getTapiLinks().size(), "Link list size should be 1"); List tapiNodes - = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList()); + = tapiFullFactory.getTapiNodes().values().stream().collect(Collectors.toList()); int myInt = 0; for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node node : tapiNodes) { if (node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA) @@ -416,7 +418,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkOtsiNode(tapiNodes.get(getNodeRank("ROADM-A1", tapiNodes)), roadmaNodeUuid, "roadm", "ROADM-A1"); List links - = tapiFactory.getTapiLinks().values().stream() + = tapiFullFactory.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"))) @@ -437,7 +439,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { @Test void convertNodeForRoadmWhenOtnMuxAttached() { - ConvertORTopoToTapiFullTopo tapiFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORTopoToTapiFullTopo tapiFullFactory = new ConvertORTopoToTapiFullTopo(topologyUuid, tapiLink); + ConvertORToTapiTopology tapiFactory = new ConvertORToTapiTopology(topologyUuid); List networkPortListA = new ArrayList<>(); for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) { if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) { @@ -445,7 +448,8 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { } } tapiFactory.convertNode(otnMuxA, networkPortListA); - tapiFactory.convertRoadmNode(roadmA, openroadmNet); + tapiFullFactory.setTapiNodes(tapiFactory.getTapiNodes()); + tapiFullFactory.convertRoadmNode(roadmA, openroadmNet, "Full"); List xponderOutLinkList = ortopoLinks.values().stream() .filter(lk -> lk.augmentation(Link1.class).getLinkType().equals(OpenroadmLinkType.XPONDEROUTPUT)) .filter(lk1 -> ((lk1.getSource().getSourceNode().equals(otnMuxA.getNodeId()) @@ -461,11 +465,17 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { || lk1.getDestination().getDestNode().getValue().contains(roadmA.getNodeId().getValue())))) .collect(Collectors.toList()); xponderInLinkList.addAll(xponderOutLinkList); - tapiFactory.convertXpdrToRdmLinks(xponderInLinkList); - assertEquals(2, tapiFactory.getTapiNodes().size(), "Node list size should be 2 (XPDR, DSR-ODU merged; ROADM)"); - assertEquals(1, tapiFactory.getTapiLinks().size(), "Link list size should be 1 : no more transitional link"); + tapiFullFactory.convertXpdrToRdmLinks(xponderInLinkList); + assertEquals(2, tapiFullFactory.getTapiNodes().size(), + "Node list size should be 2 (XPDR, DSR-ODU merged; ROADM)"); + assertEquals(1, tapiFullFactory.getTapiLinks().size(), + "Link list size should be 1 : no more transitional link"); + Map nodeMap = + tapiFactory.getTapiNodes(); + nodeMap.putAll(tapiFullFactory.getTapiNodes()); List tapiNodes - = tapiFactory.getTapiNodes().values().stream() + = nodeMap.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") @@ -486,7 +496,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { "ROADM-A1+PHOTONIC_MEDIA_OTS+SRG1-PP2-TXRXtoSPDR-SA1-XPDR1+PHOTONIC_MEDIA_OTS+XPDR1-NETWORK1" .getBytes(Charset.forName("UTF-8"))).toString()); List links - = tapiFactory.getTapiLinks().values().stream() + = tapiFullFactory.getTapiLinks().values().stream() .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) .collect(Collectors.toList()); checkXpdrRdmLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, linkUuid, @@ -544,7 +554,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { List nrgList = node.nonnullNodeRuleGroup().values().stream() .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) .collect(Collectors.toList()); - checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, enetworkNepUuid, node9Uuid); +// keep trace of the previous test performed before the structure of the NRG was modified +// checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, enetworkNepUuid, node9Uuid); + checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, inetworkNepUuid, node9Uuid); break; case "mux": nepsC = node.nonnullOwnedNodeEdgePoint().values().stream() @@ -561,19 +573,21 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkNepClient10G(nep3, client3NepUuid, nodeId + "+DSR+XPDR1-CLIENT3", "NodeEdgePoint_C"); OwnedNodeEdgePoint enep4 = enepsN.get(3); OwnedNodeEdgePoint inep4 = inepsN.get(0); - Uuid enetworkNepUuid2 = new Uuid( + Uuid eclientNepUuid2 = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+eODU+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8"))) .toString()); Uuid inetworkNepUuid2 = new Uuid( UUID.nameUUIDFromBytes((nodeId + "+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8"))) .toString()); - checkNepeODU4(enep4, enetworkNepUuid2, nodeId + "+eODU+XPDR1-CLIENT3", "eNodeEdgePoint_N", false); + checkNepeODU4(enep4, eclientNepUuid2, nodeId + "+eODU+XPDR1-CLIENT3", "eNodeEdgePoint_N", false); checkNepNetworkODU4(inep4, inetworkNepUuid2, nodeId + "+iODU+XPDR1-NETWORK1", "iNodeEdgePoint_N", true); List nrgList2 = node.nonnullNodeRuleGroup().values().stream() .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) .collect(Collectors.toList()); - checkNodeRuleGroupForMuxDSR(nrgList2, client3NepUuid, enetworkNepUuid2, node9Uuid); +// keep trace of the previous test performed before the structure of the NRG was modified +// checkNodeRuleGroupForMuxDSR(nrgList2, client3NepUuid, eclientNepUuid2, node9Uuid); + checkNodeRuleGroupForMuxDSR(nrgList2, client3NepUuid, inetworkNepUuid2, node9Uuid); break; case "tpdr": nepsC = node.nonnullOwnedNodeEdgePoint().values().stream() @@ -602,7 +616,9 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { List nrgList3 = node.nonnullNodeRuleGroup().values().stream() .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) .collect(Collectors.toList()); - checkNodeRuleGroupForTpdrDSR(nrgList3, client1NepUuid, enetworkNepUuid3, node9Uuid); +// keep trace of the previous test performed before the structure of the NRG was modified +// checkNodeRuleGroupForTpdrDSR(nrgList3, client1NepUuid, enetworkNepUuid3, node9Uuid); + checkNodeRuleGroupForTpdrDSR(nrgList3, client1NepUuid, inetworkNepUuid3, node9Uuid); break; default: fail(); @@ -755,6 +771,7 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkNodeRuleGroupForTpdrOTSi(nrgList3, enepUuid3, inepUuid3, nodeUuid); break; case "roadm": +// Keep trace of MC NEP test to be restored after the new policy for creating NEP is applied // assertEquals(0, nepsMc.size(), "MC NEP no more configured, Roadm node should have 0 MC NEPs"); // assertEquals(0, nepsOtsimc.size(), "Roadm node should have 10 OTSiMC NEPs"); assertEquals(12, nepsPhot.size(), "Roadm node should have 12 PHOT_MEDIA NEPs (2x4 OTS +2x(OTS+OMS)"); @@ -788,9 +805,12 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { checkNepOtsiRdmNode(otsNep4, otsNep4Uuid, nodeId + "+PHOTONIC_MEDIA_OTS+SRG1-PP3-TXRX", "PHOTONIC_MEDIA_OTSNodeEdgePoint", false); List nrgList4 = node.nonnullNodeRuleGroup().values().stream() - .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .sorted((nrg1, nrg2) -> nrg1.getName().entrySet().iterator().next().getValue().toString() + .compareTo(nrg2.getName().entrySet().iterator().next().getValue().toString())) .collect(Collectors.toList()); - checkNodeRuleGroupForRdm(nrgList4, 12); + LOG.info("NODERULEGROUP List nrgLIst4 is as follows {}", nrgList4.toString()); + List nepNumber = new ArrayList<>(List.of(2, 4, 4)); + checkNodeRuleGroupForRdm(nrgList4, nepNumber); break; default: fail(); @@ -871,12 +891,14 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { private void checkNodeRuleGroupForTpdrDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, Uuid nodeUuid) { - assertEquals(2, nrgList.size(), "transponder DSR should contain 2 node rule group"); + assertEquals(4, nrgList.size(), "transponder DSR should contain 4 node rule group (DSR-I_ODU/I-ODU-E_ODU)"); for (NodeRuleGroup nodeRuleGroup : nrgList) { assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), "each node-rule-group should contain 2 NEP for transponder DSR"); } - List nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values()); + Integer indNrg = nrgContainsClientAndNetwork(nrgList, clientNepUuid, networkNepUuid); + assertNotNull("One node-rule-group shall contains client and network Neps", indNrg); + List nodeEdgePointList = new ArrayList<>(nrgList.get(indNrg).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()))); @@ -898,12 +920,10 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { private void checkNodeRuleGroupForMuxDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, Uuid nodeUuid) { - assertEquals(4, nrgList.size(), "muxponder DSR should contain 4 node rule group"); - for (NodeRuleGroup nodeRuleGroup : nrgList) { - assertEquals(2, nodeRuleGroup.getNodeEdgePoint().size(), - "each node-rule-group should contain 2 NEP for muxponder DSR"); - } - List nodeEdgePointList = new ArrayList<>(nrgList.get(1).nonnullNodeEdgePoint().values()); + assertEquals(8, nrgList.size(), "muxponder DSR should contain 8 node rule group (DSR-I_ODU/I-ODU-E_ODU)"); + Integer indNrg = nrgContainsClientAndNetwork(nrgList, clientNepUuid, networkNepUuid); + assertNotNull("One node-rule-group shall contains client and network Neps", indNrg); + List nodeEdgePointList = new ArrayList<>(nrgList.get(indNrg).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()))); @@ -922,15 +942,26 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { private void checkNodeRuleGroupForSwitchDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, Uuid nodeUuid) { - assertEquals(1, nrgList.size(), "Switch-DSR should contain a single node rule group"); - assertEquals(8, nrgList.get(0).getNodeEdgePoint().size(), "Switch-DSR node-rule-group should contain 8 NEP"); + assertEquals(2, nrgList.size(), "Switch-DSR should contain 2 node rule group (DSR-I_ODU/I-ODU-E_ODU)"); + Integer indNrg = nrgContainsClientAndNetwork(nrgList, clientNepUuid, networkNepUuid); + assertNotNull("One node-rule-group shall contains client and network Neps", indNrg); + assertEquals(8, nrgList.get(indNrg).getNodeEdgePoint().size(), "Switch-DSR nrg should contain 8 NEP"); List nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream() .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue() .compareTo(nrg2.getNodeEdgePointUuid().getValue())) .collect(Collectors.toList()); + Integer xxxxx = 0; + for (NodeEdgePoint nep : nrg) { + LOG.info("nep number {} UUID is {} ", xxxxx, nep.getNodeEdgePointUuid()); + xxxxx++; + } + LOG.info("nep SPDR-SA1-XPDR2+iODU+XPDR2-NETWORK1 UUID is {} ", UUID.nameUUIDFromBytes( + ("SPDR-SA1-XPDR2" + "+iODU+XPDR2-NETWORK1").getBytes(Charset.forName("UTF-8"))).toString()); + LOG.info("nep SPDR-SA1-XPDR2+DSR+XPDR2-CLIENT4 UUID is {} ", UUID.nameUUIDFromBytes( + ("SPDR-SA1-XPDR2" + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8"))).toString()); assertEquals(networkNepUuid, nrg.get(6).getNodeEdgePointUuid(), "in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1"); - assertEquals(clientNepUuid, nrg.get(3).getNodeEdgePointUuid(), + assertEquals(clientNepUuid, nrg.get(5).getNodeEdgePointUuid(), "in the sorted node-rule-group, nep number 4 should be XPDR2-CLIENT4"); assertEquals(nodeUuid, nrg.get(4).getNodeUuid(), "any item of the node-rule-group should have the same nodeUuid"); @@ -946,22 +977,27 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { "the rule type should be 'FORWARDING'"); } - private void checkNodeRuleGroupForRdm(List nrgList, int nbNeps) { - assertEquals(1, nrgList.size(), "RDM infra node - OTSi should contain a single node rule groups"); - if (nbNeps > 0) { - List nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values()); - assertEquals(nbNeps, nodeEdgePointList.size(), - "RDM infra node -rule-group should contain " + nbNeps + " NEP"); - } else { - assertNull(nrgList.get(0).getNodeEdgePoint(), "RDM infra node -rule-group should contain no NEP"); + private void checkNodeRuleGroupForRdm(List nrgList, List nbNeps) { + assertEquals(3, nrgList.size(), "RDM infra node - OTS should contain 3 node rule groups"); + int index = 0; + for (NodeRuleGroup nrg : nrgList) { + List nodeEdgePointList = new ArrayList<>(nrg.getNodeEdgePoint().values()); + assertEquals(nbNeps.get(index), nodeEdgePointList.size(), + "RDM infra node -rule-group should contain " + nbNeps.get(index) + " NEP"); + List ruleList = new ArrayList<>(nrg.nonnullRule().values()); + assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); + assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); + assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType().stream().findFirst().orElseThrow(), + "the rule type should be 'FORWARDING'"); + if (nrg.getName().entrySet().iterator().next().getValue().toString().contains("DEG")) { + assertEquals(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); + } else { + assertEquals(FORWARDINGRULECANNOTFORWARDACROSSGROUP.VALUE, ruleList.get(0).getForwardingRule(), + "the forwarding rule should be 'CANNOTFORWARDACROSSGROUP'"); + } + index++; } - List ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values()); - assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule"); - assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'"); - assertEquals(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE, ruleList.get(0).getForwardingRule(), - "the forwarding rule should be 'MAYFORWARDACROSSGROUP'"); - assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType().stream().findFirst().orElseThrow(), - "the rule type should be 'FORWARDING'"); } private void checkNodeRuleGroupForTpdrOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, @@ -1268,4 +1304,23 @@ public class ConvertORTopoToFullTapiTopoTest extends AbstractTest { LOG.info("searched Char {} found at rank {}", searchedChar, foundAtRank); return foundAtRank; } + + private Integer nrgContainsClientAndNetwork(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid) { + // 1 NRG should at least contain the NEP of interest in the NEP List + Integer indexNrg = 0; + for (NodeRuleGroup nrg : nrgList) { + Boolean foundClient = false; + Boolean foundNetwork = false; + for (NodeEdgePoint nep : nrg.nonnullNodeEdgePoint().values()) { + foundClient = foundClient || nep.getNodeEdgePointUuid().equals(clientNepUuid); + foundNetwork = foundNetwork || nep.getNodeEdgePointUuid().equals(networkNepUuid); + } + if (foundClient && foundNetwork) { + return indexNrg; + } + indexNrg++; + } + return null; + } + }