gerrit.onap Code Review - sdc.git/blob

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