Add Node Filter Business Logic Unit Tests

Issue-ID: SDC-3125
Signed-off-by: aribeiro <anderson.ribeiro@est.tech>
Change-Id: I80c755f4fffa813396ceb85c6aa7fde5b32590cd

4 files changed, 509 insertions, 28 deletions

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogic.java
index 0356b63793..48cb80d11d 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogic.java
@@ -276,11 +276,6 @@ public class ComponentNodeFilterBusinessLogic extends BaseBusinessLogic {
             throw new BusinessLogicException(componentsUtils
                 .getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
         }
-        boolean wasLocked = false;
-        if (shouldLock) {
-            lockComponent(component.getUniqueId(), component,"Update Node Filter on Component");
-            wasLocked = true;
-        }
         final Optional<ComponentInstance> componentInstance = getComponentInstance(componentInstanceId,
             component);
         if (!componentInstance.isPresent()) {
@@ -289,10 +284,14 @@ public class ComponentNodeFilterBusinessLogic extends BaseBusinessLogic {
         }
         CINodeFilterDataDefinition nodeFilterDataDefinition = componentInstance.get().getNodeFilter();
         if (nodeFilterDataDefinition == null) {
-            throw new BusinessLogicException(componentsUtils
-                .getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
+            throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND));
         }
+        boolean wasLocked = false;
         try {
+            if (shouldLock) {
+                lockComponent(component.getUniqueId(), component,"Update Node Filter on Component");
+                wasLocked = true;
+            }
             final List<RequirementNodeFilterPropertyDataDefinition> properties = constraints.stream()
                 .map(this::getRequirementNodeFilterPropertyDataDefinition).collect(Collectors.toList());
             final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = nodeFilterOperation
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/NodeFilterValidator.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/NodeFilterValidator.java
index 27daaf2aae..30632e9012 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/NodeFilterValidator.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/NodeFilterValidator.java
@@ -59,28 +59,28 @@ public class NodeFilterValidator {
     public static final Set<String> comparableConstraintsOperators =
             ImmutableSet.of(ConstraintConvertor.GREATER_THAN_OPERATOR, ConstraintConvertor.LESS_THAN_OPERATOR);
 
-    @Autowired
-    protected ToscaOperationFacade toscaOperationFacade;
-
-    @Autowired
-    protected ComponentsUtils componentsUtils;
+    protected final ToscaOperationFacade toscaOperationFacade;
+    protected final ComponentsUtils componentsUtils;
 
     private static final Logger LOGGER = LoggerFactory.getLogger(NodeFilterValidator.class);
 
-    public Either<Boolean, ResponseFormat> validateComponentInstanceExist(
-        final Component component,
-        final String componentInstanceId) {
+    @Autowired
+    public NodeFilterValidator(final ToscaOperationFacade toscaOperationFacade,
+                               final ComponentsUtils componentsUtils) {
+        this.toscaOperationFacade = toscaOperationFacade;
+        this.componentsUtils = componentsUtils;
+    }
+
+    public Either<Boolean, ResponseFormat> validateComponentInstanceExist(final Component component,
+                                                                          final String componentInstanceId) {
         if (component == null || StringUtils.isEmpty(componentInstanceId)) {
-            LOGGER.debug("Input data cannot be empty");
-            return getErrorResponse(ActionStatus.NODE_FILTER_NOT_FOUND);
-        }
-        if (CollectionUtils.isEmpty(component.getComponentInstances())) {
-            LOGGER.debug("Component Instance list is empty");
+            LOGGER.error("Input data cannot be empty");
             return getErrorResponse(ActionStatus.NODE_FILTER_NOT_FOUND);
         }
-        if (component.getComponentInstances().stream()
-            .noneMatch(ci -> ci.getUniqueId().equals(componentInstanceId))) {
-            LOGGER.debug("Component Instance list is empty");
+        if (CollectionUtils.isEmpty(component.getComponentInstances()) ||
+            component.getComponentInstances().stream()
+                .noneMatch(ci -> ci.getUniqueId().equals(componentInstanceId))) {
+            LOGGER.error("Component Instance list is empty");
             return getErrorResponse(ActionStatus.NODE_FILTER_NOT_FOUND);
         }
         return Either.left(Boolean.TRUE);
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogicTest.java
new file mode 100644
index 0000000000..d75a731b04
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentNodeFilterBusinessLogicTest.java
@@ -0,0 +1,480 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2020 Nordix Foundation
+ *  ================================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.components.impl;
+
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
+import org.openecomp.sdc.be.components.impl.utils.DirectivesEnum;
+import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
+import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
+import org.openecomp.sdc.be.components.validation.UserValidations;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
+import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
+import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
+import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
+import org.openecomp.sdc.be.ui.model.UIConstraint;
+import org.openecomp.sdc.be.user.Role;
+
+@ExtendWith(MockitoExtension.class)
+public class ComponentNodeFilterBusinessLogicTest extends BaseBusinessLogicMock {
+
+    private static final String servicePropertyName = "resourceType";
+    private static final String constraintOperator = "equal";
+    private static final String sourceType = "static";
+    private static final String sourceName = sourceType;
+    private static final String propertyValue = "resourceTypeValue";
+    private static final String componentId = "dac65869-dfb4-40d2-aa20-084324659ec1";
+    private static final String componentInstanceId = "dac65869-dfb4-40d2-aa20-084324659ec1.resource0";
+
+    @InjectMocks
+    private ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic;
+    @Mock
+    private NodeFilterValidator nodeFilterValidator;
+    @Mock
+    private NodeFilterOperation nodeFilterOperation;
+    @Mock
+    private ToscaOperationFacade toscaOperationFacade;
+    @Mock
+    private GraphLockOperation graphLockOperation;
+    @Mock
+    private JanusGraphDao janusGraphDao;
+    @Mock
+    private JanusGraphGenericDao janusGraphGenericDao;
+    @Mock
+    private ComponentsUtils componentsUtils;
+    @Mock
+    private UserValidations userValidations;
+
+    private Resource resource;
+    private ComponentInstance componentInstance;
+    private CINodeFilterDataDefinition ciNodeFilterDataDefinition;
+    private RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition;
+    private String constraint;
+
+    @BeforeEach
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+        componentNodeFilterBusinessLogic =
+            new ComponentNodeFilterBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
+                groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
+                nodeFilterOperation, nodeFilterValidator);
+        componentNodeFilterBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
+        componentNodeFilterBusinessLogic.setGraphLockOperation(graphLockOperation);
+        componentNodeFilterBusinessLogic.setComponentsUtils(componentsUtils);
+        componentNodeFilterBusinessLogic.setUserValidations(userValidations);
+        componentNodeFilterBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
+        componentNodeFilterBusinessLogic.setJanusGraphDao(janusGraphDao);
+
+        initResource();
+    }
+
+    @Test
+    public void createWhenNodeFilterExistsTest() throws BusinessLogicException {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+
+        final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
+            .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
+
+        assertThat(result).isPresent();
+        assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+    }
+
+    @Test
+    public void createNodeFilterFailTest() {
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+        when(componentsUtils.convertFromStorageResponse(Mockito.any())).thenReturn(ActionStatus.GENERAL_ERROR);
+        when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
+            .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void createNodeFilterIfNotExist() throws BusinessLogicException {
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+        when(nodeFilterOperation.createNodeFilter(componentId, componentInstanceId))
+            .thenReturn(Either.left(ciNodeFilterDataDefinition));
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        final Optional<CINodeFilterDataDefinition> result = componentNodeFilterBusinessLogic
+            .createNodeFilterIfNotExist(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
+
+        assertThat(result).isPresent();
+        assertThat(result.get().getProperties()).isEqualTo(ciNodeFilterDataDefinition.getProperties());
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterOperation, times(1)).createNodeFilter(componentId, componentInstanceId);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void deleteNodeFilterIfExistsTest() throws BusinessLogicException {
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+
+        final Optional<String> result = componentNodeFilterBusinessLogic
+            .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
+
+        assertThat(result).isPresent();
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
+    }
+
+    @Test
+    public void deleteWhenNodeFilterExistsTest() throws BusinessLogicException {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+        when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
+            .thenReturn(Either.left(componentInstanceId));
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        final Optional<String> result = componentNodeFilterBusinessLogic
+            .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE);
+
+        assertThat(result).isPresent();
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
+        verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void deleteNodeFilterIfExistsFailTest() {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+        when(nodeFilterOperation.deleteNodeFilter(resource, componentInstanceId))
+            .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .deleteNodeFilterIfExists(componentId, componentInstanceId, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterValidator, times(1)).validateComponentInstanceExist(resource, componentInstanceId);
+        verify(nodeFilterOperation, times(1)).deleteNodeFilter(resource, componentInstanceId);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void addNodeFilterFailTest() {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator
+            .validateNodeFilter(resource, componentInstanceId,
+                requirementNodeFilterPropertyDataDefinition.getConstraints(),
+                NodeFilterConstraintAction.ADD)).thenReturn(Either.left(true));
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
+                "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterValidator, times(1)).validateNodeFilter(resource, componentInstanceId,
+            constraints, NodeFilterConstraintAction.ADD);
+        verify(nodeFilterOperation, times(0))
+            .addNewProperty(componentId, componentInstanceId, ciNodeFilterDataDefinition,
+                requirementNodeFilterPropertyDataDefinition);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void addNodeFilterFailFetchComponentTest() {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId))
+            .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .addNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.ADD,
+                "MyPropertyName", constraint, true, ComponentTypeEnum.RESOURCE));
+    }
+
+    @Test
+    public void deleteNodeFilterTest() throws BusinessLogicException {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+        when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
+            NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        when(nodeFilterOperation
+            .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
+            .thenReturn(Either.left(ciNodeFilterDataDefinition));
+
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        final Optional<CINodeFilterDataDefinition> deleteNodeFilterResult = componentNodeFilterBusinessLogic
+            .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
+                0, true, ComponentTypeEnum.RESOURCE);
+
+        assertThat(deleteNodeFilterResult).isPresent();
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterValidator, times(1))
+            .validateComponentInstanceExist(resource, componentInstanceId);
+        verify(nodeFilterValidator, times(1))
+            .validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
+                NodeFilterConstraintAction.DELETE);
+        verify(nodeFilterOperation, times(1))
+            .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void deleteNodeFilterFailTest() {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+        when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
+            NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        when(nodeFilterOperation
+            .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
+            .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
+                0, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
+        verify(nodeFilterValidator, times(1))
+            .validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
+                NodeFilterConstraintAction.DELETE);
+        verify(nodeFilterValidator, times(1))
+            .validateComponentInstanceExist(resource, componentInstanceId);
+        verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
+    }
+
+    @Test
+    public void deleteNodeFilterFailValidationTest() {
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator.validateComponentInstanceExist(resource, componentInstanceId))
+            .thenReturn(Either.left(true));
+        when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
+            NodeFilterConstraintAction.DELETE)).thenReturn(Either.left(true));
+
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
+                0, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(nodeFilterValidator, times(1))
+            .validateNodeFilter(resource, componentInstanceId, singletonList(constraint),
+                NodeFilterConstraintAction.DELETE);
+        verify(nodeFilterValidator, times(1))
+            .validateComponentInstanceExist(resource, componentInstanceId);
+    }
+
+    @Test
+    public void updateNodeFilterFailTest() {
+        componentInstance.setNodeFilter(ciNodeFilterDataDefinition);
+
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId,
+            Collections.singletonList(constraint), NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
+        when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+        when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
+            .thenReturn(StorageOperationStatus.OK);
+
+        final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .updateNodeFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(nodeFilterValidator, times(1)).validateNodeFilter(resource, componentInstanceId,
+            constraints, NodeFilterConstraintAction.UPDATE);
+    }
+
+    @Test
+    public void updateNodeFilterFailValidationTest() {
+        final List<String> constraints = requirementNodeFilterPropertyDataDefinition.getConstraints();
+        when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(resource));
+        when(nodeFilterValidator.validateNodeFilter(resource, componentInstanceId,
+            constraints, NodeFilterConstraintAction.UPDATE)).thenReturn(Either.left(true));
+
+        assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
+            .updateNodeFilter(componentId, componentInstanceId, constraints, true, ComponentTypeEnum.RESOURCE));
+
+        verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
+        verify(nodeFilterValidator, times(1)).validateNodeFilter(resource, componentInstanceId,
+            constraints, NodeFilterConstraintAction.UPDATE);
+    }
+
+    @Test
+    public void validateUserTes() {
+        final String USER_ID = "jh0003";
+        final User user = new User();
+        user.setUserId(USER_ID);
+        user.setRole(Role.ADMIN.name());
+        when(userValidations.validateUserExists(USER_ID)).thenReturn(user).thenReturn(user);
+        final User result = componentNodeFilterBusinessLogic.validateUser(USER_ID);
+        assertNotNull(result);
+        assertTrue(USER_ID.equalsIgnoreCase(result.getUserId()));
+        assertTrue(Role.ADMIN.name().equalsIgnoreCase(result.getRole()));
+    }
+
+    public void initResource() {
+        try {
+            resource = new Resource();
+            resource.setName("MyResource");
+            resource.setUniqueId(componentId);
+            resource.setToscaResourceName("My_Resource_Tosca_Name");
+            resource.addCategory("Network Layer 2-3", "Router");
+            resource.setDescription("My short description");
+
+            componentInstance = new ComponentInstance();
+            componentInstance.setUniqueId(componentInstanceId);
+            componentInstance.setName("myComponentInstance");
+            componentInstance.setDirectives(new LinkedList<>(Arrays.asList(DirectivesEnum.SELECT.getValue())));
+
+            final UIConstraint uiConstraint =
+                new UIConstraint(servicePropertyName, constraintOperator, sourceType, sourceName, propertyValue);
+            constraint = new ConstraintConvertor().convert(uiConstraint);
+
+            requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
+            requirementNodeFilterPropertyDataDefinition.setName(uiConstraint.getServicePropertyName());
+            requirementNodeFilterPropertyDataDefinition.setConstraints(new LinkedList<>(Arrays.asList(constraint)));
+
+            final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> listDataDefinition =
+                new ListDataDefinition<>(new LinkedList<>(Arrays.asList(requirementNodeFilterPropertyDataDefinition)));
+
+            ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
+            ciNodeFilterDataDefinition.setProperties(listDataDefinition);
+            ciNodeFilterDataDefinition.setID("NODE_FILTER_UID");
+
+            resource.setComponentInstances(singletonList(componentInstance));
+
+            final PropertyDefinition property = new PropertyDefinition();
+            property.setName(uiConstraint.getServicePropertyName());
+
+            final List<ComponentInstanceProperty> origProperties = new ArrayList<>();
+            final ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
+            origProperty.setName(uiConstraint.getServicePropertyName());
+            origProperty.setValue(propertyValue);
+            origProperty.setType(uiConstraint.getSourceType());
+            origProperties.add(origProperty);
+
+            final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+            componentInstanceProps.put(componentInstanceId, origProperties);
+
+            resource.setComponentInstancesProperties(componentInstanceProps);
+            resource.setProperties(new LinkedList<>(Arrays.asList(property)));
+        } catch (final Exception e) {
+            fail(e.getMessage());
+        }
+    }
+}
\ No newline at end of file
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java
index 7ed7818ab4..5f0284a159 100644
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperation.java
@@ -97,18 +97,20 @@ public class NodeFilterOperation extends BaseOperation {
         return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
     }
 
-    public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewProperty(String serviceId,
-            String componentInstanceId, CINodeFilterDataDefinition nodeFilterDataDefinition,
-            RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) {
+    public Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewProperty(
+        final String componentId, final String componentInstanceId,
+        final CINodeFilterDataDefinition nodeFilterDataDefinition,
+        final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition) {
+
         ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties =
-                nodeFilterDataDefinition.getProperties();
+            nodeFilterDataDefinition.getProperties();
         if (properties == null) {
             properties = new ListDataDefinition<>();
             nodeFilterDataDefinition.setProperties(properties);
         }
         properties.getListToscaDataDefinition().add(requirementNodeFilterPropertyDataDefinition);
         nodeFilterDataDefinition.setProperties(properties);
-        return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
+        return addOrUpdateNodeFilter(true, componentId, componentInstanceId, nodeFilterDataDefinition);
     }
 
     public Either<CINodeFilterDataDefinition, StorageOperationStatus> updateProperties(String serviceId,