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