Format Java code with respect to ONAP Code Style

Change-Id: I9025c97ffd2997bfba0dcfb9caec8b7be6ae090c
Issue-ID: EXTAPI-372
Signed-off-by: MatthieuGeerebaert <matthieu.geerebaert@orange.com>

7 files changed, 1136 insertions, 1220 deletions

diff --git a/src/test/java/org/onap/nbi/api/listener/ListenerResourceTest.java b/src/test/java/org/onap/nbi/api/listener/ListenerResourceTest.java
index 691592a..d8dc38b 100644
--- a/src/test/java/org/onap/nbi/api/listener/ListenerResourceTest.java
+++ b/src/test/java/org/onap/nbi/api/listener/ListenerResourceTest.java
@@ -11,6 +11,7 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
+
 package org.onap.nbi.api.listener;
 
 import java.net.URI;
@@ -40,91 +41,88 @@ import com.fasterxml.jackson.databind.JsonNode;
 @RequestMapping("/test/listener")
 public class ListenerResourceTest extends ResourceManagement {
 
-  Logger logger = LoggerFactory.getLogger(ListenerResourceTest.class);
+    Logger logger = LoggerFactory.getLogger(ListenerResourceTest.class);
 
-  static Map<String, JsonNode> events = new ConcurrentHashMap<>();
+    static Map<String, JsonNode> events = new ConcurrentHashMap<>();
 
-  /*
-   * listener resource test for hub resource
-   */
-  @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
-  public ResponseEntity<JsonNode> postListener(@RequestBody JsonNode event) {
-    if (logger.isDebugEnabled()) {
-      logger.debug("POST event from nbi : {}", event.toString());
-    }
-    String eventId = event.get("eventId").asText();
-    logger.info("putting eventId {} in the events map", eventId);
-    events.put(eventId, event);
-
-    URI location = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}")
-        .buildAndExpand(eventId).toUri();
-
-    return ResponseEntity.created(location).body(event);
-  }
-
-
-  @GetMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE)
-  public ResponseEntity<Collection<JsonNode>> findEvents(
-      @RequestParam MultiValueMap<String, String> params) {
-    logger.info("called listener get with params {} : " + params.toString());
-    Collection<JsonNode> values = new ArrayList<>();
-    String serviceOrderId = params.getFirst("serviceOrderId");
-    String serviceInstanceId = params.getFirst("serviceInstanceId");
-    if (StringUtils.isNotEmpty(serviceOrderId)) {
-      for (JsonNode jsonNode : events.values()) {
-        String id = jsonNode.get("event").get("id").asText();
-        logger.info("found event with service order id : " + id);
-        if (id.equals(serviceOrderId)) {
-          values.add(jsonNode);
+    /*
+     * listener resource test for hub resource
+     */
+    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<JsonNode> postListener(@RequestBody JsonNode event) {
+        if (logger.isDebugEnabled()) {
+            logger.debug("POST event from nbi : {}", event.toString());
         }
-      }
-      if (!values.isEmpty()) {
-        return ResponseEntity.ok(values);
-      } else {
-        logger.error("cannot found events with service order id : " + serviceOrderId);
-        return ResponseEntity.notFound().build();
-      }
-    } else if (StringUtils.isNotEmpty(serviceInstanceId)) {
-      for (JsonNode jsonNode : events.values()) {
-        String id = jsonNode.get("event").get("id").asText();
-        logger.info("found event with service Instance id : " + id);
-        if (id.equals(serviceInstanceId)) {
-          values.add(jsonNode);
+        String eventId = event.get("eventId").asText();
+        logger.info("putting eventId {} in the events map", eventId);
+        events.put(eventId, event);
+
+        URI location = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}").buildAndExpand(eventId).toUri();
+
+        return ResponseEntity.created(location).body(event);
+    }
+
+    @GetMapping(value = "", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<Collection<JsonNode>> findEvents(@RequestParam MultiValueMap<String, String> params) {
+        logger.info("called listener get with params {} : " + params.toString());
+        Collection<JsonNode> values = new ArrayList<>();
+        String serviceOrderId = params.getFirst("serviceOrderId");
+        String serviceInstanceId = params.getFirst("serviceInstanceId");
+        if (StringUtils.isNotEmpty(serviceOrderId)) {
+            for (JsonNode jsonNode : events.values()) {
+                String id = jsonNode.get("event").get("id").asText();
+                logger.info("found event with service order id : " + id);
+                if (id.equals(serviceOrderId)) {
+                    values.add(jsonNode);
+                }
+            }
+            if (!values.isEmpty()) {
+                return ResponseEntity.ok(values);
+            } else {
+                logger.error("cannot found events with service order id : " + serviceOrderId);
+                return ResponseEntity.notFound().build();
+            }
+        } else if (StringUtils.isNotEmpty(serviceInstanceId)) {
+            for (JsonNode jsonNode : events.values()) {
+                String id = jsonNode.get("event").get("id").asText();
+                logger.info("found event with service Instance id : " + id);
+                if (id.equals(serviceInstanceId)) {
+                    values.add(jsonNode);
+                }
+            }
+            if (!values.isEmpty()) {
+                return ResponseEntity.ok(values);
+            } else {
+                logger.error("cannot found events with service instance id : " + serviceInstanceId);
+                return ResponseEntity.notFound().build();
+            }
+        } else {
+            values = events.values();
         }
-      }
-      if (!values.isEmpty()) {
         return ResponseEntity.ok(values);
-      } else {
-        logger.error("cannot found events with service instance id : " + serviceInstanceId);
-        return ResponseEntity.notFound().build();
-      }
-    } else {
-      values = events.values();
     }
-    return ResponseEntity.ok(values);
-  }
 
-  @GetMapping(value = "/{eventId}", produces = MediaType.APPLICATION_JSON_VALUE)
-  public ResponseEntity<Object> getEvent(@PathVariable String eventId) {
+    @GetMapping(value = "/{eventId}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<Object> getEvent(@PathVariable String eventId) {
 
-    return ResponseEntity.ok(events.get(eventId));
+        return ResponseEntity.ok(events.get(eventId));
 
-  }
+    }
 
-  @DeleteMapping(value = "/{eventId}", produces = MediaType.APPLICATION_JSON_VALUE)
-  public ResponseEntity<Object> deleteEvent(@PathVariable String eventId) {
+    @DeleteMapping(value = "/{eventId}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<Object> deleteEvent(@PathVariable String eventId) {
 
-    events.remove(eventId);
-    return ResponseEntity.noContent().build();
+        events.remove(eventId);
+        return ResponseEntity.noContent().build();
 
-  }
+    }
 
-  @DeleteMapping(produces = MediaType.APPLICATION_JSON_VALUE)
-  public ResponseEntity<Object> deleteEvents() {
+    @DeleteMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+    public ResponseEntity<Object> deleteEvents() {
 
-    events.clear();
-    return ResponseEntity.noContent().build();
+        events.clear();
+        return ResponseEntity.noContent().build();
 
-  }
+    }
 
 }
diff --git a/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java b/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java
index 5dc261a..b09cf1d 100644
--- a/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java
+++ b/src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java
@@ -11,6 +11,7 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
+
 package org.onap.nbi.apis.assertions;
 
 import java.util.ArrayList;
@@ -38,407 +39,402 @@ import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
 import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
 
-
 public class ServiceOrderExecutionTaskAssertions {
 
-  public static ServiceOrder createTestServiceOrderRejected() {
-    ServiceOrder serviceOrder = new ServiceOrder();
-    serviceOrder.setExternalId("LudONAP001");
-    serviceOrder.setPriority("1");
-    serviceOrder.setDescription("Ludo first ONAP Order");
-    serviceOrder.setCategory("Consumer");
-    serviceOrder.setRequestedStartDate(new Date());
-    serviceOrder.setRequestedCompletionDate(new Date());
-
-    RelatedParty party = new RelatedParty();
-    party.setId("6490");
-    party.setRole("ONAPcustomer");
-    party.setReferredType("individual");
-    party.setName("Jean Pontus");
-    List<RelatedParty> relatedPartyList = new ArrayList<>();
-    relatedPartyList.add(party);
-    serviceOrder.setRelatedParty(relatedPartyList);
-
-    List<ServiceOrderItem> items = new ArrayList<>();
-
-    ServiceOrderItem itemA = new ServiceOrderItem();
-    itemA.id("A");
-    itemA.action(ActionType.ADD);
-    Service serviceA = new Service();
-    serviceA.setServiceState("active");
-    ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
-    serviceSpecificationRefA.setId("333");
-    serviceA.setServiceSpecification(serviceSpecificationRefA);
-    itemA.setService(serviceA);
-    items.add(itemA);
-
-    ServiceOrderItem itemB = new ServiceOrderItem();
-    itemB.id("B");
-    itemB.action(ActionType.ADD);
-    Service serviceB = new Service();
-    serviceB.setServiceState("active");
-    ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
-    serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
-    serviceB.setServiceSpecification(serviceSpecificationRefB);
-    itemB.setService(serviceB);
-    List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
-    OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
-    orderItemRelationship.setId("A");
-    orderItemRelationships.add(orderItemRelationship);
-    itemB.setOrderItemRelationship(orderItemRelationships);
-    items.add(itemB);
-    serviceOrder.setOrderItem(items);
-    return serviceOrder;
-
-  }
-
-
-  public static ServiceOrder createTestServiceOrder(ActionType actionType) {
-    ServiceOrder serviceOrder = new ServiceOrder();
-    serviceOrder.setExternalId("LudONAP001");
-    serviceOrder.setPriority("1");
-    serviceOrder.setDescription("Ludo first ONAP Order");
-    serviceOrder.setCategory("Consumer");
-    serviceOrder.setRequestedStartDate(new Date());
-    serviceOrder.setRequestedCompletionDate(new Date());
-    serviceOrder.setBaseType("toto");
-    serviceOrder.setCompletionDateTime(new Date());
-    serviceOrder.setExpectedCompletionDate(new Date());
-    serviceOrder.setSchemaLocation("/tutu");
-
-    OrderRelationship orderRelationship = new OrderRelationship();
-    orderRelationship.setId("test");
-    orderRelationship.setHref("test");
-    orderRelationship.setReferredType("test");
-    orderRelationship.setType("type");
-    List<OrderRelationship> relationships = new ArrayList<>();
-    serviceOrder.setOrderRelationship(relationships);
-
-    RelatedParty party = new RelatedParty();
-    party.setId("6490");
-    party.setRole("ONAPcustomer");
-    party.setReferredType("individual");
-    party.setName("Jean Pontus");
-    List<RelatedParty> relatedPartyList = new ArrayList<>();
-    relatedPartyList.add(party);
-    serviceOrder.setRelatedParty(relatedPartyList);
-
-    List<ServiceOrderItem> items = new ArrayList<>();
-
-    ServiceOrderItem itemA = new ServiceOrderItem();
-    itemA.id("A");
-    itemA.action(actionType);
-    Service serviceA = new Service();
-    if (actionType != ActionType.ADD) {
-      serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
-    }
-    serviceA.setServiceState("active");
-    ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
-    serviceSpecificationRefA.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
-    serviceA.setServiceSpecification(serviceSpecificationRefA);
-    itemA.setService(serviceA);
-    items.add(itemA);
-
-    ServiceOrderItem itemB = new ServiceOrderItem();
-    itemB.id("B");
-    itemB.action(actionType);
-    Service serviceB = new Service();
-    if (actionType != ActionType.ADD) {
-      serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
+    public static ServiceOrder createTestServiceOrderRejected() {
+        ServiceOrder serviceOrder = new ServiceOrder();
+        serviceOrder.setExternalId("LudONAP001");
+        serviceOrder.setPriority("1");
+        serviceOrder.setDescription("Ludo first ONAP Order");
+        serviceOrder.setCategory("Consumer");
+        serviceOrder.setRequestedStartDate(new Date());
+        serviceOrder.setRequestedCompletionDate(new Date());
+
+        RelatedParty party = new RelatedParty();
+        party.setId("6490");
+        party.setRole("ONAPcustomer");
+        party.setReferredType("individual");
+        party.setName("Jean Pontus");
+        List<RelatedParty> relatedPartyList = new ArrayList<>();
+        relatedPartyList.add(party);
+        serviceOrder.setRelatedParty(relatedPartyList);
+
+        List<ServiceOrderItem> items = new ArrayList<>();
+
+        ServiceOrderItem itemA = new ServiceOrderItem();
+        itemA.id("A");
+        itemA.action(ActionType.ADD);
+        Service serviceA = new Service();
+        serviceA.setServiceState("active");
+        ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
+        serviceSpecificationRefA.setId("333");
+        serviceA.setServiceSpecification(serviceSpecificationRefA);
+        itemA.setService(serviceA);
+        items.add(itemA);
+
+        ServiceOrderItem itemB = new ServiceOrderItem();
+        itemB.id("B");
+        itemB.action(ActionType.ADD);
+        Service serviceB = new Service();
+        serviceB.setServiceState("active");
+        ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
+        serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
+        serviceB.setServiceSpecification(serviceSpecificationRefB);
+        itemB.setService(serviceB);
+        List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
+        OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
+        orderItemRelationship.setId("A");
+        orderItemRelationships.add(orderItemRelationship);
+        itemB.setOrderItemRelationship(orderItemRelationships);
+        items.add(itemB);
+        serviceOrder.setOrderItem(items);
+        return serviceOrder;
+
     }
-    serviceB.setServiceState("active");
-    ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
-    serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
-    serviceB.setServiceSpecification(serviceSpecificationRefB);
-    itemB.setService(serviceB);
-    List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
-    OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
-    orderItemRelationship.setId("A");
-    orderItemRelationship.setType(RelationshipType.RELIESON);
-    orderItemRelationships.add(orderItemRelationship);
-    itemB.setOrderItemRelationship(orderItemRelationships);
-    items.add(itemB);
-    serviceOrder.setOrderItem(items);
-    return serviceOrder;
-
-  }
-
-
-  public static ExecutionTask setUpBddForExecutionTaskSucess(
-      ServiceOrderRepository serviceOrderRepository,
-      ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
-    ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
-
-    for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
-      serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+
+    public static ServiceOrder createTestServiceOrder(ActionType actionType) {
+        ServiceOrder serviceOrder = new ServiceOrder();
+        serviceOrder.setExternalId("LudONAP001");
+        serviceOrder.setPriority("1");
+        serviceOrder.setDescription("Ludo first ONAP Order");
+        serviceOrder.setCategory("Consumer");
+        serviceOrder.setRequestedStartDate(new Date());
+        serviceOrder.setRequestedCompletionDate(new Date());
+        serviceOrder.setBaseType("toto");
+        serviceOrder.setCompletionDateTime(new Date());
+        serviceOrder.setExpectedCompletionDate(new Date());
+        serviceOrder.setSchemaLocation("/tutu");
+
+        OrderRelationship orderRelationship = new OrderRelationship();
+        orderRelationship.setId("test");
+        orderRelationship.setHref("test");
+        orderRelationship.setReferredType("test");
+        orderRelationship.setType("type");
+        List<OrderRelationship> relationships = new ArrayList<>();
+        serviceOrder.setOrderRelationship(relationships);
+
+        RelatedParty party = new RelatedParty();
+        party.setId("6490");
+        party.setRole("ONAPcustomer");
+        party.setReferredType("individual");
+        party.setName("Jean Pontus");
+        List<RelatedParty> relatedPartyList = new ArrayList<>();
+        relatedPartyList.add(party);
+        serviceOrder.setRelatedParty(relatedPartyList);
+
+        List<ServiceOrderItem> items = new ArrayList<>();
+
+        ServiceOrderItem itemA = new ServiceOrderItem();
+        itemA.id("A");
+        itemA.action(actionType);
+        Service serviceA = new Service();
+        if (actionType != ActionType.ADD) {
+            serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
+        }
+        serviceA.setServiceState("active");
+        ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
+        serviceSpecificationRefA.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
+        serviceA.setServiceSpecification(serviceSpecificationRefA);
+        itemA.setService(serviceA);
+        items.add(itemA);
+
+        ServiceOrderItem itemB = new ServiceOrderItem();
+        itemB.id("B");
+        itemB.action(actionType);
+        Service serviceB = new Service();
+        if (actionType != ActionType.ADD) {
+            serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
+        }
+        serviceB.setServiceState("active");
+        ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
+        serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
+        serviceB.setServiceSpecification(serviceSpecificationRefB);
+        itemB.setService(serviceB);
+        List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
+        OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
+        orderItemRelationship.setId("A");
+        orderItemRelationship.setType(RelationshipType.RELIESON);
+        orderItemRelationships.add(orderItemRelationship);
+        itemB.setOrderItemRelationship(orderItemRelationships);
+        items.add(itemB);
+        serviceOrder.setOrderItem(items);
+        return serviceOrder;
+
     }
 
-    testServiceOrder.setState(StateType.ACKNOWLEDGED);
-    testServiceOrder.setId("test");
-    serviceOrderRepository.save(testServiceOrder);
-
-    LinkedHashMap<String, String> sdcResponse = new LinkedHashMap<>();
-    sdcResponse.put("invariantUUID", "uuid");
-    sdcResponse.put("name", "vFW");
-    sdcResponse.put("version", "v1");
-    sdcResponse.put("category", "NonE2E");
-
-    ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
-    serviceOrderInfo.setServiceOrderId("test");
-    SubscriberInfo subscriberInfo = new SubscriberInfo();
-    subscriberInfo.setGlobalSubscriberId("6490");
-    subscriberInfo.setSubscriberName("edgar");
-    serviceOrderInfo.setSubscriberInfo(subscriberInfo);
-
-    ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
-    serviceOrderItemInfoA.setId("A");
-    serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
-
-    ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
-    serviceOrderItemInfoB.setId("B");
-    serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
-    serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
-    serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
-
-    String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
-
-    ExecutionTask executionTaskA = new ExecutionTask();
-    executionTaskA.setCreateDate(new Date());
-    executionTaskA.setOrderItemId("A");
-    executionTaskA.setServiceOrderInfoJson(json);
-    executionTaskA = executionTaskRepository.save(executionTaskA);
-    ExecutionTask executionTaskB = new ExecutionTask();
-    executionTaskB.setCreateDate(new Date());
-    executionTaskB.setOrderItemId("B");
-    executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
-    executionTaskB.setServiceOrderInfoJson(json);
-    executionTaskRepository.save(executionTaskB);
-    return executionTaskA;
-  }
-
-  public static ExecutionTask setUpBddForE2EExecutionTaskSucess(
-      ServiceOrderRepository serviceOrderRepository,
-      ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
-    ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
-
-    for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
-      serviceOrderItem.setState(StateType.ACKNOWLEDGED);
-      List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
-      ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
-      serviceCharacteristic1.setName("access-site-id");
-      Value value1 = new Value();
-      value1.setServiceCharacteristicValue("1234765");
-      serviceCharacteristic1.setValue(value1);
-      serviceCharacteristics.add(serviceCharacteristic1);
-      ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
-      serviceCharacteristic2.setName("provider-site-id");
-      Value value2 = new Value();
-      value2.setServiceCharacteristicValue("654321");
-      serviceCharacteristic2.setValue(value2);
-      serviceCharacteristics.add(serviceCharacteristic2);
-      serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
+    public static ExecutionTask setUpBddForExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
+            ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
+        ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
+
+        for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+            serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+        }
+
+        testServiceOrder.setState(StateType.ACKNOWLEDGED);
+        testServiceOrder.setId("test");
+        serviceOrderRepository.save(testServiceOrder);
+
+        LinkedHashMap<String, String> sdcResponse = new LinkedHashMap<>();
+        sdcResponse.put("invariantUUID", "uuid");
+        sdcResponse.put("name", "vFW");
+        sdcResponse.put("version", "v1");
+        sdcResponse.put("category", "NonE2E");
+
+        ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
+        serviceOrderInfo.setServiceOrderId("test");
+        SubscriberInfo subscriberInfo = new SubscriberInfo();
+        subscriberInfo.setGlobalSubscriberId("6490");
+        subscriberInfo.setSubscriberName("edgar");
+        serviceOrderInfo.setSubscriberInfo(subscriberInfo);
+
+        ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
+        serviceOrderItemInfoA.setId("A");
+        serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
+
+        ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
+        serviceOrderItemInfoB.setId("B");
+        serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
+        serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
+        serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
+
+        String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
+
+        ExecutionTask executionTaskA = new ExecutionTask();
+        executionTaskA.setCreateDate(new Date());
+        executionTaskA.setOrderItemId("A");
+        executionTaskA.setServiceOrderInfoJson(json);
+        executionTaskA = executionTaskRepository.save(executionTaskA);
+        ExecutionTask executionTaskB = new ExecutionTask();
+        executionTaskB.setCreateDate(new Date());
+        executionTaskB.setOrderItemId("B");
+        executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
+        executionTaskB.setServiceOrderInfoJson(json);
+        executionTaskRepository.save(executionTaskB);
+        return executionTaskA;
     }
 
-    testServiceOrder.setState(StateType.ACKNOWLEDGED);
-    testServiceOrder.setId("test");
-    serviceOrderRepository.save(testServiceOrder);
-
-    LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
-    sdcResponse.put("invariantUUID", "uuid");
-    sdcResponse.put("name", "vFW");
-    sdcResponse.put("version", "v1");
-    sdcResponse.put("category", "E2E Service");
-
-    List<ResourceSpecification> resourceSpecs = new ArrayList<>();
-    ResourceSpecification resourceSpecificationA = new ResourceSpecification();
-    resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
-    resourceSpecificationA.setInstanceName("vFW-vSINK");
-    resourceSpecificationA.setName("vFW-SINK");
-    resourceSpecificationA.setType("ONAPresource");
-    resourceSpecificationA.setVersion("2.0");
-    resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
-    resourceSpecs.add(resourceSpecificationA);
-
-    sdcResponse.put("resourceSpecification", resourceSpecs);
-
-    ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
-    serviceOrderInfo.setServiceOrderId("test");
-    SubscriberInfo subscriberInfo = new SubscriberInfo();
-    subscriberInfo.setGlobalSubscriberId("6490");
-    subscriberInfo.setSubscriberName("edgar");
-    serviceOrderInfo.setSubscriberInfo(subscriberInfo);
-
-    ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
-    serviceOrderItemInfoA.setId("A");
-    serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
-
-    ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
-    serviceOrderItemInfoB.setId("B");
-    serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
-    serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
-    serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
-
-    String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
-
-    ExecutionTask executionTaskA = new ExecutionTask();
-    executionTaskA.setCreateDate(new Date());
-    executionTaskA.setOrderItemId("A");
-    executionTaskA.setServiceOrderInfoJson(json);
-    executionTaskA = executionTaskRepository.save(executionTaskA);
-    ExecutionTask executionTaskB = new ExecutionTask();
-    executionTaskB.setCreateDate(new Date());
-    executionTaskB.setOrderItemId("B");
-    executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
-    executionTaskB.setServiceOrderInfoJson(json);
-    executionTaskRepository.save(executionTaskB);
-    return executionTaskA;
-  }
-
-  public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithObject(
-      ServiceOrderRepository serviceOrderRepository,
-      ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
-    ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
-
-    for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
-      serviceOrderItem.setState(StateType.ACKNOWLEDGED);
-      List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
-      ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
-      serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
-      serviceCharacteristic1.setValueType("object");
-      Value value1 = new Value();
-      value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
-      serviceCharacteristic1.setValue(value1);
-      serviceCharacteristics.add(serviceCharacteristic1);
-      serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
+    public static ExecutionTask setUpBddForE2EExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
+            ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
+        ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
+
+        for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+            serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+            List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
+            ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
+            serviceCharacteristic1.setName("access-site-id");
+            Value value1 = new Value();
+            value1.setServiceCharacteristicValue("1234765");
+            serviceCharacteristic1.setValue(value1);
+            serviceCharacteristics.add(serviceCharacteristic1);
+            ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
+            serviceCharacteristic2.setName("provider-site-id");
+            Value value2 = new Value();
+            value2.setServiceCharacteristicValue("654321");
+            serviceCharacteristic2.setValue(value2);
+            serviceCharacteristics.add(serviceCharacteristic2);
+            serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
+        }
+
+        testServiceOrder.setState(StateType.ACKNOWLEDGED);
+        testServiceOrder.setId("test");
+        serviceOrderRepository.save(testServiceOrder);
+
+        LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
+        sdcResponse.put("invariantUUID", "uuid");
+        sdcResponse.put("name", "vFW");
+        sdcResponse.put("version", "v1");
+        sdcResponse.put("category", "E2E Service");
+
+        List<ResourceSpecification> resourceSpecs = new ArrayList<>();
+        ResourceSpecification resourceSpecificationA = new ResourceSpecification();
+        resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
+        resourceSpecificationA.setInstanceName("vFW-vSINK");
+        resourceSpecificationA.setName("vFW-SINK");
+        resourceSpecificationA.setType("ONAPresource");
+        resourceSpecificationA.setVersion("2.0");
+        resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
+        resourceSpecs.add(resourceSpecificationA);
+
+        sdcResponse.put("resourceSpecification", resourceSpecs);
+
+        ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
+        serviceOrderInfo.setServiceOrderId("test");
+        SubscriberInfo subscriberInfo = new SubscriberInfo();
+        subscriberInfo.setGlobalSubscriberId("6490");
+        subscriberInfo.setSubscriberName("edgar");
+        serviceOrderInfo.setSubscriberInfo(subscriberInfo);
+
+        ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
+        serviceOrderItemInfoA.setId("A");
+        serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
+
+        ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
+        serviceOrderItemInfoB.setId("B");
+        serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
+        serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
+        serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
+
+        String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
+
+        ExecutionTask executionTaskA = new ExecutionTask();
+        executionTaskA.setCreateDate(new Date());
+        executionTaskA.setOrderItemId("A");
+        executionTaskA.setServiceOrderInfoJson(json);
+        executionTaskA = executionTaskRepository.save(executionTaskA);
+        ExecutionTask executionTaskB = new ExecutionTask();
+        executionTaskB.setCreateDate(new Date());
+        executionTaskB.setOrderItemId("B");
+        executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
+        executionTaskB.setServiceOrderInfoJson(json);
+        executionTaskRepository.save(executionTaskB);
+        return executionTaskA;
     }
 
-    testServiceOrder.setState(StateType.ACKNOWLEDGED);
-    testServiceOrder.setId("test");
-    serviceOrderRepository.save(testServiceOrder);
-
-    LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
-    sdcResponse.put("invariantUUID", "uuid");
-    sdcResponse.put("name", "vFW");
-    sdcResponse.put("version", "v1");
-    sdcResponse.put("category", "E2E Service");
-
-    List<ResourceSpecification> resourceSpecs = new ArrayList<>();
-    ResourceSpecification resourceSpecificationA = new ResourceSpecification();
-    resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
-    resourceSpecificationA.setInstanceName("vFW-vSINK");
-    resourceSpecificationA.setName("vFW-SINK");
-    resourceSpecificationA.setType("ONAPresource");
-    resourceSpecificationA.setVersion("2.0");
-    resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
-    resourceSpecs.add(resourceSpecificationA);
-
-    sdcResponse.put("resourceSpecification", resourceSpecs);
-
-    ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
-    serviceOrderInfo.setServiceOrderId("test");
-    SubscriberInfo subscriberInfo = new SubscriberInfo();
-    subscriberInfo.setGlobalSubscriberId("6490");
-    subscriberInfo.setSubscriberName("edgar");
-    serviceOrderInfo.setSubscriberInfo(subscriberInfo);
-
-    ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
-    serviceOrderItemInfoA.setId("A");
-    serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
-
-    ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
-    serviceOrderItemInfoB.setId("B");
-    serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
-    serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
-    serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
-
-    String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
-
-    ExecutionTask executionTaskA = new ExecutionTask();
-    executionTaskA.setCreateDate(new Date());
-    executionTaskA.setOrderItemId("A");
-    executionTaskA.setServiceOrderInfoJson(json);
-    executionTaskA = executionTaskRepository.save(executionTaskA);
-    ExecutionTask executionTaskB = new ExecutionTask();
-    executionTaskB.setCreateDate(new Date());
-    executionTaskB.setOrderItemId("B");
-    executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
-    executionTaskB.setServiceOrderInfoJson(json);
-    executionTaskRepository.save(executionTaskB);
-    return executionTaskA;
-  }
-
-  public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithComplexObject(
-      ServiceOrderRepository serviceOrderRepository,
-      ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
-    ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
-
-    for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
-      serviceOrderItem.setState(StateType.ACKNOWLEDGED);
-      List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
-      ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
-      serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
-      serviceCharacteristic1.setValueType("object");
-      Value value1 = new Value();
-      // Three parameters , one is an array of child objects
-      value1.setServiceCharacteristicValue(
-          "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
-      serviceCharacteristic1.setValue(value1);
-      serviceCharacteristics.add(serviceCharacteristic1);
-      serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
+    public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithObject(
+            ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
+            ActionType actionType) {
+        ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
+
+        for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+            serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+            List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
+            ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
+            serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
+            serviceCharacteristic1.setValueType("object");
+            Value value1 = new Value();
+            value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
+            serviceCharacteristic1.setValue(value1);
+            serviceCharacteristics.add(serviceCharacteristic1);
+            serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
+        }
+
+        testServiceOrder.setState(StateType.ACKNOWLEDGED);
+        testServiceOrder.setId("test");
+        serviceOrderRepository.save(testServiceOrder);
+
+        LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
+        sdcResponse.put("invariantUUID", "uuid");
+        sdcResponse.put("name", "vFW");
+        sdcResponse.put("version", "v1");
+        sdcResponse.put("category", "E2E Service");
+
+        List<ResourceSpecification> resourceSpecs = new ArrayList<>();
+        ResourceSpecification resourceSpecificationA = new ResourceSpecification();
+        resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
+        resourceSpecificationA.setInstanceName("vFW-vSINK");
+        resourceSpecificationA.setName("vFW-SINK");
+        resourceSpecificationA.setType("ONAPresource");
+        resourceSpecificationA.setVersion("2.0");
+        resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
+        resourceSpecs.add(resourceSpecificationA);
+
+        sdcResponse.put("resourceSpecification", resourceSpecs);
+
+        ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
+        serviceOrderInfo.setServiceOrderId("test");
+        SubscriberInfo subscriberInfo = new SubscriberInfo();
+        subscriberInfo.setGlobalSubscriberId("6490");
+        subscriberInfo.setSubscriberName("edgar");
+        serviceOrderInfo.setSubscriberInfo(subscriberInfo);
+
+        ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
+        serviceOrderItemInfoA.setId("A");
+        serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
+
+        ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
+        serviceOrderItemInfoB.setId("B");
+        serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
+        serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
+        serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
+
+        String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
+
+        ExecutionTask executionTaskA = new ExecutionTask();
+        executionTaskA.setCreateDate(new Date());
+        executionTaskA.setOrderItemId("A");
+        executionTaskA.setServiceOrderInfoJson(json);
+        executionTaskA = executionTaskRepository.save(executionTaskA);
+        ExecutionTask executionTaskB = new ExecutionTask();
+        executionTaskB.setCreateDate(new Date());
+        executionTaskB.setOrderItemId("B");
+        executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
+        executionTaskB.setServiceOrderInfoJson(json);
+        executionTaskRepository.save(executionTaskB);
+        return executionTaskA;
     }
 
-    testServiceOrder.setState(StateType.ACKNOWLEDGED);
-    testServiceOrder.setId("test");
-    serviceOrderRepository.save(testServiceOrder);
-
-    LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
-    sdcResponse.put("invariantUUID", "uuid");
-    sdcResponse.put("name", "vFW");
-    sdcResponse.put("version", "v1");
-    sdcResponse.put("category", "E2E Service");
-
-    List<ResourceSpecification> resourceSpecs = new ArrayList<>();
-    ResourceSpecification resourceSpecificationA = new ResourceSpecification();
-    resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
-    resourceSpecificationA.setInstanceName("vFW-vSINK");
-    resourceSpecificationA.setName("vFW-SINK");
-    resourceSpecificationA.setType("ONAPresource");
-    resourceSpecificationA.setVersion("2.0");
-    resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
-    resourceSpecs.add(resourceSpecificationA);
-
-    sdcResponse.put("resourceSpecification", resourceSpecs);
-
-    ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
-    serviceOrderInfo.setServiceOrderId("test");
-    SubscriberInfo subscriberInfo = new SubscriberInfo();
-    subscriberInfo.setGlobalSubscriberId("6490");
-    subscriberInfo.setSubscriberName("edgar");
-    serviceOrderInfo.setSubscriberInfo(subscriberInfo);
-
-    ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
-    serviceOrderItemInfoA.setId("A");
-    serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
-
-    ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
-    serviceOrderItemInfoB.setId("B");
-    serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
-    serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
-    serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
-
-    String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
-
-    ExecutionTask executionTaskA = new ExecutionTask();
-    executionTaskA.setCreateDate(new Date());
-    executionTaskA.setOrderItemId("A");
-    executionTaskA.setServiceOrderInfoJson(json);
-    executionTaskA = executionTaskRepository.save(executionTaskA);
-    ExecutionTask executionTaskB = new ExecutionTask();
-    executionTaskB.setCreateDate(new Date());
-    executionTaskB.setOrderItemId("B");
-    executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
-    executionTaskB.setServiceOrderInfoJson(json);
-    executionTaskRepository.save(executionTaskB);
-    return executionTaskA;
-  }
+    public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithComplexObject(
+            ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
+            ActionType actionType) {
+        ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
+
+        for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
+            serviceOrderItem.setState(StateType.ACKNOWLEDGED);
+            List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
+            ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
+            serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
+            serviceCharacteristic1.setValueType("object");
+            Value value1 = new Value();
+            // Three parameters , one is an array of child objects
+            value1.setServiceCharacteristicValue(
+                    "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
+            serviceCharacteristic1.setValue(value1);
+            serviceCharacteristics.add(serviceCharacteristic1);
+            serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
+        }
+
+        testServiceOrder.setState(StateType.ACKNOWLEDGED);
+        testServiceOrder.setId("test");
+        serviceOrderRepository.save(testServiceOrder);
+
+        LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
+        sdcResponse.put("invariantUUID", "uuid");
+        sdcResponse.put("name", "vFW");
+        sdcResponse.put("version", "v1");
+        sdcResponse.put("category", "E2E Service");
+
+        List<ResourceSpecification> resourceSpecs = new ArrayList<>();
+        ResourceSpecification resourceSpecificationA = new ResourceSpecification();
+        resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
+        resourceSpecificationA.setInstanceName("vFW-vSINK");
+        resourceSpecificationA.setName("vFW-SINK");
+        resourceSpecificationA.setType("ONAPresource");
+        resourceSpecificationA.setVersion("2.0");
+        resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
+        resourceSpecs.add(resourceSpecificationA);
+
+        sdcResponse.put("resourceSpecification", resourceSpecs);
+
+        ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
+        serviceOrderInfo.setServiceOrderId("test");
+        SubscriberInfo subscriberInfo = new SubscriberInfo();
+        subscriberInfo.setGlobalSubscriberId("6490");
+        subscriberInfo.setSubscriberName("edgar");
+        serviceOrderInfo.setSubscriberInfo(subscriberInfo);
+
+        ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
+        serviceOrderItemInfoA.setId("A");
+        serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
+
+        ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
+        serviceOrderItemInfoB.setId("B");
+        serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
+        serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
+        serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
+
+        String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
+
+        ExecutionTask executionTaskA = new ExecutionTask();
+        executionTaskA.setCreateDate(new Date());
+        executionTaskA.setOrderItemId("A");
+        executionTaskA.setServiceOrderInfoJson(json);
+        executionTaskA = executionTaskRepository.save(executionTaskA);
+        ExecutionTask executionTaskB = new ExecutionTask();
+        executionTaskB.setCreateDate(new Date());
+        executionTaskB.setOrderItemId("B");
+        executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
+        executionTaskB.setServiceOrderInfoJson(json);
+        executionTaskRepository.save(executionTaskB);
+        return executionTaskA;
+    }
 }
