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
 126     }
 127
 128     @Test
 129     public void testGetComponentsUtils() {
 130         ComponentsUtils result;
 131         result = serviceImportBusinessLogic.getComponentsUtils();
 132     }
 133
 134     @Test
 135     public void testSetComponentsUtils() {
 136         ComponentsUtils componentsUtils = null;
 137
 138         serviceImportBusinessLogic.setComponentsUtils(componentsUtils);
 139     }
 140
 141     @Test
 142     public void testCreateService() {
 143         Service oldService = createServiceObject(false);
 144         String payloadName = "valid_vf";
 145         Map<String, byte[]> payload = crateCsarFromPayload();
 146         Service newService = createServiceObject(true);
 147         try {
 148             when(serviceBusinessLogic.validateServiceBeforeCreate(newService,user,AuditingActionEnum.CREATE_RESOURCE))
 149                     .thenReturn(Either.left(newService));
 150             when(toscaOperationFacade.validateCsarUuidUniqueness(payloadName)).thenReturn(StorageOperationStatus.OK);
 151             sIB1.createService(oldService, AuditingActionEnum.CREATE_RESOURCE, user, payload, payloadName);
 152         } catch (Exception e) {
 153             e.printStackTrace();
 154         }
 155     }
 156
 157     @Test
 158     public void testCreateServiceFromCsar(){
 159         Service oldService = createServiceObject(false);
 160         String csarUUID = "valid_vf";
 161         Map<String, byte[]> payload = crateCsarFromPayload();
 162         try {
 163             sIB1.createServiceFromCsar(oldService, user, payload, csarUUID);
 164         }catch (Exception e) {
 165             e.printStackTrace();
 166         }
 167     }
 168
 169     @Test
 170     public void testCreateServiceFromYaml(){
 171         Service oldService = createServiceObject(false);
 172         String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
 173         String yamlName = "group.yml";
 174         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
 175         CsarInfo csarInfo =getCsarInfo();
 176         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 177         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 178         try {
 179             sIB1.createServiceFromYaml(oldService,topologyTemplateYaml,yamlName,nodeTypesInfo,
 180                     csarInfo,nodeTypesArtifactsToCreate,true,true,nodeName);
 181         }catch (Exception e){
 182             e.printStackTrace();
 183         }
 184     }
 185
 186     @Test
 187     public void testCreateServiceAndRIsFromYaml(){
 188         Service oldService = createServiceObject(false);
 189         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 190         CreateServiceFromYamlParameter csfyp = getCsfyp();
 191         try {
 192             sIB1.createServiceAndRIsFromYaml(oldService,false,nodeTypesArtifactsToCreate,true,true,csfyp);
 193         }catch (Exception e){
 194             e.printStackTrace();
 195         }
 196     }
 197
 198     @Test
 199     public void testCreateOrUpdateArtifacts(){
 200         ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
 201         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 202         String yamlFileName = "group.yml";
 203         CsarInfo csarInfo =getCsarInfo();
 204         Resource preparedResource = createParseResourceObject(false);
 205         preparedResource.setResourceType(ResourceTypeEnum.VF);
 206         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 207         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle= new HashMap<>();
 208         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
 209                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 210         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
 211         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 212         artifactDefinition.setArtifactName("artifactName");
 213         artifactDefinitions.add(artifactDefinition);
 214         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
 215                 artifactDefinitions);
 216         nodeTypesArtifactsToHandle.put(nodeName,enumListEnumMap);
 217         NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,nodeTypesArtifactsToHandle);
 218         nodeTypeInfoToUpdateArtifacts.setNodeName(nodeName);
 219         nodeTypeInfoToUpdateArtifacts.setNodeTypesArtifactsToHandle(nodeTypesArtifactsToHandle);
 220
 221         try {
 222             sIB1.createOrUpdateArtifacts(operation,createdArtifacts,yamlFileName,csarInfo,
 223                     preparedResource,nodeTypeInfoToUpdateArtifacts,true,true);
 224         }catch (Exception e){
 225             e.printStackTrace();
 226         }
 227     }
 228
 229     @Test
 230     public void testHandleVfCsarArtifacts(){
 231         Resource resource = createParseResourceObject(false);
 232         CsarInfo csarInfo = getCsarInfo();
 233         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 234         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 235         try {
 236             sIB1.handleVfCsarArtifacts(resource,csarInfo,createdArtifacts,artifactOperation,true,true);
 237         } catch (Exception e) {
 238             e.printStackTrace();
 239         }
 240     }
 241
 242     @Test
 243     public void testCreateOrUpdateSingleNonMetaArtifactToComstants(){
 244         Resource resource = createParseResourceObject(false);
 245         CsarInfo csarInfo = getCsarInfo();
 246         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 247         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 248         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 249         artifactDefinition.setArtifactName("artifactDefinition");
 250         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 251         resource.setDeploymentArtifacts(deploymentArtifacts);
 252         try {
 253             sIB1.createOrUpdateSingleNonMetaArtifactToComstants(resource,csarInfo,artifactOperation,true,true);
 254         }catch (Exception e) {
 255             e.printStackTrace();
 256         }
 257     }
 258
 259
 260     @Test
 261     public void testCreateOrUpdateNonMetaArtifacts(){
 262         CsarInfo csarInfo = getCsarInfo();
 263         Resource resource = createParseResourceObject(false);
 264         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 265         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 266
 267         Either<Resource, ResponseFormat> result = sIB1.createOrUpdateNonMetaArtifacts(csarInfo, resource,
 268                 createdArtifacts, true, true, artifactOperation);
 269         assertEquals(result.left().value(),resource);
 270     }
 271
 272     @Test
 273     public void testFindVfCsarArtifactsToHandle(){
 274         Resource resource = createParseResourceObject(false);
 275         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 276         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 277         artifactDefinition.setArtifactName("artifactDefinition");
 278         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 279         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 280         artifacts.put("artifacts",artifactDefinition);
 281         List<GroupDefinition> groups = new ArrayList<>();
 282         GroupDefinition groupDefinition = new GroupDefinition();
 283         groupDefinition.setUniqueId("groupDefinitionUniqueId");
 284         groupDefinition.setName("groupDefinition");
 285         groups.add(groupDefinition);
 286         resource.setDeploymentArtifacts(deploymentArtifacts);
 287         resource.setArtifacts(artifacts);
 288         resource.setGroups(groups);
 289         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 290
 291         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
 292                 ResponseFormat> result = sIB1.findVfCsarArtifactsToHandle(resource,artifactPathAndNameList,user);
 293         assertNotNull(result.left().value());
 294     }
 295
 296
 297     @Test
 298     public void testIsNonMetaArtifact() {
 299         ArtifactDefinition artifactDefinition =new ArtifactDefinition();
 300         artifactDefinition.setMandatory(false);
 301         artifactDefinition.setArtifactName("creatorFullName");
 302         artifactDefinition.setArtifactType("TOSCA_CSAR");
 303
 304         boolean nonMetaArtifact = sIB1.isNonMetaArtifact(artifactDefinition);
 305         assertTrue(nonMetaArtifact);
 306
 307     }
 308
 309     @Test
 310     public void testOrganizeVfCsarArtifactsByArtifactOperation(){
 311         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 312         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 313         List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
 314         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 315         artifactDefinition.setArtifactName("artifactName");
 316         artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
 317         artifactDefinition.setArtifactChecksum("artifactChecksum");
 318         existingArtifactsToHandle.add(artifactDefinition);
 319         Resource resource = createParseResourceObject(false);
 320
 321         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
 322                 enumMapResponseFormatEither = sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifactsToHandle, resource, user);
 323         assertNotNull(enumMapResponseFormatEither.left().value());
 324     }
 325
 326     @Test
 327     public void testProcessCsarArtifacts(){
 328         CsarInfo csarInfo = getCsarInfo();
 329         Resource resource = createParseResourceObject(false);
 330         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 331         Either<Resource, ResponseFormat> resStatus = null;
 332         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 333         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 334         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
 335                 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 336         vfCsarArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,artifactPathAndNameList);
 337         Either<Resource, ResponseFormat> rrfe = sIB1.processCsarArtifacts(csarInfo,
 338                 resource, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle);
 339         assertNull(rrfe);
 340     }
 341
 342     @Test
 343     public void testCreateOrUpdateSingleNonMetaArtifact(){
 344         Resource resource = createParseResourceObject(false);
 345         CsarInfo csarInfo = getCsarInfo();
 346         Map<String, byte[]> csar = csarInfo.getCsar();
 347         String rootPath = System.getProperty("user.dir");
 348         Path path;
 349         byte[] data = new byte[0];
 350         path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
 351         try {
 352             data = Files.readAllBytes(path);
 353         } catch (IOException e) {
 354             e.printStackTrace();
 355         }
 356         csar.put("valid_vf.csar",data);
 357         String artifactPath = "valid_vf.csar", artifactFileName = "", artifactType = "";
 358         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
 359         String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
 360         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 361         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 362         try {
 363             sIB1.createOrUpdateSingleNonMetaArtifact(resource, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
 364                     artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
 365                     true, true, true);
 366         } catch (Exception e) {
 367             e.printStackTrace();
 368         }
 369     }
 370
 371     @Test
 372     public void testHandleNodeTypeArtifacts(){
 373         Resource nodeTypeResource = createParseResourceObject(false);
 374         ResourceMetadataDataDefinition componentMetadataDataDefinition = new ResourceMetadataDataDefinition();
 375         componentMetadataDataDefinition.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 376         ComponentMetadataDefinition componentMetadataDefinition = new ComponentMetadataDefinition(componentMetadataDataDefinition);
 377         nodeTypeResource.setComponentMetadataDefinition(componentMetadataDefinition);
 378         Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
 379         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
 380         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 381         artifactDefinition.setArtifactName("artifactName");
 382         artifactDefinitions.add(artifactDefinition);
 383         nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
 384                 artifactDefinitions);
 385
 386         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 387         try {
 388             sIB1.handleNodeTypeArtifacts(nodeTypeResource, nodeTypeArtifactsToHandle,
 389                     createdArtifacts, user, true, true);
 390         } catch (Exception e) {
 391             e.printStackTrace();
 392         }
 393     }
 394
 395
 396     @Test
 397     public void testCreateOrUpdateServiceArtifacts(){
 398         ArtifactsBusinessLogic.ArtifactOperationEnum operation = ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE;
 399         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 400         String yamlFileName = "group.yml";
 401         CsarInfo csarInfo =getCsarInfo();
 402         Service preparedService = createServiceObject(false);
 403         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 404         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 405         artifactDefinition.setArtifactName("artifactDefinition");
 406         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 407         preparedService.setDeploymentArtifacts(deploymentArtifacts);
 408         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 409         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle= new HashMap<>();
 410         NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,nodeTypesArtifactsToHandle);
 411
 412         try {
 413             sIB1.createOrUpdateArtifacts(operation,createdArtifacts,yamlFileName,csarInfo,
 414                     preparedService,nodeTypeInfoToUpdateArtifacts,true,true);
 415         } catch (Exception e) {
 416             e.printStackTrace();
 417         }
 418     }
 419
 420     @Test
 421     public void testHandleVfCsarServiceArtifacts(){
 422         Service service = createServiceObject(true);
 423         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 424         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 425         artifactDefinition.setArtifactName(Constants.VENDOR_LICENSE_MODEL);
 426         artifactDefinition.setUniqueId("uniqueId");
 427         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 428         service.setDeploymentArtifacts(deploymentArtifacts);
 429         CsarInfo csarInfo = getCsarInfo();
 430         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 431         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 432         try {
 433             sIB1.handleVfCsarArtifacts(service,csarInfo,createdArtifacts,artifactOperation,true,true);
 434         } catch (Exception e) {
 435             e.printStackTrace();
 436         }
 437     }
 438
 439     @Test
 440     public void testCreateOrUpdateNonMetaServiceArtifacts(){
 441         CsarInfo csarInfo = getCsarInfo();
 442         Service service = createServiceObject(true);
 443         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 444         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
 445
 446         Either<Service, ResponseFormat> result = sIB1.createOrUpdateNonMetaArtifacts(csarInfo,
 447                 service, createdArtifacts, true, true, artifactOperation);
 448         assertEquals(result.left().value(),service);
 449     }
 450
 451     @Test
 452     public void testFindServiceCsarArtifactsToHandle(){
 453         Service service = createServiceObject(true);
 454         Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
 455         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 456         artifactDefinition.setArtifactName("artifactDefinition");
 457         deploymentArtifacts.put("deploymentArtifacts",artifactDefinition);
 458         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 459         artifacts.put("artifacts",artifactDefinition);
 460         List<GroupDefinition> groups = new ArrayList<>();
 461         GroupDefinition groupDefinition = new GroupDefinition();
 462         groupDefinition.setUniqueId("groupDefinitionUniqueId");
 463         groupDefinition.setName("groupDefinition");
 464         groups.add(groupDefinition);
 465         service.setDeploymentArtifacts(deploymentArtifacts);
 466         service.setArtifacts(artifacts);
 467         service.setGroups(groups);
 468         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 469
 470         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>,
 471                 ResponseFormat> result = sIB1.findVfCsarArtifactsToHandle(service, artifactPathAndNameList, user);
 472         assertNotNull(result.left().value());
 473     }
 474
 475     @Test
 476     public void testOrganizeVfCsarArtifactsByServiceArtifactOperation(){
 477         List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = new ArrayList<>();
 478         artifactPathAndNameList.add(getNonMetaArtifactInfo());
 479         List<ArtifactDefinition> existingArtifactsToHandle = new ArrayList<>();
 480         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 481         artifactDefinition.setArtifactName("artifactName");
 482         artifactDefinition.setArtifactType(ArtifactTypeEnum.AAI_SERVICE_MODEL.name());
 483         artifactDefinition.setArtifactChecksum("artifactChecksum");
 484         existingArtifactsToHandle.add(artifactDefinition);
 485         Service service = createServiceObject(true);
 486
 487         Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
 488                 enumMapResponseFormatEither = sIB1.organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList,
 489                 existingArtifactsToHandle, service, user);
 490         assertNotNull(enumMapResponseFormatEither.left().value());
 491     }
 492
 493     @Test
 494     public void testProcessServiceCsarArtifacts(){
 495         CsarInfo csarInfo = getCsarInfo();
 496         Service service = createServiceObject(true);
 497         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 498         Either<Service, ResponseFormat> resStatus = null;
 499         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = new
 500                 EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 501         Either<Service, ResponseFormat> srfe = sIB1.processCsarArtifacts(csarInfo,
 502                 service, createdArtifacts, true, true, resStatus, vfCsarArtifactsToHandle);
 503         assertNull(srfe);
 504     }
 505
 506     @Test
 507     public void testGetValidArtifactNames(){
 508         CsarInfo csarInfo = getCsarInfo();
 509         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
 510         Either<List<CsarUtils.NonMetaArtifactInfo>, String> result = sIB1.getValidArtifactNames(csarInfo, collectedWarningMessages);
 511         System.out.println(result.left().value());
 512         assertNotNull(result.left().value());
 513     }
 514
 515     @Test
 516     public void testCreateOrUpdateSingleNonMetaServiceArtifact(){
 517         Service service = createServiceObject(true);
 518         CsarInfo csarInfo = getCsarInfo();
 519         String rootPath = System.getProperty("user.dir");
 520         Path path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
 521         String artifactPath = path.toString(), artifactFileName = "", artifactType = "";
 522         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
 523         String artifactLabel = "", artifactDisplayName = "", artifactDescription = "", artifactId = "artifactId";
 524         ArtifactOperationInfo artifactOperation = new ArtifactOperationInfo(true,true, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE);
 525         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 526         try {
 527             sIB1.createOrUpdateSingleNonMetaArtifact(service, csarInfo, artifactPath, artifactFileName, artifactType, artifactGroupType,
 528                     artifactLabel, artifactDisplayName, artifactDescription, artifactId, artifactOperation, createdArtifacts,
 529                     true, true, true);
 530         } catch (Exception e) {
 531             e.printStackTrace();
 532         }
 533     }
 534
 535     @Test
 536     public void testCreateGroupsOnResource(){
 537         Service service = createServiceObject(true);
 538         Map<String, GroupDefinition> groups = getGroups();
 539
 540         try {
 541             Either<Service, ResponseFormat> result = sIB1.createGroupsOnResource(service, groups);
 542         } catch (Exception e) {
 543             e.printStackTrace();
 544         }
 545     }
 546
 547     @Test
 548     public void testUpdateGroupsMembersUsingResource(){
 549         Service service = createServiceObject(true);
 550         Map<String, GroupDefinition> groups = null;
 551
 552         List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups, service);
 553         for (GroupDefinition groupDefinition : groupDefinitions) {
 554             assertNull(groupDefinition);
 555         }
 556     }
 557
 558     @Test
 559     public void testCreateRIAndRelationsFromResourceYaml(){
 560         String yamlName = "group.yml";
 561         Resource resource = createParseResourceObject(true);
 562         Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
 563         String topologyTemplateYaml = getMainTemplateContent();
 564         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 565         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 566         CsarInfo csarInfo = getCsarInfo();
 567         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 568         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 569
 570         try {
 571             sIB1.createRIAndRelationsFromYaml(yamlName,resource,uploadComponentInstanceInfoMap,topologyTemplateYaml,nodeTypesNewCreatedArtifacts,
 572                     nodeTypesInfo,csarInfo,nodeTypesArtifactsToCreate,nodeName);
 573         } catch (Exception e) {
 574             e.printStackTrace();
 575         }
 576     }
 577
 578
 579     @Test
 580     public void testCreateResourceInstancesRelations(){
 581         String yamlName = "group.yml";
 582         Resource resource = createParseResourceObject(true);
 583         resource.setComponentInstances(creatComponentInstances());
 584         resource.setResourceType(ResourceTypeEnum.VF);
 585         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 586         uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
 587
 588         try {
 589             sIB1.createResourceInstancesRelations(user,yamlName,resource,uploadResInstancesMap);
 590         } catch (Exception e) {
 591             e.printStackTrace();
 592         }
 593     }
 594
 595     @Test
 596     public void testProcessComponentInstance1(){
 597         String yamlName = "group.yml";
 598         Resource resource = createParseResourceObject(true);
 599         Resource originResource = createParseResourceObject(false);
 600         List<ComponentInstance> componentInstancesList = creatComponentInstances();
 601         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
 602         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
 603         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
 604         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
 605         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
 606         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
 607         Map<String, List< AttributeDataDefinition >> instAttributes = new HashMap<>();
 608         Map<String, Resource> originCompMap = new HashMap<>();
 609         originCompMap.put("componentUid",originResource);
 610         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 611         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 612         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
 613
 614         try {
 615             sIB1.processComponentInstance(yamlName, resource, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
 616                     instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
 617         } catch (Exception e) {
 618             e.printStackTrace();
 619         }
 620     }
 621
 622     @Test
 623     public void testAddInputsValuesToRi(){
 624         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 625         Map<String, List<UploadPropInfo>> properties = new HashMap<>();
 626         List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
 627         UploadPropInfo uploadPropInfo = new UploadPropInfo();
 628         uploadPropInfo.setName("uploadPropInfo");
 629         uploadPropInfoList.add(uploadPropInfo);
 630         uploadPropInfoList.add(uploadPropInfo);
 631         properties.put("propertiesMap",uploadPropInfoList);
 632         uploadComponentInstanceInfo.setProperties(properties);
 633         Resource resource = createParseResourceObject(true);
 634         Resource originResource =createParseResourceObject(false);
 635         List<InputDefinition> inputs = new ArrayList<>();
 636         InputDefinition inputDefinition = new InputDefinition();
 637         inputDefinition.setUniqueId("uniqueId");
 638         inputs.add(inputDefinition);
 639         originResource.setInputs(inputs);
 640         ComponentInstance currentCompInstance = new ComponentInstance();
 641         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 642         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 643
 644         try {
 645             sIB1.addInputsValuesToRi(uploadComponentInstanceInfo,resource,originResource,
 646                     currentCompInstance,instInputs,allDataTypes);
 647         } catch (Exception e) {
 648             e.printStackTrace();
 649         }
 650     }
 651
 652     @Test
 653     public void testProcessProperty(){
 654         Resource resource = createParseResourceObject(true);
 655         List<InputDefinition> inputs = new ArrayList<>();
 656         InputDefinition inputDefinition = new InputDefinition();
 657         inputDefinition.setUniqueId("uniqueId");
 658         inputs.add(inputDefinition);
 659         resource.setInputs(inputs);
 660         ComponentInstance currentCompInstance = null;
 661         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 662         Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
 663         inputDefinition.setType("inputDefinitionType");
 664         currPropertiesMap.put("propertyInfoName",inputDefinition);
 665         List<ComponentInstanceInput> instPropList = new ArrayList<>();
 666         List<UploadPropInfo> propertyList = getPropertyList();
 667
 668         try {
 669             sIB1.processProperty(resource, currentCompInstance, allDataTypes,
 670                     currPropertiesMap, instPropList, propertyList);
 671         } catch (Exception e) {
 672             e.printStackTrace();
 673         }
 674     }
 675
 676     @Test
 677     public void testHandleSubstitutionMappings(){
 678         Resource resource = createParseResourceObject(true);
 679         resource.setResourceType(ResourceTypeEnum.VF);
 680         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 681
 682         try {
 683             sIB1.handleSubstitutionMappings(resource, uploadResInstancesMap);
 684         } catch (Exception e) {
 685             e.printStackTrace();
 686         }
 687     }
 688
 689     @Test
 690     public void testCreateResourceInstances(){
 691         String yamlName = "group.yml";
 692         Resource resource = createParseResourceObject(true);
 693         Resource originResource = createParseResourceObject(false);
 694         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 695         UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
 696         nodesInfoValue.setName("zxjTestImportServiceAb");
 697         nodesInfoValue.setRequirements(gerRequirements());
 698         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
 699         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
 700         nodeNamespaceMap.put("resources",originResource);
 701
 702         try {
 703             sIB1.createResourceInstances(yamlName,resource,uploadResInstancesMap,nodeNamespaceMap);
 704         } catch (Exception e) {
 705             e.printStackTrace();
 706         }
 707     }
 708
 709     @Test
 710     public void testHandleNodeTypes(){
 711         String yamlName = "group.yml";
 712         Resource resource = createParseResourceObject(true);
 713         String topologyTemplateYaml = getMainTemplateContent();
 714         boolean needLock = true;
 715         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 716         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 717         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 718         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
 719         nodeTypeInfo.setNested(false);
 720         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 721         nodeTypesInfo.put(nodeName,nodeTypeInfo);
 722         CsarInfo csarInfo = getCsarInfo();
 723
 724         try {
 725             sIB1.handleNodeTypes(yamlName,resource,topologyTemplateYaml,needLock,
 726                     nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,
 727                     csarInfo,nodeName);
 728         } catch (Exception e) {
 729             e.printStackTrace();
 730         }
 731     }
 732
 733     @Test
 734     public void testHandleNestedVfc1(){
 735         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 736         Resource resource = createParseResourceObject(false);
 737         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 738         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 739         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
 740         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
 741         nodeTypeInfo.setTemplateFileName("groups.yml");
 742         nodeTypeInfo.setMappedToscaTemplate(new HashMap<>());
 743         nodesInfo.put(nodeName,nodeTypeInfo);
 744         CsarInfo csarInfo = getCsarInfo();
 745
 746         try {
 747             sIB1.handleNestedVfc(resource,nodeTypesArtifactsToHandle,createdArtifacts,
 748                     nodesInfo,csarInfo,nodeName);
 749         } catch (Exception e) {
 750             e.printStackTrace();
 751         }
 752     }
 753
 754     @Test
 755     public void testHandleComplexVfc1(){
 756         Resource resource = createParseResourceObject(true);
 757         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 758         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
 759         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
 760         CsarInfo csarInfo = getCsarInfo();
 761         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 762         String yamlName = "group.yml";
 763
 764         try {
 765             sIB1.handleComplexVfc(resource,nodeTypesArtifactsToHandle,createdArtifacts,
 766                     nodesInfo,csarInfo,nodeName,yamlName);
 767         } catch (Exception e) {
 768             e.printStackTrace();
 769         }
 770     }
 771
 772     @Test
 773     public void testCreateResourcesFromYamlNodeTypesList1(){
 774         String yamlName = "group.yml";
 775         Resource resource = createParseResourceObject(false);
 776         Map<String, Object> mappedToscaTemplate = new HashMap<>();
 777         boolean needLock = true;
 778         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 779         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 780         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 781         CsarInfo csarInfo = getCsarInfo();
 782
 783         try {
 784             sIB1.createResourcesFromYamlNodeTypesList(yamlName,resource,mappedToscaTemplate,
 785                     needLock, nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,
 786                     nodeTypesInfo,csarInfo);
 787         } catch (Exception e) {
 788             e.printStackTrace();
 789         }
 790     }
 791
 792     @Test
 793     public void testCreateNodeTypes1(){
 794         String yamlName = "group.yml";
 795         Resource resource = createParseResourceObject(false);
 796         boolean needLock = true;
 797         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 798         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
 799                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
 800         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
 801         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 802         artifactDefinition.setArtifactName("artifactName");
 803         artifactDefinitions.add(artifactDefinition);
 804         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
 805                 artifactDefinitions);
 806         nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);
 807         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 808         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 809         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
 810         nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
 811         CsarInfo csarInfo = getCsarInfo();
 812         Map<String, Object> mapToConvert =new HashMap<>();
 813         Map<String, Object> nodeTypes =new HashMap<>();
 814         nodeTypes.put("nodeTyp",nodeTypeInfo);
 815
 816         try {
 817             sIB1.createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle,
 818                     nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
 819                     nodeTypes);
 820         } catch (Exception e) {
 821             e.printStackTrace();
 822         }
 823     }
 824
 825     @Test
 826     public void testCreateNodeTypeResourceFromYaml(){
 827         String yamlName = "group.yml";
 828         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 829         Map<String,Object> nodeMap = new HashMap<>();
 830         nodeMap.put(nodeName,getGroupsYaml());
 831         Map.Entry<String, Object> nodeNameValue = nodeMap.entrySet().iterator().next();
 832         Map<String, Object> mapToConvert = new HashedMap();
 833         Resource resourceVf = createParseResourceObject(false);
 834         boolean needLock = true;
 835         Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = new HashMap<>();
 836         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 837         boolean forceCertificationAllowed = true;
 838         CsarInfo csarInfo = getCsarInfo();
 839         boolean isNested = true;
 840
 841         try {
 842             sIB1.createNodeTypeResourceFromYaml(yamlName,nodeNameValue,user,mapToConvert,resourceVf,
 843                     needLock,nodeTypeArtifactsToHandle,nodeTypesNewCreatedArtifacts,
 844                     forceCertificationAllowed,csarInfo,isNested);
 845         } catch (Exception e) {
 846             e.printStackTrace();
 847         }
 848     }
 849
 850     @Test
 851     public void testCreateRIAndRelationsFromYaml(){
 852         String yamlName = "group.yml";
 853         Service service = createServiceObject(true);
 854         Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = new HashMap<>();
 855         String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
 856         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
 857         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
 858         CsarInfo csarInfo = getCsarInfo();
 859         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
 860         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 861         try {
 862             sIB1.createRIAndRelationsFromYaml(yamlName,service,uploadComponentInstanceInfoMap,topologyTemplateYaml,nodeTypesNewCreatedArtifacts,
 863                     nodeTypesInfo,csarInfo,nodeTypesArtifactsToCreate,nodeName);
 864         } catch (Exception e) {
 865             e.printStackTrace();
 866         }
 867     }
 868
 869     @Test
 870     public void testCreateServiceInstancesRelations(){
 871         String yamlName = "group.yml";
 872         Service service = createServiceObject(true);
 873         service.setComponentInstances(creatComponentInstances());
 874         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
 875         uploadResInstancesMap.put("uploadResInstancesMap",getuploadComponentInstanceInfo());
 876
 877         try {
 878             sIB1.createServiceInstancesRelations(user, yamlName, service, uploadResInstancesMap);
 879         } catch (Exception e) {
 880             e.printStackTrace();
 881         }
 882     }
 883
 884     @Test
 885     public void testProcessComponentInstance(){
 886         String yamlName = "group.yml";
 887         Service service = createServiceObject(true);
 888         Resource originResource = createParseResourceObject(false);
 889         List<ComponentInstance> componentInstancesList = creatComponentInstances();
 890         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
 891         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
 892         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
 893         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
 894         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
 895         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
 896         Map<String, List< AttributeDataDefinition >> instAttributes = new HashMap<>();
 897         Map<String, Resource> originCompMap = new HashMap<>();
 898         originCompMap.put("componentUid",originResource);
 899         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 900         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 901         uploadComponentInstanceInfo.setName("zxjTestImportServiceAb");
 902
 903         try {
 904             sIB1.processComponentInstance(yamlName, service, componentInstancesList,allDataTypes,instProperties,instCapabilties,instRequirements,
 905                     instDeploymentArtifacts,instArtifacts,instAttributes,originCompMap,instInputs,uploadComponentInstanceInfo);
 906         } catch (Exception e) {
 907             e.printStackTrace();
 908         }
 909     }
 910
 911     @Test
 912     public void testAddInputsValuesToRi2(){
 913         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 914         Map<String, List<UploadPropInfo>> properties = new HashMap<>();
 915         List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
 916         UploadPropInfo uploadPropInfo = new UploadPropInfo();
 917         uploadPropInfo.setName("uploadPropInfo");
 918         uploadPropInfoList.add(uploadPropInfo);
 919         uploadPropInfoList.add(uploadPropInfo);
 920         properties.put("propertiesMap",uploadPropInfoList);
 921         uploadComponentInstanceInfo.setProperties(properties);
 922         Service resource = createServiceObject(true);
 923         Resource originResource =createParseResourceObject(false);
 924         List<InputDefinition> inputs = new ArrayList<>();
 925         InputDefinition inputDefinition = new InputDefinition();
 926         inputDefinition.setUniqueId("uniqueId");
 927         inputs.add(inputDefinition);
 928         originResource.setInputs(inputs);
 929         ComponentInstance currentCompInstance = new ComponentInstance();
 930         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
 931         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 932
 933         try {
 934             sIB1.addInputsValuesToRi(uploadComponentInstanceInfo,resource,originResource,
 935                         currentCompInstance,instInputs,allDataTypes);
 936         } catch (Exception e) {
 937             e.printStackTrace();
 938         }
 939     }
 940
 941     @Test
 942     public void testProcessProperty2(){
 943         Service resource = createServiceObject(true);
 944         ComponentInstance currentCompInstance = null;
 945         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 946         Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
 947         InputDefinition inputDefinition = new InputDefinition();
 948         inputDefinition.setType("inputDefinitionType");
 949         currPropertiesMap.put("propertyInfoName",inputDefinition);
 950         List<ComponentInstanceInput> instPropList = new ArrayList<>();
 951         List<UploadPropInfo> propertyList = new ArrayList<>();
 952         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
 953         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
 954         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
 955         get_input.add(getInputValueDataDefinition);
 956         UploadPropInfo propertyInfo = new UploadPropInfo();
 957         propertyInfo.setValue("value");
 958         propertyInfo.setGet_input(get_input);
 959         propertyInfo.setName("propertyInfoName");
 960         propertyList.add(propertyInfo);
 961
 962         try {
 963             sIB1.processProperty(resource, currentCompInstance, allDataTypes,
 964                     currPropertiesMap, instPropList, propertyList);
 965         } catch (Exception e) {
 966             e.printStackTrace();
 967         }
 968     }
 969
 970     @Test
 971     public void testProcessGetInput(){
 972         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
 973         List<InputDefinition> inputs = new ArrayList<>();
 974         GetInputValueDataDefinition getInputIndex = new GetInputValueDataDefinition();
 975
 976         try {
 977             sIB1.processGetInput(getInputValues,inputs,getInputIndex);
 978         } catch (Exception e) {
 979             e.printStackTrace();
 980         }
 981     }
 982
 983     @Test
 984     public void testAddPropertyValuesToRi(){
 985         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 986         uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
 987         Resource resource = createParseResourceObject(true);
 988         Resource originResource = createParseResourceObject(false);
 989         originResource.setProperties(getProperties());
 990         ComponentInstance currentCompInstance = new ComponentInstance();
 991         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
 992         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
 993         try {
 994             sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance,
 995                     instProperties, allDataTypes);
 996         } catch (Exception e) {
 997             e.printStackTrace();
 998         }
 999     }
