renderer/src/test/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadMInterface221Test.java

   1 /*
   2  * Copyright © 2019 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.renderer.openroadminterface;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertNotNull;
  12 import static org.junit.jupiter.api.Assertions.assertNull;
  13 import static org.junit.jupiter.api.Assertions.assertThrows;
  14 import static org.mockito.ArgumentMatchers.any;
  15 import static org.mockito.ArgumentMatchers.eq;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.spy;
  18 import static org.mockito.Mockito.when;
  19
  20 import java.math.BigDecimal;
  21 import java.util.Arrays;
  22 import org.junit.jupiter.api.BeforeEach;
  23 import org.junit.jupiter.api.Test;
  24 import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
  25 import org.opendaylight.transportpce.common.mapping.PortMapping;
  26 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  27 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  28 import org.opendaylight.transportpce.test.AbstractTest;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.mapping.MappingBuilder;
  30 import org.opendaylight.yangtools.yang.common.Uint32;
  31
  32 public class OpenRoadMInterface221Test extends AbstractTest {
  33
  34     private final PortMapping portMapping = mock(PortMapping.class);
  35     private OpenRoadmInterface221 openRoadMInterface221;
  36     private final String nodeId = "node1";
  37
  38     @BeforeEach
  39     void setup() {
  40         OpenRoadmInterfaces openRoadmInterfaces = spy(OpenRoadmInterfaces.class);
  41         this.openRoadMInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces);
  42     }
  43
  44     @Test
  45     void testCreateOpenRoadmEthInterface() throws OpenRoadmInterfaceException {
  46
  47         String logicalConnPoint = "logicalConnPoint";
  48         when(portMapping.getMapping(nodeId, logicalConnPoint))
  49             .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
  50                 .setLogicalConnectionPoint(logicalConnPoint).build());
  51         assertEquals(openRoadMInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint),
  52             logicalConnPoint + "-ETHERNET");
  53     }
  54
  55     @Test
  56     void testCreateOpenRoadmEthInterfaceThrowsExcpetion() throws OpenRoadmInterfaceException {
  57         when(portMapping.getMapping(eq(nodeId), any())).thenReturn(null);
  58         Exception exception = assertThrows(OpenRoadmInterfaceException.class, () -> {
  59             openRoadMInterface221.createOpenRoadmEthInterface(nodeId, "logicalConnPoint");
  60         });
  61         assertEquals(
  62             "Unable to get mapping from PortMapping for node node1 and logical connection port logicalConnPoint",
  63             exception.getMessage());
  64     }
  65
  66     @Test
  67     void testCreateFlexOCH() throws OpenRoadmInterfaceException {
  68         String logicalConnPoint = "logicalConnPoint";
  69         when(portMapping.getMapping(nodeId, logicalConnPoint))
  70             .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
  71                 .setLogicalConnectionPoint(logicalConnPoint).build());
  72         SpectrumInformation spectrumInformation = new SpectrumInformation();
  73         spectrumInformation.setWaveLength(Uint32.valueOf(1));
  74         spectrumInformation.setLowerSpectralSlotNumber(761);
  75         spectrumInformation.setHigherSpectralSlotNumber(768);
  76         spectrumInformation.setCenterFrequency(BigDecimal.valueOf(195.8));
  77         assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation));
  78         assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
  79             Arrays.asList(logicalConnPoint + "-nmc-761:768"));
  80     }
  81
  82     @Test
  83     void testCreateFlexOCHReturnsMoreThanOneElement() throws OpenRoadmInterfaceException {
  84
  85         String logicalConnPoint = "logicalConnPointDEG";
  86         when(portMapping.getMapping(nodeId, logicalConnPoint))
  87             .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
  88                 .setLogicalConnectionPoint(logicalConnPoint).build());
  89         SpectrumInformation spectrumInformation = new SpectrumInformation();
  90         spectrumInformation.setWaveLength(Uint32.valueOf(1));
  91         spectrumInformation.setLowerSpectralSlotNumber(761);
  92         spectrumInformation.setHigherSpectralSlotNumber(768);
  93         spectrumInformation.setCenterFrequency(BigDecimal.valueOf(195.8));
  94         spectrumInformation.setMinFrequency(BigDecimal.valueOf(195.775));
  95         spectrumInformation.setMaxFrequency(BigDecimal.valueOf(195.825));
  96         assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint,spectrumInformation));
  97         assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
  98             Arrays.asList(logicalConnPoint + "-mc-761:768", logicalConnPoint + "-nmc-761:768"));
  99     }
 100
 101     @Test
 102     void testCreateOpenRoadmOchInterface() throws OpenRoadmInterfaceException {
 103         String logicalConnPoint = "logicalConnPoint";
 104         when(portMapping.getMapping(nodeId, logicalConnPoint))
 105             .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
 106                 .setLogicalConnectionPoint(logicalConnPoint).build());
 107         SpectrumInformation spectrumInformation = new SpectrumInformation();
 108         spectrumInformation.setWaveLength(Uint32.valueOf(1));
 109         spectrumInformation.setLowerSpectralSlotNumber(761);
 110         spectrumInformation.setHigherSpectralSlotNumber(768);
 111         spectrumInformation.setCenterFrequency(BigDecimal.valueOf(195.8));
 112         assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
 113             spectrumInformation), logicalConnPoint + "-761:768");
 114     }
 115
 116     @Test
 117     void testCreateOpenRoadmOtu4Interface() throws OpenRoadmInterfaceException {
 118         String logicalConnPoint = "logicalConnPoint";
 119         String supportOchInterface = "supportOchInterface";
 120         when(portMapping.getMapping(nodeId, logicalConnPoint))
 121             .thenReturn(new MappingBuilder().setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
 122                 .setLogicalConnectionPoint(logicalConnPoint).build());
 123         assertEquals(
 124             openRoadMInterface221.createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface, null,
 125                 null),
 126             logicalConnPoint + "-OTU");
 127     }
 128
 129     @Test
 130     void testCreateOpenRoadmOchInterfaceName() {
 131         String logicalConnPoint = "logicalConnPoint";
 132         assertEquals(openRoadMInterface221.createOpenRoadmOchInterfaceName(logicalConnPoint, "761:768"),
 133             logicalConnPoint + "-761:768");
 134     }
 135
 136     @Test
 137     void testCreateOpenRoadmOmsInterfaceSupportingOtsNotNull() throws OpenRoadmInterfaceException {
 138         String logicalConnPoint = "logicalConnPoint";
 139         String supportingOts = "supportingOts";
 140         assertEquals(
 141             openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
 142                 .setSupportingCircuitPackName("circit-pack").setSupportingPort("port")
 143                 .setLogicalConnectionPoint(logicalConnPoint).setSupportingOts(supportingOts).build()),
 144             "OMS-" + logicalConnPoint);
 145     }
 146
 147     @Test
 148     void testCreateOpenRoadmOmsInterfaceSupportingOmsNotNullException() throws OpenRoadmInterfaceException {
 149         assertNull(openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
 150             .setLogicalConnectionPoint("logicalConnPoint").build()));
 151     }
 152
 153     @Test
 154     void testCreateOpenRoadmOmsInterfaceSupportingOmsNull() throws OpenRoadmInterfaceException {
 155         String supportingOts = "supportingOts";
 156         String logicalConnPoint = "logicalConnPoint";
 157         assertEquals(
 158             openRoadMInterface221.createOpenRoadmOmsInterface(nodeId, new MappingBuilder()
 159                 .setLogicalConnectionPoint(logicalConnPoint).setSupportingOts(supportingOts).build()),
 160             "OMS-" + logicalConnPoint);
 161     }
 162 }