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.ArrayList;
  52 import java.util.HashMap;
  53 import java.util.List;
  54 import java.util.Map;
  55
  56 import static org.junit.Assert.assertEquals;
  57 import static org.junit.Assert.assertSame;
  58 import static org.junit.Assert.assertTrue;
  59 import static org.mockito.ArgumentMatchers.eq;
  60 import static org.mockito.Mockito.when;
  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, MapListCapabilityDataDefinition> 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), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 110         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 111         assertTrue(result.isLeft());
 112         assertEquals(result.left().value(), capability);
 113     }
 114
 115     @Test
 116     public void testGetFulfilledRequirementByRelationSuccess(){
 117         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 118         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 119         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 120
 121         GraphVertex dataVertex = new GraphVertex();
 122         dataVertex.setJson(fulfilledRequirement);
 123         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex);
 124         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 125         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 126         assertTrue(result.isLeft());
 127         assertEquals(result.left().value(), requirement);
 128     }
 129
 130     @Test
 131     public void testGetFulfilledCapabilityByRelationNotFoundFailure(){
 132         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 133         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 134         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 135
 136         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
 137         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 138         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 139         assertTrue(result.isRight());
 140         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 141     }
 142
 143     @Test
 144     public void testGetFulfilledRequirementByRelationNotFoundFailure(){
 145         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 146         Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex);
 147         when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 148
 149         Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
 150         when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 151         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 152         assertTrue(result.isRight());
 153         assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
 154     }
 155
 156     private static void buildRequirementDataDefinition() {
 157         buildRequirement();
 158         fulfilledRequirement = new HashMap<>();
 159         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 160         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 161         fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition);
 162
 163     }
 164
 165     private static void buildRequirement() {
 166         requirement = new RequirementDataDefinition();
 167         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 168         requirement.setUniqueId(REQUIREMENT_UID);
 169         requirement.setName(REQUIREMENT_NAME);
 170         requirement.setRelationship(RELATIONSHIP_TYPE);
 171     }
 172
 173     private static void buildCapabiltyDataDefinition() {
 174         buildCapability();
 175         fulfilledCapability = new HashMap<>();
 176         MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition();
 177         mapListCapabiltyDataDefinition.add(capability.getType(), capability);
 178         fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition);
 179     }
 180
 181     private static void buildCapability() {
 182         capability = new CapabilityDataDefinition();
 183         capability.setOwnerId(CAPABILITY_OWNER_ID);
 184         capability.setUniqueId(CAPABILITY_UID);
 185         capability.setName(CAPABILITY_NAME);
 186     }
 187
 188     private static void buildRelation() {
 189
 190         relation = new RequirementCapabilityRelDef();
 191         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 192         RelationshipInfo relationInfo = new RelationshipInfo();
 193         relationInfo.setId(RELATION_ID);
 194         relationship.setRelation(relationInfo);
 195
 196         relation.setRelationships(Lists.newArrayList(relationship));
 197         relation.setToNode(TO_INSTANCE_ID);
 198         relation.setFromNode(FROM_INSTANCE_ID);
 199
 200         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 201         relationInfo.setCapabilityUid(CAPABILITY_UID);
 202         relationInfo.setCapability(CAPABILITY_NAME);
 203         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 204         relationInfo.setRequirementUid(REQUIREMENT_UID);
 205         relationInfo.setRequirement(REQUIREMENT_NAME);
 206         RelationshipImpl relationshipImpl  = new RelationshipImpl();
 207         relationshipImpl.setType(RELATIONSHIP_TYPE);
 208         relationInfo.setRelationships(relationshipImpl);
 209     }
 210
 211     private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
 212         return  req.getRelationship().equals(relationshipInfo.getRelationship().getType()) &&
 213                 req.getName().equals(relationshipInfo.getRequirement()) &&
 214                 req.getUniqueId().equals(relationshipInfo.getRequirementUid()) &&
 215                 req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
 216     }
 217
 218     private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
 219         return     cap.getName().equals(relationshipInfo.getCapability()) &&
 220                 cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) &&
 221                 cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
 222         }
 223
 224         private NodeTemplateOperation createTestSubject() {
 225                 return operation;
 226         }
 227
 228         @Test
 229         public void testGetDefaultHeatTimeout() {
 230                 Integer result;
 231
 232                 // default test
 233                 result = NodeTemplateOperation.getDefaultHeatTimeout();
 234     }
 235
 236         @Test
 237     public void testPrepareInstDeploymentArtifactPerInstance() {
 238         NodeTemplateOperation testSubject;
 239         Map<String, Object> deploymentResourceArtifacts = new HashMap<>();
 240         Map<String, ArtifactDataDefinition> deploymentArtifacts = new HashMap<>();
 241         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 242         artifactDataDefinition.setArtifactType("HEAT");
 243         artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 244         deploymentArtifacts.put("1", artifactDataDefinition);
 245         deploymentResourceArtifacts.put("1", artifactDataDefinition);
 246         String componentInstanceId = "componentInstanceId";
 247         User user = new User();
 248         user.setUserId("userId");
 249         user.setFirstName("first");
 250         user.setLastName("last");
 251         String envType = "VfHeatEnv";
 252         MapArtifactDataDefinition result;
 253
 254         testSubject = createTestSubject();
 255
 256         result = testSubject.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user,
 257                 envType);
 258         Assert.assertEquals(2, result.getMapToscaDataDefinition().size());
 259     }
 260
 261
 262
 263         @Test
 264         public void testCreateCapPropertyKey() throws Exception {
 265                 String key = "";
 266                 String instanceId = "";
 267                 String result;
 268
 269                 // default test
 270                 result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
 271         }
 272
 273
 274         @Test
 275         public void testPrepareCalculatedCapabiltyForNodeType() {
 276         NodeTemplateOperation testSubject;
 277         Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
 278         ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition();
 279         List<CapabilityDataDefinition> listToscaDataDefinition = new ArrayList<>();
 280         CapabilityDataDefinition capabilityDataDefinition = new CapabilityDefinition();
 281         capabilityDataDefinition.setMaxOccurrences("1");
 282         listToscaDataDefinition.add(capabilityDataDefinition);
 283         listCapDataDefinition.setListToscaDataDefinition(listToscaDataDefinition);
 284         capabilities.put("1", listCapDataDefinition);
 285         ComponentInstance componentInstance = createCompInstance();
 286         MapListCapabilityDataDefinition result;
 287
 288         // test 1
 289         testSubject = createTestSubject();
 290         result = testSubject.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
 291         Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
 292         }
 293
 294
 295     @Test
 296     public void testPrepareCalculatedReqForNodeType() {
 297         NodeTemplateOperation testSubject;
 298         Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
 299         ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition();
 300         List<RequirementDataDefinition> listToscaDataDefinition = new ArrayList<>();
 301         RequirementDataDefinition reqDataDefinition = new RequirementDataDefinition();
 302         reqDataDefinition.setMaxOccurrences("1");
 303         listToscaDataDefinition.add(reqDataDefinition);
 304         listReqDataDef.setListToscaDataDefinition(listToscaDataDefinition);
 305         requirements.put("1", listReqDataDef);
 306         ComponentInstance componentInstance = createCompInstance();
 307         MapListRequirementDataDefinition result;
 308
 309         // test 1
 310         testSubject = createTestSubject();
 311         result = testSubject.prepareCalculatedRequirementForNodeType(requirements, componentInstance);
 312         Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
 313     }
 314
 315         @Test
 316         public void testAddGroupInstancesToComponentInstance() throws Exception {
 317                 NodeTemplateOperation testSubject;
 318                 Component containerComponent = null;
 319                 ComponentInstanceDataDefinition componentInstance = null;
 320                 List<GroupDefinition> groups = null;
 321                 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
 322                 StorageOperationStatus result;
 323
 324                 // test 1
 325                 testSubject = createTestSubject();
 326                 groupInstancesArtifacts = null;
 327                 result = testSubject.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
 328                                 groupInstancesArtifacts);
 329                 Assert.assertEquals(StorageOperationStatus.OK, result);
 330         }
 331
 332         @Test
 333         public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
 334                 NodeTemplateOperation testSubject;
 335                 String componentId = "";
 336                 String instanceId = "";
 337                 List<String> groupInstances = null;
 338                 StorageOperationStatus result;
 339
 340                 // test 1
 341                 testSubject = createTestSubject();
 342                 groupInstances = null;
 343                 result = testSubject.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
 344                 Assert.assertEquals(StorageOperationStatus.OK, result);
 345         }
 346
 347     private ComponentInstance createCompInstance() {
 348         ComponentInstance componentInstance = new ComponentInstance();
 349         String id = "id";
 350         componentInstance.setComponentUid(id);
 351         componentInstance.setUniqueId(id);
 352         componentInstance.setName(id);
 353         return componentInstance;
 354     }
 355 }