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