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