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