src/test/java/org/onap/nbi/apis/assertions/ServiceOrderExecutionTaskAssertions.java

   1 /**
   2  * Copyright (c) 2018 Orange
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   5  * in compliance with the License. You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software distributed under the License
  10  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  11  * or implied. See the License for the specific language governing permissions and limitations under
  12  * the License.
  13  */
  14
  15 package org.onap.nbi.apis.assertions;
  16
  17 import java.util.ArrayList;
  18 import java.util.Date;
  19 import java.util.LinkedHashMap;
  20 import java.util.List;
  21 import org.onap.nbi.apis.serviceorder.model.ActionType;
  22 import org.onap.nbi.apis.serviceorder.model.OrderItemRelationship;
  23 import org.onap.nbi.apis.serviceorder.model.OrderRelationship;
  24 import org.onap.nbi.apis.serviceorder.model.RelatedParty;
  25 import org.onap.nbi.apis.serviceorder.model.RelationshipType;
  26 import org.onap.nbi.apis.serviceorder.model.ResourceSpecification;
  27 import org.onap.nbi.apis.serviceorder.model.Service;
  28 import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic;
  29 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
  30 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
  31 import org.onap.nbi.apis.serviceorder.model.ServiceSpecificationRef;
  32 import org.onap.nbi.apis.serviceorder.model.StateType;
  33 import org.onap.nbi.apis.serviceorder.model.Value;
  34 import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
  35 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
  36 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
  37 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderItemInfo;
  38 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
  39 import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
  40 import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
  41
  42 public class ServiceOrderExecutionTaskAssertions {
  43
  44     public static ServiceOrder createTestServiceOrderRejected() {
  45         ServiceOrder serviceOrder = new ServiceOrder();
  46         serviceOrder.setExternalId("LudONAP001");
  47         serviceOrder.setPriority("1");
  48         serviceOrder.setDescription("Ludo first ONAP Order");
  49         serviceOrder.setCategory("Consumer");
  50         serviceOrder.setRequestedStartDate(new Date());
  51         serviceOrder.setRequestedCompletionDate(new Date());
  52
  53         RelatedParty party = new RelatedParty();
  54         party.setId("6490");
  55         party.setRole("ONAPcustomer");
  56         party.setReferredType("individual");
  57         party.setName("Jean Pontus");
  58         List<RelatedParty> relatedPartyList = new ArrayList<>();
  59         relatedPartyList.add(party);
  60         serviceOrder.setRelatedParty(relatedPartyList);
  61
  62         List<ServiceOrderItem> items = new ArrayList<>();
  63
  64         ServiceOrderItem itemA = new ServiceOrderItem();
  65         itemA.id("A");
  66         itemA.action(ActionType.ADD);
  67         Service serviceA = new Service();
  68         serviceA.setServiceState("active");
  69         ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
  70         serviceSpecificationRefA.setId("333");
  71         serviceA.setServiceSpecification(serviceSpecificationRefA);
  72         itemA.setService(serviceA);
  73         items.add(itemA);
  74
  75         ServiceOrderItem itemB = new ServiceOrderItem();
  76         itemB.id("B");
  77         itemB.action(ActionType.ADD);
  78         Service serviceB = new Service();
  79         serviceB.setServiceState("active");
  80         ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
  81         serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
  82         serviceB.setServiceSpecification(serviceSpecificationRefB);
  83         itemB.setService(serviceB);
  84         List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
  85         OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
  86         orderItemRelationship.setId("A");
  87         orderItemRelationships.add(orderItemRelationship);
  88         itemB.setOrderItemRelationship(orderItemRelationships);
  89         items.add(itemB);
  90         serviceOrder.setOrderItem(items);
  91         return serviceOrder;
  92
  93     }
  94
  95     public static ServiceOrder createTestServiceOrder(ActionType actionType) {
  96         ServiceOrder serviceOrder = new ServiceOrder();
  97         serviceOrder.setExternalId("LudONAP001");
  98         serviceOrder.setPriority("1");
  99         serviceOrder.setDescription("Ludo first ONAP Order");
 100         serviceOrder.setCategory("Consumer");
 101         serviceOrder.setRequestedStartDate(new Date());
 102         serviceOrder.setRequestedCompletionDate(new Date());
 103         serviceOrder.setBaseType("toto");
 104         serviceOrder.setCompletionDateTime(new Date());
 105         serviceOrder.setExpectedCompletionDate(new Date());
 106         serviceOrder.setSchemaLocation("/tutu");
 107
 108         OrderRelationship orderRelationship = new OrderRelationship();
 109         orderRelationship.setId("test");
 110         orderRelationship.setHref("test");
 111         orderRelationship.setReferredType("test");
 112         orderRelationship.setType("type");
 113         List<OrderRelationship> relationships = new ArrayList<>();
 114         serviceOrder.setOrderRelationship(relationships);
 115
 116         RelatedParty party = new RelatedParty();
 117         party.setId("6490");
 118         party.setRole("ONAPcustomer");
 119         party.setReferredType("individual");
 120         party.setName("Jean Pontus");
 121         List<RelatedParty> relatedPartyList = new ArrayList<>();
 122         relatedPartyList.add(party);
 123         serviceOrder.setRelatedParty(relatedPartyList);
 124
 125         List<ServiceOrderItem> items = new ArrayList<>();
 126
 127         ServiceOrderItem itemA = new ServiceOrderItem();
 128         itemA.id("A");
 129         itemA.action(actionType);
 130         Service serviceA = new Service();
 131         if (actionType != ActionType.ADD) {
 132             serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 133         }
 134         serviceA.setServiceState("active");
 135         ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
 136         serviceSpecificationRefA.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
 137         serviceA.setServiceSpecification(serviceSpecificationRefA);
 138         itemA.setService(serviceA);
 139         items.add(itemA);
 140
 141         ServiceOrderItem itemB = new ServiceOrderItem();
 142         itemB.id("B");
 143         itemB.action(actionType);
 144         Service serviceB = new Service();
 145         if (actionType != ActionType.ADD) {
 146             serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 147         }
 148         serviceB.setServiceState("active");
 149         ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
 150         serviceSpecificationRefB.setId("1e3feeb0-8e36-46c6-862c-236d9c626439");
 151         serviceB.setServiceSpecification(serviceSpecificationRefB);
 152         itemB.setService(serviceB);
 153         List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
 154         OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
 155         orderItemRelationship.setId("A");
 156         orderItemRelationship.setType(RelationshipType.RELIESON);
 157         orderItemRelationships.add(orderItemRelationship);
 158         itemB.setOrderItemRelationship(orderItemRelationships);
 159         items.add(itemB);
 160         serviceOrder.setOrderItem(items);
 161         return serviceOrder;
 162
 163     }
 164
 165     public static ServiceOrder createTestServiceOrderForMacroVnf(ActionType actionType) {
 166                 ServiceOrder serviceOrder = new ServiceOrder();
 167                 serviceOrder.setExternalId("LudONAP001");
 168                 serviceOrder.setPriority("1");
 169                 serviceOrder.setDescription("Ludo first ONAP Order");
 170                 serviceOrder.setCategory("Consumer");
 171                 serviceOrder.setRequestedStartDate(new Date());
 172                 serviceOrder.setRequestedCompletionDate(new Date());
 173                 serviceOrder.setBaseType("toto");
 174                 serviceOrder.setCompletionDateTime(new Date());
 175                 serviceOrder.setExpectedCompletionDate(new Date());
 176                 serviceOrder.setSchemaLocation("/tutu");
 177
 178                 OrderRelationship orderRelationship = new OrderRelationship();
 179                 orderRelationship.setId("test");
 180                 orderRelationship.setHref("test");
 181                 orderRelationship.setReferredType("test");
 182                 orderRelationship.setType("type");
 183                 List<OrderRelationship> relationships = new ArrayList<>();
 184                 serviceOrder.setOrderRelationship(relationships);
 185
 186                 RelatedParty party = new RelatedParty();
 187                 party.setId("6490");
 188                 party.setRole("ONAPcustomer");
 189                 party.setReferredType("individual");
 190                 party.setName("Jean Pontus");
 191                 List<RelatedParty> relatedPartyList = new ArrayList<>();
 192                 relatedPartyList.add(party);
 193                 serviceOrder.setRelatedParty(relatedPartyList);
 194
 195                 List<ServiceOrderItem> items = new ArrayList<>();
 196
 197                 ServiceOrderItem itemA = new ServiceOrderItem();
 198                 itemA.id("A");
 199                 itemA.action(actionType);
 200                 Service serviceA = new Service();
 201
 202                 serviceA.setServiceState("active");
 203                 ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
 204                 serviceSpecificationRefA.setId("3bed38ff-a4fd-4463-9784-caf738d46dbc");
 205                 serviceA.setServiceSpecification(serviceSpecificationRefA);
 206                 itemA.setService(serviceA);
 207                 items.add(itemA);
 208
 209                 ServiceOrderItem itemB = new ServiceOrderItem();
 210                 itemB.id("B");
 211                 itemB.action(actionType);
 212                 Service serviceB = new Service();
 213                 if (actionType != ActionType.ADD) {
 214                         serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 215                 }
 216                 serviceB.setServiceState("active");
 217                 ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
 218                 serviceSpecificationRefB.setId("3bed38ff-a4fd-4463-9784-caf738d46dbc");
 219                 serviceB.setServiceSpecification(serviceSpecificationRefB);
 220                 itemB.setService(serviceB);
 221                 List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
 222                 OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
 223                 orderItemRelationship.setId("A");
 224                 orderItemRelationship.setType(RelationshipType.RELIESON);
 225                 orderItemRelationships.add(orderItemRelationship);
 226                 itemB.setOrderItemRelationship(orderItemRelationships);
 227                 items.add(itemB);
 228                 serviceOrder.setOrderItem(items);
 229                 return serviceOrder;
 230         }
 231
 232
 233     public static ServiceOrder createTestServiceOrderForMacro(ActionType actionType) {
 234         ServiceOrder serviceOrder = new ServiceOrder();
 235         serviceOrder.setExternalId("LudONAP001");
 236         serviceOrder.setPriority("1");
 237         serviceOrder.setDescription("Ludo first ONAP Order");
 238         serviceOrder.setCategory("Consumer");
 239         serviceOrder.setRequestedStartDate(new Date());
 240         serviceOrder.setRequestedCompletionDate(new Date());
 241         serviceOrder.setBaseType("toto");
 242         serviceOrder.setCompletionDateTime(new Date());
 243         serviceOrder.setExpectedCompletionDate(new Date());
 244         serviceOrder.setSchemaLocation("/tutu");
 245
 246         OrderRelationship orderRelationship = new OrderRelationship();
 247         orderRelationship.setId("test");
 248         orderRelationship.setHref("test");
 249         orderRelationship.setReferredType("test");
 250         orderRelationship.setType("type");
 251         List<OrderRelationship> relationships = new ArrayList<>();
 252         serviceOrder.setOrderRelationship(relationships);
 253
 254         RelatedParty party = new RelatedParty();
 255         party.setId("6490");
 256         party.setRole("ONAPcustomer");
 257         party.setReferredType("individual");
 258         party.setName("Jean Pontus");
 259         List<RelatedParty> relatedPartyList = new ArrayList<>();
 260         relatedPartyList.add(party);
 261         serviceOrder.setRelatedParty(relatedPartyList);
 262
 263         List<ServiceOrderItem> items = new ArrayList<>();
 264
 265         ServiceOrderItem itemA = new ServiceOrderItem();
 266         itemA.id("A");
 267         itemA.action(actionType);
 268         Service serviceA = new Service();
 269         if (actionType != ActionType.ADD) {
 270                 serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 271         }
 272         serviceA.setServiceState("active");
 273         ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
 274         serviceSpecificationRefA.setId("82c9fbb4-656c-4973-8c7f-172b22b5fa8f");
 275         serviceA.setServiceSpecification(serviceSpecificationRefA);
 276         itemA.setService(serviceA);
 277         items.add(itemA);
 278
 279         ServiceOrderItem itemB = new ServiceOrderItem();
 280         itemB.id("B");
 281         itemB.action(actionType);
 282         Service serviceB = new Service();
 283         if (actionType != ActionType.ADD) {
 284                 serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 285         }
 286         serviceB.setServiceState("active");
 287         ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
 288         serviceSpecificationRefB.setId("82c9fbb4-656c-4973-8c7f-172b22b5fa8f");
 289         serviceB.setServiceSpecification(serviceSpecificationRefB);
 290         itemB.setService(serviceB);
 291         List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
 292         OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
 293         orderItemRelationship.setId("A");
 294         orderItemRelationship.setType(RelationshipType.RELIESON);
 295         orderItemRelationships.add(orderItemRelationship);
 296         itemB.setOrderItemRelationship(orderItemRelationships);
 297         items.add(itemB);
 298         serviceOrder.setOrderItem(items);
 299         return serviceOrder;
 300
 301         }
 302
 303     public static ExecutionTask setUpBddForExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 304             ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 305         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 306
 307         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 308             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 309         }
 310
 311         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 312         testServiceOrder.setId("test");
 313         serviceOrderRepository.save(testServiceOrder);
 314
 315         LinkedHashMap<String, String> sdcResponse = new LinkedHashMap<>();
 316         sdcResponse.put("invariantUUID", "uuid");
 317         sdcResponse.put("name", "vFW");
 318         sdcResponse.put("version", "v1");
 319         sdcResponse.put("category", "NonE2E");
 320
 321         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 322         serviceOrderInfo.setServiceOrderId("test");
 323         SubscriberInfo subscriberInfo = new SubscriberInfo();
 324         subscriberInfo.setGlobalSubscriberId("6490");
 325         subscriberInfo.setSubscriberName("edgar");
 326         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 327
 328         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 329         serviceOrderItemInfoA.setId("A");
 330         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 331
 332         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 333         serviceOrderItemInfoB.setId("B");
 334         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 335         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 336         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 337
 338         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 339
 340         ExecutionTask executionTaskA = new ExecutionTask();
 341         executionTaskA.setCreateDate(new Date());
 342         executionTaskA.setOrderItemId("A");
 343         executionTaskA.setServiceOrderInfoJson(json);
 344         executionTaskA = executionTaskRepository.save(executionTaskA);
 345         ExecutionTask executionTaskB = new ExecutionTask();
 346         executionTaskB.setCreateDate(new Date());
 347         executionTaskB.setOrderItemId("B");
 348         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 349         executionTaskB.setServiceOrderInfoJson(json);
 350         executionTaskRepository.save(executionTaskB);
 351         return executionTaskA;
 352     }
 353
 354     public static ExecutionTask setUpBddForE2EExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 355             ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 356         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 357
 358         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 359             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 360             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 361             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 362             serviceCharacteristic1.setName("access-site-id");
 363             Value value1 = new Value();
 364             value1.setServiceCharacteristicValue("1234765");
 365             serviceCharacteristic1.setValue(value1);
 366             serviceCharacteristics.add(serviceCharacteristic1);
 367             ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 368             serviceCharacteristic2.setName("provider-site-id");
 369             Value value2 = new Value();
 370             value2.setServiceCharacteristicValue("654321");
 371             serviceCharacteristic2.setValue(value2);
 372             serviceCharacteristics.add(serviceCharacteristic2);
 373             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 374         }
 375
 376         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 377         testServiceOrder.setId("test");
 378         serviceOrderRepository.save(testServiceOrder);
 379
 380         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 381         sdcResponse.put("invariantUUID", "uuid");
 382         sdcResponse.put("name", "vFW");
 383         sdcResponse.put("version", "v1");
 384         sdcResponse.put("category", "E2E Service");
 385
 386         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 387         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 388         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 389         resourceSpecificationA.setInstanceName("vFW-vSINK");
 390         resourceSpecificationA.setName("vFW-SINK");
 391         resourceSpecificationA.setType("ONAPresource");
 392         resourceSpecificationA.setVersion("2.0");
 393         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 394         resourceSpecs.add(resourceSpecificationA);
 395
 396         sdcResponse.put("resourceSpecification", resourceSpecs);
 397
 398         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 399         serviceOrderInfo.setServiceOrderId("test");
 400         SubscriberInfo subscriberInfo = new SubscriberInfo();
 401         subscriberInfo.setGlobalSubscriberId("6490");
 402         subscriberInfo.setSubscriberName("edgar");
 403         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 404
 405         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 406         serviceOrderItemInfoA.setId("A");
 407         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 408
 409         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 410         serviceOrderItemInfoB.setId("B");
 411         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 412         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 413         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 414
 415         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 416
 417         ExecutionTask executionTaskA = new ExecutionTask();
 418         executionTaskA.setCreateDate(new Date());
 419         executionTaskA.setOrderItemId("A");
 420         executionTaskA.setServiceOrderInfoJson(json);
 421         executionTaskA = executionTaskRepository.save(executionTaskA);
 422         ExecutionTask executionTaskB = new ExecutionTask();
 423         executionTaskB.setCreateDate(new Date());
 424         executionTaskB.setOrderItemId("B");
 425         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 426         executionTaskB.setServiceOrderInfoJson(json);
 427         executionTaskRepository.save(executionTaskB);
 428         return executionTaskA;
 429     }
 430
 431     public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithObject(
 432             ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 433             ActionType actionType) {
 434         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 435
 436         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 437             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 438             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 439             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 440             serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
 441             serviceCharacteristic1.setValueType("object");
 442             Value value1 = new Value();
 443             value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
 444             serviceCharacteristic1.setValue(value1);
 445             serviceCharacteristics.add(serviceCharacteristic1);
 446             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 447         }
 448
 449         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 450         testServiceOrder.setId("test");
 451         serviceOrderRepository.save(testServiceOrder);
 452
 453         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 454         sdcResponse.put("invariantUUID", "uuid");
 455         sdcResponse.put("name", "vFW");
 456         sdcResponse.put("version", "v1");
 457         sdcResponse.put("category", "E2E Service");
 458
 459         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 460         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 461         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 462         resourceSpecificationA.setInstanceName("vFW-vSINK");
 463         resourceSpecificationA.setName("vFW-SINK");
 464         resourceSpecificationA.setType("ONAPresource");
 465         resourceSpecificationA.setVersion("2.0");
 466         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 467         resourceSpecs.add(resourceSpecificationA);
 468
 469         sdcResponse.put("resourceSpecification", resourceSpecs);
 470
 471         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 472         serviceOrderInfo.setServiceOrderId("test");
 473         SubscriberInfo subscriberInfo = new SubscriberInfo();
 474         subscriberInfo.setGlobalSubscriberId("6490");
 475         subscriberInfo.setSubscriberName("edgar");
 476         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 477
 478         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 479         serviceOrderItemInfoA.setId("A");
 480         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 481
 482         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 483         serviceOrderItemInfoB.setId("B");
 484         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 485         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 486         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 487
 488         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 489
 490         ExecutionTask executionTaskA = new ExecutionTask();
 491         executionTaskA.setCreateDate(new Date());
 492         executionTaskA.setOrderItemId("A");
 493         executionTaskA.setServiceOrderInfoJson(json);
 494         executionTaskA = executionTaskRepository.save(executionTaskA);
 495         ExecutionTask executionTaskB = new ExecutionTask();
 496         executionTaskB.setCreateDate(new Date());
 497         executionTaskB.setOrderItemId("B");
 498         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 499         executionTaskB.setServiceOrderInfoJson(json);
 500         executionTaskRepository.save(executionTaskB);
 501         return executionTaskA;
 502     }
 503
 504     public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithComplexObject(
 505             ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 506             ActionType actionType) {
 507         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 508
 509         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 510             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 511             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 512             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 513             serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
 514             serviceCharacteristic1.setValueType("object");
 515             Value value1 = new Value();
 516             // Three parameters , one is an array of child objects
 517             value1.setServiceCharacteristicValue(
 518                     "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
 519             serviceCharacteristic1.setValue(value1);
 520             serviceCharacteristics.add(serviceCharacteristic1);
 521             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 522         }
 523
 524         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 525         testServiceOrder.setId("test");
 526         serviceOrderRepository.save(testServiceOrder);
 527
 528         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 529         sdcResponse.put("invariantUUID", "uuid");
 530         sdcResponse.put("name", "vFW");
 531         sdcResponse.put("version", "v1");
 532         sdcResponse.put("category", "E2E Service");
 533
 534         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 535         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 536         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 537         resourceSpecificationA.setInstanceName("vFW-vSINK");
 538         resourceSpecificationA.setName("vFW-SINK");
 539         resourceSpecificationA.setType("ONAPresource");
 540         resourceSpecificationA.setVersion("2.0");
 541         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 542         resourceSpecs.add(resourceSpecificationA);
 543
 544         sdcResponse.put("resourceSpecification", resourceSpecs);
 545
 546         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 547         serviceOrderInfo.setServiceOrderId("test");
 548         SubscriberInfo subscriberInfo = new SubscriberInfo();
 549         subscriberInfo.setGlobalSubscriberId("6490");
 550         subscriberInfo.setSubscriberName("edgar");
 551         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 552
 553         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 554         serviceOrderItemInfoA.setId("A");
 555         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 556
 557         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 558         serviceOrderItemInfoB.setId("B");
 559         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 560         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 561         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 562
 563         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 564
 565         ExecutionTask executionTaskA = new ExecutionTask();
 566         executionTaskA.setCreateDate(new Date());
 567         executionTaskA.setOrderItemId("A");
 568         executionTaskA.setServiceOrderInfoJson(json);
 569         executionTaskA = executionTaskRepository.save(executionTaskA);
 570         ExecutionTask executionTaskB = new ExecutionTask();
 571         executionTaskB.setCreateDate(new Date());
 572         executionTaskB.setOrderItemId("B");
 573         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 574         executionTaskB.setServiceOrderInfoJson(json);
 575         executionTaskRepository.save(executionTaskB);
 576         return executionTaskA;
 577     }
 578
 579     public static ExecutionTask setUpBddForMacroExecutionTaskSucessVnf(ServiceOrderRepository serviceOrderRepository,
 580                         ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 581
 582                 ServiceOrder testServiceOrder = createTestServiceOrderForMacroVnf(actionType);
 583
 584                 for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 585                         serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 586                         List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 587                         ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 588                         serviceCharacteristic1.setName("serviceProperty1");
 589                         Value value1 = new Value();
 590                         value1.setServiceCharacteristicValue("1234765");
 591                         serviceCharacteristic1.setValue(value1);
 592                         serviceCharacteristics.add(serviceCharacteristic1);
 593                         ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 594                         serviceCharacteristic2.setName("dummy_vsp0_vfLevelProperty2");
 595                         Value value2 = new Value();
 596                         value2.setServiceCharacteristicValue("654321");
 597                         serviceCharacteristic2.setValue(value2);
 598                         serviceCharacteristics.add(serviceCharacteristic2);
 599                         serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 600                 }
 601
 602                 testServiceOrder.setState(StateType.ACKNOWLEDGED);
 603                 testServiceOrder.setId("test");
 604                 serviceOrderRepository.save(testServiceOrder);
 605
 606                 LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 607                 sdcResponse.put("invariantUUID", "b96687b0-5353-4e4d-bbd5-a49796fc3f11");
 608                 sdcResponse.put("name", "dummy_service");
 609                 sdcResponse.put("version", "2.0");
 610                 sdcResponse.put("category", "Network Service");
 611                 sdcResponse.put("instantiationType", "Macro");
 612
 613                 List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 614                 ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 615                 resourceSpecificationA.setId("725860b4-1a98-4da6-9451-6c04a581eb44");
 616                 resourceSpecificationA.setInstanceName("dummy_vsp");
 617                 resourceSpecificationA.setName("dummy_vsp");
 618                 resourceSpecificationA.setType("VF");
 619                 resourceSpecificationA.setVersion("1.0");
 620                 resourceSpecificationA.setResourceInvariantUUID("0fa0d33d-b268-42ce-b393-7d3c6fde6ca9");
 621                 resourceSpecs.add(resourceSpecificationA);
 622
 623                 sdcResponse.put("resourceSpecification", resourceSpecs);
 624
 625                 ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 626                 serviceOrderInfo.setServiceOrderId("test");
 627                 SubscriberInfo subscriberInfo = new SubscriberInfo();
 628                 subscriberInfo.setGlobalSubscriberId("6490");
 629                 subscriberInfo.setSubscriberName("edgar");
 630                 serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 631
 632                 ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 633                 serviceOrderItemInfoA.setId("A");
 634                 serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 635
 636                 ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 637                 serviceOrderItemInfoB.setId("B");
 638                 serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 639                 serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 640                 serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 641
 642
 643
 644                 String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 645
 646                 ExecutionTask executionTaskA = new ExecutionTask();
 647                 executionTaskA.setCreateDate(new Date());
 648                 executionTaskA.setOrderItemId("A");
 649                 executionTaskA.setServiceOrderInfoJson(json);
 650                 executionTaskA = executionTaskRepository.save(executionTaskA);
 651                 ExecutionTask executionTaskB = new ExecutionTask();
 652                 executionTaskB.setCreateDate(new Date());
 653                 executionTaskB.setOrderItemId("B");
 654                 executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 655                 executionTaskB.setServiceOrderInfoJson(json);
 656                 executionTaskRepository.save(executionTaskB);
 657                 return executionTaskA;
 658             }
 659
 660     public static ServiceOrder createTestServiceOrderForMacroCNF(ActionType actionType) {
 661                 ServiceOrder serviceOrder = new ServiceOrder();
 662                 serviceOrder.setExternalId("LudONAP001");
 663                 serviceOrder.setPriority("1");
 664                 serviceOrder.setDescription("Ludo first ONAP Order");
 665                 serviceOrder.setCategory("Consumer");
 666                 serviceOrder.setRequestedStartDate(new Date());
 667                 serviceOrder.setRequestedCompletionDate(new Date());
 668                 serviceOrder.setBaseType("toto");
 669                 serviceOrder.setCompletionDateTime(new Date());
 670                 serviceOrder.setExpectedCompletionDate(new Date());
 671                 serviceOrder.setSchemaLocation("/tutu");
 672
 673                 OrderRelationship orderRelationship = new OrderRelationship();
 674                 orderRelationship.setId("test");
 675                 orderRelationship.setHref("test");
 676                 orderRelationship.setReferredType("test");
 677                 orderRelationship.setType("type");
 678                 List<OrderRelationship> relationships = new ArrayList<>();
 679                 serviceOrder.setOrderRelationship(relationships);
 680
 681                 RelatedParty party = new RelatedParty();
 682                 party.setId("6490");
 683                 party.setRole("ONAPcustomer");
 684                 party.setReferredType("individual");
 685                 party.setName("Jean Pontus");
 686                 List<RelatedParty> relatedPartyList = new ArrayList<>();
 687                 relatedPartyList.add(party);
 688                 serviceOrder.setRelatedParty(relatedPartyList);
 689
 690                 List<ServiceOrderItem> items = new ArrayList<>();
 691
 692                 ServiceOrderItem itemA = new ServiceOrderItem();
 693                 itemA.id("A");
 694                 itemA.action(actionType);
 695                 Service serviceA = new Service();
 696
 697                 serviceA.setId("edf094cc-281f-4be9-a284-e047ded86066");
 698                 serviceA.setServicetype("vfwk8s");
 699
 700                 serviceA.setServiceState("active");
 701                 ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
 702                 serviceSpecificationRefA.setId("edf094cc-281f-4be9-a284-e047ded86066");
 703                 serviceA.setServiceSpecification(serviceSpecificationRefA);
 704                 itemA.setService(serviceA);
 705                 items.add(itemA);
 706
 707                 ServiceOrderItem itemB = new ServiceOrderItem();
 708                 itemB.id("B");
 709                 itemB.action(actionType);
 710                 Service serviceB = new Service();
 711                 //serviceB.setId("edf094cc-281f-4be9-a284-e047ded86066");
 712
 713                 serviceB.setServiceState("active");
 714                 ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
 715                 serviceSpecificationRefB.setId("edf094cc-281f-4be9-a284-e047ded86066");
 716                 serviceB.setServiceSpecification(serviceSpecificationRefB);
 717                 itemB.setService(serviceB);
 718                 List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
 719                 OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
 720                 orderItemRelationship.setId("A");
 721                 orderItemRelationship.setType(RelationshipType.RELIESON);
 722                 orderItemRelationships.add(orderItemRelationship);
 723                 itemB.setOrderItemRelationship(orderItemRelationships);
 724                 items.add(itemB);
 725                 serviceOrder.setOrderItem(items);
 726                 System.out.println(serviceOrder);
 727                 return serviceOrder;
 728     }
 729
 730   //setup for CNF MacroFLow
 731     public static ExecutionTask setUpBddForMacroExecutionTaskSucessForCNF(ServiceOrderRepository serviceOrderRepository,
 732                         ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 733
 734                 ServiceOrder testServiceOrder = createTestServiceOrderForMacroCNF(actionType);
 735
 736                 for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 737                         serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 738                         List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 739                         ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 740                         serviceCharacteristic1.setName("vfw_cnf_13080_dummy_vf_2");
 741                         Value value1 = new Value();
 742                         value1.setServiceCharacteristicValue("ggg");
 743                         serviceCharacteristic1.setValue(value1);
 744                         serviceCharacteristics.add(serviceCharacteristic1);
 745                         ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 746                         serviceCharacteristic2.setName("vfw_cnf_13080_dummy_vf_1");
 747                         Value value2 = new Value();
 748                         value2.setServiceCharacteristicValue("hhhh");
 749                         serviceCharacteristic2.setValue(value2);
 750                         serviceCharacteristics.add(serviceCharacteristic2);
 751                         ServiceCharacteristic serviceCharacteristic3 = new ServiceCharacteristic();
 752                         serviceCharacteristic3.setName("dummy_ser_2");
 753                         Value value3 = new Value();
 754                         value3.setServiceCharacteristicValue("serv2");
 755                         serviceCharacteristic3.setValue(value3);
 756                         serviceCharacteristics.add(serviceCharacteristic3);
 757                         ServiceCharacteristic serviceCharacteristic4 = new ServiceCharacteristic();
 758                         serviceCharacteristic4.setName("dummy_ser_1");
 759                         Value value4 = new Value();
 760                         value4.setServiceCharacteristicValue("serv1");
 761                         serviceCharacteristic4.setValue(value4);
 762                         serviceCharacteristics.add(serviceCharacteristic4);
 763
 764                         serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 765                 }
 766
 767                 testServiceOrder.setState(StateType.ACKNOWLEDGED);
 768                 testServiceOrder.setId("test");
 769                 serviceOrderRepository.save(testServiceOrder);
 770
 771                 LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 772                 sdcResponse.put("invariantUUID", "uuid");
 773                 sdcResponse.put("name", "vfw_cnf_1308");
 774                 sdcResponse.put("version", "1.0");
 775                 sdcResponse.put("category", "Network Service");
 776                 sdcResponse.put("instantiationType", "Macro");
 777
 778                 List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 779                 ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 780                 resourceSpecificationA.setId("679effb6-35e7-425e-9272-4b4e6b2b8382");
 781                 resourceSpecificationA.setInstanceName("vfw_cnf_1308 0");
 782                 resourceSpecificationA.setName("vfw_cnf_1308 0");
 783                 resourceSpecificationA.setType("VF");
 784                 resourceSpecificationA.setVersion("1.0");
 785                 resourceSpecificationA.setResourceInvariantUUID("2c9870d3-21cd-4140-afa0-3ba770bef206");
 786                 resourceSpecs.add(resourceSpecificationA);
 787
 788                 sdcResponse.put("resourceSpecification", resourceSpecs);
 789
 790                 ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 791                 serviceOrderInfo.setServiceOrderId("test");
 792                 SubscriberInfo subscriberInfo = new SubscriberInfo();
 793                 subscriberInfo.setGlobalSubscriberId("6490");
 794                 subscriberInfo.setSubscriberName("edgar");
 795                 serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 796
 797                 ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 798                 serviceOrderItemInfoA.setId("A");
 799                 serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 800
 801                 ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 802                 serviceOrderItemInfoB.setId("B");
 803                 serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 804                 serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 805                 serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 806
 807                 String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 808
 809                 ExecutionTask executionTaskA = new ExecutionTask();
 810                 executionTaskA.setCreateDate(new Date());
 811                 executionTaskA.setOrderItemId("A");
 812                 executionTaskA.setServiceOrderInfoJson(json);
 813                 executionTaskA = executionTaskRepository.save(executionTaskA);
 814                 ExecutionTask executionTaskB = new ExecutionTask();
 815                 executionTaskB.setCreateDate(new Date());
 816                 executionTaskB.setOrderItemId("B");
 817                 executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 818                 executionTaskB.setServiceOrderInfoJson(json);
 819                 executionTaskRepository.save(executionTaskB);
 820                 return executionTaskA;
 821     }
 822
 823     public static ExecutionTask setUpBddForMacroExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 824                 ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 825
 826         ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType);
 827
 828         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 829                 serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 830                 List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 831                 ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 832                 serviceCharacteristic1.setName("access-site-id");
 833                 Value value1 = new Value();
 834                 value1.setServiceCharacteristicValue("1234765");
 835                 serviceCharacteristic1.setValue(value1);
 836                 serviceCharacteristics.add(serviceCharacteristic1);
 837                 ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 838                 serviceCharacteristic2.setName("provider-site-id");
 839                 Value value2 = new Value();
 840                 value2.setServiceCharacteristicValue("654321");
 841                 serviceCharacteristic2.setValue(value2);
 842                 serviceCharacteristics.add(serviceCharacteristic2);
 843                 serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 844         }
 845
 846         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 847         testServiceOrder.setId("test");
 848         serviceOrderRepository.save(testServiceOrder);
 849
 850         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 851         sdcResponse.put("invariantUUID", "uuid");
 852         sdcResponse.put("name", "VLB_Service");
 853         sdcResponse.put("version", "1.0");
 854         sdcResponse.put("category", "Network Service");
 855         sdcResponse.put("instantiationType", "Macro");
 856
 857         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 858         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 859         resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc");
 860         resourceSpecificationA.setInstanceName("vLB_VSP");
 861         resourceSpecificationA.setName("vLB_VSP");
 862         resourceSpecificationA.setType("VF");
 863         resourceSpecificationA.setVersion("1.0");
 864         resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e");
 865         resourceSpecs.add(resourceSpecificationA);
 866
 867         sdcResponse.put("resourceSpecification", resourceSpecs);
 868
 869         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 870         serviceOrderInfo.setServiceOrderId("test");
 871         SubscriberInfo subscriberInfo = new SubscriberInfo();
 872         subscriberInfo.setGlobalSubscriberId("6490");
 873         subscriberInfo.setSubscriberName("edgar");
 874         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 875
 876         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 877         serviceOrderItemInfoA.setId("A");
 878         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 879
 880         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 881         serviceOrderItemInfoB.setId("B");
 882         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 883         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 884         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 885
 886
 887
 888         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 889
 890         ExecutionTask executionTaskA = new ExecutionTask();
 891         executionTaskA.setCreateDate(new Date());
 892         executionTaskA.setOrderItemId("A");
 893         executionTaskA.setServiceOrderInfoJson(json);
 894         executionTaskA = executionTaskRepository.save(executionTaskA);
 895         ExecutionTask executionTaskB = new ExecutionTask();
 896         executionTaskB.setCreateDate(new Date());
 897         executionTaskB.setOrderItemId("B");
 898         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 899         executionTaskB.setServiceOrderInfoJson(json);
 900         executionTaskRepository.save(executionTaskB);
 901         return executionTaskA;
 902     }
 903
 904     public static ExecutionTask setUpBddForMacroExecutionTaskSucessWithObject(
 905         ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 906         ActionType actionType) {
 907         ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType);
 908
 909         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 910                 serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 911                 List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 912                 ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 913                 serviceCharacteristic1.setName("ServiceCharacteristics");
 914                 serviceCharacteristic1.setValueType("object");
 915                 Value value1 = new Value();
 916                 value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
 917                 serviceCharacteristic1.setValue(value1);
 918                 serviceCharacteristics.add(serviceCharacteristic1);
 919                 serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 920         }
 921
 922         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 923         testServiceOrder.setId("test");
 924         serviceOrderRepository.save(testServiceOrder);
 925
 926         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 927         sdcResponse.put("invariantUUID", "uuid");
 928         sdcResponse.put("name", "VLB_Service");
 929         sdcResponse.put("version", "1");
 930         sdcResponse.put("category", "Network Service");
 931         sdcResponse.put("instantiationType", "Macro");
 932
 933         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 934         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 935         resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc");
 936         resourceSpecificationA.setInstanceName("vLB_VSP");
 937         resourceSpecificationA.setName("vFW-SINK");
 938         resourceSpecificationA.setType("ONAPresource");
 939         resourceSpecificationA.setVersion("2.0");
 940         resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e");
 941         resourceSpecs.add(resourceSpecificationA);
 942
 943         sdcResponse.put("resourceSpecification", resourceSpecs);
 944
 945         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 946         serviceOrderInfo.setServiceOrderId("test");
 947         SubscriberInfo subscriberInfo = new SubscriberInfo();
 948         subscriberInfo.setGlobalSubscriberId("6490");
 949         subscriberInfo.setSubscriberName("edgar");
 950         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 951
 952         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 953         serviceOrderItemInfoA.setId("A");
 954         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 955
 956         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 957         serviceOrderItemInfoB.setId("B");
 958         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 959         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 960         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 961
 962         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 963
 964         ExecutionTask executionTaskA = new ExecutionTask();
 965         executionTaskA.setCreateDate(new Date());
 966         executionTaskA.setOrderItemId("A");
 967         executionTaskA.setServiceOrderInfoJson(json);
 968         executionTaskA = executionTaskRepository.save(executionTaskA);
 969         ExecutionTask executionTaskB = new ExecutionTask();
 970         executionTaskB.setCreateDate(new Date());
 971         executionTaskB.setOrderItemId("B");
 972         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 973         executionTaskB.setServiceOrderInfoJson(json);
 974         executionTaskRepository.save(executionTaskB);
 975         return executionTaskA;
 976     }
 977
 978     public static ExecutionTask setUpBddForMacroExecutionTaskSucessWithComplexObject(
 979                 ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 980                 ActionType actionType) {
 981         ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType);
 982
 983         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 984                 serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 985                 List<ServiceCharacteristic> serviceCharacteristics = new ArrayList<>();
 986                 ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 987                 serviceCharacteristic1.setName("ServiceCharacteristics");
 988                 serviceCharacteristic1.setValueType("object");
 989                 Value value1 = new Value();
 990                 // Three parameters , one is an array of child objects
 991                 value1.setServiceCharacteristicValue(
 992                                 "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
 993                 serviceCharacteristic1.setValue(value1);
 994                 serviceCharacteristics.add(serviceCharacteristic1);
 995                 serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 996         }
 997
 998         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 999         testServiceOrder.setId("test");
