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