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