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