legato-api/src/test/java/org/opendaylight/unimgr/mef/legato/utils/LegatoUtilsTest.java

   1 /*
   2  * Copyright (c) 2018 Xoriant Corporation 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.unimgr.mef.legato.utils;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.mockito.Matchers.any;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.verify;
  17 import static org.mockito.Mockito.when;
  18
  19 import com.google.common.base.Optional;
  20 import com.google.common.util.concurrent.CheckedFuture;
  21
  22 import java.util.ArrayList;
  23 import java.util.List;
  24
  25 import org.junit.Before;
  26 import org.junit.Rule;
  27 import org.junit.Test;
  28 import org.junit.rules.ExpectedException;
  29 import org.junit.runner.RunWith;
  30 import org.mockito.Mock;
  31 import org.mockito.Mockito;
  32 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  33 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  34 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  35 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  36 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  37 import org.opendaylight.unimgr.mef.legato.dao.EVCDao;
  38 import org.opendaylight.unimgr.mef.legato.util.LegatoUtils;
  39 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.global.rev171215.MefGlobal;
  40 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.global.rev171215.mef.global.SlsProfiles;
  41 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.global.rev171215.mef.global.sls.profiles.Profile;
  42 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.global.rev171215.mef.global.sls.profiles.ProfileKey;
  43 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.legato.services.rev171215.MefServices;
  44 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.legato.services.rev171215.mef.services.CarrierEthernet;
  45 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.legato.services.rev171215.mef.services.carrier.ethernet.SubscriberServices;
  46 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.legato.services.rev171215.mef.services.carrier.ethernet.subscriber.services.Evc;
  47 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.legato.services.rev171215.mef.services.carrier.ethernet.subscriber.services.EvcKey;
  48 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.types.rev171215.EvcIdType;
  49 import org.opendaylight.yang.gen.v1.urn.mef.yang.mef.types.rev171215.Identifier1024;
  50 import org.opendaylight.yang.gen.v1.urn.mef.yang.nrp._interface.rev180321.CreateConnectivityServiceInput1;
  51 import org.opendaylight.yang.gen.v1.urn.mef.yang.nrp._interface.rev180321.EndPoint2;
  52 import org.opendaylight.yang.gen.v1.urn.mef.yang.nrp._interface.rev180321.EndPoint7;
  53 import org.opendaylight.yang.gen.v1.urn.mef.yang.nrp._interface.rev180321.UpdateConnectivityServiceInput1;
  54 import org.opendaylight.yang.gen.v1.urn.mef.yang.nrp._interface.rev180321.nrp.connectivity.service.attrs.NrpCarrierEthConnectivityResource;
  55 import org.opendaylight.yang.gen.v1.urn.mef.yang.nrp._interface.rev180321.nrp.connectivity.service.end.point.attrs.NrpCarrierEthConnectivityEndPointResource;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.CreateConnectivityServiceInput;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.UpdateConnectivityServiceInput;
  58 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  59 import org.powermock.api.mockito.PowerMockito;
  60 import org.powermock.api.support.membermodification.MemberMatcher;
  61 import org.powermock.api.support.membermodification.MemberModifier;
  62 import org.powermock.core.classloader.annotations.PrepareForTest;
  63 import org.powermock.modules.junit4.PowerMockRunner;
  64
  65 /**
  66 * @author Arif.Hussain@Xoriant.Com
  67 *
  68 */
  69 @SuppressWarnings("deprecation")
  70 @RunWith(PowerMockRunner.class)
  71 @PrepareForTest({LogicalDatastoreType.class, LegatoUtils.class, InstanceIdentifier.class})
  72 public class LegatoUtilsTest {
  73
  74     @Rule
  75     public final ExpectedException exception = ExpectedException.none();
  76     @Mock
  77     private DataBroker dataBroker;
  78     @Mock
  79     private WriteTransaction transaction;
  80     @SuppressWarnings("rawtypes")
  81     @Mock
  82     private CheckedFuture checkedFuture;
  83     private static final EvcIdType EVC_NODE_ID = new EvcIdType("EVC1");
  84
  85
  86     @Before
  87     public void setUp() throws Exception {
  88         PowerMockito.mockStatic(LegatoUtils.class, Mockito.CALLS_REAL_METHODS);
  89     }
  90
  91
  92     @SuppressWarnings("unchecked")
  93     @Test
  94     public void testReadEvc() throws ReadFailedException {
  95
  96         final InstanceIdentifier<Evc> evcID = InstanceIdentifier.create(MefServices.class)
  97                 .child(CarrierEthernet.class).child(SubscriberServices.class)
  98                 .child(Evc.class, new EvcKey(new EvcIdType(EVC_NODE_ID)));
  99
 100         ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
 101         when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
 102         CheckedFuture<Optional<Evc>, ReadFailedException> nodeFuture = mock(CheckedFuture.class);
 103         Optional<Evc> optNode = mock(Optional.class);
 104         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
 105                 .thenReturn(nodeFuture);
 106         when(nodeFuture.checkedGet()).thenReturn(optNode);
 107         Optional<Evc> expectedOpt =
 108                 LegatoUtils.readEvc(dataBroker, LogicalDatastoreType.CONFIGURATION, evcID);
 109         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 110         assertNotNull(expectedOpt);
 111         assertEquals(expectedOpt, optNode);
 112     }
 113
 114
 115     @SuppressWarnings("unchecked")
 116     @Test
 117     public void testReadProfiles() throws ReadFailedException {
 118
 119         final InstanceIdentifier<Profile> profileID =
 120                 InstanceIdentifier.create(MefGlobal.class).child(SlsProfiles.class)
 121                         .child(Profile.class, new ProfileKey(new Identifier1024(Constants.ONE)));
 122
 123         ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
 124         when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
 125         CheckedFuture<Optional<Profile>, ReadFailedException> nodeFuture =
 126                 mock(CheckedFuture.class);
 127         Optional<Profile> optNode = mock(Optional.class);
 128         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
 129                 .thenReturn(nodeFuture);
 130         when(nodeFuture.checkedGet()).thenReturn(optNode);
 131         Optional<Profile> expectedOpt =
 132                 (Optional<Profile>) LegatoUtils.readProfile(Constants.SLS_PROFILES,
 133                         dataBroker, LogicalDatastoreType.CONFIGURATION, profileID);
 134         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 135         assertNotNull(expectedOpt);
 136         assertEquals(expectedOpt, optNode);
 137
 138     }
 139
 140
 141     @SuppressWarnings("unchecked")
 142     @Test
 143     public void testAddToOperationalDB() {
 144         final SlsProfiles slsProfile = mock(SlsProfiles.class);
 145         final InstanceIdentifier<SlsProfiles> instanceIdentifier =
 146                 InstanceIdentifier.create(MefGlobal.class).child(SlsProfiles.class);
 147
 148         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 149         doNothing().when(transaction).merge(any(LogicalDatastoreType.class),
 150                 any(InstanceIdentifier.class), any(Profile.class));
 151         when(transaction.submit()).thenReturn(checkedFuture);
 152         LegatoUtils.addToOperationalDB(slsProfile, instanceIdentifier, dataBroker);
 153         verify(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 154                 any(Profile.class));
 155         verify(transaction).submit();
 156     }
 157
 158
 159     @SuppressWarnings("unchecked")
 160     @Test
 161     public void testDeleteFromOperationalDB() {
 162         final InstanceIdentifier<Evc> evcID = InstanceIdentifier.create(MefServices.class)
 163                 .child(CarrierEthernet.class).child(SubscriberServices.class)
 164                 .child(Evc.class, new EvcKey(new EvcIdType(EVC_NODE_ID)));
 165
 166         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 167         doNothing().when(transaction).delete(any(LogicalDatastoreType.class),
 168                 any(InstanceIdentifier.class));
 169         when(transaction.submit()).thenReturn(checkedFuture);
 170         assertEquals(true, LegatoUtils.deleteFromOperationalDB(evcID, dataBroker));
 171         verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 172         verify(transaction).submit();
 173     }
 174
 175
 176     @Test
 177     public void testBuildCreateConnectivityServiceInput() {
 178         final Evc evc = mock(Evc.class);
 179         final CreateConnectivityServiceInput input = mock(CreateConnectivityServiceInput.class);
 180         final EVCDao evcDao = mock(EVCDao.class);
 181
 182         MemberModifier.suppress(MemberMatcher.method(LegatoUtils.class, Constants.PARSE_NODES));
 183         when(LegatoUtils.parseNodes(evc)).thenReturn(evcDao);
 184         MemberModifier.suppress(
 185                 MemberMatcher.method(LegatoUtils.class, Constants.CREATE_CONNECTIVITY_INPUT));
 186         when(LegatoUtils.buildCreateConnectivityServiceInput(evcDao))
 187                 .thenReturn(input);
 188         assertNotNull(input);
 189         assertEquals(input,
 190                 LegatoUtils.buildCreateConnectivityServiceInput(evcDao));
 191     }
 192
 193
 194     @Test
 195     public void testBuildUpdateConnectivityServiceInput() {
 196         final Evc evc = mock(Evc.class);
 197         final UpdateConnectivityServiceInput input = mock(UpdateConnectivityServiceInput.class);
 198         final EVCDao evcDao = mock(EVCDao.class);
 199         MemberModifier.suppress(MemberMatcher.method(LegatoUtils.class, Constants.PARSE_NODES));
 200         when(LegatoUtils.parseNodes(evc)).thenReturn(evcDao);
 201
 202         final List<String> uniList = new ArrayList<String>();
 203         uniList.add(Constants.UNI_ID1);
 204         uniList.add(Constants.UNI_ID2);
 205         MemberModifier.suppress(
 206                 MemberMatcher.method(LegatoUtils.class, Constants.UPDATE_CONNECTIVITY_INPUT));
 207         when(LegatoUtils.buildUpdateConnectivityServiceInput(evcDao, uniList.get(0), Constants.UUID)).thenReturn(input);
 208         assertNotNull(input);
 209         assertEquals(input, LegatoUtils.buildUpdateConnectivityServiceInput(evcDao, uniList.get(0),
 210                 Constants.UUID));
 211     }
 212
 213
 214     @Test
 215     public void testBuildNrpCarrierEthConnectivityResource() {
 216
 217         final NrpCarrierEthConnectivityResource nrpCarrierEthConnectivityResource =
 218                 mock(NrpCarrierEthConnectivityResource.class);
 219
 220         MemberModifier.suppress(
 221                 MemberMatcher.method(LegatoUtils.class, Constants.NRP_CARRIER_ETH_CON_RESOURCE));
 222         when(LegatoUtils.buildNrpCarrierEthConnectivityResource(
 223                 String.valueOf(Constants.MAXFRAME_SIZE_TYPE)))
 224                         .thenReturn(nrpCarrierEthConnectivityResource);
 225         assertNotNull(nrpCarrierEthConnectivityResource);
 226         assertEquals(nrpCarrierEthConnectivityResource,
 227                 LegatoUtils.buildNrpCarrierEthConnectivityResource(
 228                         String.valueOf(Constants.MAXFRAME_SIZE_TYPE)));
 229     }
 230
 231
 232     @Test
 233     public void testBuildNrpCarrierEthConnectivityEndPointResource() {
 234         final NrpCarrierEthConnectivityEndPointResource input =
 235                 mock(NrpCarrierEthConnectivityEndPointResource.class);
 236         MemberModifier.suppress(MemberMatcher.method(LegatoUtils.class,
 237                 Constants.NRP_CARRIER_ETH_CON_ENDPOINT_RESOURCE));
 238         when(LegatoUtils.buildNrpCarrierEthConnectivityEndPointResource(
 239                 String.valueOf(Constants.VLAN_ID_TYPE))).thenReturn(input);
 240         assertNotNull(input);
 241         assertEquals(input, LegatoUtils.buildNrpCarrierEthConnectivityEndPointResource(
 242                 String.valueOf(Constants.VLAN_ID_TYPE)));
 243     }
 244
 245
 246     @Test
 247     public void testBuildCreateEthConnectivityEndPointAugmentation() {
 248         final EndPoint2 createEndPoint = mock(EndPoint2.class);
 249
 250         MemberModifier.suppress(MemberMatcher.method(LegatoUtils.class,
 251                 Constants.CREATE_ETH_CON_ENDPOINT_AUGMENTATION));
 252         when(LegatoUtils.buildCreateEthConnectivityEndPointAugmentation(
 253                 String.valueOf(Constants.VLAN_ID_TYPE))).thenReturn(createEndPoint);
 254         assertNotNull(createEndPoint);
 255         assertEquals(createEndPoint, LegatoUtils.buildCreateEthConnectivityEndPointAugmentation(
 256                 String.valueOf(Constants.VLAN_ID_TYPE)));
 257     }
 258
 259
 260     @Test
 261     public void testBuildUpdateEthConnectivityEndPointAugmentation() {
 262         final EndPoint7 updateEndPoint = mock(EndPoint7.class);
 263
 264         MemberModifier.suppress(MemberMatcher.method(LegatoUtils.class,
 265                 Constants.UPDATE_ETH_CON_ENDPOINT_AUGMENTATION));
 266         when(LegatoUtils.buildUpdateEthConnectivityEndPointAugmentation(
 267                 String.valueOf(Constants.VLAN_ID_TYPE))).thenReturn(updateEndPoint);
 268         assertNotNull(updateEndPoint);
 269         assertEquals(updateEndPoint, LegatoUtils.buildUpdateEthConnectivityEndPointAugmentation(
 270                 String.valueOf(Constants.VLAN_ID_TYPE)));
 271     }
 272
 273
 274     @Test
 275     public void testBuildCreateConServiceAugmentation() {
 276         final CreateConnectivityServiceInput1 createConServInput =
 277                 mock(CreateConnectivityServiceInput1.class);
 278
 279         MemberModifier.suppress(
 280                 MemberMatcher.method(LegatoUtils.class, Constants.CREATE_CON_SERVICE_AUGMENTATION));
 281         when(LegatoUtils
 282                 .buildCreateConServiceAugmentation(String.valueOf(Constants.MAXFRAME_SIZE_TYPE)))
 283                         .thenReturn(createConServInput);
 284         assertNotNull(createConServInput);
 285         assertEquals(createConServInput, LegatoUtils
 286                 .buildCreateConServiceAugmentation(String.valueOf(Constants.MAXFRAME_SIZE_TYPE)));
 287     }
 288
 289
 290     @Test
 291     public void testBuildUpdateConServiceAugmentation() {
 292         final UpdateConnectivityServiceInput1 updateConServInput =
 293                 mock(UpdateConnectivityServiceInput1.class);
 294
 295         MemberModifier.suppress(
 296                 MemberMatcher.method(LegatoUtils.class, Constants.UPDATE_CON_SERVICE_AUGMENTATION));
 297         when(LegatoUtils
 298                 .buildUpdateConServiceAugmentation(String.valueOf(Constants.MAXFRAME_SIZE_TYPE)))
 299                         .thenReturn(updateConServInput);
 300         assertNotNull(updateConServInput);
 301         assertEquals(updateConServInput, LegatoUtils
 302                 .buildUpdateConServiceAugmentation(String.valueOf(Constants.MAXFRAME_SIZE_TYPE)));
 303     }
 304
 305
 306 }