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.anyObject;
  67 import static org.mockito.ArgumentMatchers.anyString;
  68 import static org.mockito.ArgumentMatchers.eq;
  69 import static org.mockito.Mockito.when;
  70
  71 public class RequirementBusinessLogicTest extends BaseBusinessLogicMock {
  72     private final String componentId = "resourceId1";
  73     private final String requirementId = "uniqueId1";
  74
  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);
  81
  82     private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
  83     private User user = null;
  84
  85     @InjectMocks
  86     private RequirementBusinessLogic requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
  87         groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
  88         interfaceLifecycleTypeOperation, artifactToscaOperation);
  89
  90     @Before
  91     public void setup() {
  92         MockitoAnnotations.initMocks(this);
  93         ExternalConfiguration.setAppName("catalog-be");
  94
  95         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  96         // User data and management
  97         user = new User();
  98         user.setUserId("jh0003");
  99         user.setFirstName("Jimmi");
 100         user.setLastName("Hendrix");
 101         user.setRole(Role.ADMIN.name());
 102
 103         when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
 104         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
 105                 .thenReturn(StorageOperationStatus.OK);
 106
 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",
 113                         "0", "10"))));
 114
 115         when(requirementOperation.updateRequirement(anyString(), anyObject()))
 116                 .thenReturn(Either.left(createMockRequirementListToReturn(createRequirement(
 117                         "reqName", "capType", "node", "source1",
 118                 "0", "10"))));
 119         when(requirementOperation.deleteRequirements( anyObject(), anyString()))
 120                 .thenReturn(StorageOperationStatus.OK);
 121         when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 122
 123         requirementsBusinessLogicMock = new RequirementBusinessLogic(elementDao,
 124             groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
 125             interfaceLifecycleTypeOperation, artifactToscaOperation);
 126
 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);
 135     }
 136
 137     @Test
 138     public void shouldPassCreateRequirementsFirstTimeInComponentForHappyScenario(){
 139         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 140                 createRequirement("reqName", "reqDesc", "capType", "source1",
 141                 "0", "10"));
 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")));
 153     }
 154
 155     @Test
 156     public void shouldPassCreateRequirementsForHappyScenario(){
 157         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 158                 createRequirement("reqName2", "capType", "node", "source1",
 159                 "0", "10"));
 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);
 168
 169         Assert.assertTrue(requirements.isLeft());
 170         Assert.assertTrue(requirements.left().value().stream().anyMatch(requirementDefinition ->
 171                 requirementDefinition.getName().equals("reqName2")));
 172     }
 173
 174     @Test
 175     public void shouldPassUpdateRequirementsForHappyScenario(){
 176
 177         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 178                 createRequirement("reqName", "capType", "node", "source1",
 179                 "6", "11"));
 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")));
 193     }
 194
 195     @Test
 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());
 207
 208     }
 209
 210     @Test
 211     public void shouldPassUpdateRequirementCapabilityUpdateWhenCapabilityNotExist(){
 212
 213         List<RequirementDefinition> requirementDefinitions
 214                 = createMockRequirementListToReturn(createRequirement(
 215                         "reqName", "capTypeUpdate", "node", "source1",
 216                 "6", "11"));
 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")));
 230     }
 231
 232     @Test
 233     public void shouldPassUpdateRequirementTypeWhenCapabilityExist(){
 234
 235         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 236                 createRequirement("reqName", "capTypeUpdate1", "node",
 237                         "source1","6", "11"));
 238         Resource resource = createComponent(true);
 239         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 240
 241         RequirementDefinition requirement = createRequirement("reqName",
 242                 "capTypeUpdate1", "node", "source1",
 243                 "6", "11");
 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);
 249
 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")));
 261     }
 262
 263     @Test
 264     public void shouldFailUpdateRequirementWhenOperationFailedInJanusGraph(){
 265         List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 266                 createRequirement("reqName", "capType", "node", "source1",
 267                 "6", "11"));
 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);
 280
 281         Assert.assertTrue(capabilities.isRight());
 282     }
 283
 284
 285     @Test
 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());
 299     }
 300
 301     @Test
 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());
 313     }
 314
 315     @Test
 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());
 327
 328     }
 329
 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<>();
 336         tgs.add("test");
 337         tgs.add(resource.getName());
 338         resource.setTags(tgs);
 339
 340         if(needRequirements) {
 341             List<RequirementDefinition> requirementDefinitions = createMockRequirementListToReturn(
 342                     createRequirement("reqName", "capType", "node", "source1",
 343                     "0", "10"));
 344             Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<>();
 345             requirementsMap.put("capType", requirementDefinitions);
 346             resource.setRequirements(requirementsMap);
 347         }
 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);
 354         return resource;
 355     }
 356
 357     private List<RequirementDefinition> createMockRequirementListToReturn(RequirementDefinition requirementDefinition) {
 358         List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
 359         requirementDefinitions.add(requirementDefinition);
 360         return requirementDefinitions;
 361     }
 362
 363     private void validateUserRoles(Role... roles) {
 364         List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
 365     }
 366
 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);
 378
 379         return requirementDefinition;
 380     }
 381
 382     private Service createParentService() {
 383         Service service = new Service();
 384         service.setUniqueId("serviceUniqueId");
 385
 386         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 387         RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
 388         relationDef.setFromNode("fromNode");
 389         relationDef.setToNode("toNode");
 390
 391         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 392         CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
 393
 394         RelationshipInfo relation = new RelationshipInfo();
 395         relation.setCapabilityUid("capabilityId");
 396         relation.setRequirementUid(requirementId);
 397         capabilityRequirementRelationship.setRelation(relation);
 398
 399         relationships.add(capabilityRequirementRelationship);
 400         relationDef.setRelationships(relationships);
 401         resourceInstancesRelations.add(relationDef);
 402
 403         service.setComponentInstancesRelations(resourceInstancesRelations);
 404
 405         return service;
 406     }
 407
 408 }