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.Assert;
   6 import org.junit.Before;
   7 import org.junit.Test;
   8 import org.junit.runner.RunWith;
   9 import org.mockito.ArgumentCaptor;
  10 import org.mockito.InjectMocks;
  11 import org.mockito.Mock;
  12 import org.mockito.Mockito;
  13 import org.mockito.junit.MockitoJUnitRunner;
  14 import org.openecomp.sdc.be.components.validation.UserValidations;
  15 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  16 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  17 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  18 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  19 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  20 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  21 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  22 import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
  23 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  24 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
  25 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  26 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  27 import org.openecomp.sdc.be.impl.ComponentsUtils;
  28 import org.openecomp.sdc.be.model.Component;
  29 import org.openecomp.sdc.be.model.Resource;
  30 import org.openecomp.sdc.be.model.Service;
  31 import org.openecomp.sdc.be.model.User;
  32 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  33 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  34 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  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.model.operations.impl.ElementOperation;
  38 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  39 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  40 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  41 import org.openecomp.sdc.be.resources.data.category.CategoryData;
  42 import org.openecomp.sdc.be.ui.model.UiCategories;
  43 import org.openecomp.sdc.be.user.Role;
  44 import org.openecomp.sdc.be.user.UserBusinessLogic;
  45 import org.openecomp.sdc.common.util.ValidationUtils;
  46 import org.openecomp.sdc.exception.ResponseFormat;
  47
  48 import java.util.ArrayList;
  49 import java.util.List;
  50 import java.util.Map;
  51
  52 import static org.assertj.core.api.Assertions.assertThat;
  53 import static org.junit.Assert.assertEquals;
  54 import static org.mockito.ArgumentMatchers.anyMap;
  55 import static org.mockito.ArgumentMatchers.anyString;
  56 import static org.mockito.ArgumentMatchers.eq;
  57 import static org.mockito.Mockito.when;
  58
  59 /**
  60  * Created by chaya on 12/7/2017.
  61  */
  62 @RunWith(MockitoJUnitRunner.class)
  63 public class ElementBLTest {
  64
  65     private static final String CATAGORY_NAME = "categoryName";
  66     private static final String CATEGORY_UNIQUE_ID = "catUniqueId";
  67     private static final String SERVICE_NOT_DELETED_ID = "notDeletedId";
  68     private static final String DELETED_SERVICE_ID = "deletedId";
  69     private List<CategoryData> categories = new ArrayList<>();
  70     private List<ImmutablePair<ServiceMetadataData, GraphEdge>> services = new ArrayList<>();
  71     private List<ImmutablePair<ResourceMetadataData, GraphEdge>> resources = new ArrayList<>();
  72     private Service notDeletedService = new Service();
  73     private Resource notDeletedResource =  new Resource();
  74
  75     @Mock
  76     private TitanGenericDao titanGenericDao;
  77
  78     @Mock
  79     private ToscaOperationFacade toscaOperationFacade;
  80
  81     @Mock
  82     private TitanDao titanDao;
  83
  84     @Mock
  85     private UserValidations userValidations;
  86
  87     @Mock
  88     private ElementOperation elementOperation;
  89
  90     @Mock
  91     private UserBusinessLogic userAdminManager;
  92
  93     @Mock
  94     protected ComponentsUtils componentsUtils;
  95
  96     @Mock
  97     private SubCategoryDefinition subCategoryDef;
  98
  99     @Mock
 100     private CategoryDefinition categoryDef;
 101
 102     @InjectMocks
 103     private ElementBusinessLogic elementBusinessLogic;
 104
 105     @Before
 106     public void setup() {
 107
 108         initCategoriesList();
 109         initServicesList();
 110         initResourceslist();
 111
 112         when(titanDao.commit()).thenReturn(TitanOperationStatus.OK);
 113     }
 114
 115     private void initCategoriesList() {
 116         CategoryData categoryData = new CategoryData(NodeTypeEnum.ServiceNewCategory);
 117         categoryData.getCategoryDataDefinition().setUniqueId(CATEGORY_UNIQUE_ID);
 118         categories.add(categoryData);
 119     }
 120
 121     private void initServicesList() {
 122         ServiceMetadataData serviceNotDeleted = new ServiceMetadataData();
 123         ComponentMetadataDataDefinition componentMetadataDataDefinition1 = new ServiceMetadataDataDefinition();
 124         componentMetadataDataDefinition1.setIsDeleted(false);
 125         componentMetadataDataDefinition1.setHighestVersion(true);
 126         componentMetadataDataDefinition1.setUniqueId(SERVICE_NOT_DELETED_ID);
 127         serviceNotDeleted.setMetadataDataDefinition(componentMetadataDataDefinition1);
 128         services.add(new ImmutablePair<>(serviceNotDeleted, null));
 129
 130         ServiceMetadataData deletedService = new ServiceMetadataData();
 131         ComponentMetadataDataDefinition componentMetadataDataDefinition2 = new ServiceMetadataDataDefinition();
 132         componentMetadataDataDefinition2.setIsDeleted(true);
 133         componentMetadataDataDefinition2.setHighestVersion(true);
 134         componentMetadataDataDefinition2.setUniqueId(DELETED_SERVICE_ID);
 135         deletedService.setMetadataDataDefinition(componentMetadataDataDefinition2);
 136         services.add(new ImmutablePair<>(deletedService, null));
 137     }
 138
 139     private void initResourceslist() {
 140         ResourceMetadataData notDeletedResource = new ResourceMetadataData();
 141         ComponentMetadataDataDefinition componentMetadataDataDefinition3 = new ResourceMetadataDataDefinition();
 142         componentMetadataDataDefinition3.setIsDeleted(false);
 143         componentMetadataDataDefinition3.setHighestVersion(true);
 144         componentMetadataDataDefinition3.setUniqueId(SERVICE_NOT_DELETED_ID);
 145         notDeletedResource.setMetadataDataDefinition(componentMetadataDataDefinition3);
 146         resources.add(new ImmutablePair<>(notDeletedResource, null));
 147
 148         ResourceMetadataData deletedResource = new ResourceMetadataData();
 149         ComponentMetadataDataDefinition componentMetadataDataDefinition4 = new ResourceMetadataDataDefinition();
 150         componentMetadataDataDefinition4.setIsDeleted(true);
 151         componentMetadataDataDefinition4.setHighestVersion(true);
 152         componentMetadataDataDefinition4.setUniqueId(DELETED_SERVICE_ID);
 153         deletedResource.setMetadataDataDefinition(componentMetadataDataDefinition4);
 154         resources.add(new ImmutablePair<>(deletedResource, null));
 155     }
 156
 157     @Test
 158     public void testFetchElementsByCategoryName_filterDeleted() {
 159         ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
 160
 161         when(titanGenericDao.getByCriteria(eq(NodeTypeEnum.ServiceNewCategory), criteriaCapture.capture(), eq(CategoryData.class)))
 162                 .thenReturn(Either.left(categories));
 163         when(titanGenericDao.getParentNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ServiceNewCategory),
 164                 CATEGORY_UNIQUE_ID, GraphEdgeLabels.CATEGORY, NodeTypeEnum.Service, ServiceMetadataData.class))
 165                 .thenReturn(Either.left(services));
 166         when(toscaOperationFacade.getToscaElement(SERVICE_NOT_DELETED_ID, JsonParseFlagEnum.ParseMetadata))
 167                 .thenReturn(Either.left(notDeletedService));
 168
 169         Either<List<Object>, StorageOperationStatus> elementsByCategoryEither =
 170                 elementBusinessLogic.fetchByCategoryOrSubCategoryName(CATAGORY_NAME, NodeTypeEnum.ServiceNewCategory,
 171                         NodeTypeEnum.Service, false, ServiceMetadataData.class, null);
 172
 173         List<Object> elementsByCategory = elementsByCategoryEither.left().value();
 174         assertThat(elementsByCategory.get(0)).isSameAs(notDeletedService);
 175         assertThat(elementsByCategory.size()).isEqualTo(1);
 176         verifyCriteriaProperties(criteriaCapture);
 177     }
 178
 179     private void verifyCriteriaProperties(ArgumentCaptor<Map> propsCapture) {
 180         Map<String, Object> props = propsCapture.getValue();
 181         assertThat(props.size()).isEqualTo(1);
 182         assertThat(props.get(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty())).isEqualTo(ValidationUtils.normalizeCategoryName4Uniqueness(CATAGORY_NAME));
 183     }
 184
 185     @Test
 186     public void testFetchResourcesBySubcategoryUid_filterDeleted() {
 187
 188         when(titanGenericDao.getParentNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceSubcategory),
 189                 CATEGORY_UNIQUE_ID, GraphEdgeLabels.CATEGORY, NodeTypeEnum.Resource, ResourceMetadataData.class))
 190                 .thenReturn(Either.left(resources));
 191
 192         when(toscaOperationFacade.getToscaElement(SERVICE_NOT_DELETED_ID, JsonParseFlagEnum.ParseMetadata))
 193                 .thenReturn(Either.left(notDeletedResource));
 194
 195         Either<List<Object>, StorageOperationStatus> resourcesBySubCategoryUidEither = elementBusinessLogic.fetchByCategoryOrSubCategoryUid(CATEGORY_UNIQUE_ID, NodeTypeEnum.ResourceSubcategory,
 196                 NodeTypeEnum.Resource, false, ResourceMetadataData.class, null);
 197         List<Object> resourcesBySubCategoryUid = resourcesBySubCategoryUidEither.left().value();
 198         assertThat(resourcesBySubCategoryUid.size()).isEqualTo(1);
 199         assertThat(resourcesBySubCategoryUid.get(0)).isSameAs(notDeletedResource);
 200     }
 201
 202     @Test
 203     public void testDeleteCategory() {
 204         Either<CategoryDefinition, ResponseFormat> result;
 205         User user = new User();
 206         String userId = "userId";
 207         user.setUserId(userId);
 208         when(elementBusinessLogic.validateUserExists(anyString(), anyString(), eq(false))).thenReturn(user);
 209         when(elementOperation.deleteCategory(NodeTypeEnum.ResourceNewCategory, CATEGORY_UNIQUE_ID)).thenReturn(Either.left(categoryDef));
 210         result = elementBusinessLogic.deleteCategory(CATEGORY_UNIQUE_ID, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
 211         Assert.assertTrue(result.isLeft());
 212     }
 213
 214     @Test
 215     public void testDeleteSubCategory() {
 216         Either<SubCategoryDefinition, ResponseFormat> result;
 217         User user = new User();
 218         String userId = "userId";
 219         user.setUserId(userId);
 220         when(elementBusinessLogic.validateUserExists(anyString(), anyString(), eq(false))).thenReturn(user);
 221         when(elementOperation.deleteSubCategory(NodeTypeEnum.ResourceSubcategory, CATEGORY_UNIQUE_ID)).thenReturn(Either.left(subCategoryDef));
 222         result = elementBusinessLogic.deleteSubCategory(CATEGORY_UNIQUE_ID, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
 223         Assert.assertTrue(result.isLeft());
 224     }
 225
 226     @Test
 227     public void testDeleteGrouping() {
 228         Either<GroupingDefinition, ResponseFormat> result;
 229         GroupingDefinition groupDef = Mockito.mock(GroupingDefinition.class);
 230         when(elementOperation.deleteGrouping(null, "groupId")).thenReturn(Either.left(groupDef));
 231         result = elementBusinessLogic.deleteGrouping("groupId", ComponentTypeEnum.RESOURCE_PARAM_NAME, "userId");
 232         Assert.assertTrue(result.isLeft());
 233     }
 234
 235     @Test
 236     public void testCreateCategory() {
 237         Either<CategoryDefinition, ResponseFormat> result;
 238         CategoryDefinition categoryDef = new CategoryDefinition();
 239         String name = "name";
 240         categoryDef.setName(name);
 241         User user = new User();
 242         String userId = "userId";
 243         user.setUserId(userId);
 244         user.setRole(Role.ADMIN.name());
 245         when(userAdminManager.getUser(userId, false)).thenReturn(Either.left(user));
 246         when(elementOperation.isCategoryUniqueForType(NodeTypeEnum.ResourceNewCategory, name)).thenReturn(Either.left(true));
 247         when(elementOperation.createCategory(categoryDef, NodeTypeEnum.ResourceNewCategory)).thenReturn(Either.left(categoryDef));
 248         result = elementBusinessLogic.createCategory(categoryDef, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
 249         Assert.assertTrue(result.isLeft());
 250     }
 251
 252     @Test
 253     public void testGetAllCategories() {
 254         Either<UiCategories, ResponseFormat> result;
 255         String userId = "userId";
 256         List<CategoryDefinition> categoryDefList = new ArrayList<>();
 257         when(elementOperation.getAllCategories(NodeTypeEnum.ResourceNewCategory, false)).thenReturn(Either.left(categoryDefList));
 258         when(elementOperation.getAllCategories(NodeTypeEnum.ServiceNewCategory, false)).thenReturn(Either.left(categoryDefList));
 259         when(elementOperation.getAllCategories(NodeTypeEnum.ProductCategory, false)).thenReturn(Either.left(categoryDefList));
 260         result = elementBusinessLogic.getAllCategories(userId);
 261         Assert.assertTrue(result.isLeft());
 262     }
 263
 264     @Test
 265     public void testGetAllCategories_NodeType() {
 266         Either<List<CategoryDefinition>, ResponseFormat> result;
 267         String userId = "userId";
 268         List<CategoryDefinition> categoryDefList = new ArrayList<>();
 269         when(elementOperation.getAllCategories(NodeTypeEnum.ResourceNewCategory, false)).thenReturn(Either.left(categoryDefList));
 270         result = elementBusinessLogic.getAllCategories("resources", userId);
 271         assertEquals(0, result.left().value().size());
 272     }
 273
 274     @Test
 275     public void testGetCatalogComp_UuidAndAssetType() {
 276         Either<List<? extends Component>, ResponseFormat> result;
 277         String uuid = "userId";
 278         List<Component> components = new ArrayList<>();
 279         when(toscaOperationFacade.getComponentListByUuid(anyString(), anyMap())).thenReturn(Either.left(components));
 280         result = elementBusinessLogic.getCatalogComponentsByUuidAndAssetType("resources", uuid);
 281         Assert.assertTrue(result.isLeft());
 282     }
 283
 284     @Test
 285     public void testCreateGrouping() {
 286         Either<GroupingDefinition, ResponseFormat> result;
 287         GroupingDefinition groupDef = new GroupingDefinition();
 288         String name = "name";
 289         groupDef.setName(name);
 290         String componentTypeParamName = "products";
 291         String grandParentCatId = "gpCatId";
 292         String parentSubCatId = "pSubCatId";
 293         User user = new User();
 294         String userId = "userId";
 295         user.setUserId(userId);
 296         user.setRole(Role.PRODUCT_STRATEGIST.name());
 297         when(elementBusinessLogic.validateUserExists(userId, "create Grouping", false)).thenReturn(user);
 298         when(elementOperation.getCategory(NodeTypeEnum.ProductCategory, grandParentCatId)).thenReturn(Either.left(categoryDef));
 299         when(elementOperation.getSubCategory(NodeTypeEnum.ProductSubcategory, parentSubCatId)).thenReturn(Either.left(subCategoryDef));
 300         when(elementOperation.isGroupingUniqueForSubCategory(NodeTypeEnum.ProductGrouping, name, parentSubCatId)).thenReturn(Either.left(true));
 301         when(elementOperation.getGroupingUniqueForType(NodeTypeEnum.ProductGrouping, name)).thenReturn(Either.left(groupDef));
 302         when(elementOperation.createGrouping(parentSubCatId, groupDef, NodeTypeEnum.ProductGrouping)).thenReturn(Either.left(groupDef));
 303
 304         result = elementBusinessLogic.createGrouping(groupDef, componentTypeParamName, grandParentCatId, parentSubCatId, userId);
 305         Assert.assertTrue(result.isLeft());
 306     }
 307 }