catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ServiceImportParseLogicTest.java

   1 /*
   2  * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.be.components.impl;
  18
  19 import static org.assertj.core.api.Java6Assertions.assertThat;
  20 import static org.junit.jupiter.api.Assertions.assertEquals;
  21 import static org.junit.jupiter.api.Assertions.assertNotEquals;
  22 import static org.junit.jupiter.api.Assertions.assertNotNull;
  23 import static org.junit.jupiter.api.Assertions.assertSame;
  24 import static org.junit.jupiter.api.Assertions.assertThrows;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.junit.jupiter.api.Assertions.fail;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.anyBoolean;
  29 import static org.mockito.ArgumentMatchers.anyMap;
  30 import static org.mockito.ArgumentMatchers.anyString;
  31 import static org.mockito.Mockito.mock;
  32 import static org.mockito.Mockito.times;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35
  36 import fj.data.Either;
  37 import java.io.File;
  38 import java.io.IOException;
  39 import java.net.URISyntaxException;
  40 import java.nio.file.FileSystems;
  41 import java.nio.file.Files;
  42 import java.util.ArrayList;
  43 import java.util.Collections;
  44 import java.util.EnumMap;
  45 import java.util.HashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.Map.Entry;
  49 import java.util.NoSuchElementException;
  50 import java.util.Optional;
  51 import org.apache.commons.collections.map.HashedMap;
  52 import org.apache.commons.lang3.tuple.ImmutablePair;
  53 import org.glassfish.grizzly.http.util.HttpStatus;
  54 import org.junit.jupiter.api.Assertions;
  55 import org.junit.jupiter.api.BeforeEach;
  56 import org.junit.jupiter.api.Test;
  57 import org.mockito.MockitoAnnotations;
  58 import org.openecomp.sdc.ElementOperationMock;
  59 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  60 import org.openecomp.sdc.be.components.csar.CsarInfo;
  61 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
  62 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
  63 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  64 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  65 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  66 import org.openecomp.sdc.be.dao.api.ActionStatus;
  67 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
  68 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  69 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
  70 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  71 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  72 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  73 import org.openecomp.sdc.be.impl.ComponentsUtils;
  74 import org.openecomp.sdc.be.model.ArtifactDefinition;
  75 import org.openecomp.sdc.be.model.AttributeDefinition;
  76 import org.openecomp.sdc.be.model.CapabilityDefinition;
  77 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  78 import org.openecomp.sdc.be.model.Component;
  79 import org.openecomp.sdc.be.model.ComponentInstance;
  80 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  81 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  82 import org.openecomp.sdc.be.model.ComponentParametersView;
  83 import org.openecomp.sdc.be.model.GroupDefinition;
  84 import org.openecomp.sdc.be.model.InputDefinition;
  85 import org.openecomp.sdc.be.model.InterfaceDefinition;
  86 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
  87 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  88 import org.openecomp.sdc.be.model.NodeTypeInfo;
  89 import org.openecomp.sdc.be.model.OutputDefinition;
  90 import org.openecomp.sdc.be.model.PropertyDefinition;
  91 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  92 import org.openecomp.sdc.be.model.RequirementDefinition;
  93 import org.openecomp.sdc.be.model.Resource;
  94 import org.openecomp.sdc.be.model.Service;
  95 import org.openecomp.sdc.be.model.UploadCapInfo;
  96 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
  97 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
  98 import org.openecomp.sdc.be.model.UploadPropInfo;
  99 import org.openecomp.sdc.be.model.UploadReqInfo;
 100 import org.openecomp.sdc.be.model.User;
 101 import org.openecomp.sdc.be.model.category.CategoryDefinition;
 102 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
 103 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
 104 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
 105 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
 106 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
 107 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 108 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
 109 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 110 import org.openecomp.sdc.be.user.Role;
 111 import org.openecomp.sdc.common.api.Constants;
 112 import org.openecomp.sdc.common.zip.ZipUtils;
 113 import org.openecomp.sdc.common.zip.exception.ZipException;
 114 import org.openecomp.sdc.exception.ResponseFormat;
 115
 116 class ServiceImportParseLogicTest extends ServiceImportBussinessLogicBaseTestSetup {
 117
 118     private static final String RESOURCE_NAME = "My-Resource_Name with   space";
 119     private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name";
 120     private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
 121     private static final String RESOURCE_SUBCATEGORY = "Router";
 122
 123     private final ComponentsUtils componentsUtils = new ComponentsUtils(mock(AuditingManager.class));
 124     private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
 125     private final ServiceBusinessLogic serviceBusinessLogic = mock(ServiceBusinessLogic.class);
 126     private final ICapabilityTypeOperation capabilityTypeOperation = mock(ICapabilityTypeOperation.class);
 127     private final IElementOperation elementDao = mock(IElementOperation.class);
 128     private final IInterfaceLifecycleOperation interfaceTypeOperation = mock(IInterfaceLifecycleOperation.class);
 129     private final InputsBusinessLogic inputsBusinessLogic = mock(InputsBusinessLogic.class);
 130     private final OutputsBusinessLogic outputsBusinessLogic = mock(OutputsBusinessLogic.class);
 131     private final LifecycleBusinessLogic lifecycleBusinessLogic = mock(LifecycleBusinessLogic.class);
 132     private final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic = mock(ComponentNodeFilterBusinessLogic.class);
 133
 134     private ResponseFormatManager responseManager = null;
 135     private User user = null;
 136     private ServiceImportParseLogic testSubject;
 137
 138     private ServiceImportParseLogic createTestSubject() {
 139         return new ServiceImportParseLogic(serviceBusinessLogic, componentsUtils, toscaOperationFacade, lifecycleBusinessLogic, inputsBusinessLogic,
 140             null, null, interfaceTypeOperation, capabilityTypeOperation, componentNodeFilterBusinessLogic,
 141             groupBusinessLogic, outputsBusinessLogic);
 142     }
 143
 144     @BeforeEach
 145     public void setup() {
 146         MockitoAnnotations.openMocks(this);
 147
 148         // Elements
 149         mockElementDao = new ElementOperationMock();
 150
 151         // User data and management
 152         user = new User();
 153         user.setUserId("jh0003");
 154         user.setFirstName("Jimmi");
 155         user.setLastName("Hendrix");
 156         user.setRole(Role.ADMIN.name());
 157         responseManager = ResponseFormatManager.getInstance();
 158
 159         testSubject = createTestSubject();
 160         serviceBusinessLogic.setElementDao(elementDao);
 161     }
 162
 163     @Test
 164     void testFindNodeTypesArtifactsToHandle() {
 165         testSubject = createTestSubject();
 166         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
 167         final Service service = createServiceObject(false);
 168         Assertions.assertNotNull(
 169             this.testSubject.findNodeTypesArtifactsToHandle(
 170                 nodeTypesInfo, getCsarInfo(), service));
 171
 172     }
 173
 174     @Test
 175     void testBuildNodeTypeYaml() {
 176         Map.Entry<String, Object> nodeNameValue = new Entry<String, Object>() {
 177             @Override
 178             public String getKey() {
 179                 return null;
 180             }
 181
 182             @Override
 183             public Object getValue() {
 184                 return null;
 185             }
 186
 187             @Override
 188             public Object setValue(Object value) {
 189                 return null;
 190             }
 191         };
 192         Map<String, Object> mapToConvert = new HashMap<>();
 193         String nodeResourceType = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
 194
 195         final CsarInfo csarInfo = getCsarInfo();
 196         Assertions.assertThrows(ComponentException.class, () ->
 197             testSubject.buildNodeTypeYaml(nodeNameValue, mapToConvert, nodeResourceType, csarInfo));
 198
 199     }
 200
 201     @Test
 202     void testFindAddNodeTypeArtifactsToHandle() {
 203
 204         Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
 205         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 206         String namespace = "namespace";
 207
 208         ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
 209         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
 210         final Service service = createServiceObject(false);
 211         Resource resource = new Resource();
 212         Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
 213         when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
 214             .thenReturn(getCompLatestResult);
 215
 216         final CsarInfo csarInfo = getCsarInfo();
 217         Assertions.assertThrows(ComponentException.class, () ->
 218             testSubject.findAddNodeTypeArtifactsToHandle(csarInfo, nodeTypesArtifactsToHandle, service,
 219                 extractedVfcsArtifacts, namespace, p1));
 220
 221     }
 222
 223     @Test
 224     void testFindAddNodeTypeArtifactsToHandleNotNull() {
 225
 226         Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = new HashMap<>();
 227         Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
 228         String namespace = "namespace";
 229         List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
 230         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 231         artifactDefinition.setArtifactName("artifactDefinitionName");
 232         vfcArtifacts.add(artifactDefinition);
 233         extractedVfcsArtifacts.put(namespace, vfcArtifacts);
 234         ImmutablePair p1 = ImmutablePair.<String, String>of("s", "sd");
 235         Map<String, NodeTypeInfo> nodeTypesInfo = new HashedMap();
 236         final Service service = createServiceObject(false);
 237         Resource resource = new Resource();
 238         Either<Component, StorageOperationStatus> getCompLatestResult = Either.left(resource);
 239         when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any()))
 240             .thenReturn(getCompLatestResult);
 241         Assertions.assertNotNull(extractedVfcsArtifacts);
 242         testSubject.findAddNodeTypeArtifactsToHandle(getCsarInfo(), nodeTypesArtifactsToHandle, service,
 243             extractedVfcsArtifacts, namespace, p1);
 244     }
 245
 246     @Test
 247     void testHandleAndAddExtractedVfcsArtifacts() {
 248         List<ArtifactDefinition> vfcArtifacts = new ArrayList<>();
 249         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 250         artifactDefinition.setArtifactName("artifactDefinitionName");
 251         vfcArtifacts.add(artifactDefinition);
 252         List<ArtifactDefinition> artifactsToAdd = new ArrayList<>();
 253         ArtifactDefinition artifactDefinitionToAdd = new ArtifactDefinition();
 254         artifactDefinitionToAdd.setArtifactName("artifactDefinitionToAddName");
 255         artifactsToAdd.add(artifactDefinitionToAdd);
 256         Assertions.assertNotNull(vfcArtifacts);
 257
 258         testSubject.handleAndAddExtractedVfcsArtifacts(vfcArtifacts, artifactsToAdd);
 259     }
 260
 261     @Test
 262     void testFindNodeTypeArtifactsToHandle() {
 263
 264         Resource curNodeType = createParseResourceObject(true);
 265         List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
 266
 267         Assertions.assertNull(
 268             testSubject.findNodeTypeArtifactsToHandle(curNodeType, extractedArtifacts));
 269     }
 270
 271     @Test
 272     void testCollectExistingArtifacts() {
 273
 274         Resource curNodeType = createParseResourceObject(true);
 275         Assertions.assertNotNull(
 276             testSubject.collectExistingArtifacts(curNodeType));
 277     }
 278
 279     @Test
 280     void testPutFoundArtifacts() {
 281         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 282         List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
 283         artifactsToUpload.add(artifactDefinition);
 284         List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
 285         artifactsToUpdate.add(artifactDefinition);
 286         List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
 287         artifactsToDelete.add(artifactDefinition);
 288         Assertions.assertNotNull(
 289             testSubject.putFoundArtifacts(artifactsToUpload, artifactsToUpdate, artifactsToDelete));
 290     }
 291
 292     @Test
 293     void testProcessExistingNodeTypeArtifacts() {
 294         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 295         List<ArtifactDefinition> extractedArtifacts = new ArrayList<>();
 296         extractedArtifacts.add(artifactDefinition);
 297         List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
 298         artifactsToUpload.add(artifactDefinition);
 299         List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
 300         artifactsToUpdate.add(artifactDefinition);
 301         List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
 302         artifactsToDelete.add(artifactDefinition);
 303         Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
 304         existingArtifacts.put("test", artifactDefinition);
 305         Assertions.assertThrows(ComponentException.class, () ->
 306             testSubject.processExistingNodeTypeArtifacts(extractedArtifacts, artifactsToUpload, artifactsToUpdate,
 307                 artifactsToDelete, existingArtifacts));
 308
 309     }
 310
 311     @Test
 312     void testProcessNodeTypeArtifact() {
 313         List<ArtifactDefinition> artifactsToUpload = new ArrayList<>();
 314         List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
 315         Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
 316         ArtifactDefinition existingArtifact = new ArtifactDefinition();
 317         existingArtifact.setArtifactName("ArtifactName");
 318         existingArtifact.setArtifactType("ArtifactType");
 319         existingArtifact.setArtifactChecksum("ArtifactChecksum");
 320         existingArtifacts.put("existingArtifactMap", existingArtifact);
 321         ArtifactDefinition currNewArtifact = new ArtifactDefinition();
 322         currNewArtifact.setArtifactName("ArtifactName");
 323         currNewArtifact.setArtifactType("ArtifactType");
 324         currNewArtifact.setPayload("Payload".getBytes());
 325         Assertions.assertNotNull(existingArtifact);
 326         testSubject.processNodeTypeArtifact(artifactsToUpload, artifactsToUpdate, existingArtifacts, currNewArtifact);
 327     }
 328
 329     @Test
 330     void testUpdateFoundArtifact() {
 331         List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
 332         ArtifactDefinition currNewArtifact = new ArtifactDefinition();
 333         currNewArtifact.setArtifactChecksum("090909");
 334         currNewArtifact.setPayloadData("data");
 335         ArtifactDefinition foundArtifact = new ArtifactDefinition();
 336         foundArtifact.setArtifactChecksum("08767");
 337         Assertions.assertNotNull(currNewArtifact);
 338
 339         testSubject.updateFoundArtifact(artifactsToUpdate, currNewArtifact, foundArtifact);
 340     }
 341
 342     @Test
 343     void testIsArtifactDeletionRequired() {
 344         String artifactId = "artifactId";
 345         byte[] artifactFileBytes = new byte[100];
 346         boolean isFromCsar = true;
 347         Assertions.assertFalse(testSubject.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar));
 348     }
 349
 350     @Test
 351     void testFillGroupsFinalFields() {
 352         List<GroupDefinition> groupsAsList = new ArrayList<>();
 353         GroupDefinition groupDefinition = new GroupDefinition();
 354         groupDefinition.setName("groupDefinitionName");
 355         groupsAsList.add(groupDefinition);
 356         Assertions.assertNotNull(groupsAsList);
 357         testSubject.fillGroupsFinalFields(groupsAsList);
 358     }
 359
 360     @Test
 361     void testGetComponentTypeForResponse() {
 362         Resource resource = createParseResourceObject(true);
 363         Assertions.assertNotNull(
 364             testSubject.getComponentTypeForResponse(resource));
 365     }
 366
 367     @Test
 368     void testGetComponentTypeForResponseByService() {
 369         Service service = createServiceObject(true);
 370         Assertions.assertNotNull(
 371             testSubject.getComponentTypeForResponse(service));
 372     }
 373
 374     @Test
 375     void testBuildValidComplexVfc() {
 376         Resource resource = createParseResourceObject(true);
 377         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
 378         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
 379         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
 380         List<String> derivedFrom = new ArrayList<>();
 381         derivedFrom.add("derivedFrom");
 382         nodeTypeInfo.setDerivedFrom(derivedFrom);
 383         nodesInfo.put(nodeName, nodeTypeInfo);
 384         final CsarInfo csarInfo = getCsarInfo();
 385         Assertions.assertThrows(ComponentException.class, () ->
 386             testSubject.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo));
 387
 388     }
 389
 390     @Test
 391     void testValidateResourceBeforeCreate() {
 392         Resource resource = createParseResourceObject(true);
 393
 394         testSubject.getServiceBusinessLogic().setElementDao(elementDao);
 395         final CsarInfo csarInfo = getCsarInfo();
 396         Assertions.assertThrows(ComponentException.class, () ->
 397             testSubject.validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, false, csarInfo));
 398
 399     }
 400
 401     @Test
 402     void testValidateResourceType() {
 403         Resource resource = createParseResourceObject(true);
 404         Assertions.assertNotNull(
 405             testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 406     }
 407
 408     @Test
 409     void testValidateResourceTypeIsEmpty() {
 410         Resource resource = new Resource();
 411         resource.setResourceType(null);
 412         Assertions.assertNotNull(
 413             testSubject.validateResourceType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 414     }
 415
 416     @Test
 417     void testValidateLifecycleTypesCreate() {
 418         Resource resource = createParseResourceObject(true);
 419         Map<String, InterfaceDefinition> mapInterfaces = new HashMap<>();
 420         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 421         String uniqueId = "01932342212";
 422         interfaceDefinition.setUniqueId(uniqueId);
 423         mapInterfaces.put("uniqueId", interfaceDefinition);
 424         resource.setInterfaces(mapInterfaces);
 425         when(interfaceTypeOperation.getInterface(anyString()))
 426             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 427         Assertions.assertNotNull(
 428             testSubject.validateLifecycleTypesCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 429     }
 430
 431     @Test
 432     void testValidateCapabilityTypesCreate() {
 433         Resource resource = createParseResourceObject(true);
 434         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 435         String uniqueId = "18982938994";
 436         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 437         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 438         capabilityDefinitionList.add(capabilityDefinition);
 439         capabilities.put(uniqueId, capabilityDefinitionList);
 440         resource.setCapabilities(capabilities);
 441         when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
 442             thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 443         Assertions.assertNotNull(
 444             testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
 445                 AuditingActionEnum.IMPORT_RESOURCE, true));
 446
 447     }
 448
 449     @Test
 450     void testValidateCapabilityTypesCreateWhenHaveCapability() {
 451         Resource resource = createParseResourceObject(true);
 452         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 453         String uniqueId = "18982938994";
 454         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 455         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 456         capabilityDefinitionList.add(capabilityDefinition);
 457         capabilities.put(uniqueId, capabilityDefinitionList);
 458         resource.setCapabilities(capabilities);
 459         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 460         when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
 461             thenReturn(Either.left(capabilityTypeDefinition));
 462
 463         Assertions.assertNotNull(
 464             testSubject.validateCapabilityTypesCreate(user, testSubject.getCapabilityTypeOperation(), resource,
 465                 AuditingActionEnum.IMPORT_RESOURCE, true));
 466
 467     }
 468
 469     @Test
 470     void testValidateCapabilityTypeExists() {
 471         Resource resource = createParseResourceObject(true);
 472         Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
 473         for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
 474
 475             Assertions.assertNotNull(
 476                 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
 477                     AuditingActionEnum.IMPORT_RESOURCE,
 478                     eitherResult, typeEntry, false));
 479         }
 480     }
 481
 482     @Test
 483     void testValidateCapabilityTypeExistsWhenPropertiesIsNull() {
 484         Resource resource = createParseResourceObject(true);
 485         Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
 486         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 487
 488         String uniqueId = "0987348532";
 489         PropertyDefinition propertyDefinition = new PropertyDefinition();
 490         Map<String, PropertyDefinition> properties = new HashMap<>();
 491         properties.put(uniqueId, propertyDefinition);
 492         capabilityTypeDefinition.setProperties(properties);
 493
 494         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 495         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 496         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 497         capabilityDefinitionList.add(capabilityDefinition);
 498         capabilities.put(uniqueId, capabilityDefinitionList);
 499         resource.setCapabilities(capabilities);
 500
 501         when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
 502             thenReturn(Either.left(capabilityTypeDefinition));
 503         for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
 504
 505             Assertions.assertNotNull(
 506                 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
 507                     AuditingActionEnum.IMPORT_RESOURCE,
 508                     eitherResult, typeEntry, false));
 509         }
 510     }
 511
 512     @Test
 513     void testValidateCapabilityTypeExistsWhenPropertiesNotNull() {
 514         Resource resource = createParseResourceObject(true);
 515         Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
 516         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 517
 518         String uniqueId = "0987348532";
 519         PropertyDefinition propertyDefinition = new PropertyDefinition();
 520         propertyDefinition.setName(uniqueId);
 521         Map<String, PropertyDefinition> properties = new HashMap<>();
 522         properties.put(uniqueId, propertyDefinition);
 523         capabilityTypeDefinition.setProperties(properties);
 524
 525         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 526
 527         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 528         List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
 529         ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
 530         componentInstanceProperty.setValueUniqueUid(uniqueId);
 531         componentInstanceProperty.setName(uniqueId);
 532         componentInstancePropertyList.add(componentInstanceProperty);
 533         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 534         capabilityDefinition.setProperties(componentInstancePropertyList);
 535         capabilityDefinitionList.add(capabilityDefinition);
 536
 537         capabilities.put(uniqueId, capabilityDefinitionList);
 538         resource.setCapabilities(capabilities);
 539
 540         when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
 541             thenReturn(Either.left(capabilityTypeDefinition));
 542         for (Map.Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities().entrySet()) {
 543
 544             Assertions.assertNotNull(
 545                 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
 546                     AuditingActionEnum.IMPORT_RESOURCE,
 547                     eitherResult, typeEntry, false));
 548         }
 549     }
 550
 551     @Test
 552     void testValidateCapabilityTypeExists2() {
 553         Resource resource = createParseResourceObject(true);
 554         Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
 555         when(capabilityTypeOperation.getCapabilityType(anyString(), anyBoolean())).
 556             thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 557
 558         for (String type : resource.getRequirements().keySet()) {
 559             Assertions.assertNotNull(
 560                 testSubject.validateCapabilityTypeExists(user, testSubject.getCapabilityTypeOperation(), resource,
 561                     resource.getRequirements().get(type), AuditingActionEnum.IMPORT_RESOURCE, eitherResult, type,
 562                     false));
 563
 564         }
 565     }
 566
 567     @Test
 568     void testValidateResourceFieldsBeforeCreate() {
 569         Resource resource = createParseResourceObject(true);
 570         Assertions.assertThrows(ComponentException.class, () ->
 571             testSubject.validateResourceFieldsBeforeCreate(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 572     }
 573
 574     @Test
 575     void testValidateDerivedFromExist() {
 576         Resource resource = createParseResourceObject(true);
 577         when(toscaOperationFacade.validateToscaResourceNameExists(anyString())).thenReturn(Either.left(true));
 578         Assertions.assertNotNull(resource);
 579
 580         testSubject.validateDerivedFromExist(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
 581     }
 582
 583     @Test
 584     void testValidateLicenseType() {
 585         Resource resource = createParseResourceObject(true);
 586
 587         Assertions.assertThrows(ComponentException.class, () ->
 588             testSubject.validateLicenseType(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 589
 590
 591     }
 592
 593     @Test
 594     void testValidateCost() {
 595         Resource resource = createParseResourceObject(true);
 596         Assertions.assertThrows(ComponentException.class, () ->
 597             testSubject.validateCost(resource));
 598     }
 599
 600     @Test
 601     void testValidateResourceVendorModelNumber() {
 602         Resource resource = createParseResourceObject(true);
 603         Assertions.assertNotNull(resource);
 604
 605         testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
 606     }
 607
 608     @Test
 609     void testValidateResourceVendorModelNumberWrongLen() {
 610         Resource resource = createParseResourceObject(true);
 611         resource.setResourceVendorModelNumber("000000000011122221111222333444443222556677788778889999998776554332340");
 612         Assertions.assertThrows(ComponentException.class, () ->
 613             testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 614     }
 615
 616     @Test
 617     void testValidateResourceVendorModelNumberWrongValue() {
 618         Resource resource = createParseResourceObject(true);
 619         resource.setResourceVendorModelNumber("");
 620         Assertions.assertNotNull(resource);
 621
 622         testSubject.validateResourceVendorModelNumber(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
 623     }
 624
 625     @Test
 626     void testValidateVendorReleaseName() {
 627         Resource resource = createParseResourceObject(true);
 628         resource.setVendorRelease("0.1");
 629         Assertions.assertNotNull(resource);
 630
 631         testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
 632     }
 633
 634     @Test
 635     void testValidateVendorReleaseNameFailure() {
 636         Resource resource = createParseResourceObject(true);
 637         resource.setVendorRelease("");
 638         Assertions.assertThrows(ComponentException.class, () ->
 639             testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 640
 641     }
 642
 643     @Test
 644     void testValidateVendorReleaseNameWrongLen() {
 645         Resource resource = createParseResourceObject(true);
 646         resource.setVendorRelease("000000000011122221111222333444443222556677788778889999998776554332340");
 647         Assertions.assertThrows(ComponentException.class, () ->
 648             testSubject.validateVendorReleaseName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 649
 650     }
 651
 652     @Test
 653     void testValidateCategory() {
 654         Resource resource = createParseResourceObject(true);
 655         Assertions.assertThrows(ComponentException.class, () ->
 656             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 657     }
 658
 659     @Test
 660     void testValidateEmptyCategory() {
 661         Resource resource = createParseResourceObject(true);
 662         resource.setCategories(null);
 663         Assertions.assertThrows(ComponentException.class, () ->
 664             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 665
 666     }
 667
 668     @Test
 669     void testValidateCategorySizeBiggerThan1() {
 670         Resource resource = createParseResourceObject(true);
 671         List<CategoryDefinition> categories = new ArrayList<>();
 672         CategoryDefinition categoryDefinition1 = new CategoryDefinition();
 673         CategoryDefinition categoryDefinition2 = new CategoryDefinition();
 674         categories.add(categoryDefinition1);
 675         categories.add(categoryDefinition2);
 676
 677         resource.setCategories(categories);
 678         Assertions.assertThrows(ComponentException.class, () ->
 679             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 680
 681     }
 682
 683     @Test
 684     void testValidateEmptySubCategory() {
 685         Resource resource = createParseResourceObject(true);
 686         List<CategoryDefinition> categories = resource.getCategories();
 687         CategoryDefinition categoryDefinition = categories.get(0);
 688         categoryDefinition.setSubcategories(null);
 689
 690         Assertions.assertThrows(ComponentException.class, () ->
 691             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 692
 693     }
 694
 695     @Test
 696     void testValidateEmptySubCategorySizeBiggerThan1() {
 697         Resource resource = createParseResourceObject(true);
 698         List<CategoryDefinition> categories = resource.getCategories();
 699         CategoryDefinition categoryDefinition = categories.get(0);
 700         List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
 701         SubCategoryDefinition subCategoryDefinition1 = new SubCategoryDefinition();
 702         SubCategoryDefinition subCategoryDefinition2 = new SubCategoryDefinition();
 703         subcategories.add(subCategoryDefinition1);
 704         subcategories.add(subCategoryDefinition2);
 705
 706         Assertions.assertThrows(ComponentException.class, () ->
 707             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 708
 709     }
 710
 711     @Test
 712     void testValidateEmptyCategoryName() {
 713         Resource resource = createParseResourceObject(true);
 714         List<CategoryDefinition> categories = resource.getCategories();
 715         CategoryDefinition categoryDefinition = categories.get(0);
 716         categoryDefinition.setName(null);
 717
 718         Assertions.assertThrows(ComponentException.class, () ->
 719             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 720     }
 721
 722     @Test
 723     void testValidateEmptySubCategoryName() {
 724         Resource resource = createParseResourceObject(true);
 725         List<CategoryDefinition> categories = resource.getCategories();
 726         CategoryDefinition categoryDefinition = categories.get(0);
 727         List<SubCategoryDefinition> subcategories = categoryDefinition.getSubcategories();
 728         SubCategoryDefinition subCategoryDefinition1 = subcategories.get(0);
 729         subCategoryDefinition1.setName(null);
 730
 731         Assertions.assertThrows(ComponentException.class, () ->
 732             testSubject.validateCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 733     }
 734
 735     @Test
 736     void testValidateCategoryListed() {
 737         Resource resource = createParseResourceObject(true);
 738         CategoryDefinition category = resource.getCategories().get(0);
 739         SubCategoryDefinition subcategory = category.getSubcategories().get(0);
 740         Assertions.assertThrows(ComponentException.class, () ->
 741             testSubject.validateCategoryListed(category, subcategory, user, resource, AuditingActionEnum.IMPORT_RESOURCE, true));
 742     }
 743
 744     @Test
 745     void testFailOnInvalidCategory() {
 746         Resource resource = createParseResourceObject(true);
 747         Assertions.assertThrows(ComponentException.class, () ->
 748             testSubject.failOnInvalidCategory(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 749
 750     }
 751
 752     @Test
 753     void testValidateVendorName() {
 754         Resource resource = createParseResourceObject(true);
 755         Assertions.assertNotNull(resource);
 756         testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE);
 757     }
 758
 759     @Test
 760     void testValidateVendorNameEmpty() {
 761         Resource resource = createParseResourceObject(true);
 762         resource.setVendorName(null);
 763         Assertions.assertThrows(ComponentException.class, () ->
 764             testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 765     }
 766
 767     @Test
 768     void testValidateVendorNameWrongLen() {
 769         Resource resource = createParseResourceObject(true);
 770         resource.setVendorName("000000000011122221111222333444443222556677788778889999998776554332340");
 771         Assertions.assertThrows(ComponentException.class, () ->
 772             testSubject.validateVendorName(user, resource, AuditingActionEnum.IMPORT_RESOURCE));
 773     }
 774
 775     @Test
 776     void testValidateVendorName2() {
 777         Resource resource = createParseResourceObject(true);
 778         CategoryDefinition category = resource.getCategories().get(0);
 779         SubCategoryDefinition subcategory = category.getSubcategories().get(0);
 780         String vendorName = "vendorName";
 781         Assertions.assertNotNull(resource);
 782
 783         testSubject.validateVendorName(vendorName, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
 784     }
 785
 786     @Test
 787     void testFillResourceMetadata2() {
 788         String yamlName = "yamlName";
 789         Resource resourceVf = createParseResourceObject(true);
 790         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
 791         resourceVf.setSystemName("systemName");
 792         Assertions.assertThrows(ComponentException.class, () ->
 793             testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
 794     }
 795
 796     @Test
 797     void testFillResourceMetadataWrongStart() {
 798         String yamlName = "yamlName";
 799         Resource resourceVf = createParseResourceObject(true);
 800         String nodeName = "WrongStart" + "test";
 801         Assertions.assertThrows(ComponentException.class, () ->
 802             testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
 803     }
 804
 805     @Test
 806     void testFillResourceMetadataResourceTypeIsAbs() {
 807         String yamlName = "yamlName";
 808         Resource resourceVf = createParseResourceObject(true);
 809         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + Constants.ABSTRACT;
 810         Assertions.assertNotNull(
 811             testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
 812     }
 813
 814     @Test
 815     void testGetNodeTypeActualName() {
 816         String fullName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "test";
 817         Assertions.assertNotNull(
 818             testSubject.getNodeTypeActualName(fullName));
 819     }
 820
 821     @Test
 822     void testAddInput() {
 823         Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
 824         InputDefinition prop = new InputDefinition();
 825         Assertions.assertNotNull(currPropertiesMap);
 826
 827         testSubject.addInput(currPropertiesMap, prop);
 828     }
 829
 830     @Test
 831     void testFindAviableRequirement() {
 832         String uniqueId = "101929382910";
 833         String regName = uniqueId;
 834         String yamlName = uniqueId;
 835         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 836         ComponentInstance currentCompInstance = new ComponentInstance();
 837
 838         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 839         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
 840         RequirementDefinition requirementDefinition = new RequirementDefinition();
 841         requirementDefinition.setName(uniqueId);
 842         requirementDefinition.setMaxOccurrences("10");
 843         requirementDefinition.setLeftOccurrences("3");
 844         requirementDefinitionList.add(requirementDefinition);
 845         requirements.put(uniqueId, requirementDefinitionList);
 846         currentCompInstance.setRequirements(requirements);
 847
 848         String capName = "capName";
 849
 850         Assertions.assertNotNull(
 851             testSubject.findAvailableRequirement(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
 852     }
 853
 854     @Test
 855     void testFindAviableRequirementSameCapName() {
 856         String uniqueId = "101929382910";
 857         String regName = uniqueId;
 858         String yamlName = uniqueId;
 859         UploadComponentInstanceInfo uploadComponentInstanceInfo = new UploadComponentInstanceInfo();
 860         ComponentInstance currentCompInstance = new ComponentInstance();
 861
 862         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 863         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
 864         RequirementDefinition requirementDefinition = new RequirementDefinition();
 865         requirementDefinition.setName(uniqueId);
 866         requirementDefinition.setMaxOccurrences("10");
 867         requirementDefinition.setLeftOccurrences("3");
 868         requirementDefinitionList.add(requirementDefinition);
 869         requirements.put(uniqueId, requirementDefinitionList);
 870         currentCompInstance.setRequirements(requirements);
 871
 872         String capName = uniqueId;
 873         Assertions.assertNotNull(
 874             testSubject.findAvailableRequirement(regName, yamlName, uploadComponentInstanceInfo, currentCompInstance, capName));
 875     }
 876
 877     @Test
 878     void testFindAvailableCapabilityByTypeOrName() {
 879         RequirementDefinition validReq = new RequirementDefinition();
 880         ComponentInstance currentCapCompInstance = new ComponentInstance();
 881         UploadReqInfo uploadReqInfo = new UploadReqInfo();
 882
 883         Assertions.assertThrows(ComponentException.class, () ->
 884             testSubject.findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadReqInfo));
 885     }
 886
 887     @Test
 888     void testFindAvailableCapability() {
 889         String uniqueId = "23422345677";
 890         RequirementDefinition validReq = new RequirementDefinition();
 891         validReq.setCapability(uniqueId);
 892         ComponentInstance instance = new ComponentInstance();
 893         Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
 894         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 895         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 896         capabilityDefinition.setMaxOccurrences("3");
 897         capabilityDefinition.setLeftOccurrences("2");
 898         capabilityDefinitionList.add(capabilityDefinition);
 899         capabilityMap.put(uniqueId, capabilityDefinitionList);
 900         instance.setCapabilities(capabilityMap);
 901
 902         Assertions.assertNotNull(
 903             testSubject.findAvailableCapability(validReq, instance));
 904     }
 905
 906     @Test
 907     void testfindAvailableCapability2() {
 908         String uniqueId = "23422345677";
 909         RequirementDefinition validReq = new RequirementDefinition();
 910         validReq.setCapability(uniqueId);
 911         ComponentInstance instance = new ComponentInstance();
 912         Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
 913         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 914         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 915         capabilityDefinition.setName(uniqueId);
 916         capabilityDefinition.setMaxOccurrences("3");
 917         capabilityDefinition.setLeftOccurrences("2");
 918         capabilityDefinitionList.add(capabilityDefinition);
 919         capabilityMap.put(uniqueId, capabilityDefinitionList);
 920         instance.setCapabilities(capabilityMap);
 921         UploadReqInfo uploadReqInfo = new UploadReqInfo();
 922         uploadReqInfo.setCapabilityName(uniqueId);
 923
 924         Assertions.assertNotNull(
 925             testSubject.findAvailableCapability(validReq, instance, uploadReqInfo));
 926     }
 927
 928     @Test
 929     void testGetComponentWithInstancesFilter() {
 930
 931         Assertions.assertNotNull(
 932             testSubject.getComponentWithInstancesFilter());
 933     }
 934
 935     @Test
 936     void testCreateParseResourceObject() {
 937         String key = "0923928394";
 938         List<UploadCapInfo> capabilities = new ArrayList<>();
 939         UploadCapInfo uploadCapInfo = new UploadCapInfo();
 940         uploadCapInfo.setType(key);
 941         capabilities.add(uploadCapInfo);
 942
 943         String resourceId = "resourceId";
 944         Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
 945         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 946         capabilityDefinition.setName(key);
 947         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 948         capabilityDefinitionList.add(capabilityDefinition);
 949         defaultCapabilities.put(key, capabilityDefinitionList);
 950
 951         Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
 952         InputDefinition prop = new InputDefinition();
 953
 954         Resource resource = createParseResourceObject(true);
 955         Map<String, List<CapabilityDefinition>> capabilitiesMap = resource.getCapabilities();
 956         capabilitiesMap.put(key, capabilityDefinitionList);
 957
 958         when(toscaOperationFacade.getToscaFullElement(anyString()))
 959             .thenReturn(Either.left(resource));
 960
 961         Assertions.assertNotNull(resource);
 962
 963         testSubject.addValidComponentInstanceCapabilities(key, capabilities, resourceId, defaultCapabilities,
 964             validCapabilitiesMap);
 965     }
 966
 967     @Test
 968     void testGetCapabilityFailure() {
 969         String resourceId = "resourceId";
 970         String key = "0923928394";
 971         Map<String, List<CapabilityDefinition>> defaultCapabilities = new HashMap<>();
 972         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 973         capabilityDefinition.setName(key);
 974         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
 975         capabilityDefinitionList.add(capabilityDefinition);
 976         defaultCapabilities.put(key, capabilityDefinitionList);
 977         String capabilityType = key;
 978         when(toscaOperationFacade.getToscaFullElement(anyString()))
 979             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 980         Assertions.assertThrows(ComponentException.class, () ->
 981             testSubject.getCapability(resourceId, defaultCapabilities, capabilityType));
 982     }
 983
 984     @Test
 985     void testValidateCapabilityProperties() {
 986         List<UploadCapInfo> capabilities = new ArrayList<>();
 987         UploadCapInfo uploadCapInfo = new UploadCapInfo();
 988         List<UploadPropInfo> properties = new ArrayList<>();
 989         UploadPropInfo uploadPropInfo = new UploadPropInfo();
 990         properties.add(uploadPropInfo);
 991         uploadCapInfo.setProperties(properties);
 992         capabilities.add(uploadCapInfo);
 993         String resourceId = "resourceId";
 994         CapabilityDefinition defaultCapability = new CapabilityDefinition();
 995         defaultCapability.setProperties(null);
 996         defaultCapability.setName("test");
 997
 998         Assertions.assertThrows(ComponentException.class, () ->
 999             testSubject.validateCapabilityProperties(capabilities, resourceId, defaultCapability));
1000     }
1001
1002     @Test
1003     void testValidateUniquenessUpdateUploadedComponentInstanceCapability() {
1004         String key = "02124568";
1005         List<UploadCapInfo> capabilities = new ArrayList<>();
1006         UploadCapInfo uploadCapInfo = new UploadCapInfo();
1007         List<UploadPropInfo> properties = new ArrayList<>();
1008         UploadPropInfo uploadPropInfo = new UploadPropInfo();
1009         uploadPropInfo.setName(key);
1010         properties.add(uploadPropInfo);
1011         uploadCapInfo.setProperties(properties);
1012         capabilities.add(uploadCapInfo);
1013         String resourceId = "resourceId";
1014         CapabilityDefinition defaultCapability = new CapabilityDefinition();
1015         List<ComponentInstanceProperty> componentInstancePropertyList = new ArrayList<>();
1016         ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
1017         componentInstancePropertyList.add(componentInstanceProperty);
1018         defaultCapability.setProperties(componentInstancePropertyList);
1019         defaultCapability.setName(key);
1020
1021         Assertions.assertNotNull(defaultCapability);
1022
1023         testSubject.validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, uploadCapInfo);
1024     }
1025
1026     @Test
1027     void testSetDeploymentArtifactsPlaceHolderByResource() {
1028         Resource resource = createParseResourceObject(true);
1029
1030         Assertions.assertNotNull(resource);
1031
1032         testSubject.setDeploymentArtifactsPlaceHolder(resource, user);
1033     }
1034
1035     @Test
1036     void testSetDeploymentArtifactsPlaceHolderByService() {
1037         Service Service = createServiceObject(true);
1038
1039         Assertions.assertNotNull(Service);
1040
1041         testSubject.setDeploymentArtifactsPlaceHolder(Service, user);
1042     }
1043
1044     @Test
1045     void testProcessDeploymentResourceArtifacts() {
1046         Resource resource = createParseResourceObject(true);
1047         resource.setResourceType(ResourceTypeEnum.VF);
1048         Map<String, ArtifactDefinition> artifactMap = new HashMap<>();
1049         String k = "key";
1050         Object v = new Object();
1051         Map<String, List<String>> artifactDetails = new HashMap<>();
1052         List<String> artifactTypes = new ArrayList<>();
1053         artifactTypes.add(ResourceTypeEnum.VF.name());
1054         artifactDetails.put("validForResourceTypes", artifactTypes);
1055         v = artifactDetails;
1056         Assertions.assertNotNull(resource);
1057
1058         testSubject.processDeploymentResourceArtifacts(user, resource, artifactMap, k, v);
1059     }
1060
1061     @Test
1062     void testMergeOldResourceMetadataWithNew() {
1063         Resource oldResource = createParseResourceObject(true);
1064         Resource newResource = new Resource();
1065
1066         Assertions.assertNotNull(oldResource);
1067
1068         testSubject.mergeOldResourceMetadataWithNew(oldResource, newResource);
1069     }
1070
1071     @Test
1072     void testBuildComplexVfcMetadata() {
1073         Resource resource = createParseResourceObject(true);
1074         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1075         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1076         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1077         List<String> derivedFrom = new ArrayList<>();
1078         derivedFrom.add("derivedFrom");
1079         nodeTypeInfo.setDerivedFrom(derivedFrom);
1080         nodesInfo.put(nodeName, nodeTypeInfo);
1081
1082         Assertions.assertNotNull(
1083             testSubject.buildComplexVfcMetadata(getCsarInfo(), nodeName, nodesInfo));
1084     }
1085
1086     @Test
1087     void testValidateResourceCreationFromNodeType() {
1088         Resource resource = createParseResourceObject(true);
1089         resource.setDerivedFrom(null);
1090         Assertions.assertThrows(ComponentException.class, () ->
1091             testSubject.validateResourceCreationFromNodeType(resource, user));
1092     }
1093
1094     @Test
1095     void testCreateInputsOnResource() {
1096         Resource resource = createParseResourceObject(true);
1097         Map<String, InputDefinition> inputs = new HashMap<>();
1098
1099         Assertions.assertNotNull(
1100             testSubject.createInputsOnResource(resource, inputs));
1101     }
1102
1103     @Test
1104     void testCreateInputsOnResourceWhenIsNotEmpty() {
1105         String key = "12345667";
1106         Resource resource = createParseResourceObject(true);
1107         List<InputDefinition> inputDefinitionList = new ArrayList<>();
1108         InputDefinition inputDefinition = new InputDefinition();
1109         inputDefinitionList.add(inputDefinition);
1110         resource.setInputs(inputDefinitionList);
1111         Map<String, InputDefinition> inputs = new HashMap<>();
1112         inputs.put(key, inputDefinition);
1113         when(inputsBusinessLogic.createInputsInGraph(anyMap(),
1114             any(Component.class))).thenReturn(Either.left(inputDefinitionList));
1115         when(toscaOperationFacade
1116             .getToscaElement(anyString())).thenReturn(Either.left(resource));
1117         Assertions.assertNotNull(
1118             testSubject.createInputsOnResource(resource, inputs));
1119     }
1120
1121     @Test
1122     void testCreateInputsOnService() {
1123         Service service = createServiceObject(true);
1124         List<InputDefinition> resourceProperties = new ArrayList<>();
1125         InputDefinition inputDefinition = new InputDefinition();
1126         inputDefinition.setName("inputDefinitionName");
1127         service.setInputs(resourceProperties);
1128         Map<String, InputDefinition> inputs = new HashMap<>();
1129         InputDefinition inputDefinitionMap = new InputDefinition();
1130         inputDefinition.setName("inputDefinitionName");
1131         inputs.put("inputsMap", inputDefinitionMap);
1132         List<InputDefinition> inputDefinitionList = new ArrayList<>();
1133         Service newService = new Service();
1134
1135         when(inputsBusinessLogic.createInputsInGraph(any(Map.class), any(Component.class)))
1136             .thenReturn(Either.left(inputDefinitionList));
1137         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(newService));
1138         Service inputsOnService = testSubject.createInputsOnService(service, inputs);
1139         assertNotNull(inputsOnService);
1140     }
1141
1142     @Test
1143     void testCreateOutputsOnService_OK() {
1144         Service service = createServiceObject(true);
1145         List<OutputDefinition> resourceOutputs = new ArrayList<>();
1146         OutputDefinition outputDefinition = new OutputDefinition();
1147         resourceOutputs.add(outputDefinition);
1148         outputDefinition.setName("outputDefinitionName");
1149         service.setOutputs(resourceOutputs);
1150         Map<String, OutputDefinition> outputs = new HashMap<>();
1151         outputs.put("outputsMap", outputDefinition);
1152
1153         when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId())).thenReturn(Either.left(resourceOutputs));
1154         when(toscaOperationFacade.getToscaElement(service.getUniqueId())).thenReturn(Either.left(service));
1155         Service outputsOnService = testSubject.createOutputsOnService(service, outputs, user.getUserId());
1156         assertNotNull(outputsOnService);
1157         assertSame(service, outputsOnService);
1158     }
1159
1160     @Test
1161     void testCreateOutputsOnService_Fail_whenOutputsIsEmpty() {
1162         Service service = createServiceObject(true);
1163         Map<String, OutputDefinition> outputs = new HashMap<>();
1164         Service outputsOnService = testSubject.createOutputsOnService(service, outputs, user.getUserId());
1165         assertNotNull(outputsOnService);
1166         assertSame(service, outputsOnService);
1167     }
1168
1169     @Test
1170     void testCreateOutputsOnService_Fail_createOutputsInGraph() {
1171         Service service = createServiceObject(true);
1172         List<OutputDefinition> resourceOutputs = new ArrayList<>();
1173         OutputDefinition outputDefinition = new OutputDefinition();
1174         resourceOutputs.add(outputDefinition);
1175         outputDefinition.setName("outputDefinitionName");
1176         service.setOutputs(resourceOutputs);
1177         Map<String, OutputDefinition> outputs = new HashMap<>();
1178         outputs.put("outputsMap", outputDefinition);
1179
1180         when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId()))
1181             .thenReturn(Either.right(new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode())));
1182
1183         final var componentException = assertThrows(ComponentException.class, () -> {
1184             testSubject.createOutputsOnService(service, outputs, user.getUserId());
1185         });
1186         assertNotNull(componentException);
1187         assertEquals(ActionStatus.OK, componentException.getActionStatus());
1188         assertEquals(400, componentException.getResponseFormat().getStatus());
1189     }
1190
1191     @Test
1192     void testCreateOutputsOnService_Fail_getToscaElement() {
1193         Service service = createServiceObject(true);
1194         List<OutputDefinition> resourceOutputs = new ArrayList<>();
1195         OutputDefinition outputDefinition = new OutputDefinition();
1196         resourceOutputs.add(outputDefinition);
1197         outputDefinition.setName("outputDefinitionName");
1198         service.setOutputs(resourceOutputs);
1199         Map<String, OutputDefinition> outputs = new HashMap<>();
1200         outputs.put("outputsMap", outputDefinition);
1201
1202         when(outputsBusinessLogic.createOutputsInGraph(outputs, service, user.getUserId())).thenReturn(Either.left(resourceOutputs));
1203         when(toscaOperationFacade.getToscaElement(service.getUniqueId())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1204
1205         final var componentException = assertThrows(ComponentException.class, () -> {
1206             testSubject.createOutputsOnService(service, outputs, user.getUserId());
1207         });
1208         assertNotNull(componentException);
1209         assertEquals(ActionStatus.OK, componentException.getActionStatus());
1210         assertEquals(400, componentException.getResponseFormat().getStatus());
1211     }
1212
1213     @Test
1214     void testAssociateCINodeFilterToComponent() {
1215         String yamlName = "yamlName.yml";
1216         Service service = createServiceObject(true);
1217         Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1218         nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1219
1220         when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1221             .thenReturn(StorageOperationStatus.OK);
1222
1223         testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap);
1224         verify(componentNodeFilterBusinessLogic, times(1)).associateNodeFilterToComponentInstance(service.getUniqueId(),
1225             nodeFilterMap);
1226     }
1227
1228     @Test
1229     void testAssociateCINodeFilterToComponentFail() {
1230         String yamlName = "yamlName.yml";
1231         Service service = createServiceObject(true);
1232         Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
1233         nodeFilterMap.put("componentInstanceID", new UploadNodeFilterInfo());
1234
1235         when(componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(service.getUniqueId(), nodeFilterMap))
1236             .thenReturn(StorageOperationStatus.NOT_FOUND);
1237
1238         Assertions.assertThrows(ComponentException.class, () -> testSubject.associateCINodeFilterToComponent(yamlName, service, nodeFilterMap));
1239     }
1240
1241     @Test
1242     void testCreateServiceTransaction() {
1243         Service service = createServiceObject(true);
1244         List<ComponentInstance> list = new ArrayList<>();
1245         ComponentInstance componentInstance = new ComponentInstance();
1246         componentInstance.setName("name");
1247         service.setComponentInstances(list);
1248         when(toscaOperationFacade.validateComponentNameExists(
1249             anyString(), any(ResourceTypeEnum.class), any(ComponentTypeEnum.class))).thenReturn(Either.left(false));
1250
1251         when(toscaOperationFacade.createToscaComponent(any(Service.class))).thenReturn(Either.left(service));
1252
1253         Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true, null));
1254     }
1255
1256     @Test
1257     void testCreateArtifactsPlaceHolderData() {
1258         Service service = createServiceObject(true);
1259         CategoryDefinition category = new CategoryDefinition();
1260         category.setName("");
1261         List<CategoryDefinition> categories = new ArrayList<>();
1262         categories.add(category);
1263         service.setCategories(categories);
1264         Assertions.assertNotNull(service);
1265
1266         testSubject.createArtifactsPlaceHolderData(service, user);
1267
1268     }
1269
1270     @Test
1271     void testSetInformationalArtifactsPlaceHolder() {
1272         Service service = createServiceObject(true);
1273
1274         Assertions.assertNotNull(service);
1275
1276         testSubject.setInformationalArtifactsPlaceHolder(service, user);
1277
1278     }
1279
1280     @Test
1281     void testValidateNestedDerivedFromDuringUpdate() {
1282         Resource currentResource = createParseResourceObject(true);
1283         Resource updateInfoResource = createParseResourceObject(true);
1284         String key = "2323456";
1285
1286         List<String> currentDerivedFromList = new ArrayList<>();
1287         currentDerivedFromList.add(key);
1288         currentResource.setDerivedFrom(currentDerivedFromList);
1289         List<String> updatedDerivedFromList = new ArrayList<>();
1290         updatedDerivedFromList.add("23344567778");
1291         updateInfoResource.setDerivedFrom(updatedDerivedFromList);
1292
1293         when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1294             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1295
1296         Assertions.assertNotNull(
1297             testSubject.validateNestedDerivedFromDuringUpdate(currentResource, updateInfoResource, true));
1298
1299     }
1300
1301     @Test
1302     void testValidateDerivedFromExtending() {
1303         Resource currentResource = createParseResourceObject(true);
1304         Resource updateInfoResource = createParseResourceObject(true);
1305
1306         when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString(), any()))
1307             .thenReturn(Either.left(false));
1308
1309         Assertions.assertNotNull(
1310             testSubject.validateDerivedFromExtending(user, currentResource, updateInfoResource,
1311                 AuditingActionEnum.IMPORT_RESOURCE));
1312
1313     }
1314
1315     @Test
1316     void testValidateResourceFieldsBeforeUpdate() {
1317         Resource currentResource = createParseResourceObject(true);
1318         Resource updateInfoResource = createParseResourceObject(true);
1319
1320         Assertions.assertNotNull(currentResource);
1321
1322         testSubject.validateResourceFieldsBeforeUpdate(currentResource, updateInfoResource, true, true);
1323
1324     }
1325
1326     @Test
1327     void testValidateResourceName() {
1328         Resource currentResource = createParseResourceObject(true);
1329         Resource updateInfoResource = createParseResourceObject(true);
1330         currentResource.setName("test1");
1331         updateInfoResource.setName("test2");
1332
1333         Assertions.assertThrows(ComponentException.class, () ->
1334             testSubject.validateResourceName(currentResource, updateInfoResource, true, false));
1335
1336     }
1337
1338     @Test
1339     void testIsResourceNameEquals() {
1340         Resource currentResource = createParseResourceObject(true);
1341         Resource updateInfoResource = createParseResourceObject(true);
1342
1343         boolean resourceNameEquals = testSubject.isResourceNameEquals(currentResource, updateInfoResource);
1344         assertTrue(resourceNameEquals);
1345     }
1346
1347     @Test
1348     void testPrepareResourceForUpdate() {
1349         Resource oldResource = createParseResourceObject(true);
1350         Resource newResource = createParseResourceObject(true);
1351         when(lifecycleBusinessLogic.changeState(anyString(), any(User.class), any(LifeCycleTransitionEnum.class),
1352             any(LifecycleChangeInfoWithAction.class), anyBoolean(), anyBoolean())).thenReturn(Either.left(oldResource));
1353
1354         Assertions.assertNotNull(
1355             testSubject.prepareResourceForUpdate(oldResource, newResource, user, true, true));
1356
1357     }
1358
1359     @Test
1360     void testFailOnChangeState() {
1361         ResponseFormat response = new ResponseFormat();
1362         Resource oldResource = createParseResourceObject(true);
1363         oldResource.setUniqueId("123");
1364         Resource newResource = createParseResourceObject(true);
1365
1366         Assertions.assertThrows(ComponentException.class, () ->
1367             testSubject.failOnChangeState(response, user, oldResource, newResource));
1368     }
1369
1370     @Test
1371     void testHandleResourceGenericType() {
1372         Resource resource = createParseResourceObject(true);
1373
1374         Resource resource1 = testSubject.handleResourceGenericType(resource);
1375         assertNotEquals(resource, resource1);
1376     }
1377
1378     @Test
1379     void testUpdateOrCreateGroups() {
1380         Resource resource = createParseResourceObject(true);
1381         Map<String, GroupDefinition> groups = new HashMap<>();
1382         Assertions.assertNotNull(resource);
1383
1384         testSubject.updateOrCreateGroups(resource, groups);
1385     }
1386
1387     @Test
1388     void testAddGroupsToCreateOrUpdate() {
1389         List<GroupDefinition> groupsFromResource = new ArrayList<>();
1390         GroupDefinition groupDefinition = new GroupDefinition();
1391         groupDefinition.setInvariantName("groupDefinitionName");
1392         groupsFromResource.add(groupDefinition);
1393         List<GroupDefinition> groupsAsList = new ArrayList<>();
1394         GroupDefinition groupNewDefinition = getGroupDefinition();
1395         groupsAsList.add(groupNewDefinition);
1396         List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1397         List<GroupDefinition> groupsToCreate = new ArrayList<>();
1398         Assertions.assertNotNull(groupDefinition);
1399
1400         testSubject.addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1401     }
1402
1403     @Test
1404     void testAddGroupsToDelete() {
1405         List<GroupDefinition> groupsFromResource = new ArrayList<>();
1406         GroupDefinition groupDefinition = new GroupDefinition();
1407         groupDefinition.setName("groupDefinitionName");
1408         groupsFromResource.add(groupDefinition);
1409         List<GroupDefinition> groupsAsList = new ArrayList<>();
1410         GroupDefinition groupNewDefinition = new GroupDefinition();
1411         groupNewDefinition.setName("groupNewDefinitionName");
1412         groupsAsList.add(groupNewDefinition);
1413         List<GroupDefinition> groupsToDelete = new ArrayList<>();
1414         Assertions.assertNotNull(groupsFromResource);
1415
1416         testSubject.addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1417     }
1418
1419     @Test
1420     void testUpdateGroupsMembersUsingResource() {
1421         Service component = createServiceObject(true);
1422         Map<String, GroupDefinition> groups = new HashMap<>();
1423         GroupDefinition groupDefinition = getGroupDefinition();
1424         groupDefinition.setMembers(null);
1425         groups.put("groupsMap", groupDefinition);
1426
1427         Assertions.assertNotNull(
1428             testSubject.updateGroupsMembersUsingResource(groups, component));
1429     }
1430
1431     @Test
1432     void testupdateGroupMembers() {
1433         Service component = createServiceObject(true);
1434         Map<String, GroupDefinition> groups = new HashMap<>();
1435         GroupDefinition updatedGroupDefinition = new GroupDefinition();
1436         List<ComponentInstance> componentInstances = new ArrayList<>();
1437         String groupName = "groupName";
1438         Map<String, String> members = new HashMap<>();
1439
1440         Assertions.assertThrows(ComponentException.class, () ->
1441             testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1442     }
1443
1444     @Test
1445     void testupdateGroupMembersNotNull() {
1446         Service component = createServiceObject(true);
1447         Map<String, GroupDefinition> groups = getGroups();
1448         GroupDefinition updatedGroupDefinition = new GroupDefinition();
1449         List<ComponentInstance> componentInstances = new ArrayList<>();
1450         ComponentInstance componentInstance = new ComponentInstance();
1451         componentInstance.setName("componentInstanceName");
1452         componentInstance.setUniqueId("componentInstanceUniqueId");
1453         componentInstances.add(componentInstance);
1454         String groupName = "groupName";
1455         Map<String, String> members = new HashMap<>();
1456         members.put("members", "members");
1457         members.put("componentInstanceName", "members");
1458
1459         Assertions.assertThrows(ComponentException.class, () ->
1460             testSubject.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members));
1461     }
1462
1463     @Test
1464     void testFillResourceMetadataForServiceFailure() {
1465         String yamlName = "yamlName";
1466         Service resourceVf = createServiceObject(true);
1467         String nodeName = "nodeName";
1468
1469         Assertions.assertThrows(ComponentException.class, () ->
1470             testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1471     }
1472
1473     @Test
1474     void testFillResourceMetadataForServiceWrongType() {
1475         String yamlName = "yamlName";
1476         Service resourceVf = createServiceObject(true);
1477         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "nodeName";
1478
1479         Assertions.assertThrows(ComponentException.class, () ->
1480             testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1481     }
1482
1483     @Test
1484     void testFillResourceMetadataForServiceSuccess() {
1485         String yamlName = "yamlName";
1486         Service resourceVf = createServiceObject(true);
1487         String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "VFC";
1488
1489         Assertions.assertNotNull(
1490             testSubject.fillResourceMetadata(yamlName, resourceVf, nodeName, user));
1491     }
1492
1493     @Test
1494     void testpropagateStateToCertified() {
1495         String yamlName = "yamlName";
1496         Resource resource = createParseResourceObject(true);
1497         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1498         LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1499
1500         Assertions.assertNotNull(
1501             testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1502     }
1503
1504     @Test
1505     void testpropagateStateToCertifiedIsTrue() {
1506         String yamlName = "yamlName";
1507         Resource resource = createParseResourceObject(true);
1508         LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
1509         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1510
1511         Assertions.assertNotNull(
1512             testSubject.propagateStateToCertified(user, resource, lifecycleChangeInfo, true, true, true));
1513     }
1514
1515     @Test
1516     void testBuildValidComplexVfc2() {
1517         String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
1518         Map<String, NodeTypeInfo> nodesInfo = new HashMap<>();
1519         NodeTypeInfo nodeTypeInfo = new NodeTypeInfo();
1520         List<String> derivedFrom = new ArrayList<>();
1521         derivedFrom.add("derivedFrom");
1522         nodeTypeInfo.setDerivedFrom(derivedFrom);
1523         nodesInfo.put(nodeName, nodeTypeInfo);
1524
1525         final CsarInfo csarInfo = getCsarInfo();
1526         Assertions.assertThrows(ComponentException.class, () ->
1527             testSubject.buildValidComplexVfc(csarInfo, nodeName, nodesInfo));
1528     }
1529
1530     @Test
1531     void testUpdateGroupsOnResourceEmptyGroups() {
1532         Resource resource = createParseResourceObject(true);
1533         Map<String, GroupDefinition> groups = new HashMap<>();
1534
1535         Assertions.assertNotNull(
1536             testSubject.updateGroupsOnResource(resource, groups));
1537     }
1538
1539     @Test
1540     void testSetInformationalArtifactsPlaceHolder2() {
1541         Resource resource = createParseResourceObject(true);
1542         List<CategoryDefinition> categoryDefinitions = new ArrayList<>();
1543         CategoryDefinition categoryDefinition = new CategoryDefinition();
1544         categoryDefinition.setName("");
1545         categoryDefinitions.add(categoryDefinition);
1546         resource.setCategories(categoryDefinitions);
1547         Assertions.assertNotNull(resource);
1548
1549         testSubject.setInformationalArtifactsPlaceHolder(resource, user);
1550     }
1551
1552     @Test
1553     void testRollback() {
1554         Resource resource = createParseResourceObject(true);
1555         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1556         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1557         createdArtifacts.add(artifactDefinition);
1558         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1559         nodeTypesNewCreatedArtifacts.add(artifactDefinition);
1560         Assertions.assertNotNull(resource);
1561
1562         testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1563     }
1564
1565     @Test
1566     void testRollback_NotNull() {
1567         Resource resource = createParseResourceObject(true);
1568         List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1569         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
1570         artifactDefinition.setArtifactName("artifactName");
1571         createdArtifacts.add(artifactDefinition);
1572         List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1573         ArtifactDefinition artifactDefinition2 = new ArtifactDefinition();
1574         artifactDefinition2.setArtifactChecksum("artifactChecksum");
1575         nodeTypesNewCreatedArtifacts.add(artifactDefinition2);
1576         Assertions.assertNotNull(resource);
1577
1578         testSubject.rollback(true, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1579     }
1580
1581     @Test
1582     void testCreateArtifactsPlaceHolderData2() {
1583         Resource resource = createParseResourceObject(true);
1584
1585         Assertions.assertNotNull(resource);
1586
1587         testSubject.createArtifactsPlaceHolderData(resource, user);
1588     }
1589
1590     @Test
1591     void testHandleGroupsProperties() {
1592         Service service = createServiceObject(true);
1593         Map<String, GroupDefinition> groups = getGroups();
1594         Assertions.assertNotNull(service);
1595
1596         testSubject.handleGroupsProperties(service, groups);
1597     }
1598
1599     @Test
1600     void testHandleGroupsProperties2() {
1601         Resource resource = createParseResourceObject(true);
1602         Map<String, GroupDefinition> groups = getGroups();
1603         Assertions.assertNotNull(resource);
1604
1605         testSubject.handleGroupsProperties(resource, groups);
1606     }
1607
1608     @Test
1609     void testHandleGetInputs() {
1610         PropertyDataDefinition property = new PropertyDataDefinition();
1611         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1612         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1613         GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1614         getInput.setInputId("inputId");
1615         getInput.setInputName("inputName");
1616         getInputValueDataDefinition.setInputName("inputName");
1617         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1618         getInputValueDataDefinition.setGetInputIndex(getInputValueDataDefinition);
1619         getInputValues.add(getInputValueDataDefinition);
1620         property.setGetInputValues(getInputValues);
1621         List<InputDefinition> inputs = new ArrayList<>();
1622         InputDefinition inputDefinition = new InputDefinition();
1623         inputDefinition.setName("inputName");
1624         inputDefinition.setUniqueId("abc12345");
1625         inputs.add(inputDefinition);
1626         Assertions.assertNotNull(inputs);
1627
1628         testSubject.handleGetInputs(property, inputs);
1629     }
1630
1631     @Test
1632     void testHandleGetInputs_null() {
1633         PropertyDataDefinition property = new PropertyDataDefinition();
1634         List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1635         GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
1636         getInputValueDataDefinition.setInputName("inputName");
1637         getInputValueDataDefinition.setPropName("getInputValueDataDefinitionName");
1638         getInputValues.add(getInputValueDataDefinition);
1639         property.setGetInputValues(getInputValues);
1640         List<InputDefinition> inputs = new ArrayList<>();
1641         Assertions.assertThrows(NoSuchElementException.class, () ->
1642             testSubject.handleGetInputs(property, inputs));
1643     }
1644
1645     @Test
1646     void testFindInputByName() {
1647         GetInputValueDataDefinition getInput = new GetInputValueDataDefinition();
1648         getInput.setInputId("inputId");
1649         getInput.setInputName("inputName");
1650         List<InputDefinition> inputs = new ArrayList<>();
1651         InputDefinition inputDefinition = new InputDefinition();
1652         inputDefinition.setName("inputName");
1653         inputDefinition.setUniqueId("abc12345");
1654         inputs.add(inputDefinition);
1655
1656         Assertions.assertNotNull(
1657             testSubject.findInputByName(inputs, getInput));
1658     }
1659
1660     @Test
1661     void testAssociateComponentInstancePropertiesToComponent() {
1662         String yamlName = "yamlName";
1663         Resource resource = createParseResourceObject(true);
1664         Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1665         Assertions.assertThrows(ComponentException.class, () ->
1666             testSubject.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties));
1667     }
1668
1669     @Test
1670     void testAssociateComponentInstanceInputsToComponent() {
1671         String yamlName = "yamlName";
1672         Resource resource = createParseResourceObject(true);
1673         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1674         List<ComponentInstanceInput> componentInstanceInputList = new ArrayList<>();
1675         ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1676         componentInstanceInput.setName("componentInstanceInputName");
1677         componentInstanceInputList.add(componentInstanceInput);
1678         Assertions.assertNotNull(resource);
1679
1680         testSubject.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1681     }
1682
1683     @Test
1684     void testAssociateDeploymentArtifactsToInstances() {
1685         String yamlName = "yamlName";
1686         Resource resource = createParseResourceObject(true);
1687         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1688
1689         Assertions.assertThrows(ComponentException.class, () ->
1690             testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1691     }
1692
1693     @Test
1694     void testAssociateArtifactsToInstances() {
1695         String yamlName = "yamlName";
1696         Resource resource = createParseResourceObject(true);
1697         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1698
1699         Assertions.assertThrows(ComponentException.class, () ->
1700             testSubject.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts));
1701     }
1702
1703     @Test
1704     void testAssociateArtifactsToInstances2() {
1705         String yamlName = "yamlName";
1706         Resource resource = createParseResourceObject(true);
1707         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1708
1709         Assertions.assertThrows(ComponentException.class, () ->
1710             testSubject.associateArtifactsToInstances(yamlName, resource, instDeploymentArtifacts));
1711     }
1712
1713     @Test
1714     void testAssociateOrAddCalculatedCapReq() {
1715         String yamlName = "yamlName";
1716         Resource resource = createParseResourceObject(true);
1717         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1718         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1719         Assertions.assertThrows(ComponentException.class, () ->
1720             testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1721     }
1722
1723     @Test
1724     void testAssociateInstAttributeToComponentToInstances() {
1725         String yamlName = "yamlName";
1726         Resource resource = createParseResourceObject(true);
1727         Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1728         Assertions.assertThrows(ComponentException.class, () ->
1729             testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1730     }
1731
1732     @Test
1733     void testThrowComponentExceptionByResource() {
1734         StorageOperationStatus status = StorageOperationStatus.OK;
1735         Resource resource = createParseResourceObject(true);
1736         Assertions.assertThrows(ComponentException.class, () ->
1737             testSubject.throwComponentExceptionByResource(status, resource));
1738     }
1739
1740     @Test
1741     void testGetResourceAfterCreateRelations() {
1742         Resource resource = createParseResourceObject(true);
1743         Resource newResource = new Resource();
1744
1745         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1746             .thenReturn(Either.left(newResource));
1747         Resource resourceAfterCreateRelations = testSubject.getResourceAfterCreateRelations(resource);
1748         assertNotNull(resourceAfterCreateRelations);
1749     }
1750
1751     @Test
1752     void testSetCapabilityNamesTypes() {
1753         Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1754         List<CapabilityDefinition> capabilityDefinitionList = new ArrayList<>();
1755         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1756         capabilityDefinition.setName("Capability");
1757         capabilityDefinition.setType("Resource");
1758         capabilityDefinitionList.add(capabilityDefinition);
1759         originCapabilities.put("Capability", capabilityDefinitionList);
1760         Map<String, List<UploadCapInfo>> uploadedCapabilities = new HashMap<>();
1761         List<UploadCapInfo> uploadCapInfoList = new ArrayList<>();
1762         UploadCapInfo uploadCapInfo = new UploadCapInfo();
1763         uploadCapInfoList.add(uploadCapInfo);
1764         uploadedCapabilities.put("Capability", uploadCapInfoList);
1765         Assertions.assertNotNull(originCapabilities);
1766
1767         testSubject.setCapabilityNamesTypes(originCapabilities, uploadedCapabilities);
1768     }
1769
1770     @Test
1771     void testAssociateComponentInstanceInputsToComponent2() {
1772         String yamlName = "yamlName";
1773         Service service = createServiceObject(true);
1774         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1775
1776         Assertions.assertNotNull(service);
1777
1778         testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1779     }
1780
1781     @Test
1782     void testAssociateComponentInstanceInputsNotNullToComponent2() {
1783         String yamlName = "yamlName";
1784         Service service = createServiceObject(true);
1785         Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1786         List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
1787         ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
1788         componentInstanceInput.setName("ComponentInstanceInputName");
1789         componentInstanceInputs.add(componentInstanceInput);
1790         instInputs.put("instInputs", componentInstanceInputs);
1791         when(toscaOperationFacade.associateComponentInstanceInputsToComponent(any(Map.class),
1792             anyString())).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1793         Assertions.assertThrows(ComponentException.class, () ->
1794             testSubject.associateComponentInstanceInputsToComponent(yamlName, service, instInputs));
1795     }
1796
1797     @Test
1798     void testAssociateComponentInstancePropertiesToComponent2() {
1799         String yamlName = "yamlName";
1800         Service service = createServiceObject(true);
1801         Map<String, List<ComponentInstanceProperty>> instInputs = new HashMap<>();
1802         Map<String, List<ComponentInstanceProperty>> instInputMap = new HashMap<>();
1803         when(toscaOperationFacade.associateComponentInstancePropertiesToComponent(any(), anyString()))
1804             .thenReturn(Either.left(instInputMap));
1805         Assertions.assertNotNull(service);
1806
1807         testSubject.associateComponentInstancePropertiesToComponent(yamlName, service, instInputs);
1808     }
1809
1810     @Test
1811     void testAssociateDeploymentArtifactsToInstances2() {
1812         String yamlName = "yamlName";
1813         Service service = createServiceObject(true);
1814         Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1815
1816         Assertions.assertThrows(ComponentException.class, () ->
1817             testSubject.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts));
1818     }
1819
1820     @Test
1821     void testAssociateArtifactsToInstances3() {
1822         String yamlName = "yamlName";
1823         Service service = createServiceObject(true);
1824         Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1825
1826         Assertions.assertThrows(ComponentException.class, () ->
1827             testSubject.associateArtifactsToInstances(yamlName, service, instArtifacts));
1828     }
1829
1830     @Test
1831     void testAssociateOrAddCalculatedCapReq2() {
1832         String yamlName = "yamlName";
1833         Service resource = createServiceObject(true);
1834         Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1835         Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1836         Assertions.assertThrows(ComponentException.class, () ->
1837             testSubject.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements));
1838     }
1839
1840     @Test
1841     void testAssociateInstAttributeToComponentToInstances2() {
1842         String yamlName = "yamlName";
1843         Service resource = createServiceObject(true);
1844         Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1845         Assertions.assertThrows(ComponentException.class, () ->
1846             testSubject.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes));
1847     }
1848
1849     @Test
1850     void testAssociateRequirementsToService() {
1851         String yamlName = "yamlName";
1852         Service resource = createServiceObject(true);
1853         Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
1854         Assertions.assertThrows(ComponentException.class, () ->
1855             testSubject.associateRequirementsToService(yamlName, resource, requirements));
1856     }
1857
1858     @Test
1859     void testAssociateCapabilitiesToService() {
1860         String yamlName = "yamlName";
1861         Service resource = createServiceObject(true);
1862         Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
1863         Assertions.assertThrows(ComponentException.class, () ->
1864             testSubject.associateCapabilitiesToService(yamlName, resource, capabilities));
1865     }
1866
1867     @Test
1868     void testAssociateResourceInstances() {
1869         String yamlName = "yamlName";
1870         Service resource = createServiceObject(true);
1871         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1872         when(toscaOperationFacade.associateResourceInstances(any(Component.class),
1873             anyString(), any(ArrayList.class))).thenReturn(Either.left(relations));
1874         Assertions.assertNotNull(resource);
1875
1876         testSubject.associateResourceInstances(yamlName, resource, relations);
1877     }
1878
1879     @Test
1880     void testAddCapabilities() {
1881         Map<String, List<CapabilityDefinition>> originCapabilities = new HashMap<>();
1882         String type = "type";
1883         List<CapabilityDefinition> capabilities = new ArrayList<>();
1884         Assertions.assertNotNull(type);
1885
1886         testSubject.addCapabilities(originCapabilities, type, capabilities);
1887     }
1888
1889     @Test
1890     void testAddCapabilitiesProperties() {
1891         Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1892         List<UploadCapInfo> capabilities = new ArrayList<>();
1893         UploadCapInfo capability = new UploadCapInfo();
1894         List<UploadPropInfo> properties = new ArrayList<>();
1895         UploadPropInfo uploadPropInfo = new UploadPropInfo();
1896         uploadPropInfo.setName("uploadPropInfoName");
1897         properties.add(uploadPropInfo);
1898         capability.setProperties(properties);
1899         capability.setName("capabilityName");
1900         capabilities.add(capability);
1901         Assertions.assertNotNull(capabilities);
1902
1903         testSubject.addCapabilitiesProperties(newPropertiesMap, capabilities);
1904     }
1905
1906     @Test
1907     void testGetServiceWithGroups() {
1908         String resourceId = "resourceId";
1909         Service service = createServiceObject(true);
1910         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1911             .thenReturn(Either.left(service));
1912         Assertions.assertNotNull(
1913             testSubject.getServiceWithGroups(resourceId));
1914     }
1915
1916     @Test
1917     void testGetResourceWithGroups() {
1918         String resourceId = "resourceId";
1919         Resource resource = createParseResourceObject(false);
1920         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
1921             .thenReturn(Either.left(resource));
1922         Assertions.assertNotNull(
1923             testSubject.getResourceWithGroups(resourceId));
1924     }
1925
1926     @Test
1927     void testAssociateResourceInstances2() {
1928         String yamlName = "yamlName";
1929         Resource resource = createParseResourceObject(true);
1930         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1931         when(toscaOperationFacade.associateResourceInstances(any(Resource.class),
1932             anyString(), any(ArrayList.class))).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1933         Assertions.assertThrows(ComponentException.class, () ->
1934             testSubject.associateResourceInstances(yamlName, resource, relations));
1935     }
1936
1937     @Test
1938     void testAddRelationsToRI() {
1939         String yamlName = "group.yml";
1940         Resource resource = createResourceObject(false);
1941
1942         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1943         UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1944         nodesInfoValue.getRequirements().get("requirements").get(0).setName("zxjtestimportserviceab0.mme_ipu_vdu.dependency.test");
1945         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1946         List<ComponentInstance> componentInstancesList = creatComponentInstances();
1947         ComponentInstance componentInstance = new ComponentInstance();
1948         componentInstance.setName("zxjTestImportServiceAb");
1949         componentInstancesList.add(componentInstance);
1950         resource.setComponentInstances(componentInstancesList);
1951         componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setLeftOccurrences("1");
1952         componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setMaxOccurrences("1");
1953         componentInstancesList.get(0).getRequirements().get("tosca.capabilities.Node").get(0).setCapability("tosca.capabilities.Node");
1954         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1955         RequirementDefinition requirementDefinition = new RequirementDefinition();
1956         requirementDefinition.setOwnerId("1");
1957         requirementDefinition.setUniqueId("2");
1958         requirementDefinition.setCapability("3");
1959         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1960         capabilityDefinition.setName("4");
1961         capabilityDefinition.setUniqueId("5");
1962         capabilityDefinition.setOwnerId("6");
1963         ResponseFormat responseFormat = new ResponseFormat();
1964         responseFormat.setStatus(200);
1965         Assertions.assertNotNull(resource);
1966
1967         testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1968     }
1969
1970     @Test
1971     void testAddRelationsToRI_null() {
1972         String yamlName = "group.yml";
1973         Resource resource = createParseResourceObject(true);
1974         Map<String, UploadComponentInstanceInfo> uploadResInstancesMap = new HashMap<>();
1975         UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1976         uploadResInstancesMap.put("uploadComponentInstanceInfo", nodesInfoValue);
1977         List<ComponentInstance> componentInstancesList = new ArrayList<>();
1978         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1979
1980         Assertions.assertThrows(ComponentException.class, () ->
1981             testSubject.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList,
1982                 relations));
1983     }
1984
1985     @Test
1986     void testAddRelationToRI() {
1987         String yamlName = "yamlName";
1988         Resource resource = createParseResourceObject(true);
1989         resource.setComponentInstances(creatComponentInstances());
1990         UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
1991         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1992
1993         Assertions.assertNotNull(
1994             testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
1995     }
1996
1997     @Test
1998     void testAddRelationToRI_null() {
1999         String yamlName = "yamlName.yml";
2000         Resource resource = createParseResourceObject(false);
2001         List<ComponentInstance> componentInstancesList = new ArrayList<>();
2002         resource.setComponentInstances(componentInstancesList);
2003         UploadComponentInstanceInfo nodesInfoValue = getUploadComponentInstanceInfo();
2004         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2005         Assertions.assertNotNull(
2006             testSubject.addRelationToRI(yamlName, resource, nodesInfoValue, relations));
2007     }
2008
2009     @Test
2010     void testFindVfcResource() {
2011         Service service = createServiceObject(true);
2012         String currVfcToscaName = "currVfcToscaName";
2013         String previousVfcToscaName = "previousVfcToscaName";
2014         UploadComponentInstanceInfo nodesInfoValue = new UploadComponentInstanceInfo();
2015         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2016         final CsarInfo csarInfo = getCsarInfo();
2017         Assertions.assertThrows(ComponentException.class, () ->
2018             testSubject.findVfcResource(csarInfo, service, currVfcToscaName, previousVfcToscaName,
2019                 StorageOperationStatus.OK));
2020     }
2021
2022     private GroupDefinition getGroupDefinition() {
2023         GroupDefinition groupDefinition = new GroupDefinition();
2024         Map<String, String> members = new HashMap<>();
2025         members.put("members", "members");
2026         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
2027         List<PropertyDataDefinition> properties = new ArrayList<>();
2028         groupDefinition.setInvariantName("groupDefinitionName");
2029         groupDefinition.setMembers(members);
2030         groupDefinition.setProperties(properties);
2031         groupDefinition.setCapabilities(capabilities);
2032         return groupDefinition;
2033     }
2034
2035     protected Resource createParseResourceObject(boolean afterCreate) {
2036         Resource resource = new Resource();
2037         resource.setName(RESOURCE_NAME);
2038         resource.setToscaResourceName(RESOURCE_TOSCA_NAME);
2039         resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
2040         resource.setDescription("My short description");
2041         List<String> tgs = new ArrayList<>();
2042         tgs.add("test");
2043         tgs.add(resource.getName());
2044         resource.setTags(tgs);
2045         List<String> template = new ArrayList<>();
2046         template.add("tosca.nodes.Root");
2047         resource.setDerivedFrom(template);
2048         resource.setVendorName("Motorola");
2049         resource.setVendorRelease("1.0.0");
2050         resource.setContactId("ya5467");
2051         resource.setIcon("defaulticon");
2052         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
2053         List<RequirementDefinition> requirementDefinitionList = new ArrayList<>();
2054         requirements.put("test", requirementDefinitionList);
2055         resource.setRequirements(requirements);
2056         resource.setCost("cost");
2057         resource.setResourceVendorModelNumber("02312233");
2058
2059         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
2060         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
2061         artifacts.put("artifact", artifactDefinition);
2062         resource.setArtifacts(artifacts);
2063
2064         resource.setLicenseType("licType");
2065
2066         if (afterCreate) {
2067             resource.setName(resource.getName());
2068             resource.setVersion("0.1");
2069             resource.setUniqueId(resource.getName()
2070                 .toLowerCase() + ":" + resource.getVersion());
2071             resource.setCreatorUserId(user.getUserId());
2072             resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2073             resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2074         }
2075         return resource;
2076     }
2077
2078     protected CsarInfo getCsarInfo() {
2079         String csarUuid = "0010";
2080         User user = new User();
2081         File csarFile;
2082         try {
2083             csarFile = new File(
2084                     ServiceImportBusinessLogicTest.class.getClassLoader().getResource("csars/service-Ser09080002-csar.csar").toURI());
2085             Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
2086
2087             String vfReousrceName = "resouceName";
2088             String mainTemplateName = "Definitions/service_import_template.yml";
2089
2090             Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Ser09080002-template.yml")).findAny();
2091             byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
2092             assertNotNull(mainTemplateService);
2093             final String mainTemplateContent = new String(mainTemplateService);
2094
2095             return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false, mock(ModelOperation.class));
2096         } catch (URISyntaxException | ZipException e) {
2097             fail(e);
2098         }
2099         return null;
2100     }
2101
2102     private String loadFileNameToJsonString(String fileName) throws IOException {
2103         String sourceDir = "src/test/resources/normativeTypes";
2104         return loadFileNameToJsonString(sourceDir, fileName);
2105     }
2106
2107     private String loadFileNameToJsonString(String sourceDir, String fileName) throws IOException {
2108         java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir, fileName);
2109         byte[] fileContent = Files.readAllBytes(filePath);
2110         return new String(fileContent);
2111     }
2112
2113     protected Service createServiceObject(boolean afterCreate) {
2114         Service service = new Service();
2115         service.setUniqueId("sid");
2116         service.setName("Service");
2117         CategoryDefinition category = new CategoryDefinition();
2118         category.setName(SERVICE_CATEGORY);
2119         category.setIcons(Collections.singletonList("defaulticon"));
2120         List<CategoryDefinition> categories = new ArrayList<>();
2121         categories.add(category);
2122         service.setCategories(categories);
2123         service.setInstantiationType(INSTANTIATION_TYPE);
2124
2125         service.setDescription("description");
2126         List<String> tgs = new ArrayList<>();
2127         tgs.add(service.getName());
2128         service.setTags(tgs);
2129         service.setIcon("defaulticon");
2130         service.setContactId("aa1234");
2131         service.setProjectCode("12345");
2132         service.setEcompGeneratedNaming(true);
2133
2134         if (afterCreate) {
2135             service.setVersion("0.1");
2136             service.setUniqueId(service.getName() + ":" + service.getVersion());
2137             service.setCreatorUserId(user.getUserId());
2138             service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
2139         }
2140         return service;
2141     }
2142
2143     protected void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) {
2144         ResponseFormat actualResponse = e.getResponseFormat() != null ?
2145             e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2146         assertParseResponse(actualResponse, expectedStatus, variables);
2147     }
2148
2149     private void assertParseResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) {
2150         ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables);
2151         assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus());
2152         assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage());
2153     }
2154
2155 }