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.dao.janusgraph.JanusGraphOperationStatus;
33 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
34 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
35 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
36 import org.openecomp.sdc.be.impl.ComponentsUtils;
37 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
38 import org.openecomp.sdc.be.model.ComponentParametersView;
39 import org.openecomp.sdc.be.model.LifecycleStateEnum;
40 import org.openecomp.sdc.be.model.RelationshipInfo;
41 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
42 import org.openecomp.sdc.be.model.RequirementDefinition;
43 import org.openecomp.sdc.be.model.Resource;
44 import org.openecomp.sdc.be.model.Service;
45 import org.openecomp.sdc.be.model.User;
46 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.RequirementOperation;
47 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
48 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
49 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
50 import org.openecomp.sdc.be.user.Role;
51 import org.openecomp.sdc.be.user.UserBusinessLogic;
52 import org.openecomp.sdc.common.impl.ExternalConfiguration;
53 import org.openecomp.sdc.exception.ResponseFormat;
55 import java.util.ArrayList;
56 import java.util.Collections;
57 import java.util.HashMap;
58 import java.util.List;
60 import java.util.stream.Collectors;
61 import java.util.stream.Stream;
63 import static org.mockito.ArgumentMatchers.any;
64 import static org.mockito.ArgumentMatchers.anyBoolean;
65 import static org.mockito.ArgumentMatchers.anyCollection;
66 import static org.mockito.ArgumentMatchers.anyObject;
67 import static org.mockito.ArgumentMatchers.anyString;
68 import static org.mockito.ArgumentMatchers.eq;
69 import static org.mockito.Mockito.when;
71 public class RequirementBusinessLogicTest extends BaseBusinessLogicMock {
72 private final String componentId = "resourceId1";
73 private final String requirementId = "uniqueId1";
75 private final JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
76 private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
77 private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
78 private final UserValidations userValidations = Mockito.mock(UserValidations.class);
79 private final RequirementOperation requirementOperation = Mockito.mock(RequirementOperation.class);
80 private final RequirementValidation requirementValidation = Mockito.mock(RequirementValidation.class);
82 private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
83 private User user = null;
86 private RequirementBusinessLogic requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
87 groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
88 interfaceLifecycleTypeOperation, artifactToscaOperation);
92 MockitoAnnotations.openMocks(this);
93 ExternalConfiguration.setAppName("catalog-be");
95 ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
96 // User data and management
98 user.setUserId("jh0003");
99 user.setFirstName("Jimmi");
100 user.setLastName("Hendrix");
101 user.setRole(Role.ADMIN.name());
103 when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
104 when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
105 .thenReturn(StorageOperationStatus.OK);
107 //CapabilityOperation
108 when(requirementValidation.validateRequirements(anyCollection(), anyObject(), anyBoolean()))
109 .thenReturn(Either.left(true));
110 when(requirementOperation.addRequirement(anyString(), anyObject()))
111 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
112 "reqName", "capType", "node", "source1",
115 when(requirementOperation.updateRequirement(anyString(), anyObject()))
116 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
117 "reqName", "capType", "node", "source1",
119 when(requirementOperation.deleteRequirements( anyObject(), anyString()))
120 .thenReturn(StorageOperationStatus.OK);
121 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
123 requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
124 groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
125 interfaceLifecycleTypeOperation, artifactToscaOperation);
127 requirementsBusinessLogicMock.setComponentsUtils(componentsUtils);
128 requirementsBusinessLogicMock.setUserAdmin(mockUserAdmin);
129 requirementsBusinessLogicMock.setGraphLockOperation(graphLockOperation);
130 requirementsBusinessLogicMock.setJanusGraphDao(mockJanusGraphDao);
131 requirementsBusinessLogicMock.setToscaOperationFacade(toscaOperationFacade);
132 requirementsBusinessLogicMock.setUserValidations(userValidations);
133 requirementsBusinessLogicMock.setRequirementOperation(requirementOperation);
134 requirementsBusinessLogicMock.setRequirementValidation(requirementValidation);
138 public void shouldPassCreateRequirementsFirstTimeInComponentForHappyScenario(){
139 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
140 createRequirement("reqName", "reqDesc", "capType", "source1",
142 Resource resource = createComponent(false);
143 resource.setComponentType(ComponentTypeEnum.RESOURCE);
144 validateUserRoles(Role.ADMIN, Role.DESIGNER);
145 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
146 .thenReturn(Either.left(resource));
147 Either<List<RequirementDefinition>, ResponseFormat> requirements = requirementsBusinessLogicMock
148 .createRequirements(componentId, requirementDefinitions, user,
149 "createRequirements", true);
150 Assert.assertTrue(requirements.isLeft());
151 Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
152 requirementDefinition.getName().equals("reqName")));
156 public void shouldPassCreateRequirementsForHappyScenario(){
157 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
158 createRequirement("reqName2", "capType", "node", "source1",
160 Resource resource = createComponent(true);
161 resource.setComponentType(ComponentTypeEnum.RESOURCE);
162 validateUserRoles(Role.ADMIN, Role.DESIGNER);
163 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
164 .thenReturn(Either.left(resource));
165 Either<List<RequirementDefinition>, ResponseFormat> requirements = requirementsBusinessLogicMock
166 .createRequirements(componentId, requirementDefinitions, user,
167 "createRequirements", true);
169 Assert.assertTrue(requirements.isLeft());
170 Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
171 requirementDefinition.getName().equals("reqName2")));
175 public void shouldPassUpdateRequirementsForHappyScenario(){
177 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
178 createRequirement("reqName", "capType", "node", "source1",
180 Resource resource = createComponent(true);
181 resource.setComponentType(ComponentTypeEnum.RESOURCE);
182 validateUserRoles(Role.ADMIN, Role.DESIGNER);
183 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
184 .thenReturn(Either.left(resource));
185 when(toscaOperationFacade.getParentComponents(anyString()))
186 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
187 Either<List<RequirementDefinition>, ResponseFormat> capabilities = requirementsBusinessLogicMock
188 .updateRequirements(componentId, requirementDefinitions, user,
189 "updateRequirements", true);
190 Assert.assertTrue(capabilities.isLeft());
191 Assert.assertTrue(capabilities.left().value().stream().anyMatch(requirementDefinition ->
192 requirementDefinition.getMaxOccurrences().equals("11")));
196 public void shouldPassDeleteRequirementsForHappyScenario(){
197 Resource resource = createComponent(true);
198 resource.setComponentType(ComponentTypeEnum.RESOURCE);
199 validateUserRoles(Role.ADMIN, Role.DESIGNER);
200 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
201 .thenReturn(Either.left(resource));
202 when(toscaOperationFacade.getParentComponents(anyString()))
203 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
204 Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
205 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
206 Assert.assertTrue(deleteRequirementEither.isLeft());
211 public void shouldPassUpdateRequirementCapabilityUpdateWhenCapabilityNotExist(){
213 List<RequirementDefinition> requirementDefinitions
214 = createMockRequirementListToReturn(createRequirement(
215 "reqName", "capTypeUpdate", "node", "source1",
217 Resource resource = createComponent(true);
218 resource.setComponentType(ComponentTypeEnum.RESOURCE);
219 validateUserRoles(Role.ADMIN, Role.DESIGNER);
220 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
221 .thenReturn(Either.left(resource));
222 when(toscaOperationFacade.getParentComponents(anyString()))
223 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
224 Either<List<RequirementDefinition>, ResponseFormat> updateRequirements
225 = requirementsBusinessLogicMock.updateRequirements(componentId, requirementDefinitions,
226 user, "updateRequirements", true);
227 Assert.assertTrue(updateRequirements.isLeft());
228 Assert.assertTrue(updateRequirements.left().value().stream().anyMatch(requirementDefinition ->
229 requirementDefinition.getMaxOccurrences().equals("11")));
233 public void shouldPassUpdateRequirementTypeWhenCapabilityExist(){
235 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
236 createRequirement("reqName", "capTypeUpdate1", "node",
237 "source1","6", "11"));
238 Resource resource = createComponent(true);
239 resource.setComponentType(ComponentTypeEnum.RESOURCE);
241 RequirementDefinition requirement = createRequirement("reqName",
242 "capTypeUpdate1", "node", "source1",
244 requirement.setUniqueId("unique2");
245 List<RequirementDefinition> requirementDefinitions1 = createMockRequirementListToReturn(requirement);
246 Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
247 requirementMap.put("capTypeUpdate1", requirementDefinitions1);
248 resource.getRequirements().putAll(requirementMap);
250 validateUserRoles(Role.ADMIN, Role.DESIGNER);
251 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
252 .thenReturn(Either.left(resource));
253 when(toscaOperationFacade.getParentComponents(anyString()))
254 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
255 Either<List<RequirementDefinition>, ResponseFormat> capabilities
256 = requirementsBusinessLogicMock.updateRequirements(componentId, requirementDefinitions,
257 user, "updateRequirements", true);
258 Assert.assertTrue(capabilities.isLeft());
259 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
260 capabilityDefinition.getMaxOccurrences().equals("11")));
264 public void shouldFailUpdateRequirementWhenOperationFailedInJanusGraph(){
265 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
266 createRequirement("reqName", "capType", "node", "source1",
268 Resource resource = createComponent(true);
269 resource.setComponentType(ComponentTypeEnum.RESOURCE);
270 validateUserRoles(Role.ADMIN, Role.DESIGNER);
271 when(requirementOperation.addRequirement(anyString(), anyObject()))
272 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
273 when(requirementOperation.updateRequirement(anyString(), anyObject()))
274 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
275 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
276 .thenReturn(Either.left(resource));
277 Either<List<RequirementDefinition>, ResponseFormat> capabilities = requirementsBusinessLogicMock
278 .updateRequirements(componentId, requirementDefinitions, user,
279 "updateRequirements", true);
281 Assert.assertTrue(capabilities.isRight());
286 public void shouldFailDeleteRequirementWhenOperationFailedInJanusGraph(){
287 Resource resource = createComponent(true);
288 resource.setComponentType(ComponentTypeEnum.RESOURCE);
289 validateUserRoles(Role.ADMIN, Role.DESIGNER);
290 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
291 .thenReturn(Either.left(resource));
292 when(toscaOperationFacade.getParentComponents(anyString()))
293 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
294 when(requirementOperation.deleteRequirements(anyObject(), anyString()))
295 .thenReturn(StorageOperationStatus.GENERAL_ERROR);
296 Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
297 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
298 Assert.assertTrue(deleteRequirementEither.isRight());
302 public void shouldFailDeleteRequirementWhenRequirementUsedInServiceComposition(){
303 Resource resource = createComponent(true);
304 resource.setComponentType(ComponentTypeEnum.RESOURCE);
305 validateUserRoles(Role.ADMIN, Role.DESIGNER);
306 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
307 .thenReturn(Either.left(resource));
308 when(toscaOperationFacade.getParentComponents(anyString()))
309 .thenReturn(Either.left(Collections.singletonList(createParentService())));
310 Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
311 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
312 Assert.assertTrue(deleteRequirementEither.isRight());
316 public void shouldPassGetRequirementsForHappyScenario(){
317 Resource resource = createComponent(true);
318 resource.setComponentType(ComponentTypeEnum.RESOURCE);
319 validateUserRoles(Role.ADMIN, Role.DESIGNER);
320 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
321 .thenReturn(Either.left(resource));
322 when(toscaOperationFacade.getParentComponents(anyString()))
323 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
324 Either<RequirementDefinition, ResponseFormat> getRequirementEither
325 = requirementsBusinessLogicMock.getRequirement(componentId, requirementId, user, true);
326 Assert.assertTrue(getRequirementEither.isLeft());
330 private Resource createComponent(boolean needRequirements) {
331 Resource resource = new Resource();
332 resource.setName("Resource1");
333 resource.addCategory("Network Layer 2-3", "Router");
334 resource.setDescription("My short description");
335 List<String> tgs = new ArrayList<>();
337 tgs.add(resource.getName());
338 resource.setTags(tgs);
340 if(needRequirements) {
341 List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
342 createRequirement("reqName", "capType", "node", "source1",
344 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<>();
345 requirementsMap.put("capType", requirementDefinitions);
346 resource.setRequirements(requirementsMap);
348 resource.setName(resource.getName());
349 resource.setVersion("0.1");
350 resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
351 resource.setCreatorUserId(user.getUserId());
352 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
353 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
357 private List<RequirementDefinition> createMockRequirementListToReturn(RequirementDefinition requirementDefinition) {
358 List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
359 requirementDefinitions.add(requirementDefinition);
360 return requirementDefinitions;
363 private void validateUserRoles(Role... roles) {
364 List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
367 private RequirementDefinition createRequirement(String name, String capability, String node,
368 String relationship, String minOccurrences,
369 String maxOccurrences) {
370 RequirementDefinition requirementDefinition = new RequirementDefinition();
371 requirementDefinition.setName(name);
372 requirementDefinition.setCapability(capability);
373 requirementDefinition.setNode(node);
374 requirementDefinition.setRelationship(relationship);
375 requirementDefinition.setMaxOccurrences(maxOccurrences);
376 requirementDefinition.setMinOccurrences(minOccurrences);
377 requirementDefinition.setUniqueId(requirementId);
379 return requirementDefinition;
382 private Service createParentService() {
383 Service service = new Service();
384 service.setUniqueId("serviceUniqueId");
386 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
387 RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
388 relationDef.setFromNode("fromNode");
389 relationDef.setToNode("toNode");
391 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
392 CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
394 RelationshipInfo relation = new RelationshipInfo();
395 relation.setCapabilityUid("capabilityId");
396 relation.setRequirementUid(requirementId);
397 capabilityRequirementRelationship.setRelation(relation);
399 relationships.add(capabilityRequirementRelationship);
400 relationDef.setRelationships(relationships);
401 resourceInstancesRelations.add(relationDef);
403 service.setComponentInstancesRelations(resourceInstancesRelations);