catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentSubstitutionFilterBusinessLogicTest.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.assertThrows;
  25 import static org.junit.jupiter.api.Assertions.fail;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.ArgumentMatchers.anyInt;
  28 import static org.mockito.ArgumentMatchers.anyList;
  29 import static org.mockito.ArgumentMatchers.anyString;
  30 import static org.mockito.Mockito.times;
  31 import static org.mockito.Mockito.verify;
  32 import static org.mockito.Mockito.when;
  33
  34 import fj.data.Either;
  35 import java.util.ArrayList;
  36 import java.util.Arrays;
  37 import java.util.Collections;
  38 import java.util.HashMap;
  39 import java.util.LinkedList;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.Optional;
  43 import org.junit.jupiter.api.BeforeEach;
  44 import org.junit.jupiter.api.Test;
  45 import org.junit.jupiter.api.extension.ExtendWith;
  46 import org.mockito.InjectMocks;
  47 import org.mockito.Mock;
  48 import org.mockito.MockitoAnnotations;
  49 import org.mockito.junit.jupiter.MockitoExtension;
  50 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  51 import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
  52 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
  53 import org.openecomp.sdc.be.components.validation.UserValidations;
  54 import org.openecomp.sdc.be.config.ConfigurationManager;
  55 import org.openecomp.sdc.be.dao.api.ActionStatus;
  56 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  57 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  58 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
  59 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  60 import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
  61 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
  62 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  63 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  64 import org.openecomp.sdc.be.impl.ComponentsUtils;
  65 import org.openecomp.sdc.be.model.ComponentInstance;
  66 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  67 import org.openecomp.sdc.be.model.PropertyDefinition;
  68 import org.openecomp.sdc.be.model.Service;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.SubstitutionFilterOperation;
  70 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  71 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  72 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  73 import org.openecomp.sdc.be.ui.model.UIConstraint;
  74 import org.openecomp.sdc.exception.ResponseFormat;
  75
  76 @ExtendWith(MockitoExtension.class)
  77 public class ComponentSubstitutionFilterBusinessLogicTest extends BaseBusinessLogicMock {
  78
  79     private static final String servicePropertyName = "controller_actor";
  80     private static final String constraintOperator = "equal";
  81     private static final String sourceType = "static";
  82     private static final String sourceName = sourceType;
  83     private static final String propertyValue = "constraintValue";
  84     private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
  85     private static final String componentInstanceId = "dac65869-dfb4-40d2-aa20-084324659ec1.service0";
  86
  87     @InjectMocks
  88     private ComponentSubstitutionFilterBusinessLogic componentSubstitutionFilterBusinessLogic;
  89     @Mock
  90     private NodeFilterValidator nodeFilterValidator;
  91     @Mock
  92     private SubstitutionFilterOperation substitutionFilterOperation;
  93     @Mock
  94     private ToscaOperationFacade toscaOperationFacade;
  95     @Mock
  96     private GraphLockOperation graphLockOperation;
  97     @Mock
  98     private JanusGraphDao janusGraphDao;
  99     @Mock
 100     private JanusGraphGenericDao janusGraphGenericDao;
 101     @Mock
 102     private ComponentsUtils componentsUtils;
 103     @Mock
 104     private UserValidations userValidations;
 105     @Mock
 106     private ResponseFormat responseFormat;
 107
 108     private Service service;
 109     private ComponentInstance componentInstance;
 110     private SubstitutionFilterDataDefinition substitutionFilterDataDefinition;
 111     private RequirementSubstitutionFilterPropertyDataDefinition requirementSubstitutionFilterPropertyDataDefinition;
 112     private String constraint;
 113
 114     @BeforeEach
 115     public void init() {
 116         MockitoAnnotations.initMocks(this);
 117         componentSubstitutionFilterBusinessLogic =
 118             new ComponentSubstitutionFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 119                 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
 120                 substitutionFilterOperation, nodeFilterValidator);
 121         componentSubstitutionFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 122         componentSubstitutionFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
 123         componentSubstitutionFilterBusinessLogic.setComponentsUtils(componentsUtils);
 124         componentSubstitutionFilterBusinessLogic.setUserValidations(userValidations);
 125         componentSubstitutionFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
 126         componentSubstitutionFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
 127
 128         initResource();
 129     }
 130
 131     @Test
 132     public void doNotCreateSubstitutionFilterAsExistsTest() throws BusinessLogicException {
 133         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 134
 135         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 136
 137         final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
 138             .createSubstitutionFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.SERVICE);
 139         assertThat(result).isPresent();
 140         assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
 141         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 142     }
 143
 144     @Test
 145     public void createSubstitutionFilterIfNotExistTest() throws BusinessLogicException {
 146         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 147         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 148             .thenReturn(StorageOperationStatus.OK);
 149         when(substitutionFilterOperation.createSubstitutionFilter(componentId, componentInstanceId))
 150             .thenReturn(Either.left(substitutionFilterDataDefinition));
 151         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 152             .thenReturn(StorageOperationStatus.OK);
 153
 154         final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
 155             .createSubstitutionFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.SERVICE);
 156         assertThat(result).isPresent();
 157         assertThat(result.get().getProperties()).isEqualTo(substitutionFilterDataDefinition.getProperties());
 158         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 159         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
 160         verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId, componentInstanceId);
 161         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
 162     }
 163
 164     @Test
 165     public void createSubstitutionFilterIfNotExistFailTest() {
 166         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 167         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 168             .thenReturn(StorageOperationStatus.OK);
 169         when(substitutionFilterOperation.createSubstitutionFilter(componentId, componentInstanceId))
 170             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 171         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 172             .thenReturn(StorageOperationStatus.OK);
 173
 174         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 175             .createSubstitutionFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.SERVICE));
 176
 177         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 178         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
 179         verify(substitutionFilterOperation, times(1)).createSubstitutionFilter(componentId, componentInstanceId);
 180         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
 181     }
 182
 183     @Test
 184     public void addSubstitutionFilterTest() throws BusinessLogicException {
 185         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 186
 187         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 188         when(nodeFilterValidator.validateFilter(service, componentInstanceId, Collections.singletonList(constraint),
 189             NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
 190         when(nodeFilterValidator.validateComponentInstanceExist(service, componentInstanceId))
 191             .thenReturn(Either.left(true));
 192         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 193             .thenReturn(StorageOperationStatus.OK);
 194
 195         when(substitutionFilterOperation
 196             .addNewProperty(anyString(), anyString(), any(SubstitutionFilterDataDefinition.class),
 197                 any(RequirementSubstitutionFilterPropertyDataDefinition.class)))
 198             .thenReturn(Either.left(substitutionFilterDataDefinition));
 199
 200         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 201             .thenReturn(StorageOperationStatus.OK);
 202
 203         final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
 204             .addSubstitutionFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
 205                 servicePropertyName, constraint, true, ComponentTypeEnum.SERVICE);
 206
 207         assertThat(result).isPresent();
 208         assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(1);
 209         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 210         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
 211         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 212             Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
 213         verify(substitutionFilterOperation, times(0))
 214             .addNewProperty(componentId, componentInstanceId, substitutionFilterDataDefinition,
 215                 requirementSubstitutionFilterPropertyDataDefinition);
 216         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
 217
 218     }
 219
 220     @Test
 221     public void addSubstitutionFilterFailTest() {
 222         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 223
 224         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 225         when(nodeFilterValidator.validateFilter(service, componentInstanceId, Collections.singletonList(constraint),
 226             NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
 227         when(nodeFilterValidator.validateComponentInstanceExist(service, componentInstanceId))
 228             .thenReturn(Either.left(true));
 229         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 230             .thenReturn(StorageOperationStatus.OK);
 231
 232         when(substitutionFilterOperation
 233             .addNewProperty(anyString(), anyString(), any(SubstitutionFilterDataDefinition.class),
 234                 any(RequirementSubstitutionFilterPropertyDataDefinition.class)))
 235             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 236
 237         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 238             .thenReturn(StorageOperationStatus.OK);
 239
 240         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 241             .addSubstitutionFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
 242                 servicePropertyName, constraint, true, ComponentTypeEnum.SERVICE));
 243
 244         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 245         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
 246         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 247             Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
 248         verify(substitutionFilterOperation, times(0))
 249             .addNewProperty(componentId, componentInstanceId, substitutionFilterDataDefinition,
 250                 requirementSubstitutionFilterPropertyDataDefinition);
 251         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
 252     }
 253
 254     @Test
 255     public void updateSubstitutionFilterTest() throws BusinessLogicException {
 256         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 257
 258         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 259         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 260             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 261         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 262             .thenReturn(StorageOperationStatus.OK);
 263
 264         when(substitutionFilterOperation.updateSubstitutionFilter(anyString(), anyString(),
 265             any(SubstitutionFilterDataDefinition.class), anyList()))
 266             .thenReturn(Either.left(substitutionFilterDataDefinition));
 267
 268         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 269             .thenReturn(StorageOperationStatus.OK);
 270
 271         final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
 272             .updateSubstitutionFilter(componentId, componentInstanceId, Collections.singletonList(constraint),
 273                 true, ComponentTypeEnum.SERVICE);
 274
 275         assertThat(result).isPresent();
 276
 277         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 278         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 279             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
 280     }
 281
 282     @Test
 283     public void updateSubstitutionFilterFailTest() {
 284         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 285
 286         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 287         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 288             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 289         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 290             .thenReturn(StorageOperationStatus.OK);
 291
 292         when(substitutionFilterOperation.updateSubstitutionFilter(anyString(), anyString(),
 293             any(SubstitutionFilterDataDefinition.class), anyList()))
 294             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 295
 296         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 297             .thenReturn(StorageOperationStatus.OK);
 298
 299         final List<String> constraints = requirementSubstitutionFilterPropertyDataDefinition.getConstraints();
 300         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 301             .updateSubstitutionFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.SERVICE));
 302
 303         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 304         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 305             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
 306     }
 307
 308     @Test
 309     public void updateSubstitutionFilterFailWithFilterNotFoundTest() {
 310         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 311         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 312             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
 313
 314         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 315             .updateSubstitutionFilter(componentId, componentInstanceId,
 316                 requirementSubstitutionFilterPropertyDataDefinition.getConstraints(), true,
 317                 ComponentTypeEnum.SERVICE));
 318
 319         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 320         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 321             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
 322     }
 323
 324     @Test
 325     public void updateSubstitutionFilterFailValidationTest() {
 326         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 327
 328         final UIConstraint uiConstraint =
 329             new UIConstraint("invalidProperty", constraintOperator, sourceType, sourceName, propertyValue);
 330         constraint = new ConstraintConvertor().convert(uiConstraint);
 331         requirementSubstitutionFilterPropertyDataDefinition.setConstraints(Collections.singletonList(constraint));
 332
 333         when(responseFormat.getFormattedMessage()).thenReturn(ActionStatus.SELECTED_PROPERTY_NOT_PRESENT.name());
 334
 335         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 336             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE))
 337             .thenReturn(Either.right(responseFormat));
 338
 339         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 340             .updateSubstitutionFilter(componentId, componentInstanceId,
 341                 requirementSubstitutionFilterPropertyDataDefinition.getConstraints(), true,
 342                 ComponentTypeEnum.SERVICE));
 343
 344         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 345         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 346             Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE);
 347     }
 348
 349     @Test
 350     public void deleteSubstitutionFilterTest() throws BusinessLogicException {
 351         substitutionFilterDataDefinition.setProperties(new ListDataDefinition<>());
 352         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 353
 354         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 355         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 356             Collections.singletonList(constraint), NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 357
 358         when(nodeFilterValidator.validateComponentInstanceExist(service, componentInstanceId))
 359             .thenReturn(Either.left(true));
 360         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 361             .thenReturn(StorageOperationStatus.OK);
 362         when(substitutionFilterOperation.deleteConstraint(anyString(), anyString(),
 363             any(SubstitutionFilterDataDefinition.class), anyInt()))
 364             .thenReturn(Either.left(substitutionFilterDataDefinition));
 365         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 366             .thenReturn(StorageOperationStatus.OK);
 367
 368         final Optional<SubstitutionFilterDataDefinition> result = componentSubstitutionFilterBusinessLogic
 369             .deleteSubstitutionFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 370                 0, true, ComponentTypeEnum.SERVICE);
 371
 372         assertThat(result).isPresent();
 373         assertThat(result.get().getProperties().getListToscaDataDefinition()).hasSize(0);
 374         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 375         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 376             Collections.singletonList(constraint), NodeFilterConstraintAction.DELETE);
 377         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(service, componentInstanceId);
 378         verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Service);
 379         verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId, componentInstanceId,
 380             substitutionFilterDataDefinition, 0);
 381         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
 382     }
 383
 384     @Test
 385     public void deleteSubstitutionFilterFailTest() {
 386         componentInstance.setSubstitutionFilter(substitutionFilterDataDefinition);
 387
 388         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 389         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 390             Collections.singletonList(constraint), NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 391
 392         when(nodeFilterValidator.validateComponentInstanceExist(service, componentInstanceId))
 393             .thenReturn(Either.left(true));
 394         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 395             .thenReturn(StorageOperationStatus.OK);
 396         when(substitutionFilterOperation.deleteConstraint(anyString(), anyString(),
 397             any(SubstitutionFilterDataDefinition.class), anyInt()))
 398             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 399         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 400             .thenReturn(StorageOperationStatus.OK);
 401
 402         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 403             .deleteSubstitutionFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 404                 0, true, ComponentTypeEnum.SERVICE));
 405
 406         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 407         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 408             Collections.singletonList(constraint), NodeFilterConstraintAction.DELETE);
 409         verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(service, componentInstanceId);
 410         verify(substitutionFilterOperation, times(1)).deleteConstraint(componentId, componentInstanceId,
 411             substitutionFilterDataDefinition, 0);
 412         verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Service);
 413     }
 414
 415     @Test
 416     public void deleteSubstitutionFilterFailValidationTest() {
 417         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(service));
 418         when(nodeFilterValidator.validateFilter(service, componentInstanceId,
 419             Collections.singletonList(constraint), NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
 420
 421         when(nodeFilterValidator.validateComponentInstanceExist(service, componentInstanceId))
 422             .thenReturn(Either.left(true));
 423
 424         assertThrows(BusinessLogicException.class, () -> componentSubstitutionFilterBusinessLogic
 425             .deleteSubstitutionFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
 426                 0, true, ComponentTypeEnum.SERVICE));
 427
 428         verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
 429         verify(nodeFilterValidator, times(1)).validateFilter(service, componentInstanceId,
 430             Collections.singletonList(constraint), NodeFilterConstraintAction.DELETE);
 431     }
 432
 433     public void initResource() {
 434         try {
 435             service = new Service();
 436             service.setName("MyTestService");
 437             service.setUniqueId(componentId);
 438
 439             componentInstance = new ComponentInstance();
 440             componentInstance.setUniqueId(componentInstanceId);
 441             componentInstance.setName("myComponentInstance");
 442             componentInstance.setDirectives(ConfigurationManager.getConfigurationManager().getConfiguration()
 443                 .getDirectives());
 444
 445             final UIConstraint uiConstraint =
 446                 new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
 447             constraint = new ConstraintConvertor().convert(uiConstraint);
 448
 449             requirementSubstitutionFilterPropertyDataDefinition = new RequirementSubstitutionFilterPropertyDataDefinition();
 450             requirementSubstitutionFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
 451             requirementSubstitutionFilterPropertyDataDefinition
 452                 .setConstraints(Collections.singletonList(constraint));
 453
 454             final ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> listDataDefinition =
 455                 new ListDataDefinition<>(
 456                     Collections.singletonList(requirementSubstitutionFilterPropertyDataDefinition));
 457
 458             substitutionFilterDataDefinition = new SubstitutionFilterDataDefinition();
 459             substitutionFilterDataDefinition.setProperties(listDataDefinition);
 460             substitutionFilterDataDefinition.setID("SUBSTITUTION_FILTER_UID");
 461
 462             service.setComponentInstances(singletonList(componentInstance));
 463
 464             final PropertyDefinition property = new PropertyDefinition();
 465             property.setName(uiConstraint.getServicePropertyName());
 466
 467             final List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 468             final ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 469             origProperty.setName(uiConstraint.getServicePropertyName());
 470             origProperty.setValue(propertyValue);
 471             origProperty.setType(uiConstraint.getSourceType());
 472             origProperties.add(origProperty);
 473
 474             final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 475             componentInstanceProps.put(componentInstanceId, origProperties);
 476
 477             service.setComponentInstancesProperties(componentInstanceProps);
 478             service.setProperties(new LinkedList<>(Arrays.asList(property)));
 479         } catch (final Exception e) {
 480             fail(e.getMessage());
 481         }
 482     }
 483 }