1000         serviceOrderRepository.save(testServiceOrder);
1001
1002         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
1003         sdcResponse.put("invariantUUID", "uuid");
1004         sdcResponse.put("name", "VLB_Service");
1005         sdcResponse.put("version", "1");
1006         sdcResponse.put("category", "Network Services");
1007         sdcResponse.put("instantiationType", "Macro");
1008
1009         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
1010         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
1011         resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc");
1012         resourceSpecificationA.setInstanceName("vLB_VSP");
1013         resourceSpecificationA.setName("vLB_VSP");
1014         resourceSpecificationA.setType("ONAPresource");
1015         resourceSpecificationA.setVersion("2.0");
1016         resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e");
1017         resourceSpecs.add(resourceSpecificationA);
1018
1019         sdcResponse.put("resourceSpecification", resourceSpecs);
1020
1021         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
1022         serviceOrderInfo.setServiceOrderId("test");
1023         SubscriberInfo subscriberInfo = new SubscriberInfo();
1024         subscriberInfo.setGlobalSubscriberId("6490");
1025         subscriberInfo.setSubscriberName("edgar");
1026         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
1027
1028         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
1029         serviceOrderItemInfoA.setId("A");
1030         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
1031
1032         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
1033         serviceOrderItemInfoB.setId("B");
1034         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
1035         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
1036         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
1037
1038         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
1039
1040         ExecutionTask executionTaskA = new ExecutionTask();
1041         executionTaskA.setCreateDate(new Date());
1042         executionTaskA.setOrderItemId("A");
1043         executionTaskA.setServiceOrderInfoJson(json);
1044         executionTaskA = executionTaskRepository.save(executionTaskA);
1045         ExecutionTask executionTaskB = new ExecutionTask();
1046         executionTaskB.setCreateDate(new Date());
1047         executionTaskB.setOrderItemId("B");
1048         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
1049         executionTaskB.setServiceOrderInfoJson(json);
1050         executionTaskRepository.save(executionTaskB);
1051         return executionTaskA;
1052    }
1053 }