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