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