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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.jupiter.api.Assertions.assertEquals;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.ArgumentMatchers.anyMap;
  27 import static org.mockito.ArgumentMatchers.eq;
  28 import static org.mockito.Mockito.doReturn;
  29 import static org.mockito.Mockito.times;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32
  33 import fj.data.Either;
  34 import java.util.Collections;
  35 import java.util.HashMap;
  36 import java.util.Iterator;
  37 import java.util.Map;
  38 import org.apache.tinkerpop.gremlin.structure.Direction;
  39 import org.apache.tinkerpop.gremlin.structure.Edge;
  40 import org.apache.tinkerpop.gremlin.structure.Vertex;
  41 import org.janusgraph.core.JanusGraphVertex;
  42 import org.junit.jupiter.api.Test;
  43 import org.junit.jupiter.api.extension.ExtendWith;
  44 import org.mockito.InjectMocks;
  45 import org.mockito.Mock;
  46 import org.mockito.Mockito;
  47 import org.mockito.junit.jupiter.MockitoExtension;
  48 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  49 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  50 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  51 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  52 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  53 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  54 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
  55 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
  56 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
  57 import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
  58 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  59 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  60 import org.openecomp.sdc.be.model.ComponentParametersView;
  61 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  62 import org.openecomp.sdc.be.model.OutputDefinition;
  63 import org.openecomp.sdc.be.model.PolicyDefinition;
  64 import org.openecomp.sdc.be.model.User;
  65 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  66 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  67 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  68
  69 @ExtendWith(MockitoExtension.class)
  70 class TopologyTemplateOperationTest {
  71
  72     private static final String CONTAINER_ID = "containerId";
  73     @InjectMocks
  74     private TopologyTemplateOperation topologyTemplateOperation;
  75     @Mock
  76     private JanusGraphDao janusGraphDao;
  77
  78     @Test
  79     void overrideToscaDataOfToscaElement_failedToFetchContainerVertex() {
  80         when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
  81             JanusGraphOperationStatus.INVALID_ID));
  82         StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID,
  83             EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap());
  84         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID);
  85     }
  86
  87     @Test
  88     void overrideToscaDataOfToscaElement_failedToFetchDataVertex() {
  89         GraphVertex containerVertex = new GraphVertex();
  90         when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex));
  91         when(janusGraphDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(
  92             Either.right(
  93                 JanusGraphOperationStatus.NOT_FOUND));
  94         StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID,
  95             EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap());
  96         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND);
  97     }
  98
  99     @Test
 100     void updateToscaDataDeepElements_failedToFetchContainerVertex() {
 101         when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 102             JanusGraphOperationStatus.INVALID_ID));
 103         StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID,
 104             EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), "");
 105         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID);
 106     }
 107
 108     @Test
 109     void updateToscaDataDeepElements_failedToFetchDataVertex() {
 110         GraphVertex containerVertex = new GraphVertex();
 111         when(janusGraphDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex));
 112         when(janusGraphDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(
 113             Either.right(
 114                 JanusGraphOperationStatus.NOT_FOUND));
 115         StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID,
 116             EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), "");
 117         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND);
 118     }
 119
 120     @Test
 121     void addPolicyToToscaElementSuccessTest() {
 122         JanusGraphOperationStatus status = JanusGraphOperationStatus.OK;
 123         StorageOperationStatus result = addPolicyToToscaElementWithStatus(status);
 124         assertThat(result).isEqualTo(StorageOperationStatus.OK);
 125     }
 126
 127     @Test
 128     void addPolicyToToscaElementFailureTest() {
 129         JanusGraphOperationStatus status = JanusGraphOperationStatus.ALREADY_EXIST;
 130         StorageOperationStatus result = addPolicyToToscaElementWithStatus(status);
 131         assertThat(result).isEqualTo(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
 132     }
 133
 134     @Test
 135     void testAssociateOrAddCalcCapReqToComponent() {
 136         StorageOperationStatus result;
 137         GraphVertex graphVertex = new GraphVertex();
 138         Map<String, MapListRequirementDataDefinition> calcRequirements = new HashMap<>();
 139         Map<String, MapListCapabilityDataDefinition> calcCapabilty = new HashMap<>();
 140         Map<String, MapCapabilityProperty> calCapabilitiesProps = new HashMap<>();
 141         addPolicyToToscaElementWithStatus(JanusGraphOperationStatus.OK);
 142         result = topologyTemplateOperation.associateOrAddCalcCapReqToComponent(graphVertex, calcRequirements, calcCapabilty, calCapabilitiesProps);
 143         assertEquals(StorageOperationStatus.OK, result);
 144     }
 145
 146     @Test
 147     void testSetDataTypesFromGraph() {
 148         GraphVertex containerVertex = new GraphVertex();
 149         ComponentParametersView filter = new ComponentParametersView(true);
 150         filter.setIgnoreComponentInstancesInterfaces(true);
 151         filter.setIgnoreDataType(false);
 152         String componentName = "componentName";
 153         String componentId = UniqueIdBuilder.buildResourceUniqueId();
 154         containerVertex.setVertex(Mockito.mock(JanusGraphVertex.class));
 155         containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
 156         containerVertex.setUniqueId(componentId);
 157         containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 158         when(janusGraphDao.getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class))).thenReturn(Either.right(
 159             JanusGraphOperationStatus.GENERAL_ERROR));
 160         Either<ToscaElement, StorageOperationStatus> storageOperationStatus = topologyTemplateOperation.getToscaElement(containerVertex, filter);
 161         assertThat(storageOperationStatus).isEqualTo(Either.right(StorageOperationStatus.GENERAL_ERROR));
 162     }
 163
 164     @Test
 165     void testSetOutputsFromGraph() {
 166         final GraphVertex containerVertex = new GraphVertex();
 167         final ComponentParametersView filter = new ComponentParametersView(true);
 168         filter.setIgnoreOutputs(false);
 169         final String componentName = "componentName";
 170         final String componentId = UniqueIdBuilder.buildResourceUniqueId();
 171         containerVertex.setVertex(Mockito.mock(JanusGraphVertex.class));
 172         containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
 173         containerVertex.setUniqueId(componentId);
 174         containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 175         doReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)).when(janusGraphDao)
 176             .getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class));
 177         final Either<ToscaElement, StorageOperationStatus> storageOperationStatus
 178             = topologyTemplateOperation.getToscaElement(containerVertex, filter);
 179         assertThat(storageOperationStatus).isEqualTo(Either.right(StorageOperationStatus.GENERAL_ERROR));
 180         verify(janusGraphDao, times(1)).getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class));
 181     }
 182
 183     @Test
 184     void testUpdateDistributionStatus() {
 185         Either<GraphVertex, StorageOperationStatus> result;
 186         String uniqueId = "uniqueId";
 187         User user = new User();
 188         String userId = "userId";
 189         user.setUserId(userId);
 190         Iterator<Edge> edgeIterator = new Iterator<Edge>() {
 191             @Override
 192             public boolean hasNext() {
 193                 return false;
 194             }
 195
 196             @Override
 197             public Edge next() {
 198                 return null;
 199             }
 200         };
 201         GraphVertex graphVertex = Mockito.mock(GraphVertex.class);
 202         JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class);
 203         when(graphVertex.getVertex()).thenReturn(janusGraphVertex);
 204         when(janusGraphVertex.edges(Direction.IN, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER.name())).thenReturn(edgeIterator);
 205         when(janusGraphDao
 206             .getVertexByPropertyAndLabel(GraphPropertyEnum.USERID, userId, VertexTypeEnum.USER, JsonParseFlagEnum.NoParse)).thenReturn(
 207             Either.left(graphVertex));
 208         when(janusGraphDao.getVertexById(uniqueId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex));
 209         when(janusGraphDao.createEdge(graphVertex, graphVertex, EdgeLabelEnum.LAST_DISTRIBUTION_STATE_MODIFIER, null)).thenReturn(
 210             JanusGraphOperationStatus.OK);
 211         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
 212         result = topologyTemplateOperation.updateDistributionStatus(uniqueId, user, DistributionStatusEnum.DISTRIBUTED);
 213         assertThat(result.isLeft()).isTrue();
 214     }
 215
 216     @Test
 217     void testAssociateOutputsToComponent_OK() {
 218         GraphVertex containerVertex = new GraphVertex();
 219         String componentName = "componentName";
 220         String componentId = UniqueIdBuilder.buildResourceUniqueId();
 221         containerVertex.setVertex(Mockito.mock(JanusGraphVertex.class));
 222         containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
 223         containerVertex.setUniqueId(componentId);
 224         containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 225         final Map<String, AttributeDataDefinition> outputs = new HashMap<>();
 226         outputs.put("out-1", new OutputDefinition());
 227
 228         when(janusGraphDao.createVertex(any(GraphVertex.class))).thenReturn(Either.left(containerVertex));
 229         when(janusGraphDao.createEdge(any(Vertex.class), any(Vertex.class), eq(EdgeLabelEnum.OUTPUTS), anyMap()))
 230             .thenReturn(JanusGraphOperationStatus.OK);
 231
 232         final StorageOperationStatus result = topologyTemplateOperation.associateOutputsToComponent(containerVertex, outputs, CONTAINER_ID);
 233         assertEquals(StorageOperationStatus.OK, result);
 234     }
 235
 236     @Test
 237     void testAssociateOutputsToComponent_Fail_createVertex() {
 238         GraphVertex containerVertex = new GraphVertex();
 239         String componentName = "componentName";
 240         String componentId = UniqueIdBuilder.buildResourceUniqueId();
 241         containerVertex.setVertex(Mockito.mock(JanusGraphVertex.class));
 242         containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
 243         containerVertex.setUniqueId(componentId);
 244         containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 245         final Map<String, AttributeDataDefinition> outputs = new HashMap<>();
 246         outputs.put("out-1", new OutputDefinition());
 247
 248         when(janusGraphDao.createVertex(any(GraphVertex.class))).thenReturn(Either.right(JanusGraphOperationStatus.NOT_CREATED));
 249
 250         final StorageOperationStatus result = topologyTemplateOperation.associateOutputsToComponent(containerVertex, outputs, CONTAINER_ID);
 251         assertEquals(StorageOperationStatus.SCHEMA_ERROR, result);
 252     }
 253
 254     @SuppressWarnings("unchecked")
 255     private StorageOperationStatus addPolicyToToscaElementWithStatus(JanusGraphOperationStatus status) {
 256         GraphVertex componentV = new GraphVertex();
 257         componentV.setVertex(Mockito.mock(JanusGraphVertex.class));
 258         GraphVertex dataV = new GraphVertex();
 259         dataV.setVertex(Mockito.mock(JanusGraphVertex.class));
 260         String componentName = "componentName";
 261         String componentId = UniqueIdBuilder.buildResourceUniqueId();
 262         String policyTypeName = "org.openecomp.policies.placement.valet.Affinity";
 263         componentV.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
 264         componentV.setUniqueId(componentId);
 265         PolicyDefinition policy = new PolicyDefinition();
 266         policy.setPolicyTypeName(policyTypeName);
 267         int counter = 0;
 268         Either<GraphVertex, JanusGraphOperationStatus> toscaDataVertexRes = Either.right(
 269             JanusGraphOperationStatus.NOT_FOUND);
 270         when(janusGraphDao.getChildVertex(componentV, EdgeLabelEnum.POLICIES, JsonParseFlagEnum.ParseJson)).thenReturn(toscaDataVertexRes);
 271         Either<GraphVertex, JanusGraphOperationStatus> createVertex = Either.left(dataV);
 272         when(janusGraphDao.createVertex(any(GraphVertex.class))).thenReturn(createVertex);
 273         when(janusGraphDao.createEdge(any(JanusGraphVertex.class), any(JanusGraphVertex.class), any(EdgeLabelEnum.class),
 274             any(HashMap.class))).thenReturn(status);
 275         return topologyTemplateOperation.addPolicyToToscaElement(componentV, policy, counter);
 276     }
 277
 278 }