gerrit.onap Code Review - sdc.git/blob

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