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