gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.be.components.impl;
   2
   3 import static org.junit.Assert.assertTrue;
   4 import static org.mockito.ArgumentMatchers.any;
   5 import static org.mockito.ArgumentMatchers.eq;
   6 import static org.mockito.Mockito.when;
   7
   8 import java.util.HashMap;
   9 import java.util.List;
  10 import java.util.Map;
  11 import java.util.function.BiPredicate;
  12
  13 import org.assertj.core.util.Lists;
  14 import org.junit.BeforeClass;
  15 import org.junit.Test;
  16 import org.mockito.Mockito;
  17 import org.openecomp.sdc.be.dao.api.ActionStatus;
  18 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  19 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  20 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  21 import org.openecomp.sdc.be.impl.ComponentsUtils;
  22 import org.openecomp.sdc.be.impl.ServletUtils;
  23 import org.openecomp.sdc.be.model.CapabilityDefinition;
  24 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  25 import org.openecomp.sdc.be.model.Component;
  26 import org.openecomp.sdc.be.model.ComponentInstance;
  27 import org.openecomp.sdc.be.model.ComponentParametersView;
  28 import org.openecomp.sdc.be.model.RelationshipImpl;
  29 import org.openecomp.sdc.be.model.RelationshipInfo;
  30 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  31 import org.openecomp.sdc.be.model.RequirementDefinition;
  32 import org.openecomp.sdc.be.model.Resource;
  33 import org.openecomp.sdc.be.model.Service;
  34 import org.openecomp.sdc.be.model.User;
  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 fj.data.Either;
  41
  42 /**
  43  * The test suite designed for test functionality of ComponentInstanceBusinessLogic class
  44  */
  45 public class ComponentInstanceBusinessLogicTest {
  46
  47         private final static String USER_ID = "jh0003";
  48         private final static String COMPONENT_ID = "componentId";
  49         private final static String TO_INSTANCE_ID = "toInstanceId";
  50         private final static String FROM_INSTANCE_ID = "fromInstanceId";
  51         private final static String RELATION_ID = "relationId";
  52         private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  53         private final static String CAPABILITY_UID = "capabilityUid";
  54         private final static String CAPABILITY_NAME = "capabilityName";
  55         private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  56         private final static String REQUIREMENT_UID = "requirementUid";
  57         private final static String REQUIREMENT_NAME = "requirementName";
  58         private final static String RELATIONSHIP_TYPE = "relationshipType";
  59
  60         private static ComponentsUtils componentsUtils;
  61         private static ServletUtils servletUtils;
  62         private static ResponseFormat responseFormat;
  63         private static ToscaOperationFacade toscaOperationFacade;
  64         private static UserBusinessLogic userAdmin;
  65
  66         private static ComponentInstanceBusinessLogic serviceBusinessLogic;
  67         private static ComponentInstanceBusinessLogic resourceBusinessLogic;
  68         private static User user;
  69         private static Component service;
  70         private static Component resource;
  71         private static ComponentInstance toInstance;
  72         private static ComponentInstance fromInstance;
  73         private static CapabilityDataDefinition capability;
  74         private static RequirementDataDefinition requirement;
  75         private static RequirementCapabilityRelDef relation;
  76
  77         @BeforeClass
  78         public static void setup() {
  79                 createMocks();
  80                 setMocks();
  81                 stubMethods();
  82                 createComponents();
  83         }
  84
  85         @Test
  86         public void testGetRelationByIdSuccess(){
  87                 getServiceRelationByIdSuccess(service);
  88                 getServiceRelationByIdSuccess(resource);
  89         }
  90
  91         @Test
  92         public void testGetRelationByIdUserValidationFailure(){
  93                 getServiceRelationByIdUserValidationFailure(service);
  94                 getServiceRelationByIdUserValidationFailure(resource);
  95         }
  96
  97         @Test
  98         public void testGetRelationByIdComponentNotFoundFailure(){
  99                 getRelationByIdComponentNotFoundFailure(service);
 100                 getRelationByIdComponentNotFoundFailure(resource);
 101         }
 102
 103         @SuppressWarnings("unchecked")
 104         private void getServiceRelationByIdSuccess(Component component){
 105                 Either<User, ActionStatus> eitherCreator = Either.left(user);
 106                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 107                 Either<Component, StorageOperationStatus> getComponentRes = Either.left(component);
 108                 when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(getComponentRes);
 109
 110                 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = Either.left(requirement);
 111                 when(toscaOperationFacade.getFulfilledRequirementByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID), eq(relation), any(BiPredicate.class))).thenReturn(getfulfilledRequirementRes);
 112
 113                 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledCapabilityRes = Either.left(capability);
 114                 when(toscaOperationFacade.getFulfilledCapabilityByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID), eq(relation), any(BiPredicate.class))).thenReturn(getfulfilledCapabilityRes);
 115
 116                 Either<RequirementCapabilityRelDef, ResponseFormat> response = serviceBusinessLogic.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 117                 assertTrue(response.isLeft());
 118         }
 119
 120         private void getServiceRelationByIdUserValidationFailure(Component component){
 121                 Either<User, ActionStatus> eitherCreator = Either.right(ActionStatus.USER_NOT_FOUND);
 122                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 123
 124                 Either<RequirementCapabilityRelDef, ResponseFormat> response = serviceBusinessLogic.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 125                 assertTrue(response.isRight());
 126         }
 127
 128         private void getRelationByIdComponentNotFoundFailure(Component component){
 129                 Either<User, ActionStatus> eitherCreator = Either.left(user);
 130                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
 131                 Either<Component, StorageOperationStatus> getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND);
 132                 when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(getComponentRes);
 133
 134                 Either<RequirementCapabilityRelDef, ResponseFormat> response = serviceBusinessLogic.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 135                 assertTrue(response.isRight());
 136         }
 137
 138         private static void createMocks() {
 139                 componentsUtils = Mockito.mock(ComponentsUtils.class);
 140                 servletUtils = Mockito.mock(ServletUtils.class);
 141                 responseFormat = Mockito.mock(ResponseFormat.class);
 142                 toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
 143                 userAdmin =  Mockito.mock(UserBusinessLogic.class);
 144                 user = Mockito.mock(User.class);
 145         }
 146
 147         private static void setMocks() {
 148                 serviceBusinessLogic = new ServiceComponentInstanceBusinessLogic();
 149                 serviceBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 150                 serviceBusinessLogic.setUserAdmin(userAdmin);
 151                 serviceBusinessLogic.setComponentsUtils(componentsUtils);
 152
 153                 resourceBusinessLogic = new VFComponentInstanceBusinessLogic();
 154                 resourceBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 155                 resourceBusinessLogic.setUserAdmin(userAdmin);
 156                 resourceBusinessLogic.setComponentsUtils(componentsUtils);
 157         }
 158
 159         private static void stubMethods() {
 160                 when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
 161                 when(componentsUtils.getResponseFormat(eq(ActionStatus.RELATION_NOT_FOUND), eq(RELATION_ID), eq(COMPONENT_ID))).thenReturn(responseFormat);
 162         }
 163
 164         private static void createComponents() {
 165                 createRelation();
 166                 createInstances();
 167                 createService();
 168                 createResource();
 169         }
 170
 171         private static void createResource() {
 172                 resource = new Resource();
 173                 resource.setUniqueId(COMPONENT_ID);
 174                 resource.setComponentInstancesRelations(Lists.newArrayList(relation));
 175                 resource.setComponentInstances(Lists.newArrayList(toInstance,fromInstance));
 176                 resource.setCapabilities(toInstance.getCapabilities());
 177                 resource.setRequirements(fromInstance.getRequirements());
 178                 resource.setComponentType(ComponentTypeEnum.RESOURCE);
 179         }
 180
 181
 182         private static void createService() {
 183                 service = new Service();
 184                 service.setUniqueId(COMPONENT_ID);
 185                 service.setComponentInstancesRelations(Lists.newArrayList(relation));
 186                 service.setComponentInstances(Lists.newArrayList(toInstance,fromInstance));
 187                 service.setCapabilities(toInstance.getCapabilities());
 188                 service.setRequirements(fromInstance.getRequirements());
 189                 service.setComponentType(ComponentTypeEnum.SERVICE);
 190         }
 191
 192
 193         private static void createInstances() {
 194                 toInstance = new ComponentInstance();
 195                 toInstance.setUniqueId(TO_INSTANCE_ID);
 196
 197                 fromInstance = new ComponentInstance();
 198                 fromInstance.setUniqueId(FROM_INSTANCE_ID);
 199
 200                 capability = new CapabilityDataDefinition();
 201                 capability.setOwnerId(CAPABILITY_OWNER_ID);
 202                 capability.setUniqueId(CAPABILITY_UID);
 203                 capability.setName(CAPABILITY_NAME);
 204
 205                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 206                 capabilities.put(capability.getName(), Lists.newArrayList(new CapabilityDefinition(capability)));
 207
 208                 requirement = new RequirementDataDefinition();
 209                 requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 210                 requirement.setUniqueId(REQUIREMENT_UID);
 211                 requirement.setName(REQUIREMENT_NAME);
 212                 requirement.setRelationship(RELATIONSHIP_TYPE);
 213
 214
 215                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 216                 requirements.put(requirement.getCapability(), Lists.newArrayList(new RequirementDefinition(requirement)));
 217
 218                 toInstance.setCapabilities(capabilities);
 219                 fromInstance.setRequirements(requirements);
 220         }
 221
 222
 223         private static void createRelation() {
 224
 225                 relation = new RequirementCapabilityRelDef();
 226                 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 227                 RelationshipInfo relationInfo = new RelationshipInfo();
 228                 relationInfo.setId(RELATION_ID);
 229                 relationship.setRelation(relationInfo);
 230
 231                 relation.setRelationships(Lists.newArrayList(relationship));
 232                 relation.setToNode(TO_INSTANCE_ID);
 233                 relation.setFromNode(FROM_INSTANCE_ID);
 234
 235                 relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 236                 relationInfo.setCapabilityUid(CAPABILITY_UID);
 237                 relationInfo.setCapability(CAPABILITY_NAME);
 238                 relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 239                 relationInfo.setRequirementUid(REQUIREMENT_UID);
 240                 relationInfo.setRequirement(REQUIREMENT_NAME);
 241                 RelationshipImpl relationshipImpl  = new RelationshipImpl();
 242                 relationshipImpl.setType(RELATIONSHIP_TYPE);
 243                 relationInfo.setRelationships(relationshipImpl);
 244         }
 245 }