test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/general/AtomicOperationUtils.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.utils.general;
  22
  23 import com.aventstack.extentreports.Status;
  24 import com.google.gson.Gson;
  25 import fj.data.Either;
  26 import org.apache.commons.codec.binary.Base64;
  27 import org.apache.commons.lang3.tuple.Pair;
  28 import org.json.JSONException;
  29 import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
  30 import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
  31 import org.openecomp.sdc.be.datatypes.elements.ConsumerDataDefinition;
  32 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
  33 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  34 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  35 import org.openecomp.sdc.be.model.*;
  36 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  37 import org.openecomp.sdc.ci.tests.api.ExtentTestActions;
  38 import org.openecomp.sdc.ci.tests.api.Urls;
  39 import org.openecomp.sdc.ci.tests.config.Config;
  40 import org.openecomp.sdc.ci.tests.datatypes.*;
  41 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  42 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  43 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  44 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  45 import org.openecomp.sdc.ci.tests.execute.lifecycle.LCSbaseTest;
  46 import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaDefinition;
  47 import org.openecomp.sdc.ci.tests.utils.CsarToscaTester;
  48 import org.openecomp.sdc.ci.tests.utils.DistributionUtils;
  49 import org.openecomp.sdc.ci.tests.utils.ToscaParserUtils;
  50 import org.openecomp.sdc.ci.tests.utils.Utils;
  51 import org.openecomp.sdc.ci.tests.utils.rest.*;
  52 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  53 import org.openecomp.sdc.common.util.GeneralUtility;
  54 import org.testng.SkipException;
  55
  56 import java.io.File;
  57 import java.io.IOException;
  58 import java.nio.file.Files;
  59 import java.nio.file.Path;
  60 import java.nio.file.Paths;
  61 import java.util.ArrayList;
  62 import java.util.HashMap;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.Map.Entry;
  66 import java.util.concurrent.TimeUnit;
  67 import java.util.stream.Collectors;
  68
  69 import static org.junit.Assert.assertFalse;
  70 import static org.testng.AssertJUnit.assertEquals;
  71 import static org.testng.AssertJUnit.assertTrue;
  72
  73 public final class AtomicOperationUtils {
  74
  75         static final String basicAuthentication = "Basic Y2k6MTIzNDU2";
  76
  77         private AtomicOperationUtils() {
  78                 throw new UnsupportedOperationException();
  79         }
  80
  81         // *********** RESOURCE ****************
  82         /**
  83          * Import a vfc From tosca file
  84          *
  85          * @param filePath
  86          * @param fileName
  87          * @return
  88          * @throws IOException
  89          * @throws JSONException
  90          */
  91         public static Either<Resource, RestResponse> importResource(String filePath, String fileName) {
  92                 try {
  93                         User designer = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  94                         ImportReqDetails importReqDetails = ElementFactory.getDefaultImportResource(ElementFactory.getResourcePrefix());
  95                         importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, filePath, fileName);
  96                         RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, designer, null);
  97                         return buildResourceFromResponse(importResourceResponse);
  98                 } catch (Exception e) {
  99                         throw new AtomicOperationException(e);
 100                 }
 101         }
 102
 103         public static Either<Resource, RestResponse> importResource(ImportReqDetails importReqDetails, String filePath, String fileName, User userRole, Boolean validateState) {
 104                 try {
 105                         importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, filePath, fileName);
 106                         RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails, userRole, null);
 107
 108                         if (validateState) {
 109                                 assertTrue("Import resource failed with error: " + importResourceResponse.getResponse(),importResourceResponse.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 110                         }
 111
 112                         if (importResourceResponse.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 113                                 Resource resourceResponseObject = ResponseParser.convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 114                                 return Either.left(resourceResponseObject);
 115                         }
 116                         return Either.right(importResourceResponse);
 117                 } catch (Exception e) {
 118                         throw new AtomicOperationException(e);
 119                 }
 120         }
 121
 122
 123         public static Either<Resource, RestResponse> createResourceByType(ResourceTypeEnum resourceType, UserRoleEnum userRole, Boolean validateState) {
 124                 try {
 125                         User defaultUser = ElementFactory.getDefaultUser(userRole);
 126                         ResourceReqDetails defaultResource = ElementFactory.getDefaultResourceByType(resourceType, defaultUser);
 127                         RestResponse resourceResp = ResourceRestUtils.createResource(defaultResource, defaultUser);
 128
 129                         if (validateState) {
 130                                 assertTrue("Create resource failed with error: " + resourceResp.getResponse(),resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 131                         }
 132
 133                         if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 134                                 Resource resourceResponseObject = ResponseParser.convertResourceResponseToJavaObject(resourceResp.getResponse());
 135                                 return Either.left(resourceResponseObject);
 136                         }
 137                         return Either.right(resourceResp);
 138                 } catch (Exception e) {
 139                         throw new AtomicOperationException(e);
 140                 }
 141         }
 142
 143         public static Either<Resource, RestResponse> createResourceByResourceDetails(ResourceReqDetails resourceDetails, UserRoleEnum userRole, Boolean validateState) {
 144                 try {
 145                         User defaultUser = ElementFactory.getDefaultUser(userRole);
 146                         RestResponse resourceResp = ResourceRestUtils.createResource(resourceDetails, defaultUser);
 147
 148                         if (validateState) {
 149                                 assertTrue("Create resource failed with error: " + resourceResp.getResponse(),resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 150                         }
 151
 152                         if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 153                                 Resource resourceResponseObject = ResponseParser.convertResourceResponseToJavaObject(resourceResp.getResponse());
 154                                 return Either.left(resourceResponseObject);
 155                         }
 156                         return Either.right(resourceResp);
 157                 } catch (Exception e) {
 158                         throw new AtomicOperationException(e);
 159                 }
 160         }
 161
 162         public static Either<Resource, RestResponse> createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum resourceType, NormativeTypesEnum normativeTypes, ResourceCategoryEnum resourceCategory, UserRoleEnum userRole, Boolean validateState)
 163                         throws Exception {
 164                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 165                 ResourceReqDetails defaultResource = ElementFactory.getDefaultResourceByTypeNormTypeAndCatregory(resourceType, normativeTypes, resourceCategory, defaultUser);
 166                 RestResponse resourceResp = ResourceRestUtils.createResource(defaultResource, defaultUser);
 167
 168                 if (validateState) {
 169                         assertTrue("Actual Response Code is: " + resourceResp.getErrorCode(), resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 170                 }
 171
 172                 if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 173                         // Resource resourceResponseObject = ResponseParser
 174                         // .convertResourceResponseToJavaObject(resourceResp.getResponse());
 175                         Resource resourceResponseObject = ResponseParser.parseToObjectUsingMapper(resourceResp.getResponse(), Resource.class);
 176                         return Either.left(resourceResponseObject);
 177                 }
 178                 return Either.right(resourceResp);
 179         }
 180
 181         public static Either<Resource, RestResponse> createResourcesByCustomNormativeTypeAndCatregory(ResourceTypeEnum resourceType, Resource resourceNormativeType, ResourceCategoryEnum resourceCategory, UserRoleEnum userRole, Boolean validateState)
 182                         throws Exception {
 183                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 184                 ResourceReqDetails defaultResource = ElementFactory.getDefaultResourceByTypeNormTypeAndCatregory(resourceType, resourceNormativeType, resourceCategory, defaultUser);
 185                 RestResponse resourceResp = ResourceRestUtils.createResource(defaultResource, defaultUser);
 186
 187                 if (validateState) {
 188                         assertTrue("Create resource failed with error: " + resourceResp.getResponse(), resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 189                 }
 190
 191                 if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 192                         // Resource resourceResponseObject = ResponseParser
 193                         // .convertResourceResponseToJavaObject(resourceResp.getResponse());
 194                         Resource resourceResponseObject = ResponseParser.parseToObjectUsingMapper(resourceResp.getResponse(), Resource.class);
 195                         return Either.left(resourceResponseObject);
 196                 }
 197                 return Either.right(resourceResp);
 198         }
 199
 200         public static Either<Resource, RestResponse> updateResource(ResourceReqDetails resourceReqDetails, User defaultUser, Boolean validateState) {
 201                 try {
 202
 203                         RestResponse resourceResp = ResourceRestUtils.updateResource(resourceReqDetails, defaultUser, resourceReqDetails.getUniqueId());
 204
 205                         if (validateState) {
 206                                 assertTrue("Update resource failed with error: " + resourceResp.getResponse(),resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_SUCCESS);
 207                         }
 208
 209                         if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_SUCCESS) {
 210                                 Resource resourceResponseObject = ResponseParser.convertResourceResponseToJavaObject(resourceResp.getResponse());
 211                                 return Either.left(resourceResponseObject);
 212                         }
 213                         return Either.right(resourceResp);
 214                 } catch (Exception e) {
 215                         throw new AtomicOperationException(e);
 216                 }
 217         }
 218
 219         // *********** SERVICE ****************
 220
 221         public static Either<Service, RestResponse> createDefaultService(UserRoleEnum userRole, Boolean validateState) throws Exception {
 222                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 223                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService(defaultUser);
 224                 RestResponse createServiceResp = ServiceRestUtils.createService(serviceDetails, defaultUser);
 225
 226                 if (validateState) {
 227                         assertTrue("Create service failed with error: " + createServiceResp.getResponse(),createServiceResp.getErrorCode() == ServiceRestUtils.STATUS_CODE_CREATED);
 228                 }
 229
 230                 if (createServiceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 231                         Service serviceResponseObject = ResponseParser.convertServiceResponseToJavaObject(createServiceResp.getResponse());
 232                         return Either.left(serviceResponseObject);
 233                 }
 234                 return Either.right(createServiceResp);
 235         }
 236
 237         public static Either<Service, RestResponse> createServiceByCategory(ServiceCategoriesEnum category, UserRoleEnum userRole, Boolean validateState) throws Exception {
 238                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 239                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService(category, defaultUser);
 240                 RestResponse createServiceResp = ServiceRestUtils.createService(serviceDetails, defaultUser);
 241
 242                 if (validateState) {
 243                         assertTrue("Create service failed with error: " + createServiceResp.getResponse(),createServiceResp.getErrorCode() == ServiceRestUtils.STATUS_CODE_CREATED);
 244                 }
 245
 246                 if (createServiceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 247                         Service serviceResponseObject = ResponseParser.convertServiceResponseToJavaObject(createServiceResp.getResponse());
 248                         return Either.left(serviceResponseObject);
 249                 }
 250                 return Either.right(createServiceResp);
 251         }
 252
 253         public static Either<Service, RestResponse> createCustomService(ServiceReqDetails serviceDetails, UserRoleEnum userRole, Boolean validateState) throws Exception {
 254                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 255                 RestResponse createServiceResp = ServiceRestUtils.createService(serviceDetails, defaultUser);
 256
 257                 if (validateState) {
 258                         assertTrue("Create service failed with error: " + createServiceResp.getResponse(),createServiceResp.getErrorCode() == ServiceRestUtils.STATUS_CODE_CREATED);
 259                 }
 260
 261                 if (createServiceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 262                         Service serviceResponseObject = ResponseParser.convertServiceResponseToJavaObject(createServiceResp.getResponse());
 263                         return Either.left(serviceResponseObject);
 264                 }
 265                 return Either.right(createServiceResp);
 266         }
 267         // *********** PRODUCT ****************
 268
 269         public static Either<Product, RestResponse> createDefaultProduct(UserRoleEnum userRole, Boolean validateState) throws Exception {
 270                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 271                 ProductReqDetails defaultProduct = ElementFactory.getDefaultProduct();
 272                 RestResponse createProductResp = ProductRestUtils.createProduct(defaultProduct, defaultUser);
 273
 274                 if (validateState) {
 275                         assertTrue(createProductResp.getErrorCode() == ProductRestUtils.STATUS_CODE_CREATED);
 276                 }
 277
 278                 if (createProductResp.getErrorCode() == ProductRestUtils.STATUS_CODE_CREATED) {
 279                         Product productResponseJavaObject = ResponseParser.convertProductResponseToJavaObject(createProductResp.getResponse());
 280                         return Either.left(productResponseJavaObject);
 281                 }
 282                 return Either.right(createProductResp);
 283         }
 284
 285         // public static ComponentReqDetails
 286         // convertCompoentToComponentReqDetails(Component component){
 287         //
 288         // ComponentReqDetails componentReqDetails =
 289         // ElementFactory.getDefaultService();
 290         // componentReqDetails.setName(component.getName());
 291         // componentReqDetails.setDescription(component.getDescription());
 292         // componentReqDetails.setTags(component.getTags());
 293         // componentReqDetails.setContactId(component.getContactId());
 294         // componentReqDetails.setIcon(component.getIcon());
 295         // componentReqDetails.setUniqueId(component.getUniqueId());
 296         // componentReqDetails.setCreatorUserId(component.getCreatorUserId());
 297         // componentReqDetails.setCreatorFullName(component.getCreatorFullName());
 298         // componentReqDetails.setLastUpdaterUserId(component.getLastUpdaterUserId());
 299         // componentReqDetails.setLastUpdaterFullName(component.getLastUpdaterFullName());
 300         // componentReqDetails.setCreationDate(component.getCreationDate());
 301         // componentReqDetails.setLastUpdateDate(component.getLastUpdateDate());
 302         // componentReqDetails.setLifecycleState(component.getLifecycleState());
 303         // componentReqDetails.setVersion(component.getVersion());
 304         // componentReqDetails.setUuid(component.getUUID());
 305         // componentReqDetails.setCategories(component.getCategories());
 306         // componentReqDetails.setProjectCode(component.getProjectCode());
 307         //
 308         // return componentReqDetails;
 309         // }
 310
 311         // *********** LIFECYCLE ***************
 312
 313     public static Pair<Component, RestResponse> changeComponentState(Component component, UserRoleEnum userRole, LifeCycleStatesEnum targetState, Boolean validateState) throws Exception {
 314
 315         Boolean isValidationFailed = false;
 316         RestResponse lifeCycleStatesResponse = null;
 317         User defaultUser;
 318
 319         LifeCycleStatesEnum currentCompState = LifeCycleStatesEnum.findByCompState(component.getLifecycleState().toString());
 320
 321                 if (currentCompState == targetState) {
 322                         component = getComponentObject(component, userRole);
 323                         return Pair.of(component, null);
 324                 }
 325                 String componentType = component.getComponentType().getValue();
 326                 ArrayList<String> lifeCycleStatesEnumList = new ArrayList<>();
 327                 if (currentCompState.equals(LifeCycleStatesEnum.CHECKIN) && targetState.equals(LifeCycleStatesEnum.CHECKOUT)) {
 328                         lifeCycleStatesEnumList.add(LifeCycleStatesEnum.CHECKIN.toString());
 329                         lifeCycleStatesEnumList.add(LifeCycleStatesEnum.CHECKOUT.toString());
 330                 } else {
 331                         lifeCycleStatesEnumList.add(LifeCycleStatesEnum.CHECKOUT.toString());
 332                         lifeCycleStatesEnumList.add(LifeCycleStatesEnum.CHECKIN.toString());
 333                         lifeCycleStatesEnumList.add(LifeCycleStatesEnum.CERTIFY.toString());
 334                 }
 335                 for (int i = 0; i < lifeCycleStatesEnumList.size(); i++) {
 336                         if (lifeCycleStatesEnumList.get(i).equals(currentCompState.name())) {
 337                                 int a;
 338                                 a = (i == lifeCycleStatesEnumList.size() - 1) ? 0 : i + 1;
 339                                 for (int n = a; n < lifeCycleStatesEnumList.size(); n++) {
 340                                         defaultUser = ElementFactory.getDefaultUser(userRole);
 341                                         lifeCycleStatesResponse = LifecycleRestUtils.changeComponentState(component, defaultUser, LifeCycleStatesEnum.findByState(lifeCycleStatesEnumList.get(n)));
 342                                         if (lifeCycleStatesResponse.getErrorCode() != LifecycleRestUtils.STATUS_CODE_SUCCESS)
 343                                                 isValidationFailed = true;
 344                                         if (lifeCycleStatesEnumList.get(n).equals(targetState.toString()) || isValidationFailed) {
 345                                                 break;
 346                                         }
 347                                 }
 348                         }
 349                 }
 350                 Component componentJavaObject = getComponentObject(component, userRole);
 351
 352                 if (validateState && isValidationFailed) {
 353                         assertTrue("change state to [" + targetState.getState() + "] failed" + lifeCycleStatesResponse.getResponse(), false);
 354                         return Pair.of(componentJavaObject, lifeCycleStatesResponse);
 355                 }
 356
 357                 if (isValidationFailed) {
 358                         return Pair.of(componentJavaObject, lifeCycleStatesResponse);
 359                 }
 360
 361                 return Pair.of(componentJavaObject, lifeCycleStatesResponse);
 362         }
 363
 364         public static RestResponse distributeService(Component component, Boolean validateState) throws Exception {
 365
 366                 Service service = (Service) component;
 367
 368                 User opsUser = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
 369                 User governotUser = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
 370
 371                 ServiceReqDetails serviceDetails = new ServiceReqDetails(service);
 372                 RestResponse distributionService = null;
 373
 374                 RestResponse approveDistribution = LifecycleRestUtils.changeDistributionStatus(serviceDetails, null, governotUser, "approveService", DistributionStatusEnum.DISTRIBUTED);
 375                 if (approveDistribution.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS) {
 376                         distributionService = LifecycleRestUtils.changeDistributionStatus(serviceDetails, null, opsUser, "approveService", DistributionStatusEnum.DISTRIBUTED);
 377                 }
 378
 379                 if (validateState) {
 380                         assertTrue("Distribution approve failed with error: " + approveDistribution.getResponse(),approveDistribution.getErrorCode() == ProductRestUtils.STATUS_CODE_SUCCESS);
 381                         assertTrue("Distribute service failed with error: " + distributionService.getResponse(),distributionService.getErrorCode() == ProductRestUtils.STATUS_CODE_SUCCESS);
 382                         return distributionService;
 383                 }
 384
 385                 return distributionService;
 386         }
 387
 388         public static void toscaValidation(Component component, String vnfFile) throws Exception {
 389
 390                 ISdcCsarHelper fdntCsarHelper;
 391                 SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();
 392                 File csarFile = AssetRestUtils.getToscaModelCsarFile(AssetTypeEnum.SERVICES, component.getUUID() , vnfFile);
 393                 ExtentTestActions.log(Status.INFO, "Tosca parser is going to convert service csar file to ISdcCsarHelper object...");
 394                 fdntCsarHelper = factory.getSdcCsarHelper(csarFile.getAbsolutePath());
 395                 CsarToscaTester.processCsar(fdntCsarHelper);
 396                 ExtentTestActions.log(Status.INFO, String.format("Tosca parser successfully parsed service CSAR"));
 397
 398         }
 399
 400         // *********** ARTIFACTS *****************
 401
 402         public static Either<ArtifactDefinition, RestResponse> uploadArtifactByType(ArtifactTypeEnum artifactType, Component component, UserRoleEnum userRole, Boolean deploymentTrue, Boolean validateState) throws Exception {
 403
 404                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 405                 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(null, artifactType, deploymentTrue);
 406                 if (!deploymentTrue)
 407                         artifactDetails.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL.getType());
 408                 RestResponse uploadArtifactResp = ArtifactRestUtils.uploadArtifact(artifactDetails, component, defaultUser);
 409
 410                 if (validateState) {
 411                         assertTrue("artifact upload failed: " + artifactDetails.getArtifactName(), uploadArtifactResp.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 412                 }
 413
 414                 if (uploadArtifactResp.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS) {
 415                         ArtifactDefinition artifactJavaObject = ResponseParser.convertArtifactDefinitionResponseToJavaObject(uploadArtifactResp.getResponse());
 416                         return Either.left(artifactJavaObject);
 417                 }
 418                 return Either.right(uploadArtifactResp);
 419         }
 420
 421         // *********** CONTAINERS *****************
 422         /**
 423          * Adds Component instance to Component
 424          *
 425          * @param compInstParent
 426          * @param compContainer
 427          * @return
 428          */
 429         public static Either<ComponentInstance, RestResponse> addComponentInstanceToComponentContainer(Component compInstParent, Component compContainer) {
 430                 return addComponentInstanceToComponentContainer(compInstParent, compContainer, UserRoleEnum.DESIGNER, false);
 431         }
 432
 433     public static Either<ComponentInstance, RestResponse> addComponentInstanceToComponentContainer(Component compInstParent,
 434                                                                                                    Component compContainer,
 435                                                                                                    UserRoleEnum userRole,
 436                                                                                                    Boolean validateState) {
 437         try {
 438             User defaultUser = ElementFactory.getDefaultUser(userRole);
 439             ComponentInstanceReqDetails componentInstanceDetails = ElementFactory.getComponentInstance(compInstParent);
 440             if (componentInstanceDetails.getOriginType() == null){
 441                 componentInstanceDetails.setOriginType(((Resource) compInstParent).getResourceType().toString());
 442             }
 443             RestResponse createComponentInstance = ComponentInstanceRestUtils.createComponentInstance(componentInstanceDetails,
 444                     defaultUser, compContainer);
 445
 446             if (validateState) {
 447                 if (createComponentInstance.getErrorCode() == ServiceRestUtils.STATUS_CODE_NOT_FOUND) {
 448                     throw new SkipException("Open bug DE262001");
 449                 } else {
 450                     assertTrue("error - " + createComponentInstance.getErrorCode() + "instead - " +
 451                             ServiceRestUtils.STATUS_CODE_CREATED,
 452                             createComponentInstance.getErrorCode() == ServiceRestUtils.STATUS_CODE_CREATED);
 453                 }
 454             }
 455
 456             if (createComponentInstance.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 457                 ComponentInstance componentInstance = ResponseParser
 458                         .convertComponentInstanceResponseToJavaObject(createComponentInstance.getResponse());
 459                 return Either.left(componentInstance);
 460             }
 461             return Either.right(createComponentInstance);
 462         } catch (Exception e) {
 463             throw new AtomicOperationException(e);
 464         }
 465     }
 466
 467         public static Either<ComponentInstance, RestResponse> addComponentInstanceToComponentContainer(Component compInstParent, Component compContainer, UserRoleEnum userRole, Boolean validateState, String positionX, String positionY) {
 468                 try {
 469                         User defaultUser = ElementFactory.getDefaultUser(userRole);
 470                         ComponentInstanceReqDetails componentInstanceDetails = ElementFactory.getComponentInstance(compInstParent);
 471                         componentInstanceDetails.setPosX(positionX);
 472                         componentInstanceDetails.setPosY(positionY);
 473                         RestResponse createComponentInstance = ComponentInstanceRestUtils.createComponentInstance(componentInstanceDetails, defaultUser, compContainer);
 474
 475                         if (validateState) {
 476                                 if (createComponentInstance.getErrorCode() == ServiceRestUtils.STATUS_CODE_NOT_FOUND)
 477                                 {
 478                                         throw new SkipException("Open bug DE262001");
 479                                 }
 480                                 else{
 481                                         assertTrue("error - " + createComponentInstance.getErrorCode() + "instead - " + ServiceRestUtils.STATUS_CODE_CREATED, createComponentInstance.getErrorCode() == ServiceRestUtils.STATUS_CODE_CREATED);
 482                                 }
 483                         }
 484
 485                         if (createComponentInstance.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 486                                 ComponentInstance componentInstance = ResponseParser.convertComponentInstanceResponseToJavaObject(createComponentInstance.getResponse());
 487                                 return Either.left(componentInstance);
 488                         }
 489                         return Either.right(createComponentInstance);
 490                 } catch (Exception e) {
 491                         throw new AtomicOperationException(e);
 492                 }
 493         }
 494
 495         public static Resource getResourceObject(Component containerDetails, UserRoleEnum userRole) throws Exception {
 496                 // User defaultUser = ElementFactory.getDefaultUser(userRole);
 497                 RestResponse restResponse = ResourceRestUtils.getResource(containerDetails.getUniqueId());
 498                 return ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 499         }
 500
 501         public static Resource getResourceObject(String uniqueId) throws Exception {
 502                 RestResponse restResponse = ResourceRestUtils.getResource(uniqueId);
 503                 return ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 504         }
 505
 506         public static Resource getResourceObjectByNameAndVersion(UserRoleEnum sdncModifierDetails, String resourceName, String resourceVersion) throws Exception {
 507                 User defaultUser = ElementFactory.getDefaultUser(sdncModifierDetails);
 508                 RestResponse resourceResponse = ResourceRestUtils.getResourceByNameAndVersion(defaultUser.getUserId(), resourceName, resourceVersion);
 509                 return ResponseParser.convertResourceResponseToJavaObject(resourceResponse.getResponse());
 510         }
 511
 512         public static Service getServiceObject(Component containerDetails, UserRoleEnum userRole) throws Exception {
 513                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 514                 RestResponse serviceResponse = ServiceRestUtils.getService(containerDetails.getUniqueId(), defaultUser);
 515                 return ResponseParser.convertServiceResponseToJavaObject(serviceResponse.getResponse());
 516         }
 517
 518         public static Service getServiceObjectByNameAndVersion(UserRoleEnum sdncModifierDetails, String serviceName, String serviceVersion) throws Exception {
 519                 User defaultUser = ElementFactory.getDefaultUser(sdncModifierDetails);
 520                 RestResponse serviceResponse = ServiceRestUtils.getServiceByNameAndVersion(defaultUser, serviceName, serviceVersion);
 521                 return ResponseParser.convertServiceResponseToJavaObject(serviceResponse.getResponse());
 522         }
 523
 524         public static Service getServiceObject(String uniqueId) throws Exception {
 525                 RestResponse serviceResponse = ServiceRestUtils.getService(uniqueId);
 526                 return ResponseParser.convertServiceResponseToJavaObject(serviceResponse.getResponse());
 527         }
 528
 529         public static Product getProductObject(Component containerDetails, UserRoleEnum userRole) throws Exception {
 530                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 531                 RestResponse productRest = ProductRestUtils.getProduct(containerDetails.getUniqueId(), defaultUser.getUserId());
 532                 return ResponseParser.convertProductResponseToJavaObject(productRest.getResponse());
 533         }
 534
 535         public static Component getComponentObject(Component containerDetails, UserRoleEnum userRole) throws Exception {
 536                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 537
 538                 switch (containerDetails.getComponentType()) {
 539                         case RESOURCE:
 540                                 RestResponse restResponse = ResourceRestUtils.getResource(containerDetails.getUniqueId());
 541                                 containerDetails = ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 542                                 break;
 543                         case SERVICE:
 544                                 RestResponse serviceResponse = ServiceRestUtils.getService(containerDetails.getUniqueId(), defaultUser);
 545                                 containerDetails = ResponseParser.convertServiceResponseToJavaObject(serviceResponse.getResponse());
 546                                 break;
 547                         case PRODUCT:
 548                                 RestResponse productRest = ProductRestUtils.getProduct(containerDetails.getUniqueId(), defaultUser.getUserId());
 549                                 containerDetails = ResponseParser.convertProductResponseToJavaObject(productRest.getResponse());
 550                                 break;
 551                         default:
 552                                 break;
 553                 }
 554                 return containerDetails;
 555         }
 556
 557         public static Component convertReposnseToComponentObject(Component containerDetails, RestResponse restresponse) {
 558
 559                 switch (containerDetails.getComponentType()) {
 560                         case RESOURCE:
 561                                 containerDetails = ResponseParser.convertResourceResponseToJavaObject(restresponse.getResponse());
 562                                 break;
 563                         case SERVICE:
 564                                 containerDetails = ResponseParser.convertServiceResponseToJavaObject(restresponse.getResponse());
 565                                 break;
 566                         case PRODUCT:
 567                                 containerDetails = ResponseParser.convertProductResponseToJavaObject(restresponse.getResponse());
 568                                 break;
 569                         default:
 570                                 break;
 571                 }
 572                 return containerDetails;
 573         }
 574
 575         public static Either<Component, RestResponse> associate2ResourceInstances(Component containerDetails, ComponentInstance fromNode, ComponentInstance toNode, String assocType, UserRoleEnum userRole, Boolean validateState) throws Exception {
 576
 577                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 578                 RestResponse associate2ResourceInstancesResponse = ResourceRestUtils.associate2ResourceInstances(containerDetails, fromNode, toNode, assocType, defaultUser);
 579
 580                 if (validateState) {
 581                         assertTrue(associate2ResourceInstancesResponse.getErrorCode() == ServiceRestUtils.STATUS_CODE_SUCCESS);
 582                 }
 583
 584                 if (associate2ResourceInstancesResponse.getErrorCode() == ResourceRestUtils.STATUS_CODE_SUCCESS) {
 585
 586                         switch (containerDetails.getComponentType()) {
 587                                 case RESOURCE:
 588                                         containerDetails = ResponseParser.convertResourceResponseToJavaObject(associate2ResourceInstancesResponse.getResponse());
 589                                         break;
 590                                 case SERVICE:
 591                                         containerDetails = ResponseParser.convertServiceResponseToJavaObject(associate2ResourceInstancesResponse.getResponse());
 592                                         break;
 593                                 case PRODUCT:
 594                                         containerDetails = ResponseParser.convertProductResponseToJavaObject(associate2ResourceInstancesResponse.getResponse());
 595                                         break;
 596                                 default:
 597                                         break;
 598                         }
 599
 600                         return Either.left(containerDetails);
 601                 }
 602                 return Either.right(associate2ResourceInstancesResponse);
 603
 604         }
 605
 606         public static Either<Pair<Component, ComponentInstance>, RestResponse> updateComponentInstance(ComponentInstanceReqDetails componentInstanceReqDetails, User sdncModifierDetails, Component container, boolean validateState) throws Exception {
 607
 608                 RestResponse updateComponentInstance = ComponentInstanceRestUtils.updateComponentInstance(componentInstanceReqDetails, sdncModifierDetails, container.getUniqueId(), container.getComponentType());
 609                 if (validateState) {
 610                         assertTrue("Update ComponentInstance failed: " + updateComponentInstance.getResponseMessage(), updateComponentInstance.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 611                 }
 612                 if (updateComponentInstance.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS) {
 613                         String componentType = container.getComponentType().getValue();
 614                         Component componentObject;
 615                         if(componentType.equals("Resource")){
 616                                 componentObject = getResourceObject(container.getUniqueId());
 617                         }else{
 618                                 componentObject = getServiceObject(container.getUniqueId());
 619                         }
 620                         ComponentInstance componentInstanceJavaObject = ResponseParser.convertComponentInstanceResponseToJavaObject(updateComponentInstance.getResponse());
 621                         return Either.left(Pair.of(componentObject, componentInstanceJavaObject));
 622                 }
 623                 return Either.right(updateComponentInstance);
 624         }
 625
 626         public static Either<Pair<Component, ComponentInstance>, RestResponse> changeComponentInstanceVersion(Component containerDetails, ComponentInstance componentInstanceToReplace, Component newInstance, UserRoleEnum userRole, Boolean validateState)
 627                         throws Exception {
 628                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 629
 630                 RestResponse changeComponentInstanceVersionResp = ComponentInstanceRestUtils.changeComponentInstanceVersion(containerDetails, componentInstanceToReplace, newInstance, defaultUser);
 631                 if (validateState) {
 632                         assertTrue("change ComponentInstance version failed: " + changeComponentInstanceVersionResp.getResponseMessage(), changeComponentInstanceVersionResp.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 633                 }
 634
 635                 if (changeComponentInstanceVersionResp.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS) {
 636
 637                         Component compoenntObject = AtomicOperationUtils.getComponentObject(containerDetails, userRole);
 638                         ComponentInstance componentInstanceJavaObject = ResponseParser.convertComponentInstanceResponseToJavaObject(changeComponentInstanceVersionResp.getResponse());
 639
 640                         return Either.left(Pair.of(compoenntObject, componentInstanceJavaObject));
 641                 }
 642
 643                 return Either.right(changeComponentInstanceVersionResp);
 644         }
 645
 646         public static ComponentInstance getComponentInstanceByName(Component component, String name) {
 647                 ComponentInstance componentInstance = component.getComponentInstances()
 648                                 .stream()
 649                                 .filter(ci->ci.getName().equals(name))
 650                                 .findFirst()
 651                                 .orElse(null);
 652                 if (componentInstance == null) {
 653                         List<String> componentInstancesNameList = component.getComponentInstances().stream().map(ComponentInstance::getName).collect(Collectors.toList());
 654                         assertFalse("Instance name " + name + " not found in container " + component.getComponentType() + " named [" + component.getName()
 655                                         + "]. Component instances available are: " + componentInstancesNameList.toString(),  true);
 656                 }
 657                 return componentInstance;
 658         }
 659
 660         // *********** PROPERTIES *****************
 661
 662         public static Either<ComponentInstanceProperty, RestResponse> addCustomPropertyToResource(PropertyReqDetails propDetails, Resource resourceDetails, UserRoleEnum userRole, Boolean validateState) throws Exception {
 663
 664                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 665                 Map<String, PropertyReqDetails> propertyToSend = new HashMap<>();
 666                 propertyToSend.put(propDetails.getName(), propDetails);
 667                 Gson gson = new Gson();
 668                 RestResponse addPropertyResponse = PropertyRestUtils.createProperty(resourceDetails.getUniqueId(), gson.toJson(propertyToSend), defaultUser);
 669
 670                 if (validateState) {
 671                         assertTrue("add property to resource failed: " + addPropertyResponse.getErrorCode(), addPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_CREATED);
 672                 }
 673
 674                 if (addPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_CREATED) {
 675                         ComponentInstanceProperty compInstProp = null;
 676                         String property = ResponseParser.getJsonObjectValueByKey(addPropertyResponse.getResponse(), propDetails.getName());
 677                         compInstProp = (ResponseParser.convertPropertyResponseToJavaObject(property));
 678                         return Either.left(compInstProp);
 679                 }
 680                 return Either.right(addPropertyResponse);
 681         }
 682
 683         // Benny
 684         public static Either<ComponentInstanceProperty, RestResponse> updatePropertyOfResource(PropertyReqDetails propDetails, Resource resourceDetails, String propertyUniqueId, UserRoleEnum userRole, Boolean validateState) throws Exception {
 685
 686                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 687                 Map<String, PropertyReqDetails> propertyToSend = new HashMap<>();
 688                 propertyToSend.put(propDetails.getName(), propDetails);
 689                 Gson gson = new Gson();
 690                 RestResponse addPropertyResponse = PropertyRestUtils.updateProperty(resourceDetails.getUniqueId(), propertyUniqueId, gson.toJson(propertyToSend), defaultUser);
 691
 692                 if (validateState) {
 693                         assertTrue("add property to resource failed: " + addPropertyResponse.getResponseMessage(), addPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 694                 }
 695
 696                 if (addPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS) {
 697                         ComponentInstanceProperty compInstProp = null;
 698                         String property = ResponseParser.getJsonObjectValueByKey(addPropertyResponse.getResponse(), propDetails.getName());
 699                         compInstProp = (ResponseParser.convertPropertyResponseToJavaObject(property));
 700                         return Either.left(compInstProp);
 701                 }
 702                 return Either.right(addPropertyResponse);
 703         }
 704
 705         public static RestResponse deletePropertyOfResource(String resourceId, String propertyId, UserRoleEnum userRole) throws Exception {
 706                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 707                 return PropertyRestUtils.deleteProperty(resourceId, propertyId, defaultUser);
 708         }
 709
 710         public static Either<ComponentInstanceProperty, RestResponse> addDefaultPropertyToResource(PropertyTypeEnum propertyType, Resource resourceDetails, UserRoleEnum userRole, Boolean validateState) throws Exception {
 711
 712                 User defaultUser = ElementFactory.getDefaultUser(userRole);
 713                 PropertyReqDetails propDetails = ElementFactory.getPropertyDetails(propertyType);
 714                 Map<String, PropertyReqDetails> propertyToSend = new HashMap<>();
 715                 propertyToSend.put(propDetails.getName(), propDetails);
 716                 Gson gson = new Gson();
 717                 RestResponse addPropertyResponse = PropertyRestUtils.createProperty(resourceDetails.getUniqueId(), gson.toJson(propertyToSend), defaultUser);
 718
 719                 if (validateState) {
 720                         assertTrue("add property to resource failed: " + addPropertyResponse.getResponseMessage(), addPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_CREATED);
 721                 }
 722
 723                 if (addPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_CREATED) {
 724                         ComponentInstanceProperty compInstProp = null;
 725                         String property = ResponseParser.getJsonObjectValueByKey(addPropertyResponse.getResponse(), propDetails.getName());
 726                         compInstProp = (ResponseParser.convertPropertyResponseToJavaObject(property));
 727
 728                         return Either.left(compInstProp);
 729                 }
 730                 return Either.right(addPropertyResponse);
 731         }
 732
 733         public static Either<GroupDefinition, RestResponse> updateGroupPropertyOnResource(String maxVFModuleInstacesValue, Resource resource, String groupId, User user, Boolean validateState) throws Exception {
 734
 735 //              Gson gson = new Gson();
 736         // Json group property object
 737         String propertyObjectJson = "[{\"defaultValue\":null,\"description\":\"The maximum instances of this VF-Module\",\"name\":\"max_vf_module_instances\",\"parentUniqueId\":\"org.openecomp.groups.VfModule.1.0.grouptype.max_vf_module_instances\",\"password\":false,\"required\":false,\"schema\":{\"property\":{}},\"type\":\"integer\",\"uniqueId\":\"org.openecomp.groups.VfModule.1.0.grouptype.max_vf_module_instances.property.3\",\"value\":\"" + maxVFModuleInstacesValue + "\",\"definition\":false,\"getInputValues\":null,\"constraints\":null,\"valueUniqueUid\":null,\"ownerId\":\"org.openecomp.groups.VfModule.1.0.grouptype.max_vf_module_instances\"}]";
 738 //        GroupProperty property = gson.fromJson(propertyObjectJson, GroupProperty.class);
 739                 RestResponse updateGroupPropertyResponse = PropertyRestUtils.updateGroupProperty(resource, groupId, propertyObjectJson, user);
 740
 741                 if (validateState) {
 742                         assertTrue("update group property to resource failed: " + updateGroupPropertyResponse.getResponseMessage(), updateGroupPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS);
 743                 }
 744
 745                 if (updateGroupPropertyResponse.getErrorCode() == BaseRestUtils.STATUS_CODE_SUCCESS) {
 746                         GroupDefinition responseGroupDefinition = ResponseParser.convertPropertyResponseToObject(updateGroupPropertyResponse.getResponse());
 747                         return Either.left(responseGroupDefinition);
 748                 }
 749                 return Either.right(updateGroupPropertyResponse);
 750         }
 751
 752
 753         public static RestResponse createDefaultConsumer(Boolean validateState) {
 754                 try {
 755                         ConsumerDataDefinition defaultConsumerDefinition = ElementFactory.getDefaultConsumerDetails();
 756                         RestResponse createResponse = ConsumerRestUtils.createConsumer(defaultConsumerDefinition, ElementFactory.getDefaultUser(UserRoleEnum.ADMIN));
 757                         BaseRestUtils.checkCreateResponse(createResponse);
 758
 759                         if (validateState) {
 760                                 assertTrue(createResponse.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 761                         }
 762                         return createResponse;
 763                 } catch (Exception e) {
 764                         throw new AtomicOperationException(e);
 765                 }
 766         }
 767
 768         /**
 769          * Builds Resource From rest response
 770          *
 771          * @param resourceResp
 772          * @return
 773          */
 774         public static Either<Resource, RestResponse> buildResourceFromResponse(RestResponse resourceResp) {
 775                 Either<Resource, RestResponse> result;
 776                 if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 777                         Resource resourceResponseObject = ResponseParser.convertResourceResponseToJavaObject(resourceResp.getResponse());
 778                         result = Either.left(resourceResponseObject);
 779                 } else {
 780                         result = Either.right(resourceResp);
 781                 }
 782                 return result;
 783         }
 784
 785         private static class AtomicOperationException extends RuntimeException {
 786                 private AtomicOperationException(Exception e) {
 787                         super(e);
 788                 }
 789
 790                 private static final long serialVersionUID = 1L;
 791         }
 792
 793         /**
 794          * Import resource from CSAR
 795          *
 796          * @param resourceType
 797          * @param userRole
 798          * @param fileName
 799          * @param filePath
 800          * @return Resource
 801          * @throws Exception
 802          */
 803         public static Resource importResourceFromCsar(ResourceTypeEnum resourceType, UserRoleEnum userRole, String fileName, String... filePath) throws Exception {
 804                 // Get the CSARs path
 805                 String realFilePath = System.getProperty("user.dir") + File.separator + "src" + File.separator + "test" + File.separator + "resources" + File.separator + "CI" + File.separator + "csars" ;
 806                 if (filePath != null && filePath.length > 0) {
 807                         StringBuilder result = new StringBuilder();
 808                         for(String currStr: filePath){
 809                                 result.append(currStr);
 810                         }
 811 //                      realFilePath = Arrays.toString(filePath);
 812                         realFilePath = result.toString();
 813                 }
 814
 815                 // Create default import resource & user
 816                 return importResourceFromCsarFile(resourceType, userRole, fileName, realFilePath);
 817         }
 818
 819         public static Resource importResourceFromCsarFile(ResourceTypeEnum resourceType, UserRoleEnum userRole, String csarFileName, String csarFilePath) throws Exception{
 820                 RestResponse createResource = getCreateResourceRestResponse(resourceType, userRole, csarFileName, csarFilePath);
 821                 BaseRestUtils.checkCreateResponse(createResource);
 822                 return ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 823         }
 824
 825         public static Resource importCertifiedResourceFromCsar(ResourceTypeEnum resourceType, UserRoleEnum userRole,    String csarFileName, String csarFilePath) throws Exception{
 826                 RestResponse createResource = getCreateCertifiedResourceRestResponse(resourceType, userRole, csarFileName, csarFilePath);
 827                 BaseRestUtils.checkSuccess(createResource);
 828                 return ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 829         }
 830         public static RestResponse getCreateResourceRestResponse(ResourceTypeEnum resourceType, UserRoleEnum userRole,
 831                                                                                                                          String csarFileName, String csarFilePath) throws IOException, Exception {
 832
 833                 ImportReqDetails resourceDetails = buildImportReqDetails(resourceType, csarFileName, csarFilePath);
 834                 User sdncModifierDetails = ElementFactory.getDefaultUser(userRole);
 835                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 836                 return createResource;
 837         }
 838
 839         public static RestResponse getCreateCertifiedResourceRestResponse(ResourceTypeEnum resourceType, UserRoleEnum userRole,
 840                                                                                                                                                    String csarFileName, String csarFilePath) throws IOException, Exception {
 841
 842                 ImportReqDetails resourceDetails = buildImportReqDetails(resourceType, csarFileName, csarFilePath);
 843                 User sdncModifierDetails = ElementFactory.getDefaultUser(userRole);
 844                 RestResponse response = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 845                 BaseRestUtils.checkCreateResponse(response);
 846                 return LCSbaseTest.certifyResource(resourceDetails, sdncModifierDetails);
 847         }
 848
 849         private static ImportReqDetails buildImportReqDetails(ResourceTypeEnum resourceType, String csarFileName, String csarFilePath) throws IOException {
 850                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 851                 Path path = Paths.get(csarFilePath + File.separator + csarFileName);
 852                 byte[] data = Files.readAllBytes(path);
 853                 String payloadName = csarFileName;
 854                 String payloadData = Base64.encodeBase64String(data);
 855                 resourceDetails.setPayloadData(payloadData);
 856                 resourceDetails.setCsarUUID(payloadName);
 857                 resourceDetails.setPayloadName(payloadName);
 858                 resourceDetails.setResourceType(resourceType.name());
 859                 return resourceDetails;
 860         }
 861
 862         public static Resource updateResourceFromCsar(Resource resource, UserRoleEnum userRole, String csarFileName, String csarFilePath) throws Exception{
 863                 User sdncModifierDetails = ElementFactory.getDefaultUser(userRole);
 864
 865                 byte[] data = null;
 866                 Path path = Paths.get(csarFilePath + File.separator + csarFileName);
 867                 data = Files.readAllBytes(path);
 868                 String payloadName = csarFileName;
 869                 String payloadData = Base64.encodeBase64String(data);
 870                 ImportReqDetails resourceDetails = new ImportReqDetails(resource, payloadName, payloadData);
 871                 resourceDetails.setPayloadData(payloadData);
 872                 resourceDetails.setCsarUUID(payloadName);
 873                 resourceDetails.setPayloadName(payloadName);
 874
 875                 String userId = sdncModifierDetails.getUserId();
 876                 Config config = Utils.getConfig();
 877                 String url = String.format(Urls.UPDATE_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resource.getUniqueId());
 878
 879                 Map<String, String> headersMap = ResourceRestUtils.prepareHeadersMap(userId);
 880
 881                 Gson gson = new Gson();
 882                 String userBodyJson = gson.toJson(resourceDetails);
 883                 String calculateMD5 = GeneralUtility.calculateMD5Base64EncodedByString(userBodyJson);
 884                 headersMap.put(HttpHeaderEnum.Content_MD5.getValue(), calculateMD5);
 885                 HttpRequest http = new HttpRequest();
 886                 RestResponse updateResourceResponse = http.httpSendPut(url, userBodyJson, headersMap);
 887                 BaseRestUtils.checkSuccess(updateResourceResponse);
 888                 return ResponseParser.parseToObjectUsingMapper(updateResourceResponse.getResponse(), Resource.class);
 889         }
 890
 891         public static Either<Resource, RestResponse> importResourceByFileName(ResourceTypeEnum resourceType, UserRoleEnum userRole, String fileName, Boolean validateState, String... filePath) throws IOException {
 892
 893                 String realFilePath = System.getProperty("user.dir") + File.separator + "src" + File.separator + "test" + File.separator + "resources" + File.separator + "CI" + File.separator + "csars" ;
 894                 if (filePath != null && filePath.length > 0) {
 895                         realFilePath = filePath.toString();
 896                 }
 897
 898                 try {
 899                         User defaultUser = ElementFactory.getDefaultUser(userRole);
 900                         ResourceReqDetails defaultResource = ElementFactory.getDefaultResource(defaultUser);
 901                         ImportReqDetails defaultImportResource = ElementFactory.getDefaultImportResource(defaultResource);
 902                         ImportUtils.getImportResourceDetailsByPathAndName(defaultImportResource, realFilePath, fileName);
 903                         RestResponse resourceResp = ResourceRestUtils.createResource(defaultImportResource, defaultUser);
 904
 905                         if (validateState) {
 906                                 assertTrue(resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED);
 907                         }
 908
 909                         if (resourceResp.getErrorCode() == ResourceRestUtils.STATUS_CODE_CREATED) {
 910                                 Resource resourceResponseObject = ResponseParser.convertResourceResponseToJavaObject(resourceResp.getResponse());
 911                                 return Either.left(resourceResponseObject);
 912                         }
 913                         return Either.right(resourceResp);
 914                 } catch (Exception e) {
 915                         throw new AtomicOperationException(e);
 916                 }
 917         }
 918
 919         public static Either<String, RestResponse> getComponenetArtifactPayload(Component component, String artifactType) throws Exception {
 920
 921                 String url;
 922                 Config config = Utils.getConfig();
 923                 if(component.getComponentType().toString().toUpperCase().equals(ComponentTypeEnum.SERVICE.getValue().toUpperCase())){
 924                         url = String.format(Urls.UI_DOWNLOAD_SERVICE_ARTIFACT, config.getCatalogBeHost(), config.getCatalogBePort(), component.getUniqueId(), component.getToscaArtifacts().get(artifactType).getUniqueId());
 925                 }else{
 926                         url = String.format(Urls.UI_DOWNLOAD_RESOURCE_ARTIFACT, config.getCatalogBeHost(), config.getCatalogBePort(), component.getUniqueId(), component.getToscaArtifacts().get(artifactType).getUniqueId());
 927                 }
 928                 String userId = component.getLastUpdaterUserId();
 929                 Map<String, String> headersMap = new HashMap<>();
 930                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), BaseRestUtils.contentTypeHeaderData);
 931                 headersMap.put(HttpHeaderEnum.CACHE_CONTROL.getValue(), BaseRestUtils.cacheControlHeader);
 932                 headersMap.put(HttpHeaderEnum.AUTHORIZATION.getValue(), basicAuthentication);
 933                 headersMap.put(HttpHeaderEnum.X_ECOMP_INSTANCE_ID.getValue(), BaseRestUtils.xEcompInstanceId);
 934                 if (userId != null) {
 935                         headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId);
 936                 }
 937                 HttpRequest http = new HttpRequest();
 938                 RestResponse response = http.httpSendGet(url, headersMap);
 939                 if (response.getErrorCode() != BaseRestUtils.STATUS_CODE_SUCCESS && response.getResponse().getBytes() == null && response.getResponse().getBytes().length == 0) {
 940                         return Either.right(response);
 941                 }
 942                 return Either.left(response.getResponse());
 943
 944         }
 945
 946         public static RestResponse getDistributionStatusByDistributionId(String distributionId, Boolean validateState) {
 947
 948                 try {
 949                         User defaultUser = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
 950                         RestResponse response = DistributionUtils.getDistributionStatus(defaultUser, distributionId);
 951
 952                         if (validateState) {
 953                                 assertTrue(response.getErrorCode() == ResourceRestUtils.STATUS_CODE_SUCCESS);
 954                         }
 955                         return response;
 956
 957                 } catch (Exception e) {
 958                         throw new AtomicOperationException(e);
 959                 }
 960         }
 961
 962         public static Either <RestResponse, Map<String, List<DistributionMonitorObject>>> getSortedDistributionStatusMap(Service service, Boolean validateState) {
 963
 964                 try {
 965                         ServiceDistributionStatus serviceDistributionObject = DistributionUtils.getLatestServiceDistributionObject(service);
 966                         RestResponse response = getDistributionStatusByDistributionId(serviceDistributionObject.getDistributionID(), true);
 967                         if(validateState) {
 968                                 assertTrue(response.getErrorCode() == ResourceRestUtils.STATUS_CODE_SUCCESS);
 969                         }
 970                         if(response.getErrorCode() == ResourceRestUtils.STATUS_CODE_SUCCESS){
 971                                 Map<String, List<DistributionMonitorObject>> parsedDistributionStatus = DistributionUtils.getSortedDistributionStatus(response);
 972                                 return Either.right(parsedDistributionStatus);
 973                         }
 974                         return Either.left(response);
 975                 } catch (Exception e) {
 976                         throw new AtomicOperationException(e);
 977                 }
 978
 979         }
 980
 981
 982         /**
 983          * @param service
 984          * @param pollingCount
 985          * @param pollingInterval
 986          * Recommended values for service distribution for pollingCount is 4 and for pollingInterval is 15000ms
 987          * @throws Exception
 988          */
 989         public static Boolean distributeAndValidateService(Service service, int pollingCount, int pollingInterval) throws Exception {
 990                 int firstPollingInterval = 30000; //this value define first be polling topic time, should change if DC configuration changed
 991                 Boolean statusFlag = true;
 992                 AtomicOperationUtils.distributeService(service,  true);
 993                 TimeUnit.MILLISECONDS.sleep(firstPollingInterval);
 994                 int timeOut = pollingCount * pollingInterval;
 995                 com.clearspring.analytics.util.Pair<Boolean,Map<String,List<String>>> verifyDistributionStatus = null;
 996
 997                 while (timeOut > 0) {
 998                         Map<String,List<DistributionMonitorObject>> sortedDistributionStatusMap = AtomicOperationUtils.getSortedDistributionStatusMap(service, true).right().value();
 999                         verifyDistributionStatus = DistributionUtils.verifyDistributionStatus(sortedDistributionStatusMap);
1000                         if(verifyDistributionStatus.left.equals(false)){
1001                                 TimeUnit.MILLISECONDS.sleep(pollingInterval);
1002                                 timeOut-=pollingInterval;
1003                         }else {
1004                                 timeOut = 0;
1005                         }
1006                 }
1007
1008                 if((verifyDistributionStatus.right != null && ! verifyDistributionStatus.right.isEmpty())){
1009                         for(Entry<String, List<String>> entry : verifyDistributionStatus.right.entrySet()){
1010                                 if(ComponentBaseTest.getExtendTest() != null){
1011                                         ComponentBaseTest.getExtendTest().log(Status.INFO, "Consumer: " + entry.getKey() + " failed on following: "+ entry.getValue());
1012                                 }else{
1013                                         System.out.println("Consumer: [" + entry.getKey() + "] failed on following: "+ entry.getValue());
1014                                 }
1015                         }
1016                         statusFlag = false;
1017                 }
1018                 return statusFlag;
1019         }
1020
1021         public static Boolean distributeAndValidateService(Service service) throws Exception {
1022                 return distributeAndValidateService(service, 10, 10000);
1023         }
1024
1025           /**
1026      * @param resource to download csar file via API
1027      * @return Tosca definition object from main yaml file
1028      */
1029     public static ToscaDefinition downloadAndGetToscaMainYamlObjectApi(Resource resource, File filesFolder) throws Exception {
1030         File vfCsarFileName = new File(File.separator + "VfCsar_" + ElementFactory.generateUUIDforSufix() + ".csar");
1031         OnboardingUtillViaApis.downloadToscaCsarToDirectory(resource, new File(filesFolder.getPath() + vfCsarFileName));
1032         return ToscaParserUtils.parseToscaMainYamlToJavaObjectByCsarLocation(new File(filesFolder.getPath() + vfCsarFileName));
1033     }
1034
1035
1036     public static ComponentInstance getServiceComponentInstanceByName(Service service, String name, Boolean validateState){
1037         List<ComponentInstance> compInstances = service.getComponentInstances();
1038         for (ComponentInstance instance: compInstances){
1039             String compName = instance.getName();
1040             if (compName.equals(name))
1041                 return instance;
1042         }
1043         if (validateState) {
1044             assertEquals("Component instance name " + name + " not found", name, null);
1045         }
1046         return null;
1047     }
1048
1049         public static Pair<Component, ComponentInstance> updateComponentInstanceName(String newName, Component component, String canvasElementName, User user, Boolean validateState) throws Exception {
1050                 ComponentInstanceReqDetails componentInstanceReqDetails = ElementFactory.getDefaultComponentInstance();
1051                 ComponentInstance componentInstanceByName = AtomicOperationUtils.getComponentInstanceByName(component, canvasElementName);
1052                 componentInstanceReqDetails.setName(newName);
1053                 componentInstanceReqDetails.setComponentUid(componentInstanceByName.getComponentUid());
1054                 componentInstanceReqDetails.setUniqueId(componentInstanceByName.getUniqueId());
1055                 return AtomicOperationUtils.updateComponentInstance(componentInstanceReqDetails, user, component, validateState).left().value();
1056         }
1057
1058 }