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

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