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

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