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

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