renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java

   1 /*
   2  * Copyright © 2018 Orange Systems, 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 package org.opendaylight.transportpce.renderer.provisiondevice;
   9
  10 import java.util.ArrayList;
  11 import java.util.List;
  12 import java.util.concurrent.ExecutionException;
  13 import org.junit.Assert;
  14 import org.junit.Before;
  15 import org.junit.Ignore;
  16 import org.junit.Test;
  17 import org.mockito.Mockito;
  18 import org.opendaylight.mdsal.binding.api.MountPoint;
  19 import org.opendaylight.mdsal.binding.api.MountPointService;
  20 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  21 import org.opendaylight.transportpce.common.ResponseCodes;
  22 import org.opendaylight.transportpce.common.StringConstants;
  23 import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
  24 import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
  25 import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
  26 import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
  27 import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
  28 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  29 import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
  30 import org.opendaylight.transportpce.common.mapping.MappingUtils;
  31 import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
  32 import org.opendaylight.transportpce.common.mapping.PortMapping;
  33 import org.opendaylight.transportpce.common.mapping.PortMappingImpl;
  34 import org.opendaylight.transportpce.common.mapping.PortMappingVersion121;
  35 import org.opendaylight.transportpce.common.mapping.PortMappingVersion221;
  36 import org.opendaylight.transportpce.common.mapping.PortMappingVersion710;
  37 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  38 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  39 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl;
  40 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121;
  41 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221;
  42 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710;
  43 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
  44 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
  45 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710;
  46 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
  47 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
  48 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710;
  49 import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
  50 import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
  51 import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock;
  52 import org.opendaylight.transportpce.renderer.utils.ServiceDataUtils;
  53 import org.opendaylight.transportpce.test.AbstractTest;
  54 import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
  55 import org.opendaylight.transportpce.test.stub.MountPointStub;
  56 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathOutputBuilder;
  57 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.GetPmInput;
  58 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.GetPmInputBuilder;
  59 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.GetPmOutput;
  60 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.GetPmOutputBuilder;
  61 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.TransportpceOlmService;
  62 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.get.pm.output.Measurements;
  63 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.get.pm.output.MeasurementsBuilder;
  64 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceImplementationRequestInput;
  65 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceImplementationRequestOutput;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
  68 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.olm.get.pm.input.ResourceIdentifierBuilder;
  69 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  70
  71 @Ignore
  72 public class RendererServiceOperationsImplTest extends AbstractTest {
  73
  74     private MountPointService mountPointService;
  75     private DeviceTransactionManager deviceTransactionManager;
  76     private RendererServiceOperationsImpl rendererServiceOperations;
  77     private OpenRoadmInterfaces openRoadmInterfaces;
  78     private DeviceRendererService deviceRenderer;
  79     private OtnDeviceRendererService otnDeviceRendererService;
  80     private PortMapping portMapping;
  81     private OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
  82     private CrossConnect crossConnect;
  83     private TransportpceOlmService olmService;
  84     private MappingUtils mappingUtils;
  85     private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
  86     private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221;
  87     private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710;
  88     private PortMappingVersion710 portMappingVersion710;
  89     private PortMappingVersion221 portMappingVersion22;
  90     private PortMappingVersion121 portMappingVersion121;
  91     private CrossConnectImpl121 crossConnectImpl121;
  92     private CrossConnectImpl221 crossConnectImpl221;
  93     private CrossConnectImpl710 crossConnectImpl710;
  94
  95     private void setMountPoint(MountPoint mountPoint) {
  96         this.mountPointService = new MountPointServiceStub(mountPoint);
  97         this.deviceTransactionManager = new DeviceTransactionManagerImpl(this.mountPointService, 3000);
  98         this.mappingUtils = new MappingUtilsImpl(getDataBroker());
  99         this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils,
 100             openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710);
 101         this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces);
 102         this.portMappingVersion22 =
 103             new PortMappingVersion221(getDataBroker(), deviceTransactionManager);
 104         this.portMappingVersion121 =
 105             new PortMappingVersion121(getDataBroker(), deviceTransactionManager);
 106         this.portMappingVersion710 =
 107             new PortMappingVersion710(getDataBroker(), deviceTransactionManager);
 108         this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22,
 109             this.portMappingVersion121);
 110         OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
 111         OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
 112         OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces);
 113         OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping,
 114             openRoadmInterfaces);
 115         OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping,
 116             openRoadmInterfaces);
 117         this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
 118             openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221, openRoadmOtnInterface710);
 119         this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
 120         this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager);
 121         this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
 122             this.crossConnectImpl221, this.crossConnectImpl710);
 123     }
 124
 125     @Before
 126     public void setUp() throws OpenRoadmInterfaceException {
 127         setMountPoint(new MountPointStub(getDataBroker()));
 128         this.olmService = new OlmServiceStub();
 129         this.deviceRenderer = new DeviceRendererServiceImpl(getDataBroker(), this.deviceTransactionManager,
 130             openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, portMapping, null);
 131         this.otnDeviceRendererService = new OtnDeviceRendererServiceImpl(openRoadmInterfaceFactory, this.crossConnect,
 132             openRoadmInterfaces, this.deviceTransactionManager, null);
 133         Mockito.doNothing().when(this.openRoadmInterfaces).postEquipmentState(Mockito.anyString(),
 134             Mockito.anyString(), Mockito.anyBoolean());
 135         NotificationPublishService notificationPublishService = new NotificationPublishServiceMock();
 136         this.olmService = Mockito.spy(this.olmService);
 137         this.deviceRenderer = Mockito.spy(this.deviceRenderer);
 138         this.rendererServiceOperations =  new RendererServiceOperationsImpl(this.deviceRenderer,
 139             this.otnDeviceRendererService, this.olmService, getDataBroker(), notificationPublishService, null);
 140
 141         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 142             .setSuccess(true);
 143         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 144             Mockito.any());
 145     }
 146
 147     @Test
 148     public void serviceImplementationTerminationPointAsResourceTtp() throws InterruptedException, ExecutionException {
 149
 150         ServiceImplementationRequestInput input = ServiceDataUtils
 151             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.TTP_TOKEN);
 152         writePortMapping(input, StringConstants.TTP_TOKEN);
 153         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 154             .setSuccess(true);
 155         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 156             Mockito.any());
 157         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 158         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 159
 160     }
 161
 162     @Test
 163     public void serviceImplementationTerminationPointAsResourceTtp2() throws InterruptedException, ExecutionException {
 164
 165         ServiceImplementationRequestInput input = ServiceDataUtils
 166             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.TTP_TOKEN);
 167         writePortMapping(input, StringConstants.TTP_TOKEN);
 168         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 169             .setSuccess(true);
 170         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 171             Mockito.any());
 172         Mockito.doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService)
 173             .servicePowerSetup(Mockito.any());
 174         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 175         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
 176
 177     }
 178
 179     @Test
 180     public void serviceImplementationTerminationPointAsResourcePp() throws InterruptedException, ExecutionException {
 181
 182         ServiceImplementationRequestInput input = ServiceDataUtils
 183             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.PP_TOKEN);
 184         writePortMapping(input, StringConstants.PP_TOKEN);
 185         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 186             .setSuccess(true);
 187         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 188             Mockito.any());
 189         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 190         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 191
 192     }
 193
 194     @Test
 195     public void serviceImplementationTerminationPointAsResourceNetwork()
 196         throws InterruptedException, ExecutionException {
 197
 198         ServiceImplementationRequestInput input = ServiceDataUtils
 199             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 200         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 201         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 202             .setSuccess(true);
 203         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 204             Mockito.any());
 205         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 206         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 207
 208     }
 209
 210     @Test
 211     public void serviceImplementationTerminationPointAsResourceClient()
 212         throws InterruptedException, ExecutionException {
 213
 214         ServiceImplementationRequestInput input = ServiceDataUtils
 215      //       .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.CLIENT_TOKEN);
 216             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.CLIENT_TOKEN);
 217      //   writePortMapping(input, OpenRoadmInterfacesImpl.CLIENT_TOKEN);
 218         writePortMapping(input, StringConstants.CLIENT_TOKEN);
 219         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 220         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 221     }
 222
 223     @Test
 224     public void serviceImplementationTerminationPointAsResourceNoMapping()
 225         throws InterruptedException, ExecutionException {
 226
 227         String[] interfaceTokens = {
 228             StringConstants.NETWORK_TOKEN,
 229             StringConstants.CLIENT_TOKEN,
 230             StringConstants.TTP_TOKEN,
 231             StringConstants.PP_TOKEN
 232         };
 233
 234         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("failed")
 235             .setSuccess(false);
 236         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 237             Mockito.any());
 238
 239         for (String tpToken : interfaceTokens) {
 240             ServiceImplementationRequestInput input = ServiceDataUtils
 241                 .buildServiceImplementationRequestInputTerminationPointResource(tpToken);
 242             ServiceImplementationRequestOutput result =
 243                 this.rendererServiceOperations.serviceImplementation(input).get();
 244             Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
 245                 result.getConfigurationResponseCommon().getResponseCode());
 246         }
 247     }
 248
 249     private void writePortMapping(ServiceImplementationRequestInput input, String tpToken) {
 250         MountPointUtils.writeMapping(
 251             input.getServiceAEnd().getNodeId(),
 252             input.getServiceAEnd().getNodeId() + "-" + tpToken,
 253             this.deviceTransactionManager
 254         );
 255         MountPointUtils.writeMapping(
 256             input.getServiceZEnd().getNodeId(),
 257             input.getServiceZEnd().getNodeId() + "-"
 258                 + input.getServiceAEnd().getNodeId() + "-" + tpToken,
 259             this.deviceTransactionManager
 260         );
 261         MountPointUtils.writeMapping(
 262             input.getServiceAEnd().getNodeId(),
 263             input.getServiceAEnd().getNodeId() + "-"
 264                 + input.getServiceZEnd().getNodeId() + "-" + tpToken,
 265             this.deviceTransactionManager
 266         );
 267         MountPointUtils.writeMapping(
 268             input.getServiceZEnd().getNodeId(),
 269             input.getServiceZEnd().getNodeId() + "-" + tpToken,
 270             this.deviceTransactionManager
 271         );
 272     }
 273
 274     @Test
 275     public void serviceImplementationRollbackAllNecessary() throws InterruptedException, ExecutionException {
 276
 277         ServiceImplementationRequestInput input = ServiceDataUtils
 278             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 279         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 280         Mockito.doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService)
 281             .servicePowerSetup(Mockito.any());
 282         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 283         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
 284
 285     }
 286
 287     private GetPmInput createGetPmInput(String nodeId, String tp) {
 288         GetPmInputBuilder getPmIpBldr = new GetPmInputBuilder();
 289         getPmIpBldr.setNodeId(nodeId);
 290         getPmIpBldr.setGranularity(PmGranularity._15min);
 291         ResourceIdentifierBuilder rsrcBldr = new ResourceIdentifierBuilder();
 292         rsrcBldr.setResourceName(tp + "-OTU");
 293         getPmIpBldr.setResourceIdentifier(rsrcBldr.build());
 294         getPmIpBldr.setResourceType(ResourceTypeEnum.Interface);
 295         return getPmIpBldr.build();
 296     }
 297
 298     @Test
 299     public void serviceImplementationServiceInActive() throws InterruptedException, ExecutionException {
 300
 301         ServiceImplementationRequestInput input = ServiceDataUtils
 302             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 303         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 304         Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks")
 305             .setPmparameterValue("1").build();
 306         List<Measurements> measurementsList = new ArrayList<Measurements>();
 307         measurementsList.add(measurements);
 308         GetPmOutput getPmOutput = new GetPmOutputBuilder()
 309             .setNodeId("node1").setMeasurements(measurementsList).build();
 310         Mockito.doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService)
 311             .getPm(Mockito.any());
 312         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 313         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
 314
 315     }
 316
 317     @Test
 318     public void serviceImplementationServiceInActive2() throws InterruptedException, ExecutionException {
 319
 320         ServiceImplementationRequestInput input = ServiceDataUtils
 321             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 322         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 323         Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks")
 324             .setPmparameterValue("1").build();
 325         List<Measurements> measurementsList = new ArrayList<Measurements>();
 326         measurementsList.add(measurements);
 327         GetPmOutput getPmOutput = new GetPmOutputBuilder()
 328             .setNodeId("node1").setMeasurements(measurementsList).build();
 329         GetPmOutput getPmOutput2 = new GetPmOutputBuilder()
 330             .setNodeId("node1").setMeasurements(new ArrayList<>()).build();
 331
 332         Mockito.when(this.olmService.getPm(Mockito.any()))
 333             .thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
 334         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 335         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
 336
 337     }
 338
 339     @Test
 340     public void serviceImplementationServiceInActive3() throws InterruptedException, ExecutionException {
 341
 342         ServiceImplementationRequestInput input = ServiceDataUtils
 343             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 344         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 345         Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks")
 346             .setPmparameterValue("1").build();
 347         List<Measurements> measurementsList = new ArrayList<Measurements>();
 348         measurementsList.add(measurements);
 349         GetPmOutput getPmOutput = new GetPmOutputBuilder()
 350             .setNodeId("node1").setMeasurements(measurementsList).build();
 351         GetPmOutput getPmOutput2 = new GetPmOutputBuilder()
 352             .setNodeId("node1").setMeasurements(new ArrayList<>()).build();
 353
 354         GetPmInput getPmInputZ = createGetPmInput("XPONDER-2-3",
 355             StringConstants.NETWORK_TOKEN);
 356         GetPmInput getPmInputA = createGetPmInput("XPONDER-1-2",
 357             StringConstants.NETWORK_TOKEN);
 358
 359         Mockito.when(this.olmService.getPm(Mockito.eq(getPmInputZ)))
 360             .thenReturn(RpcResultBuilder.success(getPmOutput2).buildFuture());
 361         Mockito.when(this.olmService.getPm(Mockito.eq(getPmInputA)))
 362             .thenReturn(RpcResultBuilder.success(getPmOutput).buildFuture());
 363         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 364         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 365
 366     }
 367
 368     @Test
 369     public void serviceImplementationServiceActive() throws InterruptedException, ExecutionException {
 370
 371         ServiceImplementationRequestInput input = ServiceDataUtils
 372             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 373         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 374         GetPmOutput getPmOutput = new GetPmOutputBuilder()
 375             .setNodeId("node1").setMeasurements(new ArrayList<>()).build();
 376         GetPmOutput getPmOutput1 = null;
 377         Mockito.when(this.olmService.getPm(Mockito.any())).thenReturn(RpcResultBuilder.success(getPmOutput1)
 378             .buildFuture());
 379         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 380             .setSuccess(true);
 381         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 382             Mockito.any());
 383         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 384         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 385
 386     }
 387
 388     @Test
 389     public void serviceImplementationServiceActive2() throws InterruptedException, ExecutionException {
 390
 391         ServiceImplementationRequestInput input = ServiceDataUtils
 392             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 393         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 394         GetPmOutput getPmOutput = new GetPmOutputBuilder().setMeasurements(new ArrayList<>()).build();
 395         Mockito.when(this.olmService.getPm(Mockito.any())).thenReturn(RpcResultBuilder.success(getPmOutput)
 396             .buildFuture());
 397         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 398             .setSuccess(true);
 399         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 400             Mockito.any());
 401         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 402         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 403
 404     }
 405
 406     @Test
 407     public void serviceImplementationServiceInActive4() throws InterruptedException, ExecutionException {
 408
 409         ServiceImplementationRequestInput input = ServiceDataUtils
 410             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 411         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 412         Measurements measurements = new MeasurementsBuilder().setPmparameterName("preFECCorrectedErrors")
 413             .setPmparameterValue("1").build();
 414         List<Measurements> measurementsList = new ArrayList<Measurements>();
 415         measurementsList.add(measurements);
 416         GetPmOutput getPmOutput = new GetPmOutputBuilder()
 417             .setNodeId("node1").setMeasurements(measurementsList).build();
 418
 419         Mockito.doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService)
 420             .getPm(Mockito.any());
 421         ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
 422             .setSuccess(true);
 423         Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(),
 424             Mockito.any());
 425         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 426         Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode());
 427
 428     }
 429
 430     @Test
 431     public void serviceImplementationServiceInActive5() throws InterruptedException, ExecutionException {
 432
 433         ServiceImplementationRequestInput input = ServiceDataUtils
 434             .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN);
 435         writePortMapping(input, StringConstants.NETWORK_TOKEN);
 436         Measurements measurements = new MeasurementsBuilder().setPmparameterName("preFECCorrectedErrors")
 437             .setPmparameterValue("112000000000d").build();
 438         List<Measurements> measurementsList = new ArrayList<Measurements>();
 439         measurementsList.add(measurements);
 440         GetPmOutput getPmOutput = new GetPmOutputBuilder()
 441             .setNodeId("node1").setMeasurements(measurementsList).build();
 442
 443         Mockito.doReturn(RpcResultBuilder.success(getPmOutput).buildFuture()).when(this.olmService)
 444             .getPm(Mockito.any());
 445         ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get();
 446         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, result.getConfigurationResponseCommon().getResponseCode());
 447
 448     }
 449 }