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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  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  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.openecomp.sdc.be.components.impl;
  21
  22 import static java.util.Collections.singletonList;
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.jupiter.api.Assertions.assertEquals;
  25 import static org.junit.jupiter.api.Assertions.assertNotNull;
  26 import static org.junit.jupiter.api.Assertions.assertThrows;
  27 import static org.junit.jupiter.api.Assertions.assertTrue;
  28 import static org.mockito.ArgumentMatchers.any;
  29 import static org.mockito.ArgumentMatchers.anyString;
  30 import static org.mockito.ArgumentMatchers.eq;
  31 import static org.mockito.Mockito.never;
  32 import static org.mockito.Mockito.times;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35
  36 import fj.data.Either;
  37 import java.util.ArrayList;
  38 import java.util.Collections;
  39 import java.util.HashMap;
  40 import java.util.LinkedList;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.Optional;
  44 import org.junit.jupiter.api.BeforeEach;
  45 import org.junit.jupiter.api.Test;
  46 import org.junit.jupiter.api.extension.ExtendWith;
  47 import org.mockito.InjectMocks;
  48 import org.mockito.Mock;
  49 import org.mockito.MockitoAnnotations;
  50 import org.mockito.junit.jupiter.MockitoExtension;
  51 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  52 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  53 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  54 import org.openecomp.sdc.be.components.validation.UserValidations;
  55 import org.openecomp.sdc.be.config.ConfigurationManager;
  56 import org.openecomp.sdc.be.dao.api.ActionStatus;
  57 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  58 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  59 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  60 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  61 import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition;
  62 import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition;
  63 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
  64 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  65 import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
  66 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  67 import org.openecomp.sdc.be.impl.ComponentsUtils;
  68 import org.openecomp.sdc.be.model.Component;
  69 import org.openecomp.sdc.be.model.ComponentInstance;
  70 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  71 import org.openecomp.sdc.be.model.PropertyDefinition;
  72 import org.openecomp.sdc.be.model.Resource;
  73 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
  74 import org.openecomp.sdc.be.model.UploadNodeFilterPropertyInfo;
  75 import org.openecomp.sdc.be.model.User;
  76 import org.openecomp.sdc.be.model.dto.FilterConstraintDto;
  77 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
  78 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  79 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  80 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  81 import org.openecomp.sdc.be.ui.mapper.FilterConstraintMapper;
  82 import org.openecomp.sdc.be.ui.model.UIConstraint;
  83 import org.openecomp.sdc.be.user.Role;
  84 import org.openecomp.sdc.exception.ResponseFormat;
  85
  86 @ExtendWith(MockitoExtension.class)
  87 class ComponentNodeFilterBusinessLogicTest extends BaseBusinessLogicMock {
  88
  89     private static final String servicePropertyName = "resourceType";
  90     private static final String constraintOperator = "equal";
  91     private static final String sourceType = "static";
  92     private static final String sourceName = sourceType;
  93     private static final String propertyValue = "resourceTypeValue";
  94     private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
  95     private static final String componentInstanceId = "dac65869-dfb4-40d2-aa20-084324659ec1.resource0";
  96     private static final String capabilityName = "MyCapabilityName";
  97
  98     @InjectMocks
  99     private ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic;
 100     @Mock
 101     private NodeFilterValidator nodeFilterValidator;
 102     @Mock
 103     private NodeFilterOperation nodeFilterOperation;
 104     @Mock
 105     private ToscaOperationFacade toscaOperationFacade;
 106     @Mock
 107     private GraphLockOperation graphLockOperation;
 108     @Mock
 109     private JanusGraphDao janusGraphDao;
 110     @Mock
 111     private JanusGraphGenericDao janusGraphGenericDao;
 112     @Mock
 113     private ComponentsUtils componentsUtils;
 114     @Mock
 115     private UserValidations userValidations;
 116
 117     private Resource resource;
 118     private ComponentInstance componentInstance;
 119     private CINodeFilterDataDefinition ciNodeFilterDataDefinition;
 120     private UIConstraint uiConstraint;
 121     private FilterConstraintDto filterConstraintDto;
 122
 123     @BeforeEach
 124     public void init() {
 125         MockitoAnnotations.openMocks(this);
 126         componentNodeFilterBusinessLogic =
 127             new ComponentNodeFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 128                 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
 129                 nodeFilterOperation, nodeFilterValidator);
 130         componentNodeFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 131         componentNodeFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
 132         componentNodeFilterBusinessLogic.setComponentsUtils(componentsUtils);
 133         componentNodeFilterBusinessLogic.setUserValidations(userValidations);
 134         componentNodeFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
 135         componentNodeFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
 136
 137         initResource();
 138     }
 139
 140     @Test
 141     void createWhenNodeFilterExistsTest() throws BusinessLogicException {
 142         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 143
 144         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 145
 146         final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
 147             .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 148
 149         assertThat(result).isPresent();
 150         assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
 151         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 152     }
 153
 154     @Test
 155     void createNodeFilterFailTest() {
 156         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 157         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 158             .thenReturn(StorageOperationStatus.OK);
 159         when(componentsUtils.convertFromStorageResponse(any())).thenReturn(ActionStatus.GENERAL_ERROR);
 160         when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
 161             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 162         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 163             .thenReturn(StorageOperationStatus.OK);
 164
 165         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 166             .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
 167
 168         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 169         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 170         verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
 171         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 172     }
 173
 174     @Test
 175     void createNodeFilterIfNotExist() throws BusinessLogicException {
 176         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 177         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 178             .thenReturn(StorageOperationStatus.OK);
 179         when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
 180             .thenReturn(Either.left(ciNodeFilterDataDefinition));
 181         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 182             .thenReturn(StorageOperationStatus.OK);
 183
 184         final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
 185             .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 186
 187         assertThat(result).isPresent();
 188         assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
 189
 190         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 191         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 192         verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
 193         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 194     }
 195
 196     @Test
 197     void deleteNodeFilterIfExistsTest() throws BusinessLogicException {
 198         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 199         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 200             .thenReturn(Either.left(true));
 201
 202         final Optional<String> result = componentNodeFilterBusinessLogic
 203             .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 204
 205         assertThat(result).isPresent();
 206         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 207         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
 208     }
 209
 210     @Test
 211     void deleteWhenNodeFilterExistsTest() throws BusinessLogicException {
 212         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 213
 214         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 215         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 216             .thenReturn(StorageOperationStatus.OK);
 217         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 218             .thenReturn(Either.left(true));
 219         when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
 220             .thenReturn(Either.left(componentInstanceId));
 221         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 222             .thenReturn(StorageOperationStatus.OK);
 223
 224         final Optional<String> result = componentNodeFilterBusinessLogic
 225             .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
 226
 227         assertThat(result).isPresent();
 228         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 229         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 230         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
 231         verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
 232         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 233     }
 234
 235     @Test
 236     void deleteNodeFilterIfExistsFailTest() {
 237         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 238
 239         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 240         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 241             .thenReturn(StorageOperationStatus.OK);
 242         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 243             .thenReturn(Either.left(true));
 244         when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
 245             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 246         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 247             .thenReturn(StorageOperationStatus.OK);
 248
 249         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 250             .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
 251
 252         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 253         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 254         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
 255         verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
 256         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 257     }
 258
 259     @Test
 260     void addNodeFilterPropertiesTest() throws BusinessLogicException {
 261         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 262
 263         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 264         when(nodeFilterValidator.validateFilter(resource, componentInstanceId, filterConstraintDto))
 265             .thenReturn(Either.left(true));
 266         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 267             .thenReturn(Either.left(true));
 268         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 269             .thenReturn(StorageOperationStatus.OK);
 270         when(nodeFilterOperation.addPropertyFilter(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 271             any(PropertyFilterDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
 272         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 273             .thenReturn(StorageOperationStatus.OK);
 274
 275         final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
 276             .addNodeFilter(componentId, componentInstanceId, filterConstraintDto, true, ComponentTypeEnum.RESOURCE,
 277                 NodeFilterConstraintType.PROPERTIES, null);
 278
 279         assertThat(result).isPresent();
 280         assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
 281         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 282         verify(nodeFilterValidator, times(1))
 283             .validateFilter(resource, componentInstanceId, filterConstraintDto);
 284         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 285         verify(nodeFilterOperation, times(1))
 286             .addPropertyFilter(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 287                 any(PropertyFilterDataDefinition.class));
 288         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 289     }
 290
 291     @Test
 292     void addNodeFilterCapabilitiesTest() throws BusinessLogicException {
 293         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 294         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 295         when(nodeFilterValidator.validateFilter(resource, componentInstanceId, filterConstraintDto))
 296             .thenReturn(Either.left(true));
 297         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 298             .thenReturn(Either.left(true));
 299         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 300             .thenReturn(StorageOperationStatus.OK);
 301         when(nodeFilterOperation.addCapabilities(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 302             any(RequirementNodeFilterCapabilityDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
 303         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 304             .thenReturn(StorageOperationStatus.OK);
 305
 306         final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
 307             .addNodeFilter(componentId, componentInstanceId, filterConstraintDto, true, ComponentTypeEnum.RESOURCE,
 308                 NodeFilterConstraintType.CAPABILITIES, capabilityName
 309             );
 310
 311         assertThat(result).isPresent();
 312         assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
 313         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 314         verify(nodeFilterValidator, times(1))
 315             .validateFilter(resource, componentInstanceId, filterConstraintDto);
 316         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 317         verify(nodeFilterOperation, times(1))
 318             .addCapabilities(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 319                 any(RequirementNodeFilterCapabilityDataDefinition.class));
 320         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 321     }
 322
 323     @Test
 324     void addNodeFilterFailTest() {
 325         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 326
 327         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 328         when(nodeFilterValidator
 329             .validateFilter(resource, componentInstanceId, filterConstraintDto)).thenReturn(Either.left(true));
 330         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 331             .thenReturn(Either.left(true));
 332         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 333             .thenReturn(StorageOperationStatus.OK);
 334         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 335             .thenReturn(StorageOperationStatus.OK);
 336         when(nodeFilterOperation
 337             .addPropertyFilter(eq(componentId), eq(componentInstanceId), eq(ciNodeFilterDataDefinition), any(PropertyFilterDataDefinition.class)))
 338             .thenReturn(Either.right(StorageOperationStatus.COMPONENT_IS_IN_USE));
 339         when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.COMPONENT_IS_IN_USE)).thenReturn(ActionStatus.COMPONENT_IN_USE);
 340         final ResponseFormat expectedResponse = new ResponseFormat();
 341         when(componentsUtils.getResponseFormatByResource(ActionStatus.COMPONENT_IN_USE, resource.getSystemName())).thenReturn(expectedResponse);
 342
 343         final BusinessLogicException businessLogicException = assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 344             .addNodeFilter(componentId, componentInstanceId, filterConstraintDto, true, ComponentTypeEnum.RESOURCE,
 345                 NodeFilterConstraintType.PROPERTIES, capabilityName));
 346
 347         assertEquals(expectedResponse, businessLogicException.getResponseFormat());
 348         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 349         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 350
 351         verify(nodeFilterValidator, times(1))
 352             .validateFilter(resource, componentInstanceId, filterConstraintDto);
 353         verify(nodeFilterOperation, times(1))
 354             .addPropertyFilter(eq(componentId), eq(componentInstanceId), eq(ciNodeFilterDataDefinition),
 355                 any(PropertyFilterDataDefinition.class));
 356         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 357         verify(janusGraphDao, times(1)).rollback();
 358         verify(janusGraphDao, never()).commit();
 359     }
 360
 361     @Test
 362     void addNodeFilterFailFetchComponentTest() {
 363         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 364
 365         when(toscaOperationFacade.getToscaElement(componentId))
 366             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 367         when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND)).thenReturn(ActionStatus.COMPONENT_NOT_FOUND);
 368         final ResponseFormat expectedResponse = new ResponseFormat();
 369         when(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND)).thenReturn(expectedResponse);
 370
 371         final BusinessLogicException businessLogicException = assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 372             .addNodeFilter(componentId, componentInstanceId, filterConstraintDto, true, ComponentTypeEnum.RESOURCE,
 373                 NodeFilterConstraintType.PROPERTIES, capabilityName));
 374         assertEquals(expectedResponse, businessLogicException.getResponseFormat());
 375     }
 376
 377     @Test
 378     void deleteNodeFilterTest() throws BusinessLogicException {
 379         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 380
 381         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 382         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 383             .thenReturn(Either.left(true));
 384         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 385             .thenReturn(StorageOperationStatus.OK);
 386
 387         when(nodeFilterOperation
 388             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
 389                 NodeFilterConstraintType.PROPERTIES))
 390             .thenReturn(Either.left(ciNodeFilterDataDefinition));
 391
 392         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 393             .thenReturn(StorageOperationStatus.OK);
 394
 395         final Optional<CINodeFilterDataDefinition> deleteNodeFilterResult = componentNodeFilterBusinessLogic
 396             .deleteNodeFilter(componentId, componentInstanceId, 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES);
 397
 398         assertThat(deleteNodeFilterResult).isPresent();
 399
 400         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 401         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 402         verify(nodeFilterValidator, times(1))
 403             .validateComponentInstanceExist(resource, componentInstanceId);
 404         verify(nodeFilterOperation, times(1))
 405             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
 406                 NodeFilterConstraintType.PROPERTIES);
 407         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 408     }
 409
 410     @Test
 411     void deleteNodeFilterFailTest() {
 412         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 413
 414         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 415         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 416             .thenReturn(Either.left(true));
 417         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 418             .thenReturn(StorageOperationStatus.OK);
 419
 420         when(nodeFilterOperation
 421             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
 422                 NodeFilterConstraintType.PROPERTIES))
 423             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 424
 425         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 426             .thenReturn(StorageOperationStatus.OK);
 427
 428         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 429             .deleteNodeFilter(componentId, componentInstanceId, 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES));
 430
 431         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 432         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 433         verify(nodeFilterValidator, times(1))
 434             .validateComponentInstanceExist(resource, componentInstanceId);
 435         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 436     }
 437
 438     @Test
 439     void deleteNodeFilterFailValidationTest() {
 440         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 441         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 442             .thenReturn(Either.left(true));
 443
 444         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 445             .deleteNodeFilter(componentId, componentInstanceId, 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES));
 446
 447         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 448         verify(nodeFilterValidator, times(1))
 449             .validateComponentInstanceExist(resource, componentInstanceId);
 450     }
 451
 452     @Test
 453     void updateNodeFilterTest() throws BusinessLogicException {
 454         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 455
 456         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 457         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 458             .thenReturn(Either.left(true));
 459         when(nodeFilterValidator
 460             .validateFilter(any(Component.class), anyString(), any(FilterConstraintDto.class))
 461         ).thenReturn(Either.left(true));
 462
 463         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 464             .thenReturn(StorageOperationStatus.OK);
 465
 466         when(nodeFilterOperation.deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition,
 467             0, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(ciNodeFilterDataDefinition));
 468
 469         when(nodeFilterOperation.addPropertyFilter(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 470             any(PropertyFilterDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
 471
 472         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 473             .thenReturn(StorageOperationStatus.OK);
 474
 475         final Optional<CINodeFilterDataDefinition> updateNodeFilterResult = componentNodeFilterBusinessLogic
 476             .updateNodeFilter(componentId, componentInstanceId, uiConstraint, ComponentTypeEnum.RESOURCE,
 477                 NodeFilterConstraintType.PROPERTIES, 0);
 478
 479         assertThat(updateNodeFilterResult).isPresent();
 480         assertThat(updateNodeFilterResult.get().getProperties().getListToscaDataDefinition()).hasSize(1);
 481     }
 482
 483     @Test
 484     void updateNodeFilterFailTest() {
 485         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 486
 487         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 488         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 489             .thenReturn(Either.left(true));
 490         when(nodeFilterValidator
 491             .validateFilter(any(Component.class), anyString(), any(FilterConstraintDto.class))
 492         ).thenReturn(Either.left(true));
 493
 494
 495         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 496             .thenReturn(StorageOperationStatus.OK);
 497
 498         when(nodeFilterOperation.deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition,
 499             0, NodeFilterConstraintType.PROPERTIES)).thenReturn(Either.left(ciNodeFilterDataDefinition));
 500
 501         when(nodeFilterOperation.addPropertyFilter(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 502             any(PropertyFilterDataDefinition.class))).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 503
 504         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 505             .thenReturn(StorageOperationStatus.OK);
 506
 507         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 508                 .updateNodeFilter(componentId, componentInstanceId, uiConstraint, ComponentTypeEnum.RESOURCE,
 509                 NodeFilterConstraintType.PROPERTIES, 0));
 510     }
 511
 512     @Test
 513     void updateNodeFilterFailValidationTest() {
 514         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 515         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 516             .thenReturn(Either.left(true));
 517
 518         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 519             .updateNodeFilter(componentId, componentInstanceId, uiConstraint, ComponentTypeEnum.RESOURCE,
 520                 NodeFilterConstraintType.PROPERTIES, 0));
 521
 522         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 523     }
 524
 525     @Test
 526     void testAssociateNodeFilterToComponentInstance() {
 527         CINodeFilterDataDefinition ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
 528
 529         UploadNodeFilterInfo filter = new UploadNodeFilterInfo();
 530         UploadNodeFilterPropertyInfo propertyDataDefinition = new UploadNodeFilterPropertyInfo();
 531         propertyDataDefinition.setName("order");
 532         propertyDataDefinition.setValues(Collections.singletonList("order: {equal: 2}"));
 533         filter.setProperties(Collections.singletonList(propertyDataDefinition));
 534
 535         Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
 536         nodeFilterMap.put(componentInstanceId, filter);
 537
 538         when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId)).thenReturn(Either.left(ciNodeFilterDataDefinition));
 539         when(nodeFilterOperation.addPropertyFilter(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 540             any(PropertyFilterDataDefinition.class))).thenReturn(Either.left(ciNodeFilterDataDefinition));
 541
 542         StorageOperationStatus status = componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(componentId, nodeFilterMap);
 543         assertEquals(StorageOperationStatus.OK, status);
 544     }
 545
 546     @Test
 547     void testAssociateNodeFilterToComponentInstanceFail() {
 548         CINodeFilterDataDefinition ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
 549
 550         UploadNodeFilterInfo filter = new UploadNodeFilterInfo();
 551         UploadNodeFilterPropertyInfo propertyDataDefinition = new UploadNodeFilterPropertyInfo();
 552         propertyDataDefinition.setName("order");
 553         propertyDataDefinition.setValues(Collections.singletonList("order: {equal: 2}"));
 554         filter.setProperties(Collections.singletonList(propertyDataDefinition));
 555
 556         Map<String, UploadNodeFilterInfo> nodeFilterMap = new HashMap<>();
 557         nodeFilterMap.put(componentInstanceId, filter);
 558
 559         when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId)).thenReturn(Either.left(ciNodeFilterDataDefinition));
 560         when(nodeFilterOperation.addPropertyFilter(anyString(), anyString(), any(CINodeFilterDataDefinition.class),
 561             any(PropertyFilterDataDefinition.class))).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 562
 563         assertThrows(ComponentException.class, () -> componentNodeFilterBusinessLogic.associateNodeFilterToComponentInstance(componentId,
 564             nodeFilterMap));
 565     }
 566
 567     @Test
 568     void validateUserTes() {
 569         final String USER_ID = "jh0003";
 570         final User user = new User();
 571         user.setUserId(USER_ID);
 572         user.setRole(Role.ADMIN.name());
 573         when(userValidations.validateUserExists(USER_ID)).thenReturn(user).thenReturn(user);
 574         final User result = componentNodeFilterBusinessLogic.validateUser(USER_ID);
 575         assertNotNull(result);
 576         assertTrue(USER_ID.equalsIgnoreCase(result.getUserId()));
 577         assertTrue(Role.ADMIN.name().equalsIgnoreCase(result.getRole()));
 578     }
 579
 580     private void initResource() {
 581         resource = new Resource();
 582         resource.setName("MyResource");
 583         resource.setUniqueId(componentId);
 584         resource.setToscaResourceName("My_Resource_Tosca_Name");
 585         resource.addCategory("Network Layer 2-3", "Router");
 586         resource.setDescription("My short description");
 587
 588         componentInstance = new ComponentInstance();
 589         componentInstance.setUniqueId(componentInstanceId);
 590         componentInstance.setName("myComponentInstance");
 591         componentInstance.setDirectives(ConfigurationManager.getConfigurationManager().getConfiguration()
 592             .getDirectives());
 593
 594         uiConstraint = new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
 595         final FilterConstraintMapper filterConstraintMapper = new FilterConstraintMapper();
 596         filterConstraintDto = filterConstraintMapper.mapFrom(uiConstraint);
 597
 598         PropertyFilterDataDefinition propertyFilterDataDefinition = new PropertyFilterDataDefinition();
 599         propertyFilterDataDefinition.setName(uiConstraint.getServicePropertyName());
 600         final PropertyFilterConstraintDataDefinition propertyFilterConstraint =
 601             filterConstraintMapper.mapTo(filterConstraintDto);
 602         propertyFilterDataDefinition.setConstraints(new LinkedList<>(List.of(propertyFilterConstraint)));
 603
 604         final ListDataDefinition<PropertyFilterDataDefinition> listDataDefinition =
 605             new ListDataDefinition<>(new LinkedList<>(singletonList(propertyFilterDataDefinition)));
 606
 607         ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
 608         ciNodeFilterDataDefinition.setProperties(listDataDefinition);
 609         ciNodeFilterDataDefinition.setID("NODE_FILTER_UID");
 610
 611         resource.setComponentInstances(singletonList(componentInstance));
 612
 613         final PropertyDefinition property = new PropertyDefinition();
 614         property.setName(uiConstraint.getServicePropertyName());
 615
 616         final List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 617         final ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 618         origProperty.setName(uiConstraint.getServicePropertyName());
 619         origProperty.setValue(propertyValue);
 620         origProperty.setType(uiConstraint.getSourceType());
 621         origProperties.add(origProperty);
 622
 623         final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 624         componentInstanceProps.put(componentInstanceId, origProperties);
 625
 626         resource.setComponentInstancesProperties(componentInstanceProps);
 627         resource.setProperties(new LinkedList<>(List.of(property)));
 628     }
 629
 630 }