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

   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.junit.runner.RunWith;
  36 import org.mockito.InjectMocks;
  37 import org.mockito.Mock;
  38 import org.junit.Assert;
  39 import org.junit.BeforeClass;
  40 import org.junit.Test;
  41 import org.mockito.Mockito;
  42 import org.mockito.junit.MockitoJUnitRunner;
  43 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  44 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  45 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  46 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  47 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  48 import org.openecomp.sdc.be.datatypes.elements.*;
  49 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  50 import org.openecomp.sdc.be.model.*;
  51 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
  52 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  53 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  54 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  55 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  56
  57 import java.util.ArrayList;
  58 import java.util.HashMap;
  59 import java.util.List;
  60 import java.util.Map;
  61
  62 import static org.junit.Assert.assertEquals;
  63 import static org.junit.Assert.assertSame;
  64 import static org.junit.Assert.assertTrue;
  65 import static org.mockito.ArgumentMatchers.anyString;
  66 import static org.mockito.ArgumentMatchers.eq;
  67 import static org.mockito.Mockito.when;
  68
  69 @RunWith(MockitoJUnitRunner.class)
  70 public class NodeTemplateOperationTest extends ModelTestBase {
  71
  72     private final static String COMPONENT_ID = "componentId";
  73     private final static String TO_INSTANCE_ID = "toInstanceId";
  74     private final static String FROM_INSTANCE_ID = "fromInstanceId";
  75     private final static String RELATION_ID = "relationId";
  76     private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  77     private final static String CAPABILITY_UID = "capabilityUid";
  78     private final static String CAPABILITY_NAME = "capabilityName";
  79     private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  80     private final static String REQUIREMENT_UID = "requirementUid";
  81     private final static String REQUIREMENT_NAME = "requirementName";
  82     private final static String RELATIONSHIP_TYPE = "relationshipType";
  83
  84     private static Map<String, MapListCapabilityDataDefinition> fulfilledCapability;
  85     private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement;
  86     private static CapabilityDataDefinition capability;
  87     private static RequirementDataDefinition requirement;
  88     private static RequirementCapabilityRelDef relation;
  89
  90     @InjectMocks
  91     private static NodeTemplateOperation operation;
  92
  93     @Mock
  94     private static JanusGraphDao janusGraphDao;
  95
  96     @Mock
  97     private static TopologyTemplateOperation topologyTemplateOperation;
  98
  99     @BeforeClass
 100     public static void setup() {
 101         init();
 102         janusGraphDao = Mockito.mock(JanusGraphDao.class);
 103         operation = new NodeTemplateOperation();
 104         operation.setJanusGraphDao(janusGraphDao);
 105         buildDataDefinition();
 106     }
 107
 108     private static void buildDataDefinition() {
 109         buildCapabiltyDataDefinition();
 110         buildRequirementDataDefinition();
 111         buildRelation();
 112     }
 113
 114     @Test
 115     public void testGetFulfilledCapabilityByRelationSuccess(){
 116         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 117         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 118         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 119
 120         GraphVertex dataVertex = new GraphVertex();
 121         dataVertex.setJson(fulfilledCapability);
 122         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.left(dataVertex);
 123         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 124         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 125         assertTrue(result.isLeft());
 126         assertEquals(result.left().value(), capability);
 127     }
 128
 129     @Test
 130     public void testGetFulfilledRequirementByRelationSuccess(){
 131         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 132         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 133         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 134
 135         GraphVertex dataVertex = new GraphVertex();
 136         dataVertex.setJson(fulfilledRequirement);
 137         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.left(dataVertex);
 138         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 139         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 140         assertTrue(result.isLeft());
 141         assertEquals(result.left().value(), requirement);
 142     }
 143
 144     @Test
 145     public void testGetFulfilledCapabilityByRelationNotFoundFailure(){
 146         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 147         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 148         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 149
 150         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.right(
 151             JanusGraphOperationStatus.NOT_FOUND);
 152         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 153         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 154         assertTrue(result.isRight());
 155         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 156     }
 157
 158     @Test
 159     public void testGetFulfilledRequirementByRelationNotFoundFailure(){
 160         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 161         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 162         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 163
 164         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.right(
 165             JanusGraphOperationStatus.NOT_FOUND);
 166         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 167         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 168         assertTrue(result.isRight());
 169         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 170     }
 171
 172     @Test
 173     public void testUpdateCIMetadataOfTopologyTemplate() {
 174         Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result;
 175         String id = "id";
 176         TopologyTemplate container = new TopologyTemplate();
 177         ToscaElement toscaElement = new TopologyTemplate();
 178         toscaElement.setResourceType(ResourceTypeEnum.VF);
 179         ComponentInstance componentInstance = new ComponentInstance();
 180         componentInstance.setName(id);
 181         componentInstance.setComponentUid(id);
 182         container.setUniqueId(id);
 183         GraphVertex graphVertex = new GraphVertex();
 184         when(janusGraphDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex));
 185         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
 186         when(topologyTemplateOperation.getToscaElement(anyString())).thenReturn(Either.left(toscaElement));
 187
 188         result = operation.updateComponentInstanceMetadataOfTopologyTemplate(container, toscaElement, componentInstance);
 189         assertTrue(result.isLeft());
 190     }
 191
 192         @Test
 193         public void testGetDefaultHeatTimeout() {
 194                 Integer result;
 195
 196                 // default test
 197                 result = NodeTemplateOperation.getDefaultHeatTimeout();
 198     }
 199
 200         @Test
 201     public void testPrepareInstDeploymentArtifactPerInstance() {
 202         Map<String, Object> deploymentResourceArtifacts = new HashMap<>();
 203         Map<String, ArtifactDataDefinition> deploymentArtifacts = new HashMap<>();
 204         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 205         artifactDataDefinition.setArtifactType("HEAT");
 206         artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 207         deploymentArtifacts.put("1", artifactDataDefinition);
 208         deploymentResourceArtifacts.put("1", artifactDataDefinition);
 209         String componentInstanceId = "componentInstanceId";
 210         User user = new User();
 211         user.setUserId("userId");
 212         user.setFirstName("first");
 213         user.setLastName("last");
 214         String envType = "VfHeatEnv";
 215         MapArtifactDataDefinition result;
 216
 217         result = operation.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user,
 218                 envType);
 219         Assert.assertEquals(2, result.getMapToscaDataDefinition().size());
 220     }
 221
 222         @Test
 223         public void testCreateCapPropertyKey() throws Exception {
 224                 String key = "";
 225                 String instanceId = "";
 226                 String result;
 227
 228                 // default test
 229                 result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
 230         }
 231
 232         @Test
 233         public void testPrepareCalculatedCapabiltyForNodeType() {
 234         Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
 235         ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition();
 236         List<CapabilityDataDefinition> listToscaDataDefinition = new ArrayList<>();
 237         CapabilityDataDefinition capabilityDataDefinition = new CapabilityDefinition();
 238         capabilityDataDefinition.setMaxOccurrences("1");
 239         listToscaDataDefinition.add(capabilityDataDefinition);
 240         listCapDataDefinition.setListToscaDataDefinition(listToscaDataDefinition);
 241         capabilities.put("1", listCapDataDefinition);
 242         ComponentInstance componentInstance = createCompInstance();
 243         MapListCapabilityDataDefinition result;
 244
 245         result = operation.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
 246         Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
 247         }
 248
 249     @Test
 250     public void testPrepareCalculatedReqForNodeType() {
 251         Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
 252         ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition();
 253         List<RequirementDataDefinition> listToscaDataDefinition = new ArrayList<>();
 254         RequirementDataDefinition reqDataDefinition = new RequirementDataDefinition();
 255         reqDataDefinition.setMaxOccurrences("1");
 256         listToscaDataDefinition.add(reqDataDefinition);
 257         listReqDataDef.setListToscaDataDefinition(listToscaDataDefinition);
 258         requirements.put("1", listReqDataDef);
 259         ComponentInstance componentInstance = createCompInstance();
 260         MapListRequirementDataDefinition result;
 261
 262         result = operation.prepareCalculatedRequirementForNodeType(requirements, componentInstance);
 263         Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
 264     }
 265
 266         @Test
 267         public void testAddGroupInstancesToComponentInstance() throws Exception {
 268                 Component containerComponent = null;
 269                 ComponentInstanceDataDefinition componentInstance = null;
 270                 List<GroupDefinition> groups = null;
 271                 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
 272                 StorageOperationStatus result;
 273
 274                 result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
 275                                 groupInstancesArtifacts);
 276                 Assert.assertEquals(StorageOperationStatus.OK, result);
 277         }
 278
 279         @Test
 280         public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
 281                 String componentId = "";
 282                 String instanceId = "";
 283                 List<String> groupInstances = null;
 284                 StorageOperationStatus result;
 285
 286                 result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
 287                 Assert.assertEquals(StorageOperationStatus.OK, result);
 288         }
 289
 290     private ComponentInstance createCompInstance() {
 291         ComponentInstance componentInstance = new ComponentInstance();
 292         String id = "id";
 293         componentInstance.setComponentUid(id);
 294         componentInstance.setUniqueId(id);
 295         componentInstance.setName(id);
 296         return componentInstance;
 297     }
 298     private static void buildRequirementDataDefinition() {
 299         buildRequirement();
 300         fulfilledRequirement = new HashMap<>();
 301         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 302         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 303         fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition);
 304
 305     }
 306
 307     private static void buildRequirement() {
 308         requirement = new RequirementDataDefinition();
 309         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 310         requirement.setUniqueId(REQUIREMENT_UID);
 311         requirement.setName(REQUIREMENT_NAME);
 312         requirement.setRelationship(RELATIONSHIP_TYPE);
 313     }
 314
 315     private static void buildCapabiltyDataDefinition() {
 316         buildCapability();
 317         fulfilledCapability = new HashMap<>();
 318         MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition();
 319         mapListCapabiltyDataDefinition.add(capability.getType(), capability);
 320         fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition);
 321     }
 322
 323     private static void buildCapability() {
 324         capability = new CapabilityDataDefinition();
 325         capability.setOwnerId(CAPABILITY_OWNER_ID);
 326         capability.setUniqueId(CAPABILITY_UID);
 327         capability.setName(CAPABILITY_NAME);
 328     }
 329
 330     private static void buildRelation() {
 331
 332         relation = new RequirementCapabilityRelDef();
 333         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 334         RelationshipInfo relationInfo = new RelationshipInfo();
 335         relationInfo.setId(RELATION_ID);
 336         relationship.setRelation(relationInfo);
 337
 338         relation.setRelationships(Lists.newArrayList(relationship));
 339         relation.setToNode(TO_INSTANCE_ID);
 340         relation.setFromNode(FROM_INSTANCE_ID);
 341
 342         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 343         relationInfo.setCapabilityUid(CAPABILITY_UID);
 344         relationInfo.setCapability(CAPABILITY_NAME);
 345         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 346         relationInfo.setRequirementUid(REQUIREMENT_UID);
 347         relationInfo.setRequirement(REQUIREMENT_NAME);
 348         RelationshipImpl relationshipImpl  = new RelationshipImpl();
 349         relationshipImpl.setType(RELATIONSHIP_TYPE);
 350         relationInfo.setRelationships(relationshipImpl);
 351     }
 352
 353     private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
 354         return  req.getRelationship().equals(relationshipInfo.getRelationship().getType()) &&
 355                 req.getName().equals(relationshipInfo.getRequirement()) &&
 356                 req.getUniqueId().equals(relationshipInfo.getRequirementUid()) &&
 357                 req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
 358     }
 359
 360     private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
 361         return     cap.getName().equals(relationshipInfo.getCapability()) &&
 362                 cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) &&
 363                 cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
 364     }
 365
 366 }