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