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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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  * ================================================================================
  18  */
  19
  20 package org.openecomp.sdc.be.components.impl;
  21
  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;
  54
  55 import java.util.ArrayList;
  56 import java.util.Collections;
  57 import java.util.HashMap;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.stream.Collectors;
  61 import java.util.stream.Stream;
  62
  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.anyString;
  67 import static org.mockito.ArgumentMatchers.eq;
  68 import static org.mockito.Mockito.when;
  69
  70 public class RequirementBusinessLogicTest extends BaseBusinessLogicMock {
  71     private final String componentId = "resourceId1";
  72     private final String requirementId = "uniqueId1";
  73
  74     private final JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
  75     private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
  76     private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
  77     private final UserValidations userValidations = Mockito.mock(UserValidations.class);
  78     private final RequirementOperation requirementOperation = Mockito.mock(RequirementOperation.class);
  79     private final RequirementValidation requirementValidation = Mockito.mock(RequirementValidation.class);
  80
  81     private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
  82     private User user = null;
  83
  84     @InjectMocks
  85     private RequirementBusinessLogic requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
  86         groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
  87         interfaceLifecycleTypeOperation, artifactToscaOperation);
  88
  89     @Before
  90     public void setup() {
  91         MockitoAnnotations.openMocks(this);
  92         ExternalConfiguration.setAppName("catalog-be");
  93
  94         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  95         // User data and management
  96         user = new User();
  97         user.setUserId("jh0003");
  98         user.setFirstName("Jimmi");
  99         user.setLastName("Hendrix");
 100         user.setRole(Role.ADMIN.name());
 101
 102         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 103         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
 104                 .thenReturn(StorageOperationStatus.OK);
 105
 106         //CapabilityOperation
 107         when(requirementValidation.validateRequirements(anyCollection(), any(), anyBoolean()))
 108                 .thenReturn(Either.left(true));
 109         when(requirementOperation.addRequirement(anyString(), any()))
 110                 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
 111                         "reqName", "capType", "node", "source1",
 112                         "0", "10"))));
 113
 114         when(requirementOperation.updateRequirement(anyString(), any()))
 115                 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
 116                         "reqName", "capType", "node", "source1",
 117                 "0", "10"))));
 118         when(requirementOperation.deleteRequirements( any(), anyString()))
 119                 .thenReturn(StorageOperationStatus.OK);
 120         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 121
 122         requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
 123             groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
 124             interfaceLifecycleTypeOperation, artifactToscaOperation);
 125
 126         requirementsBusinessLogicMock.setComponentsUtils(componentsUtils);
 127         requirementsBusinessLogicMock.setUserAdmin(mockUserAdmin);
 128         requirementsBusinessLogicMock.setGraphLockOperation(graphLockOperation);
 129         requirementsBusinessLogicMock.setJanusGraphDao(mockJanusGraphDao);
 130         requirementsBusinessLogicMock.setToscaOperationFacade(toscaOperationFacade);
 131         requirementsBusinessLogicMock.setUserValidations(userValidations);
 132         requirementsBusinessLogicMock.setRequirementOperation(requirementOperation);
 133         requirementsBusinessLogicMock.setRequirementValidation(requirementValidation);
 134     }
 135
 136     @Test
 137     public void shouldPassCreateRequirementsFirstTimeInComponentForHappyScenario(){
 138         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 139                 createRequirement("reqName", "reqDesc", "capType", "source1",
 140                 "0", "10"));
 141         Resource resource = createComponent(false);
 142         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 143         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 144         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 145                 .thenReturn(Either.left(resource));
 146         Either<List<RequirementDefinition>, ResponseFormat> requirements = requirementsBusinessLogicMock
 147                 .createRequirements(componentId, requirementDefinitions, user,
 148                          "createRequirements", true);
 149         Assert.assertTrue(requirements.isLeft());
 150         Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
 151                 requirementDefinition.getName().equals("reqName")));
 152     }
 153
 154     @Test
 155     public void shouldPassCreateRequirementsForHappyScenario(){
 156         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 157                 createRequirement("reqName2", "capType", "node", "source1",
 158                 "0", "10"));
 159         Resource resource = createComponent(true);
 160         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 161         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 162         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 163                 .thenReturn(Either.left(resource));
 164         Either<List<RequirementDefinition>, ResponseFormat> requirements = requirementsBusinessLogicMock
 165                 .createRequirements(componentId, requirementDefinitions, user,
 166                          "createRequirements", true);
 167
 168         Assert.assertTrue(requirements.isLeft());
 169         Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
 170                 requirementDefinition.getName().equals("reqName2")));
 171     }
 172
 173     @Test
 174     public void shouldPassUpdateRequirementsForHappyScenario(){
 175
 176         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 177                 createRequirement("reqName", "capType", "node", "source1",
 178                 "6", "11"));
 179         Resource resource = createComponent(true);
 180         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 181         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 182         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 183                 .thenReturn(Either.left(resource));
 184         when(toscaOperationFacade.getParentComponents(anyString()))
 185                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 186         Either<List<RequirementDefinition>, ResponseFormat> capabilities = requirementsBusinessLogicMock
 187                 .updateRequirements(componentId, requirementDefinitions, user,
 188                          "updateRequirements", true);
 189         Assert.assertTrue(capabilities.isLeft());
 190         Assert.assertTrue(capabilities.left().value().stream().anyMatch(requirementDefinition ->
 191                 requirementDefinition.getMaxOccurrences().equals("11")));
 192     }
 193
 194     @Test
 195     public void shouldPassDeleteRequirementsForHappyScenario(){
 196         Resource resource = createComponent(true);
 197         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 198         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 199         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 200                 .thenReturn(Either.left(resource));
 201         when(toscaOperationFacade.getParentComponents(anyString()))
 202                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 203         Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
 204                 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
 205         Assert.assertTrue(deleteRequirementEither.isLeft());
 206
 207     }
 208
 209     @Test
 210     public void shouldPassUpdateRequirementCapabilityUpdateWhenCapabilityNotExist(){
 211
 212         List<RequirementDefinition> requirementDefinitions
 213                 = createMockRequirementListToReturn(createRequirement(
 214                         "reqName", "capTypeUpdate", "node", "source1",
 215                 "6", "11"));
 216         Resource resource = createComponent(true);
 217         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 218         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 219         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 220                 .thenReturn(Either.left(resource));
 221         when(toscaOperationFacade.getParentComponents(anyString()))
 222                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 223         Either<List<RequirementDefinition>, ResponseFormat> updateRequirements
 224                 = requirementsBusinessLogicMock.updateRequirements(componentId, requirementDefinitions,
 225                 user,  "updateRequirements", true);
 226         Assert.assertTrue(updateRequirements.isLeft());
 227         Assert.assertTrue(updateRequirements.left().value().stream().anyMatch(requirementDefinition ->
 228                 requirementDefinition.getMaxOccurrences().equals("11")));
 229     }
 230
 231     @Test
 232     public void shouldPassUpdateRequirementTypeWhenCapabilityExist(){
 233
 234         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 235                 createRequirement("reqName", "capTypeUpdate1", "node",
 236                         "source1","6", "11"));
 237         Resource resource = createComponent(true);
 238         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 239
 240         RequirementDefinition requirement = createRequirement("reqName",
 241                 "capTypeUpdate1", "node", "source1",
 242                 "6", "11");
 243         requirement.setUniqueId("unique2");
 244         List<RequirementDefinition> requirementDefinitions1 = createMockRequirementListToReturn(requirement);
 245         Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
 246         requirementMap.put("capTypeUpdate1", requirementDefinitions1);
 247         resource.getRequirements().putAll(requirementMap);
 248
 249         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 250         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 251                 .thenReturn(Either.left(resource));
 252         when(toscaOperationFacade.getParentComponents(anyString()))
 253                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 254         Either<List<RequirementDefinition>, ResponseFormat> capabilities
 255                 = requirementsBusinessLogicMock.updateRequirements(componentId, requirementDefinitions,
 256                 user,  "updateRequirements", true);
 257         Assert.assertTrue(capabilities.isLeft());
 258         Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
 259                 capabilityDefinition.getMaxOccurrences().equals("11")));
 260     }
 261
 262     @Test
 263     public void shouldFailUpdateRequirementWhenOperationFailedInJanusGraph(){
 264         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 265                 createRequirement("reqName", "capType", "node", "source1",
 266                 "6", "11"));
 267         Resource resource = createComponent(true);
 268         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 269         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 270         when(requirementOperation.addRequirement(anyString(), any()))
 271                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 272         when(requirementOperation.updateRequirement(anyString(), any()))
 273                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 274         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 275                 .thenReturn(Either.left(resource));
 276         Either<List<RequirementDefinition>, ResponseFormat> capabilities = requirementsBusinessLogicMock
 277                 .updateRequirements(componentId, requirementDefinitions, user,
 278                         "updateRequirements", true);
 279
 280         Assert.assertTrue(capabilities.isRight());
 281     }
 282
 283
 284     @Test
 285     public void shouldFailDeleteRequirementWhenOperationFailedInJanusGraph(){
 286         Resource resource = createComponent(true);
 287         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 288         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 289         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 290                 .thenReturn(Either.left(resource));
 291         when(toscaOperationFacade.getParentComponents(anyString()))
 292                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 293         when(requirementOperation.deleteRequirements(any(), anyString()))
 294                 .thenReturn(StorageOperationStatus.GENERAL_ERROR);
 295         Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
 296                 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
 297         Assert.assertTrue(deleteRequirementEither.isRight());
 298     }
 299
 300     @Test
 301     public void shouldFailDeleteRequirementWhenRequirementUsedInServiceComposition(){
 302         Resource resource = createComponent(true);
 303         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 304         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 305         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 306                 .thenReturn(Either.left(resource));
 307         when(toscaOperationFacade.getParentComponents(anyString()))
 308                 .thenReturn(Either.left(Collections.singletonList(createParentService())));
 309         Either<RequirementDefinition, ResponseFormat> deleteRequirementEither
 310                 = requirementsBusinessLogicMock.deleteRequirement(componentId, requirementId, user, true);
 311         Assert.assertTrue(deleteRequirementEither.isRight());
 312     }
 313
 314     @Test
 315     public void shouldPassGetRequirementsForHappyScenario(){
 316         Resource resource = createComponent(true);
 317         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 318         validateUserRoles(Role.ADMIN, Role.DESIGNER);
 319         when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
 320                 .thenReturn(Either.left(resource));
 321         when(toscaOperationFacade.getParentComponents(anyString()))
 322                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 323         Either<RequirementDefinition, ResponseFormat> getRequirementEither
 324                 = requirementsBusinessLogicMock.getRequirement(componentId, requirementId, user, true);
 325         Assert.assertTrue(getRequirementEither.isLeft());
 326
 327     }
 328
 329     private Resource createComponent(boolean needRequirements) {
 330         Resource resource = new Resource();
 331         resource.setName("Resource1");
 332         resource.addCategory("Network Layer 2-3", "Router");
 333         resource.setDescription("My short description");
 334         List<String> tgs = new ArrayList<>();
 335         tgs.add("test");
 336         tgs.add(resource.getName());
 337         resource.setTags(tgs);
 338
 339         if(needRequirements) {
 340             List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 341                     createRequirement("reqName", "capType", "node", "source1",
 342                     "0", "10"));
 343             Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<>();
 344             requirementsMap.put("capType", requirementDefinitions);
 345             resource.setRequirements(requirementsMap);
 346         }
 347         resource.setName(resource.getName());
 348         resource.setVersion("0.1");
 349         resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
 350         resource.setCreatorUserId(user.getUserId());
 351         resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
 352         resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 353         return resource;
 354     }
 355
 356     private List<RequirementDefinition> createMockRequirementListToReturn(RequirementDefinition requirementDefinition) {
 357         List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
 358         requirementDefinitions.add(requirementDefinition);
 359         return requirementDefinitions;
 360     }
 361
 362     private void validateUserRoles(Role... roles) {
 363         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
 364     }
 365
 366     private RequirementDefinition createRequirement(String name, String capability, String node,
 367                                                     String relationship, String minOccurrences,
 368                                                     String maxOccurrences) {
 369         RequirementDefinition requirementDefinition = new RequirementDefinition();
 370         requirementDefinition.setName(name);
 371         requirementDefinition.setCapability(capability);
 372         requirementDefinition.setNode(node);
 373         requirementDefinition.setRelationship(relationship);
 374         requirementDefinition.setMaxOccurrences(maxOccurrences);
 375         requirementDefinition.setMinOccurrences(minOccurrences);
 376         requirementDefinition.setUniqueId(requirementId);
 377
 378         return requirementDefinition;
 379     }
 380
 381     private Service createParentService() {
 382         Service service = new Service();
 383         service.setUniqueId("serviceUniqueId");
 384
 385         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 386         RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
 387         relationDef.setFromNode("fromNode");
 388         relationDef.setToNode("toNode");
 389
 390         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 391         CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
 392
 393         RelationshipInfo relation = new RelationshipInfo();
 394         relation.setCapabilityUid("capabilityId");
 395         relation.setRequirementUid(requirementId);
 396         capabilityRequirementRelationship.setRelation(relation);
 397
 398         relationships.add(capabilityRequirementRelationship);
 399         relationDef.setRelationships(relationships);
 400         resourceInstancesRelations.add(relationDef);
 401
 402         service.setComponentInstancesRelations(resourceInstancesRelations);
 403
 404         return service;
 405     }
 406
 407 }