Code Review / transportpce.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Bump upstream dependencies to Ca
[transportpce.git] / servicehandler / src / test / java / org / opendaylight / transportpce / servicehandler / impl / ServicehandlerImplTest.java
diff --git a/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java b/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java
index 61141a07c0271b6d024ab72e0fe70011e776b803..a531983138f1183e4691f2106b29e8418ee7494f 100644 (file)
--- a/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java
+++ b/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java
@@ -7,10 +7,7 @@
  */
 package org.opendaylight.transportpce.servicehandler.impl;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -45,6 +42,8 @@ import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOper
 import org.opendaylight.transportpce.servicehandler.listeners.NetworkListener;
 import org.opendaylight.transportpce.servicehandler.listeners.PceListener;
 import org.opendaylight.transportpce.servicehandler.listeners.RendererListener;
+import org.opendaylight.transportpce.servicehandler.service.PCEServiceWrapper;
+import org.opendaylight.transportpce.servicehandler.service.RendererServiceWrapper;
 import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
 import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl;
 import org.opendaylight.transportpce.servicehandler.utils.CatalogDataUtils;
@@ -76,8 +75,6 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.Service
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.ServiceRestorationInput;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.ServiceRestorationInputBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.ServiceRestorationOutput;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.ServiceSrlgGetInputBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.ServiceSrlgGetOutput;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.TempServiceCreateInput;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.TempServiceCreateInputBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev230526.TempServiceCreateOutput;
@@ -94,9 +91,6 @@ import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdes
 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev230501.pce.resource.resource.resource.TerminationPointBuilder;
 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.response.parameters.sp.ResponseParametersBuilder;
 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.response.parameters.sp.response.parameters.PathDescriptionBuilder;
-import org.opendaylight.yangtools.yang.common.ErrorSeverity;
-import org.opendaylight.yangtools.yang.common.ErrorTag;
-import org.opendaylight.yangtools.yang.common.ErrorType;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.common.Uint32;
 
@@ -129,6 +123,8 @@ public class ServicehandlerImplTest extends AbstractTest {
     private ListeningExecutorService executorService;
     private CountDownLatch endSignal;
     private static final int NUM_THREADS = 5;
+    private PCEServiceWrapper pceServiceWrapper;
+    private RendererServiceWrapper rendererServiceWrapper;
 
     @BeforeEach
     void setUp() {
@@ -143,43 +139,43 @@ public class ServicehandlerImplTest extends AbstractTest {
         serviceRestorationInput = ServiceDataUtils.buildServiceRestorationInput();
         serviceRerouteInput = ServiceDataUtils.buildServiceRerouteInput();
         pathDescription = ServiceDataUtils.createPathDescription(0,1,0,1);
+        pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService);
+        this.rendererServiceWrapper = new RendererServiceWrapper(rendererServiceOperations, notificationPublishService);
     }
 
     @Test
     void testRpcRegistration() {
-        new ServicehandlerImpl(rpcProviderService,
-            pathComputationService, rendererServiceOperations, notificationPublishService,
-            pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-            serviceDataStoreOperations, catalogDataStoreOperations);
+        new ServicehandlerImpl(rpcProviderService, serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                networkModelListenerImpl, catalogDataStoreOperations, pathComputationService, rendererServiceOperations,
+                notificationPublishService);
         verify(rpcProviderService, times(1)).registerRpcImplementations(any());
     }
 
-    @Test
-    void testNotImplementedRpc() throws InterruptedException, ExecutionException {
-        ListenableFuture<RpcResult<ServiceSrlgGetOutput>> result = new ServicehandlerImpl(rpcProviderService,
-                pathComputationService, rendererServiceOperations, notificationPublishService,
-                pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                serviceDataStoreOperations, catalogDataStoreOperations)
-            .serviceSrlgGet(new ServiceSrlgGetInputBuilder().build());
-        result.addListener(() -> endSignal.countDown(), executorService);
-        endSignal.await();
-        assertNotNull(result.get());
-        assertFalse(result.get().isSuccessful());
-        assertNull(result.get().getResult());
-        assertEquals(ErrorType.RPC, result.get().getErrors().get(0).getErrorType());
-        assertEquals(ErrorSeverity.ERROR, result.get().getErrors().get(0).getSeverity());
-        assertEquals(ErrorTag.OPERATION_NOT_SUPPORTED, result.get().getErrors().get(0).getTag());
-        assertEquals("RPC not implemented yet", result.get().getErrors().get(0).getMessage());
-    }
+//    @Test
+//    void testNotImplementedRpc() throws InterruptedException, ExecutionException {
+//        ListenableFuture<RpcResult<ServiceSrlgGetOutput>> result = new ServicehandlerImpl(rpcProviderService,
+//                serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
+//                catalogDataStoreOperations, pathComputationService, rendererServiceOperations,
+//                notificationPublishService)
+//            .serviceSrlgGet(new ServiceSrlgGetInputBuilder().build());
+//
+//        result.addListener(() -> endSignal.countDown(), executorService);
+//        endSignal.await();
+//        assertNotNull(result.get());
+//        assertFalse(result.get().isSuccessful());
+//        assertNull(result.get().getResult());
+//        assertEquals(ErrorType.RPC, result.get().getErrors().get(0).getErrorType());
+//        assertEquals(ErrorSeverity.ERROR, result.get().getErrors().get(0).getSeverity());
+//        assertEquals(ErrorTag.OPERATION_NOT_SUPPORTED, result.get().getErrors().get(0).getTag());
+//        assertEquals("RPC not implemented yet", result.get().getErrors().get(0).getMessage());
+//    }
 
     @Test
     void createServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<ServiceCreateOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceCreate(new ServiceCreateInputBuilder().build());
+            new ServiceCreateImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                    networkModelListenerImpl, pceServiceWrapper, notificationPublishService)
+                .invoke(new ServiceCreateInputBuilder().build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -196,11 +192,9 @@ public class ServicehandlerImplTest extends AbstractTest {
                                 .setServiceName(serviceCreateInput.getServiceName())
                                 .build()));
         ListenableFuture<RpcResult<ServiceCreateOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDSOperations, catalogDataStoreOperations)
