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

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