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

   1 package org.openecomp.sdc.be.components.impl;
   2
   3 import fj.data.Either;
   4 import org.apache.commons.lang3.tuple.ImmutablePair;
   5 import org.junit.Before;
   6 import org.junit.Test;
   7 import org.junit.runner.RunWith;
   8 import org.mockito.ArgumentCaptor;
   9 import org.mockito.InjectMocks;
  10 import org.mockito.Mock;
  11 import org.mockito.Mockito;
  12 import org.mockito.junit.MockitoJUnitRunner;
  13 import org.openecomp.sdc.be.components.validation.UserValidations;
  14 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  15 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  16 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  17 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  18 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  19 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  20 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  21 import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
  22 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  23 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
  24 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  25 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  26 import org.openecomp.sdc.be.impl.ComponentsUtils;
  27 import org.openecomp.sdc.be.model.Resource;
  28 import org.openecomp.sdc.be.model.Service;
  29 import org.openecomp.sdc.be.model.User;
  30 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  31 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  32 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  33 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  34 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  35 import org.openecomp.sdc.be.model.operations.impl.ElementOperation;
  36 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  37 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  38 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  39 import org.openecomp.sdc.be.resources.data.category.CategoryData;
  40 import org.openecomp.sdc.be.user.Role;
  41 import org.openecomp.sdc.be.user.UserBusinessLogic;
  42 import org.openecomp.sdc.common.util.ValidationUtils;
  43 import org.openecomp.sdc.exception.ResponseFormat;
  44
  45 import java.util.ArrayList;
  46 import java.util.List;
  47 import java.util.Map;
  48
  49 import static org.assertj.core.api.Assertions.assertThat;
  50 import static org.mockito.ArgumentMatchers.anyString;
  51 import static org.mockito.ArgumentMatchers.eq;
  52 import static org.mockito.Mockito.when;
  53
  54 /**
  55  * Created by chaya on 12/7/2017.
  56  */
  57 @RunWith(MockitoJUnitRunner.class)
  58 public class ElementBLTest {
  59
  60     private static final String CATAGORY_NAME = "categoryName";
  61     private static final String CATEGORY_UNIQUE_ID = "catUniqueId";
  62     private static final String SERVICE_NOT_DELETED_ID = "notDeletedId";
  63     private static final String DELETED_SERVICE_ID = "deletedId";
  64     private List<CategoryData> categories = new ArrayList<>();
  65     private List<ImmutablePair<ServiceMetadataData, GraphEdge>> services = new ArrayList<>();
  66     private List<ImmutablePair<ResourceMetadataData, GraphEdge>> resources = new ArrayList<>();
  67     private Service notDeletedService = new Service();
  68     private Resource notDeletedResource =  new Resource();
  69
  70     @Mock
  71     private TitanGenericDao titanGenericDao;
  72
  73     @Mock
  74     private ToscaOperationFacade toscaOperationFacade;
  75
  76     @Mock
  77     private TitanDao titanDao;
  78
  79     @Mock
  80     private UserValidations userValidations;
  81
  82     @Mock
  83     private ElementOperation elementOperation;
  84
  85     @Mock
  86     private UserBusinessLogic userAdminManager;
  87
  88     @Mock
  89     protected ComponentsUtils componentsUtils;
  90
  91     @InjectMocks
  92     private ElementBusinessLogic elementBusinessLogic;
  93
  94     @Before
  95     public void setup() {
  96
  97         initCategoriesList();
  98         initServicesList();
  99         initResourceslist();
 100
 101         when(titanDao.commit()).thenReturn(TitanOperationStatus.OK);
 102     }
 103
 104     private void initCategoriesList() {
 105         CategoryData categoryData = new CategoryData(NodeTypeEnum.ServiceNewCategory);
 106         categoryData.getCategoryDataDefinition().setUniqueId(CATEGORY_UNIQUE_ID);
 107         categories.add(categoryData);
 108     }
 109
 110     private void initServicesList() {
 111         ServiceMetadataData serviceNotDeleted = new ServiceMetadataData();
 112         ComponentMetadataDataDefinition componentMetadataDataDefinition1 = new ServiceMetadataDataDefinition();
 113         componentMetadataDataDefinition1.setIsDeleted(false);
 114         componentMetadataDataDefinition1.setHighestVersion(true);
 115         componentMetadataDataDefinition1.setUniqueId(SERVICE_NOT_DELETED_ID);
 116         serviceNotDeleted.setMetadataDataDefinition(componentMetadataDataDefinition1);
 117         services.add(new ImmutablePair<>(serviceNotDeleted, null));
 118
 119         ServiceMetadataData deletedService = new ServiceMetadataData();
 120         ComponentMetadataDataDefinition componentMetadataDataDefinition2 = new ServiceMetadataDataDefinition();
 121         componentMetadataDataDefinition2.setIsDeleted(true);
 122         componentMetadataDataDefinition2.setHighestVersion(true);
 123         componentMetadataDataDefinition2.setUniqueId(DELETED_SERVICE_ID);
 124         deletedService.setMetadataDataDefinition(componentMetadataDataDefinition2);
 125         services.add(new ImmutablePair<>(deletedService, null));
 126     }
 127
 128     private void initResourceslist() {
 129         ResourceMetadataData notDeletedResource = new ResourceMetadataData();
 130         ComponentMetadataDataDefinition componentMetadataDataDefinition3 = new ResourceMetadataDataDefinition();
 131         componentMetadataDataDefinition3.setIsDeleted(false);
 132         componentMetadataDataDefinition3.setHighestVersion(true);
 133         componentMetadataDataDefinition3.setUniqueId(SERVICE_NOT_DELETED_ID);
 134         notDeletedResource.setMetadataDataDefinition(componentMetadataDataDefinition3);
 135         resources.add(new ImmutablePair<>(notDeletedResource, null));
 136
 137         ResourceMetadataData deletedResource = new ResourceMetadataData();
 138         ComponentMetadataDataDefinition componentMetadataDataDefinition4 = new ResourceMetadataDataDefinition();
 139         componentMetadataDataDefinition4.setIsDeleted(true);
 140         componentMetadataDataDefinition4.setHighestVersion(true);
 141         componentMetadataDataDefinition4.setUniqueId(DELETED_SERVICE_ID);
 142         deletedResource.setMetadataDataDefinition(componentMetadataDataDefinition4);
 143         resources.add(new ImmutablePair<>(deletedResource, null));
 144     }
 145
 146     @Test
 147     public void testFetchElementsByCategoryName_filterDeleted() {
 148         ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
 149
 150         when(titanGenericDao.getByCriteria(eq(NodeTypeEnum.ServiceNewCategory), criteriaCapture.capture(), eq(CategoryData.class)))
 151                 .thenReturn(Either.left(categories));
 152         when(titanGenericDao.getParentNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ServiceNewCategory),
 153                 CATEGORY_UNIQUE_ID, GraphEdgeLabels.CATEGORY, NodeTypeEnum.Service, ServiceMetadataData.class))
 154                 .thenReturn(Either.left(services));
 155         when(toscaOperationFacade.getToscaElement(SERVICE_NOT_DELETED_ID, JsonParseFlagEnum.ParseMetadata))
 156                 .thenReturn(Either.left(notDeletedService));
 157
 158         Either<List<Object>, StorageOperationStatus> elementsByCategoryEither =
 159                 elementBusinessLogic.fetchByCategoryOrSubCategoryName(CATAGORY_NAME, NodeTypeEnum.ServiceNewCategory,
 160                         NodeTypeEnum.Service, false, ServiceMetadataData.class, null);
 161
 162         List<Object> elementsByCategory = elementsByCategoryEither.left().value();
 163         assertThat(elementsByCategory.get(0)).isSameAs(notDeletedService);
 164         assertThat(elementsByCategory.size()).isEqualTo(1);
 165         verifyCriteriaProperties(criteriaCapture);
 166     }
 167
 168     private void verifyCriteriaProperties(ArgumentCaptor<Map> propsCapture) {
 169         Map<String, Object> props = propsCapture.getValue();
 170         assertThat(props.size()).isEqualTo(1);
 171         assertThat(props.get(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty())).isEqualTo(ValidationUtils.normalizeCategoryName4Uniqueness(CATAGORY_NAME));
 172     }
 173
 174     @Test
 175     public void testFetchResourcesBySubcategoryUid_filterDeleted() {
 176
 177         when(titanGenericDao.getParentNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceSubcategory),
 178                 CATEGORY_UNIQUE_ID, GraphEdgeLabels.CATEGORY, NodeTypeEnum.Resource, ResourceMetadataData.class))
 179                 .thenReturn(Either.left(resources));
 180
 181         when(toscaOperationFacade.getToscaElement(SERVICE_NOT_DELETED_ID, JsonParseFlagEnum.ParseMetadata))
 182                 .thenReturn(Either.left(notDeletedResource));
 183
 184         Either<List<Object>, StorageOperationStatus> resourcesBySubCategoryUidEither = elementBusinessLogic.fetchByCategoryOrSubCategoryUid(CATEGORY_UNIQUE_ID, NodeTypeEnum.ResourceSubcategory,
 185                 NodeTypeEnum.Resource, false, ResourceMetadataData.class, null);
 186         List<Object> resourcesBySubCategoryUid = resourcesBySubCategoryUidEither.left().value();
 187         assertThat(resourcesBySubCategoryUid.size()).isEqualTo(1);
 188         assertThat(resourcesBySubCategoryUid.get(0)).isSameAs(notDeletedResource);
 189     }
 190
 191     @Test
 192     public void testDeleteCategory() {
 193         Either<CategoryDefinition, ResponseFormat> result;
 194         User user = new User();
 195         String userId = "userId";
 196         user.setUserId(userId);
 197         CategoryDefinition categoryDef = new CategoryDefinition();
 198         when(elementBusinessLogic.validateUserExists(anyString(), anyString(), eq(false))).thenReturn(user);
 199         when(elementOperation.deleteCategory(NodeTypeEnum.ResourceNewCategory, CATEGORY_UNIQUE_ID)).thenReturn(Either.left(categoryDef));
 200         result = elementBusinessLogic.deleteCategory(CATEGORY_UNIQUE_ID, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
 201         assertThat(result.isLeft());
 202     }
 203
 204     @Test
 205     public void testDeleteSubCategory() {
 206         Either<SubCategoryDefinition, ResponseFormat> result;
 207         User user = new User();
 208         String userId = "userId";
 209         user.setUserId(userId);
 210         SubCategoryDefinition subCategoryDef = new SubCategoryDefinition();
 211         when(elementBusinessLogic.validateUserExists(anyString(), anyString(), eq(false))).thenReturn(user);
 212         when(elementOperation.deleteSubCategory(NodeTypeEnum.ResourceSubcategory, CATEGORY_UNIQUE_ID)).thenReturn(Either.left(subCategoryDef));
 213         result = elementBusinessLogic.deleteSubCategory(CATEGORY_UNIQUE_ID, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
 214         assertThat(result.isLeft());
 215     }
 216
 217     @Test
 218     public void testDeleteGrouping() {
 219         Either<GroupingDefinition, ResponseFormat> result;
 220         GroupingDefinition groupDef = Mockito.mock(GroupingDefinition.class);
 221         when(elementOperation.deleteGrouping(null, "groupId")).thenReturn(Either.left(groupDef));
 222         result = elementBusinessLogic.deleteGrouping("groupId", ComponentTypeEnum.RESOURCE_PARAM_NAME, "userId");
 223         assertThat(result.isLeft());
 224     }
 225
 226     @Test
 227     public void testCreateCategory() {
 228         Either<CategoryDefinition, ResponseFormat> result;
 229         CategoryDefinition categoryDef = new CategoryDefinition();
 230         String name = "name";
 231         categoryDef.setName(name);
 232         User user = new User();
 233         String userId = "userId";
 234         user.setUserId(userId);
 235         user.setRole(Role.ADMIN.name());
 236         when(userAdminManager.getUser(userId, false)).thenReturn(Either.left(user));
 237         when(elementOperation.isCategoryUniqueForType(NodeTypeEnum.ResourceNewCategory, name)).thenReturn(Either.left(true));
 238         when(elementOperation.createCategory(categoryDef, NodeTypeEnum.ResourceNewCategory)).thenReturn(Either.left(categoryDef));
 239         result = elementBusinessLogic.createCategory(categoryDef, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
 240         assertThat(result.isLeft());
 241     }
 242 }