2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.model.operations.impl;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertNotNull;
25 import static org.junit.Assert.assertTrue;
27 import fj.data.Either;
28 import java.util.ArrayList;
29 import java.util.Collections;
30 import java.util.HashMap;
31 import java.util.List;
33 import java.util.Map.Entry;
34 import org.apache.commons.collections4.MapUtils;
35 import org.apache.commons.lang3.tuple.ImmutablePair;
36 import org.junit.jupiter.api.BeforeAll;
37 import org.junit.jupiter.api.BeforeEach;
38 import org.junit.jupiter.api.Test;
39 import org.mockito.InjectMocks;
40 import org.mockito.Mock;
41 import org.mockito.Mockito;
42 import org.mockito.MockitoAnnotations;
43 import org.mockito.Spy;
44 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
45 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
46 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
47 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
48 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
49 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
50 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
51 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
52 import org.openecomp.sdc.be.model.ModelTestBase;
53 import org.openecomp.sdc.be.model.PropertyConstraint;
54 import org.openecomp.sdc.be.model.PropertyDefinition;
55 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
56 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
57 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
58 import org.openecomp.sdc.be.model.tosca.ToscaType;
59 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
60 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
61 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
62 import org.openecomp.sdc.be.resources.data.ModelData;
63 import org.openecomp.sdc.be.resources.data.RelationshipTypeData;
64 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
66 @SpringJUnitConfig(locations = "classpath:application-context-test.xml")
67 public class RelationshipTypeOperationTest extends ModelTestBase {
69 private static final String PROP = "prop";
71 private static final String DOT = ".";
74 HealingJanusGraphGenericDao janusGraphGenericDao;
77 PropertyOperation propertyOperation;
80 DerivedFromOperation derivedFromOperation;
84 private RelationshipTypeOperation relationshipTypeOperation;
86 private RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
89 relationshipTypeDefinition.setDescription("desc1");
90 relationshipTypeDefinition.setType("tosca.relationships.Container1");
91 relationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
92 relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
93 relationshipTypeDefinition.setUniqueId("tosca.relationships.Container1");
97 public static void setupBeforeClass() {
102 public void setUp() throws Exception {
103 MockitoAnnotations.initMocks(this);
105 Mockito.doReturn(JanusGraphOperationStatus.OK).when(janusGraphGenericDao).commit();
106 Mockito.doReturn(JanusGraphOperationStatus.OK).when(janusGraphGenericDao).rollback();
110 public void testDummy() {
111 assertNotNull(relationshipTypeOperation);
115 public void testAddRelationshipTypeValidationFailStatusNullInTransactionFalse() {
116 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED))
117 .when(propertyOperation)
118 .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
120 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
121 .when(janusGraphGenericDao).getNode(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
123 Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
124 .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
126 Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType =
127 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, false);
129 assertTrue(addRelationshipType.isRight());
133 public void testAddRelationshipTypeValidationFailStatusPropertiesReturnedInTransactionFalse() {
134 Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
135 .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
136 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(propertyOperation)
137 .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
139 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
140 .when(janusGraphGenericDao).getNode(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
142 Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
143 .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
145 Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType =
146 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, false);
148 assertTrue(addRelationshipType.isRight());
152 public void testGetAllRelationshipTypesNotFound() {
153 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(
154 janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, null,
155 RelationshipTypeData.class);
156 Either<Map<String, RelationshipTypeDefinition>, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(null);
158 assertTrue(either.isLeft() && MapUtils.isEmpty(either.left().value()));
162 public void testGetAllRelationshipTypesNotConnnected() {
163 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED)).when(
164 janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, null,
165 RelationshipTypeData.class);
166 Either<Map<String, RelationshipTypeDefinition>, JanusGraphOperationStatus> either = relationshipTypeOperation.getAllRelationshipTypes(null);
168 assertTrue(either.isRight() && JanusGraphOperationStatus.NOT_CONNECTED == either.right().value());
172 public void testGetAllRelationshipTypesSuccess() {
173 List<RelationshipTypeData> relationshipTypeDataList = new ArrayList<>();
175 RelationshipTypeData relationshipTypeData1 = new RelationshipTypeData();
176 RelationshipInstDataDefinition relationshipInstDataDefinition1 = new RelationshipInstDataDefinition();
177 relationshipInstDataDefinition1.setUniqueId("tosca.relationships.Root1");
178 relationshipInstDataDefinition1.setType("tosca.relationships.Root1");
179 relationshipTypeData1.setRelationshipTypeDataDefinition(relationshipInstDataDefinition1);
181 relationshipTypeDataList.add(relationshipTypeData1);
183 Mockito.doReturn(Either.left(relationshipTypeDataList))
184 .when(janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, null,
185 RelationshipTypeData.class);
187 Mockito.doReturn(Either.left(relationshipTypeData1)).when(janusGraphGenericDao)
188 .getNode(Mockito.anyString(), Mockito.anyString(), Mockito.eq(RelationshipTypeData.class));
190 Mockito.doReturn(Either.left(createPropertyData("prop1"))).when(propertyOperation)
191 .findPropertiesOfNode(NodeTypeEnum.RelationshipType, "tosca.relationships.Root1");
193 RelationshipInstDataDefinition derivedFromRelationshipTypeDefinition = new RelationshipInstDataDefinition();
194 derivedFromRelationshipTypeDefinition.setUniqueId("tosca.relationships.Root1");
195 derivedFromRelationshipTypeDefinition.setType("tosca.relationships.Parent");
197 Mockito.doReturn(Either.left(new RelationshipTypeData(derivedFromRelationshipTypeDefinition)))
198 .when(derivedFromOperation)
199 .getDerivedFromChild("tosca.relationships.Root1", NodeTypeEnum.RelationshipType, RelationshipTypeData.class);
201 Either<Map<String, RelationshipTypeDefinition>, JanusGraphOperationStatus> either =
202 relationshipTypeOperation.getAllRelationshipTypes(null);
204 assertTrue(either.isLeft());
205 RelationshipTypeDefinition relationshipTypeDefinition = either.left().value().get("tosca.relationships.Root1");
206 assertEquals("tosca.relationships.Parent", relationshipTypeDefinition.getDerivedFrom());
208 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND))
209 .when(janusGraphGenericDao).getByCriteriaForModel(NodeTypeEnum.RelationshipType, null, "modelA",
210 RelationshipTypeData.class);
211 either = relationshipTypeOperation.getAllRelationshipTypes("modelA");
212 assertTrue(either.isLeft());
213 assertTrue(MapUtils.isEmpty(either.left().value()));
216 public RelationshipTypeDefinition createRelationship(String relationshipTypeName) {
218 RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
219 relationshipTypeDefinition.setDescription("desc1");
220 relationshipTypeDefinition.setType(relationshipTypeName);
222 Map<String, PropertyDefinition> properties = new HashMap<>();
224 String propName1 = "disk_size";
225 String propName2 = "num_cpus";
227 PropertyDefinition property1 = buildProperty1();
229 properties.put(propName1, property1);
231 PropertyDefinition property2 = buildProperty2();
233 properties.put(propName2, property2);
235 relationshipTypeDefinition.setProperties(properties);
237 Either<RelationshipTypeDefinition, StorageOperationStatus> addRelationshipType1 =
238 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
240 RelationshipTypeDefinition relationshipTypeDefinitionCreated = addRelationshipType1.left().value();
241 Either<RelationshipTypeDefinition, StorageOperationStatus> relationshipType =
242 relationshipTypeOperation.getRelationshipType(relationshipTypeDefinitionCreated.getUniqueId(), true);
243 assertTrue("check relationship type fetched", relationshipType.isLeft());
244 RelationshipTypeDefinition fetchedCTD = relationshipType.left().value();
246 Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
248 compareProperties(fetchedProps, properties);
254 private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
256 assertTrue("check properties are full or empty",
257 ((first == null && second == null) || (first != null && second != null)));
259 assertEquals("check properties size", first.size(), second.size());
261 for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
263 String propName = entry.getKey();
264 PropertyDefinition secondPD = second.get(propName);
265 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
267 PropertyDefinition firstPD = entry.getValue();
269 comparePropertyDefinition(firstPD, secondPD);
276 private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
278 assertTrue("check objects are full or empty",
279 ((first == null && second == null) || (first != null && second != null)));
281 assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
282 assertTrue("check property default value", compareValue((String) first.getDefaultValue(),
283 (String) second.getDefaultValue()));
284 assertTrue("check property type", compareValue(first.getType(), second.getType()));
285 compareList(first.getConstraints(), second.getConstraints());
290 private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
292 assertTrue("check lists are full or empty",
293 ((first == null && second == null) || (first != null && second != null)));
295 assertEquals("check list size", first.size(), second.size());
299 private PropertyDefinition buildProperty2() {
300 PropertyDefinition property2 = new PropertyDefinition();
301 property2.setDefaultValue("2");
302 property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
303 property2.setType(ToscaType.INTEGER.name().toLowerCase());
304 List<PropertyConstraint> constraints3 = new ArrayList<>();
305 List<String> range = new ArrayList<>();
308 InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
309 constraints3.add(propertyConstraint3);
310 property2.setConstraints(constraints3);
314 private PropertyDefinition buildProperty1() {
315 PropertyDefinition property1 = new PropertyDefinition();
316 property1.setDefaultValue("10");
317 property1.setDescription("Size of the local disk, in Gigabytes (GB), "
318 + "available to applications running on the Compute node.");
319 property1.setType(ToscaType.INTEGER.name().toLowerCase());
320 List<PropertyConstraint> constraints = new ArrayList<>();
321 GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
322 constraints.add(propertyConstraint1);
324 LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
325 constraints.add(propertyConstraint2);
327 property1.setConstraints(constraints);
331 private boolean compareValue(String first, String second) {
333 if (first == null && second == null) {
337 return first.equals(second);
343 public void setOperations(RelationshipTypeOperation relationshipTypeOperation) {
344 this.relationshipTypeOperation = relationshipTypeOperation;
348 public void testAddRelationshipType() {
350 RelationshipTypeData relationshipTypeData = new RelationshipTypeData();
351 RelationshipInstDataDefinition relationshipInstDataDefinition1 = new RelationshipInstDataDefinition();
352 relationshipInstDataDefinition1.setUniqueId("tosca.relationships.Root");
353 relationshipInstDataDefinition1.setType("tosca.relationships.Root");
354 relationshipTypeData.setRelationshipTypeDataDefinition(relationshipInstDataDefinition1);
356 RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition(relationshipTypeData);
357 relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
358 relationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
360 Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
361 .getAllTypePropertiesFromAllDerivedFrom(Mockito.anyString(), Mockito.any(), Mockito.any());
363 Mockito.doReturn(Either.left(new ArrayList<>(relationshipTypeDefinition.getProperties().values()))).when(propertyOperation)
364 .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
366 Mockito.doReturn(Either.left(relationshipTypeData)).when(janusGraphGenericDao)
367 .createNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
369 Mockito.doReturn(Either.left(new HashMap())).when(propertyOperation)
370 .addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
372 Mockito.doReturn(Either.left(relationshipTypeDefinition))
373 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
375 Mockito.doReturn(Either.left(new GraphRelation()))
376 .when(derivedFromOperation)
377 .addDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
379 Mockito.doReturn(Either.left(relationshipTypeDefinition))
380 .when(relationshipTypeOperation).getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
382 Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
383 .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
385 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
386 .getChild(Mockito.any(), Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
388 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
389 .when(janusGraphGenericDao).getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class), Mockito.any());
391 ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
392 ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
393 Mockito.doReturn(Either.left(pair))
394 .when(janusGraphGenericDao)
395 .getParentNode("uid", relationshipInstDataDefinition1.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
397 Either<RelationshipTypeDefinition, StorageOperationStatus> either =
398 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
400 assertTrue(either.isLeft());
404 public void testAddRelationshipTypeToModel() {
406 final String relationshipName = "tosca.relationships.MyRelationship";
407 final String derivedFromRelationshipName = "tosca.relationships.Root";
408 final String modelName = "modelA";
410 RelationshipTypeDefinition relationshipTypeDefinition = new RelationshipTypeDefinition();
411 relationshipTypeDefinition.setProperties(createPropertyData("prop1"));
412 relationshipTypeDefinition.setUniqueId(modelName + DOT + relationshipName);
413 relationshipTypeDefinition.setType(relationshipName);
414 relationshipTypeDefinition.setModel(modelName);
415 relationshipTypeDefinition.setDerivedFrom(derivedFromRelationshipName);
417 RelationshipTypeData derivedFromRelationshipTypeData = new RelationshipTypeData();
418 RelationshipInstDataDefinition dervideFromRelationshipInstDataDefinition = new RelationshipInstDataDefinition();
419 dervideFromRelationshipInstDataDefinition.setUniqueId("modelA.tosca.relationships.Root");
420 dervideFromRelationshipInstDataDefinition.setType("tosca.relationships.Root");
421 derivedFromRelationshipTypeData.setRelationshipTypeDataDefinition(dervideFromRelationshipInstDataDefinition);
423 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND))
424 .when(janusGraphGenericDao).getNode("uid", relationshipTypeDefinition.getUniqueId(), RelationshipTypeData.class);
426 Mockito.doReturn(Either.left(derivedFromRelationshipTypeData))
427 .when(janusGraphGenericDao).getNode("type", "tosca.relationships.Root", RelationshipTypeData.class, "modelA");
429 Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
430 .getAllTypePropertiesFromAllDerivedFrom(modelName + DOT + derivedFromRelationshipName, NodeTypeEnum.RelationshipType,
431 RelationshipTypeData.class);
433 Mockito.doReturn(Either.left(new ArrayList<>(relationshipTypeDefinition.getProperties().values()))).when(propertyOperation)
434 .validatePropertiesUniqueness(Mockito.any(), Mockito.any());
436 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition))).when(janusGraphGenericDao)
437 .createNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
439 Mockito.doReturn(Either.left(new HashMap())).when(propertyOperation)
440 .addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
442 Mockito.doReturn(Either.left(new GraphRelation())).when(janusGraphGenericDao)
443 .createRelation(Mockito.any(), Mockito.any(), Mockito.eq(GraphEdgeLabels.MODEL_ELEMENT), Mockito.any());
445 Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
446 .findPropertiesOfNode(NodeTypeEnum.RelationshipType, derivedFromRelationshipTypeData.getUniqueId());
448 Mockito.doReturn(Either.left(Collections.singletonMap("prop1", new PropertyDefinition()))).when(propertyOperation)
449 .findPropertiesOfNode(NodeTypeEnum.RelationshipType, relationshipTypeDefinition.getUniqueId());
451 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
452 .getChild("uid", derivedFromRelationshipTypeData.getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.RelationshipType,
453 RelationshipTypeData.class);
455 Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(relationshipTypeDefinition), null))).when(janusGraphGenericDao)
456 .getChild("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.RelationshipType,
457 RelationshipTypeData.class);
459 Mockito.doReturn(Either.left(new GraphRelation())).when(derivedFromOperation)
460 .addDerivedFromRelation(relationshipTypeDefinition.getUniqueId(), derivedFromRelationshipTypeData.getUniqueId(),
461 NodeTypeEnum.RelationshipType);
463 ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
464 ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
465 Mockito.doReturn(Either.left(pair))
466 .when(janusGraphGenericDao)
467 .getParentNode("uid", dervideFromRelationshipInstDataDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model,
470 Mockito.doReturn(Either.left(pair))
471 .when(janusGraphGenericDao)
472 .getParentNode("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
474 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
475 .when(janusGraphGenericDao).getNode("uid", relationshipTypeDefinition.getUniqueId(), RelationshipTypeData.class);
477 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
478 .when(janusGraphGenericDao).getNode("type", relationshipTypeDefinition.getUniqueId(), RelationshipTypeData.class, "modelA");
480 Either<RelationshipTypeDefinition, StorageOperationStatus> either =
481 relationshipTypeOperation.addRelationshipType(relationshipTypeDefinition, true);
483 assertTrue(either.isLeft());
487 public void testGetRelationshipTypeNotConnected() {
488 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_CONNECTED))
489 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
491 Either<RelationshipTypeDefinition, StorageOperationStatus> either =
492 relationshipTypeOperation.getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
494 assertTrue(either.isRight());
498 public void testGetRelationshipTypeSuccess() {
499 Mockito.doReturn(Either.left(relationshipTypeDefinition))
500 .when(relationshipTypeOperation).getRelationshipTypeByUid(Mockito.anyString());
502 Either<RelationshipTypeDefinition, StorageOperationStatus> either =
503 relationshipTypeOperation.getRelationshipType(Mockito.anyString(), Mockito.anyBoolean());
505 assertTrue(either.isLeft());
509 public void testUpdateRelationshipType() {
510 RelationshipTypeDefinition newRelationshipTypeDefinition = new RelationshipTypeDefinition();
511 newRelationshipTypeDefinition.setUniqueId("tosca.relationships.Container2");
512 newRelationshipTypeDefinition.setDescription("desc2");
513 newRelationshipTypeDefinition.setType("tosca.relationships.Container2");
514 newRelationshipTypeDefinition.setDerivedFrom("tosca.relationships.Root");
515 newRelationshipTypeDefinition.setProperties(createPropertyData("prop1"));
517 Mockito.doReturn(Either.left(new RelationshipTypeData(newRelationshipTypeDefinition))).when(
518 janusGraphGenericDao)
519 .updateNode(Mockito.any(), Mockito.eq(RelationshipTypeData.class));
521 Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties()))
522 .when(propertyOperation).deletePropertiesAssociatedToNode(Mockito.any(), Mockito.anyString());
524 Mockito.doReturn(Either.left(newRelationshipTypeDefinition.getProperties()))
525 .when(propertyOperation).addPropertiesToElementType(Mockito.anyString(), Mockito.any(), Mockito.anyMap());
527 Mockito.doReturn(Either.left(newRelationshipTypeDefinition)).when(relationshipTypeOperation)
528 .getRelationshipTypeByUid(Mockito.anyString());
530 Mockito.doReturn(StorageOperationStatus.OK).when(derivedFromOperation)
531 .removeDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
533 Mockito.doReturn(Either.left(new GraphRelation()))
534 .when(derivedFromOperation)
535 .addDerivedFromRelation(Mockito.anyString(), Mockito.anyString(), Mockito.any());
537 Mockito.doReturn(Either.left(new RelationshipTypeData(relationshipTypeDefinition)))
538 .when(janusGraphGenericDao).getNode(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
540 Mockito.doReturn(Either.left(Collections.singletonMap("derivedFromProp1", new PropertyDefinition()))).when(propertyOperation)
541 .findPropertiesOfNode(Mockito.any(), Mockito.anyString());
543 Mockito.doReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)).when(janusGraphGenericDao)
544 .getChild(Mockito.any(), Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
546 ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
547 ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
548 Mockito.doReturn(Either.left(pair))
549 .when(janusGraphGenericDao)
550 .getParentNode("uid", newRelationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
552 Either<RelationshipTypeDefinition, StorageOperationStatus> either =
553 relationshipTypeOperation.updateRelationshipType(relationshipTypeDefinition,
554 newRelationshipTypeDefinition, false);
556 assertTrue(either.isLeft());
560 public void testGetRelationshipTypeByUid() {
561 RelationshipTypeData relationshipTypeData = new RelationshipTypeData(relationshipTypeDefinition);
563 Mockito.doReturn(Either.left(relationshipTypeData)).when(janusGraphGenericDao)
564 .getNode(Mockito.anyString(), Mockito.any(), Mockito.eq(RelationshipTypeData.class));
566 Mockito.doReturn(Either.left(relationshipTypeDefinition.getProperties()))
567 .when(propertyOperation).findPropertiesOfNode(Mockito.any(), Mockito.anyString());
569 RelationshipTypeDefinition childRelationshipTypeDefinition = new RelationshipTypeDefinition();
570 childRelationshipTypeDefinition.setType("tosca.relationships.ContainerChild");
572 Mockito.doReturn(Either.left(new ImmutablePair(new RelationshipTypeData(childRelationshipTypeDefinition), null))).when(
573 janusGraphGenericDao)
574 .getChild(Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(),
575 Mockito.eq(RelationshipTypeData.class));
577 ModelData modelData = new ModelData("modelA", "modelA", ModelTypeEnum.NORMATIVE);
578 ImmutablePair<ModelData, GraphEdge> pair = new ImmutablePair<>(modelData, new GraphEdge());
579 Mockito.doReturn(Either.left(pair))
580 .when(janusGraphGenericDao)
581 .getParentNode("uid", relationshipTypeDefinition.getUniqueId(), GraphEdgeLabels.MODEL_ELEMENT, NodeTypeEnum.Model, ModelData.class);
583 Either<RelationshipTypeDefinition, JanusGraphOperationStatus> either =
584 relationshipTypeOperation.getRelationshipTypeByUid("tosca.relationships.Container1");
586 assertTrue(either.isLeft()
587 && "tosca.relationships.ContainerChild".equals(either.left().value().getDerivedFrom()));
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<>();
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;