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