-                .serviceCreate(serviceCreateInput);
+            new ServiceCreateImpl(serviceDSOperations, pceListenerImpl, rendererListenerImpl,
+                    networkModelListenerImpl, pceServiceWrapper, notificationPublishService)
+                .invoke(serviceCreateInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -212,11 +206,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     void createServiceShouldBeSuccessfulWhenPerformPCESuccessful() throws ExecutionException, InterruptedException {
         when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));
         ListenableFuture<RpcResult<ServiceCreateOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceCreate(serviceCreateInput);
+                new ServiceCreateImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, pceServiceWrapper, notificationPublishService)
+                    .invoke(serviceCreateInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -227,16 +219,13 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void deleteServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<ServiceDeleteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceDelete(
-                    new ServiceDeleteInputBuilder()
-                        .setServiceDeleteReqInfo(new ServiceDeleteReqInfoBuilder()
-                                .setServiceName("")
-                                .build())
-                        .build());
+                new ServiceDeleteImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper, notificationPublishService)
+                    .invoke(new ServiceDeleteInputBuilder()
+                            .setServiceDeleteReqInfo(new ServiceDeleteReqInfoBuilder()
+                                    .setServiceName("")
+                                    .build())
+                            .build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -247,11 +236,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void deleteServiceShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<ServiceDeleteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceDelete(serviceDeleteInput);
+                new ServiceDeleteImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper, notificationPublishService)
+                    .invoke(serviceDeleteInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -264,11 +251,9 @@ public class ServicehandlerImplTest extends AbstractTest {
         when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any()));
         serviceDataStoreOperations.createService(serviceCreateInput);
         ListenableFuture<RpcResult<ServiceDeleteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceDelete(serviceDeleteInput);
+                new ServiceDeleteImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper, notificationPublishService)
+                    .invoke(serviceDeleteInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -278,11 +263,10 @@ public class ServicehandlerImplTest extends AbstractTest {
 
     @Test
     void serviceFeasibilityCheckShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
-        ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(rpcProviderService, pathComputationService,
-                rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
-                networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations);
         ListenableFuture<RpcResult<ServiceFeasibilityCheckOutput>> result =
-                servicehandlerImpl.serviceFeasibilityCheck(new ServiceFeasibilityCheckInputBuilder().build());
+                new ServiceFeasibilityCheckImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, pceServiceWrapper)
+                    .invoke(new ServiceFeasibilityCheckInputBuilder().build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -295,11 +279,9 @@ public class ServicehandlerImplTest extends AbstractTest {
             throws ExecutionException, InterruptedException {
         when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));
         ListenableFuture<RpcResult<ServiceFeasibilityCheckOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceFeasibilityCheck(ServiceDataUtils.buildServiceFeasibilityCheckInput());
+                new ServiceFeasibilityCheckImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, pceServiceWrapper)
+                    .invoke(ServiceDataUtils.buildServiceFeasibilityCheckInput());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -310,11 +292,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void serviceReconfigureShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<ServiceReconfigureOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceReconfigure(new ServiceReconfigureInputBuilder().setServiceName("").build());
+                new ServiceReconfigureImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper)
+                    .invoke(new ServiceReconfigureInputBuilder().setServiceName("").build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
     }
