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