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