2 * Copyright © 2016-2018 European Support Limited
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 * ================================================================================
16 * Modifications copyright (c) 2019 Nokia
17 * ================================================================================
20 package org.openecomp.sdc.be.components.impl;
22 import fj.data.Either;
23 import org.junit.Assert;
24 import org.junit.Before;
25 import org.junit.Test;
26 import org.mockito.InjectMocks;
27 import org.mockito.Mockito;
28 import org.mockito.MockitoAnnotations;
29 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
30 import org.openecomp.sdc.be.components.validation.RequirementValidation;
31 import org.openecomp.sdc.be.components.validation.UserValidations;
32 import org.openecomp.sdc.be.config.ConfigurationManager;
33 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
34 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
35 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
36 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
37 import org.openecomp.sdc.be.impl.ComponentsUtils;
38 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
39 import org.openecomp.sdc.be.model.ComponentParametersView;
40 import org.openecomp.sdc.be.model.LifecycleStateEnum;
41 import org.openecomp.sdc.be.model.RelationshipInfo;
42 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
43 import org.openecomp.sdc.be.model.RequirementDefinition;
44 import org.openecomp.sdc.be.model.Resource;
45 import org.openecomp.sdc.be.model.Service;
46 import org.openecomp.sdc.be.model.User;
47 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.RequirementOperation;
48 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
49 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
50 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
51 import org.openecomp.sdc.be.user.Role;
52 import org.openecomp.sdc.be.user.UserBusinessLogic;
53 import org.openecomp.sdc.common.api.ConfigurationSource;
54 import org.openecomp.sdc.common.impl.ExternalConfiguration;
55 import org.openecomp.sdc.common.impl.FSConfigurationSource;
56 import org.openecomp.sdc.exception.ResponseFormat;
58 import java.util.ArrayList;
59 import java.util.Collections;
60 import java.util.HashMap;
61 import java.util.List;
63 import java.util.stream.Collectors;
64 import java.util.stream.Stream;
66 import static org.mockito.ArgumentMatchers.any;
67 import static org.mockito.ArgumentMatchers.anyBoolean;
68 import static org.mockito.ArgumentMatchers.anyCollection;
69 import static org.mockito.ArgumentMatchers.anyObject;
70 import static org.mockito.ArgumentMatchers.anyString;
71 import static org.mockito.ArgumentMatchers.eq;
72 import static org.mockito.Mockito.when;
74 public class RequirementBusinessLogicTest extends BaseBusinessLogicMock {
75 private final String componentId = "resourceId1";
76 private final String requirementId = "uniqueId1";
78 private final JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
79 private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
80 private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
81 private final UserValidations userValidations = Mockito.mock(UserValidations.class);
82 private final RequirementOperation requirementOperation = Mockito.mock(RequirementOperation.class);
83 private final RequirementValidation requirementValidation = Mockito.mock(RequirementValidation.class);
85 private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
86 private User user = null;
89 private RequirementBusinessLogic requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
90 groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
91 interfaceLifecycleTypeOperation, artifactToscaOperation);
95 MockitoAnnotations.initMocks(this);
96 ExternalConfiguration.setAppName("catalog-be");
99 String appConfigDir = "src/test/resources/config/catalog-be";
100 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration
101 .getChangeListener(), appConfigDir);
102 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
104 ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
105 // User data and management
107 user.setUserId("jh0003");
108 user.setFirstName("Jimmi");
109 user.setLastName("Hendrix");
110 user.setRole(Role.ADMIN.name());
112 when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
113 when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
114 .thenReturn(StorageOperationStatus.OK);
116 //CapabilityOperation
117 when(requirementValidation.validateRequirements(anyCollection(), anyObject(), anyBoolean()))
118 .thenReturn(Either.left(true));
119 when(requirementOperation.addRequirement(anyString(), anyObject()))
120 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
121 "reqName", "capType", "node", "source1",
124 when(requirementOperation.updateRequirement(anyString(), anyObject()))
125 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
126 "reqName", "capType", "node", "source1",
128 when(requirementOperation.deleteRequirements( anyObject(), anyString()))
129 .thenReturn(StorageOperationStatus.OK);
130 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
132 requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
133 groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
134 interfaceLifecycleTypeOperation, artifactToscaOperation);
136 requirementsBusinessLogicMock.setComponentsUtils(componentsUtils);
137 requirementsBusinessLogicMock.setUserAdmin(mockUserAdmin);
138 requirementsBusinessLogicMock.setGraphLockOperation(graphLockOperation);
139 requirementsBusinessLogicMock.setJanusGraphDao(mockJanusGraphDao);
140 requirementsBusinessLogicMock.setToscaOperationFacade(toscaOperationFacade);
141 requirementsBusinessLogicMock.setUserValidations(userValidations);
142 requirementsBusinessLogicMock.setRequirementOperation(requirementOperation);
143 requirementsBusinessLogicMock.setRequirementValidation(requirementValidation);
147 public void shouldPassCreateRequirementsFirstTimeInComponentForHappyScenario(){
148 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
149 createRequirement("reqName", "reqDesc", "capType", "source1",
151 Resource resource = createComponent(false);
152 resource.setComponentType(ComponentTypeEnum.RESOURCE);
153 validateUserRoles(Role.ADMIN, Role.DESIGNER);
154 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
155 .thenReturn(Either.left(resource));
156 Either<List<RequirementDefinition>, ResponseFormat> requirements = requirementsBusinessLogicMock
157 .createRequirements(componentId, requirementDefinitions, user,
158 "createRequirements", true);
159 Assert.assertTrue(requirements.isLeft());
160 Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
161 requirementDefinition.getName().equals("reqName")));
165 public void shouldPassCreateRequirementsForHappyScenario(){
166 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
167 createRequirement("reqName2", "capType", "node", "source1",
169 Resource resource = createComponent(true);
170 resource.setComponentType(ComponentTypeEnum.RESOURCE);
171 validateUserRoles(Role.ADMIN, Role.DESIGNER);
172 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
173 .thenReturn(Either.left(resource));
174 Either<List<RequirementDefinition>, ResponseFormat> requirements = requirementsBusinessLogicMock
175 .createRequirements(componentId, requirementDefinitions, user,
176 "createRequirements", true);
178 Assert.assertTrue(requirements.isLeft());
179 Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
180 requirementDefinition.getName().equals("reqName2")));
184 public void shouldPassUpdateRequirementsForHappyScenario(){
186 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
187 createRequirement("reqName", "capType", "node", "source1",
189 Resource resource = createComponent(true);
190 resource.setComponentType(ComponentTypeEnum.RESOURCE);
191 validateUserRoles(Role.ADMIN, Role.DESIGNER);
192 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
193 .thenReturn(Either.left(resource));
194 when(toscaOperationFacade.getParentComponents(anyString()))
195 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
196 Either<List<RequirementDefinition>, ResponseFormat> capabilities = requirementsBusinessLogicMock
197 .updateRequirements(componentId, requirementDefinitions, user,
198 "updateRequirements", true);
199 Assert.assertTrue(capabilities.isLeft());
200 Assert.assertTrue(capabilities.left().value().stream().anyMatch(requirementDefinition ->
201 requirementDefinition.getMaxOccurrences().equals("11")));
205 public void shouldPassDeleteRequirementsForHappyScenario(){
206 Resource resource = createComponent(true);
207 resource.setComponentType(ComponentTypeEnum.RESOURCE);
208 validateUserRoles(Role.ADMIN, Role.DESIGNER);
209 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
210 .thenReturn(Either.left(resource));
211 when(toscaOperationFacade.getParentComponents(anyString()))
212 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
213 Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
214 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
215 Assert.assertTrue(deleteRequirementEither.isLeft());
220 public void shouldPassUpdateRequirementCapabilityUpdateWhenCapabilityNotExist(){
222 List<RequirementDefinition> requirementDefinitions
223 = createMockRequirementListToReturn(createRequirement(
224 "reqName", "capTypeUpdate", "node", "source1",
226 Resource resource = createComponent(true);
227 resource.setComponentType(ComponentTypeEnum.RESOURCE);
228 validateUserRoles(Role.ADMIN, Role.DESIGNER);
229 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
230 .thenReturn(Either.left(resource));
231 when(toscaOperationFacade.getParentComponents(anyString()))
232 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
233 Either<List<RequirementDefinition>, ResponseFormat> updateRequirements
234 = requirementsBusinessLogicMock.updateRequirements(componentId, requirementDefinitions,
235 user, "updateRequirements", true);
236 Assert.assertTrue(updateRequirements.isLeft());
237 Assert.assertTrue(updateRequirements.left().value().stream().anyMatch(requirementDefinition ->
238 requirementDefinition.getMaxOccurrences().equals("11")));
242 public void shouldPassUpdateRequirementTypeWhenCapabilityExist(){
244 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
245 createRequirement("reqName", "capTypeUpdate1", "node",
246 "source1","6", "11"));
247 Resource resource = createComponent(true);
248 resource.setComponentType(ComponentTypeEnum.RESOURCE);
250 RequirementDefinition requirement = createRequirement("reqName",
251 "capTypeUpdate1", "node", "source1",
253 requirement.setUniqueId("unique2");
254 List<RequirementDefinition> requirementDefinitions1 = createMockRequirementListToReturn(requirement);
255 Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
256 requirementMap.put("capTypeUpdate1", requirementDefinitions1);
257 resource.getRequirements().putAll(requirementMap);
259 validateUserRoles(Role.ADMIN, Role.DESIGNER);
260 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
261 .thenReturn(Either.left(resource));
262 when(toscaOperationFacade.getParentComponents(anyString()))
263 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
264 Either<List<RequirementDefinition>, ResponseFormat> capabilities
265 = requirementsBusinessLogicMock.updateRequirements(componentId, requirementDefinitions,
266 user, "updateRequirements", true);
267 Assert.assertTrue(capabilities.isLeft());
268 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
269 capabilityDefinition.getMaxOccurrences().equals("11")));
273 public void shouldFailUpdateRequirementWhenOperationFailedInJanusGraph(){
274 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
275 createRequirement("reqName", "capType", "node", "source1",
277 Resource resource = createComponent(true);
278 resource.setComponentType(ComponentTypeEnum.RESOURCE);
279 validateUserRoles(Role.ADMIN, Role.DESIGNER);
280 when(requirementOperation.addRequirement(anyString(), anyObject()))
281 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
282 when(requirementOperation.updateRequirement(anyString(), anyObject()))
283 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
284 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
285 .thenReturn(Either.left(resource));
286 Either<List<RequirementDefinition>, ResponseFormat> capabilities = requirementsBusinessLogicMock
287 .updateRequirements(componentId, requirementDefinitions, user,
288 "updateRequirements", true);
290 Assert.assertTrue(capabilities.isRight());
295 public void shouldFailDeleteRequirementWhenOperationFailedInJanusGraph(){
296 Resource resource = createComponent(true);
297 resource.setComponentType(ComponentTypeEnum.RESOURCE);
298 validateUserRoles(Role.ADMIN, Role.DESIGNER);
299 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
300 .thenReturn(Either.left(resource));
301 when(toscaOperationFacade.getParentComponents(anyString()))
302 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
303 when(requirementOperation.deleteRequirements(anyObject(), anyString()))
304 .thenReturn(StorageOperationStatus.GENERAL_ERROR);
305 Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
306 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
307 Assert.assertTrue(deleteRequirementEither.isRight());
311 public void shouldFailDeleteRequirementWhenRequirementUsedInServiceComposition(){
312 Resource resource = createComponent(true);
313 resource.setComponentType(ComponentTypeEnum.RESOURCE);
314 validateUserRoles(Role.ADMIN, Role.DESIGNER);
315 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
316 .thenReturn(Either.left(resource));
317 when(toscaOperationFacade.getParentComponents(anyString()))
318 .thenReturn(Either.left(Collections.singletonList(createParentService())));
319 Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
320 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
321 Assert.assertTrue(deleteRequirementEither.isRight());
325 public void shouldPassGetRequirementsForHappyScenario(){
326 Resource resource = createComponent(true);
327 resource.setComponentType(ComponentTypeEnum.RESOURCE);
328 validateUserRoles(Role.ADMIN, Role.DESIGNER);
329 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
330 .thenReturn(Either.left(resource));
331 when(toscaOperationFacade.getParentComponents(anyString()))
332 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
333 Either<RequirementDefinition, ResponseFormat> getRequirementEither
334 = requirementsBusinessLogicMock.getRequirement(componentId, requirementId, user, true);
335 Assert.assertTrue(getRequirementEither.isLeft());
339 private Resource createComponent(boolean needRequirements) {
340 Resource resource = new Resource();
341 resource.setName("Resource1");
342 resource.addCategory("Network Layer 2-3", "Router");
343 resource.setDescription("My short description");
344 List<String> tgs = new ArrayList<>();
346 tgs.add(resource.getName());
347 resource.setTags(tgs);
349 if(needRequirements) {
350 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
351 createRequirement("reqName", "capType", "node", "source1",
353 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<>();
354 requirementsMap.put("capType", requirementDefinitions);
355 resource.setRequirements(requirementsMap);
357 resource.setName(resource.getName());
358 resource.setVersion("0.1");
359 resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
360 resource.setCreatorUserId(user.getUserId());
361 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
362 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
366 private List<RequirementDefinition> createMockRequirementListToReturn(RequirementDefinition requirementDefinition) {
367 List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
368 requirementDefinitions.add(requirementDefinition);
369 return requirementDefinitions;
372 private void validateUserRoles(Role... roles) {
373 List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
376 private RequirementDefinition createRequirement(String name, String capability, String node,
377 String relationship, String minOccurrences,
378 String maxOccurrences) {
379 RequirementDefinition requirementDefinition = new RequirementDefinition();
380 requirementDefinition.setName(name);
381 requirementDefinition.setCapability(capability);
382 requirementDefinition.setNode(node);
383 requirementDefinition.setRelationship(relationship);
384 requirementDefinition.setMaxOccurrences(maxOccurrences);
385 requirementDefinition.setMinOccurrences(minOccurrences);
386 requirementDefinition.setUniqueId(requirementId);
388 return requirementDefinition;
391 private Service createParentService() {
392 Service service = new Service();
393 service.setUniqueId("serviceUniqueId");
395 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
396 RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
397 relationDef.setFromNode("fromNode");
398 relationDef.setToNode("toNode");
400 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
401 CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
403 RelationshipInfo relation = new RelationshipInfo();
404 relation.setCapabilityUid("capabilityId");
405 relation.setRequirementUid(requirementId);
406 capabilityRequirementRelationship.setRelation(relation);
408 relationships.add(capabilityRequirementRelationship);
409 relationDef.setRelationships(relationships);
410 resourceInstancesRelations.add(relationDef);
412 service.setComponentInstancesRelations(resourceInstancesRelations);