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