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