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

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