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