2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.components.impl;
23 import fj.data.Either;
24 import org.junit.Assert;
25 import org.junit.Before;
26 import org.junit.Test;
27 import org.junit.runner.RunWith;
28 import org.mockito.InjectMocks;
29 import org.mockito.Mock;
30 import org.mockito.Mockito;
31 import org.mockito.junit.MockitoJUnitRunner;
32 import org.openecomp.sdc.be.components.validation.UserValidations;
33 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
34 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
35 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
36 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
37 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
38 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
39 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
40 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
41 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
42 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
43 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
44 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
45 import org.openecomp.sdc.be.impl.ComponentsUtils;
46 import org.openecomp.sdc.be.model.Component;
47 import org.openecomp.sdc.be.model.Resource;
48 import org.openecomp.sdc.be.model.Service;
49 import org.openecomp.sdc.be.model.User;
50 import org.openecomp.sdc.be.model.category.CategoryDefinition;
51 import org.openecomp.sdc.be.model.category.GroupingDefinition;
52 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
53 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
54 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
55 import org.openecomp.sdc.be.model.operations.impl.ElementOperation;
56 import org.openecomp.sdc.be.resources.data.category.CategoryData;
57 import org.openecomp.sdc.be.resources.data.category.SubCategoryData;
58 import org.openecomp.sdc.be.ui.model.UiCategories;
59 import org.openecomp.sdc.be.user.Role;
60 import org.openecomp.sdc.be.user.UserBusinessLogic;
61 import org.openecomp.sdc.common.util.ValidationUtils;
62 import org.openecomp.sdc.exception.ResponseFormat;
64 import java.util.ArrayList;
65 import java.util.HashMap;
66 import java.util.List;
69 import static org.assertj.core.api.Assertions.assertThat;
70 import static org.junit.Assert.assertEquals;
71 import static org.mockito.ArgumentMatchers.anyMap;
72 import static org.mockito.ArgumentMatchers.anyString;
73 import static org.mockito.ArgumentMatchers.eq;
74 import static org.mockito.Mockito.when;
77 * Created by chaya on 12/7/2017.
79 @RunWith(MockitoJUnitRunner.class)
80 public class ElementBLTest {
82 private static final String CATEGORY_NAME = "categoryName";
83 private static final String CATEGORY_UNIQUE_ID = "catUniqueId";
84 private static final String SUBCATEGORY_UNIQUE_ID = "subCatUniqeId";
85 private static final String PROPER_COMPONENT_ID = "properComponentId";
86 private static final String DELETED_COMPONENT_ID = "deletedId";
87 private static final String ARCHIVED_COMPONENT_ID = "archivedId";
88 private static final String NOT_HIGHEST_VERSION_ID = "notHighestVersionId";
90 private GraphVertex categoryVertex = new GraphVertex(VertexTypeEnum.RESOURCE_CATEGORY);
91 private List<GraphVertex> deletedAndNotDeletedResourceVertices = new ArrayList<>();
92 private List<GraphVertex> archivedAndNotArchivedResourceVertices = new ArrayList<>();
93 private List<GraphVertex> notHighestVersionAndHighestVersionResourceVertices = new ArrayList<>();
94 private List<GraphVertex> deletedAndNotDeletedServiceVertices = new ArrayList<>();
96 private Resource properResource = new Resource();
98 private Service properService = new Service();
100 private List<CategoryData> categories = new ArrayList<>();
101 private List<SubCategoryData> subCategories = new ArrayList<>();
105 private JanusGraphGenericDao janusGraphGenericDao;
108 private ToscaOperationFacade toscaOperationFacade;
111 private JanusGraphDao janusGraphDao;
114 private UserValidations userValidations;
117 private ElementOperation elementOperation;
120 private UserBusinessLogic userAdminManager;
123 protected ComponentsUtils componentsUtils;
126 private SubCategoryDefinition subCategoryDef;
129 private CategoryDefinition categoryDef;
132 private ElementBusinessLogic elementBusinessLogic;
136 public void setup() {
137 initCategoriesAndSubCategories();
138 initResourcesVerticesLists();
139 initServiceVerticesLists();
140 elementBusinessLogic.setUserValidations(userValidations);
141 elementBusinessLogic.setComponentsUtils(componentsUtils);
142 elementBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
143 elementBusinessLogic.setJanusGraphDao(janusGraphDao);
144 elementBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
146 when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
150 private void initCategoriesAndSubCategories() {
151 CategoryData categoryData = new CategoryData(NodeTypeEnum.ServiceNewCategory);
152 categoryData.getCategoryDataDefinition().setUniqueId(CATEGORY_UNIQUE_ID);
153 categories.add(categoryData);
155 SubCategoryData subCategoryData = new SubCategoryData(NodeTypeEnum.ResourceNewCategory);
156 subCategoryData.getSubCategoryDataDefinition().setUniqueId(SUBCATEGORY_UNIQUE_ID);
157 subCategories.add(subCategoryData);
160 private void initServiceVerticesLists() {
161 Map<String, Object> properServiceMetadataJson = new HashMap<>();
162 properServiceMetadataJson.put(JsonPresentationFields.IS_DELETED.getPresentation(), false);
163 properServiceMetadataJson.put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
164 properServiceMetadataJson.put(JsonPresentationFields.IS_ARCHIVED.getPresentation(), false);
165 GraphVertex properService = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
166 properService.setType(ComponentTypeEnum.SERVICE);
167 properService.setMetadataJson(properServiceMetadataJson);
168 properService.setUniqueId(PROPER_COMPONENT_ID);
169 deletedAndNotDeletedServiceVertices.add(properService);
171 Map<String, Object> deletedServiceMetadataJson = new HashMap<>();
172 deletedServiceMetadataJson.put(JsonPresentationFields.IS_DELETED.getPresentation(), true);
173 deletedServiceMetadataJson.put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
174 deletedServiceMetadataJson.put(JsonPresentationFields.IS_ARCHIVED.getPresentation(), false);
175 GraphVertex deletedService = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
176 deletedService.setType(ComponentTypeEnum.SERVICE);
177 deletedService.setMetadataJson(deletedServiceMetadataJson);
178 deletedService.setUniqueId(DELETED_COMPONENT_ID);
179 deletedAndNotDeletedServiceVertices.add(deletedService);
182 private void initResourcesVerticesLists() {
183 Map<String, Object> properResourceMetadataJson = new HashMap<>();
184 properResourceMetadataJson.put(JsonPresentationFields.IS_DELETED.getPresentation(), false);
185 properResourceMetadataJson.put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
186 properResourceMetadataJson.put(JsonPresentationFields.IS_ARCHIVED.getPresentation(), false);
187 properResourceMetadataJson.put(JsonPresentationFields.RESOURCE_TYPE.getPresentation(), ResourceTypeEnum.VFC.getValue());
188 GraphVertex properResource = new GraphVertex(VertexTypeEnum.NODE_TYPE);
189 properResource.setType(ComponentTypeEnum.RESOURCE);
190 properResource.setMetadataJson(properResourceMetadataJson);
191 properResource.setUniqueId(PROPER_COMPONENT_ID);
192 deletedAndNotDeletedResourceVertices.add(properResource);
193 archivedAndNotArchivedResourceVertices.add(properResource);
194 notHighestVersionAndHighestVersionResourceVertices.add(properResource);
196 Map<String, Object> deletedResourceMetadataJson = new HashMap<>();
197 deletedResourceMetadataJson.put(JsonPresentationFields.IS_DELETED.getPresentation(), true);
198 deletedResourceMetadataJson.put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
199 deletedResourceMetadataJson.put(JsonPresentationFields.IS_ARCHIVED.getPresentation(), false);
200 deletedResourceMetadataJson.put(JsonPresentationFields.RESOURCE_TYPE.getPresentation(), ResourceTypeEnum.VFC.getValue());
201 GraphVertex deletedResource = new GraphVertex(VertexTypeEnum.NODE_TYPE);
202 deletedResource.setType(ComponentTypeEnum.RESOURCE);
203 deletedResource.setMetadataJson(deletedResourceMetadataJson);
204 deletedResource.setUniqueId(DELETED_COMPONENT_ID);
205 deletedAndNotDeletedResourceVertices.add(deletedResource);
207 Map<String, Object> archivedResourceMetadataJson = new HashMap<>();
208 archivedResourceMetadataJson.put(JsonPresentationFields.IS_DELETED.getPresentation(), false);
209 archivedResourceMetadataJson.put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
210 archivedResourceMetadataJson.put(JsonPresentationFields.IS_ARCHIVED.getPresentation(), true);
211 archivedResourceMetadataJson.put(JsonPresentationFields.RESOURCE_TYPE.getPresentation(), ResourceTypeEnum.VFC.getValue());
212 GraphVertex archivedResource = new GraphVertex(VertexTypeEnum.NODE_TYPE);
213 archivedResource.setType(ComponentTypeEnum.RESOURCE);
214 archivedResource.setMetadataJson(archivedResourceMetadataJson);
215 archivedResource.setUniqueId(ARCHIVED_COMPONENT_ID);
216 archivedAndNotArchivedResourceVertices.add(archivedResource);
218 Map<String, Object> notHighestVersionResourceMetadataJson = new HashMap<>();
219 notHighestVersionResourceMetadataJson.put(JsonPresentationFields.IS_DELETED.getPresentation(), false);
220 notHighestVersionResourceMetadataJson.put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), false);
221 notHighestVersionResourceMetadataJson.put(JsonPresentationFields.IS_ARCHIVED.getPresentation(), false);
222 notHighestVersionResourceMetadataJson.put(JsonPresentationFields.RESOURCE_TYPE.getPresentation(), ResourceTypeEnum.VFC.getValue());
223 GraphVertex notHighestVersionResource = new GraphVertex(VertexTypeEnum.NODE_TYPE);
224 notHighestVersionResource.setType(ComponentTypeEnum.RESOURCE);
225 notHighestVersionResource.setMetadataJson(notHighestVersionResourceMetadataJson);
226 notHighestVersionResource.setUniqueId(NOT_HIGHEST_VERSION_ID);
227 notHighestVersionAndHighestVersionResourceVertices.add(notHighestVersionResource);
231 public void testFetchByCategoryOrSubCategoryUid_deletedResource() {
232 when(janusGraphDao.getVertexById(CATEGORY_UNIQUE_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(categoryVertex));
233 when(janusGraphDao.getParentVertices(categoryVertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(deletedAndNotDeletedResourceVertices));
234 when(toscaOperationFacade.getToscaElement(PROPER_COMPONENT_ID, JsonParseFlagEnum.ParseMetadata))
235 .thenReturn(Either.left(properResource));
236 Either<List<Component>, StorageOperationStatus> resourcesBySubCategoryUidEither = elementBusinessLogic.fetchByCategoryOrSubCategoryUid(CATEGORY_UNIQUE_ID, NodeTypeEnum.Resource, false, null);
237 List<Component> resourcesBySubCategoryUid = resourcesBySubCategoryUidEither.left().value();
238 assertThat(resourcesBySubCategoryUid.size()).isEqualTo(1);
239 assertThat(resourcesBySubCategoryUid.get(0)).isSameAs(properResource);
243 public void testFetchByCategoryOrSubCategoryUid_archivedResource() {
244 when(janusGraphDao.getVertexById(CATEGORY_UNIQUE_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(categoryVertex));
245 when(janusGraphDao.getParentVertices(categoryVertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(archivedAndNotArchivedResourceVertices));
246 when(toscaOperationFacade.getToscaElement(PROPER_COMPONENT_ID, JsonParseFlagEnum.ParseMetadata))
247 .thenReturn(Either.left(properResource));
248 Either<List<Component>, StorageOperationStatus> resourcesBySubCategoryUidEither = elementBusinessLogic.fetchByCategoryOrSubCategoryUid(CATEGORY_UNIQUE_ID, NodeTypeEnum.Resource, false, null);
249 List<Component> resourcesBySubCategoryUid = resourcesBySubCategoryUidEither.left().value();
250 assertThat(resourcesBySubCategoryUid.size()).isEqualTo(1);
251 assertThat(resourcesBySubCategoryUid.get(0)).isSameAs(properResource);
255 public void testFetchByCategoryOrSubCategoryUid_notHighestResource() {
256 when(janusGraphDao.getVertexById(CATEGORY_UNIQUE_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(categoryVertex));
257 when(janusGraphDao.getParentVertices(categoryVertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(notHighestVersionAndHighestVersionResourceVertices));
258 when(toscaOperationFacade.getToscaElement(PROPER_COMPONENT_ID, JsonParseFlagEnum.ParseMetadata))
259 .thenReturn(Either.left(properResource));
260 Either<List<Component>, StorageOperationStatus> resourcesBySubCategoryUidEither = elementBusinessLogic.fetchByCategoryOrSubCategoryUid(CATEGORY_UNIQUE_ID, NodeTypeEnum.Resource, false, null);
261 List<Component> resourcesBySubCategoryUid = resourcesBySubCategoryUidEither.left().value();
262 assertThat(resourcesBySubCategoryUid.size()).isEqualTo(1);
263 assertThat(resourcesBySubCategoryUid.get(0)).isSameAs(properResource);
268 public void testFetchByCategoryOrSubCategoryName_resource() {
269 Map<String, Object> props = new HashMap<>();
270 props.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), ValidationUtils.normalizeCategoryName4Uniqueness(CATEGORY_NAME));
271 when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.ResourceNewCategory, props, SubCategoryData.class))
272 .thenReturn(Either.left(subCategories));
273 when(janusGraphDao.getVertexById(SUBCATEGORY_UNIQUE_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(categoryVertex));
274 when(janusGraphDao.getParentVertices(categoryVertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(deletedAndNotDeletedResourceVertices));
275 when(toscaOperationFacade.getToscaElement(PROPER_COMPONENT_ID, JsonParseFlagEnum.ParseMetadata))
276 .thenReturn(Either.left(properResource));
277 Either<List<Component>, StorageOperationStatus> elementsByCategoryEither =
278 elementBusinessLogic.fetchByCategoryOrSubCategoryName(CATEGORY_NAME, NodeTypeEnum.ResourceNewCategory,
279 NodeTypeEnum.Resource, false, null);
280 List<Component> elementsByCategory = elementsByCategoryEither.left().value();
281 assertThat(elementsByCategory.get(0)).isSameAs(properResource);
282 assertThat(elementsByCategory.size()).isEqualTo(1);
286 public void testDeleteSubCategory() {
287 Either<SubCategoryDefinition, ResponseFormat> result;
288 User user = new User();
289 String userId = "userId";
290 user.setUserId(userId);
291 when(elementBusinessLogic.validateUserExists(anyString())).thenReturn(user);
292 when(elementOperation.deleteSubCategory(NodeTypeEnum.ResourceSubcategory, CATEGORY_UNIQUE_ID)).thenReturn(Either.left(subCategoryDef));
293 result = elementBusinessLogic.deleteSubCategory(CATEGORY_UNIQUE_ID, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
294 Assert.assertTrue(result.isLeft());
298 public void testDeleteGrouping() {
299 Either<GroupingDefinition, ResponseFormat> result;
300 GroupingDefinition groupDef = Mockito.mock(GroupingDefinition.class);
301 when(elementOperation.deleteGrouping(null, "groupId")).thenReturn(Either.left(groupDef));
302 result = elementBusinessLogic.deleteGrouping("groupId", ComponentTypeEnum.RESOURCE_PARAM_NAME, "userId");
303 Assert.assertTrue(result.isLeft());
307 public void testCreateCategory() {
308 Either<CategoryDefinition, ResponseFormat> result;
309 CategoryDefinition categoryDef = new CategoryDefinition();
310 String name = "name";
311 categoryDef.setName(name);
312 User user = new User();
313 String userId = "userId";
314 user.setUserId(userId);
315 user.setRole(Role.ADMIN.name());
316 when(userValidations.validateUserExists(eq(userId))).thenReturn(user);
317 when(elementOperation.isCategoryUniqueForType(NodeTypeEnum.ResourceNewCategory, name)).thenReturn(Either.left(true));
318 when(elementOperation.createCategory(categoryDef, NodeTypeEnum.ResourceNewCategory)).thenReturn(Either.left(categoryDef));
319 result = elementBusinessLogic.createCategory(categoryDef, ComponentTypeEnum.RESOURCE_PARAM_NAME, userId);
320 Assert.assertTrue(result.isLeft());
324 public void testGetAllCategories() {
325 Either<UiCategories, ResponseFormat> result;
326 String userId = "userId";
327 List<CategoryDefinition> categoryDefList = new ArrayList<>();
328 when(elementOperation.getAllCategories(NodeTypeEnum.ResourceNewCategory, false)).thenReturn(Either.left(categoryDefList));
329 when(elementOperation.getAllCategories(NodeTypeEnum.ServiceNewCategory, false)).thenReturn(Either.left(categoryDefList));
330 result = elementBusinessLogic.getAllCategories(userId);
331 Assert.assertTrue(result.isLeft());
335 public void testGetAllCategories_NodeType() {
336 Either<List<CategoryDefinition>, ResponseFormat> result;
337 String userId = "userId";
338 List<CategoryDefinition> categoryDefList = new ArrayList<>();
339 when(elementOperation.getAllCategories(NodeTypeEnum.ResourceNewCategory, false)).thenReturn(Either.left(categoryDefList));
340 result = elementBusinessLogic.getAllCategories("resources", userId);
341 assertEquals(0, result.left().value().size());
345 public void testGetCatalogComp_UuidAndAssetType() {
346 Either<List<? extends Component>, ResponseFormat> result;
347 String uuid = "userId";
348 List<Component> components = new ArrayList<>();
349 when(toscaOperationFacade.getComponentListByUuid(anyString(), anyMap())).thenReturn(Either.left(components));
350 result = elementBusinessLogic.getCatalogComponentsByUuidAndAssetType("resources", uuid);
351 Assert.assertTrue(result.isLeft());
355 public void testCreateGrouping() {
356 Either<GroupingDefinition, ResponseFormat> result;
357 GroupingDefinition groupDef = new GroupingDefinition();
358 String name = "name";
359 groupDef.setName(name);
360 String componentTypeParamName = "products";
361 String grandParentCatId = "gpCatId";
362 String parentSubCatId = "pSubCatId";
363 User user = new User();
364 String userId = "userId";
365 user.setUserId(userId);
366 user.setRole(Role.PRODUCT_STRATEGIST.name());
367 when(elementBusinessLogic.validateUserExists(userId)).thenReturn(user);
368 when(elementOperation.getCategory(NodeTypeEnum.ProductCategory, grandParentCatId)).thenReturn(Either.left(categoryDef));
369 when(elementOperation.getSubCategory(NodeTypeEnum.ProductSubcategory, parentSubCatId)).thenReturn(Either.left(subCategoryDef));
370 when(elementOperation.isGroupingUniqueForSubCategory(NodeTypeEnum.ProductGrouping, name, parentSubCatId)).thenReturn(Either.left(true));
371 when(elementOperation.getGroupingUniqueForType(NodeTypeEnum.ProductGrouping, name)).thenReturn(Either.left(groupDef));
372 when(elementOperation.createGrouping(parentSubCatId, groupDef, NodeTypeEnum.ProductGrouping)).thenReturn(Either.left(groupDef));
374 result = elementBusinessLogic.createGrouping(groupDef, componentTypeParamName, grandParentCatId, parentSubCatId, userId);
375 Assert.assertTrue(result.isLeft());
379 public void testFetchByCategoryOrSubCategoryName_service() {
380 Map<String, Object> props = new HashMap<>();
381 props.put(GraphPropertiesDictionary.NORMALIZED_NAME.getProperty(), ValidationUtils.normalizeCategoryName4Uniqueness(CATEGORY_NAME));
382 when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.ServiceNewCategory, props, CategoryData.class))
383 .thenReturn(Either.left(categories));
384 when(janusGraphDao.getVertexById(CATEGORY_UNIQUE_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(categoryVertex));
385 when(janusGraphDao.getParentVertices(categoryVertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(deletedAndNotDeletedServiceVertices));
386 when(toscaOperationFacade.getToscaElement(PROPER_COMPONENT_ID, JsonParseFlagEnum.ParseMetadata))
387 .thenReturn(Either.left(properService));
388 Either<List<Component>, StorageOperationStatus> elementsByCategoryEither =
389 elementBusinessLogic.fetchByCategoryOrSubCategoryName(CATEGORY_NAME, NodeTypeEnum.ServiceNewCategory,
390 NodeTypeEnum.Service, false, null);
391 List<Component> elementsByCategory = elementsByCategoryEither.left().value();
392 assertThat(elementsByCategory.get(0)).isSameAs(properService);
393 assertThat(elementsByCategory.size()).isEqualTo(1);