diff --git a/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java b/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java
index 9742d88..e02cdc0 100644
--- a/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java
+++ b/src/test/java/org/onap/nbi/apis/servicecatalog/ToscaInfosProcessorTest.java
@@ -11,6 +11,7 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
+
 package org.onap.nbi.apis.servicecatalog;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -31,223 +32,209 @@ import org.springframework.test.context.junit4.SpringRunner;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
 
-
 @RunWith(SpringRunner.class)
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
 @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
 @ActiveProfiles("test")
 public class ToscaInfosProcessorTest {
 
-  @Autowired
-  ToscaInfosProcessor toscaInfosProcessor;
-  final ObjectMapper mapper = new ObjectMapper(new YAMLFactory()); // jackson databind
-
-
-  @Test
-  public void buildResponseWithSdcToscaParser() {
-
-    ClassLoader classLoader = getClass().getClassLoader();
-    Path path = new File(
-        classLoader.getResource("toscafile/service-Sdwanvpninfraservice-csar.csar").getFile())
-            .toPath().toAbsolutePath();
-    List<LinkedHashMap> resources = new ArrayList<>();
-    LinkedHashMap resource1 = new LinkedHashMap();
-    resource1.put("id", "7baa7742-3a13-4288-8330-868015adc340");
-    resources.add(resource1);
-    LinkedHashMap resource2 = new LinkedHashMap();
-    resource2.put("id", "81b9430b-8abe-45d6-8bf9-f41a8f5c735f");
-    resources.add(resource2);
-    LinkedHashMap response = new LinkedHashMap();
-    response.put("resourceSpecification", resources);
-
-    try {
-      toscaInfosProcessor.buildResponseWithSdcToscaParser(path, response);
-    } catch (SdcToscaParserException e) {
-      throw new TechnicalException("unable to build response from tosca csar using sdc-parser : "
-          + path.toString() + " " + e.getMessage());
+    @Autowired
+    ToscaInfosProcessor toscaInfosProcessor;
+    final ObjectMapper mapper = new ObjectMapper(new YAMLFactory()); // jackson databind
+
+    @Test
+    public void buildResponseWithSdcToscaParser() {
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        Path path = new File(classLoader.getResource("toscafile/service-Sdwanvpninfraservice-csar.csar").getFile())
+                .toPath().toAbsolutePath();
+        List<LinkedHashMap> resources = new ArrayList<>();
+        LinkedHashMap resource1 = new LinkedHashMap();
+        resource1.put("id", "7baa7742-3a13-4288-8330-868015adc340");
+        resources.add(resource1);
+        LinkedHashMap resource2 = new LinkedHashMap();
+        resource2.put("id", "81b9430b-8abe-45d6-8bf9-f41a8f5c735f");
+        resources.add(resource2);
+        LinkedHashMap response = new LinkedHashMap();
+        response.put("resourceSpecification", resources);
+
+        try {
+            toscaInfosProcessor.buildResponseWithSdcToscaParser(path, response);
+        } catch (SdcToscaParserException e) {
+            throw new TechnicalException("unable to build response from tosca csar using sdc-parser : "
+                    + path.toString() + " " + e.getMessage());
+        }
+        resources = (List<LinkedHashMap>) response.get("resourceSpecification");
+        List<LinkedHashMap> serviceSpecCharacteristic = new ArrayList<>();
+        serviceSpecCharacteristic = (List<LinkedHashMap>) response.get("serviceSpecCharacteristic");
+        assertThat(serviceSpecCharacteristic.get(0).get("name")).isEqualTo("sdwanconnectivity0_topology");
+        assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
+        assertThat(serviceSpecCharacteristic.get(0).get("required")).isEqualTo(true);
+        assertThat(serviceSpecCharacteristic.get(1).get("name")).isEqualTo("sdwanconnectivity0_name");
+        assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
+        assertThat(serviceSpecCharacteristic.get(1).get("required")).isEqualTo(true);
+        assertThat(resources.get(0).get("modelCustomizationId")).isEqualTo("94ec574b-2306-4cbd-8214-09662b040f73");
+        assertThat(resources.get(1).get("modelCustomizationId")).isEqualTo("a7baba5d-6ac3-42b5-b47d-070841303ab1");
+
     }
-    resources = (List<LinkedHashMap>) response.get("resourceSpecification");
-    List<LinkedHashMap> serviceSpecCharacteristic = new ArrayList<>();
-    serviceSpecCharacteristic = (List<LinkedHashMap>) response.get("serviceSpecCharacteristic");
-    assertThat(serviceSpecCharacteristic.get(0).get("name"))
-        .isEqualTo("sdwanconnectivity0_topology");
-    assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
-    assertThat(serviceSpecCharacteristic.get(0).get("required")).isEqualTo(true);
-    assertThat(serviceSpecCharacteristic.get(1).get("name")).isEqualTo("sdwanconnectivity0_name");
-    assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
-    assertThat(serviceSpecCharacteristic.get(1).get("required")).isEqualTo(true);
-    assertThat(resources.get(0).get("modelCustomizationId"))
-        .isEqualTo("94ec574b-2306-4cbd-8214-09662b040f73");
-    assertThat(resources.get(1).get("modelCustomizationId"))
-        .isEqualTo("a7baba5d-6ac3-42b5-b47d-070841303ab1");
-
-  }
-
-  @Test
-  public void buildResponseWithSdcToscaParserWithDefaultInputs() {
-
-    ClassLoader classLoader = getClass().getClassLoader();
-    Path path = new File(
-        classLoader.getResource("toscafile/service-Sotnvpninfraservice-csar.csar").getFile())
-            .toPath().toAbsolutePath();
-    List<LinkedHashMap> resources = new ArrayList<>();
-    LinkedHashMap resource1 = new LinkedHashMap();
-    resource1.put("id", "218df3c3-50dd-4c26-9e36-4771387bb771");
-    resources.add(resource1);
-    LinkedHashMap resource2 = new LinkedHashMap();
-    resource2.put("id", "81b9430b-8abe-45d6-8bf9-f41a8f5c735f");
-    resources.add(resource2);
-    LinkedHashMap response = new LinkedHashMap();
-    response.put("resourceSpecification", resources);
-
-    try {
-      toscaInfosProcessor.buildResponseWithSdcToscaParser(path, response);
-    } catch (SdcToscaParserException e) {
-      throw new TechnicalException("unable to build response from tosca csar using sdc-parser : "
-          + path.toString() + " " + e.getMessage());
+
+    @Test
+    public void buildResponseWithSdcToscaParserWithDefaultInputs() {
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        Path path = new File(classLoader.getResource("toscafile/service-Sotnvpninfraservice-csar.csar").getFile())
+                .toPath().toAbsolutePath();
+        List<LinkedHashMap> resources = new ArrayList<>();
+        LinkedHashMap resource1 = new LinkedHashMap();
+        resource1.put("id", "218df3c3-50dd-4c26-9e36-4771387bb771");
+        resources.add(resource1);
+        LinkedHashMap resource2 = new LinkedHashMap();
+        resource2.put("id", "81b9430b-8abe-45d6-8bf9-f41a8f5c735f");
+        resources.add(resource2);
+        LinkedHashMap response = new LinkedHashMap();
+        response.put("resourceSpecification", resources);
+
+        try {
+            toscaInfosProcessor.buildResponseWithSdcToscaParser(path, response);
+        } catch (SdcToscaParserException e) {
+            throw new TechnicalException("unable to build response from tosca csar using sdc-parser : "
+                    + path.toString() + " " + e.getMessage());
+        }
+        resources = (List<LinkedHashMap>) response.get("resourceSpecification");
+        List<LinkedHashMap> serviceSpecCharacteristic = new ArrayList<>();
+        serviceSpecCharacteristic = (List<LinkedHashMap>) response.get("serviceSpecCharacteristic");
+        assertThat(resources.get(0).get("modelCustomizationId")).isEqualTo("b44071c8-04fd-4d6b-b6af-772cbfaa1129");
+        assertThat(resources.get(1).get("modelCustomizationId")).isEqualTo("c3612284-6c67-4d8c-8b41-b699cc90e76d");
+        assertThat(serviceSpecCharacteristic.get(12).get("serviceSpecCharacteristicValue")).isNull();
+        assertThat(serviceSpecCharacteristic.get(13).get("serviceSpecCharacteristicValue")).isNotNull();
     }
-    resources = (List<LinkedHashMap>) response.get("resourceSpecification");
-    List<LinkedHashMap> serviceSpecCharacteristic = new ArrayList<>();
-    serviceSpecCharacteristic = (List<LinkedHashMap>) response.get("serviceSpecCharacteristic");
-    assertThat(resources.get(0).get("modelCustomizationId"))
-        .isEqualTo("b44071c8-04fd-4d6b-b6af-772cbfaa1129");
-    assertThat(resources.get(1).get("modelCustomizationId"))
-        .isEqualTo("c3612284-6c67-4d8c-8b41-b699cc90e76d");
-    assertThat(serviceSpecCharacteristic.get(12).get("serviceSpecCharacteristicValue")).isNull();
-    assertThat(serviceSpecCharacteristic.get(13).get("serviceSpecCharacteristicValue")).isNotNull();
-  }
-
-  @Test
-  public void buildResponseWithSdcToscaParserwithMetaDataMisMatch() {
-
-    ClassLoader classLoader = getClass().getClassLoader();
-    Path path = new File(
-        classLoader.getResource("toscafile/service-Sdwanvpninfraservice-csar.csar").getFile())
-            .toPath().toAbsolutePath();
-    List<LinkedHashMap> resources = new ArrayList<>();
-    LinkedHashMap resource1 = new LinkedHashMap();
-    resource1.put("id", "some bad resource id no in TOSCA CSAR");
-    resources.add(resource1);
-    LinkedHashMap resource2 = new LinkedHashMap();
-    resource2.put("id", "some bad resource id no in TOSCA CSAR");
-    resources.add(resource2);
-    LinkedHashMap response = new LinkedHashMap();
-    response.put("resourceSpecification", resources);
-
-    try {
-      toscaInfosProcessor.buildResponseWithSdcToscaParser(path, response);
-    } catch (SdcToscaParserException e) {
-      throw new TechnicalException("unable to build response from tosca csar using sdc-parser : "
-          + path.toString() + " " + e.getMessage());
+
+    @Test
+    public void buildResponseWithSdcToscaParserwithMetaDataMisMatch() {
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        Path path = new File(classLoader.getResource("toscafile/service-Sdwanvpninfraservice-csar.csar").getFile())
+                .toPath().toAbsolutePath();
+        List<LinkedHashMap> resources = new ArrayList<>();
+        LinkedHashMap resource1 = new LinkedHashMap();
+        resource1.put("id", "some bad resource id no in TOSCA CSAR");
+        resources.add(resource1);
+        LinkedHashMap resource2 = new LinkedHashMap();
+        resource2.put("id", "some bad resource id no in TOSCA CSAR");
+        resources.add(resource2);
+        LinkedHashMap response = new LinkedHashMap();
+        response.put("resourceSpecification", resources);
+
+        try {
+            toscaInfosProcessor.buildResponseWithSdcToscaParser(path, response);
+        } catch (SdcToscaParserException e) {
+            throw new TechnicalException("unable to build response from tosca csar using sdc-parser : "
+                    + path.toString() + " " + e.getMessage());
+        }
+        resources = (List<LinkedHashMap>) response.get("resourceSpecification");
+        List<LinkedHashMap> serviceSpecCharacteristic = new ArrayList<>();
+        serviceSpecCharacteristic = (List<LinkedHashMap>) response.get("serviceSpecCharacteristic");
+        assertThat(serviceSpecCharacteristic.get(0).get("name")).isEqualTo("sdwanconnectivity0_topology");
+        assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
+        assertThat(serviceSpecCharacteristic.get(0).get("required")).isEqualTo(true);
+        assertThat(serviceSpecCharacteristic.get(1).get("name")).isEqualTo("sdwanconnectivity0_name");
+        assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
+        assertThat(serviceSpecCharacteristic.get(1).get("required")).isEqualTo(true);
+        // Check that resources cannot be found in the TOSCA template
+        assertThat(resources.get(0).get("modelCustomizationId")).isNull();
+        assertThat(resources.get(1).get("modelCustomizationId")).isNull();
+
     }
-    resources = (List<LinkedHashMap>) response.get("resourceSpecification");
-    List<LinkedHashMap> serviceSpecCharacteristic = new ArrayList<>();
-    serviceSpecCharacteristic = (List<LinkedHashMap>) response.get("serviceSpecCharacteristic");
-    assertThat(serviceSpecCharacteristic.get(0).get("name"))
-        .isEqualTo("sdwanconnectivity0_topology");
-    assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
-    assertThat(serviceSpecCharacteristic.get(0).get("required")).isEqualTo(true);
-    assertThat(serviceSpecCharacteristic.get(1).get("name")).isEqualTo("sdwanconnectivity0_name");
-    assertThat(serviceSpecCharacteristic.get(1).get("valueType")).isEqualTo("string");
-    assertThat(serviceSpecCharacteristic.get(1).get("required")).isEqualTo(true);
-    // Check that resources cannot be found in the TOSCA template
-    assertThat(resources.get(0).get("modelCustomizationId")).isNull();
-    assertThat(resources.get(1).get("modelCustomizationId")).isNull();
-
-  }
-
-  @Test
-  public void testBuildAndSaveResponseWithSdcToscaParser() {
-
-    ClassLoader classLoader = getClass().getClassLoader();
-    Path path = new File(
-        classLoader.getResource("toscafile/service-Sotnvpninfraservice-csar.csar").getFile())
-            .toPath().toAbsolutePath();
-
-    LinkedHashMap response = new LinkedHashMap();
-    response.put("version", "1.0");
-    response.put("name", "Service_vMME");
-    response.put("description", "some service characteristics schema");
-    response.put("id", "7f5e5139-768d-4410-a871-c41430785214");
-
-    List<LinkedHashMap> resources = new ArrayList<>();
-    LinkedHashMap resource1 = new LinkedHashMap();
-    resource1.put("id", "7baa7742-3a13-4288-8330-868015adc340");
-    resources.add(resource1);
-    LinkedHashMap resource2 = new LinkedHashMap();
-    resource2.put("id", "81b9430b-8abe-45d6-8bf9-f41a8f5c735f");
-    resources.add(resource2);
-
-    response.put("resourceSpecification", resources);
-
-    LinkedHashMap serviceSpecCharacteristicValue = new LinkedHashMap();
-    serviceSpecCharacteristicValue.put("valueType", "object");
-    serviceSpecCharacteristicValue.put("@schemaLocation",
-        "/serviceSpecification/7f5e5139-768d-4410-a871-c41430785214/specificationInputSchema");
-    serviceSpecCharacteristicValue.put("@type", "Service_vMME_ServiceCharacteristic");
-
-    LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap();
-    serviceSpecCharacteristic.put("name", "Service_vMME_ServiceCharacteristics");
-    serviceSpecCharacteristic.put("description",
-        "This object describes all the inputs needed from the client to interact with the Service_vMME Service Topology");
-    // using object to match examples in specifications
-    serviceSpecCharacteristic.put("valueType", "object");
-    serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic");
-    serviceSpecCharacteristic.put("@schemaLocation", "null");
-    serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", serviceSpecCharacteristicValue);
-    try {
-      toscaInfosProcessor.buildAndSaveResponseWithSdcToscaParser(path, response);
-    } catch (SdcToscaParserException ex) {
-      throw new TechnicalException("unable to build response " + ex.getMessage());
+
+    @Test
+    public void testBuildAndSaveResponseWithSdcToscaParser() {
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        Path path = new File(classLoader.getResource("toscafile/service-Sotnvpninfraservice-csar.csar").getFile())
+                .toPath().toAbsolutePath();
+
+        LinkedHashMap response = new LinkedHashMap();
+        response.put("version", "1.0");
+        response.put("name", "Service_vMME");
+        response.put("description", "some service characteristics schema");
+        response.put("id", "7f5e5139-768d-4410-a871-c41430785214");
+
+        List<LinkedHashMap> resources = new ArrayList<>();
+        LinkedHashMap resource1 = new LinkedHashMap();
+        resource1.put("id", "7baa7742-3a13-4288-8330-868015adc340");
+        resources.add(resource1);
+        LinkedHashMap resource2 = new LinkedHashMap();
+        resource2.put("id", "81b9430b-8abe-45d6-8bf9-f41a8f5c735f");
+        resources.add(resource2);
+
+        response.put("resourceSpecification", resources);
+
+        LinkedHashMap serviceSpecCharacteristicValue = new LinkedHashMap();
+        serviceSpecCharacteristicValue.put("valueType", "object");
+        serviceSpecCharacteristicValue.put("@schemaLocation",
+                "/serviceSpecification/7f5e5139-768d-4410-a871-c41430785214/specificationInputSchema");
+        serviceSpecCharacteristicValue.put("@type", "Service_vMME_ServiceCharacteristic");
+
+        LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap();
+        serviceSpecCharacteristic.put("name", "Service_vMME_ServiceCharacteristics");
+        serviceSpecCharacteristic.put("description",
+                "This object describes all the inputs needed from the client to interact with the Service_vMME Service Topology");
+        // using object to match examples in specifications
+        serviceSpecCharacteristic.put("valueType", "object");
+        serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic");
+        serviceSpecCharacteristic.put("@schemaLocation", "null");
+        serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", serviceSpecCharacteristicValue);
+        try {
+            toscaInfosProcessor.buildAndSaveResponseWithSdcToscaParser(path, response);
+        } catch (SdcToscaParserException ex) {
+            throw new TechnicalException("unable to build response " + ex.getMessage());
+        }
+        assertThat(response.get("serviceSpecCharacteristic")).isEqualTo(serviceSpecCharacteristic);
     }
-    assertThat(response.get("serviceSpecCharacteristic")).isEqualTo(serviceSpecCharacteristic);
-  }
-  
-  
-  @Test
-  public void testBuildAndSaveResponseWithSdcToscaParserWithInputListType() {
-
-    ClassLoader classLoader = getClass().getClassLoader();
-    Path path = new File(
-        classLoader.getResource("toscafile/service-MscmEvplService-csar.csar").getFile())
-            .toPath().toAbsolutePath();
-
-    LinkedHashMap response = new LinkedHashMap();
-    response.put("version", "1.0");
-    response.put("name", "MSCM-EVPL-Service");
-    response.put("description", "MSCM EVPL Service");
-    response.put("id", "66a66cc3-178c-45fd-82c2-494336cb3665");
-
-    List<LinkedHashMap> resources = new ArrayList<>();
-    LinkedHashMap resource1 = new LinkedHashMap();
-    resource1.put("id", "f5f487df-8c02-4485-81d4-695c50e24b22");
-    resources.add(resource1);
-    LinkedHashMap resource2 = new LinkedHashMap();
-    resource2.put("id", "65c34b35-e8ab-426a-b048-d707467f68b2");
-    resources.add(resource2);
-
-    response.put("resourceSpecification", resources);
-
-    LinkedHashMap serviceSpecCharacteristicValue = new LinkedHashMap();
-    serviceSpecCharacteristicValue.put("valueType", "object");
-    serviceSpecCharacteristicValue.put("@schemaLocation",
-        "/serviceSpecification/66a66cc3-178c-45fd-82c2-494336cb3665/specificationInputSchema");
-    serviceSpecCharacteristicValue.put("@type", "MSCM-EVPL-Service_ServiceCharacteristic");
-
-    LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap();
-    serviceSpecCharacteristic.put("name", "MSCM-EVPL-Service_ServiceCharacteristics");
-    serviceSpecCharacteristic.put("description",
-        "This object describes all the inputs needed from the client to interact with the MSCM-EVPL-Service Service Topology");
-    // using object to match examples in specifications
-    serviceSpecCharacteristic.put("valueType", "object");
-    serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic");
-    serviceSpecCharacteristic.put("@schemaLocation", "null");
-    serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", serviceSpecCharacteristicValue);
-    try {
-      toscaInfosProcessor.buildAndSaveResponseWithSdcToscaParser(path, response);
-    } catch (SdcToscaParserException ex) {
-      throw new TechnicalException("unable to build response " + ex.getMessage());
+
+    @Test
+    public void testBuildAndSaveResponseWithSdcToscaParserWithInputListType() {
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        Path path = new File(classLoader.getResource("toscafile/service-MscmEvplService-csar.csar").getFile()).toPath()
+                .toAbsolutePath();
+
+        LinkedHashMap response = new LinkedHashMap();
+        response.put("version", "1.0");
+        response.put("name", "MSCM-EVPL-Service");
+        response.put("description", "MSCM EVPL Service");
+        response.put("id", "66a66cc3-178c-45fd-82c2-494336cb3665");
+
+        List<LinkedHashMap> resources = new ArrayList<>();
+        LinkedHashMap resource1 = new LinkedHashMap();
+        resource1.put("id", "f5f487df-8c02-4485-81d4-695c50e24b22");
+        resources.add(resource1);
+        LinkedHashMap resource2 = new LinkedHashMap();
+        resource2.put("id", "65c34b35-e8ab-426a-b048-d707467f68b2");
+        resources.add(resource2);
+
+        response.put("resourceSpecification", resources);
+
+        LinkedHashMap serviceSpecCharacteristicValue = new LinkedHashMap();
+        serviceSpecCharacteristicValue.put("valueType", "object");
+        serviceSpecCharacteristicValue.put("@schemaLocation",
+                "/serviceSpecification/66a66cc3-178c-45fd-82c2-494336cb3665/specificationInputSchema");
+        serviceSpecCharacteristicValue.put("@type", "MSCM-EVPL-Service_ServiceCharacteristic");
+
+        LinkedHashMap serviceSpecCharacteristic = new LinkedHashMap();
+        serviceSpecCharacteristic.put("name", "MSCM-EVPL-Service_ServiceCharacteristics");
+        serviceSpecCharacteristic.put("description",
+                "This object describes all the inputs needed from the client to interact with the MSCM-EVPL-Service Service Topology");
+        // using object to match examples in specifications
+        serviceSpecCharacteristic.put("valueType", "object");
+        serviceSpecCharacteristic.put("@type", "ONAPServiceCharacteristic");
+        serviceSpecCharacteristic.put("@schemaLocation", "null");
+        serviceSpecCharacteristic.put("serviceSpecCharacteristicValue", serviceSpecCharacteristicValue);
+        try {
+            toscaInfosProcessor.buildAndSaveResponseWithSdcToscaParser(path, response);
+        } catch (SdcToscaParserException ex) {
+            throw new TechnicalException("unable to build response " + ex.getMessage());
+        }
+        assertThat(response.get("serviceSpecCharacteristic")).isEqualTo(serviceSpecCharacteristic);
     }
-    assertThat(response.get("serviceSpecCharacteristic")).isEqualTo(serviceSpecCharacteristic);
-  }
 }
diff --git a/src/test/java/org/onap/nbi/test/Context.java b/src/test/java/org/onap/nbi/test/Context.java
index 10ad2c2..e1066fd 100644
--- a/src/test/java/org/onap/nbi/test/Context.java
+++ b/src/test/java/org/onap/nbi/test/Context.java
@@ -11,6 +11,7 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
+
 package org.onap.nbi.test;
 
 import com.github.tomakehurst.wiremock.WireMockServer;
@@ -25,81 +26,80 @@ import org.springframework.web.context.request.ServletRequestAttributes;
 
 public class Context {
 
+    public static ConfigurableApplicationContext nbiServer;
 
-  public static ConfigurableApplicationContext nbiServer;
+    public static WireMockServer wireMockServer;
 
-  public static WireMockServer wireMockServer;
+    public static void startServers() throws Exception {
+        startWiremock();
 
-  public static void startServers() throws Exception {
-    startWiremock();
+        // NBI
+        if (nbiServer == null) {
+            String[] args = new String[1];
+            args[0] = "--spring.profiles.active=test";
+            nbiServer = Application.run(args);
+            MockHttpServletRequest request = new MockHttpServletRequest();
+            RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
+        }
 
-    // NBI
-    if (nbiServer == null) {
-      String[] args = new String[1];
-      args[0] = "--spring.profiles.active=test";
-      nbiServer = Application.run(args);
-      MockHttpServletRequest request = new MockHttpServletRequest();
-      RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
     }
 
-  }
-
-  public static void startWiremock() {
-    // Wiremock
-    // If wireMockServer was previously created
-    if (wireMockServer != null) {
-      wireMockServer.stop();
-      wireMockServer.resetToDefaultMappings();
-    } else {
-      wireMockServer =
-          new WireMockServer(
-              WireMockConfiguration.wireMockConfig().port(8091).jettyStopTimeout(1000L));
+    public static void startWiremock() {
+        // Wiremock
+        // If wireMockServer was previously created
+        if (wireMockServer != null) {
+            wireMockServer.stop();
+            wireMockServer.resetToDefaultMappings();
+        } else {
+            wireMockServer =
+                    new WireMockServer(WireMockConfiguration.wireMockConfig().port(8091).jettyStopTimeout(1000L));
+        }
+
+        wireMockServer.start();
     }
 
-    wireMockServer.start();
-  }
+    public static void removeWireMockMapping(String mappingToBeRemoved) {
 
-  public static void removeWireMockMapping(String mappingToBeRemoved) {
+        if (mappingToBeRemoved == null) {
+            return;
+        }
 
-    if (mappingToBeRemoved == null) {
-      return;
-    }
+        // Get current mappings
+        List<StubMapping> mappings = wireMockServer.listAllStubMappings().getMappings();
 
-    // Get current mappings
-    List<StubMapping> mappings = wireMockServer.listAllStubMappings().getMappings();
+        StubMapping mappingToDelete = null;
+        for (StubMapping mapping : mappings) {
+            if (mapping.getRequest().getUrl().equals(mappingToBeRemoved)) {
+                mappingToDelete = mapping;
+            }
+        }
 
-    StubMapping mappingToDelete = null;
-    for (StubMapping mapping : mappings) {
-      if (mapping.getRequest().getUrl().equals(mappingToBeRemoved)) {
-        mappingToDelete = mapping;
-      }
+        if (mappingToDelete != null) {
+            wireMockServer.removeStubMapping(mappingToDelete);
+        }
     }
 
-    if (mappingToDelete != null) {
-      wireMockServer.removeStubMapping(mappingToDelete);
-    }
-  }
+    public static void stopServers() throws Exception {
 
-  public static void stopServers() throws Exception {
+        // NBI
+        if (nbiServer != null) { // keep spring boot side alive for all tests including package
+            // 'mock'
+            nbiServer.close();
+        }
 
-    // NBI
-    if (nbiServer != null) { // keep spring boot side alive for all tests including package
-      // 'mock'
-      nbiServer.close();
-    }
+        // Wiremock
+        if (wireMockServer != null) {
+            wireMockServer.stop();
+        }
 
-    // Wiremock
-    if (wireMockServer != null) {
-      wireMockServer.stop();
     }
 
-  }
-  public static void stopWiremock() throws Exception {
+    public static void stopWiremock() throws Exception {
 
-    // Wiremock
-    if (wireMockServer != null) {
-      wireMockServer.stop();
-    }
+        // Wiremock
+        if (wireMockServer != null) {
+            wireMockServer.stop();
+        }
 
-  }
+    }
 }
diff --git a/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java b/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java
index 4d32672..ca33c39 100644
--- a/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java
+++ b/src/test/java/org/onap/nbi/test/ExecutionTaskTest.java
@@ -11,8 +11,8 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-package org.onap.nbi.test;
 
+package org.onap.nbi.test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import java.util.Calendar;
@@ -56,615 +56,550 @@ import com.github.tomakehurst.wiremock.stubbing.StubMapping;
 @DirtiesContext(classMode = ClassMode.AFTER_CLASS)
 public class ExecutionTaskTest {
 
-  @Autowired
-  ServiceOrderRepository serviceOrderRepository;
-
-  @Autowired
-  ExecutionTaskRepository executionTaskRepository;
-
-  @Autowired
-  SOTaskProcessor SoTaskProcessor;
-
-
-  static Validator validator;
-
-  @Before
-  public void before() {
-    MockHttpServletRequest request = new MockHttpServletRequest();
-    RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
-  }
-
-  @BeforeClass
-  public static void setUp() throws Exception {
-    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
-    validator = factory.getValidator();
-    Context.startWiremock();
-  }
-
-  @AfterClass
-  public static void tearsDown() throws Exception {
-    Context.stopServers();
+    @Autowired
+    ServiceOrderRepository serviceOrderRepository;
 
-  }
+    @Autowired
+    ExecutionTaskRepository executionTaskRepository;
 
-  @After
-  public void tearsDownUpPort() throws Exception {
-    executionTaskRepository.deleteAll();
-    serviceOrderRepository.deleteAll();
-    Context.wireMockServer.resetToDefaultMappings();
+    @Autowired
+    SOTaskProcessor SoTaskProcessor;
 
-  }
+    static Validator validator;
 
-
-  public ExecutionTask getExecutionTask(String orderItemId) {
-    for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
-      if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
-        return executionTask;
-      }
-
-    }
-    return null;
-  }
-
-  private void changeWireMockResponse(String s, int statusCode, String bodyContent) {
-    ListStubMappingsResult listStubMappingsResult = Context.wireMockServer.listAllStubMappings();
-    ResponseDefinition responseDefinition = new ResponseDefinition(statusCode, bodyContent);
-    List<StubMapping> mappings = listStubMappingsResult.getMappings();
-    for (StubMapping mapping : mappings) {
-      if (mapping.getRequest().getUrl().equals(s)) {
-        mapping.setResponse(responseDefinition);
-      }
+    @Before
+    public void before() {
+        MockHttpServletRequest request = new MockHttpServletRequest();
+        RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
     }
-  }
-
-
-  private ServiceOrder getServiceOrder(String serviceOrderId) {
-    Optional<ServiceOrder> serviceOrderChecked = serviceOrderRepository.findById(serviceOrderId);
-    return serviceOrderChecked.get();
-  }
-
-
-
-  @Test
-  public void testExecutionTaskSuccess() throws Exception {
-
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.ADD);
-    ExecutionTask executionTaskB;
 
-
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
+    @BeforeClass
+    public static void setUp() throws Exception {
+        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+        validator = factory.getValidator();
+        Context.startWiremock();
     }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
-
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+    @AfterClass
+    public static void tearsDown() throws Exception {
+        Context.stopServers();
 
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
-
-
-  }
+    @After
+    public void tearsDownUpPort() throws Exception {
+        executionTaskRepository.deleteAll();
+        serviceOrderRepository.deleteAll();
+        Context.wireMockServer.resetToDefaultMappings();
 
-  @Test
-  public void testE2EExecutionTaskSuccess() throws Exception {
-
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
-            serviceOrderRepository, executionTaskRepository, ActionType.ADD);
-    ExecutionTask executionTaskB;
-
-
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
     }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
-
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+    public ExecutionTask getExecutionTask(String orderItemId) {
+        for (ExecutionTask executionTask : executionTaskRepository.findAll()) {
+            if (executionTask.getOrderItemId().equalsIgnoreCase(orderItemId)) {
+                return executionTask;
+            }
 
+        }
+        return null;
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
-
-
-  }
-
-  @Test
-  public void testE2EExecutionTaskSuccessWithObject() throws Exception {
-
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithObject(
-            serviceOrderRepository, executionTaskRepository, ActionType.ADD);
-    ExecutionTask executionTaskB;
-
-
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
+    private void changeWireMockResponse(String s, int statusCode, String bodyContent) {
+        ListStubMappingsResult listStubMappingsResult = Context.wireMockServer.listAllStubMappings();
+        ResponseDefinition responseDefinition = new ResponseDefinition(statusCode, bodyContent);
+        List<StubMapping> mappings = listStubMappingsResult.getMappings();
+        for (StubMapping mapping : mappings) {
+            if (mapping.getRequest().getUrl().equals(s)) {
+                mapping.setResponse(responseDefinition);
+            }
+        }
     }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
-
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-
+    private ServiceOrder getServiceOrder(String serviceOrderId) {
+        Optional<ServiceOrder> serviceOrderChecked = serviceOrderRepository.findById(serviceOrderId);
+        return serviceOrderChecked.get();
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
+    @Test
+    public void testExecutionTaskSuccess() throws Exception {
 
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+        ExecutionTask executionTaskB;
 
-  }
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
 
-  @Test
-  public void testE2EExecutionTaskSuccessWithComplexObject() throws Exception {
-    // A Service Order with complex object including arrays
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithComplexObject(
-            serviceOrderRepository, executionTaskRepository, ActionType.ADD);
-    ExecutionTask executionTaskB;
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
 
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
-    }
+        }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
-
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+    @Test
+    public void testE2EExecutionTaskSuccess() throws Exception {
 
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+        ExecutionTask executionTaskB;
 
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
 
-  }
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
 
-  @Test
-  public void testExecutionTaskDeleteSuccess() throws Exception {
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.DELETE);
-    ExecutionTask executionTaskB;
+        }
 
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
     }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
+    @Test
+    public void testE2EExecutionTaskSuccessWithObject() throws Exception {
 
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithObject(
+                serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+        ExecutionTask executionTaskB;
 
-    }
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
 
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 
+        }
 
-  }
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-  @Test
-  public void testE2EExecutionTaskDeleteSuccess() throws Exception {
-
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
-            serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
-    ExecutionTask executionTaskB;
+    }
 
+    @Test
+    public void testE2EExecutionTaskSuccessWithComplexObject() throws Exception {
+        // A Service Order with complex object including arrays
+        ExecutionTask executionTaskA =
+                ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucessWithComplexObject(
+                        serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+        ExecutionTask executionTaskB;
+
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
+
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
+
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+
+        }
+
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
     }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
+    @Test
+    public void testExecutionTaskDeleteSuccess() throws Exception {
 
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
+        ExecutionTask executionTaskB;
 
-    }
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
 
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 
+        }
 
-  }
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
+    }
 
-  @Test
-  public void testExecutionTaskFailed() throws Exception {
+    @Test
+    public void testE2EExecutionTaskDeleteSuccess() throws Exception {
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.ADD);
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.DELETE);
+        ExecutionTask executionTaskB;
 
-    Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
 
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
-    }
-    executionTaskA = getExecutionTask("A");
-    Date createDate = executionTaskA.getCreateDate();
-    assertThat(executionTaskA.getLastAttemptDate().getTime() > createDate.getTime()).isTrue();
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
 
-    changeCreationDate(executionTaskA);
-    SoTaskProcessor.processOrderItem(executionTaskA);
+        }
 
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
+    @Test
+    public void testExecutionTaskFailed() throws Exception {
 
-  }
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 
-  private void changeCreationDate(ExecutionTask executionTaskA) {
-    Calendar cal = Calendar.getInstance();
-    cal.setTime(executionTaskA.getCreateDate());
-    cal.add(Calendar.SECOND, -30);
-    executionTaskA.setCreateDate(cal.getTime());
-  }
+        Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
+        executionTaskA = getExecutionTask("A");
+        Date createDate = executionTaskA.getCreateDate();
+        assertThat(executionTaskA.getLastAttemptDate().getTime() > createDate.getTime()).isTrue();
 
-  @Test
-  public void testE2EExecutionTaskFailed() throws Exception {
+        changeCreationDate(executionTaskA);
+        SoTaskProcessor.processOrderItem(executionTaskA);
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
-            serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 
-    Context.removeWireMockMapping(
-        "/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
+        }
 
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
     }
-    executionTaskA = getExecutionTask("A");
-    assertThat(
-        executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime())
-            .isTrue();
-    changeCreationDate(executionTaskA);
-    SoTaskProcessor.processOrderItem(executionTaskA);
-
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 
+    private void changeCreationDate(ExecutionTask executionTaskA) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(executionTaskA.getCreateDate());
+        cal.add(Calendar.SECOND, -30);
+        executionTaskA.setCreateDate(cal.getTime());
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+    @Test
+    public void testE2EExecutionTaskFailed() throws Exception {
 
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 
-  }
+        Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 
-  @Test
-  public void testExecutionTaskFailedNoSoResponse() throws Exception {
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime()).isTrue();
+        changeCreationDate(executionTaskA);
+        SoTaskProcessor.processOrderItem(executionTaskA);
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.ADD);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
 
-    Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
+        }
 
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
-
-
-  }
+    @Test
+    public void testExecutionTaskFailedNoSoResponse() throws Exception {
 
-  @Test
-  public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.ADD);
+        Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
 
