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