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