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