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