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