catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/CapabilityTypeOperationTest.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 com.thinkaurelius.titan.core.TitanGraph;
  24 import com.thinkaurelius.titan.core.TitanVertex;
  25 import fj.data.Either;
  26 import org.apache.commons.lang3.tuple.ImmutablePair;
  27 import org.junit.Before;
  28 import org.junit.BeforeClass;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  32 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  33 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  34 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  35 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  36 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  37 import org.openecomp.sdc.be.model.ModelTestBase;
  38 import org.openecomp.sdc.be.model.PropertyConstraint;
  39 import org.openecomp.sdc.be.model.PropertyDefinition;
  40 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  41 import org.openecomp.sdc.be.model.tosca.ToscaType;
  42 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
  43 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
  44 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
  45 import org.openecomp.sdc.be.resources.data.CapabilityTypeData;
  46 import org.springframework.test.context.ContextConfiguration;
  47 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  48
  49 import javax.annotation.Resource;
  50 import java.util.*;
  51 import java.util.Map.Entry;
  52 import java.util.function.Function;
  53 import java.util.stream.Collectors;
  54 import java.util.stream.Stream;
  55
  56 import static org.assertj.core.api.Assertions.assertThat;
  57 import static org.junit.Assert.*;
  58 import static org.junit.Assert.assertTrue;
  59
  60 @RunWith(SpringJUnit4ClassRunner.class)
  61 @ContextConfiguration("classpath:application-context-test.xml")
  62 public class CapabilityTypeOperationTest extends ModelTestBase {
  63
  64     @Resource(name = "titan-generic-dao")
  65     private TitanGenericDao titanDao;
  66
  67     @Resource(name = "capability-type-operation")
  68     private CapabilityTypeOperation capabilityTypeOperation;
  69
  70     @BeforeClass
  71     public static void setupBeforeClass() {
  72         ModelTestBase.init();
  73     }
  74
  75     @Before
  76     public void cleanUp() {
  77         TitanGenericDao titanGenericDao = capabilityTypeOperation.titanGenericDao;
  78         Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
  79         TitanGraph graph = graphResult.left().value();
  80
  81         Iterable<TitanVertex> vertices = graph.query().vertices();
  82         if (vertices != null) {
  83             Iterator<TitanVertex> iterator = vertices.iterator();
  84             while (iterator.hasNext()) {
  85                 TitanVertex vertex = iterator.next();
  86                 vertex.remove();
  87             }
  88
  89         }
  90         titanGenericDao.commit();
  91     }
  92
  93     @Test
  94     public void testDummy() {
  95         assertNotNull(capabilityTypeOperation);
  96     }
  97
  98     @Test
  99     public void testAddCapabilityType() {
 100
 101         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 102         capabilityTypeDefinition.setDescription("desc1");
 103         capabilityTypeDefinition.setType("tosca.capabilities.Container1");
 104
 105         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 106         assertTrue("check capability type added", addCapabilityType1.isLeft());
 107
 108         CapabilityTypeDefinition capabilityTypeAdded = addCapabilityType1.left().value();
 109         compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
 110
 111         Either<CapabilityTypeDefinition, TitanOperationStatus> capabilityTypeByUid = capabilityTypeOperation.getCapabilityTypeByUid(capabilityTypeAdded.getUniqueId());
 112         compareBetweenCreatedToSent(capabilityTypeByUid.left().value(), capabilityTypeDefinition);
 113
 114         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType2 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 115         assertTrue("check capability type failed", addCapabilityType2.isRight());
 116         assertEquals("check returned error", StorageOperationStatus.SCHEMA_VIOLATION, addCapabilityType2.right().value());
 117
 118     }
 119
 120     @Test
 121     public void testAddDerviedCapabilityType() {
 122
 123         CapabilityTypeDefinition capabilityTypeDefinition = createCapabilityTypeDef("tosca.capabilities.Container2", "desc1", "derivedFrom");
 124
 125         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 126         assertEquals("check capability type parent not exist", StorageOperationStatus.NOT_FOUND, addCapabilityType1.right().value());
 127     }
 128
 129     public CapabilityTypeDefinition createCapability(String capabilityTypeName) {
 130
 131         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 132         capabilityTypeDefinition.setDescription("desc1");
 133         capabilityTypeDefinition.setType(capabilityTypeName);
 134
 135         Map<String, PropertyDefinition> properties = new HashMap<>();
 136
 137         String propName1 = "disk_size";
 138         String propName2 = "num_cpus";
 139
 140         PropertyDefinition property1 = buildProperty1();
 141
 142         properties.put(propName1, property1);
 143
 144         PropertyDefinition property2 = buildProperty2();
 145
 146         properties.put(propName2, property2);
 147
 148         capabilityTypeDefinition.setProperties(properties);
 149
 150         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 151
 152         CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 153         Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId(), true);
 154         assertTrue("check capability type fetched", capabilityType.isLeft());
 155         CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 156
 157         Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 158
 159         compareProperties(fetchedProps, properties);
 160
 161         return fetchedCTD;
 162
 163     }
 164
 165     @Test
 166     public void testAddCapabilityTypeWithProperties() {
 167
 168         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 169         capabilityTypeDefinition.setDescription("desc1");
 170         capabilityTypeDefinition.setType("tosca.capabilities.Container3");
 171
 172         Map<String, PropertyDefinition> properties = new HashMap<>();
 173
 174         String propName1 = "disk_size";
 175         String propName2 = "num_cpus";
 176
 177         PropertyDefinition property1 = buildProperty1();
 178
 179         properties.put(propName1, property1);
 180
 181         PropertyDefinition property2 = buildProperty2();
 182
 183         properties.put(propName2, property2);
 184
 185         capabilityTypeDefinition.setProperties(properties);
 186
 187         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 188
 189         CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 190         Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId());
 191         assertTrue("check capability type fetched", capabilityType.isLeft());
 192         CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 193
 194         Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 195
 196         compareProperties(fetchedProps, properties);
 197     }
 198
 199     private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
 200
 201         assertTrue("check properties are full or empty", ((first == null && second == null) || (first != null && second != null)));
 202         if (first != null) {
 203             assertEquals("check properties size", first.size(), second.size());
 204
 205             for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
 206
 207                 String propName = entry.getKey();
 208                 PropertyDefinition secondPD = second.get(propName);
 209                 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
 210
 211                 PropertyDefinition firstPD = entry.getValue();
 212
 213                 comparePropertyDefinition(firstPD, secondPD);
 214             }
 215
 216         }
 217
 218     }
 219
 220     @Test
 221     public void testGetCapabilityTypeNotFound() {
 222
 223         Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType("not_exists");
 224         assertEquals("check not found is returned", StorageOperationStatus.NOT_FOUND, capabilityType.right().value());
 225
 226     }
 227
 228
 229
 230     @Test
 231     public void updateCapabilityType_returnNotFoundErrorIfTryingToUpdateANonExistingType() {
 232         CapabilityTypeDefinition currType = createCapabilityTypeDef();
 233         CapabilityTypeDefinition updatedType = createCapabilityTypeDef();
 234         Either<CapabilityTypeDefinition, StorageOperationStatus> updateCapabilityTypeRes = capabilityTypeOperation.updateCapabilityType(updatedType, currType);
 235         assertThat(updateCapabilityTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 236     }
 237
 238     @Test
 239     public void updateCapabilityType_basicFields() {
 240         CapabilityTypeDefinition createdType = createCapabilityTypeDef("type1", "description1");
 241         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(createdType);
 242
 243         CapabilityTypeDefinition updatedType = createCapabilityTypeDef("type1", "description2");
 244         capabilityTypeOperation.updateCapabilityType(updatedType, currCapabilityType.left().value());
 245
 246         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(createdType.getType());
 247         CapabilityTypeDefinition fetchedCapabilityType = fetchedUpdatedType.left().value();
 248         assertThat(fetchedCapabilityType.getProperties()).isNullOrEmpty();
 249         assertThat(fetchedCapabilityType.getDerivedFrom()).isNullOrEmpty();
 250         assertEquals(fetchedCapabilityType.getCreationTime(), updatedType.getCreationTime());
 251         assertEquals(fetchedCapabilityType.getType(), updatedType.getType());
 252         assertEquals(fetchedCapabilityType.getDescription(), updatedType.getDescription());
 253         assertEquals(fetchedCapabilityType.getValidSourceTypes(), updatedType.getValidSourceTypes());
 254         assertEquals(fetchedCapabilityType.getVersion(), updatedType.getVersion());
 255     }
 256
 257     @Test
 258     public void updateCapabilityType_updatePropertiesFailedDueTypeChange() {
 259         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 260         CapabilityTypeDefinition capabilityType = createCapabilityTypeDef(asMap(prop1));
 261         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType);
 262
 263         PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "int");
 264         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 265         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef(asMap(updatedProp1, prop3));
 266
 267         Either<CapabilityTypeDefinition, StorageOperationStatus> updatedCapabilityTypeRes =
 268                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 269
 270         assertTrue(updatedCapabilityTypeRes.isRight());
 271         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updatedCapabilityTypeRes.right().value());
 272
 273         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(capabilityType.getType());
 274         assertEquals(fetchedUpdatedType.left().value().getProperties(), asMap(prop1));
 275
 276     }
 277
 278     @Test
 279     public void updateCapabilityType_updatePropertiesFailedDueDeletedProp() {
 280         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 281         CapabilityTypeDefinition capabilityType = createCapabilityTypeDef(asMap(prop1));
 282         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType);
 283
 284         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 285         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef(asMap(prop3));
 286
 287         Either<CapabilityTypeDefinition, StorageOperationStatus> updatedCapabilityTypeRes =
 288                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 289
 290         assertTrue(updatedCapabilityTypeRes.isRight());
 291         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updatedCapabilityTypeRes.right().value());
 292
 293         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(capabilityType.getType());
 294         assertEquals(fetchedUpdatedType.left().value().getProperties(), asMap(prop1));
 295
 296     }
 297
 298     @Test
 299     public void updateCapabilityType_updateProperties() {
 300         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 301         CapabilityTypeDefinition capabilityType = createCapabilityTypeDef(asMap(prop1));
 302         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType);
 303
 304         PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "string");
 305         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 306         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef(asMap(updatedProp1, prop3));
 307
 308         Either<CapabilityTypeDefinition, StorageOperationStatus> updatedCapabilityTypeRes =
 309                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 310         assertTrue(updatedCapabilityTypeRes.isLeft());
 311
 312         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(capabilityType.getType());
 313         assertEquals(fetchedUpdatedType.left().value().getProperties(), asMap(updatedProp1, prop3));
 314
 315     }
 316
 317     @Test
 318     public void updateCapabilityType_derivedFrom_whenNoPrevDerivedFrom_updateToNewDerivedFrom() {
 319         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 320         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr");
 321         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 322         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 323         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 324         capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 325
 326         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 327         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(rootCapabilityType.getType());
 328         verifyDerivedFromNodeEqualsToRootCapabilityType(rootCapabilityType, latestCapabilityType.left().value().getUniqueId());
 329     }
 330
 331     @Test
 332     public void updateCapabilityType_derivedFrom_updateToNullDerivedFrom_Failed() {
 333         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 334         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 335         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", null, new HashMap<>());
 336         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 337         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 338
 339         Either<CapabilityTypeDefinition, StorageOperationStatus> updateRes =
 340                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 341
 342         assertThat(updateRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 343
 344         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 345         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(rootCapabilityType.getType());
 346     }
 347
 348     @Test
 349     public void updateCapabilityType_updateDerivedFrom() {
 350         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 351         CapabilityTypeDefinition derivedType1 = createCapabilityTypeDef("derivedType1", "descr", rootCapabilityType.getType());
 352         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 353         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", derivedType1.getType());
 354
 355         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 356         capabilityTypeOperation.addCapabilityType(derivedType1);
 357         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 358
 359         capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 360
 361         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 362         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(derivedType1.getType());
 363         verifyDerivedFromNodeEqualsToRootCapabilityType(derivedType1, latestCapabilityType.left().value().getUniqueId());
 364     }
 365
 366     @Test
 367     public void updateCapabilityType_updateDerivedFrom_Failed_NewParentIsNotChildOfOldOne() {
 368         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 369         CapabilityTypeDefinition notDerivedType = createCapabilityTypeDef("derivedType1", "descr");
 370         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 371         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", notDerivedType.getType());
 372
 373         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 374         capabilityTypeOperation.addCapabilityType(notDerivedType);
 375         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 376
 377         Either<CapabilityTypeDefinition, StorageOperationStatus> result = capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 378         assertThat(result.right().value()).isEqualTo(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY);
 379
 380         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 381         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(rootCapabilityType.getType());
 382         verifyDerivedFromNodeEqualsToRootCapabilityType(rootCapabilityType, latestCapabilityType.left().value().getUniqueId());
 383     }
 384
 385     private CapabilityTypeDefinition createCapabilityTypeDef() {
 386         return createCapabilityTypeDef("tosca.capabilities.Root", "The TOSCA root Capability Type all other TOSCA base Capability Types derived from", null, new HashMap<>());
 387     }
 388
 389     private CapabilityTypeDefinition createCapabilityTypeDef(Map<String, PropertyDefinition> properties) {
 390         return createCapabilityTypeDef("tosca.capabilities.Root",
 391                 "The TOSCA root Capability Type all other TOSCA base Capability Types derived from", null, properties);
 392     }
 393
 394     private CapabilityTypeDefinition createCapabilityTypeDef(String type, String description) {
 395         return createCapabilityTypeDef(type, description, null, null);
 396     }
 397
 398     private CapabilityTypeDefinition createCapabilityTypeDef(String type, String description, String derivedFrom) {
 399         return createCapabilityTypeDef(type, description, derivedFrom, null);
 400     }
 401
 402
 403     private CapabilityTypeDefinition createCapabilityTypeDef(String type, String description, String derivedFrom,  Map<String, PropertyDefinition> properties) {
 404         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 405         capabilityTypeDefinition.setDescription(description);
 406         capabilityTypeDefinition.setType(type);
 407         capabilityTypeDefinition.setDerivedFrom(derivedFrom);
 408         capabilityTypeDefinition.setVersion("1.0");
 409         capabilityTypeDefinition.setValidSourceTypes(null);
 410         if (properties != null) {
 411             capabilityTypeDefinition.setProperties(properties);
 412         }
 413         return capabilityTypeDefinition;
 414     }
 415
 416     private PropertyDefinition duplicateProperty(PropertyDefinition prop1, String updatedValue, String updatedType) {
 417         PropertyDefinition updatedProp1 = new PropertyDefinition(prop1);
 418         updatedProp1.setDefaultValue(updatedValue);
 419         updatedProp1.setType(updatedType);
 420         return updatedProp1;
 421     }
 422
 423     private static Map<String, PropertyDefinition> asMap(PropertyDefinition ... props) {
 424         return Stream.of(props).collect(Collectors.toMap(PropertyDefinition::getName, Function.identity()));
 425     }
 426
 427     private void verifyDerivedFromNodeEqualsToRootCapabilityType(CapabilityTypeDefinition rootCapabilityType, String parentCapabilityId) {
 428         Either<ImmutablePair<CapabilityTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), parentCapabilityId, GraphEdgeLabels.DERIVED_FROM,
 429                 NodeTypeEnum.CapabilityType, CapabilityTypeData.class);
 430         assertThat(derivedFromRelation.left().value().getLeft().getCapabilityTypeDataDefinition())
 431                 .isEqualToComparingFieldByField(rootCapabilityType);
 432     }
 433
 434
 435     private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
 436
 437         assertTrue("check objects are full or empty", ((first == null && second == null) || (first != null && second != null)));
 438         if (first != null) {
 439             assertTrue("check property default value", compareValue(first.getDefaultValue(), second.getDefaultValue()));
 440             assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
 441             assertTrue("check property type", compareValue(first.getType(), second.getType()));
 442             compareList(first.getConstraints(), second.getConstraints());
 443         }
 444
 445     }
 446
 447     private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
 448
 449         assertTrue("check lists are full or empty", ((first == null && second == null) || (first != null && second != null)));
 450         if (first != null) {
 451             assertEquals("check list size", first.size(), second.size());
 452         }
 453     }
 454
 455     private PropertyDefinition buildProperty2() {
 456         PropertyDefinition property2 = new PropertyDefinition();
 457         property2.setDefaultValue("2");
 458         property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 459         property2.setType(ToscaType.INTEGER.name().toLowerCase());
 460         List<PropertyConstraint> constraints3 = new ArrayList<>();
 461         List<String> range = new ArrayList<>();
 462         range.add("1");
 463         range.add("4");
 464
 465         InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 466         constraints3.add(propertyConstraint3);
 467         // property2.setConstraints(constraints3);
 468         property2.setConstraints(constraints3);
 469         return property2;
 470     }
 471
 472     private PropertyDefinition buildProperty1() {
 473         PropertyDefinition property1 = new PropertyDefinition();
 474         property1.setDefaultValue("10");
 475         property1.setDescription("Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
 476         property1.setType(ToscaType.INTEGER.name().toLowerCase());
 477         List<PropertyConstraint> constraints = new ArrayList<>();
 478         GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
 479         constraints.add(propertyConstraint1);
 480
 481         LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
 482         constraints.add(propertyConstraint2);
 483
 484         property1.setConstraints(constraints);
 485         return property1;
 486     }
 487
 488     private void compareBetweenCreatedToSent(CapabilityTypeDefinition x, CapabilityTypeDefinition y) {
 489         assertTrue(compareValue(x.getDerivedFrom(), y.getDerivedFrom()));
 490         assertTrue(compareValue(x.getType(), y.getType()));
 491         assertTrue(compareValue(x.getDescription(), y.getDescription()));
 492
 493     }
 494
 495     private boolean compareValue(String first, String second) {
 496
 497         if (first == null && second == null) {
 498             return true;
 499         }
 500         if (first != null) {
 501             return first.equals(second);
 502         } else {
 503             return false;
 504         }
 505     }
 506 }