-    Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
-    Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+        }
 
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+    @Test
+    public void testExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 
-  }
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 
-  @Test
-  public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
+        Context.removeWireMockMapping("/onap/so/infra/serviceInstantiation/v7/serviceInstances/");
+        Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForE2EExecutionTaskSucess(
-            serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+        }
 
-    Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3");
-    Context.removeWireMockMapping(
-        "/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
-  }
-
-
-  @Test
-  public void testExecutionTaskFailedBadRequestSo() throws Exception {
+    @Test
+    public void testE2EExecutionTaskFailedNoSoAndStatusResponse() throws Exception {
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.ADD);
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForE2EExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 
+        Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3");
+        Context.removeWireMockMapping("/onap/so/infra/e2eServiceInstances/v3/serviceId/operations/operationId");
 
-    changeWireMockResponse("/onap/so/infra/serviceInstantiation/v7/serviceInstances/", 400,
-        "\"serviceException\": {\n" + "        \"messageId\": \"SVC0002\",\n"
-            + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
-            + "    }");
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+        }
 
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+    @Test
+    public void testExecutionTaskFailedBadRequestSo() throws Exception {
 
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
-        assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
-        assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField())
-            .isEqualTo("service.name");
-      }
-    }
-
-  }
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
 
+        changeWireMockResponse("/onap/so/infra/serviceInstantiation/v7/serviceInstances/", 400,
+                "\"serviceException\": {\n" + "        \"messageId\": \"SVC0002\",\n"
+                        + "        \"text\": \"Error parsing request.  org.openecomp.mso.apihandler.common.ValidationException: serviceInstance already existsd\"\n"
+                        + "    }");
 
