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

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