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