-  @Test
-  public void testExecutionTaskModifySuccess() throws Exception {
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+        }
 
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.MODIFY);
-    ExecutionTask executionTaskB;
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getOrderItemMessage().size()).isEqualTo(1);
+                assertThat(serviceOrderItem.getOrderItemMessage().get(0).getCode()).isEqualTo("105");
+                assertThat(serviceOrderItem.getOrderItemMessage().get(0).getField()).isEqualTo("service.name");
+            }
+        }
 
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
-        assertThat(serviceOrderItem.getState())
-            .isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
-    }
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
     }
 
-    executionTaskB = getExecutionTask("B");
-    assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
-    executionTaskA = getExecutionTask("A");
-    assertThat(executionTaskA).isNull();
-
-    SoTaskProcessor.processOrderItem(executionTaskB);
-    SoTaskProcessor.processOrderItem(executionTaskB);
-
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+    @Test
+    public void testExecutionTaskModifySuccess() throws Exception {
+
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.MODIFY);
+        ExecutionTask executionTaskB;
+
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_ITEM_TO_CREATE);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
+
+        executionTaskB = getExecutionTask("B");
+        assertThat(executionTaskB.getReliedTasks()).isNullOrEmpty();
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA).isNull();
+
+        SoTaskProcessor.processOrderItem(executionTaskB);
+        SoTaskProcessor.processOrderItem(executionTaskB);
+
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.COMPLETED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.COMPLETED);
+
+        }
+
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-
-  }
-
-
-
-  @Test
-  public void testExecutionTaskModifyFailed() throws Exception {
-
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.MODIFY);
-    ExecutionTask executionTaskB;
-    Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
-
-
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      if (serviceOrderItem.getId().equals("A")) {
-        // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
-        assertThat(serviceOrderItem.getState())
-            .isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
-      } else {
-        assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
-      }
-    }
-    executionTaskA = getExecutionTask("A");
-    assertThat(
-        executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime())
-            .isTrue();
-    changeCreationDate(executionTaskA);
-    SoTaskProcessor.processOrderItem(executionTaskA);
-
-    serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+    @Test
+    public void testExecutionTaskModifyFailed() throws Exception {
+
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.MODIFY);
+        ExecutionTask executionTaskB;
+        Context.removeWireMockMapping("/onap/so/infra/orchestrationRequests/v7/requestId");
+
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.INPROGRESS);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            if (serviceOrderItem.getId().equals("A")) {
+                // assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS);
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.INPROGRESS_MODIFY_REQUEST_DELETE_SEND);
+            } else {
+                assertThat(serviceOrderItem.getState()).isEqualTo(StateType.ACKNOWLEDGED);
+            }
+        }
+        executionTaskA = getExecutionTask("A");
+        assertThat(executionTaskA.getLastAttemptDate().getTime() > executionTaskA.getCreateDate().getTime()).isTrue();
+        changeCreationDate(executionTaskA);
+        SoTaskProcessor.processOrderItem(executionTaskA);
+
+        serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+
+        }
+
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
 
     }
 
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
+    @Test
+    public void testExecutionTaskWithoutOnap() throws Exception {
+        Context.stopWiremock();
+        ExecutionTask executionTaskA = ServiceOrderExecutionTaskAssertions
+                .setUpBddForExecutionTaskSucess(serviceOrderRepository, executionTaskRepository, ActionType.ADD);
+
+        SoTaskProcessor.processOrderItem(executionTaskA);
+        ServiceOrder serviceOrderChecked = getServiceOrder("test");
+        assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
+        for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
+            assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
+        }
+        assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
+        assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("502");
+        assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation())
+                .isEqualTo("Problem with SO API");
+
+        assertThat(executionTaskRepository.count()).isEqualTo(0);
+        Context.startWiremock();
 
