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