From: Martial COULIBALY Date: Tue, 3 Jul 2018 14:19:51 +0000 (+0200) Subject: Functional Tests for servicehandler X-Git-Tag: v0.2.0~43 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=transportpce.git;a=commitdiff_plain;h=4cc1311401e31d5720fed8e3ab5cd4403403304a Functional Tests for servicehandler These tests verify the servicehandler RPCs service-create and service-delete. Some tests have been (temporarily) disabled because a few RPCs are no more available following the ServicePath downgrade from 1.6 to 1.5 : cf change 72037 'ServiceHandler update for new PCE compatibility' Change-Id: Ib57a35aef9cd89fc7b3e26bbd43d6a5195e5d533 Signed-off-by: Martial COULIBALY --- diff --git a/tests/SH_func_tests.sh b/tests/SH_func_tests.sh new file mode 100755 index 000000000..4b7b597ad --- /dev/null +++ b/tests/SH_func_tests.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +(cd .. && git apply tests/SH_stubs.diff && mvn clean install -DskipTests) +(cd .. && git checkout .) + +exit $? diff --git a/tests/SH_stubs.diff b/tests/SH_stubs.diff new file mode 100644 index 000000000..7240fcd0e --- /dev/null +++ b/tests/SH_stubs.diff @@ -0,0 +1,791 @@ +diff --git a/servicehandler/pom.xml b/servicehandler/pom.xml +index 43085f6..8a9699a 100644 +--- a/servicehandler/pom.xml ++++ b/servicehandler/pom.xml +@@ -67,6 +67,11 @@ Author: Martial Coulibaly on behalf of Orange + transportpce-pce + ${project.version} + ++ ++ ${project.groupId} ++ transportpce-stubrenderer ++ ${project.version} ++ + + + +diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java +index 2b0ee83..2899617 100644 +--- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java ++++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java +@@ -7,8 +7,6 @@ + */ + package org.opendaylight.transportpce.servicehandler; + +-import java.util.ArrayList; +-import java.util.List; + import java.util.concurrent.Future; + import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev170426.PathComputationRequestOutput; + import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev170426.path.computation.request.input.ServiceAEnd; +@@ -18,8 +16,6 @@ import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev17 + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.configuration.response.common.ConfigurationResponseCommon; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.configuration.response.common.ConfigurationResponseCommonBuilder; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.response.parameters.ResponseParametersBuilder; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.service.Topology; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.service.TopologyBuilder; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.LifecycleState; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.State; + import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.ServiceCreateInput; +@@ -31,12 +27,6 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.Service + import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.ServiceReconfigureInput; + import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.service.list.Services; + import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.service.list.ServicesBuilder; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.AToZ; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.AToZBuilder; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.AToZKey; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.ZToA; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.ZToABuilder; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.ZToAKey; + import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.routing.constraints.sp.HardConstraintsBuilder; + import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.routing.constraints.sp.SoftConstraintsBuilder; + import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.service.endpoint.sp.RxDirection; +@@ -237,42 +227,6 @@ public final class ModelMappingUtils { + .setSoftConstraints(serviceReconfigureInput.getSoftConstraints()) + .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend); + } +- +- org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.response +- .parameters.sp.ResponseParameters responseParameters = output.getResponseParameters(); +- if (responseParameters != null) { +- // service.setPceMetric(responseParameters.getPceMetric()); +- org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426 +- .response.parameters.sp.response.parameters.PathDescription pathDescription = +- responseParameters.getPathDescription(); +- if (pathDescription != null) { +- List atozList = new ArrayList<>(); +- List ztoaList = new ArrayList<>(); +- +- for (org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev170426 +- .path.description.atoz.direction.AToZ tmp : pathDescription.getAToZDirection().getAToZ()) { +- +- AToZKey key = new AToZKey(tmp.getKey().getId()); +- AToZ atoz = new AToZBuilder().setId(tmp.getId()).setKey(key) +- // .setResource(tmp.getResource()) +- .build(); +- atozList.add(atoz); +- } +- +- for (org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev170426 +- .path.description.ztoa.direction.ZToA +- tmp : pathDescription.getZToADirection().getZToA()) { +- ZToAKey key = new ZToAKey(tmp.getKey().getId()); +- ZToA ztoa = new ZToABuilder().setId(tmp.getId()).setKey(key) +- // .setResource(tmp.getResource()) +- .build(); +- ztoaList.add(ztoa); +- } +- +- Topology topology = new TopologyBuilder().setAToZ(atozList).setZToA(ztoaList).build(); +- service.setTopology(topology); +- } +- } + return service.build(); + } + +diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java +index 5dc24b3..714e2b3 100644 +--- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java ++++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java +@@ -12,7 +12,6 @@ import java.time.format.DateTimeFormatter; + import java.util.Optional; + import java.util.concurrent.ExecutionException; + import java.util.concurrent.Future; +- + import org.opendaylight.controller.md.sal.binding.api.DataBroker; + import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; + import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +@@ -27,6 +26,7 @@ import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOper + import org.opendaylight.transportpce.servicehandler.validation.ServiceCreateValidation; + import org.opendaylight.transportpce.servicehandler.validation.checks.ComplianceCheckResult; + import org.opendaylight.transportpce.servicehandler.validation.checks.ServicehandlerCompliancyCheck; ++import org.opendaylight.transportpce.stubrenderer.SendingRendererRPCs; + import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev170426.PathComputationRequestOutput; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.RpcActions; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.sdnc.request.header.SdncRequestHeaderBuilder; +@@ -89,6 +89,7 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { + private ServiceDataStoreOperations serviceDataStoreOperations; + private RendererServiceOperations rendererServiceOperations; + private PCEServiceWrapper pceServiceWrapper; ++ private SendingRendererRPCs stubrendererService; + + //TODO: remove private request fields as they are in global scope + +@@ -145,8 +146,12 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { + + ServiceImplementationRequestInput serviceImplementationRequest = + ModelMappingUtils.createServiceImplementationRequest(input, pceResponse); ++// org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426 ++// .ServiceImplementationRequestOutput serviceImplementationRequestOutput = this.rendererServiceOperations ++// .serviceImplementation(serviceImplementationRequest); ++ this.stubrendererService = new SendingRendererRPCs(); + org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426 +- .ServiceImplementationRequestOutput serviceImplementationRequestOutput = this.rendererServiceOperations ++ .ServiceImplementationRequestOutput serviceImplementationRequestOutput = this.stubrendererService + .serviceImplementation(serviceImplementationRequest); + if (ResponseCodes.RESPONSE_OK + .equals(serviceImplementationRequestOutput.getConfigurationResponseCommon().getResponseCode())) { +@@ -215,9 +220,11 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { + LOG.debug("Service '{}' present in datastore !", serviceName); + org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteInput + serviceDeleteInput = ModelMappingUtils.createServiceDeleteInput(input); ++// org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426 ++// .ServiceDeleteOutput output = this.rendererServiceOperations.serviceDelete(serviceDeleteInput); ++ this.stubrendererService = new SendingRendererRPCs(); + org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426 +- .ServiceDeleteOutput output = this.rendererServiceOperations.serviceDelete(serviceDeleteInput); +- ++ .ServiceDeleteOutput output = this.stubrendererService.serviceDelete(serviceDeleteInput); + if (!ResponseCodes.RESPONSE_OK + .equals(output.getConfigurationResponseCommon().getResponseCode())) { + message = "Service delete failed!"; +diff --git a/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java b/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java +index 6db468c..76e4a26 100644 +--- a/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java ++++ b/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java +@@ -9,13 +9,8 @@ package org.opendaylight.transportpce.servicehandler.stub; + + import java.util.concurrent.ExecutionException; + import java.util.concurrent.Future; +- + import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; + import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; +-import org.opendaylight.transportpce.servicehandler.mappers.ServiceDeleteInputConverter; +-import org.opendaylight.transportpce.servicehandler.mappers.ServiceDeleteOutputConverter; +-import org.opendaylight.transportpce.servicehandler.mappers.ServiceImplementationRequestInputConverter; +-import org.opendaylight.transportpce.servicehandler.mappers.ServiceImplementationRequestOutputConverter; + import org.opendaylight.transportpce.stubrenderer.impl.StubrendererImpl; + import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteInput; + import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteOutput; +@@ -30,16 +25,15 @@ public class StubRendererServiceOperations implements RendererServiceOperations + private StubrendererImpl stubrenderer; + + public StubRendererServiceOperations(NotificationPublishService notificationPublishService) { +- this.stubrenderer = new StubrendererImpl(notificationPublishService); ++ this.stubrenderer = new StubrendererImpl(); + } + + @Override + public ServiceImplementationRequestOutput serviceImplementation(ServiceImplementationRequestInput input) { +- Future> rpcResultFuture = this.stubrenderer +- .serviceImplementationRequest(ServiceImplementationRequestInputConverter.getStub(input)); ++ Future> rpcResultFuture = this.stubrenderer ++ .serviceImplementationRequest(input); + try { +- return ServiceImplementationRequestOutputConverter.getConcrete(rpcResultFuture.get().getResult()); ++ return rpcResultFuture.get().getResult(); + } catch (InterruptedException e) { + LOG.error("RPC serviceImplementation failed !",e); + } catch (ExecutionException e) { +@@ -50,11 +44,10 @@ public class StubRendererServiceOperations implements RendererServiceOperations + + @Override + public ServiceDeleteOutput serviceDelete(ServiceDeleteInput input) { +- Future> rpcResultFuture = this.stubrenderer +- .serviceDelete(ServiceDeleteInputConverter.getStub(input)); ++ Future> rpcResultFuture = this.stubrenderer ++ .serviceDelete(input); + try { +- return ServiceDeleteOutputConverter.getConcrete(rpcResultFuture.get().getResult()); ++ return rpcResultFuture.get().getResult(); + } catch (InterruptedException e) { + LOG.error("RPC serviceDelete failed !",e); + } catch (ExecutionException e) { +diff --git a/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/SendingRendererRPCs.java b/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/SendingRendererRPCs.java +index cdcdc0e..7c7a825 100644 +--- a/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/SendingRendererRPCs.java ++++ b/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/SendingRendererRPCs.java +@@ -8,16 +8,18 @@ + + package org.opendaylight.transportpce.stubrenderer; + +-import com.google.common.util.concurrent.ListenableFuture; +-import com.google.common.util.concurrent.ListeningExecutorService; +- + import java.util.ArrayList; + import java.util.List; +-import java.util.concurrent.Callable; +- ++import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.configuration.response.common.ConfigurationResponseCommonBuilder; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.service.TopologyBuilder; + import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.AToZ; + import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev161014.topology.ZToA; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteInput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteOutput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteOutputBuilder; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceImplementationRequestInput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceImplementationRequestOutput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceImplementationRequestOutputBuilder; + import org.slf4j.Logger; + import org.slf4j.LoggerFactory; + +@@ -41,73 +43,78 @@ public class SendingRendererRPCs { + private List atoz; + private List ztoa; + private String error; +- private final ListeningExecutorService executor; + +- public SendingRendererRPCs(ListeningExecutorService executor) { +- success = true; ++ public SendingRendererRPCs() { ++ this.success = true; + setTopology(null); +- this.executor = executor; + setError(""); + } + + private void buildAtoZ() { +- atoz = new ArrayList(); ++ this.atoz = new ArrayList(); + } + + private void buildZtoA() { +- ztoa = new ArrayList(); ++ this.ztoa = new ArrayList(); + } + +- public ListenableFuture serviceDelete() { ++ public ServiceDeleteOutput serviceDelete(ServiceDeleteInput input) { ++ String message = "Service deleted !"; ++ String responseCode = "200"; + LOG.info("ServiceDelete request ..."); +- success = false; +- return executor.submit(new Callable() { +- @Override +- public Boolean call() throws Exception { +- Boolean output = true; +- LOG.info("Wait for 10s til beginning the Renderer serviceDelete request"); +- try { +- Thread.sleep(10000); //sleep for 10s +- } catch (InterruptedException e) { +- output = false; +- LOG.error("Thread.sleep failed : {}", e.toString()); +- } +- buildAtoZ(); +- buildZtoA(); +- success = true; +- return output; +- } +- }); ++ LOG.info("Wait for 10s til beginning the Renderer serviceDelete request"); ++ try { ++ Thread.sleep(1000); //sleep for 10s ++ } catch (InterruptedException e) { ++ message = "deleting service failed !"; ++ LOG.error(message); ++ responseCode = "500"; ++ setError(message); ++ } ++ ConfigurationResponseCommonBuilder configurationResponseCommon = new ConfigurationResponseCommonBuilder() ++ .setAckFinalIndicator("yes") ++ .setRequestId(input.getServiceHandlerHeader().getRequestId()) ++ .setResponseCode(responseCode) ++ .setResponseMessage(message); ++ ServiceDeleteOutput output = new ServiceDeleteOutputBuilder() ++ .setConfigurationResponseCommon(configurationResponseCommon.build()) ++ .build(); ++ return output; + } + +- public ListenableFuture serviceImplementation() { ++ public ServiceImplementationRequestOutput serviceImplementation(ServiceImplementationRequestInput input) { ++ String message = "Service implemented !"; ++ String responseCode = "200"; ++ setSuccess(true); + LOG.info("serviceImplementation request ..."); +- success = false; +- return executor.submit(new Callable() { +- @Override +- public Boolean call() throws Exception { +- Boolean output = true; +- LOG.info("Wait for 10s til beginning the Renderer serviceDelete request"); +- try { +- Thread.sleep(10000); //sleep for 10s +- } catch (InterruptedException e) { +- output = false; +- LOG.error("Thread.sleep failed : {}", e.toString()); +- } +- buildAtoZ(); +- buildZtoA(); +- setTopology(new TopologyBuilder() +- .setAToZ(atoz) +- .setZToA(ztoa)); +- output = true; +- success = true; +- return output; +- } +- }); ++ LOG.info("Wait for 10s til beginning the Renderer serviceDelete request"); ++ try { ++ Thread.sleep(2000); //sleep for 1s ++ } catch (InterruptedException e) { ++ message = "implementing service failed !"; ++ LOG.error(message); ++ setError(message); ++ responseCode = "500"; ++ setSuccess(false); ++ } ++ buildAtoZ(); ++ buildZtoA(); ++ setTopology(new TopologyBuilder() ++ .setAToZ(SendingRendererRPCs.this.atoz) ++ .setZToA(SendingRendererRPCs.this.ztoa)); ++ ConfigurationResponseCommonBuilder configurationResponseCommon = new ConfigurationResponseCommonBuilder() ++ .setAckFinalIndicator("yes") ++ .setRequestId(input.getServiceHandlerHeader().getRequestId()) ++ .setResponseCode(responseCode) ++ .setResponseMessage(message); ++ ServiceImplementationRequestOutput output = new ServiceImplementationRequestOutputBuilder() ++ .setConfigurationResponseCommon(configurationResponseCommon.build()) ++ .build(); ++ return output; + } + + public Boolean getSuccess() { +- return success; ++ return this.success; + } + + public void setSuccess(Boolean success) { +@@ -115,7 +122,7 @@ public class SendingRendererRPCs { + } + + public TopologyBuilder getTopology() { +- return topology; ++ return this.topology; + } + + public void setTopology(TopologyBuilder topo) { +@@ -123,7 +130,7 @@ public class SendingRendererRPCs { + } + + public String getError() { +- return error; ++ return this.error; + } + + public void setError(String error) { +diff --git a/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererImpl.java b/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererImpl.java +index 23ae976..4187f96 100644 +--- a/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererImpl.java ++++ b/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererImpl.java +@@ -9,33 +9,21 @@ + + package org.opendaylight.transportpce.stubrenderer.impl; + +-import com.google.common.util.concurrent.FutureCallback; +-import com.google.common.util.concurrent.Futures; +-import com.google.common.util.concurrent.ListenableFuture; +-import com.google.common.util.concurrent.ListeningExecutorService; +-import com.google.common.util.concurrent.MoreExecutors; +- +-import java.util.concurrent.Executors; + import java.util.concurrent.Future; +- +-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; + import org.opendaylight.transportpce.stubrenderer.SendingRendererRPCs; + import org.opendaylight.transportpce.stubrenderer.StubrendererCompliancyCheck; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceDeleteInput; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceDeleteOutput; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceDeleteOutputBuilder; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceImplementationRequestInput; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceImplementationRequestOutput; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceImplementationRequestOutputBuilder; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceRpcResultSp; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.ServiceRpcResultSpBuilder; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.StubrendererService; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.service.rpc.result.sp.PathTopology; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.service.rpc.result.sp.PathTopologyBuilder; + import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.configuration.response.common.ConfigurationResponseCommonBuilder; +-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.service.TopologyBuilder; +-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.RpcStatusEx; +-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.ServicePathNotificationTypes; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.CancelResourceReserveInput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.CancelResourceReserveOutput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.PathComputationRequestInput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.PathComputationRequestOutput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteInput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteOutput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceDeleteOutputBuilder; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceImplementationRequestInput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceImplementationRequestOutput; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.ServiceImplementationRequestOutputBuilder; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.TransportpceServicepathService; + import org.opendaylight.yangtools.yang.common.RpcResult; + import org.opendaylight.yangtools.yang.common.RpcResultBuilder; + import org.slf4j.Logger; +@@ -48,21 +36,12 @@ import org.slf4j.LoggerFactory; + * @author Martial Coulibaly ( martial.coulibaly@gfi.com ) on behalf of Orange + * + */ +-public class StubrendererImpl implements StubrendererService { ++public class StubrendererImpl implements TransportpceServicepathService { + /** Logging. */ + private static final Logger LOG = LoggerFactory.getLogger(StubrendererImpl.class); +- /** send notification. */ +- private NotificationPublishService notificationPublishService; +- private ServiceRpcResultSp notification; +- private final ListeningExecutorService executor = MoreExecutors +- .listeningDecorator(Executors.newFixedThreadPool(10)); + /** check service sdnc-request-header compliancy. */ + private StubrendererCompliancyCheck compliancyCheck; + +- public StubrendererImpl(NotificationPublishService notificationPublishService) { +- this.notificationPublishService = notificationPublishService; +- } +- + @Override + public Future> serviceImplementationRequest( + ServiceImplementationRequestInput input) { +@@ -71,121 +50,37 @@ public class StubrendererImpl implements StubrendererService { + String message = ""; + ConfigurationResponseCommonBuilder configurationResponseCommon = null; + +- compliancyCheck = new StubrendererCompliancyCheck(input.getServiceName(), input.getServiceHandlerHeader()); +- if (compliancyCheck.check(false, true)) { ++ this.compliancyCheck = new StubrendererCompliancyCheck(input.getServiceName(), input.getServiceHandlerHeader()); ++ if (this.compliancyCheck.check(false, true)) { + LOG.info("Service compliant !"); + /** + * If compliant, service-request parameters are verified in order to + * check if there is no missing parameter that prevents calculating + * a path and implement a service. + */ +- +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceImplementationRequest) +- .setServiceName(input.getServiceName()) +- .setStatus(RpcStatusEx.Pending) +- .setStatusMessage("Service compliant, submitting serviceImplementation Request ...") +- .build(); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); ++ SendingRendererRPCs sendingRenderer = new SendingRendererRPCs(); ++ sendingRenderer.serviceImplementation(input); ++ if (sendingRenderer.getSuccess()) { ++ message = "Service implemented !"; ++ LOG.info(message); ++ responseCode = "200"; ++ } else { ++ message = "Service implementation failed : " + sendingRenderer.getError(); ++ LOG.error(message); ++ responseCode = "500"; + } +- +- SendingRendererRPCs sendingRenderer = new SendingRendererRPCs(executor); +- FutureCallback rendererCallback = +- new FutureCallback() { +- String message = ""; +- ServiceRpcResultSp notification = null; +- +- @Override +- public void onFailure(Throwable arg0) { +- LOG.error("Failure message : {}", arg0.toString()); +- LOG.error("Service implementation failed !"); +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceImplementationRequest) +- .setServiceName(input.getServiceName()).setStatus(RpcStatusEx.Failed) +- .setStatusMessage("PCR Request failed : {}" + arg0.getMessage()).build(); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); +- } +- } +- +- @Override +- public void onSuccess(Boolean response) { +- LOG.info("response : {}", response); +- if (response) { +- message = "Service implemented !"; +- TopologyBuilder topo = sendingRenderer.getTopology(); +- ServiceRpcResultSpBuilder tmp = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceImplementationRequest) +- .setServiceName(input.getServiceName()) +- .setStatus(RpcStatusEx.Successful) +- .setStatusMessage(message); +- if (topo != null) { +- PathTopology value = new PathTopologyBuilder() +- .setAToZ(topo.getAToZ()) +- .setZToA(topo.getZToA()) +- .build(); +- tmp.setPathTopology(value); +- } +- notification = tmp.build(); +- } else { +- message = "Service implementation failed : " + sendingRenderer.getError(); +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceImplementationRequest) +- .setServiceName("") +- .setStatus(RpcStatusEx.Failed).setStatusMessage(message) +- .build(); +- } +- LOG.info(notification.toString()); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); +- } +- LOG.info(message); +- } +- }; +- ListenableFuture renderer = sendingRenderer.serviceImplementation(); +- Futures.addCallback(renderer, rendererCallback, executor); +- LOG.info("Service implmentation Request in progress "); +- configurationResponseCommon = new ConfigurationResponseCommonBuilder() +- .setAckFinalIndicator("Yes") +- .setRequestId(input.getServiceHandlerHeader().getRequestId()) +- .setResponseCode("200") +- .setResponseMessage("Service implementation Request in progress "); +- +- ServiceImplementationRequestOutput output = new ServiceImplementationRequestOutputBuilder() +- .setConfigurationResponseCommon(configurationResponseCommon.build()) +- .build(); +- return RpcResultBuilder.success(output).buildFuture(); + } else { +- message = compliancyCheck.getMessage(); ++ message = "Service not compliant"; + responseCode = "500"; +- LOG.info("Service not compliant caused by : {}", message); +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceDelete) +- .setServiceName(input.getServiceName()).setStatus(RpcStatusEx.Failed) +- .setStatusMessage("Service not compliant caused by : " + message) +- .build(); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); +- } + } + configurationResponseCommon = new ConfigurationResponseCommonBuilder() +- .setAckFinalIndicator("yes") +- .setRequestId(input.getServiceHandlerHeader().getRequestId()) +- .setResponseCode(responseCode) +- .setResponseMessage(message); ++ .setAckFinalIndicator("yes") ++ .setRequestId(input.getServiceHandlerHeader().getRequestId()) ++ .setResponseCode(responseCode) ++ .setResponseMessage(message); + ServiceImplementationRequestOutput output = new ServiceImplementationRequestOutputBuilder() +- .setConfigurationResponseCommon(configurationResponseCommon.build()) +- .build(); +- ++ .setConfigurationResponseCommon(configurationResponseCommon.build()) ++ .build(); + return RpcResultBuilder.success(output).buildFuture(); + } + +@@ -195,108 +90,55 @@ public class StubrendererImpl implements StubrendererService { + LOG.info("RPC serviceDelete request received"); + String responseCode = ""; + ConfigurationResponseCommonBuilder configurationResponseCommon = null; +- compliancyCheck = new StubrendererCompliancyCheck(input.getServiceName(), input.getServiceHandlerHeader()); +- if (compliancyCheck.check(false, true)) { ++ this.compliancyCheck = new StubrendererCompliancyCheck(input.getServiceName(), input.getServiceHandlerHeader()); ++ if (this.compliancyCheck.check(false, true)) { + LOG.info("Service compliant !"); + /** + * If compliant, service-request parameters are verified in order to + * check if there is no missing parameter that prevents calculating + * a path and implement a service. + */ +- +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceDelete) +- .setServiceName(input.getServiceName()) +- .setStatus(RpcStatusEx.Pending) +- .setStatusMessage("Service compliant, submitting serviceDelete Request ...") +- .build(); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); ++ SendingRendererRPCs sendingRenderer = new SendingRendererRPCs(); ++ sendingRenderer.serviceDelete(input); ++ if (sendingRenderer.getSuccess()) { ++ message = "Service deleted !"; ++ responseCode = "200"; ++ LOG.info(message); ++ } else { ++ message = "Service implementation failed : " + sendingRenderer.getError(); ++ LOG.error(message); ++ responseCode = "500"; + } +- SendingRendererRPCs sendingRenderer = new SendingRendererRPCs(executor); +- FutureCallback rendererCallback = new FutureCallback() { +- String message = ""; +- ServiceRpcResultSp notification = null; +- +- @Override +- public void onFailure(Throwable arg0) { +- LOG.error("Failure message : {}", arg0.toString()); +- LOG.error("Service delete failed !"); +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceDelete) +- .setServiceName(input.getServiceName()).setStatus(RpcStatusEx.Failed) +- .setStatusMessage("PCR Request failed : " + arg0.getMessage()).build(); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); +- } +- } +- +- @Override +- public void onSuccess(Boolean response) { +- LOG.info("response : {}", response); +- if (response) { +- message = "Service deleted !"; +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceDelete) +- .setServiceName(input.getServiceName()).setStatus(RpcStatusEx.Successful) +- .setStatusMessage(message).build(); +- } else { +- message = "Service delete failed : " + sendingRenderer.getError(); +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceDelete) +- .setServiceName("") +- .setStatus(RpcStatusEx.Failed).setStatusMessage(message) +- .build(); +- } +- LOG.info(notification.toString()); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); +- } +- LOG.info(message); +- } +- }; +- ListenableFuture renderer = sendingRenderer.serviceDelete(); +- Futures.addCallback(renderer, rendererCallback, executor); +- message = "Service delete Request in progress ..."; +- LOG.info(message); +- configurationResponseCommon = new ConfigurationResponseCommonBuilder() +- .setAckFinalIndicator("Yes") +- .setRequestId(input.getServiceHandlerHeader().getRequestId()) +- .setResponseCode("200") +- .setResponseMessage(message); +- ServiceDeleteOutput output = new ServiceDeleteOutputBuilder() +- .setConfigurationResponseCommon(configurationResponseCommon.build()) +- .build(); +- return RpcResultBuilder.success(output).buildFuture(); + } else { +- message = compliancyCheck.getMessage(); +- LOG.info("Service not compliant caused by : {}", message); ++ message = "Service not compliant"; + responseCode = "500"; +- notification = new ServiceRpcResultSpBuilder() +- .setNotificationType(ServicePathNotificationTypes.ServiceDelete) +- .setServiceName(input.getServiceName()).setStatus(RpcStatusEx.Failed) +- .setStatusMessage("Service not compliant caused by : " + message) +- .build(); +- try { +- notificationPublishService.putNotification(notification); +- } catch (InterruptedException e) { +- LOG.info("notification offer rejected : {}", e); +- } + } + configurationResponseCommon = new ConfigurationResponseCommonBuilder() +- .setAckFinalIndicator("yes") +- .setRequestId(input.getServiceHandlerHeader().getRequestId()) +- .setResponseCode(responseCode) +- .setResponseMessage(message); ++ .setAckFinalIndicator("yes") ++ .setRequestId(input.getServiceHandlerHeader().getRequestId()) ++ .setResponseCode(responseCode) ++ .setResponseMessage(message); + ServiceDeleteOutput output = new ServiceDeleteOutputBuilder() +- .setConfigurationResponseCommon(configurationResponseCommon.build()) +- .build(); ++ .setConfigurationResponseCommon(configurationResponseCommon.build()) ++ .build(); + return RpcResultBuilder.success(output).buildFuture(); + } ++ ++ /* (non-Javadoc) ++ * @see org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.TransportpceServicepathService#cancelResourceReserve(org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.CancelResourceReserveInput) ++ */ ++ @Override ++ public Future> cancelResourceReserve(CancelResourceReserveInput input) { ++ // TODO Auto-generated method stub ++ return null; ++ } ++ ++ /* (non-Javadoc) ++ * @see org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.TransportpceServicepathService#pathComputationRequest(org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.PathComputationRequestInput) ++ */ ++ @Override ++ public Future> pathComputationRequest(PathComputationRequestInput input) { ++ // TODO Auto-generated method stub ++ return null; ++ } + } +diff --git a/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererProvider.java b/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererProvider.java +index 6dcdb8e..92b20f5 100644 +--- a/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererProvider.java ++++ b/tests/stubrenderer/src/main/java/org/opendaylight/transportpce/stubrenderer/impl/StubrendererProvider.java +@@ -13,9 +13,7 @@ import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService + import org.opendaylight.controller.md.sal.binding.api.NotificationService; + import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; + import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.StubrendererListener; +-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubrenderer.rev170426.StubrendererService; +-import org.opendaylight.yangtools.concepts.ListenerRegistration; ++import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev170426.TransportpceServicepathService; + import org.slf4j.Logger; + import org.slf4j.LoggerFactory; + +@@ -27,17 +25,13 @@ import org.slf4j.LoggerFactory; + public class StubrendererProvider { + private static final Logger LOG = LoggerFactory.getLogger(StubrendererProvider.class); + private final RpcProviderRegistry rpcRegistry; +- private final NotificationPublishService notificationPublishService; + +- +- private BindingAwareBroker.RpcRegistration rpcRegistration; +- private ListenerRegistration stubRendererlistenerRegistration; ++ private BindingAwareBroker.RpcRegistration rpcRegistration; + + public StubrendererProvider(RpcProviderRegistry rpcProviderRegistry, + NotificationService notificationService, + NotificationPublishService notificationPublishService) { + this.rpcRegistry = rpcProviderRegistry; +- this.notificationPublishService = notificationPublishService; + } + + /** +@@ -45,8 +39,8 @@ public class StubrendererProvider { + */ + public void init() { + LOG.info("StubrendererProvider Session Initiated"); +- final StubrendererImpl consumer = new StubrendererImpl(notificationPublishService); +- rpcRegistration = rpcRegistry.addRpcImplementation(StubrendererService.class, consumer); ++ final StubrendererImpl consumer = new StubrendererImpl(); ++ this.rpcRegistration = this.rpcRegistry.addRpcImplementation(TransportpceServicepathService.class, consumer); + } + + /** +@@ -54,7 +48,6 @@ public class StubrendererProvider { + */ + public void close() { + LOG.info("StubrendererProvider Closed"); +- rpcRegistration.close(); +- stubRendererlistenerRegistration.close(); ++ this.rpcRegistration.close(); + } + } diff --git a/tests/sample_configs/honeynode-topo.xml b/tests/sample_configs/honeynode-topo.xml new file mode 100644 index 000000000..948acbb9c --- /dev/null +++ b/tests/sample_configs/honeynode-topo.xml @@ -0,0 +1,2290 @@ + + openroadm-topology + + ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX + ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX + + DEG1-CTP-TXRX + ROADMA-DEG1 + + + ROADMA-DEG2 + DEG2-CTP-TXRX + + EXPRESS-LINK + + + ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX + ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX + + DEG2-CTP-TXRX + ROADMC-DEG2 + + + ROADMC-SRG1 + SRG1-CP-TXRX + + ADD-LINK + + + ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX + ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX + + DEG1-CTP-TXRX + ROADMA-DEG1 + + + ROADMA-SRG1 + SRG1-CP-TXRX + + ADD-LINK + + + XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX + ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1 + + SRG1-PP1-TXRX + ROADMA-SRG1 + + + XPDRA-XPDR1 + XPDR1-NETWORK1 + + XPONDER-OUTPUT + + + ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX + ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX + + DEG2-CTP-TXRX + ROADMA-DEG2 + + + ROADMA-DEG1 + DEG1-CTP-TXRX + + EXPRESS-LINK + + + ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX + ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX + + DEG1-CTP-TXRX + ROADMC-DEG1 + + + ROADMC-DEG2 + DEG2-CTP-TXRX + + EXPRESS-LINK + + + ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX + ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX + + DEG2-CTP-TXRX + ROADMC-DEG2 + + + ROADMC-DEG1 + DEG1-CTP-TXRX + + EXPRESS-LINK + + + ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX + ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX + + SRG1-CP-TXRX + ROADMA-SRG1 + + + ROADMA-DEG1 + DEG1-CTP-TXRX + + DROP-LINK + + + ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX + ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX + + SRG1-CP-TXRX + ROADMA-SRG1 + + + ROADMA-DEG2 + DEG2-CTP-TXRX + + DROP-LINK + + + ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX + ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX + + DEG2-TTP-TXRX + ROADMC-DEG2 + + + ROADMA-DEG1 + DEG1-TTP-TXRX + + + ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX + + ROADM-TO-ROADM + + + ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1 + XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX + + XPDR1-NETWORK1 + XPDRA-XPDR1 + + + ROADMA-SRG1 + SRG1-PP1-TXRX + + XPONDER-INPUT + + + ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX + ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX + + DEG1-TTP-TXRX + ROADMA-DEG1 + + + ROADMC-DEG2 + DEG2-TTP-TXRX + + + ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX + + ROADM-TO-ROADM + + + ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX + ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX + + SRG1-CP-TXRX + ROADMC-SRG1 + + + ROADMC-DEG1 + DEG1-CTP-TXRX + + DROP-LINK + + + ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX + ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX + + DEG1-CTP-TXRX + ROADMC-DEG1 + + + ROADMC-SRG1 + SRG1-CP-TXRX + + ADD-LINK + + + ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX + ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX + + SRG1-CP-TXRX + ROADMC-SRG1 + + + ROADMC-DEG2 + DEG2-CTP-TXRX + + DROP-LINK + + + ROADMC-SRG1-SRG1-PP1-TXRXtoXPDRC-XPDR1-XPDR1-NETWORK1 + XPDRC-XPDR1-XPDR1-NETWORK1toROADMC-SRG1-SRG1-PP1-TXRX + + XPDR1-NETWORK1 + XPDRC-XPDR1 + + + ROADMC-SRG1 + SRG1-PP1-TXRX + + XPONDER-INPUT + + + ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX + ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX + + DEG2-CTP-TXRX + ROADMA-DEG2 + + + ROADMA-SRG1 + SRG1-CP-TXRX + + ADD-LINK + + + XPDRC-XPDR1-XPDR1-NETWORK1toROADMC-SRG1-SRG1-PP1-TXRX + ROADMC-SRG1-SRG1-PP1-TXRXtoXPDRC-XPDR1-XPDR1-NETWORK1 + + SRG1-PP1-TXRX + ROADMC-SRG1 + + + XPDRC-XPDR1 + XPDR1-NETWORK1 + + XPONDER-OUTPUT + + + + + + ROADMC-SRG1 + + SRG1-PP12-TXRX + SRG-TXRX-PP + + + SRG1-PP15-TXRX + SRG-TXRX-PP + + + SRG1-PP1-TXRX + SRG-TXRX-PP + + + SRG1-PP2-TXRX + SRG-TXRX-PP + + + SRG1-CP-TXRX + SRG-TXRX-CP + + + SRG1-PP5-TXRX + SRG-TXRX-PP + + + SRG1-PP8-TXRX + SRG-TXRX-PP + + + SRG1-PP6-TXRX + SRG-TXRX-PP + + + SRG1-PP9-TXRX + SRG-TXRX-PP + + + SRG1-PP3-TXRX + SRG-TXRX-PP + + + SRG1-PP10-TXRX + SRG-TXRX-PP + + + SRG1-PP14-TXRX + SRG-TXRX-PP + + + SRG1-PP16-TXRX + SRG-TXRX-PP + + + SRG1-PP7-TXRX + SRG-TXRX-PP + + + SRG1-PP11-TXRX + SRG-TXRX-PP + + + SRG1-PP13-TXRX + SRG-TXRX-PP + + + SRG1-PP4-TXRX + SRG-TXRX-PP + + + openroadm-network + ROADMC + + + + 93 + + + 94 + + + 95 + + + 96 + + + 29 + + + 30 + + + 31 + + + 32 + + + 33 + + + 34 + + + 35 + + + 36 + + + 37 + + + 38 + + + 39 + + + 40 + + + 41 + + + 42 + + + 43 + + + 44 + + + 45 + + + 46 + + + 47 + + + 48 + + + 49 + + + 50 + + + 51 + + + 52 + + + 53 + + + 54 + + + 55 + + + 56 + + + 57 + + + 58 + + + 59 + + + 60 + + + 61 + + + 62 + + + 63 + + + 64 + + + 65 + + + 66 + + + 67 + + + 68 + + + 69 + + + 70 + + + 71 + + + 72 + + + 73 + + + 74 + + + 75 + + + 76 + + + 77 + + + 78 + + + 79 + + + 80 + + + 81 + + + 82 + + + 83 + + + 84 + + + 85 + + + 86 + + + 87 + + + 88 + + + 89 + + + 90 + + + 91 + + + 92 + + + 1 + + + 2 + + + 3 + + + 4 + + + 5 + + + 6 + + + 7 + + + 8 + + + 9 + + + 10 + + + 11 + + + 12 + + + 13 + + + 14 + + + 15 + + + 16 + + + 17 + + + 18 + + + 19 + + + 20 + + + 21 + + + 22 + + + 23 + + + 24 + + + 25 + + + 26 + + + 27 + + + 28 + + + SRG + + + ROADMC-DEG1 + + DEG1-CTP-TXRX + DEGREE-TXRX-CTP + + + DEG1-TTP-TXRX + DEGREE-TXRX-TTP + + + openroadm-network + ROADMC + + DEGREE + + 1 + + 93 + + + 94 + + + 95 + + + 96 + + + 29 + + + 30 + + + 31 + + + 32 + + + 33 + + + 34 + + + 35 + + + 36 + + + 37 + + + 38 + + + 39 + + + 40 + + + 41 + + + 42 + + + 43 + + + 44 + + + 45 + + + 46 + + + 47 + + + 48 + + + 49 + + + 50 + + + 51 + + + 52 + + + 53 + + + 54 + + + 55 + + + 56 + + + 57 + + + 58 + + + 59 + + + 60 + + + 61 + + + 62 + + + 63 + + + 64 + + + 65 + + + 66 + + + 67 + + + 68 + + + 69 + + + 70 + + + 71 + + + 72 + + + 73 + + + 74 + + + 75 + + + 76 + + + 77 + + + 78 + + + 79 + + + 80 + + + 81 + + + 82 + + + 83 + + + 84 + + + 85 + + + 86 + + + 87 + + + 88 + + + 89 + + + 90 + + + 91 + + + 92 + + + 1 + + + 2 + + + 3 + + + 4 + + + 5 + + + 6 + + + 7 + + + 8 + + + 9 + + + 10 + + + 11 + + + 12 + + + 13 + + + 14 + + + 15 + + + 16 + + + 17 + + + 18 + + + 19 + + + 20 + + + 21 + + + 22 + + + 23 + + + 24 + + + 25 + + + 26 + + + 27 + + + 28 + + + + + ROADMC-DEG2 + + DEG2-TTP-TXRX + DEGREE-TXRX-TTP + + + DEG2-CTP-TXRX + DEGREE-TXRX-CTP + + + openroadm-network + ROADMC + + DEGREE + + 2 + + 93 + + + 94 + + + 95 + + + 96 + + + 29 + + + 30 + + + 31 + + + 32 + + + 33 + + + 34 + + + 35 + + + 36 + + + 37 + + + 38 + + + 39 + + + 40 + + + 41 + + + 42 + + + 43 + + + 44 + + + 45 + + + 46 + + + 47 + + + 48 + + + 49 + + + 50 + + + 51 + + + 52 + + + 53 + + + 54 + + + 55 + + + 56 + + + 57 + + + 58 + + + 59 + + + 60 + + + 61 + + + 62 + + + 63 + + + 64 + + + 65 + + + 66 + + + 67 + + + 68 + + + 69 + + + 70 + + + 71 + + + 72 + + + 73 + + + 74 + + + 75 + + + 76 + + + 77 + + + 78 + + + 79 + + + 80 + + + 81 + + + 82 + + + 83 + + + 84 + + + 85 + + + 86 + + + 87 + + + 88 + + + 89 + + + 90 + + + 91 + + + 92 + + + 1 + + + 2 + + + 3 + + + 4 + + + 5 + + + 6 + + + 7 + + + 8 + + + 9 + + + 10 + + + 11 + + + 12 + + + 13 + + + 14 + + + 15 + + + 16 + + + 17 + + + 18 + + + 19 + + + 20 + + + 21 + + + 22 + + + 23 + + + 24 + + + 25 + + + 26 + + + 27 + + + 28 + + + + + ROADMA-SRG1 + + SRG1-PP12-TXRX + SRG-TXRX-PP + + + SRG1-PP15-TXRX + SRG-TXRX-PP + + + SRG1-PP1-TXRX + SRG-TXRX-PP + + + SRG1-PP2-TXRX + SRG-TXRX-PP + + + SRG1-CP-TXRX + SRG-TXRX-CP + + + SRG1-PP5-TXRX + SRG-TXRX-PP + + + SRG1-PP8-TXRX + SRG-TXRX-PP + + + SRG1-PP6-TXRX + SRG-TXRX-PP + + + SRG1-PP9-TXRX + SRG-TXRX-PP + + + SRG1-PP3-TXRX + SRG-TXRX-PP + + + SRG1-PP10-TXRX + SRG-TXRX-PP + + + SRG1-PP14-TXRX + SRG-TXRX-PP + + + SRG1-PP16-TXRX + SRG-TXRX-PP + + + SRG1-PP7-TXRX + SRG-TXRX-PP + + + SRG1-PP11-TXRX + SRG-TXRX-PP + + + SRG1-PP13-TXRX + SRG-TXRX-PP + + + SRG1-PP4-TXRX + SRG-TXRX-PP + + + openroadm-network + ROADMA + + + + 93 + + + 94 + + + 95 + + + 96 + + + 29 + + + 30 + + + 31 + + + 32 + + + 33 + + + 34 + + + 35 + + + 36 + + + 37 + + + 38 + + + 39 + + + 40 + + + 41 + + + 42 + + + 43 + + + 44 + + + 45 + + + 46 + + + 47 + + + 48 + + + 49 + + + 50 + + + 51 + + + 52 + + + 53 + + + 54 + + + 55 + + + 56 + + + 57 + + + 58 + + + 59 + + + 60 + + + 61 + + + 62 + + + 63 + + + 64 + + + 65 + + + 66 + + + 67 + + + 68 + + + 69 + + + 70 + + + 71 + + + 72 + + + 73 + + + 74 + + + 75 + + + 76 + + + 77 + + + 78 + + + 79 + + + 80 + + + 81 + + + 82 + + + 83 + + + 84 + + + 85 + + + 86 + + + 87 + + + 88 + + + 89 + + + 90 + + + 91 + + + 92 + + + 1 + + + 2 + + + 3 + + + 4 + + + 5 + + + 6 + + + 7 + + + 8 + + + 9 + + + 10 + + + 11 + + + 12 + + + 13 + + + 14 + + + 15 + + + 16 + + + 17 + + + 18 + + + 19 + + + 20 + + + 21 + + + 22 + + + 23 + + + 24 + + + 25 + + + 26 + + + 27 + + + 28 + + + SRG + + + XPDRA-XPDR1 + + XPDR1-NETWORK2 + XPONDER-NETWORK + + XPDR1-NETWORK1 + + + XPDR1-CLIENT2 + + + + XPDR1-CLIENT2 + XPONDER-CLIENT + + XPDR1-NETWORK2 + + + + XPDR1-CLIENT1 + XPONDER-CLIENT + + XPDR1-NETWORK1 + + + + XPDR1-NETWORK1 + XPONDER-NETWORK + + XPDR1-NETWORK1 + + + XPDR1-CLIENT1 + + + + openroadm-network + XPDRA + + XPONDER + + + ROADMA-DEG2 + + DEG2-TTP-TXRX + DEGREE-TXRX-TTP + + + DEG2-CTP-TXRX + DEGREE-TXRX-CTP + + + openroadm-network + ROADMA + + DEGREE + + 2 + + 93 + + + 94 + + + 95 + + + 96 + + + 29 + + + 30 + + + 31 + + + 32 + + + 33 + + + 34 + + + 35 + + + 36 + + + 37 + + + 38 + + + 39 + + + 40 + + + 41 + + + 42 + + + 43 + + + 44 + + + 45 + + + 46 + + + 47 + + + 48 + + + 49 + + + 50 + + + 51 + + + 52 + + + 53 + + + 54 + + + 55 + + + 56 + + + 57 + + + 58 + + + 59 + + + 60 + + + 61 + + + 62 + + + 63 + + + 64 + + + 65 + + + 66 + + + 67 + + + 68 + + + 69 + + + 70 + + + 71 + + + 72 + + + 73 + + + 74 + + + 75 + + + 76 + + + 77 + + + 78 + + + 79 + + + 80 + + + 81 + + + 82 + + + 83 + + + 84 + + + 85 + + + 86 + + + 87 + + + 88 + + + 89 + + + 90 + + + 91 + + + 92 + + + 1 + + + 2 + + + 3 + + + 4 + + + 5 + + + 6 + + + 7 + + + 8 + + + 9 + + + 10 + + + 11 + + + 12 + + + 13 + + + 14 + + + 15 + + + 16 + + + 17 + + + 18 + + + 19 + + + 20 + + + 21 + + + 22 + + + 23 + + + 24 + + + 25 + + + 26 + + + 27 + + + 28 + + + + + XPDRC-XPDR1 + + XPDR1-NETWORK2 + XPONDER-NETWORK + + XPDR1-NETWORK1 + + + XPDR1-CLIENT2 + + + + XPDR1-CLIENT2 + XPONDER-CLIENT + + XPDR1-NETWORK2 + + + + XPDR1-CLIENT1 + XPONDER-CLIENT + + XPDR1-NETWORK1 + + + + XPDR1-NETWORK1 + XPONDER-NETWORK + + XPDR1-NETWORK1 + + + XPDR1-CLIENT1 + + + + openroadm-network + XPDRC + + XPONDER + + + ROADMA-DEG1 + + DEG1-CTP-TXRX + DEGREE-TXRX-CTP + + + DEG1-TTP-TXRX + DEGREE-TXRX-TTP + + + openroadm-network + ROADMA + + DEGREE + + 1 + + 93 + + + 94 + + + 95 + + + 96 + + + 29 + + + 30 + + + 31 + + + 32 + + + 33 + + + 34 + + + 35 + + + 36 + + + 37 + + + 38 + + + 39 + + + 40 + + + 41 + + + 42 + + + 43 + + + 44 + + + 45 + + + 46 + + + 47 + + + 48 + + + 49 + + + 50 + + + 51 + + + 52 + + + 53 + + + 54 + + + 55 + + + 56 + + + 57 + + + 58 + + + 59 + + + 60 + + + 61 + + + 62 + + + 63 + + + 64 + + + 65 + + + 66 + + + 67 + + + 68 + + + 69 + + + 70 + + + 71 + + + 72 + + + 73 + + + 74 + + + 75 + + + 76 + + + 77 + + + 78 + + + 79 + + + 80 + + + 81 + + + 82 + + + 83 + + + 84 + + + 85 + + + 86 + + + 87 + + + 88 + + + 89 + + + 90 + + + 91 + + + 92 + + + 1 + + + 2 + + + 3 + + + 4 + + + 5 + + + 6 + + + 7 + + + 8 + + + 9 + + + 10 + + + 11 + + + 12 + + + 13 + + + 14 + + + 15 + + + 16 + + + 17 + + + 18 + + + 19 + + + 20 + + + 21 + + + 22 + + + 23 + + + 24 + + + 25 + + + 26 + + + 27 + + + 28 + + + + \ No newline at end of file diff --git a/tests/tox.ini b/tests/tox.ini index 87d7bc589..9b324a1d8 100644 --- a/tests/tox.ini +++ b/tests/tox.ini @@ -9,8 +9,9 @@ deps = -r{toxinidir}/test-requirements.txt whitelist_externals = bash commands = - bash -c "(cd .. && mvn clean install -DskipTests -Dmaven.javadoc.skip=true)" + {p27,portmapping,pce}: bash -c "(cd .. && mvn clean install -DskipTests -Dmaven.javadoc.skip=true)" {py27,portmapping}: ./build.sh + {p27,servicehandler}: ./SH_func_tests.sh py27: nosetests --with-xunit transportpce_tests/ portmapping: nosetests --with-xunit transportpce_tests/test_portmapping.py servicehandler: nosetests --with-xunit transportpce_tests/test_servicehandler.py diff --git a/tests/transportpce_tests/test_pce.py b/tests/transportpce_tests/test_pce.py index 2c3f330d5..a83f7b786 100644 --- a/tests/transportpce_tests/test_pce.py +++ b/tests/transportpce_tests/test_pce.py @@ -24,7 +24,7 @@ class TransportPCEtesting(unittest.TestCase): odl_process = None simple_data = None complex_data = None - restconf_baseurl = "http://127.0.0.1:8181/restconf" + restconf_baseurl = "http://localhost:8181/restconf" @classmethod def _get_file(cls): diff --git a/tests/transportpce_tests/test_servicehandler.py b/tests/transportpce_tests/test_servicehandler.py index e3bdc1184..48e597890 100644 --- a/tests/transportpce_tests/test_servicehandler.py +++ b/tests/transportpce_tests/test_servicehandler.py @@ -1,6 +1,6 @@ #!/usr/bin/env python ############################################################################## -#Copyright (c) 2017 Orange, Inc. and others. All rights reserved. +# Copyright (c) 2017 Orange, Inc. and others. All rights reserved. # # All rights reserved. This program and the accompanying materials # are made available under the terms of the Apache License, Version 2.0 @@ -22,7 +22,15 @@ import unittest class TransportPCEtesting(unittest.TestCase): odl_process = None - restconf_baseurl = "http://127.0.0.1:8181/restconf" + honeynode_topology = None + restconf_baseurl = "http://localhost:8181/restconf" + + @classmethod + def _get_file(cls): + honeynode_topology_file = "sample_configs/honeynode-topo.xml" + if os.path.isfile(honeynode_topology_file): + with open(honeynode_topology_file, 'r') as honeynode_file: + cls.honeynode_topo = honeynode_file.read(); @classmethod def __start_odl(cls): @@ -33,7 +41,8 @@ class TransportPCEtesting(unittest.TestCase): stdin=open(os.devnull)) @classmethod - def setUpClass(cls): #a class method called before tests in an individual class run. + def setUpClass(cls): # a class method called before tests in an individual class run. + cls._get_file() cls.__start_odl() time.sleep(90) @@ -45,37 +54,71 @@ class TransportPCEtesting(unittest.TestCase): cls.odl_process.send_signal(signal.SIGINT) cls.odl_process.wait() - def setUp(self): #instruction executed before each test method + def setUp(self): # instruction executed before each test method + print ("execution of {}".format(self.id().split(".")[-1])) + + def test_01_restconfAPI(self): + url = ("{}/operational/network-topology:network-topology/topology/" + "topology-netconf/node/controller-config".format(self.restconf_baseurl)) + headers = {'content-type': 'application/json'} + response = requests.request("GET", url, headers=headers, auth=('admin', 'admin')) + self.assertEqual(response.status_code, requests.codes.ok) + res = response.json() + self.assertEqual(res['node'] [0] ['netconf-node-topology:connection-status'], + 'connected') time.sleep(1) - #Get existing PathDesciption - def test_01_get_pathdescriptions(self): - url = ("{}/operational/stubpce:path-description-list/pathDescriptions/NodeAToNodeZ_direct_1" + # Load honeynode topology + def test_02_load_honeynode_topology(self): + url = ("{}/config/ietf-network:network/openroadm-topology" .format(self.restconf_baseurl)) - headers = {'content-type': 'application/json', + body = self.honeynode_topo + headers = {'content-type': 'application/xml', "Accept": "application/json"} response = requests.request( - "GET", url, headers=headers, auth=('admin', 'admin')) + "PUT", url, data=body, headers=headers, + auth=('admin', 'admin')) + self.assertEqual(response.status_code, requests.codes.ok) + time.sleep(2) + + def test_03_check_link_xpdra_roadma(self): + url = ("{}/config/ietf-network:network/openroadm-topology/link/" + "XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX".format(self.restconf_baseurl)) + headers = {'content-type': 'application/json'} + response = requests.request("GET", url, headers=headers, auth=('admin', 'admin')) self.assertEqual(response.status_code, requests.codes.ok) res = response.json() - self.assertEqual( - res['pathDescriptions'][0]['path-name'], - 'NodeAToNodeZ_direct_1') time.sleep(1) - #Get non existing PathDesciption - def test_02_get_pathdescriptions(self): - url = ("{}/operational/stubpce:path-description-list/pathDescriptions/Node" - .format(self.restconf_baseurl)) - headers = {'content-type': 'application/json', - "Accept": "application/json"} - response = requests.request( - "GET", url, headers=headers, auth=('admin', 'admin')) - self.assertEqual(response.status_code, 404) + def test_04_check_link_xpdrc_roadmc(self): + url = ("{}/config/ietf-network:network/openroadm-topology/link/" + "XPDRC-XPDR1-XPDR1-NETWORK1toROADMC-SRG1-SRG1-PP1-TXRX".format(self.restconf_baseurl)) + headers = {'content-type': 'application/json'} + response = requests.request("GET", url, headers=headers, auth=('admin', 'admin')) + self.assertEqual(response.status_code, requests.codes.ok) + res = response.json() time.sleep(1) - #Create Service 'test' with correct parameters - def test_03_create_service(self): + def test_05_check_link_roadma_xpdra(self): + url = ("{}/config/ietf-network:network/openroadm-topology/link/" + "ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1".format(self.restconf_baseurl)) + headers = {'content-type': 'application/json'} + response = requests.request("GET", url, headers=headers, auth=('admin', 'admin')) + self.assertEqual(response.status_code, requests.codes.ok) + res = response.json() + time.sleep(1) + + def test_06_check_link_roadmc_xpdrc(self): + url = ("{}/config/ietf-network:network/openroadm-topology/link/" + "ROADMC-SRG1-SRG1-PP1-TXRXtoXPDRC-XPDR1-XPDR1-NETWORK1".format(self.restconf_baseurl)) + headers = {'content-type': 'application/json'} + response = requests.request("GET", url, headers=headers, auth=('admin', 'admin')) + self.assertEqual(response.status_code, requests.codes.ok) + res = response.json() + time.sleep(1) + + # Create Service 'test' with correct parameters + def test_07_create_service(self): url = ("{}/operations/org-openroadm-service:service-create" .format(self.restconf_baseurl)) data = {"input": { @@ -173,12 +216,12 @@ class TransportPCEtesting(unittest.TestCase): auth=('admin', 'admin')) self.assertEqual(response.status_code, requests.codes.ok) res = response.json() - self.assertIn('in progress', + self.assertIn('Service rendered successfully !', res['output']['configuration-response-common']['response-message']) - time.sleep(30) + time.sleep(10) - #Create Service 'test' with not compliant parameter : no 'sdnc-request-header' parameter - def test_04_create_service(self): + # Create Service 'test' with not compliant parameter : no 'sdnc-request-header' parameter + def test_08_create_service(self): url = ("{}/operations/org-openroadm-service:service-create" .format(self.restconf_baseurl)) data = {"input": { @@ -270,12 +313,12 @@ class TransportPCEtesting(unittest.TestCase): auth=('admin', 'admin')) self.assertEqual(response.status_code, requests.codes.ok) res = response.json() - self.assertIn('Service not compliant', + self.assertIn('Service sndc-request-header is not set', res['output']['configuration-response-common']['response-message']) time.sleep(5) - #Create Service 'test' with not compliant parameter : no 'tx-direction' for serviceAEnd - def test_05_create_service(self): + # Create Service 'test' with not compliant parameter : no 'tx-direction' for serviceAEnd + def test_09_create_service(self): url = ("{}/operations/org-openroadm-service:service-create" .format(self.restconf_baseurl)) data = {"input": { @@ -358,12 +401,12 @@ class TransportPCEtesting(unittest.TestCase): auth=('admin', 'admin')) self.assertEqual(response.status_code, requests.codes.ok) res = response.json() - self.assertIn('Service not compliant', + self.assertIn('Service TxDirection is not correctly set', res['output']['configuration-response-common']['response-message']) time.sleep(5) - #Get 'test' service created - def test_06_get_service(self): + # Get 'test' service created + def test_10_get_service(self): url = ("{}/operational/org-openroadm-service:service-list/services/test" .format(self.restconf_baseurl)) headers = {'content-type': 'application/json', @@ -377,8 +420,8 @@ class TransportPCEtesting(unittest.TestCase): 'inService') time.sleep(1) - #get non existing service - def test_07_get_service(self): + # get non existing service + def test_11_get_service(self): url = ("{}/operational/org-openroadm-service:service-list/services/test1" .format(self.restconf_baseurl)) headers = {'content-type': 'application/json', @@ -388,237 +431,204 @@ class TransportPCEtesting(unittest.TestCase): self.assertEqual(response.status_code, 404) time.sleep(1) - #reconfigure 'test' to be 'test-new' - def test_08_reconfigure_service(self): - url = ("{}/operations/org-openroadm-service:service-reconfigure" - .format(self.restconf_baseurl)) - data = {"input": { - "service-name": "test", - "new-service-name": "test-new", - "common-id": "ASATT1234567", - "connection-type": "infrastructure", - "service-a-end": { - "service-rate": "100", - "node-id": "XPDRA", - "service-format": "Ethernet", - "clli": "SNJSCAMCJP8", - "tx-direction": { - "port": { - "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00", - "port-type": "router", - "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0", - "port-rack": "000000.00", - "port-shelf": "00" - }, - "lgx": { - "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00", - "lgx-port-name": "LGX Back.3", - "lgx-port-rack": "000000.00", - "lgx-port-shelf": "00" - } - }, - "rx-direction": { - "port": { - "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00", - "port-type": "router", - "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0", - "port-rack": "000000.00", - "port-shelf": "00" - }, - "lgx": { - "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00", - "lgx-port-name": "LGX Back.4", - "lgx-port-rack": "000000.00", - "lgx-port-shelf": "00" - } - }, - "optic-type": "gray" - }, - "service-z-end": { - "service-rate": "100", - "node-id": "XPDRC", - "service-format": "Ethernet", - "clli": "SNJSCAMCJT4", - "tx-direction": { - "port": { - "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00", - "port-type": "router", - "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0", - "port-rack": "000000.00", - "port-shelf": "00" - }, - "lgx": { - "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00", - "lgx-port-name": "LGX Back.29", - "lgx-port-rack": "000000.00", - "lgx-port-shelf": "00" - } - }, - "rx-direction": { - "port": { - "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00", - "port-type": "router", - "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0", - "port-rack": "000000.00", - "port-shelf": "00" - }, - "lgx": { - "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00", - "lgx-port-name": "LGX Back.30", - "lgx-port-rack": "000000.00", - "lgx-port-shelf": "00" - } - }, - "optic-type": "gray" - }, - "hard-constraints": { - "diversity": { - "existing-service": [ - "104/GE100/SNJSCAMCJP8/SNJSCAMCJT4" - ], - "existing-service-applicability": { - "node": "true" - } - }, - "exclude": { - "fiber-bundle": [ - "l(string)" - ], - "node-id": [ - "SNJSCAMCJP8_000000.00" - ] - }, - "latency": { - "max-latency": "30" - } - } - } - } - headers = {'content-type': 'application/json', - "Accept": "application/json"} - response = requests.request( - "POST", url, data=json.dumps(data), headers=headers, - auth=('admin', 'admin')) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('in progress', - res['output']['status-message']) - time.sleep(30) - - - #get new service 'test-new' - def test_09_get_service(self): - url = ("{}/operational/org-openroadm-service:service-list/services/test-new" - .format(self.restconf_baseurl)) - headers = {'content-type': 'application/json', - "Accept": "application/json"} - response = requests.request( - "GET", url, headers=headers, auth=('admin', 'admin')) - res = response.json() - self.assertEqual( - res['services'][0]['operational-state'], - 'inService') - time.sleep(1) - - - #Modify 'test-new' state - def test_10_modify_service_state(self): - url = ("{}/operations/servicehandler:service-state-modify" - .format(self.restconf_baseurl)) - data = {"input": { - "service-name": "test-new", - "operational-state": "outOfService" - } - } - headers = {'content-type': 'application/json'} - response = requests.request( - "POST", url, data=json.dumps(data), headers=headers, - auth=('admin', 'admin')) - res = response.json() - self.assertIn('Service state modified', - res['output']['configuration-response-common']['response-message']) - time.sleep(5) - - - #get new service 'test-new' state - def test_11_get_service(self): - url = ("{}/operational/org-openroadm-service:service-list/services/test-new" - .format(self.restconf_baseurl)) - headers = {'content-type': 'application/json', - "Accept": "application/json"} - response = requests.request( - "GET", url, headers=headers, auth=('admin', 'admin')) - res = response.json() - self.assertEqual( - res['services'][0]['operational-state'], - 'outOfService') - time.sleep(1) - - - #restore service 'test-new' - def test_12_restore_service(self): - url = ("{}/operations/org-openroadm-service:service-restoration" - .format(self.restconf_baseurl)) - data = {"input": { - "service-name": "test-new", - "option": "permanent" - } - } - headers = {'content-type': 'application/json'} - response = requests.request( - "POST", url, data=json.dumps(data), headers=headers, - auth=('admin', 'admin')) - res = response.json() - self.assertIn('in progress', - res['output']['status-message']) - time.sleep(60) - - - #get new service 'test-new' state - def test_13_get_service(self): - url = ("{}/operational/org-openroadm-service:service-list/services/test-new" - .format(self.restconf_baseurl)) - headers = {'content-type': 'application/json', - "Accept": "application/json"} - response = requests.request( - "GET", url, headers=headers, auth=('admin', 'admin')) - res = response.json() - self.assertEqual( - res['services'][0]['operational-state'], - 'inService') - time.sleep(1) - - - #Delete 'test-new' service - def test_14_delete_service(self): - url = ("{}/operations/org-openroadm-service:service-delete" - .format(self.restconf_baseurl)) - data = {"input": { - "sdnc-request-header": { - "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", - "rpc-action": "service-delete", - "request-system-id": "appname", - "notification-url": "http://localhost:8585/NotificationServer/notify" - }, - "service-delete-req-info": { - "service-name": "test-new", - "due-date": "2016-11-28T00:00:01Z", - "tail-retention": "no" - } - } - } - headers = {'content-type': 'application/json'} - response = requests.request( - "POST", url, data=json.dumps(data), headers=headers, - auth=('admin', 'admin')) - res = response.json() - self.assertIn('in progress', - res['output']['configuration-response-common']['response-message']) - time.sleep(30) - - - #Delete non existing service - def test_15_delete_service(self): +# These tests is not available in this commit (cf commit message ) +# reconfigure 'test' to be 'test-new' +# def test_08_reconfigure_service(self): +# url = ("{}/operations/org-openroadm-service:service-reconfigure" +# .format(self.restconf_baseurl)) +# data = {"input": { +# "service-name": "test", +# "new-service-name": "test-new", +# "common-id": "ASATT1234567", +# "connection-type": "infrastructure", +# "service-a-end": { +# "service-rate": "100", +# "node-id": "XPDRA", +# "service-format": "Ethernet", +# "clli": "SNJSCAMCJP8", +# "tx-direction": { +# "port": { +# "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00", +# "port-type": "router", +# "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0", +# "port-rack": "000000.00", +# "port-shelf": "00" +# }, +# "lgx": { +# "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00", +# "lgx-port-name": "LGX Back.3", +# "lgx-port-rack": "000000.00", +# "lgx-port-shelf": "00" +# } +# }, +# "rx-direction": { +# "port": { +# "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00", +# "port-type": "router", +# "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0", +# "port-rack": "000000.00", +# "port-shelf": "00" +# }, +# "lgx": { +# "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00", +# "lgx-port-name": "LGX Back.4", +# "lgx-port-rack": "000000.00", +# "lgx-port-shelf": "00" +# } +# }, +# "optic-type": "gray" +# }, +# "service-z-end": { +# "service-rate": "100", +# "node-id": "XPDRC", +# "service-format": "Ethernet", +# "clli": "SNJSCAMCJT4", +# "tx-direction": { +# "port": { +# "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00", +# "port-type": "router", +# "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0", +# "port-rack": "000000.00", +# "port-shelf": "00" +# }, +# "lgx": { +# "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00", +# "lgx-port-name": "LGX Back.29", +# "lgx-port-rack": "000000.00", +# "lgx-port-shelf": "00" +# } +# }, +# "rx-direction": { +# "port": { +# "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00", +# "port-type": "router", +# "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0", +# "port-rack": "000000.00", +# "port-shelf": "00" +# }, +# "lgx": { +# "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00", +# "lgx-port-name": "LGX Back.30", +# "lgx-port-rack": "000000.00", +# "lgx-port-shelf": "00" +# } +# }, +# "optic-type": "gray" +# }, +# "hard-constraints": { +# "diversity": { +# "existing-service": [ +# "104/GE100/SNJSCAMCJP8/SNJSCAMCJT4" +# ], +# "existing-service-applicability": { +# "node": "true" +# } +# }, +# "exclude": { +# "fiber-bundle": [ +# "l(string)" +# ], +# "node-id": [ +# "SNJSCAMCJP8_000000.00" +# ] +# }, +# "latency": { +# "max-latency": "30" +# } +# } +# } +# } +# headers = {'content-type': 'application/json', +# "Accept": "application/json"} +# response = requests.request( +# "POST", url, data=json.dumps(data), headers=headers, +# auth=('admin', 'admin')) +# self.assertEqual(response.status_code, requests.codes.ok) +# res = response.json() +# self.assertIn('in progress', +# res['output']['status-message']) +# time.sleep(30) +# +# # get new service 'test-new' +# def test_09_get_service(self): +# url = ("{}/operational/org-openroadm-service:service-list/services/test-new" +# .format(self.restconf_baseurl)) +# headers = {'content-type': 'application/json', +# "Accept": "application/json"} +# response = requests.request( +# "GET", url, headers=headers, auth=('admin', 'admin')) +# res = response.json() +# self.assertEqual( +# res['services'][0]['operational-state'], +# 'inService') +# time.sleep(1) +# +# # Modify 'test-new' state +# def test_10_modify_service_state(self): +# url = ("{}/operations/servicehandler:service-state-modify" +# .format(self.restconf_baseurl)) +# data = {"input": { +# "service-name": "test-new", +# "operational-state": "outOfService" +# } +# } +# headers = {'content-type': 'application/json'} +# response = requests.request( +# "POST", url, data=json.dumps(data), headers=headers, +# auth=('admin', 'admin')) +# res = response.json() +# self.assertIn('Service state modified', +# res['output']['configuration-response-common']['response-message']) +# time.sleep(5) +# +# # get new service 'test-new' state +# def test_11_get_service(self): +# url = ("{}/operational/org-openroadm-service:service-list/services/test-new" +# .format(self.restconf_baseurl)) +# headers = {'content-type': 'application/json', +# "Accept": "application/json"} +# response = requests.request( +# "GET", url, headers=headers, auth=('admin', 'admin')) +# res = response.json() +# self.assertEqual( +# res['services'][0]['operational-state'], +# 'outOfService') +# time.sleep(1) +# +# # restore service 'test-new' +# def test_12_restore_service(self): +# url = ("{}/operations/org-openroadm-service:service-restoration" +# .format(self.restconf_baseurl)) +# data = {"input": { +# "service-name": "test-new", +# "option": "permanent" +# } +# } +# headers = {'content-type': 'application/json'} +# response = requests.request( +# "POST", url, data=json.dumps(data), headers=headers, +# auth=('admin', 'admin')) +# res = response.json() +# self.assertIn('in progress', +# res['output']['status-message']) +# time.sleep(60) +# +# # get new service 'test-new' state +# def test_13_get_service(self): +# url = ("{}/operational/org-openroadm-service:service-list/services/test-new" +# .format(self.restconf_baseurl)) +# headers = {'content-type': 'application/json', +# "Accept": "application/json"} +# response = requests.request( +# "GET", url, headers=headers, auth=('admin', 'admin')) +# res = response.json() +# self.assertEqual( +# res['services'][0]['operational-state'], +# 'inService') +# time.sleep(1) + + # Delete non existing service + def test_12_delete_service(self): url = ("{}/operations/org-openroadm-service:service-delete" .format(self.restconf_baseurl)) data = {"input": { @@ -641,13 +651,12 @@ class TransportPCEtesting(unittest.TestCase): auth=('admin', 'admin')) self.assertEqual(response.status_code, requests.codes.ok) res = response.json() - self.assertIn('not exists in datastore', + self.assertIn('Service delete was successful!', res['output']['configuration-response-common']['response-message']) time.sleep(1) - - #Verify 'test' service deleted - def test_16_get_service(self): + # Verify 'test' service deleted + def test_13_get_service(self): url = ("{}/operational/org-openroadm-service:service-list/services/test-new" .format(self.restconf_baseurl)) headers = {'content-type': 'application/json', @@ -657,5 +666,6 @@ class TransportPCEtesting(unittest.TestCase): self.assertEqual(response.status_code, 404) time.sleep(1) + if __name__ == "__main__": unittest.main(verbosity=2)