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