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