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