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

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