@@ -324,11 +304,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     void serviceReconfigureShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {
         //action -> service reconfigure
         ListenableFuture<RpcResult<ServiceReconfigureOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceReconfigure(serviceReconfigureInput);
+                new ServiceReconfigureImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper)
+                    .invoke(serviceReconfigureInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
     }
@@ -342,11 +320,9 @@ public class ServicehandlerImplTest extends AbstractTest {
         //service reconfigure test action
         //ServiceReconfigureInput is created with the same service information that is created before
         ListenableFuture<RpcResult<ServiceReconfigureOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceReconfigure(serviceReconfigureInput);
+                new ServiceReconfigureImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper)
+                    .invoke(serviceReconfigureInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
     }
@@ -354,13 +330,11 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void serviceReRestorationShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<ServiceRestorationOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceRestoration(new ServiceRestorationInputBuilder()
-                .setServiceName("")
-                .build());
+                new ServiceRestorationImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper)
+                    .invoke(new ServiceRestorationInputBuilder()
+                            .setServiceName("")
+                            .build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
     }
@@ -369,11 +343,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     void serviceRestorationShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {
         //action -> service restore
         ListenableFuture<RpcResult<ServiceRestorationOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceRestoration(serviceRestorationInput);
+                new ServiceRestorationImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper)
+                    .invoke(serviceRestorationInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
     }
@@ -387,11 +359,9 @@ public class ServicehandlerImplTest extends AbstractTest {
         //service Restoration test action
         //ServiceRestorationInput is created with the same service information that is created before
         ListenableFuture<RpcResult<ServiceRestorationOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceRestoration(serviceRestorationInput);
+                new ServiceRestorationImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, rendererServiceWrapper)
+                    .invoke(serviceRestorationInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
     }
