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