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