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.assertTrue;
  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", StorageOperationStatus.NOT_FOUND, addCapabilityType1.right().value());
 134     }
 135
 136     public CapabilityTypeDefinition createCapability(String capabilityTypeName) {
 137
 138         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 139         capabilityTypeDefinition.setDescription("desc1");
 140         capabilityTypeDefinition.setType(capabilityTypeName);
 141
 142         Map<String, PropertyDefinition> properties = new HashMap<>();
 143
 144         String propName1 = "disk_size";
 145         String propName2 = "num_cpus";
 146
 147         PropertyDefinition property1 = buildProperty1();
 148
 149         properties.put(propName1, property1);
 150
 151         PropertyDefinition property2 = buildProperty2();
 152
 153         properties.put(propName2, property2);
 154
 155         capabilityTypeDefinition.setProperties(properties);
 156
 157         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 158
 159         CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 160         Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId(), true);
 161         assertTrue("check capability type fetched", capabilityType.isLeft());
 162         CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 163
 164         Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 165
 166         compareProperties(fetchedProps, properties);
 167
 168         return fetchedCTD;
 169
 170     }
 171
 172     @Test
 173     public void testAddCapabilityTypeWithProperties() {
 174
 175         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 176         capabilityTypeDefinition.setDescription("desc1");
 177         capabilityTypeDefinition.setType("tosca.capabilities.Container3");
 178
 179         Map<String, PropertyDefinition> properties = new HashMap<>();
 180
 181         String propName1 = "disk_size";
 182         String propName2 = "num_cpus";
 183
 184         PropertyDefinition property1 = buildProperty1();
 185
 186         properties.put(propName1, property1);
 187
 188         PropertyDefinition property2 = buildProperty2();
 189
 190         properties.put(propName2, property2);
 191
 192         capabilityTypeDefinition.setProperties(properties);
 193
 194         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityType1 = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 195
 196         CapabilityTypeDefinition capabilityTypeDefinitionCreated = addCapabilityType1.left().value();
 197         Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType(capabilityTypeDefinitionCreated.getUniqueId());
 198         assertTrue("check capability type fetched", capabilityType.isLeft());
 199         CapabilityTypeDefinition fetchedCTD = capabilityType.left().value();
 200
 201         Map<String, PropertyDefinition> fetchedProps = fetchedCTD.getProperties();
 202
 203         compareProperties(fetchedProps, properties);
 204     }
 205
 206     private void compareProperties(Map<String, PropertyDefinition> first, Map<String, PropertyDefinition> second) {
 207
 208         assertTrue("check properties are full or empty", ((first == null && second == null) || (first != null && second != null)));
 209         if (first != null) {
 210             assertEquals("check properties size", first.size(), second.size());
 211
 212             for (Entry<String, PropertyDefinition> entry : first.entrySet()) {
 213
 214                 String propName = entry.getKey();
 215                 PropertyDefinition secondPD = second.get(propName);
 216                 assertNotNull("Cannot find property " + propName + " in " + second, secondPD);
 217
 218                 PropertyDefinition firstPD = entry.getValue();
 219
 220                 comparePropertyDefinition(firstPD, secondPD);
 221             }
 222
 223         }
 224
 225     }
 226
 227     @Test
 228     public void testGetCapabilityTypeNotFound() {
 229
 230         Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityType = capabilityTypeOperation.getCapabilityType("not_exists");
 231         assertEquals("check not found is returned", StorageOperationStatus.NOT_FOUND, capabilityType.right().value());
 232
 233     }
 234
 235
 236
 237     @Test
 238     public void updateCapabilityType_returnNotFoundErrorIfTryingToUpdateANonExistingType() {
 239         CapabilityTypeDefinition currType = createCapabilityTypeDef();
 240         CapabilityTypeDefinition updatedType = createCapabilityTypeDef();
 241         Either<CapabilityTypeDefinition, StorageOperationStatus> updateCapabilityTypeRes = capabilityTypeOperation.updateCapabilityType(updatedType, currType);
 242         assertThat(updateCapabilityTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 243     }
 244
 245     @Test
 246     public void updateCapabilityType_basicFields() {
 247         CapabilityTypeDefinition createdType = createCapabilityTypeDef("type1", "description1");
 248         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(createdType);
 249
 250         CapabilityTypeDefinition updatedType = createCapabilityTypeDef("type1", "description2");
 251         capabilityTypeOperation.updateCapabilityType(updatedType, currCapabilityType.left().value());
 252
 253         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(createdType.getType());
 254         CapabilityTypeDefinition fetchedCapabilityType = fetchedUpdatedType.left().value();
 255         assertThat(fetchedCapabilityType.getProperties()).isNullOrEmpty();
 256         assertThat(fetchedCapabilityType.getDerivedFrom()).isNullOrEmpty();
 257         assertEquals(fetchedCapabilityType.getCreationTime(), updatedType.getCreationTime());
 258         assertEquals(fetchedCapabilityType.getType(), updatedType.getType());
 259         assertEquals(fetchedCapabilityType.getDescription(), updatedType.getDescription());
 260         assertEquals(fetchedCapabilityType.getValidSourceTypes(), updatedType.getValidSourceTypes());
 261         assertEquals(fetchedCapabilityType.getVersion(), updatedType.getVersion());
 262     }
 263
 264     @Test
 265     public void updateCapabilityType_updatePropertiesFailedDueTypeChange() {
 266         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 267         CapabilityTypeDefinition capabilityType = createCapabilityTypeDef(asMap(prop1));
 268         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType);
 269
 270         PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "int");
 271         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 272         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef(asMap(updatedProp1, prop3));
 273
 274         Either<CapabilityTypeDefinition, StorageOperationStatus> updatedCapabilityTypeRes =
 275                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 276
 277         assertTrue(updatedCapabilityTypeRes.isRight());
 278         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updatedCapabilityTypeRes.right().value());
 279
 280         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(capabilityType.getType());
 281         assertEquals(fetchedUpdatedType.left().value().getProperties(), asMap(prop1));
 282
 283     }
 284
 285     @Test
 286     public void updateCapabilityType_updatePropertiesFailedDueDeletedProp() {
 287         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 288         CapabilityTypeDefinition capabilityType = createCapabilityTypeDef(asMap(prop1));
 289         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType);
 290
 291         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 292         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef(asMap(prop3));
 293
 294         Either<CapabilityTypeDefinition, StorageOperationStatus> updatedCapabilityTypeRes =
 295                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 296
 297         assertTrue(updatedCapabilityTypeRes.isRight());
 298         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updatedCapabilityTypeRes.right().value());
 299
 300         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(capabilityType.getType());
 301         assertEquals(fetchedUpdatedType.left().value().getProperties(), asMap(prop1));
 302
 303     }
 304
 305     @Test
 306     public void updateCapabilityType_updateProperties() {
 307         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 308         CapabilityTypeDefinition capabilityType = createCapabilityTypeDef(asMap(prop1));
 309         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType);
 310
 311         PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "string");
 312         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 313         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef(asMap(updatedProp1, prop3));
 314
 315         Either<CapabilityTypeDefinition, StorageOperationStatus> updatedCapabilityTypeRes =
 316                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 317         assertTrue(updatedCapabilityTypeRes.isLeft());
 318
 319         Either<CapabilityTypeDefinition, StorageOperationStatus> fetchedUpdatedType = capabilityTypeOperation.getCapabilityType(capabilityType.getType());
 320         assertEquals(fetchedUpdatedType.left().value().getProperties(), asMap(updatedProp1, prop3));
 321
 322     }
 323
 324     @Test
 325     public void updateCapabilityType_derivedFrom_whenNoPrevDerivedFrom_updateToNewDerivedFrom() {
 326         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 327         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr");
 328         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 329         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 330         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 331         capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 332
 333         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 334         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(rootCapabilityType.getType());
 335         verifyDerivedFromNodeEqualsToRootCapabilityType(rootCapabilityType, latestCapabilityType.left().value().getUniqueId());
 336     }
 337
 338     @Test
 339     public void updateCapabilityType_derivedFrom_updateToNullDerivedFrom_Failed() {
 340         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 341         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 342         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", null, new HashMap<>());
 343         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 344         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 345
 346         Either<CapabilityTypeDefinition, StorageOperationStatus> updateRes =
 347                 capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 348
 349         assertThat(updateRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 350
 351         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 352         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(rootCapabilityType.getType());
 353     }
 354
 355     @Test
 356     public void updateCapabilityType_updateDerivedFrom() {
 357         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 358         CapabilityTypeDefinition derivedType1 = createCapabilityTypeDef("derivedType1", "descr", rootCapabilityType.getType());
 359         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 360         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", derivedType1.getType());
 361
 362         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 363         capabilityTypeOperation.addCapabilityType(derivedType1);
 364         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 365
 366         capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 367
 368         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 369         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(derivedType1.getType());
 370         verifyDerivedFromNodeEqualsToRootCapabilityType(derivedType1, latestCapabilityType.left().value().getUniqueId());
 371     }
 372
 373     @Test
 374     public void updateCapabilityType_updateDerivedFrom_Failed_NewParentIsNotChildOfOldOne() {
 375         CapabilityTypeDefinition rootCapabilityType = createCapabilityTypeDef();
 376         CapabilityTypeDefinition notDerivedType = createCapabilityTypeDef("derivedType1", "descr");
 377         CapabilityTypeDefinition capabilityType1 = createCapabilityTypeDef("type1", "descr", rootCapabilityType.getType());
 378         CapabilityTypeDefinition updatedCapabilityType = createCapabilityTypeDef("type1", "descr", notDerivedType.getType());
 379
 380         capabilityTypeOperation.addCapabilityType(rootCapabilityType);
 381         capabilityTypeOperation.addCapabilityType(notDerivedType);
 382         Either<CapabilityTypeDefinition, StorageOperationStatus> currCapabilityType = capabilityTypeOperation.addCapabilityType(capabilityType1);
 383
 384         Either<CapabilityTypeDefinition, StorageOperationStatus> result = capabilityTypeOperation.updateCapabilityType(updatedCapabilityType, currCapabilityType.left().value());
 385         assertThat(result.right().value()).isEqualTo(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY);
 386
 387         Either<CapabilityTypeDefinition, StorageOperationStatus> latestCapabilityType = capabilityTypeOperation.getCapabilityType(capabilityType1.getType());
 388         assertThat(latestCapabilityType.left().value().getDerivedFrom()).isEqualTo(rootCapabilityType.getType());
 389         verifyDerivedFromNodeEqualsToRootCapabilityType(rootCapabilityType, latestCapabilityType.left().value().getUniqueId());
 390     }
 391
 392     private CapabilityTypeDefinition createCapabilityTypeDef() {
 393         return createCapabilityTypeDef("tosca.capabilities.Root", "The TOSCA root Capability Type all other TOSCA base Capability Types derived from", null, new HashMap<>());
 394     }
 395
 396     private CapabilityTypeDefinition createCapabilityTypeDef(Map<String, PropertyDefinition> properties) {
 397         return createCapabilityTypeDef("tosca.capabilities.Root",
 398                 "The TOSCA root Capability Type all other TOSCA base Capability Types derived from", null, properties);
 399     }
 400
 401     private CapabilityTypeDefinition createCapabilityTypeDef(String type, String description) {
 402         return createCapabilityTypeDef(type, description, null, null);
 403     }
 404
 405     private CapabilityTypeDefinition createCapabilityTypeDef(String type, String description, String derivedFrom) {
 406         return createCapabilityTypeDef(type, description, derivedFrom, null);
 407     }
 408
 409
 410     private CapabilityTypeDefinition createCapabilityTypeDef(String type, String description, String derivedFrom,  Map<String, PropertyDefinition> properties) {
 411         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 412         capabilityTypeDefinition.setDescription(description);
 413         capabilityTypeDefinition.setType(type);
 414         capabilityTypeDefinition.setDerivedFrom(derivedFrom);
 415         capabilityTypeDefinition.setVersion("1.0");
 416         capabilityTypeDefinition.setValidSourceTypes(null);
 417         if (properties != null) {
 418             capabilityTypeDefinition.setProperties(properties);
 419         }
 420         return capabilityTypeDefinition;
 421     }
 422
 423     private PropertyDefinition duplicateProperty(PropertyDefinition prop1, String updatedValue, String updatedType) {
 424         PropertyDefinition updatedProp1 = new PropertyDefinition(prop1);
 425         updatedProp1.setDefaultValue(updatedValue);
 426         updatedProp1.setType(updatedType);
 427         return updatedProp1;
 428     }
 429
 430     private static Map<String, PropertyDefinition> asMap(PropertyDefinition ... props) {
 431         return Stream.of(props).collect(Collectors.toMap(PropertyDefinition::getName, Function.identity()));
 432     }
 433
 434     private void verifyDerivedFromNodeEqualsToRootCapabilityType(CapabilityTypeDefinition rootCapabilityType, String parentCapabilityId) {
 435         Either<ImmutablePair<CapabilityTypeData, GraphEdge>, JanusGraphOperationStatus> derivedFromRelation = janusGraphDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityType), parentCapabilityId, GraphEdgeLabels.DERIVED_FROM,
 436                 NodeTypeEnum.CapabilityType, CapabilityTypeData.class);
 437         assertThat(derivedFromRelation.left().value().getLeft().getCapabilityTypeDataDefinition())
 438                 .isEqualToComparingFieldByField(rootCapabilityType);
 439     }
 440
 441
 442     private void comparePropertyDefinition(PropertyDefinition first, PropertyDefinition second) {
 443
 444         assertTrue("check objects are full or empty", ((first == null && second == null) || (first != null && second != null)));
 445         if (first != null) {
 446             assertTrue("check property default value", compareValue(first.getDefaultValue(), second.getDefaultValue()));
 447             assertTrue("check property description", compareValue(first.getDescription(), second.getDescription()));
 448             assertTrue("check property type", compareValue(first.getType(), second.getType()));
 449             compareList(first.getConstraints(), second.getConstraints());
 450         }
 451
 452     }
 453
 454     private void compareList(List<PropertyConstraint> first, List<PropertyConstraint> second) {
 455
 456         assertTrue("check lists are full or empty", ((first == null && second == null) || (first != null && second != null)));
 457         if (first != null) {
 458             assertEquals("check list size", first.size(), second.size());
 459         }
 460     }
 461
 462     private PropertyDefinition buildProperty2() {
 463         PropertyDefinition property2 = new PropertyDefinition();
 464         property2.setDefaultValue("2");
 465         property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 466         property2.setType(ToscaType.INTEGER.name().toLowerCase());
 467         List<PropertyConstraint> constraints3 = new ArrayList<>();
 468         List<String> range = new ArrayList<>();
 469         range.add("1");
 470         range.add("4");
 471
 472         InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 473         constraints3.add(propertyConstraint3);
 474         // property2.setConstraints(constraints3);
 475         property2.setConstraints(constraints3);
 476         return property2;
 477     }
 478
 479     private PropertyDefinition buildProperty1() {
 480         PropertyDefinition property1 = new PropertyDefinition();
 481         property1.setDefaultValue("10");
 482         property1.setDescription("Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
 483         property1.setType(ToscaType.INTEGER.name().toLowerCase());
 484         List<PropertyConstraint> constraints = new ArrayList<>();
 485         GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
 486         constraints.add(propertyConstraint1);
 487
 488         LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
 489         constraints.add(propertyConstraint2);
 490
 491         property1.setConstraints(constraints);
 492         return property1;
 493     }
 494
 495     private void compareBetweenCreatedToSent(CapabilityTypeDefinition x, CapabilityTypeDefinition y) {
 496         assertTrue(compareValue(x.getDerivedFrom(), y.getDerivedFrom()));
 497         assertTrue(compareValue(x.getType(), y.getType()));
 498         assertTrue(compareValue(x.getDescription(), y.getDescription()));
 499
 500     }
 501
 502     private boolean compareValue(String first, String second) {
 503
 504         if (first == null && second == null) {
 505             return true;
 506         }
 507         if (first != null) {
 508             return first.equals(second);
 509         } else {
 510             return false;
 511         }
 512     }
 513 }