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