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

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