catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/RelationshipTypeOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertNotNull;
  25 import static org.junit.Assert.assertTrue;
  26
  27 import fj.data.Either;
  28 import java.util.ArrayList;
  29 import java.util.Collections;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Map.Entry;
  34 import org.apache.commons.collections4.MapUtils;
  35 import org.apache.commons.lang3.tuple.ImmutablePair;
  36 import org.junit.jupiter.api.BeforeAll;
  37 import org.junit.jupiter.api.BeforeEach;
  38 import org.junit.jupiter.api.Test;
  39 import org.mockito.InjectMocks;
  40 import org.mockito.Mock;
  41 import org.mockito.Mockito;
  42 import org.mockito.MockitoAnnotations;
  43 import org.mockito.Spy;
  44 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  45 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  46 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
  47 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  48 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  49 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
  51 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  52 import org.openecomp.sdc.be.model.ModelTestBase;
  53 import org.openecomp.sdc.be.model.PropertyConstraint;
  54 import org.openecomp.sdc.be.model.PropertyDefinition;
  55 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
  56 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  57 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  58 import org.openecomp.sdc.be.model.tosca.ToscaType;
  59 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
  60 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
  61 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
  62 import org.openecomp.sdc.be.resources.data.ModelData;
  63 import org.openecomp.sdc.be.resources.data.RelationshipTypeData;
  64 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
  65
  66 @SpringJUnitConfig(locations = "classpath:application-context-test.xml")
  67 public class RelationshipTypeOperationTest extends ModelTestBase {
  68
  69     private static final String PROP = "prop";
  70
  71     private static final String DOT = ".";
  72
  73     @Mock
  74     HealingJanusGraphGenericDao janusGraphGenericDao;
  75
  76     @Mock
  77     PropertyOperation propertyOperation;
  78
  79     @Mock
  80     DerivedFromOperation derivedFromOperation;
  81
  82     @InjectMocks
  83     @Spy
  84     private RelationshipTypeOperation relationshipTypeOperation;
  85
  86     private RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
  87
  88     {
  89         relationshipTypeDefinition.setDescription("desc1");
  90         relationshipTypeDefinition.setType("tosca.relationships.Container1");
  91         relationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
  92         relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
  93         relationshipTypeDefinition.setUniqueId("tosca.relationships.Container1");
  94     }
  95
  96     @BeforeAll
  97     public static void setupBeforeClass() {
  98         ModelTestBase.init();
  99     }
 100
 101     @BeforeEach
 102     public void setUp() throws Exception {
 103         MockitoAnnotations.initMocks(this);
 104
 105         Mockito.doReturn(JanusGraphOperationStatus.OK).when(janusGraphGenericDao).commit();
 106         Mockito.doReturn(JanusGraphOperationStatus.OK).when(janusGraphGenericDao).rollback();
 107     }
 108
 109     @Test
 110     public void testDummy() {
 111         assertNotNull(relationshipTypeOperation);
 112     }
 113
 114     @Test
 115     public void testAddRelationshipTypeValidationFailStatusNullInTransactionFalse() {
 116         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED))
 117             .when(propertyOperation)
 118             .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
 119
 120         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
 121             .when(janusGraphGenericDao).getNode(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
 122
 123         Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
 124             .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
 125
 126         Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType =
 127             relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, false);
 128
 129         assertTrue(addRelationshipType.isRight());
 130     }
 131
 132     @Test
 133     public void testAddRelationshipTypeValidationFailStatusPropertiesReturnedInTransactionFalse() {
 134         Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
 135             .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
 136         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(propertyOperation)
 137             .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
 138
 139         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
 140             .when(janusGraphGenericDao).getNode(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
 141
 142         Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
 143             .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
 144
 145         Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType =
 146             relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, false);
 147
 148         assertTrue(addRelationshipType.isRight());
 149     }
 150
 151     @Test
 152     public void testGetAllRelationshipTypesNotFound() {
 153         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(
 154             janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, null,
 155             RelationshipTypeData.class);
 156         Either<Map<String, RelationshipTypeDefinition>, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(null);
 157
 158         assertTrue(either.isLeft() && MapUtils.isEmpty(either.left().value()));
 159     }
 160
 161     @Test
 162     public void testGetAllRelationshipTypesNotConnnected() {
 163         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED)).when(
 164             janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, null,
 165             RelationshipTypeData.class);
 166         Either<Map<String, RelationshipTypeDefinition>, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(null);
 167
 168         assertTrue(either.isRight() && JanusGraphOperationStatus.NOT_CONNECTED == either.right().value());
 169     }
 170
 171     @Test
 172     public void testGetAllRelationshipTypesSuccess() {
 173         List<RelationshipTypeData> relationshipTypeDataList = new ArrayList<>();
 174
 175         RelationshipTypeData relationshipTypeData1 = new RelationshipTypeData();
 176         RelationshipInstDataDefinition relationshipInstDataDefinition1 = new RelationshipInstDataDefinition();
 177         relationshipInstDataDefinition1.setUniqueId("tosca.relationships.Root1");
 178         relationshipInstDataDefinition1.setType("tosca.relationships.Root1");
 179         relationshipTypeData1.setRelationshipTypeDataDefinition(relationshipInstDataDefinition1);
 180
 181         relationshipTypeDataList.add(relationshipTypeData1);
 182
 183         Mockito.doReturn(Either.left(relationshipTypeDataList))
 184             .when(janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, null,
 185                 RelationshipTypeData.class);
 186
 187         Mockito.doReturn(Either.left(relationshipTypeData1)).when(janusGraphGenericDao)
 188             .getNode(Mockito.anyString(), Mockito.anyString(), Mockito.eq(RelationshipTypeData.class));
 189
 190         Mockito.doReturn(Either.left(createPropertyData("prop1"))).when(propertyOperation)
 191             .findPropertiesOfNode(NodeTypeEnum.RelationshipType, "tosca.relationships.Root1");
 192
 193         RelationshipInstDataDefinition derivedFromRelationshipTypeDefinition = new RelationshipInstDataDefinition();
 194         derivedFromRelationshipTypeDefinition.setUniqueId("tosca.relationships.Root1");
 195         derivedFromRelationshipTypeDefinition.setType("tosca.relationships.Parent");
 196
 197         Mockito.doReturn(Either.left(new RelationshipTypeData(derivedFromRelationshipTypeDefinition)))
 198             .when(derivedFromOperation)
 199             .getDerivedFromChild("tosca.relationships.Root1", NodeTypeEnum.RelationshipType, RelationshipTypeData.class);
 200
 201         Either<Map<String, RelationshipTypeDefinition>, JanusGraphOperationStatus> either =
 202             relationshipTypeOperation.getAllRelationshipTypes(null);
 203
 204         assertTrue(either.isLeft());
 205         RelationshipTypeDefinition relationshipTypeDefinition = either.left().value().get("tosca.relationships.Root1");
 206         assertEquals("tosca.relationships.Parent", relationshipTypeDefinition.getDerivedFrom());
 207
 208         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND))
 209             .when(janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, "modelA",
 210                 RelationshipTypeData.class);
 211         either = relationshipTypeOperation.getAllRelationshipTypes("modelA");
 212         assertTrue(either.isLeft());
 213         assertTrue(MapUtils.isEmpty(either.left().value()));
 214     }
 215
 216     public RelationshipTypeDefinition createRelationship(String relationshipTypeName) {
 217
 218         RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
 219         relationshipTypeDefinition.setDescription("desc1");
 220         relationshipTypeDefinition.setType(relationshipTypeName);
 221
 222         Map<String, PropertyDefinition> properties = new HashMap<>();
 223
 224         String propName1 = "disk_size";
 225         String propName2 = "num_cpus";
 226
 227         PropertyDefinition property1 = buildProperty1();
 228
 229         properties.put(propName1, property1);
 230
 231         PropertyDefinition property2 = buildProperty2();
 232
 233         properties.put(propName2, property2);
 234
 235         relationshipTypeDefinition.setProperties(properties);
 236
 237         Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType1 =
 238             relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
 239
 240         RelationshipTypeDefinition relationshipTypeDefinitionCreated = addRelationshipType1.left().value();
 241         Either<RelationshipTypeDefinition, StorageOperationStatus> relationshipType =
 242             relationshipTypeOperation.getRelationshipType(relationshipTypeDefinitionCreated.getUniqueId(), true);
 243         assertTrue("check relationship type fetched", relationshipType.isLeft());
 244         RelationshipTypeDefinition fetchedCTD = relationshipType.left().value();
 245
 246         Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 247
 248         compareProperties(fetchedProps, properties);
 249
 250         return fetchedCTD;
 251
 252     }
 253
 254     private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
 255
 256         assertTrue("check properties are full or empty",
 257             ((first == null && second == null) || (first != null && second != null)));
 258         if (first != null) {
 259             assertEquals("check properties size", first.size(), second.size());
 260
 261             for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
 262
 263                 String propName = entry.getKey();
 264                 PropertyDefinition secondPD = second.get(propName);
 265                 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
 266
 267                 PropertyDefinition firstPD = entry.getValue();
 268
 269                 comparePropertyDefinition(firstPD, secondPD);
 270             }
 271
 272         }
 273
 274     }
 275
 276     private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
 277
 278         assertTrue("check objects are full or empty",
 279             ((first == null && second == null) || (first != null && second != null)));
 280         if (first != null) {
 281             assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
 282             assertTrue("check property default value", compareValue((String) first.getDefaultValue(),
 283                 (String) second.getDefaultValue()));
 284             assertTrue("check property type", compareValue(first.getType(), second.getType()));
 285             compareList(first.getConstraints(), second.getConstraints());
 286         }
 287
 288     }
 289
 290     private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
 291
 292         assertTrue("check lists are full or empty",
 293             ((first == null && second == null) || (first != null && second != null)));
 294         if (first != null) {
 295             assertEquals("check list size", first.size(), second.size());
 296         }
 297     }
 298
 299     private PropertyDefinition buildProperty2() {
 300         PropertyDefinition property2 = new PropertyDefinition();
 301         property2.setDefaultValue("2");
 302         property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 303         property2.setType(ToscaType.INTEGER.name().toLowerCase());
 304         List<PropertyConstraint> constraints3 = new ArrayList<>();
 305         List<String> range = new ArrayList<>();
 306         range.add("4");
 307         range.add("1");
 308         InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 309         constraints3.add(propertyConstraint3);
 310         property2.setConstraints(constraints3);
 311         return property2;
 312     }
 313
 314     private PropertyDefinition buildProperty1() {
 315         PropertyDefinition property1 = new PropertyDefinition();
 316         property1.setDefaultValue("10");
 317         property1.setDescription("Size of the local disk, in Gigabytes (GB), "
 318             + "available to applications running on the Compute node.");
 319         property1.setType(ToscaType.INTEGER.name().toLowerCase());
 320         List<PropertyConstraint> constraints = new ArrayList<>();
 321         GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
 322         constraints.add(propertyConstraint1);
 323
 324         LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
 325         constraints.add(propertyConstraint2);
 326
 327         property1.setConstraints(constraints);
 328         return property1;
 329     }
 330
 331     private boolean compareValue(String first, String second) {
 332
 333         if (first == null && second == null) {
 334             return true;
 335         }
 336         if (first != null) {
 337             return first.equals(second);
 338         } else {
 339             return false;
 340         }
 341     }
 342
 343     public void setOperations(RelationshipTypeOperation relationshipTypeOperation) {
 344         this.relationshipTypeOperation = relationshipTypeOperation;
 345     }
 346
 347     @Test
 348     public void testAddRelationshipType() {
 349
 350         RelationshipTypeData relationshipTypeData = new RelationshipTypeData();
 351         RelationshipInstDataDefinition relationshipInstDataDefinition1 = new RelationshipInstDataDefinition();
 352         relationshipInstDataDefinition1.setUniqueId("tosca.relationships.Root");
 353         relationshipInstDataDefinition1.setType("tosca.relationships.Root");
 354         relationshipTypeData.setRelationshipTypeDataDefinition(relationshipInstDataDefinition1);
 355
 356         RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition(relationshipTypeData);
 357         relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
 358         relationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
 359
 360         Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
 361             .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
 362
 363         Mockito.doReturn(Either.left(new ArrayList<>(relationshipTypeDefinition.getProperties().values()))).when(propertyOperation)
 364             .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
 365
 366         Mockito.doReturn(Either.left(relationshipTypeData)).when(janusGraphGenericDao)
 367             .createNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 368
 369         Mockito.doReturn(Either.left(new HashMap())).when(propertyOperation)
 370             .addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
 371
 372         Mockito.doReturn(Either.left(relationshipTypeDefinition))
 373             .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 374
 375         Mockito.doReturn(Either.left(new GraphRelation()))
 376             .when(derivedFromOperation)
 377             .addDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
 378
 379         Mockito.doReturn(Either.left(relationshipTypeDefinition))
 380             .when(relationshipTypeOperation).getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
 381
 382         Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
 383             .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
 384
 385         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
 386             .getChild(Mockito.any(), Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 387
 388         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
 389             .when(janusGraphGenericDao).getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class), Mockito.any());
 390
 391         ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
 392         ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
 393         Mockito.doReturn(Either.left(pair))
 394             .when(janusGraphGenericDao)
 395             .getParentNode("uid", relationshipInstDataDefinition1.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
 396
 397         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 398             relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
 399
 400         assertTrue(either.isLeft());
 401     }
 402
 403     @Test
 404     public void testAddRelationshipTypeToModel() {
 405
 406         final String relationshipName = "tosca.relationships.MyRelationship";
 407         final String derivedFromRelationshipName = "tosca.relationships.Root";
 408         final String modelName = "modelA";
 409
 410         RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
 411         relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
 412         relationshipTypeDefinition.setUniqueId(modelName + DOT + relationshipName);
 413         relationshipTypeDefinition.setType(relationshipName);
 414         relationshipTypeDefinition.setModel(modelName);
 415         relationshipTypeDefinition.setDerivedFrom(derivedFromRelationshipName);
 416
 417         RelationshipTypeData derivedFromRelationshipTypeData = new RelationshipTypeData();
 418         RelationshipInstDataDefinition dervideFromRelationshipInstDataDefinition = new RelationshipInstDataDefinition();
 419         dervideFromRelationshipInstDataDefinition.setUniqueId("modelA.tosca.relationships.Root");
 420         dervideFromRelationshipInstDataDefinition.setType("tosca.relationships.Root");
 421         derivedFromRelationshipTypeData.setRelationshipTypeDataDefinition(dervideFromRelationshipInstDataDefinition);
 422
 423         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND))
 424             .when(janusGraphGenericDao).getNode("uid", relationshipTypeDefinition.getUniqueId(), RelationshipTypeData.class);
 425
 426         Mockito.doReturn(Either.left(derivedFromRelationshipTypeData))
 427             .when(janusGraphGenericDao).getNode("type", "tosca.relationships.Root", RelationshipTypeData.class, "modelA");
 428
 429         Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
 430             .getAllTypePropertiesFromAllDerivedFrom(modelName + DOT + derivedFromRelationshipName, NodeTypeEnum.RelationshipType,
 431                 RelationshipTypeData.class);
 432
 433         Mockito.doReturn(Either.left(new ArrayList<>(relationshipTypeDefinition.getProperties().values()))).when(propertyOperation)
 434             .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
 435
 436         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition))).when(janusGraphGenericDao)
 437             .createNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 438
 439         Mockito.doReturn(Either.left(new HashMap())).when(propertyOperation)
 440             .addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
 441
 442         Mockito.doReturn(Either.left(new GraphRelation())).when(janusGraphGenericDao)
 443             .createRelation(Mockito.any(), Mockito.any(), Mockito.eq(GraphEdgeLabels.MODEL_ELEMENT), Mockito.any());
 444
 445         Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
 446             .findPropertiesOfNode(NodeTypeEnum.RelationshipType, derivedFromRelationshipTypeData.getUniqueId());
 447
 448         Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
 449             .findPropertiesOfNode(NodeTypeEnum.RelationshipType, relationshipTypeDefinition.getUniqueId());
 450
 451         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
 452             .getChild("uid", derivedFromRelationshipTypeData.getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.RelationshipType,
 453                 RelationshipTypeData.class);
 454
 455         Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(relationshipTypeDefinition), null))).when(janusGraphGenericDao)
 456             .getChild("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.RelationshipType,
 457                 RelationshipTypeData.class);
 458
 459         Mockito.doReturn(Either.left(new GraphRelation())).when(derivedFromOperation)
 460             .addDerivedFromRelation(relationshipTypeDefinition.getUniqueId(), derivedFromRelationshipTypeData.getUniqueId(),
 461                 NodeTypeEnum.RelationshipType);
 462
 463         ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
 464         ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
 465         Mockito.doReturn(Either.left(pair))
 466             .when(janusGraphGenericDao)
 467             .getParentNode("uid", dervideFromRelationshipInstDataDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model,
 468                 ModelData.class);
 469
 470         Mockito.doReturn(Either.left(pair))
 471             .when(janusGraphGenericDao)
 472             .getParentNode("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
 473
 474         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
 475             .when(janusGraphGenericDao).getNode("uid", relationshipTypeDefinition.getUniqueId(), RelationshipTypeData.class);
 476
 477         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
 478             .when(janusGraphGenericDao).getNode("type", relationshipTypeDefinition.getUniqueId(), RelationshipTypeData.class, "modelA");
 479
 480         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 481             relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
 482
 483         assertTrue(either.isLeft());
 484     }
 485
 486     @Test
 487     public void testGetRelationshipTypeNotConnected() {
 488         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED))
 489             .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 490
 491         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 492             relationshipTypeOperation.getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
 493
 494         assertTrue(either.isRight());
 495     }
 496
 497     @Test
 498     public void testGetRelationshipTypeSuccess() {
 499         Mockito.doReturn(Either.left(relationshipTypeDefinition))
 500             .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
 501
 502         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 503             relationshipTypeOperation.getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
 504
 505         assertTrue(either.isLeft());
 506     }
 507
 508     @Test
 509     public void testUpdateRelationshipType() {
 510         RelationshipTypeDefinition newRelationshipTypeDefinition = new RelationshipTypeDefinition();
 511         newRelationshipTypeDefinition.setUniqueId("tosca.relationships.Container2");
 512         newRelationshipTypeDefinition.setDescription("desc2");
 513         newRelationshipTypeDefinition.setType("tosca.relationships.Container2");
 514         newRelationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
 515         newRelationshipTypeDefinition.setProperties(createPropertyData("prop1"));
 516
 517         Mockito.doReturn(Either.left(new RelationshipTypeData(newRelationshipTypeDefinition))).when(
 518                 janusGraphGenericDao)
 519             .updateNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 520
 521         Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties()))
 522             .when(propertyOperation).deletePropertiesAssociatedToNode(Mockito.any(), Mockito.anyString());
 523
 524         Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties()))
 525             .when(propertyOperation).addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
 526
 527         Mockito.doReturn(Either.left(newRelationshipTypeDefinition)).when(relationshipTypeOperation)
 528             .getRelationshipTypeByUid(Mockito.anyString());
 529
 530         Mockito.doReturn(StorageOperationStatus.OK).when(derivedFromOperation)
 531             .removeDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
 532
 533         Mockito.doReturn(Either.left(new GraphRelation()))
 534             .when(derivedFromOperation)
 535             .addDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
 536
 537         Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
 538             .when(janusGraphGenericDao).getNode(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
 539
 540         Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
 541             .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
 542
 543         Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
 544             .getChild(Mockito.any(), Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 545
 546         ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
 547         ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
 548         Mockito.doReturn(Either.left(pair))
 549             .when(janusGraphGenericDao)
 550             .getParentNode("uid", newRelationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
 551
 552         Either<RelationshipTypeDefinition, StorageOperationStatus> either =
 553             relationshipTypeOperation.updateRelationshipType(relationshipTypeDefinition,
 554                 newRelationshipTypeDefinition, false);
 555
 556         assertTrue(either.isLeft());
 557     }
 558
 559     @Test
 560     public void testGetRelationshipTypeByUid() {
 561         RelationshipTypeData relationshipTypeData = new RelationshipTypeData(relationshipTypeDefinition);
 562
 563         Mockito.doReturn(Either.left(relationshipTypeData)).when(janusGraphGenericDao)
 564             .getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
 565
 566         Mockito.doReturn(Either.left(relationshipTypeDefinition.getProperties()))
 567             .when(propertyOperation).findPropertiesOfNode(Mockito.any(), Mockito.anyString());
 568
 569         RelationshipTypeDefinition childRelationshipTypeDefinition = new RelationshipTypeDefinition();
 570         childRelationshipTypeDefinition.setType("tosca.relationships.ContainerChild");
 571
 572         Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(childRelationshipTypeDefinition), null))).when(
 573                 janusGraphGenericDao)
 574             .getChild(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(),
 575                 Mockito.eq(RelationshipTypeData.class));
 576
 577         ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
 578         ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
 579         Mockito.doReturn(Either.left(pair))
 580             .when(janusGraphGenericDao)
 581             .getParentNode("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
 582
 583         Either<RelationshipTypeDefinition, JanusGraphOperationStatus> either =
 584             relationshipTypeOperation.getRelationshipTypeByUid("tosca.relationships.Container1");
 585
 586         assertTrue(either.isLeft()
 587             && "tosca.relationships.ContainerChild".equals(either.left().value().getDerivedFrom()));
 588     }
 589
 590     private Map<String, PropertyDefinition> createPropertyData(String value) {
 591         PropertyDefinition propertyDefinition = new PropertyDefinition();
 592         propertyDefinition.setDefaultValue(value);
 593         propertyDefinition.setDescription(PROP + "_" + value);
 594         propertyDefinition.setType(ToscaType.INTEGER.name().toLowerCase());
 595         List<PropertyConstraint> constraints = new ArrayList<>();
 596         List<String> range = new ArrayList<>();
 597         range.add("1");
 598         range.add("4");
 599         InRangeConstraint propertyConstraint = new InRangeConstraint(range);
 600         constraints.add(propertyConstraint);
 601         propertyDefinition.setConstraints(constraints);
 602         Map<String, PropertyDefinition> propertiesMap = new HashMap<>();
 603         propertiesMap.put(PROP, propertyDefinition);
 604         return propertiesMap;
 605     }
 606
 607 }