pce/src/test/java/org/opendaylight/transportpce/pce/networkanalyzer/port/PreferenceFactoryTest.java

   1 /*
   2  * Copyright (c) 2024 Smartoptics 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.pce.networkanalyzer.port;
  10
  11 import java.util.HashMap;
  12 import java.util.Map;
  13 import java.util.Set;
  14 import org.junit.jupiter.api.Assertions;
  15 import org.junit.jupiter.api.Test;
  16 import org.mockito.Mockito;
  17 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev230925.PathComputationRequestInput;
  18 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev230925.path.computation.request.input.ServiceAEnd;
  19 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev230925.path.computation.request.input.ServiceZEnd;
  20 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev230526.service.port.PortBuilder;
  21 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.endpoint.sp.RxDirection;
  22 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.endpoint.sp.TxDirection;
  23
  24 class PreferenceFactoryTest {
  25
  26     @Test
  27     void emptyPathComputationRequest_returnEmptyHashmap() {
  28
  29         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
  30         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
  31
  32         Map<String, Set<String>> expected = new HashMap<>();
  33         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
  34
  35     }
  36
  37     @Test
  38     void pathComputationRequestServiceAEndRxDirectionWithoutDeviceAndPort_returnEmptyHashmap() {
  39
  40         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
  41         ServiceAEnd serviceAEnd = Mockito.mock(ServiceAEnd.class);
  42         RxDirection rxDirection = Mockito.mock(RxDirection.class);
  43
  44         Mockito.when(rxDirection.getPort()).thenReturn(new PortBuilder().build());
  45         Mockito.when(serviceAEnd.getRxDirection()).thenReturn(rxDirection);
  46         Mockito.when(pathComputationRequestInput.getServiceAEnd()).thenReturn(serviceAEnd);
  47
  48         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
  49
  50         Map<String, Set<String>> expected = new HashMap<>();
  51         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
  52
  53     }
  54
  55     @Test
  56     void pathComputationRequestServiceAEndRxDirectionWithoutPort_returnEmptyHashmap() {
  57
  58         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
  59         ServiceAEnd serviceAEnd = Mockito.mock(ServiceAEnd.class);
  60         RxDirection rxDirection = Mockito.mock(RxDirection.class);
  61
  62         Mockito.when(rxDirection.getPort()).thenReturn(
  63             new PortBuilder()
  64                 .setPortDeviceName("ROADM-B-SRG1")
  65                 .build()
  66         );
  67         Mockito.when(serviceAEnd.getRxDirection()).thenReturn(rxDirection);
  68         Mockito.when(pathComputationRequestInput.getServiceAEnd()).thenReturn(serviceAEnd);
  69
  70         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
  71
  72         Map<String, Set<String>> expected = new HashMap<>();
  73         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
  74
  75     }
  76
  77     @Test
  78     void pathComputationRequestServiceAEndRxDirectionTxRx_returnHashmap() {
  79
  80         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
  81         ServiceAEnd serviceAEnd = Mockito.mock(ServiceAEnd.class);
  82         RxDirection rxDirection = Mockito.mock(RxDirection.class);
  83
  84         Mockito.when(rxDirection.getPort()).thenReturn(
  85             new PortBuilder()
  86                 .setPortDeviceName("ROADM-B-SRG1")
  87                 .setPortName("SRG1-PP1-TXRX")
  88                 .build()
  89         );
  90         Mockito.when(serviceAEnd.getRxDirection()).thenReturn(rxDirection);
  91         Mockito.when(pathComputationRequestInput.getServiceAEnd()).thenReturn(serviceAEnd);
  92
  93         Map<String, Set<String>> expected = new HashMap<>();
  94         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-TXRX"));
  95         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
  96
  97         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
  98
  99     }
 100
 101     @Test
 102     void pathComputationRequestServiceAEndRxDirectionTx_returnHashmap() {
 103
 104         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 105         ServiceAEnd serviceAEnd = Mockito.mock(ServiceAEnd.class);
 106         RxDirection rxDirection = Mockito.mock(RxDirection.class);
 107
 108         Mockito.when(rxDirection.getPort()).thenReturn(
 109             new PortBuilder()
 110                 .setPortDeviceName("ROADM-B-SRG1")
 111                 .setPortName("SRG1-PP1-TX")
 112                 .build()
 113         );
 114         Mockito.when(serviceAEnd.getRxDirection()).thenReturn(rxDirection);
 115         Mockito.when(pathComputationRequestInput.getServiceAEnd()).thenReturn(serviceAEnd);
 116
 117         Map<String, Set<String>> expected = new HashMap<>();
 118         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-TX"));
 119         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 120
 121         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 122
 123     }
 124
 125     @Test
 126     void pathComputationRequestServiceAEndRxDirectionRx_returnHashmap() {
 127
 128         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 129         ServiceAEnd serviceAEnd = Mockito.mock(ServiceAEnd.class);
 130         TxDirection txDirection = Mockito.mock(TxDirection.class);
 131
 132         Mockito.when(txDirection.getPort()).thenReturn(
 133             new PortBuilder()
 134                 .setPortDeviceName("ROADM-B-SRG1")
 135                 .setPortName("SRG1-PP1-RX")
 136                 .build()
 137         );
 138         Mockito.when(serviceAEnd.getTxDirection()).thenReturn(txDirection);
 139         Mockito.when(pathComputationRequestInput.getServiceAEnd()).thenReturn(serviceAEnd);
 140
 141         Map<String, Set<String>> expected = new HashMap<>();
 142         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-RX"));
 143         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 144
 145         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 146
 147     }
 148
 149     @Test
 150     void pathComputationRequestServiceZEndRx_returnHashmap() {
 151
 152         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 153         ServiceZEnd serviceZEnd = Mockito.mock(ServiceZEnd.class);
 154         RxDirection rxDirection = Mockito.mock(RxDirection.class);
 155
 156         Mockito.when(rxDirection.getPort()).thenReturn(
 157             new PortBuilder()
 158                 .setPortDeviceName("ROADM-B-SRG1")
 159                 .setPortName("SRG1-PP1-TXRX")
 160                 .build()
 161         );
 162         Mockito.when(serviceZEnd.getRxDirection()).thenReturn(rxDirection);
 163         Mockito.when(pathComputationRequestInput.getServiceZEnd()).thenReturn(serviceZEnd);
 164
 165         Map<String, Set<String>> expected = new HashMap<>();
 166         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-TXRX"));
 167         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 168
 169         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 170
 171     }
 172
 173     @Test
 174     void pathComputationRequestServiceZEndTxDirectionTxRx_returnHashmap() {
 175
 176         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 177         ServiceZEnd serviceZEnd = Mockito.mock(ServiceZEnd.class);
 178         TxDirection txDirection = Mockito.mock(TxDirection.class);
 179
 180         Mockito.when(txDirection.getPort()).thenReturn(
 181             new PortBuilder()
 182                 .setPortDeviceName("ROADM-B-SRG1")
 183                 .setPortName("SRG1-PP1-TXRX")
 184                 .build()
 185         );
 186         Mockito.when(serviceZEnd.getTxDirection()).thenReturn(txDirection);
 187         Mockito.when(pathComputationRequestInput.getServiceZEnd()).thenReturn(serviceZEnd);
 188
 189         Map<String, Set<String>> expected = new HashMap<>();
 190         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-TXRX"));
 191         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 192
 193         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 194
 195     }
 196
 197     @Test
 198     void pathComputationRequestServiceZEndTxDirectionTx_returnHashmap() {
 199
 200         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 201         ServiceZEnd serviceZEnd = Mockito.mock(ServiceZEnd.class);
 202         TxDirection txDirection = Mockito.mock(TxDirection.class);
 203
 204         Mockito.when(txDirection.getPort()).thenReturn(
 205             new PortBuilder()
 206                 .setPortDeviceName("ROADM-B-SRG1")
 207                 .setPortName("SRG1-PP1-TX")
 208                 .build()
 209         );
 210         Mockito.when(serviceZEnd.getTxDirection()).thenReturn(txDirection);
 211         Mockito.when(pathComputationRequestInput.getServiceZEnd()).thenReturn(serviceZEnd);
 212
 213         Map<String, Set<String>> expected = new HashMap<>();
 214         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-TX"));
 215         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 216
 217         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 218
 219     }
 220
 221     @Test
 222     void pathComputationRequestServiceZEndTxDirectionRx_returnHashmap() {
 223
 224         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 225         ServiceZEnd serviceZEnd = Mockito.mock(ServiceZEnd.class);
 226         TxDirection txDirection = Mockito.mock(TxDirection.class);
 227
 228         Mockito.when(txDirection.getPort()).thenReturn(
 229             new PortBuilder()
 230                 .setPortDeviceName("ROADM-B-SRG1")
 231                 .setPortName("SRG1-PP1-RX")
 232                 .build()
 233         );
 234         Mockito.when(serviceZEnd.getTxDirection()).thenReturn(txDirection);
 235         Mockito.when(pathComputationRequestInput.getServiceZEnd()).thenReturn(serviceZEnd);
 236
 237         Map<String, Set<String>> expected = new HashMap<>();
 238         expected.put("ROADM-B-SRG1", Set.of("SRG1-PP1-RX"));
 239         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 240
 241         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 242
 243     }
 244
 245     @Test
 246     void pathEmptyComputationRequestServiceZEndTx_returnHashmap() {
 247
 248         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 249         ServiceZEnd serviceZEnd = Mockito.mock(ServiceZEnd.class);
 250         TxDirection txDirection = Mockito.mock(TxDirection.class);
 251
 252         Mockito.when(txDirection.getPort()).thenReturn(
 253             new PortBuilder()
 254                 .setPortDeviceName("ROADM-B-SRG1")
 255                 .setPortName(" ")
 256                 .build()
 257         );
 258         Mockito.when(serviceZEnd.getTxDirection()).thenReturn(txDirection);
 259         Mockito.when(pathComputationRequestInput.getServiceZEnd()).thenReturn(serviceZEnd);
 260
 261         Map<String, Set<String>> expected = new HashMap<>();
 262
 263         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 264         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 265
 266     }
 267
 268     @Test
 269     void pathUnexpectedPortName_returnHashmap() {
 270
 271         PathComputationRequestInput pathComputationRequestInput = Mockito.mock(PathComputationRequestInput.class);
 272         ServiceZEnd serviceZEnd = Mockito.mock(ServiceZEnd.class);
 273         TxDirection txDirection = Mockito.mock(TxDirection.class);
 274
 275         Mockito.when(txDirection.getPort()).thenReturn(
 276             new PortBuilder()
 277                 .setPortDeviceName("ROADM-B-SRG1")
 278                 .setPortName("FUBAR")
 279                 .build()
 280         );
 281         Mockito.when(serviceZEnd.getTxDirection()).thenReturn(txDirection);
 282         Mockito.when(pathComputationRequestInput.getServiceZEnd()).thenReturn(serviceZEnd);
 283
 284         Map<String, Set<String>> expected = new HashMap<>();
 285         expected.put("ROADM-B-SRG1", Set.of("FUBAR"));
 286
 287         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 288         Assertions.assertEquals(expected, portPreferenceFactory.nodePortMap(pathComputationRequestInput));
 289
 290     }
 291
 292     @Test
 293     void addingMultiplePort() {
 294
 295         PreferenceFactory portPreferenceFactory = new PreferenceFactory();
 296         Map<String, Set<String>> mapper = new HashMap<>();
 297
 298         //New ports
 299         Assertions.assertTrue(portPreferenceFactory.add("ROADM-B-SRG1", "SRG1-PP1-TXRX", mapper));
 300         Assertions.assertTrue(portPreferenceFactory.add("ROADM-B-SRG1", "SRG1-PP2-TXRX", mapper));
 301         Assertions.assertTrue(portPreferenceFactory.add("ROADM-B-SRG1", "SRG1-PP3-RX", mapper));
 302         Assertions.assertTrue(portPreferenceFactory.add("ROADM-B-SRG1", "SRG1-PP3-TX", mapper));
 303
 304         //This port already exists, should return false.
 305         Assertions.assertFalse(portPreferenceFactory.add("ROADM-B-SRG1", "SRG1-PP2-TXRX", mapper));
 306
 307         Assertions.assertEquals(
 308             Set.of("SRG1-PP1-TXRX", "SRG1-PP2-TXRX", "SRG1-PP3-RX", "SRG1-PP3-TX"),
 309             mapper.get("ROADM-B-SRG1")
 310         );
 311     }
 312 }