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