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