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