gerrit.onap Code Review - sdc.git/blob

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