-  }
-
-  @Test
-  public void testExecutionTaskWithoutOnap() throws Exception {
-    Context.stopWiremock();
-    ExecutionTask executionTaskA =
-        ServiceOrderExecutionTaskAssertions.setUpBddForExecutionTaskSucess(serviceOrderRepository,
-            executionTaskRepository, ActionType.ADD);
-
-    SoTaskProcessor.processOrderItem(executionTaskA);
-    ServiceOrder serviceOrderChecked = getServiceOrder("test");
-    assertThat(serviceOrderChecked.getState()).isEqualTo(StateType.FAILED);
-    for (ServiceOrderItem serviceOrderItem : serviceOrderChecked.getOrderItem()) {
-      assertThat(serviceOrderItem.getState()).isEqualTo(StateType.FAILED);
     }
-    assertThat(serviceOrderChecked.getOrderMessage().size()).isGreaterThan(0);
-    assertThat(serviceOrderChecked.getOrderMessage().get(0).getCode()).isEqualTo("502");
-    assertThat(serviceOrderChecked.getOrderMessage().get(0).getMessageInformation())
-        .isEqualTo("Problem with SO API");
-
-    assertThat(executionTaskRepository.count()).isEqualTo(0);
-    Context.startWiremock();
-
-  }
 
 }
