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

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