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

   1 package org.openecomp.sdc.be.model.jsontitan.operations;
   2
   3 import static org.junit.Assert.assertTrue;
   4 import static org.mockito.ArgumentMatchers.eq;
   5 import static org.mockito.Mockito.when;
   6
   7 import java.util.HashMap;
   8 import java.util.Map;
   9
  10 import org.junit.BeforeClass;
  11 import org.junit.Test;
  12 import org.mockito.Mockito;
  13 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  14 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  15 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  16 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  17 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  18 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  19 import org.openecomp.sdc.be.datatypes.elements.MapListCapabiltyDataDefinition;
  20 import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
  21 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  22 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  23 import org.openecomp.sdc.be.model.ModelTestBase;
  24 import org.openecomp.sdc.be.model.RelationshipImpl;
  25 import org.openecomp.sdc.be.model.RelationshipInfo;
  26 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  27 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  28 import com.google.common.collect.Lists;
  29
  30 import fj.data.Either;
  31
  32 public class NodeTemplateOperationTest extends ModelTestBase{
  33
  34         private final static String COMPONENT_ID = "componentId";
  35         private final static String TO_INSTANCE_ID = "toInstanceId";
  36         private final static String FROM_INSTANCE_ID = "fromInstanceId";
  37         private final static String RELATION_ID = "relationId";
  38         private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  39         private final static String CAPABILITY_UID = "capabilityUid";
  40         private final static String CAPABILITY_NAME = "capabilityName";
  41         private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  42         private final static String REQUIREMENT_UID = "requirementUid";
  43         private final static String REQUIREMENT_NAME = "requirementName";
  44         private final static String RELATIONSHIP_TYPE = "relationshipType";
  45
  46         private static Map<String, MapListCapabiltyDataDefinition> fulfilledCapability;
  47         private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement;
  48         private static CapabilityDataDefinition capability;
  49         private static RequirementDataDefinition requirement;
  50         private static RequirementCapabilityRelDef relation;
  51
  52         private static TitanDao titanDao;
  53         private static NodeTemplateOperation operation;
  54
  55         @BeforeClass
  56         public static void setup() {
  57                 init();
  58                 titanDao = Mockito.mock(TitanDao.class);
  59                 operation = new NodeTemplateOperation();
  60                 operation.setTitanDao(titanDao);
  61                 buildDataDefinition();
  62         }
  63
  64         private static void buildDataDefinition() {
  65                 buildCapabiltyDataDefinition();
  66                 buildRequirementDataDefinition();
  67                 buildRelation();
  68         }
  69
  70         @Test
  71         public void testGetFulfilledCapabilityByRelationSuccess(){
  72                 GraphVertex vertex = Mockito.mock(GraphVertex.class);
  73                 Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
  74                 when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
  75
  76                 GraphVertex dataVertex = new GraphVertex();
  77                 dataVertex.setJson(fulfilledCapability);
  78                 Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex);
  79                 when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
  80                 Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, (rel, cap)->isBelongingCapability(rel, cap));
  81                 assertTrue(result.isLeft());
  82                 assertTrue(result.left().value().equals(capability));
  83         }
  84
  85         @Test
  86         public void testGetFulfilledRequirementByRelationSuccess(){
  87                 GraphVertex vertex = Mockito.mock(GraphVertex.class);
  88                 Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
  89                 when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
  90
  91                 GraphVertex dataVertex = new GraphVertex();
  92                 dataVertex.setJson(fulfilledRequirement);
  93                 Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex);
  94                 when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
  95                 Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, (rel, req)->isBelongingRequirement(rel, req));
  96                 assertTrue(result.isLeft());
  97                 assertTrue(result.left().value().equals(requirement));
  98         }
  99
 100         @Test
 101         public void testGetFulfilledCapabilityByRelationNotFoundFailure(){
 102                 GraphVertex vertex = Mockito.mock(GraphVertex.class);
 103                 Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 104                 when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 105
 106                 Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
 107                 when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 108                 Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, (rel, cap)->isBelongingCapability(rel, cap));
 109                 assertTrue(result.isRight());
 110                 assertTrue(result.right().value() == StorageOperationStatus.NOT_FOUND);
 111         }
 112
 113         @Test
 114         public void testGetFulfilledRequirementByRelationNotFoundFailure(){
 115                 GraphVertex vertex = Mockito.mock(GraphVertex.class);
 116                 Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 117                 when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 118
 119                 Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
 120                 when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 121                 Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation,(rel, req)->isBelongingRequirement(rel, req));
 122                 assertTrue(result.isRight());
 123                 assertTrue(result.right().value() == StorageOperationStatus.NOT_FOUND);
 124         }
 125
 126         private static void buildRequirementDataDefinition() {
 127                 buildRequirement();
 128                 fulfilledRequirement = new HashMap<>();
 129                 MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 130                 mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 131                 fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition);
 132
 133         }
 134
 135         private static void buildRequirement() {
 136                 requirement = new RequirementDataDefinition();
 137                 requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 138                 requirement.setUniqueId(REQUIREMENT_UID);
 139                 requirement.setName(REQUIREMENT_NAME);
 140                 requirement.setRelationship(RELATIONSHIP_TYPE);
 141         }
 142
 143         private static void buildCapabiltyDataDefinition() {
 144                 buildCapability();
 145                 fulfilledCapability = new HashMap<>();
 146                 MapListCapabiltyDataDefinition mapListCapabiltyDataDefinition = new MapListCapabiltyDataDefinition();
 147                 mapListCapabiltyDataDefinition.add(capability.getType(), capability);
 148                 fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition);
 149         }
 150
 151         private static void buildCapability() {
 152                 capability = new CapabilityDataDefinition();
 153                 capability.setOwnerId(CAPABILITY_OWNER_ID);
 154                 capability.setUniqueId(CAPABILITY_UID);
 155                 capability.setName(CAPABILITY_NAME);
 156         }
 157
 158         private static void buildRelation() {
 159
 160                 relation = new RequirementCapabilityRelDef();
 161                 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 162                 RelationshipInfo relationInfo = new RelationshipInfo();
 163                 relationInfo.setId(RELATION_ID);
 164                 relationship.setRelation(relationInfo);
 165
 166                 relation.setRelationships(Lists.newArrayList(relationship));
 167                 relation.setToNode(TO_INSTANCE_ID);
 168                 relation.setFromNode(FROM_INSTANCE_ID);
 169
 170                 relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 171                 relationInfo.setCapabilityUid(CAPABILITY_UID);
 172                 relationInfo.setCapability(CAPABILITY_NAME);
 173                 relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 174                 relationInfo.setRequirementUid(REQUIREMENT_UID);
 175                 relationInfo.setRequirement(REQUIREMENT_NAME);
 176                 RelationshipImpl relationshipImpl  = new RelationshipImpl();
 177                 relationshipImpl.setType(RELATIONSHIP_TYPE);
 178                 relationInfo.setRelationships(relationshipImpl);
 179         }
 180
 181         private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
 182                 return  req.getRelationship().equals(relationshipInfo.getRelationship().getType()) &&
 183                                 req.getName().equals(relationshipInfo.getRequirement()) &&
 184                                 req.getUniqueId().equals(relationshipInfo.getRequirementUid()) &&
 185                                 req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
 186         }
 187
 188         private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
 189                 return  cap.getName().equals(relationshipInfo.getCapability()) &&
 190                                 cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) &&
 191                                 cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
 192         }
 193 }