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

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