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

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