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.mockito.ArgumentMatchers.eq;
  12 import static org.mockito.Mockito.times;
  13 import static org.mockito.Mockito.verify;
  14 import static org.mockito.Mockito.verifyNoInteractions;
  15
  16 import java.math.BigDecimal;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Optional;
  21 import org.junit.Assert;
  22 import org.junit.Before;
  23 import org.junit.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.rev220316.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 DataBroker dataBroker;
  48     private OpenRoadmInterfaces openRoadmInterfaces;
  49     private CrossConnect crossConnect;
  50     private DeviceTransactionManager deviceTransactionManager;
  51     private PortMapping portMapping;
  52     private PowerMgmt powerMgmt;
  53
  54     @Before
  55     public void setUp() {
  56         this.dataBroker = Mockito.mock(DataBroker.class);
  57         this.openRoadmInterfaces = Mockito.mock(OpenRoadmInterfaces.class);
  58         this.crossConnect = Mockito.mock((CrossConnectImpl.class));
  59         this.deviceTransactionManager = Mockito.mock(DeviceTransactionManager.class);
  60         this.portMapping = Mockito.mock(PortMapping.class);
  61         this.powerMgmt = new PowerMgmtImpl(this.dataBroker, this.openRoadmInterfaces, this.crossConnect,
  62                 this.deviceTransactionManager, this.portMapping, "1000", "1000");
  63     }
  64
  65     @Test
  66     public void testSetPowerWhenMappingReturnNull() {
  67         Mockito.when(this.portMapping.getNode(Mockito.anyString())).thenReturn(null);
  68         boolean output = this.powerMgmt.setPower(OlmPowerServiceRpcImplUtil.getServicePowerSetupInput());
  69         Assert.assertEquals(false, output);
  70     }
  71
  72     @Test
  73     public void testSetPowerForTransponderAEnd() throws OpenRoadmInterfaceException {
  74         Mockito.when(this.portMapping.getNode("xpdr-A"))
  75             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
  76                     List.of("network-A")));
  77         Mockito.when(this.portMapping.getNode("roadm-A"))
  78             .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
  79                     List.of("srg1-A", "deg2-A")));
  80         Interface interfOch = new InterfaceBuilder()
  81                 .setName("interface name")
  82                 .addAugmentation(new Interface1Builder()
  83                         .setOch(new OchBuilder().build())
  84                         .build())
  85                 .build();
  86         Mockito.when(this.openRoadmInterfaces.getInterface(Mockito.matches("xpdr-A"), Mockito.anyString()))
  87             .thenReturn(Optional.of(interfOch));
  88         Interface interfOts = new InterfaceBuilder()
  89                 .setName("interface name")
  90                 .addAugmentation(
  91                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
  92                                 .Interface1Builder()
  93                                 .setOts(new OtsBuilder()
  94                                         .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
  95                                         .build())
  96                                 .build())
  97                 .build();
  98         Mockito.when(this.openRoadmInterfaces
  99                         .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         Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 112                         Mockito.anyString()))
 113                 .thenReturn(true);
 114
 115         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
 116         boolean result = this.powerMgmt.setPower(input);
 117         Assert.assertEquals(true, result);
 118     }
 119
 120     @Test
 121     public void testSetPowerForTransponderZEnd() throws OpenRoadmInterfaceException {
 122         Mockito.when(this.portMapping.getNode("xpdr-C"))
 123                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-C", OpenroadmNodeVersion._121,
 124                         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         Assert.assertEquals(true, result);
 130     }
 131
 132     @Test
 133     public void testSetPowerForRoadmAEnd() throws OpenRoadmInterfaceException {
 134         Mockito.when(this.portMapping.getNode("roadm-A"))
 135                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
 136                         List.of("srg1-A", "deg2-A")));
 137         Mockito.when(this.deviceTransactionManager.getDataFromDevice(Mockito.anyString(), Mockito.any(),
 138                         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         Mockito.when(this.openRoadmInterfaces.getInterface(Mockito.anyString(), Mockito.anyString()))
 151                 .thenReturn(Optional.of(interfOts));
 152         Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 153                         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         Assert.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     public void testSetPowerForRoadmZEnd() throws OpenRoadmInterfaceException {
 170         Mockito.when(this.portMapping.getNode("roadm-C"))
 171                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-C", OpenroadmNodeVersion._121,
 172                         List.of("deg1-C", "srg1-C")));
 173         Mockito.when(this.deviceTransactionManager.getDataFromDevice(Mockito.anyString(), Mockito.any(),
 174                         Mockito.any(), Mockito.anyLong(), Mockito.any()))
 175                 .thenReturn(Optional.empty());
 176         Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 177                         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         Assert.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     public void testSetPowerForTransponderWhenNoTransponderPort() throws OpenRoadmInterfaceException {
 191         Mockito.when(this.portMapping.getNode("xpdr-A"))
 192                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
 193                         List.of("network-A")));
 194         Mockito.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         Mockito.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         Mockito.when(this.openRoadmInterfaces
 216                         .getInterface(Mockito.matches("roadm-A"), Mockito.anyString()))
 217                 .thenReturn(Optional.of(interfOts));
 218         try (MockedStatic<PowerMgmtVersion121> pmv121 = Mockito.mockStatic(PowerMgmtVersion121.class)) {
 219             pmv121.when(() -> PowerMgmtVersion121.setTransponderPower(Mockito.anyString(), Mockito.anyString(),
 220                             Mockito.any(), Mockito.any(), Mockito.any()))
 221                     .thenReturn(true);
 222             pmv121.when(() -> PowerMgmtVersion121.getXponderPowerRange(Mockito.anyString(), Mockito.anyString(),
 223                             Mockito.anyString(), Mockito.any()))
 224                     .thenReturn(new HashMap<>());
 225
 226             Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 227                             Mockito.anyString()))
 228                     .thenReturn(true);
 229
 230
 231             ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
 232             boolean result = this.powerMgmt.setPower(input);
 233             Assert.assertEquals(true, result);
 234             pmv121.verify(() -> PowerMgmtVersion121.setTransponderPower(Mockito.matches("xpdr-A"),
 235                     Mockito.anyString(), eq(new BigDecimal("-5")), Mockito.any(), Mockito.any()));
 236             verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 237                     Mockito.matches(OpticalControlMode.GainLoss.getName()), eq(Decimal64.valueOf("-3.00")),
 238                     Mockito.matches("srg1-A-deg2-A-761:768"));
 239         }
 240     }
 241
 242     @Test
 243     public void testSetPowerForTransponderAEndWithRoadmPort() throws OpenRoadmInterfaceException {
 244         Mockito.when(this.portMapping.getNode("xpdr-A"))
 245                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeTpdr("xpdr-A", OpenroadmNodeVersion._121,
 246                         List.of("network-A")));
 247         Mockito.when(this.portMapping.getNode("roadm-A"))
 248                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeRdm("roadm-A", OpenroadmNodeVersion._121,
 249                         List.of("srg1-A", "deg2-A")));
 250         Interface interfOch = new InterfaceBuilder()
 251                 .setName("interface name")
 252                 .addAugmentation(new Interface1Builder()
 253                         .setOch(new OchBuilder().build())
 254                         .build())
 255                 .build();
 256         Mockito.when(this.openRoadmInterfaces.getInterface(Mockito.matches("xpdr-A"), Mockito.anyString()))
 257                 .thenReturn(Optional.of(interfOch));
 258         Interface interfOts = new InterfaceBuilder()
 259                 .setName("interface name")
 260                 .addAugmentation(
 261                         new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
 262                                 .Interface1Builder()
 263                                 .setOts(new OtsBuilder()
 264                                         .setSpanLossTransmit(new RatioDB(Decimal64.valueOf("6")))
 265                                         .build())
 266                                 .build())
 267                 .build();
 268         Mockito.when(this.openRoadmInterfaces
 269                         .getInterface(Mockito.matches("roadm-A"), Mockito.anyString()))
 270                 .thenReturn(Optional.of(interfOts));
 271         try (MockedStatic<PowerMgmtVersion121> pmv121 = Mockito.mockStatic(PowerMgmtVersion121.class)) {
 272
 273             pmv121.when(() -> PowerMgmtVersion121.setTransponderPower(Mockito.anyString(), Mockito.anyString(),
 274                             Mockito.any(), Mockito.any(), Mockito.any()))
 275                     .thenReturn(true);
 276             Map<String, Double> powerRangeMapTpdrTx = new HashMap<>();
 277             powerRangeMapTpdrTx.put("MaxTx", 0.1);
 278             powerRangeMapTpdrTx.put("MinTx", -5.1);
 279             pmv121.when(() -> PowerMgmtVersion121.getXponderPowerRange(Mockito.anyString(), Mockito.anyString(),
 280                             Mockito.anyString(), Mockito.any()))
 281                     .thenReturn(powerRangeMapTpdrTx);
 282             Map<String, Double> powerRangeMapSrgRx = new HashMap<>();
 283             powerRangeMapSrgRx.put("MaxRx", -4.2);
 284             powerRangeMapSrgRx.put("MinRx", -22.2);
 285             pmv121.when(() -> PowerMgmtVersion121.getSRGRxPowerRange(Mockito.anyString(), Mockito.anyString(),
 286                             Mockito.any(), Mockito.anyString(), Mockito.anyString()))
 287                     .thenReturn(powerRangeMapSrgRx);
 288             Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 289                             Mockito.anyString()))
 290                     .thenReturn(true);
 291
 292             ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputForTransponder();
 293             boolean result = this.powerMgmt.setPower(input);
 294             Assert.assertEquals(true, result);
 295             pmv121.verify(() -> PowerMgmtVersion121.setTransponderPower(Mockito.matches("xpdr-A"),
 296                     Mockito.anyString(), eq(new BigDecimal("-4.20000000000000017763568394002504646778106689453125")),
 297                     Mockito.any(), Mockito.any()));
 298         }
 299     }
 300
 301     @Test
 302     public void testSetPowerWithoutNode() {
 303         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInputWthoutNode();
 304         boolean result = this.powerMgmt.setPower(input);
 305         Assert.assertEquals(false, result);
 306         verifyNoInteractions(this.crossConnect);
 307     }
 308
 309     @Test
 310     public void testSetPowerForBadNodeType() throws OpenRoadmInterfaceException {
 311         Mockito.when(this.portMapping.getNode("ila node"))
 312                 .thenReturn(OlmPowerServiceRpcImplUtil.getMappingNodeIla());
 313
 314         ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil
 315                 .getServicePowerSetupInputForOneNode("ila node", "rx-port", "tx-port");
 316         boolean result = this.powerMgmt.setPower(input);
 317         Assert.assertEquals(true, result);
 318         verifyNoInteractions(this.crossConnect);
 319         verifyNoInteractions(this.openRoadmInterfaces);
 320     }
 321
 322
 323     @Test
 324     public void testPowerTurnDownWhenSuccess() {
 325         Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 326                         Mockito.anyString()))
 327                 .thenReturn(true);
 328         ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
 329         boolean result = this.powerMgmt.powerTurnDown(input);
 330         Assert.assertEquals(true, result);
 331         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-C"),
 332                 Mockito.matches(OpticalControlMode.Off.getName()), Mockito.isNull(), Mockito.anyString());
 333         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 334                 Mockito.matches(OpticalControlMode.Power.getName()), eq(Decimal64.valueOf("-60")),
 335                 Mockito.anyString());
 336         verify(this.crossConnect, times(1)).setPowerLevel(Mockito.matches("roadm-A"),
 337                 Mockito.matches(OpticalControlMode.Off.getName()), Mockito.isNull(), Mockito.anyString());
 338     }
 339
 340     @Test
 341     public void testPowerTurnDownWhenFailure() {
 342         Mockito.when(this.crossConnect.setPowerLevel(Mockito.anyString(), Mockito.anyString(), Mockito.any(),
 343                         Mockito.anyString()))
 344                 .thenReturn(false);
 345         ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput();
 346         boolean result = this.powerMgmt.powerTurnDown(input);
 347         Assert.assertEquals(false, result);
 348         verify(this.crossConnect, times(2))
 349                 .setPowerLevel(Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.anyString());
 350     }
 351 }