gerrit.onap Code Review - sdc.git/blob

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