olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java

   1 /*
   2  * Copyright © 2018 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
   9 package org.opendaylight.transportpce.olm.power;
  10
  11 import static org.junit.jupiter.api.Assertions.assertEquals;
  12 import static org.mockito.ArgumentMatchers.eq;
  13 import static org.mockito.Mockito.mock;
  14 import static org.mockito.Mockito.times;
  15 import static org.mockito.Mockito.verify;
  16 import static org.mockito.Mockito.verifyNoInteractions;
  17 import static org.mockito.Mockito.when;
  18
  19 import java.math.BigDecimal;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Optional;
  24 import org.junit.jupiter.api.BeforeEach;
  25 import org.junit.jupiter.api.Test;
  26 import org.mockito.MockedStatic;
  27 import org.mockito.Mockito;
  28 import org.opendaylight.mdsal.binding.api.DataBroker;
  29 import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
  30 import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
  31 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  32 import org.opendaylight.transportpce.common.mapping.PortMapping;
  33 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  34 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  35 import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil;
  36 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.ServicePowerSetupInput;
  37 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.ServicePowerTurndownInput;
  38 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev231221.OpenroadmNodeVersion;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.RatioDB;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1Builder;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.och.container.OchBuilder;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.OtsBuilder;
  46 import org.opendaylight.yangtools.yang.common.Decimal64;
  47
  48 class PowerMgmtTest {
  49     private OpenRoadmInterfaces openRoadmInterfaces;
  50     private CrossConnect crossConnect;
  51     private DeviceTransactionManager deviceTransactionManager;
  52     private PortMapping portMapping;
  53     private PowerMgmt powerMgmt;
  54
  55     @BeforeEach
  56     void setUp() {
  57         mock(DataBroker.class);
  58         this.openRoadmInterfaces = Mockito.mock(OpenRoadmInterfaces.class);
  59         this.crossConnect = Mockito.mock((CrossConnectImpl.class));
  60         this.deviceTransactionManager = Mockito.mock(DeviceTransactionManager.class);
  61         this.portMapping = Mockito.mock(PortMapping.class);
  62         this.powerMgmt = new PowerMgmtImpl(this.openRoadmInterfaces, this.crossConnect,
  63                 this.deviceTransactionManager, this.portMapping, 1000, 1000);
  64     }
  65
  66     @Test
  67     void testSetPowerWhenMappingReturnNull() {
  68         when(this.portMapping.getNode(Mockito.anyString())).thenReturn(null);
  69         boolean output = this.powerMgmt.setPower(OlmPowerServiceRpcImplUtil.getServicePowerSetupInput());
  70         assertEquals(false, output);
  71     }
  72
  73     @Test
  74     void testSetPowerForTransponderAEnd() throws OpenRoadmInterfaceException {
  75         when(this.portMapping.getNode("xpdr-A"))
  76             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
  77                     List.of("network-A")));
  78         when(this.portMapping.getNode("roadm-A"))
  79             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
  80                     List.of("srg1-A", "deg2-A")));
  81         Interface interfOch = new InterfaceBuilder()
  82                 .setName("interface name")
  83                 .addAugmentation(new Interface1Builder()
  84                         .setOch(new OchBuilder().build())
  85                         .build())
  86                 .build();
  87         when(this.openRoadmInterfaces.getInterface(Mockito.matches("xpdr-A"), Mockito.anyString()))
  88             .thenReturn(Optional.of(interfOch));
  89         Interface interfOts = new InterfaceBuilder()
  90                 .setName("interface name")
  91                 .addAugmentation(
  92                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
  93                                 .Interface1Builder()
  94                                 .setOts(new OtsBuilder()
  95                                         .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
  96                                         .build())
  97                                 .build())
  98                 .build();
  99         when(this.openRoadmInterfaces.getInterface(Mockito.matches("roadm-A"), Mockito.anyString()))
 100             .thenReturn(Optional.of(interfOts));
 101         MockedStatic<PowerMgmtVersion121> pmv121 = Mockito.mockStatic(PowerMgmtVersion121.class);
 102         pmv121.when(() -> PowerMgmtVersion121.setTransponderPower(Mockito.anyString(), Mockito.anyString(),
 103                     Mockito.any(), Mockito.any(), Mockito.any()))
 104                 .thenReturn(true);
 105         Map<String, Double> powerRangeMap = new HashMap<>();
 106         powerRangeMap.put("MaxTx", 0.1);
 107         powerRangeMap.put("MinTx", -5.1);
 108         pmv121.when(() -> PowerMgmtVersion121.getXponderPowerRange(Mockito.anyString(), Mockito.anyString(),
 109                     Mockito.anyString(), Mockito.any()))
 110                 .thenReturn(powerRangeMap);
 111         when(this.crossConnect
 112                 .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 113             .thenReturn(true);
 114
 115         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
 116         boolean result = this.powerMgmt.setPower(input);
 117         assertEquals(true, result);
 118     }
 119
 120     @Test
 121     void testSetPowerForTransponderZEnd() throws OpenRoadmInterfaceException {
 122         when(this.portMapping.getNode("xpdr-C"))
 123             .thenReturn(OlmPowerServiceRpcImplUtil
 124                 .getMappingNodeTpdr("xpdr-C", OpenroadmNodeVersion._121, List.of("client-C")));
 125
 126         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
 127                 .getServicePowerSetupInputForOneNode("xpdr-C", "network-C", "client-C");
 128         boolean result = this.powerMgmt.setPower(input);
 129         assertEquals(true, result);
 130     }
 131
 132     @Test
 133     void testSetPowerForRoadmAEnd() throws OpenRoadmInterfaceException {
 134         when(this.portMapping.getNode("roadm-A"))
 135             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
 136                         List.of("srg1-A", "deg2-A")));
 137         when(this.deviceTransactionManager
 138                 .getDataFromDevice(Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any()))
 139             .thenReturn(Optional.empty());
 140         Interface interfOts = new InterfaceBuilder()
 141                 .setName("interface name")
 142                 .addAugmentation(
 143                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
 144                             .Interface1Builder()
 145                     .setOts(new OtsBuilder()
 146                             .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
 147                             .build())
 148                     .build())
 149                 .build();
 150         when(this.openRoadmInterfaces.getInterface(Mockito.anyString(), Mockito.anyString()))
 151             .thenReturn(Optional.of(interfOts));
 152         when(this.crossConnect
 153                 .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 154             .thenReturn(true);
 155
 156         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
 157                 .getServicePowerSetupInputForOneNode("roadm-A", "srg1-A", "deg2-A");
 158         boolean result = this.powerMgmt.setPower(input);
 159         assertEquals(true, result);
 160         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 161                 Mockito.matches(OpticalControlMode.Power.getName()), eq(Decimal64.valueOf("-3.00")),
 162                 Mockito.matches("srg1-A-deg2-A-761:768"));
 163         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 164                 Mockito.matches(OpticalControlMode.GainLoss.getName()), eq(Decimal64.valueOf("-3.00")),
 165                 Mockito.matches("srg1-A-deg2-A-761:768"));
 166     }
 167
 168     @Test
 169     void testSetPowerForRoadmZEnd() throws OpenRoadmInterfaceException {
 170         when(this.portMapping.getNode("roadm-C"))
 171             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-C", OpenroadmNodeVersion._121,
 172                     List.of("deg1-C", "srg1-C")));
 173         when(this.deviceTransactionManager
 174                 .getDataFromDevice(Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any()))
 175             .thenReturn(Optional.empty());
 176         when(this.crossConnect
 177                 .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 178             .thenReturn(true);
 179
 180         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
 181                 .getServicePowerSetupInputForOneNode("roadm-C", "deg1-C", "srg1-C");
 182         boolean result = this.powerMgmt.setPower(input);
 183         assertEquals(true, result);
 184         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-C"),
 185                 Mockito.matches(OpticalControlMode.Power.getName()), Mockito.isNull(),
 186                 Mockito.matches("deg1-C-srg1-C-761:768"));
 187     }
 188
 189     @Test
 190     void testSetPowerForTransponderWhenNoTransponderPort() throws OpenRoadmInterfaceException {
 191         when(this.portMapping.getNode("xpdr-A"))
 192             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
 193                     List.of("network-A")));
 194         when(this.portMapping.getNode("roadm-A"))
 195             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
 196                     List.of("srg1-A", "deg2-A")));
 197         Interface interfOch = new InterfaceBuilder()
 198                 .setName("interface name")
 199                 .addAugmentation(new Interface1Builder()
 200                         .setOch(new OchBuilder().build())
 201                         .build())
 202                 .build();
 203         when(this.openRoadmInterfaces.getInterface(Mockito.matches("xpdr-A"), Mockito.anyString()))
 204             .thenReturn(Optional.of(interfOch));
 205         Interface interfOts = new InterfaceBuilder()
 206                 .setName("interface name")
 207                 .addAugmentation(
 208                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
 209                                 .Interface1Builder()
 210                                 .setOts(new OtsBuilder()
 211                                         .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
 212                                         .build())
 213                                 .build())
 214                 .build();
 215         when(this.openRoadmInterfaces.getInterface(Mockito.matches("roadm-A"), Mockito.anyString()))
 216             .thenReturn(Optional.of(interfOts));
 217         try (MockedStatic<PowerMgmtVersion121> pmv121 = Mockito.mockStatic(PowerMgmtVersion121.class)) {
 218             pmv121.when(() -> PowerMgmtVersion121.setTransponderPower(Mockito.anyString(), Mockito.anyString(),
 219                             Mockito.any(), Mockito.any(), Mockito.any()))
 220                     .thenReturn(true);
 221             pmv121.when(() -> PowerMgmtVersion121.getXponderPowerRange(Mockito.anyString(), Mockito.anyString(),
 222                             Mockito.anyString(), Mockito.any()))
 223                     .thenReturn(new HashMap<>());
 224
 225             when(this.crossConnect
 226                     .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 227                 .thenReturn(true);
 228
 229
 230             ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
 231             boolean result = this.powerMgmt.setPower(input);
 232             assertEquals(true, result);
 233             pmv121.verify(() -> PowerMgmtVersion121.setTransponderPower(Mockito.matches("xpdr-A"),
 234                     Mockito.anyString(), eq(new BigDecimal("-5")), Mockito.any(), Mockito.any()));
 235             verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 236                     Mockito.matches(OpticalControlMode.GainLoss.getName()), eq(Decimal64.valueOf("-3.00")),
 237                     Mockito.matches("srg1-A-deg2-A-761:768"));
 238         }
 239     }
 240
 241     @Test
 242     void testSetPowerForTransponderAEndWithRoadmPort() throws OpenRoadmInterfaceException {
 243         when(this.portMapping.getNode("xpdr-A"))
 244             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
 245                     List.of("network-A")));
 246         when(this.portMapping.getNode("roadm-A"))
 247             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
 248                     List.of("srg1-A", "deg2-A")));
 249         Interface interfOch = new InterfaceBuilder()
 250                 .setName("interface name")
 251                 .addAugmentation(new Interface1Builder()
 252                         .setOch(new OchBuilder().build())
 253                         .build())
 254                 .build();
 255         when(this.openRoadmInterfaces.getInterface(Mockito.matches("xpdr-A"), Mockito.anyString()))
 256             .thenReturn(Optional.of(interfOch));
 257         Interface interfOts = new InterfaceBuilder()
 258                 .setName("interface name")
 259                 .addAugmentation(
 260                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
 261                                 .Interface1Builder()
 262                                 .setOts(new OtsBuilder()
 263                                         .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
 264                                         .build())
 265                                 .build())
 266                 .build();
 267         when(this.openRoadmInterfaces.getInterface(Mockito.matches("roadm-A"), Mockito.anyString()))
 268             .thenReturn(Optional.of(interfOts));
 269         try (MockedStatic<PowerMgmtVersion121> pmv121 = Mockito.mockStatic(PowerMgmtVersion121.class)) {
 270
 271             pmv121.when(() -> PowerMgmtVersion121.setTransponderPower(Mockito.anyString(), Mockito.anyString(),
 272                             Mockito.any(), Mockito.any(), Mockito.any()))
 273                     .thenReturn(true);
 274             Map<String, Double> powerRangeMapTpdrTx = new HashMap<>();
 275             powerRangeMapTpdrTx.put("MaxTx", 0.1);
 276             powerRangeMapTpdrTx.put("MinTx", -5.1);
 277             pmv121.when(() -> PowerMgmtVersion121.getXponderPowerRange(Mockito.anyString(), Mockito.anyString(),
 278                             Mockito.anyString(), Mockito.any()))
 279                     .thenReturn(powerRangeMapTpdrTx);
 280             Map<String, Double> powerRangeMapSrgRx = new HashMap<>();
 281             powerRangeMapSrgRx.put("MaxRx", -4.2);
 282             powerRangeMapSrgRx.put("MinRx", -22.2);
 283             pmv121.when(() -> PowerMgmtVersion121.getSRGRxPowerRange(Mockito.anyString(), Mockito.anyString(),
 284                             Mockito.any(), Mockito.anyString(), Mockito.anyString()))
 285                     .thenReturn(powerRangeMapSrgRx);
 286             when(this.crossConnect
 287                     .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 288                 .thenReturn(true);
 289
 290             ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
 291             boolean result = this.powerMgmt.setPower(input);
 292             assertEquals(true, result);
 293             pmv121.verify(() -> PowerMgmtVersion121.setTransponderPower(Mockito.matches("xpdr-A"),
 294                     Mockito.anyString(), eq(new BigDecimal("-4.20000000000000017763568394002504646778106689453125")),
 295                     Mockito.any(), Mockito.any()));
 296         }
 297     }
 298
 299     @Test
 300     void testSetPowerWithoutNode() {
 301         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputWthoutNode();
 302         boolean result = this.powerMgmt.setPower(input);
 303         assertEquals(false, result);
 304         verifyNoInteractions(this.crossConnect);
 305     }
 306
 307     @Test
 308     void testSetPowerForBadNodeType() throws OpenRoadmInterfaceException {
 309         when(this.portMapping.getNode("ila node")).thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeIla());
 310
 311         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
 312                 .getServicePowerSetupInputForOneNode("ila node", "rx-port", "tx-port");
 313         boolean result = this.powerMgmt.setPower(input);
 314         assertEquals(true, result);
 315         verifyNoInteractions(this.crossConnect);
 316         verifyNoInteractions(this.openRoadmInterfaces);
 317     }
 318
 319
 320     @Test
 321     void testPowerTurnDownWhenSuccess() {
 322         when(this.crossConnect
 323                 .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 324             .thenReturn(true);
 325         ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
 326         boolean result = this.powerMgmt.powerTurnDown(input);
 327         assertEquals(true, result);
 328         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-C"),
 329                 Mockito.matches(OpticalControlMode.Off.getName()), Mockito.isNull(), Mockito.anyString());
 330         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 331                 Mockito.matches(OpticalControlMode.Power.getName()), eq(Decimal64.valueOf("-60")),
 332                 Mockito.anyString());
 333         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 334                 Mockito.matches(OpticalControlMode.Off.getName()), Mockito.isNull(), Mockito.anyString());
 335     }
 336
 337     @Test
 338     void testPowerTurnDownWhenFailure() {
 339         when(this.crossConnect
 340                 .setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.anyString()))
 341             .thenReturn(false);
 342         ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
 343         boolean result = this.powerMgmt.powerTurnDown(input);
 344         assertEquals(false, result);
 345         verify(this.crossConnect, times(2))
 346                 .setPowerLevel(Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.anyString());
 347     }
 348
 349     @Test
 350     void testSetPowerForRoadmAEndGainLossFailure() throws OpenRoadmInterfaceException {
 351         when(this.portMapping.getNode("roadm-A"))
 352             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
 353                         List.of("srg1-A", "deg2-A")));
 354         when(this.deviceTransactionManager
 355                 .getDataFromDevice(Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any()))
 356             .thenReturn(Optional.empty());
 357         Interface interfOts = new InterfaceBuilder()
 358                 .setName("interface name")
 359                 .addAugmentation(
 360                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
 361                             .Interface1Builder()
 362                     .setOts(new OtsBuilder()
 363                             .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
 364                             .build())
 365                     .build())
 366                 .build();
 367         when(this.crossConnect
 368                 .setPowerLevel(Mockito.anyString(), Mockito.matches(OpticalControlMode.Power.getName()),
 369                     Mockito.any(), Mockito.anyString()))
 370             .thenReturn(true);
 371         when(this.openRoadmInterfaces.getInterface(Mockito.anyString(), Mockito.anyString()))
 372             .thenReturn(Optional.of(interfOts));
 373         when(this.crossConnect
 374                 .setPowerLevel(Mockito.anyString(), Mockito.matches(OpticalControlMode.GainLoss.getName()),
 375                     Mockito.any(), Mockito.anyString()))
 376             .thenReturn(false);
 377         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
 378                 .getServicePowerSetupInputForOneNode("roadm-A", "srg1-A", "deg2-A");
 379         boolean result = this.powerMgmt.setPower(input);
 380         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 381                 Mockito.matches(OpticalControlMode.Power.getName()), eq(Decimal64.valueOf("-3.00")),
 382                 Mockito.matches("srg1-A-deg2-A-761:768"));
 383         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 384                 Mockito.matches(OpticalControlMode.GainLoss.getName()), eq(Decimal64.valueOf("-3.00")),
 385                 Mockito.matches("srg1-A-deg2-A-761:768"));
 386         assertEquals(false, result);
 387     }
 388
 389
 390 }