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