diff --git a/src/test/java/org/onap/nbi/test/KarateApiTest.java b/src/test/java/org/onap/nbi/test/KarateApiTest.java
index e5845f3..ee2a993 100644
--- a/src/test/java/org/onap/nbi/test/KarateApiTest.java
+++ b/src/test/java/org/onap/nbi/test/KarateApiTest.java
@@ -11,6 +11,7 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
+
 package org.onap.nbi.test;
 
 import com.intuit.karate.junit4.Karate;
@@ -22,9 +23,9 @@ import org.junit.runner.RunWith;
 @CucumberOptions(features = "src/test/resources/karatetest/features")
 public class KarateApiTest {
 
-  @AfterClass
-  public static void stop() throws Exception {
-    Context.stopServers();
-  }
+    @AfterClass
+    public static void stop() throws Exception {
+        Context.stopServers();
+    }
 
 }
diff --git a/src/test/java/org/onap/nbi/test/ServiceOrderRepositoryTest.java b/src/test/java/org/onap/nbi/test/ServiceOrderRepositoryTest.java
index fd83ec0..61bf59d 100644
--- a/src/test/java/org/onap/nbi/test/ServiceOrderRepositoryTest.java
+++ b/src/test/java/org/onap/nbi/test/ServiceOrderRepositoryTest.java
@@ -13,8 +13,8 @@
  *     See the License for the specific language governing permissions and
  *     limitations under the License.
  */
-package org.onap.nbi.test;
 
+package org.onap.nbi.test;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -37,14 +37,13 @@ import org.springframework.test.context.junit4.SpringRunner;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-@DirtiesContext(classMode= ClassMode.AFTER_CLASS)
+@DirtiesContext(classMode = ClassMode.AFTER_CLASS)
 @ActiveProfiles("test")
 public class ServiceOrderRepositoryTest {
 
     @Autowired
     ServiceOrderRepository serviceOrderRepository;
 
-
     @Before
     public void setUp() {
         ServiceOrder serviceOrder = new ServiceOrder();