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