1000
1001     @Test
1002     public void testAddPropertyValuesToRi2(){
1003         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1004         uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());
1005         Service service = createServiceObject(false);
1006         Resource originResource = createParseResourceObject(false);
1007         originResource.setProperties(getProperties());
1008         ComponentInstance currentCompInstance = new ComponentInstance();
1009         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1010         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1011
1012         try {
1013             sIB1.addPropertyValuesToRi(uploadComponentInstanceInfo, service, originResource, currentCompInstance,
1014                     instProperties, allDataTypes);
1015         } catch (Exception e) {
1016             e.printStackTrace();
1017         }
1018     }
1019
1020     @Test
1021     public void testProcessComponentInstanceCapabilities(){
1022         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1023         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties = new HashMap<>();
1024         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1025         uploadComponentInstanceInfo.setProperties(getUploadPropInfoProperties());        Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1026         uploadComponentInstanceInfo.setProperties(properties);
1027         ComponentInstance currentCompInstance = new ComponentInstance();
1028         Resource originResource = createParseResourceObject(false);
1029
1030         sIB1.processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
1031                 currentCompInstance, originResource);
1032     }
1033
1034     @Test
1035     public void testUpdateCapabilityPropertiesValues(){
1036         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = null;
1037         Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1038         Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1039
1040         sIB1.updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
1041     }
1042
1043     @Test
1044     public void testUpdatePropertyValues(){
1045         List<ComponentInstanceProperty> properties = new ArrayList<>();
1046         Map<String, UploadPropInfo> newProperties = new HashMap<>();
1047         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1048
1049         sIB1.updatePropertyValues(properties,newProperties,allDataTypes);
1050     }
1051
1052     @Test
1053     public void testUpdatePropertyValue(){
1054         ComponentInstanceProperty property = new ComponentInstanceProperty();
1055         property.setType("services");
1056         UploadPropInfo propertyInfo = new UploadPropInfo();
1057         propertyInfo.setValue("value");
1058         Map<String, DataTypeDefinition> allDataTypes = new HashMap<>();
1059
1060         try {
1061             sIB1.updatePropertyValue(property,propertyInfo,allDataTypes);
1062         } catch (Exception e) {
1063             e.printStackTrace();
1064         }
1065     }
1066
1067     @Test
1068     public void testGetOriginResource(){
1069         String yamlName = "group.yml";
1070         Map<String, Resource> originCompMap = new HashMap<>();
1071         ComponentInstance currentCompInstance = new ComponentInstance();
1072         currentCompInstance.setComponentUid("currentCompInstance");
1073
1074         try {
1075             sIB1.getOriginResource(yamlName,originCompMap,currentCompInstance);
1076         } catch (Exception e) {
1077             e.printStackTrace();
1078         }
1079     }
1080
1081     @Test
1082     public void testHandleSubstitutionMappings2(){
1083         Service service = createServiceObject(false);
1084         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1085
1086         sIB1.handleSubstitutionMappings(service, uploadResInstancesMap);
1087     }
1088
1089     @Test
1090     public void testUpdateCalculatedCapReqWithSubstitutionMappings(){
1091         Resource resource = createParseResourceObject(false);
1092         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1093
1094         when(toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(any())).thenReturn(StorageOperationStatus.OK);
1095
1096         try {
1097             sIB1.updateCalculatedCapReqWithSubstitutionMappings(resource,uploadResInstancesMap);
1098         } catch (Exception e) {
1099
1100         }
1101     }
1102
1103     @Test
1104     public void testFillUpdatedInstCapabilitiesRequirements(){
1105         List<ComponentInstance> componentInstances = creatComponentInstances();
1106         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = getUploadResInstancesMap();
1107         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1108         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirement = new HashMap<>();
1109
1110         sIB1.fillUpdatedInstCapabilitiesRequirements(componentInstances,uploadResInstancesMap,
1111                 updatedInstCapabilities,updatedInstRequirement);
1112     }
1113
1114     @Test
1115     public void testFillUpdatedInstCapabilities(){
1116         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties = new HashMap<>();
1117         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1118         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1119         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1120         capabilityDefinition.setName("mme_ipu_vdu.feature");
1121         capabilityDefinitionList.add(capabilityDefinition);
1122         capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
1123         ComponentInstance instance = new ComponentInstance();
1124         instance.setCapabilities(capabilities);
1125         Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1126         capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
1127
1128         sIB1.fillUpdatedInstCapabilities(updatedInstCapabilties,instance,capabilitiesNamesToUpdate);
1129     }
1130
1131     @Test
1132     public void testFillUpdatedInstRequirements(){
1133         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new
1134                 HashMap<>();
1135         ComponentInstance instance = new ComponentInstance();
1136         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1137         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1138         RequirementDefinition requirementDefinition = new RequirementDefinition();
1139         requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1140         requirementDefinitionList.add(requirementDefinition);
1141         requirements.put("tosca.capabilities.Node",requirementDefinitionList);
1142         instance.setRequirements(requirements);
1143         Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1144         requirementsNamesToUpdate.put("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test",
1145                 "requirementsNamesToUpdate");
1146
1147
1148         sIB1.fillUpdatedInstRequirements(updatedInstRequirements,instance,requirementsNamesToUpdate);
1149     }
1150
1151     @Test
1152     public void testAddRelationsToRI(){
1153         String yamlName = "group.yml";
1154         Service service = createServiceObject(false);
1155         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1156         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1157         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1158         List<ComponentInstance> componentInstancesList = creatComponentInstances();
1159         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1160
1161         try {
1162             sIB1.addRelationsToRI(yamlName,service,uploadResInstancesMap,componentInstancesList,
1163                     relations);
1164         } catch (Exception e) {
1165             e.printStackTrace();
1166         }
1167     }
1168
1169     @Test
1170     public void testAddRelationToRI(){
1171         String yamlName = "group.yml";
1172         Service service = createServiceObject(false);
1173         service.setComponentInstances(creatComponentInstances());
1174
1175         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1176         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1177
1178         try {
1179             sIB1.addRelationToRI(yamlName,service,nodesInfoValue,relations);
1180         } catch (Exception e) {
1181             e.printStackTrace();
1182         }
1183     }
1184
1185     @Test
1186     public void testGetResourceAfterCreateRelations(){
1187         Service service = createServiceObject(false);
1188         ComponentParametersView componentParametersView = createComponentParametersView();
1189         when(serviceImportParseLogic.getComponentFilterAfterCreateRelations()).thenReturn(componentParametersView);
1190         try {
1191             sIB1.getResourceAfterCreateRelations(service);
1192         } catch (Exception e) {
1193             e.printStackTrace();
1194         }
1195     }
1196
1197     @Test
1198     public void testCreateServiceInstances(){
1199         String yamlName = "group.yml";
1200         Service service = createServiceObject(false);
1201         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1202         UploadComponentInstanceInfo nodesInfoValue = getuploadComponentInstanceInfo();
1203         uploadResInstancesMap.put("uploadResInstancesMap",nodesInfoValue);
1204         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1205         Resource resource = createParseResourceObject(true);
1206         resource.setToscaResourceName("toscaResourceName");
1207         nodeNamespaceMap.put("nodeNamespaceMap",resource);
1208
1209         try {
1210             sIB1.createServiceInstances(yamlName,service,uploadResInstancesMap,nodeNamespaceMap);
1211         } catch (Exception e) {
1212            e.printStackTrace();
1213         }
1214     }
1215
1216     @Test
1217     public void testCreateAndAddResourceInstance(){
1218         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1219         String yamlName = "group.yml";
1220         Resource resource = createParseResourceObject(false);
1221         Resource originResource = createParseResourceObject(true);
1222         originResource.setResourceType(ResourceTypeEnum.VF);
1223         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1224         nodeNamespaceMap.put("resources",originResource);
1225         Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1226         Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1227
1228         try {
1229             sIB1.createAndAddResourceInstance(uploadComponentInstanceInfo,yamlName,resource,nodeNamespaceMap,
1230                     existingnodeTypeMap,resourcesInstancesMap);
1231         } catch (Exception e) {
1232             e.printStackTrace();
1233         }
1234     }
1235
1236     @Test
1237     public void testCreateAndAddResourceInstances(){
1238         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1239         String yamlName = "group.yml";
1240         Service service = createServiceObject(false);
1241         service.setServiceType("services");
1242         Resource originResource = createParseResourceObject(true);
1243         originResource.setResourceType(ResourceTypeEnum.VF);
1244         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1245         nodeNamespaceMap.put("resources", originResource);
1246         Map<String, Resource> existingnodeTypeMap = new HashMap<>();
1247         Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1248
1249         try {
1250             sIB1.createAndAddResourceInstance(uploadComponentInstanceInfo, yamlName, service, nodeNamespaceMap,
1251                     existingnodeTypeMap, resourcesInstancesMap);
1252         } catch (Exception e) {
1253             e.printStackTrace();
1254         }
1255     }
1256
1257     @Test
1258     public void testValidateResourceInstanceBeforeCreate(){
1259         String yamlName = "group.yml";
1260         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1261         Resource originResource = createParseResourceObject(true);
1262         originResource.setResourceType(ResourceTypeEnum.VF);
1263         Map<String, Resource> nodeNamespaceMap = new HashMap<>();
1264         nodeNamespaceMap.put("resources", originResource);
1265
1266         try {
1267             sIB1.validateResourceInstanceBeforeCreate(yamlName,uploadComponentInstanceInfo,nodeNamespaceMap);
1268         } catch (Exception e) {
1269             e.printStackTrace();
1270         }
1271     }
1272
1273     @Test
1274     public void testHandleServiceNodeTypes(){
1275         String yamlName = "group.yml";
1276         Service service =createServiceObject(false);
1277         String topologyTemplateYaml = getMainTemplateContent("service_import_template.yml");;
1278         boolean needLock = true;
1279         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1280         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1281         Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1282         CsarInfo csarInfo = getCsarInfo();
1283         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1284
1285         try {
1286             sIB1.handleServiceNodeTypes(yamlName,service,topologyTemplateYaml,needLock,
1287                     nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,
1288                     csarInfo,nodeName);
1289         } catch (Exception e) {
1290             e.printStackTrace();
1291         }
1292     }
1293
1294     @Test
1295     public void testValidateResourceNotExisted(){
1296         String type = "org.openecomp.resource.vf";
1297         boolean b = false;
1298         try {
1299             b = sIB1.validateResourceNotExisted(type);
1300         } catch (Exception e) {
1301             e.printStackTrace();
1302         }
1303     }
1304
1305     @Test
1306     public void testHandleNestedVF(){
1307         Service service =createServiceObject(false);
1308         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1309         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1310         Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1311         CsarInfo csarInfo = getCsarInfo();
1312         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1313
1314         try {
1315             sIB1.handleNestedVF(service,nodeTypesArtifactsToHandle,createdArtifacts,
1316                     nodesInfo,csarInfo,nodeName);
1317         } catch (Exception e) {
1318             e.printStackTrace();
1319         }
1320     }
1321
1322     @Test
1323     public void testHandleNestedVfc(){
1324         Service service =createServiceObject(false);
1325         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1326         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1327         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1328         CsarInfo csarInfo = getCsarInfo();
1329         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1330
1331         try {
1332             sIB1.handleNestedVfc(service,nodeTypesArtifactsToHandle,createdArtifacts,
1333                     nodesInfo,csarInfo,nodeName);
1334         } catch (Exception e) {
1335             e.printStackTrace();
1336         }
1337     }
1338
1339     @Test
1340     public void testHandleComplexVfc(){
1341         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1342         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1343         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1344         CsarInfo csarInfo = getCsarInfo();
1345         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1346         String yamlName = "group.yml";
1347
1348         try {
1349             sIB1.handleComplexVfc(nodeTypesArtifactsToHandle,createdArtifacts,
1350                     nodesInfo,csarInfo,nodeName,yamlName);
1351         } catch (Exception e) {
1352             e.printStackTrace();
1353         }
1354     }
1355
1356
1357     @Test
1358     public void testHandleComplexVfc2(){
1359         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1360         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1361         Map<String, NodeTypeInfo> nodesInfo = getNodeTypesInfo();
1362         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1363         String yamlName = "group.yml";
1364         CsarInfo csarInfo = getCsarInfo();
1365         Map<String, byte[]> csar = new HashMap<>();
1366         csar.put(yamlName,yamlName.getBytes());
1367         csarInfo.setCsar(csar);
1368         Resource oldComplexVfc = createParseResourceObject(false);
1369         Resource newComplexVfc = createParseResourceObject(true);
1370
1371         try {
1372             sIB1.handleComplexVfc(nodeTypesArtifactsToHandle,createdArtifacts,nodesInfo,
1373                     csarInfo,nodeName,yamlName,oldComplexVfc,newComplexVfc);
1374         } catch (Exception e) {
1375             e.printStackTrace();
1376         }
1377     }
1378
1379     @Test
1380     public void testUpdateResourceFromYaml(){
1381         Resource oldRresource = createParseResourceObject(false);
1382         Resource newRresource = createParseResourceObject(true);
1383         AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1384         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1385         String yamlFileName = "group.yml";
1386         String yamlFileContent = getYamlFileContent();
1387         CsarInfo csarInfo = getCsarInfo();
1388         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1389         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1390         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1391         boolean isNested = true;
1392
1393         try {
1394             sIB1.updateResourceFromYaml(oldRresource,newRresource,actionEnum,createdArtifacts,yamlFileName,yamlFileContent,
1395                     csarInfo,nodeTypesInfo,nodeTypesArtifactsToHandle,nodeName,isNested);
1396         } catch (Exception e) {
1397
1398         }
1399     }
1400
1401     @Test
1402     public void testCreateResourceFromYaml(){
1403         Resource resource = createParseResourceObject(true);
1404         String topologyTemplateYaml = getMainTemplateContent();
1405         String yamlName = "group.yml";
1406         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1407         CsarInfo csarInfo = getCsarInfo();
1408         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1409         boolean shouldLock = true;
1410         boolean inTransaction =true;
1411         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1412
1413         try {
1414             sIB1.createResourceFromYaml(resource,topologyTemplateYaml,yamlName,nodeTypesInfo,csarInfo,
1415                     nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
1416         } catch (Exception e) {
1417
1418         }
1419     }
1420
1421     @Test
1422     public void testCreateResourceAndRIsFromYaml(){
1423         String yamlName = "group.yml";
1424         Resource resource = createParseResourceObject(false);
1425         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
1426         AuditingActionEnum actionEnum = AuditingActionEnum.CREATE_RESOURCE;
1427         boolean isNormative = true;
1428         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1429         String topologyTemplateYaml = getMainTemplateContent();
1430         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1431         CsarInfo csarInfo = getCsarInfo();
1432         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate = new HashMap<>();
1433         boolean shouldLock = true;
1434         boolean inTransaction = true;
1435         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1436
1437         try {
1438             sIB1.createResourceAndRIsFromYaml(yamlName,resource,parsedToscaYamlInfo,actionEnum,
1439                     isNormative,createdArtifacts,topologyTemplateYaml,nodeTypesInfo,csarInfo,
1440                     nodeTypesArtifactsToCreate,shouldLock,inTransaction,nodeName);
1441         } catch (Exception e) {
1442
1443         }
1444     }
1445
1446     @Test
1447     public void testCreateGroupsOnResource2(){
1448         Resource resource = createParseResourceObject(false);
1449         Map<String, GroupDefinition> groups = new HashMap<>();
1450
1451         Either<Resource, ResponseFormat> result = sIB1.createGroupsOnResource(resource, groups);
1452         assertEquals(result.left().value(),resource);
1453     }
1454
1455     @Test
1456     public void testUpdateGroupsMembersUsingResource2(){
1457         Resource resource = createParseResourceObject(true);
1458         Map<String, GroupDefinition> groups = null;
1459
1460         List<GroupDefinition> groupDefinitions = sIB1.updateGroupsMembersUsingResource(groups,resource);
1461         for (GroupDefinition groupDefinition : groupDefinitions) {
1462             assertNull(groupDefinition);
1463         }
1464     }
1465
1466     @Test
1467     public void testUpdateGroupMembers(){
1468         Map<String, GroupDefinition> groups = new HashMap<>();
1469         GroupDefinition updatedGroupDefinition = new GroupDefinition();
1470         Resource component = createParseResourceObject(true);
1471         List<ComponentInstance> componentInstances = creatComponentInstances();
1472         String groupName = "tosca_simple_yaml_1_1";
1473         Map<String, String> members = new HashMap<>();
1474         members.put("zxjTestImportServiceAb",getGroupsYaml());
1475
1476         try {
1477             sIB1.updateGroupMembers(groups,updatedGroupDefinition,component,componentInstances,
1478                     groupName,members);
1479         } catch (Exception e) {
1480             e.printStackTrace();
1481         }
1482     }
1483
1484     @Test
1485     public void setCreateResourceTransaction(){
1486         Resource resource = createParseResourceObject(false);
1487         resource.setComponentType(ComponentTypeEnum.RESOURCE);
1488         boolean isNormative = true;
1489
1490         try {
1491             sIB1.createResourceTransaction(resource,user,isNormative);
1492         } catch (Exception e) {
1493             e.printStackTrace();
1494         }
1495     }
1496
1497     @Test
1498     public void testUpdateExistingResourceByImport(){
1499         Resource newResource = createParseResourceObject(false);
1500         Resource oldResource = createParseResourceObject(true);
1501
1502         try {
1503             sIB1.updateExistingResourceByImport(newResource,oldResource,user,
1504                     true,true,true);
1505         } catch (Exception e) {
1506             e.printStackTrace();
1507         }
1508     }
1509
1510     @Test
1511     public void testCreateResourcesFromYamlNodeTypesList(){
1512         String yamlName = "group.yml";
1513         Service service =createServiceObject(false);
1514         Map<String, Object> mappedToscaTemplate = new HashMap<>();
1515         boolean needLock = true;
1516         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1517         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1518         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1519         CsarInfo csarInfo = getCsarInfo();
1520
1521         try {
1522             sIB1.createResourcesFromYamlNodeTypesList(yamlName,service,mappedToscaTemplate,needLock,
1523                     nodeTypesArtifactsToHandle,nodeTypesNewCreatedArtifacts,nodeTypesInfo,csarInfo);
1524         } catch (Exception e) {
1525             e.printStackTrace();
1526         }
1527     }
1528
1529     @Test
1530     public void testCreateNodeTypes(){
1531         String yamlName = "group.yml";
1532         Service service =createServiceObject(false);
1533         boolean needLock = true;
1534         Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
1535         EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> enumListEnumMap =
1536                 new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1537         List<ArtifactDefinition> artifactDefinitions = new ArrayList<>();
1538         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1539         artifactDefinition.setArtifactName("artifactName");
1540         artifactDefinitions.add(artifactDefinition);
1541         enumListEnumMap.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
1542                 artifactDefinitions);
1543         nodeTypesArtifactsToHandle.put("nodeTyp",enumListEnumMap);        List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1544         Map<String, NodeTypeInfo> nodeTypesInfo = getNodeTypesInfo();
1545         CsarInfo csarInfo = getCsarInfo();
1546         Map<String, Object> mapToConvert =new HashMap<>();
1547         Map<String, Object> nodeTypes =new HashMap<>();
1548         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1549         nodeTypesInfo.put("nodeTyp",nodeTypeInfo);
1550         nodeTypes.put("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test",
1551                 nodeTypeInfo);
1552
1553         try {
1554             sIB1.createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle,
1555                     nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1556                     nodeTypes);
1557         } catch (Exception e) {
1558             e.printStackTrace();
1559         }
1560     }
1561
1562     protected List<UploadPropInfo> getPropertyList() {
1563         List<UploadPropInfo> propertyList = new ArrayList<>();
1564         UploadPropInfo uploadPropInfo = new UploadPropInfo();
1565         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1566         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1567         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1568         get_input.add(getInputValueDataDefinition);
1569         uploadPropInfo.setName("propertiesName");
1570         uploadPropInfo.setValue("value");
1571         uploadPropInfo.setGet_input(get_input);
1572         propertyList.add(uploadPropInfo);
1573         return propertyList;
1574     }
1575
1576     protected Map<String, GroupDefinition> getGroups() {
1577         Map<String, GroupDefinition> groups = new HashMap<>();
1578         GroupDefinition groupDefinition = new GroupDefinition();
1579         groupDefinition.setName("groupDefinitionName");
1580         groups.put("groupsMap",groupDefinition);
1581         return groups;
1582     }
1583
1584     protected Map<String, NodeTypeInfo> getNodeTypesInfo(){
1585         Map<String, NodeTypeInfo> nodeTypesInfo = new HashMap<>();
1586         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1587         Map<String, Object> mappedToscaTemplate = new HashMap<>();
1588         nodeTypeInfo.setTemplateFileName("templateFileName");
1589         nodeTypeInfo.setMappedToscaTemplate(mappedToscaTemplate);
1590         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1591         nodeTypesInfo.put(nodeName,nodeTypeInfo);
1592         return nodeTypesInfo;
1593     }
1594
1595     protected Map<String, UploadComponentInstanceInfo> getUploadResInstancesMap(){
1596         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1597         UploadComponentInstanceInfo uploadComponentInstanceInfo = getuploadComponentInstanceInfo();
1598         Map<String, String> capabilitiesNamesToUpdate = new HashMap<>();
1599         capabilitiesNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
1600         Map<String, String> requirementsNamesToUpdate = new HashMap<>();
1601         requirementsNamesToUpdate.put("mme_ipu_vdu.feature","capabilitiesNamesToUpdate");
1602         uploadResInstancesMap.put("zxjTestImportServiceAb",uploadComponentInstanceInfo);
1603         return uploadResInstancesMap;
1604     }
1605
1606     protected Map<String, List<UploadPropInfo>> getUploadPropInfoProperties(){
1607         Map<String, List<UploadPropInfo>> properties = new HashMap<>();
1608         List<UploadPropInfo> uploadPropInfoList = new ArrayList<>();
1609         UploadPropInfo uploadPropInfo = new UploadPropInfo();
1610         List<GetInputValueDataDefinition> get_input = new ArrayList<>();
1611         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1612         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1613         get_input.add(getInputValueDataDefinition);
1614         uploadPropInfo.setName("propertiesName");
1615         uploadPropInfo.setValue("value");
1616         uploadPropInfo.setGet_input(get_input);
1617         uploadPropInfoList.add(uploadPropInfo);
1618         properties.put("uploadComponentInstanceInfo",uploadPropInfoList);
1619         return properties;
1620     }
1621
1622     protected List<PropertyDefinition> getProperties(){
1623         List<PropertyDefinition> properties = new ArrayList<>();
1624         PropertyDefinition propertyDefinition = new PropertyDefinition();
1625         propertyDefinition.setName("propertiesName");
1626         properties.add(propertyDefinition);
1627         return properties;
1628     }
1629
1630     protected UploadComponentInstanceInfo getuploadComponentInstanceInfo(){
1631         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
1632         uploadComponentInstanceInfo.setType("resources");
1633         Collection<String> directives = new Collection<String>() {
1634             @Override
1635             public int size() {
1636                 return 0;
1637             }
1638
1639             @Override
1640             public boolean isEmpty() {
1641                 return false;
1642             }
1643
1644             @Override
1645             public boolean contains(Object o) {
1646                 return false;
1647             }
1648
1649             @Override
1650             public Iterator<String> iterator() {
1651                 return null;
1652             }
1653
1654             @Override
1655             public Object[] toArray() {
1656                 return new Object[0];
1657             }
1658
1659             @Override
1660             public <T> T[] toArray(T[] ts) {
1661                 return null;
1662             }
1663
1664             @Override
1665             public boolean add(String s) {
1666                 return false;
1667             }
1668
1669             @Override
1670             public boolean remove(Object o) {
1671                 return false;
1672             }
1673
1674             @Override
1675             public boolean containsAll(Collection<?> collection) {
1676                 return false;
1677             }
1678
1679             @Override
1680             public boolean addAll(Collection<? extends String> collection) {
1681                 return false;
1682             }
1683
1684             @Override
1685             public boolean removeAll(Collection<?> collection) {
1686                 return false;
1687             }
1688
1689             @Override
1690             public boolean retainAll(Collection<?> collection) {
1691                 return false;
1692             }
1693
1694             @Override
1695             public void clear() {
1696
1697             }
1698         };
1699         uploadComponentInstanceInfo.setDirectives(directives);
1700         UploadNodeFilterInfo uploadNodeFilterInfo = new UploadNodeFilterInfo();
1701         Map<String, List<UploadReqInfo>> requirements = new HashMap<>();
1702         List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
1703         UploadReqInfo uploadReqInfo = new UploadReqInfo();
1704         uploadReqInfo.setName("uploadReqInfo");
1705         uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
1706         uploadReqInfoList.add(uploadReqInfo);
1707         requirements.put("requirements",uploadReqInfoList);
1708         uploadNodeFilterInfo.setName("mme_ipu_vdu.virtualbinding");
1709         uploadComponentInstanceInfo.setCapabilities(getCapabilities());
1710         uploadComponentInstanceInfo.setRequirements(requirements);
1711         return uploadComponentInstanceInfo;
1712     }
1713
1714     protected Map<String, List<UploadCapInfo>> getCapabilities(){
1715         List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
1716         UploadCapInfo uploadCapInfo = new UploadCapInfo();
1717         uploadCapInfo.setNode("tosca.nodes.Root");
1718         uploadCapInfo.setName("mme_ipu_vdu.dependency");
1719         uploadCapInfoList.add(uploadCapInfo);
1720         Map<String, List<UploadCapInfo>> uploadCapInfoMap = new HashMap<>();
1721         uploadCapInfoMap.put("tosca.capabilities.Node",uploadCapInfoList);
1722         return uploadCapInfoMap;
1723     }
1724
1725     protected Map<String, List<UploadReqInfo>> gerRequirements(){
1726         Map<String, List<UploadReqInfo>> uploadReqInfoMap = new HashMap<>();
1727         String requirementName = "tosca.capabilities.Node";
1728         List<UploadReqInfo> uploadReqInfoList = new ArrayList<>();
1729         UploadReqInfo uploadReqInfo = new UploadReqInfo();
1730         uploadReqInfo.setCapabilityName("tosca.capabilities.Node");
1731         uploadReqInfoMap.put(requirementName,uploadReqInfoList);
1732         return uploadReqInfoMap;
1733     }
1734
1735     protected ComponentParametersView createComponentParametersView() {
1736         ComponentParametersView parametersView = new ComponentParametersView();
1737         parametersView.disableAll();
1738         parametersView.setIgnoreComponentInstances(false);
1739         parametersView.setIgnoreComponentInstancesProperties(false);
1740         parametersView.setIgnoreCapabilities(false);
1741         parametersView.setIgnoreRequirements(false);
1742         parametersView.setIgnoreGroups(false);
1743         return parametersView;
1744     }
1745     protected Map<String, byte[]> crateCsarFromPayload() {
1746         String payloadName = "valid_vf.csar";
1747         String rootPath = System.getProperty("user.dir");
1748         Path path;
1749         byte[] data;
1750         String payloadData;
1751         Map<String, byte[]> returnValue = null;
1752         try {
1753             path = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
1754             data = Files.readAllBytes(path);
1755             payloadData = Base64.encodeBase64String(data);
1756             UploadResourceInfo resourceInfo = new UploadResourceInfo();
1757             resourceInfo.setPayloadName(payloadName);
1758             resourceInfo.setPayloadData(payloadData);
1759             Method privateMethod = null;
1760             privateMethod = AbstractValidationsServlet.class.getDeclaredMethod("getCsarFromPayload", UploadResourceInfo.class);
1761             privateMethod.setAccessible(true);
1762             returnValue = (Map<String, byte[]>) privateMethod.invoke(servlet, resourceInfo);
1763         } catch (IOException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
1764             e.printStackTrace();
1765         }
1766         return returnValue;
1767     }
1768
1769
1770     protected List<ComponentInstance> creatComponentInstances(){
1771         List<ComponentInstance> componentInstances = new ArrayList<>();
1772         ComponentInstance componentInstance = new ComponentInstance();
1773         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1774         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1775         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1776         capabilityDefinition.setName("mme_ipu_vdu.feature");
1777         capabilityDefinitionList.add(capabilityDefinition);
1778         capabilities.put("tosca.capabilities.Node",capabilityDefinitionList);
1779
1780         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1781         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
1782         RequirementDefinition requirementDefinition = new RequirementDefinition();
1783         requirementDefinition.setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1784         requirementDefinitionList.add(requirementDefinition);
1785         requirements.put("tosca.capabilities.Node",requirementDefinitionList);
1786         componentInstance.setRequirements(requirements);
1787         componentInstance.setCapabilities(capabilities);
1788         componentInstance.setUniqueId("uniqueId");
1789         componentInstance.setComponentUid("componentUid");
1790         componentInstance.setName("zxjTestImportServiceAb");
1791         componentInstances.add(componentInstance);
1792         return componentInstances;
1793     }
1794
1795     protected CreateServiceFromYamlParameter getCsfyp() {
1796         CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
1797         List<ArtifactDefinition> createdArtifacts =new ArrayList<>();
1798         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
1799
1800         csfyp.setNodeName("org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test");
1801         csfyp.setTopologyTemplateYaml(getMainTemplateContent("service_import_template.yml"));
1802         csfyp.setCreatedArtifacts(createdArtifacts);
1803         csfyp.setInTransaction(true);
1804         csfyp.setShouldLock(true);
1805         csfyp.setCsarInfo(getCsarInfo());
1806         csfyp.setParsedToscaYamlInfo(getParsedToscaYamlInfo());
1807         csfyp.setNodeTypesInfo(nodeTypesInfo);
1808         csfyp.setYamlName("group.yml");
1809         return csfyp;
1810     }
1811
1812     protected ParsedToscaYamlInfo getParsedToscaYamlInfo(){
1813         ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
1814         Map<String, InputDefinition> inputs = new HashMap<>();
1815         Map<String, UploadComponentInstanceInfo> instances=new HashMap<>();
1816         Map<String, GroupDefinition> groups=new HashMap<>();
1817         Map<String, PolicyDefinition> policies=new HashMap<>();
1818         parsedToscaYamlInfo.setGroups(groups);
1819         parsedToscaYamlInfo.setInputs(inputs);
1820         parsedToscaYamlInfo.setInstances(instances);
1821         parsedToscaYamlInfo.setPolicies(policies);
1822         return parsedToscaYamlInfo;
1823     }
1824
1825     String getMainTemplateContent(String fileName){
1826         String mainTemplateContent = null;
1827         try {
1828             mainTemplateContent = loadFileNameToJsonString(fileName);
1829         } catch (IOException e) {
1830             e.printStackTrace();
1831         }
1832         return mainTemplateContent;
1833     }
1834
1835     protected CsarInfo getCsarInfo ()
1836     {
1837         String csarUuid = "0010";
1838         User user = new User();
1839         Map<String, byte[]> csar = crateCsarFromPayload();
1840         String vfReousrceName = "resouceName";
1841         String mainTemplateName = "mainTemplateName";
1842         String mainTemplateContent = getMainTemplateContent("service_import_template.yml");
1843         CsarInfo csarInfo = new CsarInfo(user, csarUuid,  csar, vfReousrceName, mainTemplateName, mainTemplateContent, false);
1844         return csarInfo;
1845     }
1846
1847     public static String loadFileNameToJsonString(String fileName) throws IOException {
1848         String sourceDir = "src/test/resources/normativeTypes";
1849         return loadFileNameToJsonString(sourceDir, fileName);
1850     }
1851
1852     private static String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
1853         java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
1854         byte[] fileContent = Files.readAllBytes(filePath);
1855         return new String(fileContent);
1856     }
1857
1858
1859         protected CsarUtils.NonMetaArtifactInfo getNonMetaArtifactInfo(){
1860         String artifactName = "artifactName",path = "/src/test/resources/valid_vf.csar",artifactType = "AAI_SERVICE_MODEL";
1861         ArtifactGroupTypeEnum artifactGroupType = ArtifactGroupTypeEnum.TOSCA;
1862         String rootPath = System.getProperty("user.dir");
1863         Path path2;
1864         byte[] data = new byte[0];
1865         path2 = Paths.get(rootPath + "/src/test/resources/valid_vf.csar");
1866         try {
1867             data = Files.readAllBytes(path2);
1868         } catch (IOException e) {
1869             e.printStackTrace();
1870         }
1871         String artifactUniqueId = "artifactUniqueId";
1872         boolean isFromCsar = true;
1873         CsarUtils.NonMetaArtifactInfo  nonMetaArtifactInfo = new CsarUtils.NonMetaArtifactInfo(artifactName,
1874                 path,artifactType,artifactGroupType,data,artifactUniqueId,isFromCsar);
1875         return nonMetaArtifactInfo;
1876
1877     }
1878
1879     protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
1880         ResponseFormat actualResponse = e.getResponseFormat() != null ?
1881                 e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1882         assertParseResponse(actualResponse, expectedStatus, variables);
1883     }
1884
1885     private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
1886         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
1887         assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
1888         assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
1889     }
1890 }