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