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

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