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             .thenReturn(Either.left(ciNodeFilterDataDefinition));
 381
 382         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 383             .thenReturn(StorageOperationStatus.OK);
 384
 385         final Optional<CINodeFilterDataDefinition> deleteNodeFilterResult = componentNodeFilterBusinessLogic
 386             .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 387                 0, true, ComponentTypeEnum.RESOURCE);
 388
 389         assertThat(deleteNodeFilterResult).isPresent();
 390
 391         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 392         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 393         verify(nodeFilterValidator, times(1))
 394             .validateComponentInstanceExist(resource, componentInstanceId);
 395         verify(nodeFilterValidator, times(1))
 396             .validateFilter(resource, componentInstanceId, singletonList(constraint),
 397                 NodeFilterConstraintAction.DELETE);
 398         verify(nodeFilterOperation, times(1))
 399             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0);
 400         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 401     }
 402
 403     @Test
 404     public void deleteNodeFilterFailTest() {
 405         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 406
 407         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 408         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 409             .thenReturn(Either.left(true));
 410         when(nodeFilterValidator.validateFilter(resource, componentInstanceId, singletonList(constraint),
 411             NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 412         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 413             .thenReturn(StorageOperationStatus.OK);
 414
 415         when(nodeFilterOperation
 416             .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
 417             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 418
 419         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 420             .thenReturn(StorageOperationStatus.OK);
 421
 422         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 423             .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 424                 0, true, ComponentTypeEnum.RESOURCE));
 425
 426         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 427         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
 428         verify(nodeFilterValidator, times(1))
 429             .validateFilter(resource, componentInstanceId, singletonList(constraint),
 430                 NodeFilterConstraintAction.DELETE);
 431         verify(nodeFilterValidator, times(1))
 432             .validateComponentInstanceExist(resource, componentInstanceId);
 433         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
 434     }
 435
 436     @Test
 437     public void deleteNodeFilterFailValidationTest() {
 438         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 439         when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
 440             .thenReturn(Either.left(true));
 441         when(nodeFilterValidator.validateFilter(resource, componentInstanceId, singletonList(constraint),
 442             NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 443
 444         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 445             .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 446                 0, true, ComponentTypeEnum.RESOURCE));
 447
 448         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 449         verify(nodeFilterValidator, times(1))
 450             .validateFilter(resource, componentInstanceId, singletonList(constraint),
 451                 NodeFilterConstraintAction.DELETE);
 452         verify(nodeFilterValidator, times(1))
 453             .validateComponentInstanceExist(resource, componentInstanceId);
 454     }
 455
 456     @Test
 457     public void updateNodeFilterFailTest() {
 458         componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
 459
 460         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 461         when(nodeFilterValidator.validateFilter(resource, componentInstanceId,
 462             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 463         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
 464             .thenReturn(StorageOperationStatus.OK);
 465         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
 466             .thenReturn(StorageOperationStatus.OK);
 467
 468         final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
 469         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 470             .updateNodeFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.RESOURCE));
 471
 472         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 473         verify(nodeFilterValidator, times(1)).validateFilter(resource, componentInstanceId,
 474             constraints, NodeFilterConstraintAction.UPDATE);
 475     }
 476
 477     @Test
 478     public void updateNodeFilterFailValidationTest() {
 479         final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
 480         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
 481         when(nodeFilterValidator.validateFilter(resource, componentInstanceId,
 482             constraints, NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 483
 484         assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
 485             .updateNodeFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.RESOURCE));
 486
 487         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 488         verify(nodeFilterValidator, times(1)).validateFilter(resource, componentInstanceId,
 489             constraints, NodeFilterConstraintAction.UPDATE);
 490     }
 491
 492     @Test
 493     public void validateUserTes() {
 494         final String USER_ID = "jh0003";
 495         final User user = new User();
 496         user.setUserId(USER_ID);
 497         user.setRole(Role.ADMIN.name());
 498         when(userValidations.validateUserExists(USER_ID)).thenReturn(user).thenReturn(user);
 499         final User result = componentNodeFilterBusinessLogic.validateUser(USER_ID);
 500         assertNotNull(result);
 501         assertTrue(USER_ID.equalsIgnoreCase(result.getUserId()));
 502         assertTrue(Role.ADMIN.name().equalsIgnoreCase(result.getRole()));
 503     }
 504
 505     public void initResource() {
 506         try {
 507             resource = new Resource();
 508             resource.setName("MyResource");
 509             resource.setUniqueId(componentId);
 510             resource.setToscaResourceName("My_Resource_Tosca_Name");
 511             resource.addCategory("Network Layer 2-3", "Router");
 512             resource.setDescription("My short description");
 513
 514             componentInstance = new ComponentInstance();
 515             componentInstance.setUniqueId(componentInstanceId);
 516             componentInstance.setName("myComponentInstance");
 517             componentInstance.setDirectives(new LinkedList<>(Arrays.asList(DirectivesEnum.SELECT.getValue())));
 518
 519             final UIConstraint uiConstraint =
 520                 new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
 521             constraint = new ConstraintConvertor().convert(uiConstraint);
 522
 523             requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
 524             requirementNodeFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
 525             requirementNodeFilterPropertyDataDefinition.setConstraints(new LinkedList<>(Arrays.asList(constraint)));
 526
 527             final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> listDataDefinition =
 528                 new ListDataDefinition<>(new LinkedList<>(Arrays.asList(requirementNodeFilterPropertyDataDefinition)));
 529
 530             ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
 531             ciNodeFilterDataDefinition.setProperties(listDataDefinition);
 532             ciNodeFilterDataDefinition.setID("NODE_FILTER_UID");
 533
 534             resource.setComponentInstances(singletonList(componentInstance));
 535
 536             final PropertyDefinition property = new PropertyDefinition();
 537             property.setName(uiConstraint.getServicePropertyName());
 538
 539             final List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 540             final ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 541             origProperty.setName(uiConstraint.getServicePropertyName());
 542             origProperty.setValue(propertyValue);
 543             origProperty.setType(uiConstraint.getSourceType());
 544             origProperties.add(origProperty);
 545
 546             final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 547             componentInstanceProps.put(componentInstanceId, origProperties);
 548
 549             resource.setComponentInstancesProperties(componentInstanceProps);
 550             resource.setProperties(new LinkedList<>(Arrays.asList(property)));
 551         } catch (final Exception e) {
 552             fail(e.getMessage());
 553         }
 554     }
 555 }