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 com.google.common.collect.Lists;
   4 import fj.data.Either;
   5 import org.junit.Assert;
   6 import org.junit.BeforeClass;
   7 import org.junit.Test;
   8 import org.mockito.Mockito;
   9 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  10 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  11 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  12 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  13 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  14 import org.openecomp.sdc.be.datatypes.elements.*;
  15 import org.openecomp.sdc.be.model.*;
  16 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
  17 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  18
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertSame;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.ArgumentMatchers.eq;
  27 import static org.mockito.Mockito.when;
  28
  29 public class NodeTemplateOperationTest extends ModelTestBase {
  30
  31     private final static String COMPONENT_ID = "componentId";
  32     private final static String TO_INSTANCE_ID = "toInstanceId";
  33     private final static String FROM_INSTANCE_ID = "fromInstanceId";
  34     private final static String RELATION_ID = "relationId";
  35     private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  36     private final static String CAPABILITY_UID = "capabilityUid";
  37     private final static String CAPABILITY_NAME = "capabilityName";
  38     private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  39     private final static String REQUIREMENT_UID = "requirementUid";
  40     private final static String REQUIREMENT_NAME = "requirementName";
  41     private final static String RELATIONSHIP_TYPE = "relationshipType";
  42
  43     private static Map<String, MapListCapabilityDataDefinition> fulfilledCapability;
  44     private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement;
  45     private static CapabilityDataDefinition capability;
  46     private static RequirementDataDefinition requirement;
  47     private static RequirementCapabilityRelDef relation;
  48
  49     private static TitanDao titanDao;
  50     private static NodeTemplateOperation operation;
  51
  52     @BeforeClass
  53     public static void setup() {
  54         init();
  55         titanDao = Mockito.mock(TitanDao.class);
  56         operation = new NodeTemplateOperation();
  57         operation.setTitanDao(titanDao);
  58         buildDataDefinition();
  59     }
  60
  61     private static void buildDataDefinition() {
  62         buildCapabiltyDataDefinition();
  63         buildRequirementDataDefinition();
  64         buildRelation();
  65     }
  66
  67     @Test
  68     public void testGetFulfilledCapabilityByRelationSuccess(){
  69         GraphVertex vertex = Mockito.mock(GraphVertex.class);
  70         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
  71         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
  72
  73         GraphVertex dataVertex = new GraphVertex();
  74         dataVertex.setJson(fulfilledCapability);
  75         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex);
  76         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
  77         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
  78         assertTrue(result.isLeft());
  79         assertEquals(result.left().value(), capability);
  80     }
  81
  82     @Test
  83     public void testGetFulfilledRequirementByRelationSuccess(){
  84         GraphVertex vertex = Mockito.mock(GraphVertex.class);
  85         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
  86         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
  87
  88         GraphVertex dataVertex = new GraphVertex();
  89         dataVertex.setJson(fulfilledRequirement);
  90         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex);
  91         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
  92         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
  93         assertTrue(result.isLeft());
  94         assertEquals(result.left().value(), requirement);
  95     }
  96
  97     @Test
  98     public void testGetFulfilledCapabilityByRelationNotFoundFailure(){
  99         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 100         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 101         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 102
 103         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
 104         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 105         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 106         assertTrue(result.isRight());
 107         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 108     }
 109
 110     @Test
 111     public void testGetFulfilledRequirementByRelationNotFoundFailure(){
 112         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 113         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 114         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 115
 116         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
 117         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 118         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 119         assertTrue(result.isRight());
 120         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 121     }
 122
 123     private static void buildRequirementDataDefinition() {
 124         buildRequirement();
 125         fulfilledRequirement = new HashMap<>();
 126         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 127         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 128         fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition);
 129
 130     }
 131
 132     private static void buildRequirement() {
 133         requirement = new RequirementDataDefinition();
 134         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 135         requirement.setUniqueId(REQUIREMENT_UID);
 136         requirement.setName(REQUIREMENT_NAME);
 137         requirement.setRelationship(RELATIONSHIP_TYPE);
 138     }
 139
 140     private static void buildCapabiltyDataDefinition() {
 141         buildCapability();
 142         fulfilledCapability = new HashMap<>();
 143         MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition();
 144         mapListCapabiltyDataDefinition.add(capability.getType(), capability);
 145         fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition);
 146     }
 147
 148     private static void buildCapability() {
 149         capability = new CapabilityDataDefinition();
 150         capability.setOwnerId(CAPABILITY_OWNER_ID);
 151         capability.setUniqueId(CAPABILITY_UID);
 152         capability.setName(CAPABILITY_NAME);
 153     }
 154
 155     private static void buildRelation() {
 156
 157         relation = new RequirementCapabilityRelDef();
 158         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 159         RelationshipInfo relationInfo = new RelationshipInfo();
 160         relationInfo.setId(RELATION_ID);
 161         relationship.setRelation(relationInfo);
 162
 163         relation.setRelationships(Lists.newArrayList(relationship));
 164         relation.setToNode(TO_INSTANCE_ID);
 165         relation.setFromNode(FROM_INSTANCE_ID);
 166
 167         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 168         relationInfo.setCapabilityUid(CAPABILITY_UID);
 169         relationInfo.setCapability(CAPABILITY_NAME);
 170         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 171         relationInfo.setRequirementUid(REQUIREMENT_UID);
 172         relationInfo.setRequirement(REQUIREMENT_NAME);
 173         RelationshipImpl relationshipImpl  = new RelationshipImpl();
 174         relationshipImpl.setType(RELATIONSHIP_TYPE);
 175         relationInfo.setRelationships(relationshipImpl);
 176     }
 177
 178     private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
 179         return  req.getRelationship().equals(relationshipInfo.getRelationship().getType()) &&
 180                 req.getName().equals(relationshipInfo.getRequirement()) &&
 181                 req.getUniqueId().equals(relationshipInfo.getRequirementUid()) &&
 182                 req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
 183     }
 184
 185     private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
 186         return     cap.getName().equals(relationshipInfo.getCapability()) &&
 187                 cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) &&
 188                 cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
 189         }
 190
 191         private NodeTemplateOperation createTestSubject() {
 192                 return operation;
 193         }
 194
 195
 196         @Test
 197         public void testGetDefaultHeatTimeout() throws Exception {
 198                 Integer result;
 199
 200                 // default test
 201                 result = NodeTemplateOperation.getDefaultHeatTimeout();
 202     }
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215         @Test
 216         public void testPrepareInstDeploymentArtifactPerInstance() throws Exception {
 217                 NodeTemplateOperation testSubject;
 218                 Map<String, ArtifactDataDefinition> deploymentArtifacts = null;
 219                 String componentInstanceId = "";
 220                 User user = null;
 221                 String envType = "";
 222                 MapArtifactDataDefinition result;
 223
 224                 // test 1
 225                 testSubject = createTestSubject();
 226                 deploymentArtifacts = null;
 227                 result = testSubject.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user,
 228                                 envType);
 229                 Assert.assertEquals(null, result);
 230         }
 231
 232
 233
 234         @Test
 235         public void testCreateCapPropertyKey() throws Exception {
 236                 String key = "";
 237                 String instanceId = "";
 238                 String result;
 239
 240                 // default test
 241                 result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
 242         }
 243
 244
 245         @Test
 246         public void testPrepareCalculatedCapabiltyForNodeType() throws Exception {
 247                 NodeTemplateOperation testSubject;
 248                 Map<String, ListCapabilityDataDefinition> capabilities = null;
 249                 ComponentInstanceDataDefinition componentInstance = null;
 250                 MapListCapabilityDataDefinition result;
 251
 252                 // test 1
 253                 testSubject = createTestSubject();
 254                 capabilities = null;
 255                 result = testSubject.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
 256                 Assert.assertEquals(null, result);
 257         }
 258
 259
 260         @Test
 261         public void testPrepareCalculatedRequirementForNodeType() throws Exception {
 262                 NodeTemplateOperation testSubject;
 263                 Map<String, ListRequirementDataDefinition> requirements = null;
 264                 ComponentInstanceDataDefinition componentInstance = null;
 265                 MapListRequirementDataDefinition result;
 266
 267                 // test 1
 268                 testSubject = createTestSubject();
 269                 requirements = null;
 270                 result = testSubject.prepareCalculatedRequirementForNodeType(requirements, componentInstance);
 271                 Assert.assertEquals(null, result);
 272         }
 273
 274
 275         @Test
 276         public void testAddGroupInstancesToComponentInstance() throws Exception {
 277                 NodeTemplateOperation testSubject;
 278                 Component containerComponent = null;
 279                 ComponentInstanceDataDefinition componentInstance = null;
 280                 List<GroupDefinition> groups = null;
 281                 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
 282                 StorageOperationStatus result;
 283
 284                 // test 1
 285                 testSubject = createTestSubject();
 286                 groupInstancesArtifacts = null;
 287                 result = testSubject.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
 288                                 groupInstancesArtifacts);
 289                 Assert.assertEquals(StorageOperationStatus.OK, result);
 290         }
 291
 292         @Test
 293         public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
 294                 NodeTemplateOperation testSubject;
 295                 String componentId = "";
 296                 String instanceId = "";
 297                 List<String> groupInstances = null;
 298                 StorageOperationStatus result;
 299
 300                 // test 1
 301                 testSubject = createTestSubject();
 302                 groupInstances = null;
 303                 result = testSubject.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
 304                 Assert.assertEquals(StorageOperationStatus.OK, result);
 305         }
 306
 307 }