catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java

   1 package org.openecomp.sdc.be.components.impl;
   2
   3 import fj.data.Either;
   4 import org.assertj.core.util.Lists;
   5 import org.junit.Assert;
   6 import org.junit.Before;
   7 import org.junit.BeforeClass;
   8 import org.junit.Test;
   9 import org.mockito.Mockito;
  10 import org.mockito.MockitoAnnotations;
  11 import org.openecomp.sdc.be.components.validation.UserValidations;
  12 import org.openecomp.sdc.be.dao.api.ActionStatus;
  13 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  14 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  15 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  16 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  17 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  18 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  19 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  20 import org.openecomp.sdc.be.impl.ComponentsUtils;
  21 import org.openecomp.sdc.be.impl.ServletUtils;
  22 import org.openecomp.sdc.be.model.CapabilityDefinition;
  23 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  24 import org.openecomp.sdc.be.model.Component;
  25 import org.openecomp.sdc.be.model.ComponentInstance;
  26 import org.openecomp.sdc.be.model.ComponentParametersView;
  27 import org.openecomp.sdc.be.model.RelationshipImpl;
  28 import org.openecomp.sdc.be.model.RelationshipInfo;
  29 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  30 import org.openecomp.sdc.be.model.RequirementDefinition;
  31 import org.openecomp.sdc.be.model.Resource;
  32 import org.openecomp.sdc.be.model.Service;
  33 import org.openecomp.sdc.be.model.User;
  34 import org.openecomp.sdc.be.model.jsontitan.operations.ForwardingPathOperation;
  35 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  36 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  37 import org.openecomp.sdc.be.user.UserBusinessLogic;
  38 import org.openecomp.sdc.exception.ResponseFormat;
  39
  40 import java.util.ArrayList;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Set;
  46 import java.util.function.BiPredicate;
  47
  48 import static org.junit.Assert.assertTrue;
  49 import static org.mockito.ArgumentMatchers.any;
  50 import static org.mockito.ArgumentMatchers.anySet;
  51 import static org.mockito.ArgumentMatchers.eq;
  52 import static org.mockito.Mockito.when;
  53
  54 /**
  55  * The test suite designed for test functionality of ComponentInstanceBusinessLogic class
  56  */
  57 public class ComponentInstanceBusinessLogicTest {
  58
  59     private final static String USER_ID = "jh0003";
  60     private final static String COMPONENT_ID = "componentId";
  61     private final static String TO_INSTANCE_ID = "toInstanceId";
  62     private final static String FROM_INSTANCE_ID = "fromInstanceId";
  63     private final static String RELATION_ID = "relationId";
  64     private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  65     private final static String CAPABILITY_UID = "capabilityUid";
  66     private final static String CAPABILITY_NAME = "capabilityName";
  67     private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  68     private final static String REQUIREMENT_UID = "requirementUid";
  69     private final static String REQUIREMENT_NAME = "requirementName";
  70     private final static String RELATIONSHIP_TYPE = "relationshipType";
  71
  72     private static ComponentsUtils componentsUtils;
  73     private static ServletUtils servletUtils;
  74     private static ResponseFormat responseFormat;
  75     private static ToscaOperationFacade toscaOperationFacade;
  76     private static UserBusinessLogic userAdmin;
  77
  78     private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
  79     private static ForwardingPathOperation forwardingPathOperation;
  80     private static User user;
  81     private static UserValidations userValidations;
  82     private static Component service;
  83     private static Component resource;
  84     private static ComponentInstance toInstance;
  85     private static ComponentInstance fromInstance;
  86     private static CapabilityDataDefinition capability;
  87     private static RequirementDataDefinition requirement;
  88     private static RequirementCapabilityRelDef relation;
  89
  90     @BeforeClass
  91     public static void setup() {
  92         createMocks();
  93         setMocks();
  94         stubMethods();
  95         createComponents();
  96
  97     }
  98
  99     @Before
 100     public void init(){
 101         MockitoAnnotations.initMocks(this);
 102     }
 103     @Test
 104     public void testGetRelationByIdSuccess(){
 105         getServiceRelationByIdSuccess(service);
 106         getServiceRelationByIdSuccess(resource);
 107     }
 108
 109     @Test
 110     public void testGetRelationByIdUserValidationFailure(){
 111         getServiceRelationByIdUserValidationFailure(service);
 112         getServiceRelationByIdUserValidationFailure(resource);
 113     }
 114
 115     @Test
 116     public void testGetRelationByIdComponentNotFoundFailure(){
 117         getRelationByIdComponentNotFoundFailure(service);
 118         getRelationByIdComponentNotFoundFailure(resource);
 119     }
 120
 121
 122
 123
 124     @Test
 125     public void testForwardingPathOnVersionChange(){
 126         getforwardingPathOnVersionChange();
 127     }
 128
 129     private void getforwardingPathOnVersionChange(){
 130         String containerComponentParam="services";
 131         String containerComponentID="121-cont";
 132         String componentInstanceID="121-cont-1-comp";
 133         Service component=new Service();
 134         Map<String, ForwardingPathDataDefinition> forwardingPaths = generateForwardingPath(componentInstanceID);
 135
 136         //Add existing componentInstance to component
 137         List<ComponentInstance> componentInstanceList=new ArrayList<>();
 138         ComponentInstance oldComponentInstance=new ComponentInstance();
 139         oldComponentInstance.setName("OLD_COMP_INSTANCE");
 140         oldComponentInstance.setUniqueId(componentInstanceID);
 141         oldComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID,"1-comp");
 142         componentInstanceList.add(oldComponentInstance);
 143         component.setComponentInstances(componentInstanceList);
 144         component.setForwardingPaths(forwardingPaths);
 145
 146         List<ComponentInstance> componentInstanceListNew=new ArrayList<>();
 147         ComponentInstance newComponentInstance=new ComponentInstance();
 148         String new_Comp_UID="2-comp";
 149         newComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID,new_Comp_UID);
 150         newComponentInstance.setUniqueId(new_Comp_UID);
 151         componentInstanceListNew.add(newComponentInstance);
 152         Component component2=new Service();
 153         component2.setComponentInstances(componentInstanceListNew);
 154
 155         //Mock for getting component
 156         when(toscaOperationFacade.getToscaElement(eq(containerComponentID),any(ComponentParametersView.class))).thenReturn(Either.left(component));
 157         when(toscaOperationFacade.validateComponentExists(any(String.class))).thenReturn(Either.left(Boolean.TRUE));
 158         //Mock for getting component for componentInstance
 159         when(toscaOperationFacade.getToscaFullElement(eq("1-comp"))).thenReturn(Either.left(component));
 160         when(toscaOperationFacade.getToscaFullElement(eq(new_Comp_UID))).thenReturn(Either.left(component2));
 161
 162         Either<Set<String>, ResponseFormat> resultOp = componentInstanceBusinessLogic.forwardingPathOnVersionChange
 163             (containerComponentParam,containerComponentID,componentInstanceID,newComponentInstance);
 164         Assert.assertEquals(1,resultOp.left().value().size());
 165         Assert.assertEquals("FP-ID-1",resultOp.left().value().iterator().next());
 166
 167     }
 168
 169
 170     @Test
 171     public void testDeleteForwardingPathsWhenComponentinstanceDeleted(){
 172
 173         ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
 174         String containerComponentID = "Service-comp";
 175         String componentInstanceID = "NodeA1";
 176         Service component = new Service();
 177
 178         component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1",  "1"));
 179         component.addForwardingPath(createPath("Path2", "NodeA2","NodeB2", "2"));
 180         when(toscaOperationFacade.getToscaElement(eq(containerComponentID),any(ComponentParametersView.class))).thenReturn(Either.left(component));
 181         when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
 182         when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet())).thenReturn(Either.left(new HashSet<>()));
 183         Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic.deleteForwardingPathsRelatedTobeDeletedComponentInstance(
 184                 containerComponentID, componentInstanceID, containerComponentType, Either.left(new ComponentInstance()));
 185         Assert.assertTrue(responseFormatEither.isLeft());
 186
 187     }
 188
 189     @Test
 190     public void testDeleteForwardingPathsWhenErrorInComponentinstanceDelete(){
 191
 192         ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
 193         String containerComponentID = "Service-comp";
 194         String componentInstanceID = "NodeA1";
 195         Service component = new Service();
 196
 197         component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1",  "1"));
 198         component.addForwardingPath(createPath("Path2", "NodeA2","NodeB2", "2"));
 199         when(toscaOperationFacade.getToscaElement(eq(containerComponentID),any(ComponentParametersView.class))).thenReturn(Either.left(component));
 200         when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
 201         when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet())).thenReturn(Either.left(new HashSet<>()));
 202         Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic.deleteForwardingPathsRelatedTobeDeletedComponentInstance(
 203                 containerComponentID, componentInstanceID, containerComponentType, Either.right(new ResponseFormat()));
 204         Assert.assertTrue(responseFormatEither.isRight());
 205
 206     }
 207
 208
 209     private ForwardingPathDataDefinition createPath(String pathName, String fromNode, String toNode , String uniqueId){
 210         ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition(pathName);
 211         forwardingPath.setProtocol("protocol");
 212         forwardingPath.setDestinationPortNumber("port");
 213         forwardingPath.setUniqueId(uniqueId);
 214         ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = new ListDataDefinition<>();
 215         forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition(fromNode, toNode,
 216                 "nodeAcpType", "nodeBcpType", "nodeDcpName", "nodeBcpName"));
 217         forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 218
 219         return forwardingPath;
 220     }
 221
 222
 223
 224     private Map<String, ForwardingPathDataDefinition> generateForwardingPath(String componentInstanceID) {
 225         ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition("fpName");
 226         String protocol = "protocol";
 227         forwardingPath.setProtocol(protocol);
 228         forwardingPath.setDestinationPortNumber("DestinationPortNumber");
 229         forwardingPath.setUniqueId("FP-ID-1");
 230         ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition =
 231             new ListDataDefinition<>();
 232         forwardingPathElementListDataDefinition.add(
 233             new ForwardingPathElementDataDefinition(componentInstanceID, "nodeB", "nodeA_FORWARDER_CAPABILITY",
 234                 "nodeBcpType" , "nodeDcpName",
 235                 "nodeBcpName"));
 236         forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 237         Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 238         forwardingPaths.put("1122", forwardingPath);
 239         return forwardingPaths;
 240     }
 241
 242   @SuppressWarnings("unchecked")
 243     private void getServiceRelationByIdSuccess(Component component){
 244         Either<User, ActionStatus> eitherCreator = Either.left(user);
 245         when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 246         Either<Component, StorageOperationStatus> getComponentRes = Either.left(component);
 247         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(getComponentRes);
 248
 249         Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = Either.left(requirement);
 250         when(toscaOperationFacade.getFulfilledRequirementByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID), eq(relation), any(BiPredicate.class))).thenReturn(getfulfilledRequirementRes);
 251
 252         Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledCapabilityRes = Either.left(capability);
 253         when(toscaOperationFacade.getFulfilledCapabilityByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID), eq(relation), any(BiPredicate.class))).thenReturn(getfulfilledCapabilityRes);
 254
 255         Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 256         assertTrue(response.isLeft());
 257     }
 258
 259     private void getServiceRelationByIdUserValidationFailure(Component component){
 260         //Either<User, ActionStatus> eitherCreator = Either.right(ActionStatus.USER_NOT_FOUND);
 261         //when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 262         when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false))).thenReturn(Either.right(new ResponseFormat(404)));
 263         Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 264         assertTrue(response.isRight());
 265     }
 266
 267     private void getRelationByIdComponentNotFoundFailure(Component component){
 268         Either<User, ActionStatus> eitherCreator = Either.left(user);
 269         when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 270         Either<Component, StorageOperationStatus> getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND);
 271         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(getComponentRes);
 272
 273         Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 274         assertTrue(response.isRight());
 275     }
 276
 277     private static void createMocks() {
 278         componentsUtils = Mockito.mock(ComponentsUtils.class);
 279         servletUtils = Mockito.mock(ServletUtils.class);
 280         responseFormat = Mockito.mock(ResponseFormat.class);
 281         toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 282         userAdmin =  Mockito.mock(UserBusinessLogic.class);
 283         user = Mockito.mock(User.class);
 284         userValidations = Mockito.mock(UserValidations.class);
 285         forwardingPathOperation = Mockito.mock(ForwardingPathOperation.class);
 286     }
 287
 288     private static void setMocks() {
 289         componentInstanceBusinessLogic = new ComponentInstanceBusinessLogic();
 290         componentInstanceBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 291         componentInstanceBusinessLogic.setUserAdmin(userAdmin);
 292         componentInstanceBusinessLogic.setComponentsUtils(componentsUtils);
 293         componentInstanceBusinessLogic.setUserValidations(userValidations);
 294         componentInstanceBusinessLogic.setForwardingPathOperation(forwardingPathOperation);
 295     }
 296
 297     private static void stubMethods() {
 298         when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
 299         when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false))).thenReturn(Either.left(user));
 300         when(componentsUtils.getResponseFormat(eq(ActionStatus.RELATION_NOT_FOUND), eq(RELATION_ID), eq(COMPONENT_ID))).thenReturn(responseFormat);
 301     }
 302
 303     private static void createComponents() {
 304         createRelation();
 305         createInstances();
 306         createService();
 307         createResource();
 308     }
 309
 310     private static void createResource() {
 311         resource = new Resource();
 312         resource.setUniqueId(COMPONENT_ID);
 313         resource.setComponentInstancesRelations(Lists.newArrayList(relation));
 314         resource.setComponentInstances(Lists.newArrayList(toInstance,fromInstance));
 315         resource.setCapabilities(toInstance.getCapabilities());
 316         resource.setRequirements(fromInstance.getRequirements());
 317         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 318     }
 319
 320
 321     private static void createService() {
 322         service = new Service();
 323         service.setUniqueId(COMPONENT_ID);
 324         service.setComponentInstancesRelations(Lists.newArrayList(relation));
 325         service.setComponentInstances(Lists.newArrayList(toInstance,fromInstance));
 326         service.setCapabilities(toInstance.getCapabilities());
 327         service.setRequirements(fromInstance.getRequirements());
 328         service.setComponentType(ComponentTypeEnum.SERVICE);
 329     }
 330
 331
 332     private static void createInstances() {
 333         toInstance = new ComponentInstance();
 334         toInstance.setUniqueId(TO_INSTANCE_ID);
 335
 336         fromInstance = new ComponentInstance();
 337         fromInstance.setUniqueId(FROM_INSTANCE_ID);
 338
 339         capability = new CapabilityDataDefinition();
 340         capability.setOwnerId(CAPABILITY_OWNER_ID);
 341         capability.setUniqueId(CAPABILITY_UID);
 342         capability.setName(CAPABILITY_NAME);
 343
 344         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 345         capabilities.put(capability.getName(), Lists.newArrayList(new CapabilityDefinition(capability)));
 346
 347         requirement = new RequirementDataDefinition();
 348         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 349         requirement.setUniqueId(REQUIREMENT_UID);
 350         requirement.setName(REQUIREMENT_NAME);
 351         requirement.setRelationship(RELATIONSHIP_TYPE);
 352
 353
 354         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 355         requirements.put(requirement.getCapability(), Lists.newArrayList(new RequirementDefinition(requirement)));
 356
 357         toInstance.setCapabilities(capabilities);
 358         fromInstance.setRequirements(requirements);
 359     }
 360
 361
 362     private static void createRelation() {
 363
 364         relation = new RequirementCapabilityRelDef();
 365         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 366         RelationshipInfo relationInfo = new RelationshipInfo();
 367         relationInfo.setId(RELATION_ID);
 368         relationship.setRelation(relationInfo);
 369
 370         relation.setRelationships(Lists.newArrayList(relationship));
 371         relation.setToNode(TO_INSTANCE_ID);
 372         relation.setFromNode(FROM_INSTANCE_ID);
 373
 374         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 375         relationInfo.setCapabilityUid(CAPABILITY_UID);
 376         relationInfo.setCapability(CAPABILITY_NAME);
 377         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 378         relationInfo.setRequirementUid(REQUIREMENT_UID);
 379         relationInfo.setRequirement(REQUIREMENT_NAME);
 380         RelationshipImpl relationshipImpl  = new RelationshipImpl();
 381         relationshipImpl.setType(RELATIONSHIP_TYPE);
 382         relationInfo.setRelationships(relationshipImpl);
 383     }
 384 }