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