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