catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ServiceImportBusinessLogicTest.java

   1 /*
   2
   3  * Copyright (c) 2018 AT&T Intellectual Property.
   4
   5  *
   6
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8
   9  * you may not use this file except in compliance with the License.
  10
  11  * You may obtain a copy of the License at
  12
  13  *
  14
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16
  17  *
  18
  19  * Unless required by applicable law or agreed to in writing, software
  20
  21  * distributed under the License is distributed on an "AS IS" BASIS,
  22
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24
  25  * See the License for the specific language governing permissions and
  26
  27  * limitations under the License.
  28
  29  */
  30
  31 package org.openecomp.sdc.be.components.impl;
  32
  33
  34 import fj.data.Either;
  35 import io.cucumber.java.hu.Ha;
  36 import org.apache.commons.codec.binary.Base64;
  37 import org.apache.commons.collections.map.HashedMap;
  38 import org.apache.commons.lang3.tuple.ImmutablePair;
  39 import org.junit.Before;
  40 import org.junit.Test;
  41 import org.mockito.InjectMocks;
  42 import org.mockito.Mock;
  43 import org.mockito.Mockito;
  44 import org.mockito.MockitoAnnotations;
  45 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  46 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
  47 import org.openecomp.sdc.be.components.csar.CsarInfo;
  48 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
  49 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  50 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
  51 import org.openecomp.sdc.be.dao.api.ActionStatus;
  52 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  53 import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  55 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
  56 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  57 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  58 import org.openecomp.sdc.be.externalapi.servlet.ArtifactExternalServlet;
  59 import org.openecomp.sdc.be.impl.ComponentsUtils;
  60 import org.openecomp.sdc.be.impl.ServletUtils;
  61 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
  62 import org.openecomp.sdc.be.model.*;
  63 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  64 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  65 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  66 import org.openecomp.sdc.be.servlets.AbstractValidationsServlet;
  67 import org.openecomp.sdc.be.tosca.CsarUtils;
  68 import org.openecomp.sdc.be.user.UserBusinessLogic;
  69 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  70 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  71 import org.openecomp.sdc.common.api.Constants;
  72 import org.openecomp.sdc.exception.ResponseFormat;
  73
  74 import java.io.IOException;
  75 import java.lang.reflect.InvocationTargetException;
  76 import java.lang.reflect.Method;
  77 import java.nio.file.FileSystems;
  78 import java.nio.file.Files;
  79 import java.nio.file.Path;
  80 import java.nio.file.Paths;
  81 import java.util.*;
  82
  83 import static org.assertj.core.api.Java6Assertions.assertThat;
  84 import static org.junit.Assert.*;
  85 import static org.mockito.Mockito.*;
  86
  87 public class ServiceImportBusinessLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
  88     private final static String DEFAULT_ICON = "defaulticon";
  89
  90     @InjectMocks
  91     static ServiceImportBusinessLogic serviceImportBusinessLogic;
  92     @Mock
  93     private ServiceBusinessLogic serviceBusinessLogic;
  94     @Mock
  95     private CsarBusinessLogic csarBusinessLogic;
  96     @Mock
  97     private ToscaOperationFacade toscaOperationFacade;
  98     @Mock
  99     private ServiceImportParseLogic serviceImportParseLogic;
 100     @Mock
 101     ArtifactDefinition artifactDefinition =new ArtifactDefinition();
 102
 103     private static UserBusinessLogic userBusinessLogic = Mockito.mock(UserBusinessLogic.class);
 104     private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class);
 105     private static ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 106     private static ServletUtils servletUtils = mock(ServletUtils.class);
 107     private static ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
 108     private static ArtifactsBusinessLogic artifactsBusinessLogic = mock(ArtifactsBusinessLogic.class);
 109
 110     private static AbstractValidationsServlet servlet = new ArtifactExternalServlet(userBusinessLogic,
 111             componentInstanceBusinessLogic, componentsUtils, servletUtils, resourceImportManager, artifactsBusinessLogic);
 112
 113     @Before
 114     public void initMocks() {
 115         MockitoAnnotations.initMocks(this);
 116         when(artifactDefinition.getMandatory()).thenReturn(true);
 117         when(artifactDefinition.getArtifactName()).thenReturn("creatorFullName");
 118         when(artifactDefinition.getArtifactType()).thenReturn("TOSCA_CSAR");
 119
 120         sIB1.setServiceBusinessLogic(serviceBusinessLogic);
 121         sIB1.setCsarBusinessLogic(csarBusinessLogic);
 122         sIB1.setServiceImportParseLogic(serviceImportParseLogic);
 123         sIB1.setToscaOperationFacade(toscaOperationFacade);
 124         sIB1.setComponentsUtils(componentsUtils);
 125         sIB1.setCsarArtifactsAndGroupsBusinessLogic(csarArtifactsAndGroupsBusinessLogic);
 126
 127     }
 128
 129     @Test
 130     public void testGetComponentsUtils() {
 131         ComponentsUtils result;
 132         result = serviceImportBusinessLogic.getComponentsUtils();
 133     }
 134
 135     @Test
 136     public void testSetComponentsUtils() {
 137         ComponentsUtils componentsUtils = null;
 138
 139         serviceImportBusinessLogic.setComponentsUtils(componentsUtils);
 140     }
 141
 142     @Test
 143     public void testCreateService() {
 144         Service oldService = createServiceObject(false);
 145         String payloadName = "valid_vf";
 146         Map<String, byte[]> payload = crateCsarFromPayload();
 147         Service newService = createServiceObject(true);
 148         try {
 149             when(serviceBusinessLogic.validateServiceBeforeCreate(newService,user,AuditingActionEnum.CREATE_RESOURCE))
 150                     .thenReturn(Either.left(newService));
 151             when(toscaOperationFacade.validateCsarUuidUniqueness(payloadName)).thenReturn(StorageOperationStatus.OK);
 152             sIB1.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
 153         } catch (Exception e) {
 154             e.printStackTrace();
 155         }
 156     }
 157
 158     @Test
 159     public void testCreateServiceFromCsar(){
 160         Service oldService = createServiceObject(false);
 161         String csarUUID = "valid_vf";
 162         Map<String, byte[]> payload = crateCsarFromPayload();
 163         try {
 164             sIB1.createServiceFromCsar(oldService, user, payload, csarUUID);
 165         }catch (Exception e) {
 166             e.printStackTrace();
 167         }
 168     }
 169
 170     @Test
 171     public void testCreateServiceFromYaml(){
 172         Service oldService = createServiceObject(false);
 173         String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
 174         String yamlName = "group.yml";
 175         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
 176         CsarInfo csarInfo =getCsarInfo();
 177         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 178         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 179         try {
 180             sIB1.createServiceFromYaml(oldService,topologyTemplateYaml,yamlName,nodeTypesInfo,
 181                     csarInfo,nodeTypesArtifactsToCreate,true,true,nodeName);
 182         }catch (Exception e){
 183             e.printStackTrace();
 184         }
 185     }
 186
 187     @Test
 188     public void testCreateServiceAndRIsFromYaml(){
 189         Service oldService = createServiceObject(false);
 190         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 191         CreateServiceFromYamlParameter csfyp = getCsfyp();
 192         try {
 193             sIB1.createServiceAndRIsFromYaml(oldService,false,
 194                     nodeTypesArtifactsToCreate,true,true,csfyp);
 195         }catch (Exception e){
 196             e.printStackTrace();
 197         }
 198     }
 199
 200     @Test
 201     public void testCreateServiceAndRIsFromYamlShoudLook(){
 202         Service oldService = createServiceObject(false);
 203         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 204         CreateServiceFromYamlParameter csfyp = getCsfyp();
 205         try {
 206             sIB1.createServiceAndRIsFromYaml(oldService,false,
 207                     nodeTypesArtifactsToCreate,false,true,csfyp);
 208         }catch (Exception e){
 209             e.printStackTrace();
 210         }
 211     }
 212
 213     @Test
 214     public void testCreateOrUpdateArtifacts(){
 215         ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
 216         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 217         String yamlFileName = "group.yml";
 218         CsarInfo csarInfo =getCsarInfo();
 219         Resource preparedResource = createParseResourceObject(false);
 220         preparedResource.setResourceType(ResourceTypeEnum.VF);
 221         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 222         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle= new HashMap<>();
 223         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
 224                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 225         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
 226         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 227         artifactDefinition.setArtifactName("artifactName");
 228         artifactDefinitions.add(artifactDefinition);
 229         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
 230                 artifactDefinitions);
 231         nodeTypesArtifactsToHandle.put(nodeName,enumListEnumMap);
 232         NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,nodeTypesArtifactsToHandle);
 233         nodeTypeInfoToUpdateArtifacts.setNodeName(nodeName);
 234         nodeTypeInfoToUpdateArtifacts.setNodeTypesArtifactsToHandle(nodeTypesArtifactsToHandle);
 235
 236         try {
 237             sIB1.createOrUpdateArtifacts(operation,createdArtifacts,yamlFileName,csarInfo,
 238                     preparedResource,nodeTypeInfoToUpdateArtifacts,true,true);
 239         }catch (Exception e){
 240             e.printStackTrace();
 241         }
 242     }
 243
 244     @Test
 245     public void testHandleVfCsarArtifacts(){
 246         Resource resource = createParseResourceObject(false);
 247         CsarInfo csarInfo = getCsarInfo();
 248         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 249         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 250         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 251
 252         try {
 253             sIB1.handleVfCsarArtifacts(resource,csarInfo,createdArtifacts,artifactOperation,true,true);
 254         } catch (Exception e) {
 255             e.printStackTrace();
 256         }
 257     }
 258
 259     @Test
 260     public void testHandleVfCsarArtifactsGetToscaElement() {
 261         Resource resource = createParseResourceObject(false);
 262         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 263         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 264         artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
 265         artifactDefinition.setUniqueId("uniqueId");
 266         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 267         resource.setDeploymentArtifacts(deploymentArtifacts);
 268         CsarInfo csarInfo = getCsarInfo();
 269         Map<String, byte[]> csar = new HashMap<>();
 270         String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
 271         byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
 272         csar.put(csarKey,artifactsMetaBytes);
 273         csarInfo.setCsar(csar);
 274         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 275         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 276         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
 277
 278         try {
 279             sIB1.handleVfCsarArtifacts(resource,csarInfo,createdArtifacts,artifactOperation,true,true);
 280         } catch (Exception e) {
 281             e.printStackTrace();
 282         }
 283     }
 284
 285     @Test
 286     public void testCreateOrUpdateSingleNonMetaArtifactToComstants(){
 287         Resource resource = createParseResourceObject(false);
 288         CsarInfo csarInfo = getCsarInfo();
 289         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 290         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 291         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 292         artifactDefinition.setArtifactName("artifactDefinition");
 293         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 294         resource.setDeploymentArtifacts(deploymentArtifacts);
 295         try {
 296             sIB1.createOrUpdateSingleNonMetaArtifactToComstants(resource,csarInfo,artifactOperation,true,true);
 297         }catch (Exception e) {
 298             e.printStackTrace();
 299         }
 300     }
 301
 302
 303     @Test
 304     public void testCreateOrUpdateNonMetaArtifacts(){
 305         CsarInfo csarInfo = getCsarInfo();
 306         Resource resource = createParseResourceObject(false);
 307         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 308         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 309
 310         Either<Resource, ResponseFormat> result = sIB1.createOrUpdateNonMetaArtifacts(csarInfo, resource,
 311                 createdArtifacts, true, true, artifactOperation);
 312         assertEquals(result.left().value(),resource);
 313     }
 314
 315     @Test
 316     public void testFindVfCsarArtifactsToHandle(){
 317         Resource resource = createParseResourceObject(false);
 318         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 319         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 320         artifactDefinition.setArtifactName("artifactDefinition");
 321         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 322         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 323         artifacts.put("artifacts",artifactDefinition);
 324         List<GroupDefinition> groups = new ArrayList<>();
 325         GroupDefinition groupDefinition = new GroupDefinition();
 326         groupDefinition.setUniqueId("groupDefinitionUniqueId");
 327         groupDefinition.setName("groupDefinition");
 328         groups.add(groupDefinition);
 329         resource.setDeploymentArtifacts(deploymentArtifacts);
 330         resource.setArtifacts(artifacts);
 331         resource.setGroups(groups);
 332         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 333
 334         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
 335                 ResponseFormat> result = sIB1.findVfCsarArtifactsToHandle(resource,artifactPathAndNameList,user);
 336         assertNotNull(result.left().value());
 337     }
 338
 339
 340     @Test
 341     public void testIsNonMetaArtifact() {
 342         ArtifactDefinition artifactDefinition =new ArtifactDefinition();
 343         artifactDefinition.setMandatory(false);
 344         artifactDefinition.setArtifactName("creatorFullName");
 345         artifactDefinition.setArtifactType("TOSCA_CSAR");
 346
 347         boolean nonMetaArtifact = sIB1.isNonMetaArtifact(artifactDefinition);
 348         assertTrue(nonMetaArtifact);
 349
 350     }
 351
 352     @Test
 353     public void testOrganizeVfCsarArtifactsByArtifactOperation(){
 354         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 355         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 356         List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
 357         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 358         artifactDefinition.setArtifactName("artifactName");
 359         artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
 360         artifactDefinition.setArtifactChecksum("artifactChecksum");
 361         existingArtifactsToHandle.add(artifactDefinition);
 362         Resource resource = createParseResourceObject(false);
 363
 364         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
 365                 enumMapResponseFormatEither = sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource, user);
 366         assertNotNull(enumMapResponseFormatEither.left().value());
 367     }
 368
 369     @Test
 370     public void testOrganizeVfCsarArtifactsByArtifactOperationElse(){
 371         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 372         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 373         List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
 374         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 375         artifactDefinition.setArtifactName("artifactName");
 376         artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
 377         artifactDefinition.setArtifactChecksum("artifactChecksum");
 378         existingArtifactsToHandle.add(artifactDefinition);
 379         Resource resource = createParseResourceObject(false);
 380
 381         try {
 382             sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource, user);
 383         } catch (Exception e) {
 384             e.printStackTrace();
 385         }
 386
 387     }
 388
 389     @Test
 390     public void testProcessCsarArtifacts(){
 391         CsarInfo csarInfo = getCsarInfo();
 392         Resource resource = createParseResourceObject(false);
 393         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 394         Either<Resource, ResponseFormat> resStatus = null;
 395         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 396         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 397         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
 398                 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 399         vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,artifactPathAndNameList);
 400         Either<Resource, ResponseFormat> rrfe = sIB1.processCsarArtifacts(csarInfo,
 401                 resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle);
 402         assertNull(rrfe);
 403     }
 404
 405     @Test
 406     public void testCreateOrUpdateSingleNonMetaArtifact(){
 407         Resource resource = createParseResourceObject(false);
 408         CsarInfo csarInfo = getCsarInfo();
 409         Map<String, byte[]> csar = csarInfo.getCsar();
 410         String rootPath = System.getProperty("user.dir");
 411         Path path;
 412         byte[] data = new byte[0];
 413         path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
 414         try {
 415             data = Files.readAllBytes(path);
 416         } catch (IOException e) {
 417             e.printStackTrace();
 418         }
 419         csar.put("valid_vf.csar",data);
 420         String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
 421         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
 422         String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
 423         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 424         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 425         try {
 426             sIB1.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
 427                     artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
 428                     true, true, true);
 429         } catch (Exception e) {
 430             e.printStackTrace();
 431         }
 432     }
 433
 434     @Test
 435     public void testHandleNodeTypeArtifacts(){
 436         Resource nodeTypeResource = createParseResourceObject(false);
 437         ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
 438         componentMetadataDataDefinition.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 439         ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
 440         nodeTypeResource.setComponentMetadataDefinition(componentMetadataDefinition);
 441         Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
 442         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
 443         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 444         artifactDefinition.setArtifactName("artifactName");
 445         artifactDefinitions.add(artifactDefinition);
 446         nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
 447                 artifactDefinitions);
 448
 449         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 450         try {
 451             sIB1.handleNodeTypeArtifacts(nodeTypeResource, nodeTypeArtifactsToHandle,
 452                     createdArtifacts, user, true, true);
 453         } catch (Exception e) {
 454             e.printStackTrace();
 455         }
 456     }
 457
 458
 459     @Test
 460     public void testCreateOrUpdateServiceArtifacts(){
 461         ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
 462         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 463         String yamlFileName = "group.yml";
 464         CsarInfo csarInfo =getCsarInfo();
 465         Service preparedService = createServiceObject(false);
 466         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 467         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 468         artifactDefinition.setArtifactName("artifactDefinition");
 469         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 470         preparedService.setDeploymentArtifacts(deploymentArtifacts);
 471         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 472         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle= new HashMap<>();
 473         NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,nodeTypesArtifactsToHandle);
 474
 475         try {
 476             sIB1.createOrUpdateArtifacts(operation,createdArtifacts,yamlFileName,csarInfo,
 477                     preparedService,nodeTypeInfoToUpdateArtifacts,true,true);
 478         } catch (Exception e) {
 479             e.printStackTrace();
 480         }
 481     }
 482
 483     @Test
 484     public void testHandleVfCsarServiceArtifacts(){
 485         Service service = createServiceObject(true);
 486         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 487         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 488         artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
 489         artifactDefinition.setUniqueId("uniqueId");
 490         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 491         service.setDeploymentArtifacts(deploymentArtifacts);
 492         CsarInfo csarInfo = getCsarInfo();
 493         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 494         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 495         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 496
 497         try {
 498             sIB1.handleVfCsarArtifacts(service,csarInfo,createdArtifacts,artifactOperation,true,true);
 499         } catch (Exception e) {
 500             e.printStackTrace();
 501         }
 502     }
 503
 504     @Test
 505     public void testHandleVfCsarServiceArtifactsGetToscaElement() throws IOException {
 506         Service service = createServiceObject(true);
 507         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 508         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 509         artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
 510         artifactDefinition.setUniqueId("uniqueId");
 511         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 512         service.setDeploymentArtifacts(deploymentArtifacts);
 513         CsarInfo csarInfo = getCsarInfo();
 514         Map<String, byte[]> csar = new HashMap<>();
 515         String csarKey = CsarUtils.ARTIFACTS_PATH + "HEAT.meta";
 516         byte[] artifactsMetaBytes = "src/test/resources/normativeTypes/valid_vf.csar".getBytes();
 517         csar.put(csarKey,artifactsMetaBytes);
 518         csarInfo.setCsar(csar);
 519         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 520         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 521         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(service));
 522
 523         try {
 524             sIB1.handleVfCsarArtifacts(service,csarInfo,createdArtifacts,artifactOperation,true,true);
 525         } catch (Exception e) {
 526             e.printStackTrace();
 527         }
 528     }
 529
 530     @Test
 531     public void testCreateOrUpdateNonMetaServiceArtifacts(){
 532         CsarInfo csarInfo = getCsarInfo();
 533         Service service = createServiceObject(true);
 534         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 535         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 536
 537         Either<Service, ResponseFormat> result = sIB1.createOrUpdateNonMetaArtifacts(csarInfo,
 538                 service, createdArtifacts, true, true, artifactOperation);
 539         assertEquals(result.left().value(),service);
 540     }
 541
 542     @Test
 543     public void testFindServiceCsarArtifactsToHandle(){
 544         Service service = createServiceObject(true);
 545         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 546         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 547         artifactDefinition.setArtifactName("artifactDefinition");
 548         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 549         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 550         artifacts.put("artifacts",artifactDefinition);
 551         List<GroupDefinition> groups = new ArrayList<>();
 552         GroupDefinition groupDefinition = new GroupDefinition();
 553         groupDefinition.setUniqueId("groupDefinitionUniqueId");
 554         groupDefinition.setName("groupDefinition");
 555         groups.add(groupDefinition);
 556         service.setDeploymentArtifacts(deploymentArtifacts);
 557         service.setArtifacts(artifacts);
 558         service.setGroups(groups);
 559         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 560
 561         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
 562                 ResponseFormat> result = sIB1.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
 563         assertNotNull(result.left().value());
 564     }
 565
 566     @Test
 567     public void testOrganizeVfCsarArtifactsByServiceArtifactOperation(){
 568         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 569         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 570         List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
 571         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 572         artifactDefinition.setArtifactName("artifactName");
 573         artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
 574         artifactDefinition.setArtifactChecksum("artifactChecksum");
 575         existingArtifactsToHandle.add(artifactDefinition);
 576         Service service = createServiceObject(true);
 577
 578         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
 579                 enumMapResponseFormatEither = sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
 580                 existingArtifactsToHandle, service, user);
 581         assertNotNull(enumMapResponseFormatEither.left().value());
 582     }
 583
 584     @Test
 585     public void testOrganizeVfCsarArtifactsByServiceArtifactOperationElse(){
 586         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 587         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 588         List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
 589         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 590         artifactDefinition.setArtifactName("artifactName");
 591         artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_VF_MODEL.name());
 592         artifactDefinition.setArtifactChecksum("artifactChecksum");
 593         existingArtifactsToHandle.add(artifactDefinition);
 594         Service service = createServiceObject(true);
 595
 596         try {
 597             sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, service, user);
 598         } catch (Exception e) {
 599             e.printStackTrace();
 600         }
 601
 602     }
 603
 604     @Test
 605     public void testProcessServiceCsarArtifacts(){
 606         CsarInfo csarInfo = getCsarInfo();
 607         Service service = createServiceObject(true);
 608         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 609         Either<Service, ResponseFormat> resStatus = null;
 610         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
 611                 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 612         Either<Service, ResponseFormat> srfe = sIB1.processCsarArtifacts(csarInfo,
 613                 service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle);
 614         assertNull(srfe);
 615     }
 616
 617     @Test
 618     public void testGetValidArtifactNames(){
 619         CsarInfo csarInfo = getCsarInfo();
 620         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
 621         Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIB1.getValidArtifactNames(csarInfo, collectedWarningMessages);
 622         System.out.println(result.left().value());
 623         assertNotNull(result.left().value());
 624     }
 625
 626     @Test
 627     public void testCreateOrUpdateSingleNonMetaServiceArtifact(){
 628         Service service = createServiceObject(true);
 629         CsarInfo csarInfo = getCsarInfo();
 630         Map<String, byte[]> csar = csarInfo.getCsar();
 631         String rootPath = System.getProperty("user.dir");
 632         Path path;
 633         byte[] data = new byte[0];
 634         path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
 635         try {
 636             data = Files.readAllBytes(path);
 637         } catch (IOException e) {
 638             e.printStackTrace();
 639         }
 640         csar.put("valid_vf.csar",data);
 641         csarInfo.setCsar(csar);
 642         String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
 643         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
 644         String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
 645         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 646         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 647         try {
 648             sIB1.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
 649                     artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
 650                     true, true, true);
 651         } catch (Exception e) {
 652             e.printStackTrace();
 653         }
 654     }
 655
 656     @Test
 657     public void testCreateOrUpdateSingleNonMetaServiceArtifactNull(){
 658         Service service = createServiceObject(true);
 659         CsarInfo csarInfo = getCsarInfo();
 660         String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
 661         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
 662         String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
 663         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 664         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 665         try {
 666             sIB1.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
 667                     artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
 668                     true, true, true);
 669         } catch (Exception e) {
 670             e.printStackTrace();
 671         }
 672     }
 673
 674     @Test
 675     public void testCreateGroupsOnResource(){
 676         Service service = createServiceObject(true);
 677         Map<String, GroupDefinition> groups = getGroups();
 678
 679         try {
 680             Either<Service, ResponseFormat> result = sIB1.createGroupsOnResource(service, groups);
 681         } catch (Exception e) {
 682             e.printStackTrace();
 683         }
 684     }
 685
 686     @Test
 687     public void testCreateGroupsOnResourceNull(){
 688         Service service = createServiceObject(true);
 689         Map<String, GroupDefinition> groups = null;
 690
 691         Either<Service, ResponseFormat> result = sIB1.createGroupsOnResource(service, groups);
 692         assertNotNull(result);
 693
 694     }
 695
 696     @Test
 697     public void testUpdateGroupsMembersUsingResource(){
 698         Service service = createServiceObject(true);
 699         Map<String, GroupDefinition> groups = null;
 700
 701         List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, service);
 702         for (GroupDefinition groupDefinition : groupDefinitions) {
 703             assertNull(groupDefinition);
 704         }
 705     }
 706
 707     @Test
 708     public void testUpdateGroupsMembersUsingResource_left(){
 709         Service service = createServiceObject(true);
 710         Map<String, GroupDefinition> groups = getGroups();
 711         when(serviceImportParseLogic.validateCyclicGroupsDependencies(any()))
 712                 .thenReturn(Either.left(true));
 713
 714         List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, service);
 715         for (GroupDefinition groupDefinition : groupDefinitions) {
 716             assertNotNull(groupDefinition);
 717         }
 718     }
 719
 720     @Test
 721     public void testCreateRIAndRelationsFromResourceYaml(){
 722         String yamlName = "group.yml";
 723         Resource resource = createParseResourceObject(true);
 724         Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
 725         String topologyTemplateYaml = getMainTemplateContent();
 726         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 727         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 728         CsarInfo csarInfo = getCsarInfo();
 729         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 730         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 731
 732         try {
 733             sIB1.createRIAndRelationsFromYaml(yamlName,resource,uploadComponentInstanceInfoMap,topologyTemplateYaml,nodeTypesNewCreatedArtifacts,
 734                     nodeTypesInfo,csarInfo,nodeTypesArtifactsToCreate,nodeName);
 735         } catch (Exception e) {
 736             e.printStackTrace();
 737         }
 738     }
 739
 740
 741     @Test
 742     public void testCreateResourceInstancesRelations(){
 743         String yamlName = "group.yml";
 744         Resource resource = createParseResourceObject(true);
 745         resource.setComponentInstances(creatComponentInstances());
 746         resource.setResourceType(ResourceTypeEnum.VF);
 747         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 748         uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
 749
 750         try {
 751             sIB1.createResourceInstancesRelations(user,yamlName,resource,uploadResInstancesMap);
 752         } catch (Exception e) {
 753             e.printStackTrace();
 754         }
 755     }
 756
 757     @Test
 758     public void testCreateResourceInstancesRelations_Empty(){
 759         String yamlName = "group.yml";
 760         Resource resource = createParseResourceObject(true);
 761         resource.setComponentInstances(creatComponentInstances());
 762         resource.setResourceType(ResourceTypeEnum.PNF);
 763         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 764         uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
 765
 766         try {
 767             sIB1.createResourceInstancesRelations(user,yamlName,resource,uploadResInstancesMap);
 768         } catch (Exception e) {
 769             e.printStackTrace();
 770         }
 771     }
 772
 773
 774     @Test
 775     public void testProcessComponentInstance1(){
 776         String yamlName = "group.yml";
 777         Resource resource = createParseResourceObject(true);
 778         Resource originResource = createParseResourceObject(false);
 779         List<ComponentInstance> componentInstancesList = creatComponentInstances();
 780         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
 781         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
 782         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
 783         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
 784         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
 785         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
 786         Map<String, List< AttributeDefinition >> instAttributes = new HashMap<>();
 787         Map<String, Resource> originCompMap = new HashMap<>();
 788         originCompMap.put("componentUid",originResource);
 789         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 790         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 791         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
 792
 793         try {
 794             sIB1.processComponentInstance(yamlName, resource, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
 795                     instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
 796         } catch (Exception e) {
 797             e.printStackTrace();
 798         }
 799     }
 800
 801     @Test
 802     public void testProcessComponentInstance_null(){
 803         String yamlName = "group.yml";
 804         Resource resource = createParseResourceObject(true);
 805         Resource originResource = createParseResourceObject(false);
 806         List<ComponentInstance> componentInstancesList = creatComponentInstances();
 807         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
 808         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
 809         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
 810         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
 811         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
 812         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
 813         Map<String, List< AttributeDefinition >> instAttributes = new HashMap<>();
 814         Map<String, Resource> originCompMap = new HashMap<>();
 815         originCompMap.put("componentUid",originResource);
 816         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 817         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 818         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
 819
 820         try {
 821             sIB1.processComponentInstance(yamlName, resource, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
 822                     instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
 823         } catch (Exception e) {
 824             e.printStackTrace();
 825         }
 826     }
 827
 828     @Test
 829     public void testAddInputsValuesToRi(){
 830         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 831         Map<String, List<UploadPropInfo>> properties = new HashMap<>();
 832         List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
 833         UploadPropInfo uploadPropInfo = new UploadPropInfo();
 834         uploadPropInfo.setName("uploadPropInfo");
 835         uploadPropInfoList.add(uploadPropInfo);
 836         uploadPropInfoList.add(uploadPropInfo);
 837         properties.put("propertiesMap",uploadPropInfoList);
 838         uploadComponentInstanceInfo.setProperties(properties);
 839         Resource resource = createParseResourceObject(true);
 840         Resource originResource =createParseResourceObject(false);
 841         List<InputDefinition> inputs = new ArrayList<>();
 842         InputDefinition inputDefinition = new InputDefinition();
 843         inputDefinition.setUniqueId("uniqueId");
 844         inputs.add(inputDefinition);
 845         originResource.setInputs(inputs);
 846         ComponentInstance currentCompInstance = new ComponentInstance();
 847         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 848         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 849
 850         try {
 851             sIB1.addInputsValuesToRi(uploadComponentInstanceInfo,resource,originResource,
 852                     currentCompInstance,instInputs,allDataTypes);
 853         } catch (Exception e) {
 854             e.printStackTrace();
 855         }
 856     }
 857
 858     @Test
 859     public void testProcessProperty(){
 860         Resource resource = createParseResourceObject(true);
 861         List<InputDefinition> inputs = new ArrayList<>();
 862         InputDefinition inputDefinition = new InputDefinition();
 863         inputDefinition.setName("inputDefinitionName");
 864         inputDefinition.setUniqueId("uniqueId");
 865         inputDefinition.setType("inputDefinitionType");
 866         inputs.add(inputDefinition);
 867         resource.setInputs(inputs);
 868         ComponentInstance currentCompInstance = null;
 869         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 870         Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
 871         currPropertiesMap.put("propertyInfoName",inputDefinition);
 872         List<ComponentInstanceInput> instPropList = new ArrayList<>();
 873         List<UploadPropInfo> propertyList = new ArrayList<>();
 874         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
 875         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
 876         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
 877         getInputValueDataDefinition.setInputName("inputDefinitionName");
 878         get_input.add(getInputValueDataDefinition);
 879         UploadPropInfo propertyInfo = new UploadPropInfo();
 880         propertyInfo.setValue("value");
 881         propertyInfo.setGet_input(get_input);
 882         propertyInfo.setName("propertyInfoName");
 883         propertyList.add(propertyInfo);
 884
 885         try {
 886             sIB1.processProperty(resource, currentCompInstance, allDataTypes,
 887                     currPropertiesMap, instPropList, propertyList);
 888         } catch (Exception e) {
 889             e.printStackTrace();
 890         }
 891     }
 892
 893     @Test
 894     public void testHandleSubstitutionMappings(){
 895         Resource resource = createParseResourceObject(true);
 896         resource.setResourceType(ResourceTypeEnum.VF);
 897         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 898         when(toscaOperationFacade.getToscaFullElement(anyString()))
 899                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 900
 901         try {
 902             sIB1.handleSubstitutionMappings(resource, uploadResInstancesMap);
 903         } catch (Exception e) {
 904             e.printStackTrace();
 905         }
 906     }
 907
 908     @Test
 909     public void testHandleSubstitutionMappings_left(){
 910         Resource resource = createParseResourceObject(true);
 911         resource.setResourceType(ResourceTypeEnum.VF);
 912         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 913         when(toscaOperationFacade.getToscaFullElement(anyString()))
 914                 .thenReturn(Either.left(resource));
 915
 916         try {
 917             sIB1.handleSubstitutionMappings(resource, uploadResInstancesMap);
 918         } catch (Exception e) {
 919             e.printStackTrace();
 920         }
 921     }
 922
 923     @Test
 924     public void testCreateResourceInstances(){
 925         String yamlName = "group.yml";
 926         Resource resource = createParseResourceObject(true);
 927         Resource originResource = createParseResourceObject(false);
 928         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 929         UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
 930         nodesInfoValue.setName("zxjTestImportServiceAb");
 931         nodesInfoValue.setRequirements(gerRequirements());
 932         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
 933         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
 934         nodeNamespaceMap.put("resources",originResource);
 935
 936         try {
 937             sIB1.createResourceInstances(yamlName,resource,uploadResInstancesMap,nodeNamespaceMap);
 938         } catch (Exception e) {
 939             e.printStackTrace();
 940         }
 941     }
 942
 943     @Test
 944     public void testHandleNodeTypes(){
 945         String yamlName = "group.yml";
 946         Resource resource = createParseResourceObject(true);
 947         String topologyTemplateYaml = getMainTemplateContent();
 948         boolean needLock = true;
 949         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 950         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 951         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 952         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
 953         nodeTypeInfo.setNested(false);
 954         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 955         nodeTypesInfo.put(nodeName,nodeTypeInfo);
 956         CsarInfo csarInfo = getCsarInfo();
 957
 958         try {
 959             sIB1.handleNodeTypes(yamlName,resource,topologyTemplateYaml,needLock,
 960                     nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,
 961                     csarInfo,nodeName);
 962         } catch (Exception e) {
 963             e.printStackTrace();
 964         }
 965     }
 966
 967     @Test
 968     public void testHandleNestedVfc1(){
 969         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 970         Resource resource = createParseResourceObject(false);
 971         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 972         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 973         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
 974         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
 975         nodeTypeInfo.setTemplateFileName("groups.yml");
 976         nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
 977         nodesInfo.put(nodeName,nodeTypeInfo);
 978         CsarInfo csarInfo = getCsarInfo();
 979
 980         try {
 981             sIB1.handleNestedVfc(resource,nodeTypesArtifactsToHandle,createdArtifacts,
 982                     nodesInfo,csarInfo,nodeName);
 983         } catch (Exception e) {
 984             e.printStackTrace();
 985         }
 986     }
 987
 988     @Test
 989     public void testHandleComplexVfc1(){
 990         Resource resource = createParseResourceObject(true);
 991         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 992         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 993         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
 994         CsarInfo csarInfo = getCsarInfo();
 995         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 996         String yamlName = "group.yml";
 997         when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
 998                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 999
1000         try {
1001             sIB1.handleComplexVfc(resource,nodeTypesArtifactsToHandle,createdArtifacts,
1002                     nodesInfo,csarInfo,nodeName,yamlName);
1003         } catch (Exception e) {
1004             e.printStackTrace();
1005         }
1006     }
1007
1008     @Test
1009     public void testCreateResourcesFromYamlNodeTypesList1(){
1010         String yamlName = "group.yml";
1011         Resource resource = createParseResourceObject(false);
1012         Map<String, Object> mappedToscaTemplate = new HashMap<>();
1013         boolean needLock = true;
1014         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1015         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1016         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1017         CsarInfo csarInfo = getCsarInfo();
1018
1019         try {
1020             sIB1.createResourcesFromYamlNodeTypesList(yamlName,resource,mappedToscaTemplate,
1021                     needLock, nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,
1022                     nodeTypesInfo,csarInfo);
1023         } catch (Exception e) {
1024             e.printStackTrace();
1025         }
1026     }
1027
1028     @Test
1029     public void testCreateNodeTypes1(){
1030         String yamlName = "group.yml";
1031         Resource resource = createParseResourceObject(false);
1032         boolean needLock = true;
1033         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1034         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
1035                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1036         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
1037         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1038         artifactDefinition.setArtifactName("artifactName");
1039         artifactDefinitions.add(artifactDefinition);
1040         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
1041                 artifactDefinitions);
1042         nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
1043         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1044         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1045         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1046         nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
1047         CsarInfo csarInfo = getCsarInfo();
1048         Map<String, Object> mapToConvert =new HashMap<>();
1049         Map<String, Object> nodeTypes =new HashMap<>();
1050         nodeTypes.put("nodeTyp",nodeTypeInfo);
1051
1052         try {
1053             sIB1.createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle,
1054                     nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1055                     nodeTypes);
1056         } catch (Exception e) {
1057             e.printStackTrace();
1058         }
1059     }
1060
1061     @Test
1062     public void testCreateNodeTypeResourceFromYaml(){
1063         String yamlName = "group.yml";
1064         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1065         Map<String,Object> nodeMap = new HashMap<>();
1066         nodeMap.put(nodeName,getGroupsYaml());
1067         Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
1068         Map<String, Object> mapToConvert = new HashedMap();
1069         Resource resourceVf = createParseResourceObject(false);
1070         boolean needLock = true;
1071         Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
1072         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1073         boolean forceCertificationAllowed = true;
1074         CsarInfo csarInfo = getCsarInfo();
1075         boolean isNested = true;
1076
1077         try {
1078             sIB1.createNodeTypeResourceFromYaml(yamlName,nodeNameValue,user,mapToConvert,resourceVf,
1079                     needLock,nodeTypeArtifactsToHandle,nodeTypesNewCreatedArtifacts,
1080                     forceCertificationAllowed,csarInfo,isNested);
1081         } catch (Exception e) {
1082             e.printStackTrace();
1083         }
1084     }
1085
1086     @Test
1087     public void testCreateRIAndRelationsFromYaml(){
1088         String yamlName = "group.yml";
1089         Service service = createServiceObject(true);
1090         Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
1091         String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
1092         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1093         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1094         CsarInfo csarInfo = getCsarInfo();
1095         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1096         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1097         try {
1098             sIB1.createRIAndRelationsFromYaml(yamlName,service,uploadComponentInstanceInfoMap,topologyTemplateYaml,nodeTypesNewCreatedArtifacts,
1099                     nodeTypesInfo,csarInfo,nodeTypesArtifactsToCreate,nodeName);
1100         } catch (Exception e) {
1101             e.printStackTrace();
1102         }
1103     }
1104
1105     @Test
1106     public void testCreateServiceInstancesRelations(){
1107         String yamlName = "group.yml";
1108         Service service = createServiceObject(true);
1109         service.setComponentInstances(creatComponentInstances());
1110         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1111         uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
1112
1113         try {
1114             sIB1.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap);
1115         } catch (Exception e) {
1116             e.printStackTrace();
1117         }
1118     }
1119
1120     @Test
1121     public void testCreateServiceInstancesRelations_Empty(){
1122         String yamlName = "group.yml";
1123         Service service = createServiceObject(true);
1124         service.setComponentInstances(creatComponentInstances());
1125         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1126
1127         try {
1128             sIB1.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap);
1129         } catch (Exception e) {
1130             e.printStackTrace();
1131         }
1132     }
1133
1134     @Test
1135     public void testProcessComponentInstance(){
1136         String yamlName = "group.yml";
1137         Service service = createServiceObject(true);
1138         Resource originResource = createParseResourceObject(false);
1139         List<ComponentInstance> componentInstancesList = creatComponentInstances();
1140         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1141         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1142         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1143         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1144         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1145         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1146         Map<String, List< AttributeDefinition >> instAttributes = new HashMap<>();
1147         Map<String, Resource> originCompMap = new HashMap<>();
1148         originCompMap.put("componentUid",originResource);
1149         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1150         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1151         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
1152
1153         try {
1154             sIB1.processComponentInstance(yamlName, service, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
1155                     instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
1156         } catch (Exception e) {
1157             e.printStackTrace();
1158         }
1159     }
1160
1161     @Test
1162     public void testProcessComponentInstance_null2(){
1163         String yamlName = "group.yml";
1164         Service service = createServiceObject(true);
1165         Resource originResource = createParseResourceObject(false);
1166         List<ComponentInstance> componentInstancesList = creatComponentInstances();
1167         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1168         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1169         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1170         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1171         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1172         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1173         Map<String, List< AttributeDefinition >> instAttributes = new HashMap<>();
1174         Map<String, Resource> originCompMap = new HashMap<>();
1175         originCompMap.put("componentUid",originResource);
1176         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1177         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1178         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb0");
1179
1180         try {
1181             sIB1.processComponentInstance(yamlName, service, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
1182                     instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
1183         } catch (Exception e) {
1184             e.printStackTrace();
1185         }
1186     }
1187
1188     @Test
1189     public void testAddInputsValuesToRi2(){
1190         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1191         Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1192         List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
1193         UploadPropInfo uploadPropInfo = new UploadPropInfo();
1194         uploadPropInfo.setName("uploadPropInfo");
1195         uploadPropInfoList.add(uploadPropInfo);
1196         uploadPropInfoList.add(uploadPropInfo);
1197         properties.put("propertiesMap",uploadPropInfoList);
1198         uploadComponentInstanceInfo.setProperties(properties);
1199         Service resource = createServiceObject(true);
1200         Resource originResource =createParseResourceObject(false);
1201         List<InputDefinition> inputs = new ArrayList<>();
1202         InputDefinition inputDefinition = new InputDefinition();
1203         inputDefinition.setUniqueId("uniqueId");
1204         inputs.add(inputDefinition);
1205         originResource.setInputs(inputs);
1206         ComponentInstance currentCompInstance = new ComponentInstance();
1207         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1208         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1209
1210         try {
1211             sIB1.addInputsValuesToRi(uploadComponentInstanceInfo,resource,originResource,
1212                         currentCompInstance,instInputs,allDataTypes);
1213         } catch (Exception e) {
1214             e.printStackTrace();
1215         }
1216     }
1217
1218     @Test
1219     public void testProcessProperty2(){
1220         Service resource = createServiceObject(true);
1221         List<InputDefinition> inputs = new ArrayList<>();
1222         ComponentInstance currentCompInstance = null;
1223         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1224         Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1225         InputDefinition inputDefinition = new InputDefinition();
1226         inputDefinition.setName("inputDefinitionName");
1227         inputDefinition.setType("inputDefinitionType");
1228         inputs.add(inputDefinition);
1229         currPropertiesMap.put("propertyInfoName",inputDefinition);
1230         resource.setInputs(inputs);
1231         List<ComponentInstanceInput> instPropList = new ArrayList<>();
1232         List<UploadPropInfo> propertyList = new ArrayList<>();
1233         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1234         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1235         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1236         getInputValueDataDefinition.setInputName("inputDefinitionName");
1237         get_input.add(getInputValueDataDefinition);
1238         UploadPropInfo propertyInfo = new UploadPropInfo();
1239         propertyInfo.setValue("value");
1240         propertyInfo.setGet_input(get_input);
1241         propertyInfo.setName("propertyInfoName");
1242         propertyList.add(propertyInfo);
1243
1244         try {
1245             sIB1.processProperty(resource, currentCompInstance, allDataTypes,
1246                     currPropertiesMap, instPropList, propertyList);
1247         } catch (Exception e) {
1248             e.printStackTrace();
1249         }
1250     }
1251
1252     @Test
1253     public void testProcessGetInput(){
1254         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1255         List<InputDefinition> inputs = new ArrayList<>();
1256         GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1257
1258         try {
1259             sIB1.processGetInput(getInputValues,inputs,getInputIndex);
1260         } catch (Exception e) {
1261             e.printStackTrace();
1262         }
1263     }
1264
1265     @Test
1266     public void testProcessGetInput_optional(){
1267         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1268         List<InputDefinition> inputs = new ArrayList<>();
1269         InputDefinition inputDefinition = new InputDefinition();
1270         inputDefinition.setUniqueId("uniqueId");
1271         inputDefinition.setName("InputName");
1272         inputs.add(inputDefinition);
1273         GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
1274         getInputIndex.setInputName("InputName");
1275
1276         sIB1.processGetInput(getInputValues,inputs,getInputIndex);
1277     }
1278
1279     @Test
1280     public void testAddPropertyValuesToRi(){
1281         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1282         uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1283         Resource resource = createParseResourceObject(true);
1284         Resource originResource = createParseResourceObject(false);
1285         originResource.setProperties(getProperties());
1286         ComponentInstance currentCompInstance = new ComponentInstance();
1287         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1288         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1289         try {
1290             sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
1291                     instProperties, allDataTypes);
1292         } catch (Exception e) {
1293             e.printStackTrace();
1294         }
1295     }
1296
1297     @Test
1298     public void testAddPropertyValuesToRi_else(){
1299         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1300         Resource resource = createParseResourceObject(true);
1301         Resource originResource = createParseResourceObject(false);
1302         originResource.setProperties(getProperties());
1303         ComponentInstance currentCompInstance = new ComponentInstance();
1304         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1305         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1306         try {
1307             sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
1308                     instProperties, allDataTypes);
1309         } catch (Exception e) {
1310             e.printStackTrace();
1311         }
1312     }
1313
1314     @Test
1315     public void testAddPropertyValuesToRi2(){
1316         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1317         uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1318         Service service = createServiceObject(false);
1319         Resource originResource = createParseResourceObject(false);
1320         originResource.setProperties(getProperties());
1321         ComponentInstance currentCompInstance = new ComponentInstance();
1322         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1323         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1324
1325         try {
1326             sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1327                     instProperties, allDataTypes);
1328         } catch (Exception e) {
1329             e.printStackTrace();
1330         }
1331     }
1332
1333     @Test
1334     public void testAddPropertyValuesToRi2_else(){
1335         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1336         Service service = createServiceObject(false);
1337         Resource originResource = createParseResourceObject(false);
1338         originResource.setProperties(getProperties());
1339         ComponentInstance currentCompInstance = new ComponentInstance();
1340         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1341         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1342
1343         try {
1344             sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1345                     instProperties, allDataTypes);
1346         } catch (Exception e) {
1347             e.printStackTrace();
1348         }
1349     }
1350
1351     @Test
1352     public void testProcessComponentInstanceCapabilities(){
1353         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1354         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1355         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1356         uploadComponentInstanceInfo.setCapabilities(getCapabilities());
1357         ComponentInstance currentCompInstance = new ComponentInstance();
1358         Resource originResource = createParseResourceObject(false);
1359
1360         sIB1.processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
1361                 currentCompInstance, originResource);
1362     }
1363
1364     @Test
1365     public void testProcessComponentInstanceCapabilities_null(){
1366         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1367         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1368         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1369         ComponentInstance currentCompInstance = new ComponentInstance();
1370         Resource originResource = createParseResourceObject(false);
1371
1372         sIB1.processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
1373                 currentCompInstance, originResource);
1374     }
1375
1376     @Test
1377     public void testUpdateCapabilityPropertiesValues(){
1378         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1379         Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1380         Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1381
1382         sIB1.updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
1383     }
1384
1385     @Test
1386     public void testUpdatePropertyValues(){
1387         List<ComponentInstanceProperty> properties = new ArrayList<>();
1388         Map<String, UploadPropInfo> newProperties = new HashMap<>();
1389         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1390
1391         sIB1.updatePropertyValues(properties,newProperties,allDataTypes);
1392     }
1393
1394     @Test
1395     public void testUpdatePropertyValue(){
1396         ComponentInstanceProperty property = new ComponentInstanceProperty();
1397         property.setType("services");
1398         UploadPropInfo propertyInfo = new UploadPropInfo();
1399         propertyInfo.setValue("value");
1400         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1401
1402         try {
1403             sIB1.updatePropertyValue(property,propertyInfo,allDataTypes);
1404         } catch (Exception e) {
1405             e.printStackTrace();
1406         }
1407     }
1408
1409     @Test
1410     public void testGetOriginResource(){
1411         String yamlName = "group.yml";
1412         Map<String, Resource> originCompMap = new HashMap<>();
1413         ComponentInstance currentCompInstance = new ComponentInstance();
1414         currentCompInstance.setComponentUid("currentCompInstance");
1415
1416         try {
1417             sIB1.getOriginResource(yamlName,originCompMap,currentCompInstance);
1418         } catch (Exception e) {
1419             e.printStackTrace();
1420         }
1421     }
1422
1423     @Test
1424     public void testHandleSubstitutionMappings2(){
1425         Service service = createServiceObject(false);
1426         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1427
1428         sIB1.handleSubstitutionMappings(service, uploadResInstancesMap);
1429     }
1430
1431     @Test
1432     public void testUpdateCalculatedCapReqWithSubstitutionMappings(){
1433         Resource resource = createParseResourceObject(false);
1434         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1435
1436         when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
1437
1438         try {
1439             sIB1.updateCalculatedCapReqWithSubstitutionMappings(resource,uploadResInstancesMap);
1440         } catch (Exception e) {
1441
1442         }
1443     }
1444
1445     @Test
1446     public void testFillUpdatedInstCapabilitiesRequirements(){
1447         List<ComponentInstance> componentInstances = creatComponentInstances();
1448         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1449         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1450         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
1451
1452         sIB1.fillUpdatedInstCapabilitiesRequirements(componentInstances,uploadResInstancesMap,
1453                 updatedInstCapabilities,updatedInstRequirement);
1454     }
1455
1456     @Test
1457     public void testFillUpdatedInstCapabilities(){
1458         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
1459         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1460         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1461         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1462         capabilityDefinition.setName("mme_ipu_vdu.feature");
1463         capabilityDefinitionList.add(capabilityDefinition);
1464         capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
1465         ComponentInstance instance = new ComponentInstance();
1466         instance.setCapabilities(capabilities);
1467         Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1468         capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
1469
1470         sIB1.fillUpdatedInstCapabilities(updatedInstCapabilties,instance,capabilitiesNamesToUpdate);
1471     }
1472
1473     @Test
1474     public void testFillUpdatedInstRequirements(){
1475         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
1476                 HashMap<>();
1477         ComponentInstance instance = new ComponentInstance();
1478         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1479         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1480         RequirementDefinition requirementDefinition = new RequirementDefinition();
1481         requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1482         requirementDefinitionList.add(requirementDefinition);
1483         requirements.put("tosca.capabilities.Node",requirementDefinitionList);
1484         instance.setRequirements(requirements);
1485         Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1486         requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
1487                 "requirementsNamesToUpdate");
1488
1489
1490         sIB1.fillUpdatedInstRequirements(updatedInstRequirements,instance,requirementsNamesToUpdate);
1491     }
1492
1493     @Test
1494     public void testAddRelationsToRI(){
1495         String yamlName = "group.yml";
1496         Service service = createServiceObject(false);
1497         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1498         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1499         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1500         List<ComponentInstance> componentInstancesList = creatComponentInstances();
1501         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1502
1503         try {
1504             sIB1.addRelationsToRI(yamlName,service,uploadResInstancesMap,componentInstancesList,
1505                     relations);
1506         } catch (Exception e) {
1507             e.printStackTrace();
1508         }
1509     }
1510
1511     @Test
1512     public void testAddRelationsToRI_null(){
1513         String yamlName = "group.yml";
1514         Service service = createServiceObject(false);
1515         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1516         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1517         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1518         List<ComponentInstance> componentInstancesList = new ArrayList<>();
1519         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1520
1521         try {
1522             sIB1.addRelationsToRI(yamlName,service,uploadResInstancesMap,componentInstancesList,
1523                     relations);
1524         } catch (Exception e) {
1525             e.printStackTrace();
1526         }
1527     }
1528
1529     @Test
1530     public void testAddRelationToRI(){
1531         String yamlName = "group.yml";
1532         Service service = createServiceObject(false);
1533         service.setComponentInstances(creatComponentInstances());
1534
1535         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1536         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1537
1538         try {
1539             sIB1.addRelationToRI(yamlName,service,nodesInfoValue,relations);
1540         } catch (Exception e) {
1541             e.printStackTrace();
1542         }
1543     }
1544
1545     @Test
1546     public void testAddRelationToRI_null(){
1547         String yamlName = "group.yml";
1548         Service service = createServiceObject(false);
1549         List<ComponentInstance> componentInstancesList = new ArrayList<>();
1550         service.setComponentInstances(componentInstancesList);
1551
1552         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1553         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1554
1555         try {
1556             sIB1.addRelationToRI(yamlName,service,nodesInfoValue,relations);
1557         } catch (Exception e) {
1558             e.printStackTrace();
1559         }
1560     }
1561
1562     @Test
1563     public void testGetResourceAfterCreateRelations(){
1564         Service service = createServiceObject(false);
1565         ComponentParametersView componentParametersView = createComponentParametersView();
1566         when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1567         try {
1568             sIB1.getResourceAfterCreateRelations(service);
1569         } catch (Exception e) {
1570             e.printStackTrace();
1571         }
1572     }
1573
1574     @Test
1575     public void testCreateServiceInstances(){
1576         String yamlName = "group.yml";
1577         Service service = createServiceObject(false);
1578         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1579         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1580         uploadResInstancesMap.put("uploadResInstancesMap",nodesInfoValue);
1581         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1582         Resource resource = createParseResourceObject(true);
1583         resource.setToscaResourceName("toscaResourceName");
1584         nodeNamespaceMap.put("nodeNamespaceMap",resource);
1585
1586         try {
1587             sIB1.createServiceInstances(yamlName,service,uploadResInstancesMap,nodeNamespaceMap);
1588         } catch (Exception e) {
1589            e.printStackTrace();
1590         }
1591     }
1592
1593     @Test
1594     public void testCreateAndAddResourceInstance(){
1595         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1596         String yamlName = "group.yml";
1597         Resource resource = createParseResourceObject(false);
1598         Resource originResource = createParseResourceObject(true);
1599         originResource.setResourceType(ResourceTypeEnum.VF);
1600         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1601         nodeNamespaceMap.put("resources",originResource);
1602         Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1603         Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1604
1605         try {
1606             sIB1.createAndAddResourceInstance(uploadComponentInstanceInfo,yamlName,resource,nodeNamespaceMap,
1607                     existingnodeTypeMap,resourcesInstancesMap);
1608         } catch (Exception e) {
1609             e.printStackTrace();
1610         }
1611     }
1612
1613     @Test
1614     public void testCreateAndAddResourceInstances(){
1615         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1616         String yamlName = "group.yml";
1617         Service service = createServiceObject(false);
1618         service.setServiceType("services");
1619         Resource originResource = createParseResourceObject(true);
1620         originResource.setResourceType(ResourceTypeEnum.VF);
1621         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1622         nodeNamespaceMap.put("resources", originResource);
1623         Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1624         Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1625
1626         try {
1627             sIB1.createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service, nodeNamespaceMap,
1628                     existingnodeTypeMap, resourcesInstancesMap);
1629         } catch (Exception e) {
1630             e.printStackTrace();
1631         }
1632     }
1633
1634     @Test
1635     public void testValidateResourceInstanceBeforeCreate(){
1636         String yamlName = "group.yml";
1637         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1638         Resource originResource = createParseResourceObject(true);
1639         ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
1640         componentMetadataDataDefinition.setState(LifecycleStateEnum.CERTIFIED.name());
1641         ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
1642         originResource.setComponentMetadataDefinition(componentMetadataDefinition);
1643         originResource.setComponentType(ComponentTypeEnum.RESOURCE);
1644         originResource.setToscaResourceName("toscaResourceName");
1645         originResource.setResourceType(ResourceTypeEnum.VF);
1646         originResource.setResourceType(ResourceTypeEnum.VF);
1647         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1648         nodeNamespaceMap.put("resources", originResource);
1649         when( toscaOperationFacade.getLatestResourceByToscaResourceName(anyString()))
1650                 .thenReturn(Either.left(originResource));
1651
1652         try {
1653             sIB1.validateResourceInstanceBeforeCreate(yamlName,uploadComponentInstanceInfo,nodeNamespaceMap);
1654         } catch (Exception e) {
1655             e.printStackTrace();
1656         }
1657     }
1658
1659     @Test
1660     public void testHandleServiceNodeTypes(){
1661         String yamlName = "group.yml";
1662         Service service =createServiceObject(false);
1663         String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
1664         boolean needLock = true;
1665         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1666         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1667         Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1668         CsarInfo csarInfo = getCsarInfo();
1669         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1670         when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString()))
1671                 .thenReturn(Either.left(createOldResource()));
1672
1673         sIB1.handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, needLock,
1674                 nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1675                 csarInfo, nodeName);
1676     }
1677
1678     @Test
1679     public void testValidateResourceNotExisted(){
1680         String type = "org.openecomp.resource.vf";
1681         boolean b = false;
1682         try {
1683             b = sIB1.validateResourceNotExisted(type);
1684         } catch (Exception e) {
1685             e.printStackTrace();
1686         }
1687     }
1688
1689     @Test
1690     public void testHandleNestedVF(){
1691         Service service =createServiceObject(false);
1692         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1693         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1694         Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1695         CsarInfo csarInfo = getCsarInfo();
1696         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1697
1698         try {
1699             sIB1.handleNestedVF(service,nodeTypesArtifactsToHandle,createdArtifacts,
1700                     nodesInfo,csarInfo,nodeName);
1701         } catch (Exception e) {
1702             e.printStackTrace();
1703         }
1704     }
1705
1706     @Test
1707     public void testHandleNestedVfc(){
1708         Service service =createServiceObject(false);
1709         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1710         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1711         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1712         CsarInfo csarInfo = getCsarInfo();
1713         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1714
1715         try {
1716             sIB1.handleNestedVfc(service,nodeTypesArtifactsToHandle,createdArtifacts,
1717                     nodesInfo,csarInfo,nodeName);
1718         } catch (Exception e) {
1719             e.printStackTrace();
1720         }
1721     }
1722
1723     @Test
1724     public void testHandleComplexVfc(){
1725         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1726         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1727         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1728         CsarInfo csarInfo = getCsarInfo();
1729         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1730         String yamlName = "group.yml";
1731         when(toscaOperationFacade.getFullLatestComponentByToscaResourceName(anyString()))
1732                 .thenReturn(Either.left(createNewResource()));
1733
1734         try {
1735             sIB1.handleComplexVfc(nodeTypesArtifactsToHandle,createdArtifacts,
1736                     nodesInfo,csarInfo,nodeName,yamlName);
1737         } catch (Exception e) {
1738             e.printStackTrace();
1739         }
1740     }
1741
1742
1743     @Test
1744     public void testHandleComplexVfc2(){
1745         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1746         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1747         Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1748         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1749         String yamlName = "group.yml";
1750         CsarInfo csarInfo = getCsarInfo();
1751         Map<String, byte[]> csar = new HashMap<>();
1752         csar.put(yamlName,yamlName.getBytes());
1753         csarInfo.setCsar(csar);
1754         Resource oldComplexVfc = createParseResourceObject(false);
1755         Resource newComplexVfc = createParseResourceObject(true);
1756
1757         try {
1758             sIB1.handleComplexVfc(nodeTypesArtifactsToHandle,createdArtifacts,nodesInfo,
1759                     csarInfo,nodeName,yamlName,oldComplexVfc,newComplexVfc);
1760         } catch (Exception e) {
1761             e.printStackTrace();
1762         }
1763     }
1764
1765     @Test
1766     public void testUpdateResourceFromYaml(){
1767         Resource oldRresource = createParseResourceObject(false);
1768         Resource newRresource = createParseResourceObject(true);
1769         AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1770         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1771         String yamlFileName = "group.yml";
1772         String yamlFileContent = getYamlFileContent();
1773         CsarInfo csarInfo = getCsarInfo();
1774         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1775         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1776         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1777         boolean isNested = true;
1778
1779         try {
1780             sIB1.updateResourceFromYaml(oldRresource,newRresource,actionEnum,createdArtifacts,yamlFileName,yamlFileContent,
1781                     csarInfo,nodeTypesInfo,nodeTypesArtifactsToHandle,nodeName,isNested);
1782         } catch (Exception e) {
1783
1784         }
1785     }
1786
1787     @Test
1788     public void testCreateResourceFromYaml(){
1789         Resource resource = createParseResourceObject(true);
1790         String topologyTemplateYaml = getMainTemplateContent();
1791         String yamlName = "group.yml";
1792         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1793         CsarInfo csarInfo = getCsarInfo();
1794         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1795         boolean shouldLock = true;
1796         boolean inTransaction =true;
1797         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1798
1799         try {
1800             sIB1.createResourceFromYaml(resource,topologyTemplateYaml,yamlName,nodeTypesInfo,csarInfo,
1801                     nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
1802         } catch (Exception e) {
1803
1804         }
1805     }
1806
1807     @Test
1808     public void testCreateResourceAndRIsFromYaml(){
1809         String yamlName = "group.yml";
1810         Resource resource = createParseResourceObject(true);
1811         resource.setSystemName("SystemName");
1812         resource.setComponentType(ComponentTypeEnum.RESOURCE);
1813         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
1814         AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1815         boolean isNormative = true;
1816         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1817         String topologyTemplateYaml = getMainTemplateContent();
1818         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1819         CsarInfo csarInfo = getCsarInfo();
1820         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1821         boolean shouldLock = true;
1822         boolean inTransaction = true;
1823         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1824         when(serviceBusinessLogic.lockComponentByName(anyString(),any(),anyString()))
1825                 .thenReturn(Either.left(true));
1826
1827         try {
1828             sIB1.createResourceAndRIsFromYaml(yamlName,resource,parsedToscaYamlInfo,actionEnum,
1829                     isNormative,createdArtifacts,topologyTemplateYaml,nodeTypesInfo,csarInfo,
1830                     nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
1831         } catch (Exception e) {
1832             e.printStackTrace();
1833         }
1834     }
1835
1836     @Test
1837     public void testCreateResourceAndRIsFromYaml_False(){
1838         String yamlName = "group.yml";
1839         Resource resource = createParseResourceObject(false);
1840         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
1841         AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1842         boolean isNormative = true;
1843         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1844         String topologyTemplateYaml = getMainTemplateContent();
1845         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1846         CsarInfo csarInfo = getCsarInfo();
1847         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1848         boolean shouldLock = false;
1849         boolean inTransaction = false;
1850         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1851
1852         try {
1853             sIB1.createResourceAndRIsFromYaml(yamlName,resource,parsedToscaYamlInfo,actionEnum,
1854                     isNormative,createdArtifacts,topologyTemplateYaml,nodeTypesInfo,csarInfo,
1855                     nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
1856         } catch (Exception e) {
1857             e.printStackTrace();
1858         }
1859     }
1860
1861     @Test
1862     public void testCreateGroupsOnResource2() {
1863         Resource resource = createParseResourceObject(false);
1864         Map<String, GroupDefinition> groups = getGroups();
1865         when(serviceImportParseLogic.validateCyclicGroupsDependencies(any()))
1866                 .thenReturn(Either.left(true));
1867
1868         try {
1869             sIB1.createGroupsOnResource(resource, groups);
1870         } catch (Exception e) {
1871             e.printStackTrace();
1872         }
1873     }
1874
1875     @Test
1876     public void testCreateGroupsOnResource2_null() {
1877         Resource resource = createParseResourceObject(false);
1878         Map<String, GroupDefinition> groups = null;
1879
1880         Either<Resource, ResponseFormat> result = sIB1.createGroupsOnResource(resource, groups);
1881         assertEquals(result.left().value(),resource);
1882     }
1883
1884     @Test
1885     public void testUpdateGroupsMembersUsingResource2(){
1886         Resource resource = createParseResourceObject(true);
1887         Map<String, GroupDefinition> groups = null;
1888
1889         List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups,resource);
1890         for (GroupDefinition groupDefinition : groupDefinitions) {
1891             assertNull(groupDefinition);
1892         }
1893     }
1894
1895     @Test
1896     public void testUpdateGroupsMembersUsingResource_left2(){
1897         Resource resource = createParseResourceObject(true);
1898         Map<String, GroupDefinition> groups = getGroups();
1899         when(serviceImportParseLogic.validateCyclicGroupsDependencies(any()))
1900                 .thenReturn(Either.left(true));
1901
1902         List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, resource);
1903         for (GroupDefinition groupDefinition : groupDefinitions) {
1904             assertNotNull(groupDefinition);
1905         }
1906     }
1907
1908     @Test
1909     public void testUpdateGroupMembers(){
1910         Map<String, GroupDefinition> groups = new HashMap<>();
1911         GroupDefinition updatedGroupDefinition = new GroupDefinition();
1912         Resource component = createParseResourceObject(true);
1913         List<ComponentInstance> componentInstances = creatComponentInstances();
1914         String groupName = "tosca_simple_yaml_1_1";
1915         Map<String, String> members = new HashMap<>();
1916         members.put("zxjTestImportServiceAb",getGroupsYaml());
1917
1918         try {
1919             sIB1.updateGroupMembers(groups,updatedGroupDefinition,component,componentInstances,
1920                     groupName,members);
1921         } catch (Exception e) {
1922             e.printStackTrace();
1923         }
1924     }
1925
1926     @Test
1927     public void testUpdateGroupMembers_null(){
1928         Map<String, GroupDefinition> groups = new HashMap<>();
1929         GroupDefinition updatedGroupDefinition = new GroupDefinition();
1930         Resource component = createParseResourceObject(true);
1931         List<ComponentInstance> componentInstances = new ArrayList<>();
1932         String groupName = "tosca_simple_yaml_1_1";
1933         Map<String, String> members = new HashMap<>();
1934         members.put("zxjTestImportServiceAb",getGroupsYaml());
1935
1936         try {
1937             sIB1.updateGroupMembers(groups,updatedGroupDefinition,component,componentInstances,
1938                     groupName,members);
1939         } catch (Exception e) {
1940             e.printStackTrace();
1941         }
1942     }
1943
1944     @Test
1945     public void setCreateResourceTransaction(){
1946         Resource resource = createParseResourceObject(false);
1947         resource.setComponentType(ComponentTypeEnum.RESOURCE);
1948         boolean isNormative = true;
1949         when(toscaOperationFacade.validateComponentNameExists(anyString(),any(),any()))
1950                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1951
1952         try {
1953             sIB1.createResourceTransaction(resource,user,isNormative);
1954         } catch (Exception e) {
1955             e.printStackTrace();
1956         }
1957     }
1958
1959     @Test
1960     public void setCreateResourceTransaction_leftTrue() {
1961         Resource resource = createParseResourceObject(false);
1962         resource.setComponentType(ComponentTypeEnum.RESOURCE);
1963         boolean isNormative = true;
1964         when(toscaOperationFacade.validateComponentNameExists(anyString(),any(),any()))
1965                 .thenReturn(Either.left(true));
1966
1967         try {
1968             sIB1.createResourceTransaction(resource,user,isNormative);
1969         } catch (Exception e) {
1970             e.printStackTrace();
1971         }
1972     }
1973
1974     @Test
1975     public void setCreateResourceTransaction_Left() {
1976         Resource resource = createParseResourceObject(false);
1977         resource.setComponentType(ComponentTypeEnum.RESOURCE);
1978         when(toscaOperationFacade.validateComponentNameExists(anyString(),any(),any()))
1979                 .thenReturn(Either.left(false));
1980
1981         try {
1982             sIB1.createResourceTransaction(resource,user,false);
1983         } catch (Exception e) {
1984             e.printStackTrace();
1985         }
1986     }
1987
1988     @Test
1989     public void testUpdateExistingResourceByImport(){
1990         Resource newResource = createNewResource();
1991         Resource oldResource = createOldResource();
1992
1993         try {
1994             sIB1.updateExistingResourceByImport(newResource,oldResource,user,
1995                     true,true,true);
1996         } catch (Exception e) {
1997             e.printStackTrace();
1998         }
1999     }
2000
2001     @Test
2002     public void testCreateNewResourceToOldResource(){
2003         Resource newResource = createNewResource();
2004         Resource oldResource = createOldResource();
2005
2006         try {
2007             sIB1.createNewResourceToOldResource(newResource,oldResource,user);
2008         } catch (Exception e) {
2009             e.printStackTrace();
2010         }
2011     }
2012
2013     @Test
2014     public void testCreateResourcesFromYamlNodeTypesList(){
2015         String yamlName = "group.yml";
2016         Service service =createServiceObject(false);
2017         Map<String, Object> mappedToscaTemplate = new HashMap<>();
2018         boolean needLock = true;
2019         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2020         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2021         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2022         CsarInfo csarInfo = getCsarInfo();
2023
2024         try {
2025             sIB1.createResourcesFromYamlNodeTypesList(yamlName,service,mappedToscaTemplate,needLock,
2026                     nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,csarInfo);
2027         } catch (Exception e) {
2028             e.printStackTrace();
2029         }
2030     }
2031
2032     @Test
2033     public void testCreateNodeTypes(){
2034         String yamlName = "group.yml";
2035         Service service =createServiceObject(false);
2036         boolean needLock = true;
2037         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2038         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2039                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2040         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2041         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2042         artifactDefinition.setArtifactName("artifactName");
2043         artifactDefinitions.add(artifactDefinition);
2044         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2045                 artifactDefinitions);
2046         nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
2047         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2048         Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2049         CsarInfo csarInfo = getCsarInfo();
2050         Map<String, Object> mapToConvert =new HashMap<>();
2051         Map<String, Object> nodeTypes =new HashMap<>();
2052         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2053         nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
2054         nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
2055                 nodeTypeInfo);
2056
2057         try {
2058             sIB1.createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle,
2059                     nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
2060                     nodeTypes);
2061         } catch (Exception e) {
2062             e.printStackTrace();
2063         }
2064     }
2065
2066     @Test
2067     public void testCreateNodeTypesElse(){
2068         String yamlName = "group.yml";
2069         Service service =createServiceObject(false);
2070         boolean needLock = true;
2071         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
2072         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
2073                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
2074         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
2075         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2076         artifactDefinition.setArtifactName("artifactName");
2077         artifactDefinitions.add(artifactDefinition);
2078         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2079                 artifactDefinitions);
2080         nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
2081         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2082         Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
2083         CsarInfo csarInfo = getCsarInfo();
2084         Map<String, Object> mapToConvert =new HashMap<>();
2085         Map<String, Object> nodeTypes =new HashMap<>();
2086         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2087         nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
2088         nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb0.test",
2089                 nodeTypeInfo);
2090
2091         try {
2092             sIB1.createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle,
2093                     nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
2094                     nodeTypes);
2095         } catch (Exception e) {
2096             e.printStackTrace();
2097         }
2098     }
2099
2100     protected Resource createNewResource(){
2101         Resource newResource = createParseResourceObject(false);
2102         newResource.setVersion("1.0");
2103         newResource.setInvariantUUID("");
2104         newResource.setLifecycleState(null);
2105         newResource.setUUID("");
2106         newResource.setNormalizedName("");
2107         newResource.setSystemName("");
2108         newResource.setCsarUUID("");
2109         newResource.setImportedToscaChecksum("");
2110         newResource.setDerivedFromGenericType("");
2111         newResource.setDerivedFromGenericVersion("");
2112         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2113         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2114         artifactDefinition.setArtifactName("artifactDefinition");
2115         toscaArtifacts.put("toscaArtifactsMap",artifactDefinition);
2116         Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2117         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2118         interfaceDefinition.setOwnerId("OwnerId");
2119         interfaces.put("interfacesMap",interfaceDefinition);
2120         newResource.setInterfaces(interfaces);
2121         newResource.setToscaArtifacts(toscaArtifacts);
2122         newResource.setProperties(getProperties());
2123         return newResource;
2124     }
2125
2126     protected Resource createOldResource(){
2127         Resource newResource = createParseResourceObject(false);
2128         newResource.setVersion("1.0");
2129         newResource.setInvariantUUID("552e8f6c-340c-4fb4-8a82-fe7732fd8010");
2130         newResource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
2131         newResource.setUUID("13065b80-ca96-4331-b643-d28aeaf961cb");
2132         newResource.setNormalizedName("NormalizedName");
2133         newResource.setSystemName("default");
2134         newResource.setCsarUUID("CsarUUID");
2135         newResource.setImportedToscaChecksum("ImportedToscaChecksum");
2136         newResource.setDerivedFromGenericType("DerivedFromGenericType");
2137         newResource.setDerivedFromGenericVersion("0.1");
2138         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
2139         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2140         artifactDefinition.setArtifactName("tosca_simple_yaml_1_1");
2141         toscaArtifacts.put("tosca_definitions_version",artifactDefinition);
2142         Map<String, InterfaceDefinition> interfaces = new HashMap<>();
2143         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
2144         interfaceDefinition.setDescription("Invoked upon receipt of an Instantiate VNF request");
2145         interfaces.put("tosca_simple_yaml_1_1",interfaceDefinition);
2146         newResource.setInterfaces(interfaces);
2147         newResource.setToscaArtifacts(toscaArtifacts);
2148         List<PropertyDefinition> properties = new ArrayList<>();
2149         PropertyDefinition propertyDefinition = new PropertyDefinition();
2150         propertyDefinition.setName("tosca_simple_yaml_1_1");
2151         properties.add(propertyDefinition);
2152         newResource.setProperties(properties);
2153         return newResource;
2154     }
2155
2156     protected List<UploadPropInfo> getPropertyList() {
2157         List<UploadPropInfo> propertyList = new ArrayList<>();
2158         UploadPropInfo uploadPropInfo = new UploadPropInfo();
2159         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2160         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2161         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2162         get_input.add(getInputValueDataDefinition);
2163         uploadPropInfo.setName("propertiesName");
2164         uploadPropInfo.setValue("value");
2165         uploadPropInfo.setGet_input(get_input);
2166         propertyList.add(uploadPropInfo);
2167         return propertyList;
2168     }
2169
2170
2171     protected Map<String, NodeTypeInfo> getNodeTypesInfo(){
2172         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
2173         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
2174         Map<String, Object> mappedToscaTemplate = new HashMap<>();
2175         nodeTypeInfo.setNested(true);
2176         nodeTypeInfo.setTemplateFileName("templateFileName");
2177         nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
2178         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
2179         nodeTypesInfo.put(nodeName,nodeTypeInfo);
2180         return nodeTypesInfo;
2181     }
2182
2183     protected Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap(){
2184         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
2185         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
2186         Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
2187         capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
2188         Map<String, String> requirementsNamesToUpdate = new HashMap<>();
2189         requirementsNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
2190         uploadResInstancesMap.put("zxjTestImportServiceAb",uploadComponentInstanceInfo);
2191         return uploadResInstancesMap;
2192     }
2193
2194     protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties(){
2195         Map<String, List<UploadPropInfo>> properties = new HashMap<>();
2196         List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
2197         UploadPropInfo uploadPropInfo = new UploadPropInfo();
2198         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
2199         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
2200         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
2201         get_input.add(getInputValueDataDefinition);
2202         uploadPropInfo.setName("propertiesName");
2203         uploadPropInfo.setValue("value");
2204         uploadPropInfo.setGet_input(get_input);
2205         uploadPropInfoList.add(uploadPropInfo);
2206         properties.put("uploadComponentInstanceInfo",uploadPropInfoList);
2207         return properties;
2208     }
2209
2210     protected List<PropertyDefinition> getProperties(){
2211         List<PropertyDefinition> properties = new ArrayList<>();
2212         PropertyDefinition propertyDefinition = new PropertyDefinition();
2213         propertyDefinition.setName("propertiesName");
2214         properties.add(propertyDefinition);
2215         return properties;
2216     }
2217
2218     protected Map<String, List<UploadReqInfo>> gerRequirements(){
2219         Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
2220         String requirementName = "tosca.capabilities.Node";
2221         List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
2222         UploadReqInfo uploadReqInfo = new UploadReqInfo();
2223         uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
2224         uploadReqInfoMap.put(requirementName,uploadReqInfoList);
2225         return uploadReqInfoMap;
2226     }
2227
2228     protected ComponentParametersView createComponentParametersView() {
2229         ComponentParametersView parametersView = new ComponentParametersView();
2230         parametersView.disableAll();
2231         parametersView.setIgnoreComponentInstances(false);
2232         parametersView.setIgnoreComponentInstancesProperties(false);
2233         parametersView.setIgnoreCapabilities(false);
2234         parametersView.setIgnoreRequirements(false);
2235         parametersView.setIgnoreGroups(false);
2236         return parametersView;
2237     }
2238     protected Map<String, byte[]> crateCsarFromPayload() {
2239         String payloadName = "valid_vf.csar";
2240         String rootPath = System.getProperty("user.dir");
2241         Path path;
2242         byte[] data;
2243         String payloadData;
2244         Map<String, byte[]> returnValue = null;
2245         try {
2246             path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2247             data = Files.readAllBytes(path);
2248             payloadData = Base64.encodeBase64String(data);
2249             UploadResourceInfo resourceInfo = new UploadResourceInfo();
2250             resourceInfo.setPayloadName(payloadName);
2251             resourceInfo.setPayloadData(payloadData);
2252             Method privateMethod = null;
2253             privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
2254             privateMethod.setAccessible(true);
2255             returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
2256         } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
2257             e.printStackTrace();
2258         }
2259         return returnValue;
2260     }
2261
2262
2263     protected List<ComponentInstance> creatComponentInstances(){
2264         List<ComponentInstance> componentInstances = new ArrayList<>();
2265         ComponentInstance componentInstance = new ComponentInstance();
2266         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2267         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
2268         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
2269         capabilityDefinition.setName("mme_ipu_vdu.feature");
2270         capabilityDefinitionList.add(capabilityDefinition);
2271         capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
2272
2273         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2274         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2275         RequirementDefinition requirementDefinition = new RequirementDefinition();
2276         requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
2277         requirementDefinitionList.add(requirementDefinition);
2278         requirements.put("tosca.capabilities.Node",requirementDefinitionList);
2279         componentInstance.setRequirements(requirements);
2280         componentInstance.setCapabilities(capabilities);
2281         componentInstance.setUniqueId("uniqueId");
2282         componentInstance.setComponentUid("componentUid");
2283         componentInstance.setName("zxjTestImportServiceAb");
2284         componentInstances.add(componentInstance);
2285         return componentInstances;
2286     }
2287
2288     protected CreateServiceFromYamlParameter getCsfyp() {
2289         CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
2290         List<ArtifactDefinition> createdArtifacts =new ArrayList<>();
2291         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
2292
2293         csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
2294         csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
2295         csfyp.setCreatedArtifacts(createdArtifacts);
2296         csfyp.setInTransaction(true);
2297         csfyp.setShouldLock(true);
2298         csfyp.setCsarInfo(getCsarInfo());
2299         csfyp.setParsedToscaYamlInfo(getParsedToscaYamlInfo());
2300         csfyp.setNodeTypesInfo(nodeTypesInfo);
2301         csfyp.setYamlName("group.yml");
2302         return csfyp;
2303     }
2304
2305     protected ParsedToscaYamlInfo getParsedToscaYamlInfo(){
2306         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
2307         Map<String, InputDefinition> inputs = new HashMap<>();
2308         Map<String, UploadComponentInstanceInfo> instances=new HashMap<>();
2309         Map<String, GroupDefinition> groups=new HashMap<>();
2310         Map<String, PolicyDefinition> policies=new HashMap<>();
2311         parsedToscaYamlInfo.setGroups(groups);
2312         parsedToscaYamlInfo.setInputs(inputs);
2313         parsedToscaYamlInfo.setInstances(instances);
2314         parsedToscaYamlInfo.setPolicies(policies);
2315         return parsedToscaYamlInfo;
2316     }
2317
2318     String getMainTemplateContent(String fileName){
2319         String mainTemplateContent = null;
2320         try {
2321             mainTemplateContent = loadFileNameToJsonString(fileName);
2322         } catch (IOException e) {
2323             e.printStackTrace();
2324         }
2325         return mainTemplateContent;
2326     }
2327
2328     protected CsarInfo getCsarInfo ()
2329     {
2330         String csarUuid = "0010";
2331         User user = new User();
2332         Map<String, byte[]> csar = crateCsarFromPayload();
2333         String vfReousrceName = "resouceName";
2334         String mainTemplateName = "mainTemplateName";
2335         String mainTemplateContent = getMainTemplateContent("service_import_template.yml");
2336         CsarInfo csarInfo = new CsarInfo(user, csarUuid,  csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
2337         return csarInfo;
2338     }
2339
2340     public static String loadFileNameToJsonString(String fileName) throws IOException {
2341         String sourceDir = "src/test/resources/normativeTypes";
2342         return loadFileNameToJsonString(sourceDir, fileName);
2343     }
2344
2345     private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
2346         java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
2347         byte[] fileContent = Files.readAllBytes(filePath);
2348         return new String(fileContent);
2349     }
2350
2351
2352         protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo(){
2353         String artifactName = "artifactName",path = "/src/test/resources/valid_vf.csar",artifactType = "AAI_SERVICE_MODEL";
2354         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
2355         String rootPath = System.getProperty("user.dir");
2356         Path path2;
2357         byte[] data = new byte[0];
2358         path2 = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
2359         try {
2360             data = Files.readAllBytes(path2);
2361         } catch (IOException e) {
2362             e.printStackTrace();
2363         }
2364         String artifactUniqueId = "artifactUniqueId";
2365         boolean isFromCsar = true;
2366         CsarUtils.NonMetaArtifactInfo  nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
2367                 path,artifactType,artifactGroupType,data,artifactUniqueId,isFromCsar);
2368         return nonMetaArtifactInfo;
2369
2370     }
2371
2372     protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2373         ResponseFormat actualResponse = e.getResponseFormat() != null ?
2374                 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2375         assertParseResponse(actualResponse, expectedStatus, variables);
2376     }
2377
2378     private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2379         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2380         assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2381         assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
2382     }
2383 }