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 createTestServiceOrderForMacro(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         if (actionType != ActionType.ADD) {
 202                 serviceA.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 203         }
 204         serviceA.setServiceState("active");
 205         ServiceSpecificationRef serviceSpecificationRefA = new ServiceSpecificationRef();
 206         serviceSpecificationRefA.setId("82c9fbb4-656c-4973-8c7f-172b22b5fa8f");
 207         serviceA.setServiceSpecification(serviceSpecificationRefA);
 208         itemA.setService(serviceA);
 209         items.add(itemA);
 210
 211         ServiceOrderItem itemB = new ServiceOrderItem();
 212         itemB.id("B");
 213         itemB.action(actionType);
 214         Service serviceB = new Service();
 215         if (actionType != ActionType.ADD) {
 216                 serviceB.setId("e4688e5f-61a0-4f8b-ae02-a2fbde623bcb");
 217         }
 218         serviceB.setServiceState("active");
 219         ServiceSpecificationRef serviceSpecificationRefB = new ServiceSpecificationRef();
 220         serviceSpecificationRefB.setId("82c9fbb4-656c-4973-8c7f-172b22b5fa8f");
 221         serviceB.setServiceSpecification(serviceSpecificationRefB);
 222         itemB.setService(serviceB);
 223         List<OrderItemRelationship> orderItemRelationships = new ArrayList<>();
 224         OrderItemRelationship orderItemRelationship = new OrderItemRelationship();
 225         orderItemRelationship.setId("A");
 226         orderItemRelationship.setType(RelationshipType.RELIESON);
 227         orderItemRelationships.add(orderItemRelationship);
 228         itemB.setOrderItemRelationship(orderItemRelationships);
 229         items.add(itemB);
 230         serviceOrder.setOrderItem(items);
 231         return serviceOrder;
 232
 233         }
 234
 235     public static ExecutionTask setUpBddForExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 236             ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 237         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 238
 239         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 240             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 241         }
 242
 243         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 244         testServiceOrder.setId("test");
 245         serviceOrderRepository.save(testServiceOrder);
 246
 247         LinkedHashMap<String, String> sdcResponse = new LinkedHashMap<>();
 248         sdcResponse.put("invariantUUID", "uuid");
 249         sdcResponse.put("name", "vFW");
 250         sdcResponse.put("version", "v1");
 251         sdcResponse.put("category", "NonE2E");
 252
 253         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 254         serviceOrderInfo.setServiceOrderId("test");
 255         SubscriberInfo subscriberInfo = new SubscriberInfo();
 256         subscriberInfo.setGlobalSubscriberId("6490");
 257         subscriberInfo.setSubscriberName("edgar");
 258         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 259
 260         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 261         serviceOrderItemInfoA.setId("A");
 262         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 263
 264         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 265         serviceOrderItemInfoB.setId("B");
 266         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 267         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 268         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 269
 270         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 271
 272         ExecutionTask executionTaskA = new ExecutionTask();
 273         executionTaskA.setCreateDate(new Date());
 274         executionTaskA.setOrderItemId("A");
 275         executionTaskA.setServiceOrderInfoJson(json);
 276         executionTaskA = executionTaskRepository.save(executionTaskA);
 277         ExecutionTask executionTaskB = new ExecutionTask();
 278         executionTaskB.setCreateDate(new Date());
 279         executionTaskB.setOrderItemId("B");
 280         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 281         executionTaskB.setServiceOrderInfoJson(json);
 282         executionTaskRepository.save(executionTaskB);
 283         return executionTaskA;
 284     }
 285
 286     public static ExecutionTask setUpBddForE2EExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 287             ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 288         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 289
 290         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 291             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 292             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 293             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 294             serviceCharacteristic1.setName("access-site-id");
 295             Value value1 = new Value();
 296             value1.setServiceCharacteristicValue("1234765");
 297             serviceCharacteristic1.setValue(value1);
 298             serviceCharacteristics.add(serviceCharacteristic1);
 299             ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 300             serviceCharacteristic2.setName("provider-site-id");
 301             Value value2 = new Value();
 302             value2.setServiceCharacteristicValue("654321");
 303             serviceCharacteristic2.setValue(value2);
 304             serviceCharacteristics.add(serviceCharacteristic2);
 305             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 306         }
 307
 308         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 309         testServiceOrder.setId("test");
 310         serviceOrderRepository.save(testServiceOrder);
 311
 312         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 313         sdcResponse.put("invariantUUID", "uuid");
 314         sdcResponse.put("name", "vFW");
 315         sdcResponse.put("version", "v1");
 316         sdcResponse.put("category", "E2E Service");
 317
 318         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 319         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 320         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 321         resourceSpecificationA.setInstanceName("vFW-vSINK");
 322         resourceSpecificationA.setName("vFW-SINK");
 323         resourceSpecificationA.setType("ONAPresource");
 324         resourceSpecificationA.setVersion("2.0");
 325         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 326         resourceSpecs.add(resourceSpecificationA);
 327
 328         sdcResponse.put("resourceSpecification", resourceSpecs);
 329
 330         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 331         serviceOrderInfo.setServiceOrderId("test");
 332         SubscriberInfo subscriberInfo = new SubscriberInfo();
 333         subscriberInfo.setGlobalSubscriberId("6490");
 334         subscriberInfo.setSubscriberName("edgar");
 335         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 336
 337         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 338         serviceOrderItemInfoA.setId("A");
 339         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 340
 341         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 342         serviceOrderItemInfoB.setId("B");
 343         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 344         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 345         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 346
 347         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 348
 349         ExecutionTask executionTaskA = new ExecutionTask();
 350         executionTaskA.setCreateDate(new Date());
 351         executionTaskA.setOrderItemId("A");
 352         executionTaskA.setServiceOrderInfoJson(json);
 353         executionTaskA = executionTaskRepository.save(executionTaskA);
 354         ExecutionTask executionTaskB = new ExecutionTask();
 355         executionTaskB.setCreateDate(new Date());
 356         executionTaskB.setOrderItemId("B");
 357         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 358         executionTaskB.setServiceOrderInfoJson(json);
 359         executionTaskRepository.save(executionTaskB);
 360         return executionTaskA;
 361     }
 362
 363     public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithObject(
 364             ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 365             ActionType actionType) {
 366         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 367
 368         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 369             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 370             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 371             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 372             serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
 373             serviceCharacteristic1.setValueType("object");
 374             Value value1 = new Value();
 375             value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
 376             serviceCharacteristic1.setValue(value1);
 377             serviceCharacteristics.add(serviceCharacteristic1);
 378             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 379         }
 380
 381         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 382         testServiceOrder.setId("test");
 383         serviceOrderRepository.save(testServiceOrder);
 384
 385         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 386         sdcResponse.put("invariantUUID", "uuid");
 387         sdcResponse.put("name", "vFW");
 388         sdcResponse.put("version", "v1");
 389         sdcResponse.put("category", "E2E Service");
 390
 391         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 392         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 393         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 394         resourceSpecificationA.setInstanceName("vFW-vSINK");
 395         resourceSpecificationA.setName("vFW-SINK");
 396         resourceSpecificationA.setType("ONAPresource");
 397         resourceSpecificationA.setVersion("2.0");
 398         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 399         resourceSpecs.add(resourceSpecificationA);
 400
 401         sdcResponse.put("resourceSpecification", resourceSpecs);
 402
 403         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 404         serviceOrderInfo.setServiceOrderId("test");
 405         SubscriberInfo subscriberInfo = new SubscriberInfo();
 406         subscriberInfo.setGlobalSubscriberId("6490");
 407         subscriberInfo.setSubscriberName("edgar");
 408         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 409
 410         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 411         serviceOrderItemInfoA.setId("A");
 412         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 413
 414         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 415         serviceOrderItemInfoB.setId("B");
 416         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 417         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 418         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 419
 420         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 421
 422         ExecutionTask executionTaskA = new ExecutionTask();
 423         executionTaskA.setCreateDate(new Date());
 424         executionTaskA.setOrderItemId("A");
 425         executionTaskA.setServiceOrderInfoJson(json);
 426         executionTaskA = executionTaskRepository.save(executionTaskA);
 427         ExecutionTask executionTaskB = new ExecutionTask();
 428         executionTaskB.setCreateDate(new Date());
 429         executionTaskB.setOrderItemId("B");
 430         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 431         executionTaskB.setServiceOrderInfoJson(json);
 432         executionTaskRepository.save(executionTaskB);
 433         return executionTaskA;
 434     }
 435
 436     public static ExecutionTask setUpBddForE2EExecutionTaskSucessWithComplexObject(
 437             ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 438             ActionType actionType) {
 439         ServiceOrder testServiceOrder = createTestServiceOrder(actionType);
 440
 441         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 442             serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 443             List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 444             ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 445             serviceCharacteristic1.setName("EPL_ServiceCharacteristics");
 446             serviceCharacteristic1.setValueType("object");
 447             Value value1 = new Value();
 448             // Three parameters , one is an array of child objects
 449             value1.setServiceCharacteristicValue(
 450                     "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
 451             serviceCharacteristic1.setValue(value1);
 452             serviceCharacteristics.add(serviceCharacteristic1);
 453             serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 454         }
 455
 456         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 457         testServiceOrder.setId("test");
 458         serviceOrderRepository.save(testServiceOrder);
 459
 460         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 461         sdcResponse.put("invariantUUID", "uuid");
 462         sdcResponse.put("name", "vFW");
 463         sdcResponse.put("version", "v1");
 464         sdcResponse.put("category", "E2E Service");
 465
 466         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 467         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 468         resourceSpecificationA.setId("2e3feeb0-8e36-46c6-862c-236d9c626438");
 469         resourceSpecificationA.setInstanceName("vFW-vSINK");
 470         resourceSpecificationA.setName("vFW-SINK");
 471         resourceSpecificationA.setType("ONAPresource");
 472         resourceSpecificationA.setVersion("2.0");
 473         resourceSpecificationA.setResourceInvariantUUID("6e3feeb0-8e36-46c6-862c-236d9c626438");
 474         resourceSpecs.add(resourceSpecificationA);
 475
 476         sdcResponse.put("resourceSpecification", resourceSpecs);
 477
 478         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 479         serviceOrderInfo.setServiceOrderId("test");
 480         SubscriberInfo subscriberInfo = new SubscriberInfo();
 481         subscriberInfo.setGlobalSubscriberId("6490");
 482         subscriberInfo.setSubscriberName("edgar");
 483         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 484
 485         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 486         serviceOrderItemInfoA.setId("A");
 487         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 488
 489         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 490         serviceOrderItemInfoB.setId("B");
 491         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 492         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 493         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 494
 495         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 496
 497         ExecutionTask executionTaskA = new ExecutionTask();
 498         executionTaskA.setCreateDate(new Date());
 499         executionTaskA.setOrderItemId("A");
 500         executionTaskA.setServiceOrderInfoJson(json);
 501         executionTaskA = executionTaskRepository.save(executionTaskA);
 502         ExecutionTask executionTaskB = new ExecutionTask();
 503         executionTaskB.setCreateDate(new Date());
 504         executionTaskB.setOrderItemId("B");
 505         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 506         executionTaskB.setServiceOrderInfoJson(json);
 507         executionTaskRepository.save(executionTaskB);
 508         return executionTaskA;
 509     }
 510
 511     public static ExecutionTask setUpBddForMacroExecutionTaskSucess(ServiceOrderRepository serviceOrderRepository,
 512                 ExecutionTaskRepository executionTaskRepository, ActionType actionType) {
 513
 514         ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType);
 515
 516         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 517                 serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 518                 List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 519                 ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 520                 serviceCharacteristic1.setName("access-site-id");
 521                 Value value1 = new Value();
 522                 value1.setServiceCharacteristicValue("1234765");
 523                 serviceCharacteristic1.setValue(value1);
 524                 serviceCharacteristics.add(serviceCharacteristic1);
 525                 ServiceCharacteristic serviceCharacteristic2 = new ServiceCharacteristic();
 526                 serviceCharacteristic2.setName("provider-site-id");
 527                 Value value2 = new Value();
 528                 value2.setServiceCharacteristicValue("654321");
 529                 serviceCharacteristic2.setValue(value2);
 530                 serviceCharacteristics.add(serviceCharacteristic2);
 531                 serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 532         }
 533
 534         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 535         testServiceOrder.setId("test");
 536         serviceOrderRepository.save(testServiceOrder);
 537
 538         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 539         sdcResponse.put("invariantUUID", "uuid");
 540         sdcResponse.put("name", "VLB_Service");
 541         sdcResponse.put("version", "1.0");
 542         sdcResponse.put("category", "Network Service");
 543         sdcResponse.put("instantiationType", "Macro");
 544
 545         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 546         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 547         resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc");
 548         resourceSpecificationA.setInstanceName("vLB_VSP");
 549         resourceSpecificationA.setName("vLB_VSP");
 550         resourceSpecificationA.setType("VF");
 551         resourceSpecificationA.setVersion("1.0");
 552         resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e");
 553         resourceSpecs.add(resourceSpecificationA);
 554
 555         sdcResponse.put("resourceSpecification", resourceSpecs);
 556
 557         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 558         serviceOrderInfo.setServiceOrderId("test");
 559         SubscriberInfo subscriberInfo = new SubscriberInfo();
 560         subscriberInfo.setGlobalSubscriberId("6490");
 561         subscriberInfo.setSubscriberName("edgar");
 562         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 563
 564         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 565         serviceOrderItemInfoA.setId("A");
 566         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 567
 568         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 569         serviceOrderItemInfoB.setId("B");
 570         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 571         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 572         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 573
 574
 575
 576         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 577
 578         ExecutionTask executionTaskA = new ExecutionTask();
 579         executionTaskA.setCreateDate(new Date());
 580         executionTaskA.setOrderItemId("A");
 581         executionTaskA.setServiceOrderInfoJson(json);
 582         executionTaskA = executionTaskRepository.save(executionTaskA);
 583         ExecutionTask executionTaskB = new ExecutionTask();
 584         executionTaskB.setCreateDate(new Date());
 585         executionTaskB.setOrderItemId("B");
 586         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 587         executionTaskB.setServiceOrderInfoJson(json);
 588         executionTaskRepository.save(executionTaskB);
 589         return executionTaskA;
 590     }
 591
 592     public static ExecutionTask setUpBddForMacroExecutionTaskSucessWithObject(
 593         ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 594         ActionType actionType) {
 595         ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType);
 596
 597         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 598                 serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 599                 List<ServiceCharacteristic> serviceCharacteristics = new ArrayList();
 600                 ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 601                 serviceCharacteristic1.setName("ServiceCharacteristics");
 602                 serviceCharacteristic1.setValueType("object");
 603                 Value value1 = new Value();
 604                 value1.setServiceCharacteristicValue("{ \"key1\":\"value1\", \"key2\":\"value2\"}");
 605                 serviceCharacteristic1.setValue(value1);
 606                 serviceCharacteristics.add(serviceCharacteristic1);
 607                 serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 608         }
 609
 610         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 611         testServiceOrder.setId("test");
 612         serviceOrderRepository.save(testServiceOrder);
 613
 614         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 615         sdcResponse.put("invariantUUID", "uuid");
 616         sdcResponse.put("name", "VLB_Service");
 617         sdcResponse.put("version", "1");
 618         sdcResponse.put("category", "Network Service");
 619         sdcResponse.put("instantiationType", "Macro");
 620
 621         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 622         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 623         resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc");
 624         resourceSpecificationA.setInstanceName("vLB_VSP");
 625         resourceSpecificationA.setName("vFW-SINK");
 626         resourceSpecificationA.setType("ONAPresource");
 627         resourceSpecificationA.setVersion("2.0");
 628         resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e");
 629         resourceSpecs.add(resourceSpecificationA);
 630
 631         sdcResponse.put("resourceSpecification", resourceSpecs);
 632
 633         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 634         serviceOrderInfo.setServiceOrderId("test");
 635         SubscriberInfo subscriberInfo = new SubscriberInfo();
 636         subscriberInfo.setGlobalSubscriberId("6490");
 637         subscriberInfo.setSubscriberName("edgar");
 638         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 639
 640         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 641         serviceOrderItemInfoA.setId("A");
 642         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 643
 644         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 645         serviceOrderItemInfoB.setId("B");
 646         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 647         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 648         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 649
 650         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 651
 652         ExecutionTask executionTaskA = new ExecutionTask();
 653         executionTaskA.setCreateDate(new Date());
 654         executionTaskA.setOrderItemId("A");
 655         executionTaskA.setServiceOrderInfoJson(json);
 656         executionTaskA = executionTaskRepository.save(executionTaskA);
 657         ExecutionTask executionTaskB = new ExecutionTask();
 658         executionTaskB.setCreateDate(new Date());
 659         executionTaskB.setOrderItemId("B");
 660         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 661         executionTaskB.setServiceOrderInfoJson(json);
 662         executionTaskRepository.save(executionTaskB);
 663         return executionTaskA;
 664     }
 665
 666     public static ExecutionTask setUpBddForMacroExecutionTaskSucessWithComplexObject(
 667                 ServiceOrderRepository serviceOrderRepository, ExecutionTaskRepository executionTaskRepository,
 668                 ActionType actionType) {
 669         ServiceOrder testServiceOrder = createTestServiceOrderForMacro(actionType);
 670
 671         for (ServiceOrderItem serviceOrderItem : testServiceOrder.getOrderItem()) {
 672                 serviceOrderItem.setState(StateType.ACKNOWLEDGED);
 673                 List<ServiceCharacteristic> serviceCharacteristics = new ArrayList<>();
 674                 ServiceCharacteristic serviceCharacteristic1 = new ServiceCharacteristic();
 675                 serviceCharacteristic1.setName("ServiceCharacteristics");
 676                 serviceCharacteristic1.setValueType("object");
 677                 Value value1 = new Value();
 678                 // Three parameters , one is an array of child objects
 679                 value1.setServiceCharacteristicValue(
 680                                 "{\"key1\":\"value1\", \"key2\":\"value2\", \"key3\":[ {\"lat1\":\"value1\",\"lon1\":\"value1\"}, { \"lat2\":\"value2\", \"lon2\":\"value2\"}]}");
 681                 serviceCharacteristic1.setValue(value1);
 682                 serviceCharacteristics.add(serviceCharacteristic1);
 683                 serviceOrderItem.getService().setServiceCharacteristic(serviceCharacteristics);
 684         }
 685
 686         testServiceOrder.setState(StateType.ACKNOWLEDGED);
 687         testServiceOrder.setId("test");
 688         serviceOrderRepository.save(testServiceOrder);
 689
 690         LinkedHashMap<String, Object> sdcResponse = new LinkedHashMap<>();
 691         sdcResponse.put("invariantUUID", "uuid");
 692         sdcResponse.put("name", "VLB_Service");
 693         sdcResponse.put("version", "1");
 694         sdcResponse.put("category", "Network Services");
 695         sdcResponse.put("instantiationType", "Macro");
 696
 697         List<ResourceSpecification> resourceSpecs = new ArrayList<>();
 698         ResourceSpecification resourceSpecificationA = new ResourceSpecification();
 699         resourceSpecificationA.setId("35d7887d-3c35-4fb4-aed1-d15b4d9f4ccc");
 700         resourceSpecificationA.setInstanceName("vLB_VSP");
 701         resourceSpecificationA.setName("vLB_VSP");
 702         resourceSpecificationA.setType("ONAPresource");
 703         resourceSpecificationA.setVersion("2.0");
 704         resourceSpecificationA.setResourceInvariantUUID("368371e6-1d2f-4f4a-b992-a9053c7c2f1e");
 705         resourceSpecs.add(resourceSpecificationA);
 706
 707         sdcResponse.put("resourceSpecification", resourceSpecs);
 708
 709         ServiceOrderInfo serviceOrderInfo = new ServiceOrderInfo();
 710         serviceOrderInfo.setServiceOrderId("test");
 711         SubscriberInfo subscriberInfo = new SubscriberInfo();
 712         subscriberInfo.setGlobalSubscriberId("6490");
 713         subscriberInfo.setSubscriberName("edgar");
 714         serviceOrderInfo.setSubscriberInfo(subscriberInfo);
 715
 716         ServiceOrderItemInfo serviceOrderItemInfoA = new ServiceOrderItemInfo();
 717         serviceOrderItemInfoA.setId("A");
 718         serviceOrderItemInfoA.setCatalogResponse(sdcResponse);
 719
 720         ServiceOrderItemInfo serviceOrderItemInfoB = new ServiceOrderItemInfo();
 721         serviceOrderItemInfoB.setId("B");
 722         serviceOrderItemInfoB.setCatalogResponse(sdcResponse);
 723         serviceOrderInfo.addServiceOrderItemInfos("A", serviceOrderItemInfoA);
 724         serviceOrderInfo.addServiceOrderItemInfos("B", serviceOrderItemInfoB);
 725
 726         String json = JsonEntityConverter.convertServiceOrderInfoToJson(serviceOrderInfo);
 727
 728         ExecutionTask executionTaskA = new ExecutionTask();
 729         executionTaskA.setCreateDate(new Date());
 730         executionTaskA.setOrderItemId("A");
 731         executionTaskA.setServiceOrderInfoJson(json);
 732         executionTaskA = executionTaskRepository.save(executionTaskA);
 733         ExecutionTask executionTaskB = new ExecutionTask();
 734         executionTaskB.setCreateDate(new Date());
 735         executionTaskB.setOrderItemId("B");
 736         executionTaskB.setReliedTasks(String.valueOf(executionTaskA.getInternalId()));
 737         executionTaskB.setServiceOrderInfoJson(json);
 738         executionTaskRepository.save(executionTaskB);
 739         return executionTaskA;
 740    }
 741 }