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.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;
  57
  58 import java.util.ArrayList;
  59 import java.util.Collections;
  60 import java.util.HashMap;
  61 import java.util.List;
  62 import java.util.Map;
  63 import java.util.stream.Collectors;
  64 import java.util.stream.Stream;
  65
  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;
  73
  74 public class RequirementBusinessLogicTest extends BaseBusinessLogicMock {
  75     private final String componentId = "resourceId1";
  76     private final String requirementId = "uniqueId1";
  77
  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);
  84
  85     private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
  86     private User user = null;
  87
  88     @InjectMocks
  89     private RequirementBusinessLogic requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
  90         groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
  91         interfaceLifecycleTypeOperation, artifactToscaOperation);
  92
  93     @Before
  94     public void setup() {
  95         MockitoAnnotations.initMocks(this);
  96         ExternalConfiguration.setAppName("catalog-be");
  97
  98         // init Configuration
  99         String appConfigDir = "src/test/resources/config/catalog-be";
 100         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration
 101                 .getChangeListener(), appConfigDir);
 102         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 103
 104         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
 105         // User data and management
 106         user = new User();
 107         user.setUserId("jh0003");
 108         user.setFirstName("Jimmi");
 109         user.setLastName("Hendrix");
 110         user.setRole(Role.ADMIN.name());
 111
 112         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 113         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
 114                 .thenReturn(StorageOperationStatus.OK);
 115
 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",
 122                         "0", "10"))));
 123
 124         when(requirementOperation.updateRequirement(anyString(), anyObject()))
 125                 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
 126                         "reqName", "capType", "node", "source1",
 127                 "0", "10"))));
 128         when(requirementOperation.deleteRequirements( anyObject(), anyString()))
 129                 .thenReturn(StorageOperationStatus.OK);
 130         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 131
 132         requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
 133             groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
 134             interfaceLifecycleTypeOperation, artifactToscaOperation);
 135
 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);
 144     }
 145
 146     @Test
 147     public void shouldPassCreateRequirementsFirstTimeInComponentForHappyScenario(){
 148         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 149                 createRequirement("reqName", "reqDesc", "capType", "source1",
 150                 "0", "10"));
 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")));
 162     }
 163
 164     @Test
 165     public void shouldPassCreateRequirementsForHappyScenario(){
 166         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 167                 createRequirement("reqName2", "capType", "node", "source1",
 168                 "0", "10"));
 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);
 177
 178         Assert.assertTrue(requirements.isLeft());
 179         Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
 180                 requirementDefinition.getName().equals("reqName2")));
 181     }
 182
 183     @Test
 184     public void shouldPassUpdateRequirementsForHappyScenario(){
 185
 186         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 187                 createRequirement("reqName", "capType", "node", "source1",
 188                 "6", "11"));
 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")));
 202     }
 203
 204     @Test
 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());
 216
 217     }
 218
 219     @Test
 220     public void shouldPassUpdateRequirementCapabilityUpdateWhenCapabilityNotExist(){
 221
 222         List<RequirementDefinition> requirementDefinitions
 223                 = createMockRequirementListToReturn(createRequirement(
 224                         "reqName", "capTypeUpdate", "node", "source1",
 225                 "6", "11"));
 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")));
 239     }
 240
 241     @Test
 242     public void shouldPassUpdateRequirementTypeWhenCapabilityExist(){
 243
 244         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 245                 createRequirement("reqName", "capTypeUpdate1", "node",
 246                         "source1","6", "11"));
 247         Resource resource = createComponent(true);
 248         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 249
 250         RequirementDefinition requirement = createRequirement("reqName",
 251                 "capTypeUpdate1", "node", "source1",
 252                 "6", "11");
 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);
 258
 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")));
 270     }
 271
 272     @Test
 273     public void shouldFailUpdateRequirementWhenOperationFailedInJanusGraph(){
 274         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 275                 createRequirement("reqName", "capType", "node", "source1",
 276                 "6", "11"));
 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);
 289
 290         Assert.assertTrue(capabilities.isRight());
 291     }
 292
 293
 294     @Test
 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());
 308     }
 309
 310     @Test
 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());
 322     }
 323
 324     @Test
 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());
 336
 337     }
 338
 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<>();
 345         tgs.add("test");
 346         tgs.add(resource.getName());
 347         resource.setTags(tgs);
 348
 349         if(needRequirements) {
 350             List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 351                     createRequirement("reqName", "capType", "node", "source1",
 352                     "0", "10"));
 353             Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<>();
 354             requirementsMap.put("capType", requirementDefinitions);
 355             resource.setRequirements(requirementsMap);
 356         }
 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);
 363         return resource;
 364     }
 365
 366     private List<RequirementDefinition> createMockRequirementListToReturn(RequirementDefinition requirementDefinition) {
 367         List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
 368         requirementDefinitions.add(requirementDefinition);
 369         return requirementDefinitions;
 370     }
 371
 372     private void validateUserRoles(Role... roles) {
 373         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
 374     }
 375
 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);
 387
 388         return requirementDefinition;
 389     }
 390
 391     private Service createParentService() {
 392         Service service = new Service();
 393         service.setUniqueId("serviceUniqueId");
 394
 395         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 396         RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
 397         relationDef.setFromNode("fromNode");
 398         relationDef.setToNode("toNode");
 399
 400         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 401         CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
 402
 403         RelationshipInfo relation = new RelationshipInfo();
 404         relation.setCapabilityUid("capabilityId");
 405         relation.setRequirementUid(requirementId);
 406         capabilityRequirementRelationship.setRelation(relation);
 407
 408         relationships.add(capabilityRequirementRelationship);
 409         relationDef.setRelationships(relationships);
 410         resourceInstancesRelations.add(relationDef);
 411
 412         service.setComponentInstancesRelations(resourceInstancesRelations);
 413
 414         return service;
 415     }
 416
 417 }