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

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