catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeFilterOperationTest.java

   1 /*
   2  * -
   3  *  ============LICENSE_START=======================================================
   4  *  Copyright (C) 2022 Nordix Foundation.
   5  *  ================================================================================
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *       http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  *  SPDX-License-Identifier: Apache-2.0
  19  *  ============LICENSE_END=========================================================
  20  */
  21 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  22
  23 import static org.junit.jupiter.api.Assertions.assertEquals;
  24 import static org.junit.jupiter.api.Assertions.assertFalse;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.ArgumentMatchers.eq;
  28 import static org.mockito.ArgumentMatchers.nullable;
  29 import static org.mockito.Mockito.mock;
  30 import static org.mockito.Mockito.when;
  31
  32 import fj.data.Either;
  33 import java.util.Arrays;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import org.apache.tinkerpop.gremlin.structure.Direction;
  38 import org.apache.tinkerpop.gremlin.structure.Edge;
  39 import org.janusgraph.core.JanusGraphVertex;
  40 import org.junit.jupiter.api.BeforeEach;
  41 import org.junit.jupiter.api.Test;
  42 import org.mockito.Mock;
  43 import org.mockito.MockitoAnnotations;
  44 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  45 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  46 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  47 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  48 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  49 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.enums.ConstraintType;
  55 import org.openecomp.sdc.be.datatypes.enums.FilterValueType;
  56 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  57 import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
  58 import org.openecomp.sdc.be.datatypes.enums.PropertyFilterTargetType;
  59 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  60
  61 class NodeFilterOperationTest {
  62
  63     private final NodeFilterOperation nodeFilterOperation = new NodeFilterOperation();
  64
  65     @Mock
  66     private JanusGraphDao janusGraphDao;
  67
  68     @BeforeEach
  69     void setUp() {
  70         MockitoAnnotations.openMocks(this);
  71         nodeFilterOperation.setJanusGraphDao(janusGraphDao);
  72     }
  73
  74     @Test
  75     void addOrUpdateNodeFilterData() {
  76         CINodeFilterDataDefinition nodeFilterDataDefinition = new CINodeFilterDataDefinition();
  77         nodeFilterDataDefinition.setName("new node filter name");
  78         String prop1 = "property1";
  79         String prop2 = "property2";
  80         final var propertyFilterDataDefinition = new PropertyFilterDataDefinition();
  81         propertyFilterDataDefinition.setName("Name1");
  82         final var propertyFilterConstraint1 = new PropertyFilterConstraintDataDefinition();
  83         propertyFilterConstraint1.setPropertyName("mem_size");
  84         propertyFilterConstraint1.setOperator(ConstraintType.EQUAL);
  85         propertyFilterConstraint1.setValue(Map.of("get_property", List.of(prop1, "size")));
  86         propertyFilterConstraint1.setValueType(FilterValueType.GET_PROPERTY);
  87         propertyFilterConstraint1.setTargetType(PropertyFilterTargetType.PROPERTY);
  88         propertyFilterDataDefinition.setConstraints(List.of(propertyFilterConstraint1));
  89
  90         final var propertyFilterDataDefinition2 = new PropertyFilterDataDefinition();
  91         propertyFilterDataDefinition2.setName("Name2");
  92         final var propertyFilterConstraint2 = new PropertyFilterConstraintDataDefinition();
  93         propertyFilterConstraint2.setPropertyName("mem_size");
  94         propertyFilterConstraint2.setOperator(ConstraintType.EQUAL);
  95         propertyFilterConstraint2.setValue(Map.of("get_property", List.of("SELF", prop2)));
  96         propertyFilterConstraint2.setValueType(FilterValueType.GET_PROPERTY);
  97         propertyFilterConstraint2.setTargetType(PropertyFilterTargetType.PROPERTY);
  98         propertyFilterDataDefinition2.setConstraints(List.of(propertyFilterConstraint2));
  99
 100         ListDataDefinition<PropertyFilterDataDefinition> listDataDefinition =
 101                 new ListDataDefinition<>(Arrays.asList(
 102                     propertyFilterDataDefinition,
 103                     propertyFilterDataDefinition2));
 104         nodeFilterDataDefinition.setProperties(listDataDefinition);
 105
 106         String componentId = "componentId";
 107         final GraphVertex serviceVertexMock = mock(GraphVertex.class);
 108         final JanusGraphVertex serviceJanusVertex = mock(JanusGraphVertex.class);
 109         when(serviceVertexMock.getVertex()).thenReturn(serviceJanusVertex);
 110         when(serviceVertexMock.getUniqueId()).thenReturn("componentId");
 111         when(janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(serviceVertexMock));
 112         when(janusGraphDao.getChildVertex(serviceVertexMock, EdgeLabelEnum.NODE_FILTER_TEMPLATE, JsonParseFlagEnum.ParseJson))
 113                 .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 114         when(janusGraphDao.createVertex(any())).thenReturn(Either.left(new GraphVertex()));
 115         when(janusGraphDao.createEdge(eq(serviceJanusVertex), nullable(JanusGraphVertex.class), eq(EdgeLabelEnum.NODE_FILTER_TEMPLATE), eq(new HashMap<>())))
 116                 .thenReturn(JanusGraphOperationStatus.OK);
 117         final Either<CINodeFilterDataDefinition, StorageOperationStatus> expectedNodeFilterEither = nodeFilterOperation.updateNodeFilter(
 118                 componentId, "componentInstanceId", nodeFilterDataDefinition);
 119         assertTrue(expectedNodeFilterEither.isLeft());
 120         final CINodeFilterDataDefinition expectedNodeFilter = expectedNodeFilterEither.left().value();
 121         assertEquals("new node filter name", expectedNodeFilter.getName());
 122         assertEquals(listDataDefinition, expectedNodeFilter.getProperties());
 123     }
 124
 125     @Test
 126     void deleteCapabilityConstraintTest() {
 127         final var ciNodeFilterDataDefinition = new CINodeFilterDataDefinition();
 128         final var capabilities = new ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition>();
 129
 130         var capabilityFilter1 = new RequirementNodeFilterCapabilityDataDefinition();
 131         final var propertyFilterList = new ListDataDefinition<PropertyFilterDataDefinition>();
 132         propertyFilterList.add(new PropertyFilterDataDefinition());
 133         propertyFilterList.add(new PropertyFilterDataDefinition());
 134         propertyFilterList.add(new PropertyFilterDataDefinition());
 135         propertyFilterList.add(new PropertyFilterDataDefinition());
 136         propertyFilterList.add(new PropertyFilterDataDefinition());
 137         propertyFilterList.add(new PropertyFilterDataDefinition());
 138         capabilityFilter1.setProperties(propertyFilterList);
 139         capabilities.add(capabilityFilter1);
 140
 141         var capabilityFilter2 = new RequirementNodeFilterCapabilityDataDefinition();
 142         final var propertyFilterList2 = new ListDataDefinition<PropertyFilterDataDefinition>();
 143         final var filterToDelete = new PropertyFilterDataDefinition();
 144         propertyFilterList2.add(filterToDelete);
 145         propertyFilterList2.add(new PropertyFilterDataDefinition());
 146         capabilityFilter2.setProperties(propertyFilterList2);
 147         capabilities.add(capabilityFilter2);
 148
 149         final GraphVertex serviceVertexMock = mock(GraphVertex.class);
 150         final JanusGraphVertex serviceJanusVertex = mock(JanusGraphVertex.class);
 151         when(serviceVertexMock.getVertex()).thenReturn(serviceJanusVertex);
 152         when(serviceVertexMock.getUniqueId()).thenReturn("componentId");
 153         when(janusGraphDao.getVertexById("componentId", JsonParseFlagEnum.NoParse)).thenReturn(Either.left(serviceVertexMock));
 154         final GraphVertex nodeFilterVertexMock = mock(GraphVertex.class);
 155         when(janusGraphDao.getChildVertex(serviceVertexMock, EdgeLabelEnum.NODE_FILTER_TEMPLATE, JsonParseFlagEnum.ParseJson))
 156             .thenReturn(Either.left(nodeFilterVertexMock));
 157         final JanusGraphVertex nodeFilterJanusVertexMock = mock(JanusGraphVertex.class);
 158         when(nodeFilterVertexMock.getVertex()).thenReturn(nodeFilterJanusVertexMock);
 159         final Edge edgeToDeleteMock = mock(Edge.class);
 160         when(nodeFilterJanusVertexMock.edges(Direction.IN, EdgeLabelEnum.NODE_FILTER_TEMPLATE.name()))
 161             .thenReturn(List.of(edgeToDeleteMock).iterator());
 162         when(janusGraphDao.getProperty(any(), eq(GraphPropertyEnum.UNIQUE_ID.getProperty()))).thenReturn("componentId");
 163         when(janusGraphDao.updateVertex(nodeFilterVertexMock)).thenReturn(Either.left(nodeFilterVertexMock));
 164
 165         ciNodeFilterDataDefinition.setCapabilities(capabilities);
 166         final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = nodeFilterOperation.deleteConstraint(
 167             "componentId", "instanceId", ciNodeFilterDataDefinition, 6, NodeFilterConstraintType.CAPABILITIES);
 168
 169         assertTrue(result.isLeft());
 170         assertEquals(1, propertyFilterList2.getListToscaDataDefinition().size());
 171         assertFalse(propertyFilterList2.getListToscaDataDefinition().contains(filterToDelete));
 172     }
 173
 174 }