gerrit.onap Code Review - sdc.git/blob

   1 /*
   2
   3  * Copyright (c) 2018 AT&T Intellectual Property.
   4
   5  *
   6
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8
   9  * you may not use this file except in compliance with the License.
  10
  11  * You may obtain a copy of the License at
  12
  13  *
  14
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16
  17  *
  18
  19  * Unless required by applicable law or agreed to in writing, software
  20
  21  * distributed under the License is distributed on an "AS IS" BASIS,
  22
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24
  25  * See the License for the specific language governing permissions and
  26
  27  * limitations under the License.
  28
  29  */
  30 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  31
  32 import com.google.common.collect.Lists;
  33 import fj.data.Either;
  34 import org.apache.commons.lang3.tuple.ImmutablePair;
  35 import org.apache.tinkerpop.gremlin.structure.Direction;
  36 import org.apache.tinkerpop.gremlin.structure.Edge;
  37 import org.apache.tinkerpop.gremlin.structure.Vertex;
  38 import org.janusgraph.core.JanusGraphVertex;
  39 import org.junit.runner.RunWith;
  40 import org.mockito.InjectMocks;
  41 import org.mockito.Mock;
  42 import org.junit.Assert;
  43 import org.junit.BeforeClass;
  44 import org.junit.Test;
  45 import org.mockito.Mockito;
  46 import org.mockito.junit.MockitoJUnitRunner;
  47 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  48 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  49 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  50 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  51 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  52 import org.openecomp.sdc.be.datatypes.elements.*;
  53 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  54 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  55 import org.openecomp.sdc.be.model.*;
  56 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  57 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  58 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  59 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  60
  61 import java.util.ArrayList;
  62 import java.util.HashMap;
  63 import java.util.Iterator;
  64 import java.util.List;
  65 import java.util.Map;
  66
  67 import static org.junit.Assert.assertEquals;
  68 import static org.junit.Assert.assertSame;
  69 import static org.junit.Assert.assertTrue;
  70 import static org.mockito.ArgumentMatchers.anyString;
  71 import static org.mockito.ArgumentMatchers.eq;
  72 import static org.mockito.Mockito.when;
  73
  74 @RunWith(MockitoJUnitRunner.class)
  75 public class NodeTemplateOperationTest extends ModelTestBase {
  76
  77     private final static String COMPONENT_ID = "componentId";
  78     private final static String TO_INSTANCE_ID = "toInstanceId";
  79     private final static String FROM_INSTANCE_ID = "fromInstanceId";
  80     private final static String RELATION_ID = "relationId";
  81     private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  82     private final static String CAPABILITY_UID = "capabilityUid";
  83     private final static String CAPABILITY_NAME = "capabilityName";
  84     private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  85     private final static String REQUIREMENT_UID = "requirementUid";
  86     private final static String REQUIREMENT_NAME = "requirementName";
  87     private final static String RELATIONSHIP_TYPE = "relationshipType";
  88
  89     private static Map<String, MapListCapabilityDataDefinition> fulfilledCapability;
  90     private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement;
  91     private static CapabilityDataDefinition capability;
  92     private static RequirementDataDefinition requirement;
  93     private static RequirementCapabilityRelDef relation;
  94
  95     @InjectMocks
  96     private static NodeTemplateOperation operation;
  97
  98     @Mock
  99     private static JanusGraphDao janusGraphDao;
 100
 101     @Mock
 102     private static TopologyTemplateOperation topologyTemplateOperation;
 103
 104     @BeforeClass
 105     public static void setup() {
 106         init();
 107         janusGraphDao = Mockito.mock(JanusGraphDao.class);
 108         operation = new NodeTemplateOperation();
 109         operation.setJanusGraphDao(janusGraphDao);
 110         buildDataDefinition();
 111     }
 112
 113     private static void buildDataDefinition() {
 114         buildCapabiltyDataDefinition();
 115         buildRequirementDataDefinition();
 116         buildRelation();
 117     }
 118
 119     @Test
 120     public void testGetFulfilledCapabilityByRelationSuccess(){
 121         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 122         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 123         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 124
 125         GraphVertex dataVertex = new GraphVertex();
 126         dataVertex.setJson(fulfilledCapability);
 127         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.left(dataVertex);
 128         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 129         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 130         assertTrue(result.isLeft());
 131         assertEquals(result.left().value(), capability);
 132     }
 133
 134     @Test
 135     public void testGetFulfilledRequirementByRelationSuccess(){
 136         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 137         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 138         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 139
 140         GraphVertex dataVertex = new GraphVertex();
 141         dataVertex.setJson(fulfilledRequirement);
 142         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.left(dataVertex);
 143         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 144         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 145         assertTrue(result.isLeft());
 146         assertEquals(result.left().value(), requirement);
 147     }
 148
 149     @Test
 150     public void testGetFulfilledCapabilityByRelationNotFoundFailure(){
 151         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 152         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 153         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 154
 155         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.right(
 156             JanusGraphOperationStatus.NOT_FOUND);
 157         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 158         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 159         assertTrue(result.isRight());
 160         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 161     }
 162
 163     @Test
 164     public void testGetFulfilledRequirementByRelationNotFoundFailure(){
 165         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 166         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 167         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 168
 169         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.right(
 170             JanusGraphOperationStatus.NOT_FOUND);
 171         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 172         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 173         assertTrue(result.isRight());
 174         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 175     }
 176
 177     @Test
 178     public void testUpdateCIMetadataOfTopologyTemplate() {
 179         Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result;
 180         String id = "id";
 181         TopologyTemplate container = new TopologyTemplate();
 182         ToscaElement toscaElement = new TopologyTemplate();
 183         toscaElement.setResourceType(ResourceTypeEnum.VF);
 184         ComponentInstance componentInstance = new ComponentInstance();
 185         componentInstance.setName(id);
 186         componentInstance.setComponentUid(id);
 187         container.setUniqueId(id);
 188         GraphVertex graphVertex = new GraphVertex();
 189         when(janusGraphDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex));
 190         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
 191         when(topologyTemplateOperation.getToscaElement(anyString())).thenReturn(Either.left(toscaElement));
 192
 193         result = operation.updateComponentInstanceMetadataOfTopologyTemplate(container, toscaElement, componentInstance);
 194         assertTrue(result.isLeft());
 195     }
 196
 197         @Test
 198         public void testGetDefaultHeatTimeout() {
 199                 Integer result;
 200
 201                 // default test
 202                 result = NodeTemplateOperation.getDefaultHeatTimeout();
 203     }
 204
 205         @Test
 206     public void testPrepareInstDeploymentArtifactPerInstance() {
 207         Map<String, Object> deploymentResourceArtifacts = new HashMap<>();
 208         Map<String, ArtifactDataDefinition> deploymentArtifacts = new HashMap<>();
 209         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 210         artifactDataDefinition.setArtifactType("HEAT");
 211         artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 212         deploymentArtifacts.put("1", artifactDataDefinition);
 213         deploymentResourceArtifacts.put("1", artifactDataDefinition);
 214         String componentInstanceId = "componentInstanceId";
 215         User user = new User();
 216         user.setUserId("userId");
 217         user.setFirstName("first");
 218         user.setLastName("last");
 219         String envType = "VfHeatEnv";
 220         MapArtifactDataDefinition result;
 221
 222         result = operation.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user,
 223                 envType);
 224         Assert.assertEquals(2, result.getMapToscaDataDefinition().size());
 225     }
 226
 227         @Test
 228         public void testCreateCapPropertyKey() throws Exception {
 229                 String key = "";
 230                 String instanceId = "";
 231                 String result;
 232
 233                 // default test
 234                 result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
 235         }
 236
 237         @Test
 238         public void testPrepareCalculatedCapabiltyForNodeType() {
 239         Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
 240         ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition();
 241         List<CapabilityDataDefinition> listToscaDataDefinition = new ArrayList<>();
 242         CapabilityDataDefinition capabilityDataDefinition = new CapabilityDefinition();
 243         capabilityDataDefinition.setMaxOccurrences("1");
 244         listToscaDataDefinition.add(capabilityDataDefinition);
 245         listCapDataDefinition.setListToscaDataDefinition(listToscaDataDefinition);
 246         capabilities.put("1", listCapDataDefinition);
 247         ComponentInstance componentInstance = createCompInstance();
 248         MapListCapabilityDataDefinition result;
 249
 250         result = operation.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
 251         Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
 252         }
 253
 254     @Test
 255     public void testPrepareCalculatedReqForNodeType() {
 256         Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
 257         ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition();
 258         List<RequirementDataDefinition> listToscaDataDefinition = new ArrayList<>();
 259         RequirementDataDefinition reqDataDefinition = new RequirementDataDefinition();
 260         reqDataDefinition.setMaxOccurrences("1");
 261         listToscaDataDefinition.add(reqDataDefinition);
 262         listReqDataDef.setListToscaDataDefinition(listToscaDataDefinition);
 263         requirements.put("1", listReqDataDef);
 264         ComponentInstance componentInstance = createCompInstance();
 265         MapListRequirementDataDefinition result;
 266
 267         result = operation.prepareCalculatedRequirementForNodeType(requirements, componentInstance);
 268         Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
 269     }
 270
 271         @Test
 272         public void testAddGroupInstancesToComponentInstance() throws Exception {
 273                 Component containerComponent = null;
 274                 ComponentInstanceDataDefinition componentInstance = null;
 275                 List<GroupDefinition> groups = null;
 276                 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
 277                 StorageOperationStatus result;
 278
 279                 result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
 280                                 groupInstancesArtifacts);
 281                 Assert.assertEquals(StorageOperationStatus.OK, result);
 282         }
 283
 284         @Test
 285         public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
 286                 String componentId = "";
 287                 String instanceId = "";
 288                 List<String> groupInstances = null;
 289                 StorageOperationStatus result;
 290
 291                 result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
 292                 Assert.assertEquals(StorageOperationStatus.OK, result);
 293         }
 294
 295         @Test
 296         public void testUpdateComponentInstanceRequirement() {
 297         String componentId = "";
 298         String componentInstanceId = "requirementOwnerId";
 299
 300         GraphVertex graphVertex = new GraphVertex();
 301         graphVertex.setUniqueId("uniqueId");
 302         when(janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 303         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
 304
 305         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 306         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 307         Map<String, MapListRequirementDataDefinition> mapOfRequirements = new HashMap<>();
 308         mapOfRequirements.put(requirement.getOwnerId(), mapListRequirementDataDefinition);
 309         GraphVertex childVertex = new GraphVertex();
 310         childVertex.setJson(mapOfRequirements);
 311         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.CALCULATED_REQUIREMENTS, JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(childVertex));
 312
 313         JanusGraphVertex outVertex = Mockito.mock(JanusGraphVertex.class);
 314         Edge edge = Mockito.mock(Edge.class);
 315         when(edge.outVertex()).thenReturn(outVertex);
 316         Iterator<Edge> edgeIterator = new Iterator<Edge>() {
 317             private int counter = 0;
 318             @Override
 319             public boolean hasNext() {
 320                 return counter++ < 1;
 321             }
 322
 323             @Override
 324             public Edge next() {
 325                 return edge;
 326             }
 327         };
 328         String outId = (String) janusGraphDao
 329                 .getProperty((JanusGraphVertex) outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty());
 330         when(janusGraphDao.getProperty(outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty())).thenReturn("uniqueId");
 331         when(janusGraphDao.updateVertex(childVertex)).thenReturn(Either.left(childVertex));
 332         JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class);
 333         childVertex.setVertex(janusGraphVertex);
 334         when(janusGraphVertex.edges(Direction.IN, EdgeLabelEnum.CALCULATED_REQUIREMENTS.name())).thenReturn(edgeIterator);
 335
 336             StorageOperationStatus result = operation.updateComponentInstanceRequirement(componentId, componentInstanceId, requirement);
 337             assertEquals(StorageOperationStatus.OK, result);
 338         }
 339
 340     private ComponentInstance createCompInstance() {
 341         ComponentInstance componentInstance = new ComponentInstance();
 342         String id = "id";
 343         componentInstance.setComponentUid(id);
 344         componentInstance.setUniqueId(id);
 345         componentInstance.setName(id);
 346         return componentInstance;
 347     }
 348     private static void buildRequirementDataDefinition() {
 349         buildRequirement();
 350         fulfilledRequirement = new HashMap<>();
 351         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 352         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 353         fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition);
 354
 355     }
 356
 357     private static void buildRequirement() {
 358         requirement = new RequirementDataDefinition();
 359         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 360         requirement.setUniqueId(REQUIREMENT_UID);
 361         requirement.setName(REQUIREMENT_NAME);
 362         requirement.setRelationship(RELATIONSHIP_TYPE);
 363     }
 364
 365     private static void buildCapabiltyDataDefinition() {
 366         buildCapability();
 367         fulfilledCapability = new HashMap<>();
 368         MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition();
 369         mapListCapabiltyDataDefinition.add(capability.getType(), capability);
 370         fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition);
 371     }
 372
 373     private static void buildCapability() {
 374         capability = new CapabilityDataDefinition();
 375         capability.setOwnerId(CAPABILITY_OWNER_ID);
 376         capability.setUniqueId(CAPABILITY_UID);
 377         capability.setName(CAPABILITY_NAME);
 378     }
 379
 380     private static void buildRelation() {
 381
 382         relation = new RequirementCapabilityRelDef();
 383         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 384         RelationshipInfo relationInfo = new RelationshipInfo();
 385         relationInfo.setId(RELATION_ID);
 386         relationship.setRelation(relationInfo);
 387
 388         relation.setRelationships(Lists.newArrayList(relationship));
 389         relation.setToNode(TO_INSTANCE_ID);
 390         relation.setFromNode(FROM_INSTANCE_ID);
 391
 392         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 393         relationInfo.setCapabilityUid(CAPABILITY_UID);
 394         relationInfo.setCapability(CAPABILITY_NAME);
 395         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 396         relationInfo.setRequirementUid(REQUIREMENT_UID);
 397         relationInfo.setRequirement(REQUIREMENT_NAME);
 398         RelationshipImpl relationshipImpl  = new RelationshipImpl();
 399         relationshipImpl.setType(RELATIONSHIP_TYPE);
 400         relationInfo.setRelationships(relationshipImpl);
 401     }
 402
 403     private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
 404         return  req.getRelationship().equals(relationshipInfo.getRelationship().getType()) &&
 405                 req.getName().equals(relationshipInfo.getRequirement()) &&
 406                 req.getUniqueId().equals(relationshipInfo.getRequirementUid()) &&
 407                 req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
 408     }
 409
 410     private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
 411         return     cap.getName().equals(relationshipInfo.getCapability()) &&
 412                 cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) &&
 413                 cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
 414     }
 415
 416 }