gerrit.onap Code Review - sdc.git/blob

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