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