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