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