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