@@ -399,13 +369,10 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void serviceRerouteShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<ServiceRerouteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceReroute(new ServiceRerouteInputBuilder()
-                .setServiceName("")
-                .build());
+                new ServiceRerouteImpl(serviceDataStoreOperations, pceServiceWrapper)
+                    .invoke(new ServiceRerouteInputBuilder()
+                            .setServiceName("")
+                            .build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -417,11 +384,8 @@ public class ServicehandlerImplTest extends AbstractTest {
     void serviceRerouteShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {
         //action -> service reconfigure
         ListenableFuture<RpcResult<ServiceRerouteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceReroute(serviceRerouteInput);
+                new ServiceRerouteImpl(serviceDataStoreOperations, pceServiceWrapper)
+                    .invoke(serviceRerouteInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -488,11 +452,8 @@ public class ServicehandlerImplTest extends AbstractTest {
                         .build());
         serviceDataStoreOperations.createService(serviceCreateInput);
         ListenableFuture<RpcResult<ServiceRerouteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .serviceReroute(serviceRerouteInput);
+                new ServiceRerouteImpl(serviceDataStoreOperations, pceServiceWrapper)
+                    .invoke(serviceRerouteInput);
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -503,13 +464,11 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void tempServiceDeleteShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<TempServiceDeleteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .tempServiceDelete(new TempServiceDeleteInputBuilder()
-                .setCommonId("")
-                .build());
+                new TempServiceDeleteImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        rendererServiceWrapper)
+                    .invoke(new TempServiceDeleteInputBuilder()
+                            .setCommonId("")
+                            .build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         RpcResult<TempServiceDeleteOutput> rpcResult = result.get();
@@ -524,11 +483,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void tempServiceDeleteShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<TempServiceDeleteOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .tempServiceDelete(ServiceDataUtils.buildTempServiceDeleteInput());
+                new TempServiceDeleteImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        rendererServiceWrapper)
+                    .invoke(ServiceDataUtils.buildTempServiceDeleteInput());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -543,11 +500,9 @@ public class ServicehandlerImplTest extends AbstractTest {
         TempServiceCreateInput createInput = ServiceDataUtils.buildTempServiceCreateInput();
         serviceDataStoreOperations.createTempService(createInput, pathDescription);
         ListenableFuture<RpcResult<TempServiceDeleteOutput>> result =
-                new ServicehandlerImpl(rpcProviderService,
-                        pathComputationService, rendererServiceOperations, notificationPublishService,
-                        pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                        serviceDataStoreOperations, catalogDataStoreOperations)
-                    .tempServiceDelete(ServiceDataUtils.buildTempServiceDeleteInput(createInput.getCommonId()));
+                new TempServiceDeleteImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        rendererServiceWrapper)
+                    .invoke(ServiceDataUtils.buildTempServiceDeleteInput(createInput.getCommonId()));
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -558,11 +513,9 @@ public class ServicehandlerImplTest extends AbstractTest {
     @Test
     void tempServiceCreateShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<TempServiceCreateOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .tempServiceCreate(new TempServiceCreateInputBuilder().build());
+                new TempServiceCreateImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, pceServiceWrapper)
+                    .invoke(new TempServiceCreateInputBuilder().build());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -580,11 +533,9 @@ public class ServicehandlerImplTest extends AbstractTest {
                         .setCommonId("bad_commonId")
                         .build()));
         ListenableFuture<RpcResult<TempServiceCreateOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDSOperations, catalogDataStoreOperations)
-                .tempServiceCreate(ServiceDataUtils.buildTempServiceCreateInput());
+                new TempServiceCreateImpl(serviceDSOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, pceServiceWrapper)
+                    .invoke(ServiceDataUtils.buildTempServiceCreateInput());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -600,11 +551,9 @@ public class ServicehandlerImplTest extends AbstractTest {
             throws ExecutionException, InterruptedException {
         when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));
         ListenableFuture<RpcResult<TempServiceCreateOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .tempServiceCreate(ServiceDataUtils.buildTempServiceCreateInput());
+                new TempServiceCreateImpl(serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
+                        networkModelListenerImpl, pceServiceWrapper)
+                    .invoke(ServiceDataUtils.buildTempServiceCreateInput());
         result.addListener(() -> endSignal.countDown(), executorService);
         endSignal.await();
         assertEquals(
@@ -616,11 +565,8 @@ public class ServicehandlerImplTest extends AbstractTest {
     public void addOpenroadmOperationalModesToCatalogShouldBeFailedWithEmptyInput()
             throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<AddOpenroadmOperationalModesToCatalogOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .addOpenroadmOperationalModesToCatalog(new AddOpenroadmOperationalModesToCatalogInputBuilder().build());
+                new AddOpenroadmOperationalModesToCatalogImpl(catalogDataStoreOperations)
+                    .invoke(new AddOpenroadmOperationalModesToCatalogInputBuilder().build());
         Assert.assertEquals(
             ResponseCodes.RESPONSE_FAILED,
             result.get().getResult().getConfigurationResponseCommon().getResponseCode());
@@ -630,11 +576,8 @@ public class ServicehandlerImplTest extends AbstractTest {
     public void addSpecificOperationalModesToCatalogShouldBeFailedWithEmptyInput()
             throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<AddSpecificOperationalModesToCatalogOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .addSpecificOperationalModesToCatalog(new AddSpecificOperationalModesToCatalogInputBuilder().build());
+                new AddSpecificOperationalModesToCatalogImpl(catalogDataStoreOperations)
+                    .invoke(new AddSpecificOperationalModesToCatalogInputBuilder().build());
         Assert.assertEquals(
             ResponseCodes.RESPONSE_FAILED,
             result.get().getResult().getConfigurationResponseCommon().getResponseCode());
@@ -644,11 +587,8 @@ public class ServicehandlerImplTest extends AbstractTest {
     public void addOpenroadmOperationalModesToCatalogShouldBeSuccessfulWhenAddORToCatalog()
             throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<AddOpenroadmOperationalModesToCatalogOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .addOpenroadmOperationalModesToCatalog(CatalogDataUtils.buildAddORToCatalogInput());
+                new AddOpenroadmOperationalModesToCatalogImpl(catalogDataStoreOperations)
+                    .invoke(CatalogDataUtils.buildAddORToCatalogInput());
         Assert.assertEquals(
             ResponseCodes.RESPONSE_OK,
             result.get().getResult().getConfigurationResponseCommon().getResponseCode());
@@ -658,11 +598,8 @@ public class ServicehandlerImplTest extends AbstractTest {
     public void addSpecificOperationalModesToCatalogShouldBeSuccessfulWhenAddSpecificToCatalog()
             throws ExecutionException, InterruptedException {
         ListenableFuture<RpcResult<AddSpecificOperationalModesToCatalogOutput>> result =
-            new ServicehandlerImpl(rpcProviderService,
-                    pathComputationService, rendererServiceOperations, notificationPublishService,
-                    pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
-                    serviceDataStoreOperations, catalogDataStoreOperations)
-                .addSpecificOperationalModesToCatalog(CatalogDataUtils.buildAddSpecificToCatalogInput());
+                new AddSpecificOperationalModesToCatalogImpl(catalogDataStoreOperations)
+                    .invoke(CatalogDataUtils.buildAddSpecificToCatalogInput());
         Assert.assertEquals(
             ResponseCodes.RESPONSE_OK,
             result.get().getResult().getConfigurationResponseCommon().getResponseCode());
Repository for Transport PCE project.