catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java

   1 package org.openecomp.sdc.be.model.operations.impl;
   2
   3 import com.thinkaurelius.titan.core.TitanGraph;
   4 import com.thinkaurelius.titan.core.TitanVertex;
   5 import fj.data.Either;
   6 import org.apache.commons.lang3.tuple.ImmutablePair;
   7 import org.apache.tinkerpop.gremlin.structure.Edge;
   8 import org.junit.After;
   9 import org.junit.BeforeClass;
  10 import org.junit.Test;
  11 import org.junit.runner.RunWith;
  12 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  13 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  14 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  15 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  16 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  17 import org.openecomp.sdc.be.datatypes.elements.GroupTypeDataDefinition;
  18 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  19 import org.openecomp.sdc.be.model.*;
  20 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  21 import org.openecomp.sdc.be.model.tosca.ToscaType;
  22 import org.openecomp.sdc.be.resources.data.CapabilityTypeData;
  23 import org.openecomp.sdc.be.resources.data.GroupTypeData;
  24 import org.springframework.test.context.ContextConfiguration;
  25 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  26
  27 import javax.annotation.Resource;
  28 import java.util.HashMap;
  29 import java.util.Iterator;
  30 import java.util.List;
  31 import java.util.Map;
  32
  33 import static com.google.common.collect.Sets.newHashSet;
  34 import static java.util.Arrays.asList;
  35 import static java.util.Collections.singletonList;
  36 import static org.assertj.core.api.Assertions.assertThat;
  37 import static org.junit.Assert.*;
  38
  39 @RunWith(SpringJUnit4ClassRunner.class)
  40 @ContextConfiguration("classpath:application-context-test.xml")
  41 public class GroupTypeOperationTest extends ModelTestBase {
  42
  43     private static final String TOSCA_GROUPS_ROOT = "tosca.groups.Root";
  44     private static final String NULL_STRING = null;
  45
  46     @Resource(name = "titan-generic-dao")
  47     private TitanGenericDao titanDao;
  48
  49     @Resource(name = "capability-type-operation")
  50     private CapabilityTypeOperation capabilityTypeOperation;
  51
  52     @Resource(name = "group-type-operation")
  53     private GroupTypeOperation groupTypeOperation;
  54
  55     @BeforeClass
  56     public static void setupBeforeClass() {
  57         ModelTestBase.init();
  58     }
  59
  60     @After
  61     public void tearDown() {
  62         titanDao.rollback();
  63         cleanUp();
  64     }
  65
  66     @Test
  67     public void getAllGroupTypes() {
  68         GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
  69         GroupTypeDefinition type1 = createGroupType("type1");
  70         GroupTypeDefinition type2 = createGroupType("type2");
  71         groupTypeOperation.addGroupType(rootGroupDefinition);
  72         groupTypeOperation.addGroupType(type1);
  73         groupTypeOperation.addGroupType(type2);
  74
  75         List<GroupTypeDefinition> allGroupTypesNoExclusion = groupTypeOperation.getAllGroupTypes(null);
  76         assertThat(allGroupTypesNoExclusion)
  77                 .usingElementComparatorOnFields("type", "icon", "name")
  78                 .containsExactlyInAnyOrder(rootGroupDefinition, type1, type2);
  79     }
  80
  81     @Test
  82     public void getAllGroupTypes_whenPassingExclusionList_doNotReturnExcludedTypes() {
  83         GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
  84         GroupTypeDefinition type1 = createGroupType("type1");
  85         GroupTypeDefinition type2 = createGroupType("type2");
  86         groupTypeOperation.addGroupType(rootGroupDefinition);
  87         groupTypeOperation.addGroupType(type1);
  88         groupTypeOperation.addGroupType(type2);
  89
  90         List<GroupTypeDefinition> allGroupTypes = groupTypeOperation.getAllGroupTypes(newHashSet("type1", "type2"));
  91         assertThat(allGroupTypes)
  92                 .usingElementComparatorOnFields("type")
  93                 .containsExactly(rootGroupDefinition);
  94     }
  95
  96     @Test
  97     public void groupTypeWithoutCapabilityCreated() {
  98         GroupTypeData rootNode = getOrCreateRootGroupTypeNode();
  99
 100         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 101         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 102         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 103         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 104         groupTypeDefinition.setVersion("1.0");
 105
 106         List<PropertyDefinition> properties = asList(
 107                 buildProperty("network_collection_type", "l3-network", "network collection type, defined with default value"),
 108                 buildProperty("network_collection_subtype", "sub-interface", "network collection subtype, defined with default value"),
 109                 buildProperty("network_collection_role", null, "network collection role"),
 110                 buildProperty("network_collection_description", null, "network collection description, free format text"));
 111
 112         groupTypeDefinition.setProperties(properties );
 113
 114         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 115         assertTrue("check group type added", addGroupTypeResult.isLeft());
 116         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 117
 118         addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.NetworkCollection", "1.0");
 119         assertTrue("check group type added", addGroupTypeResult.isLeft());
 120         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 121
 122         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
 123         GroupTypeData groupTypeNode = extractVal(groupTypeResult);
 124
 125         Either<Edge, TitanOperationStatus> edgeResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM);
 126         validate(edgeResult);
 127     }
 128
 129     @Test
 130     public void groupTypeWithCapabilityAndPropsButCapTypeWithoutProps() {
 131         getOrCreateRootGroupTypeNode();
 132
 133         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(null);
 134         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 135         extractVal(capabilityTypeResult);
 136
 137         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 138         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 139         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 140         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 141
 142         Map<String, CapabilityDefinition> mapCapabilities = new HashMap<>();
 143
 144         ComponentInstanceProperty property = new ComponentInstanceProperty(
 145                 buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance"));
 146         CapabilityDefinition capabilityDef = buildCapabilityDefintion(asList(property));
 147         mapCapabilities.put("vlan_assignment", capabilityDef);
 148         groupTypeDefinition.setCapabilities(mapCapabilities);
 149
 150
 151         List<PropertyDefinition> properties = asList(
 152                 buildProperty("vfc_instance_group_role", null, "role of this VFC group"),
 153                 buildProperty("vfc_parent_port_role", null, "common role of parent ports of VFCs in this group"),
 154                 buildProperty("network_collection_role", null, "network collection role assigned to this group"),
 155                 buildProperty("subinterface_role", null, "common role of subinterfaces of VFCs in this group, criteria the group is created"));
 156
 157         groupTypeDefinition.setProperties(properties );
 158
 159         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 160         assertTrue(addGroupTypeResult.isRight());
 161         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, addGroupTypeResult.right().value());
 162     }
 163
 164     @Test
 165     public void groupTypeWithCapabilityTypeAndEdgeCreated() {
 166         GroupTypeData rootNode = getOrCreateRootGroupTypeNode();
 167
 168         Map<String, PropertyDefinition> capTypeProperties = new HashMap<>();
 169         capTypeProperties.put("vfc_instance_group_reference",
 170                 buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance"));
 171
 172         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties);
 173         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 174         extractVal(capabilityTypeResult);
 175
 176         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 177         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 178         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 179         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 180
 181         Map<String, CapabilityDefinition> mapCapabilities = new HashMap<>();
 182         ComponentInstanceProperty property = new ComponentInstanceProperty(
 183                 buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance"));
 184         CapabilityDefinition capabilityDef = buildCapabilityDefintion(asList(property));
 185         mapCapabilities.put("vlan_assignment", capabilityDef);
 186         groupTypeDefinition.setCapabilities(mapCapabilities);
 187
 188
 189         List<PropertyDefinition> properties = asList(
 190                 buildProperty("vfc_instance_group_role", null, "role of this VFC group"),
 191                 buildProperty("vfc_parent_port_role", null, "common role of parent ports of VFCs in this group"),
 192                 buildProperty("network_collection_role", null, "network collection role assigned to this group"),
 193                 buildProperty("subinterface_role", null, "common role of subinterfaces of VFCs in this group, criteria the group is created"));
 194
 195         groupTypeDefinition.setProperties(properties );
 196
 197         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 198         assertTrue("check group type added", addGroupTypeResult.isLeft());
 199         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 200
 201         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
 202         GroupTypeData groupTypeNode = extractVal(groupTypeResult);
 203
 204         Either<GroupTypeDefinition, StorageOperationStatus> groupTypeDefResult = groupTypeOperation.getGroupTypeByUid(groupTypeNode.getUniqueId());
 205         assertTrue(groupTypeDefResult.isLeft());
 206         GroupTypeDefinition groupTypeDefinitionRetrieved = groupTypeDefResult.left().value();
 207         assertNotNull(groupTypeDefinitionRetrieved);
 208         Map<String, CapabilityDefinition> capabilityDefs = groupTypeDefinitionRetrieved.getCapabilities();
 209         assertNotNull(capabilityDefs);
 210         assertEquals(1, capabilityDefs.size());
 211         assertTrue(capabilityDefs.containsKey("vlan_assignment"));
 212         CapabilityDefinition updatedCapabilityDef = capabilityDefs.get("vlan_assignment");
 213         assertEquals(2, updatedCapabilityDef.getProperties().size());
 214
 215         Either<Edge, TitanOperationStatus> edgeDerivedFromResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM);
 216         validate(edgeDerivedFromResult);
 217     }
 218
 219     @Test
 220     public void groupTypeWithCapabilityTypeAndEdgeCreated_OverrideDefaultCapabilityTypeValue() {
 221         getOrCreateRootGroupTypeNode();
 222
 223         PropertyDefinition property = buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance");
 224
 225         Map<String, PropertyDefinition> capTypeProperties = new HashMap<>();
 226         capTypeProperties.put("vfc_instance_group_reference", property);
 227         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties);
 228         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 229         extractVal(capabilityTypeResult);
 230
 231         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 232         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 233         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 234         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 235
 236         Map<String, CapabilityDefinition> mapCapabilities = new HashMap<>();
 237         property.setValue("new_value");
 238         ComponentInstanceProperty capDefProperty = new ComponentInstanceProperty(property);
 239         CapabilityDefinition capabilityDef = buildCapabilityDefintion(asList(capDefProperty));
 240         mapCapabilities.put("vlan_assignment", capabilityDef);
 241         groupTypeDefinition.setCapabilities(mapCapabilities);
 242
 243
 244         List<PropertyDefinition> properties = asList(
 245                 buildProperty("vfc_instance_group_role", null, "role of this VFC group"),
 246                 buildProperty("vfc_parent_port_role", null, "common role of parent ports of VFCs in this group"),
 247                 buildProperty("network_collection_role", null, "network collection role assigned to this group"),
 248                 buildProperty("subinterface_role", null, "common role of subinterfaces of VFCs in this group, criteria the group is created"));
 249
 250         groupTypeDefinition.setProperties(properties );
 251
 252         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 253         assertTrue("check group type added", addGroupTypeResult.isLeft());
 254         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 255
 256         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
 257         GroupTypeData groupTypeNode = extractVal(groupTypeResult);
 258
 259         Either<GroupTypeDefinition, StorageOperationStatus> groupTypeDefResult = groupTypeOperation.getGroupTypeByUid(groupTypeNode.getUniqueId());
 260         assertTrue(groupTypeDefResult.isLeft());
 261         GroupTypeDefinition groupTypeDefinitionRetrieved = groupTypeDefResult.left().value();
 262         assertNotNull(groupTypeDefinitionRetrieved);
 263         Map<String, CapabilityDefinition> capabilityDefs = groupTypeDefinitionRetrieved.getCapabilities();
 264         assertNotNull(capabilityDefs);
 265         assertEquals(1, capabilityDefs.size());
 266         assertTrue(capabilityDefs.containsKey("vlan_assignment"));
 267
 268         CapabilityDefinition capDefinition = capabilityDefs.get("vlan_assignment");
 269         assertEquals("new_value", capDefinition.getProperties().get(0).getValue());
 270         assertEquals(2, capDefinition.getProperties().size());
 271     }
 272
 273
 274     @Test
 275     public void updateGroupTypeWithCapability_FailedDueToCapabilityDeleteAttempt() {
 276         createRootGroupTypeNode();
 277
 278         PropertyDefinition property = buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance");
 279
 280         Map<String, PropertyDefinition> capTypeProperties = new HashMap<>();
 281         capTypeProperties.put("vfc_instance_group_reference", property);
 282         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties);
 283         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 284         extractVal(capabilityTypeResult);
 285
 286         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 287         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 288         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 289         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 290
 291         Map<String, CapabilityDefinition> mapCapabilities = new HashMap<>();
 292         property.setValue("new_value");
 293         ComponentInstanceProperty capDefProperty = new ComponentInstanceProperty(property);
 294         CapabilityDefinition capabilityDef = buildCapabilityDefintion(asList(capDefProperty));
 295         mapCapabilities.put("vlan_assignment", capabilityDef);
 296         groupTypeDefinition.setCapabilities(mapCapabilities);
 297
 298         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition);
 299         assertTrue(addGroupTypeResult.isLeft());
 300
 301         GroupTypeDefinition newGroupTypeDefinition = new GroupTypeDefinition();
 302         newGroupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 303         newGroupTypeDefinition.setDescription("groups l3-networks in network collection");
 304         newGroupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 305         Either<GroupTypeDefinition, StorageOperationStatus> updateGroupTypeResult =  groupTypeOperation.updateGroupType(newGroupTypeDefinition, addGroupTypeResult.left().value());
 306         assertTrue(updateGroupTypeResult.isRight());
 307         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updateGroupTypeResult.right().value());
 308     }
 309
 310     @Test
 311     public void updateGroupTypeWithCapability_FailedDueToCapabilityChangeTypeAttempt() {
 312         createRootGroupTypeNode();
 313
 314         PropertyDefinition property = buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance");
 315
 316         Map<String, PropertyDefinition> capTypeProperties = new HashMap<>();
 317         capTypeProperties.put("vfc_instance_group_reference", property);
 318         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties);
 319         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 320         extractVal(capabilityTypeResult);
 321
 322         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 323         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 324         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 325         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 326
 327         Map<String, CapabilityDefinition> mapCapabilities = new HashMap<>();
 328         property.setValue("new_value");
 329         ComponentInstanceProperty capDefProperty = new ComponentInstanceProperty(property);
 330         CapabilityDefinition capabilityDef = buildCapabilityDefintion(asList(capDefProperty));
 331         mapCapabilities.put("vlan_assignment", capabilityDef);
 332         groupTypeDefinition.setCapabilities(mapCapabilities);
 333
 334         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition);
 335         assertTrue(addGroupTypeResult.isLeft());
 336
 337         GroupTypeDefinition newGroupTypeDefinition = new GroupTypeDefinition();
 338         newGroupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 339         newGroupTypeDefinition.setDescription("groups l3-networks in network collection");
 340         newGroupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 341
 342         Map<String, CapabilityDefinition> updatedMapCapabilities = new HashMap<>();
 343         property.setValue("new_value");
 344         ComponentInstanceProperty newCapDefProperty = new ComponentInstanceProperty(property);
 345         CapabilityDefinition updatedCapabilityDef = buildCapabilityDefintion(asList(newCapDefProperty));
 346         updatedCapabilityDef.setType("Another type");
 347         updatedMapCapabilities.put("vlan_assignment", updatedCapabilityDef);
 348         newGroupTypeDefinition.setCapabilities(updatedMapCapabilities);
 349
 350         Either<GroupTypeDefinition, StorageOperationStatus> updateGroupTypeResult =  groupTypeOperation.updateGroupType(newGroupTypeDefinition,  addGroupTypeResult.left().value());
 351         assertTrue(updateGroupTypeResult.isRight());
 352         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updateGroupTypeResult.right().value());
 353     }
 354
 355     @Test
 356     public void updateGroupTypeWithCapability_Success() {
 357         createRootGroupTypeNode();
 358
 359         PropertyDefinition property = buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance");
 360
 361         Map<String, PropertyDefinition> capTypeProperties = new HashMap<>();
 362         capTypeProperties.put("vfc_instance_group_reference", property);
 363         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(capTypeProperties);
 364         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 365         extractVal(capabilityTypeResult);
 366
 367         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 368         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 369         groupTypeDefinition.setDescription("groups l3-networks in network collection");
 370         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 371
 372         Map<String, CapabilityDefinition> mapCapabilities = new HashMap<>();
 373         property.setValue("new_value");
 374         ComponentInstanceProperty capDefProperty = new ComponentInstanceProperty(property);
 375         CapabilityDefinition capabilityDef = buildCapabilityDefintion(asList(capDefProperty));
 376         mapCapabilities.put("vlan_assignment", capabilityDef);
 377         groupTypeDefinition.setCapabilities(mapCapabilities);
 378
 379         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition);
 380         assertTrue(addGroupTypeResult.isLeft());
 381
 382         GroupTypeDefinition newGroupTypeDefinition = new GroupTypeDefinition();
 383         newGroupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 384         newGroupTypeDefinition.setDescription("groups l3-networks in network collection");
 385         newGroupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
 386
 387         Map<String, CapabilityDefinition> updatedMapCapabilities = new HashMap<>();
 388         property.setValue("another_value");
 389         ComponentInstanceProperty newCapDefProperty = new ComponentInstanceProperty(property);
 390         CapabilityDefinition updatedCapabilityDef = buildCapabilityDefintion(asList(newCapDefProperty));
 391         updatedMapCapabilities.put("vlan_assignment", updatedCapabilityDef);
 392         newGroupTypeDefinition.setCapabilities(updatedMapCapabilities);
 393
 394         Either<GroupTypeDefinition, StorageOperationStatus> updateGroupTypeResult =  groupTypeOperation.updateGroupType(newGroupTypeDefinition,  addGroupTypeResult.left().value());
 395         assertTrue(updateGroupTypeResult.isLeft());
 396     }
 397
 398     @Test
 399     public void testUpdateGroupTypeWithDerivedFromEdge() {
 400         createRootGroupTypeNode();
 401
 402         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 403         groupTypeDefinition.setDescription("groups l2-networks in network collection");
 404         groupTypeDefinition.setType("org.openecomp.groups.PrivateCollection");
 405         groupTypeDefinition.setVersion("1.0");
 406
 407         List<PropertyDefinition> properties = singletonList(
 408                 buildProperty("network_collection_type", "l2-network", "network collection type, defined with default value"));
 409
 410         groupTypeDefinition.setProperties(properties );
 411
 412         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 413         assertTrue("check group type added", addGroupTypeResult.isLeft());
 414         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 415
 416         addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.PrivateCollection", "1.0");
 417         assertTrue("check group type added", addGroupTypeResult.isLeft());
 418         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 419
 420         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.updateGroupType(groupTypeDefinition, groupTypeDefinition);
 421         assertNotNull(upgradeResult);
 422         assertTrue(upgradeResult.isLeft());
 423     }
 424
 425     @Test
 426     public void testUpdateNonExistingGroupType() {
 427         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 428         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 429         groupTypeDefinition.setDescription("groups l2-networks in network collection");
 430         groupTypeDefinition.setType("org.openecomp.groups.MyCollection");
 431         groupTypeDefinition.setVersion("1.0");
 432
 433         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.updateGroupType(groupTypeDefinition, groupTypeDefinition);
 434         assertNotNull(upgradeResult);
 435         assertTrue(upgradeResult.isRight());
 436     }
 437
 438     @Test
 439     public void testUpdateNotDerivedGroupType() {
 440         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 441         groupTypeDefinition.setDescription("groups social-networks in school");
 442         groupTypeDefinition.setType("org.openecomp.groups.Teachers");
 443         groupTypeDefinition.setVersion("1.0");
 444
 445         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 446         assertTrue("check group type added", addGroupTypeResult.isLeft());
 447         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 448
 449         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.updateGroupType(groupTypeDefinition, groupTypeDefinition);
 450         assertNotNull(upgradeResult);
 451         assertTrue(upgradeResult.isLeft());
 452         assertThat(groupTypeDefinition).isEqualToIgnoringGivenFields(upgradeResult.left().value(), "properties", "capabilities");
 453     }
 454
 455     @Test
 456     public void testUpdateGroupTypeWithNonExistingParent() {
 457         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 458         groupTypeDefinition.setDescription("groups social-networks in work");
 459         groupTypeDefinition.setType("org.openecomp.groups.Cowokers");
 460         groupTypeDefinition.setVersion("1.0");
 461
 462         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 463         assertTrue("check group type added", addGroupTypeResult.isLeft());
 464         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 465
 466         groupTypeDefinition.setDerivedFrom("Non.existing.parent");
 467         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.updateGroupType(groupTypeDefinition, groupTypeDefinition);
 468         assertNotNull(upgradeResult);
 469         assertTrue(upgradeResult.isRight());
 470     }
 471
 472     @Test
 473     public void testUpgradeGroupType() {
 474         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 475         groupTypeDefinition.setDescription("groups social-networks in university");
 476         groupTypeDefinition.setType("org.openecomp.groups.Students");
 477         groupTypeDefinition.setVersion("1.0");
 478
 479         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 480         assertTrue("check group type added", addGroupTypeResult.isLeft());
 481         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 482
 483         GroupTypeDefinition parentGroupTypeDefinition = new GroupTypeDefinition();
 484         parentGroupTypeDefinition.setDescription("groups social-networks in university");
 485         parentGroupTypeDefinition.setType("org.openecomp.groups.Parents");
 486         parentGroupTypeDefinition.setVersion("1.0");
 487         parentGroupTypeDefinition.setHighestVersion(true);
 488
 489
 490         Either<GroupTypeDefinition, StorageOperationStatus> addParentGroupTypeResult =  groupTypeOperation.addGroupType(parentGroupTypeDefinition, true);
 491         assertTrue("check group type added", addParentGroupTypeResult.isLeft());
 492         compareBetweenCreatedToSent(parentGroupTypeDefinition, addParentGroupTypeResult.left().value());
 493
 494         groupTypeDefinition.setDerivedFrom("org.openecomp.groups.Parents");
 495         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.updateGroupType(groupTypeDefinition, addGroupTypeResult.left().value());
 496         assertNotNull(upgradeResult);
 497         assertTrue(upgradeResult.isLeft());
 498         assertThat(groupTypeDefinition).isEqualToIgnoringGivenFields(upgradeResult.left().value(), "properties", "capabilities");
 499     }
 500
 501
 502     private GroupTypeData getOrCreateRootGroupTypeNode() {
 503         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), TOSCA_GROUPS_ROOT, GroupTypeData.class);
 504         if(groupTypeResult.isLeft()) {
 505             return groupTypeResult.left().value();
 506         }
 507
 508         return createRootGroupTypeNode();
 509     }
 510
 511     private GroupTypeData createRootGroupTypeNode() {
 512         GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
 513         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(rootGroupDefinition, false);
 514         assertTrue("check group type added", addGroupTypeResult.isLeft());
 515
 516         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), rootGroupDefinition.getType(), GroupTypeData.class);
 517         return extractVal(groupTypeResult);
 518     }
 519
 520     private GroupTypeDefinition createRootGroupDefinition() {
 521         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 522         groupTypeDefinition.setDescription("The TOSCA Group Type all other TOSCA Group Types derive from");
 523         groupTypeDefinition.setType(TOSCA_GROUPS_ROOT);
 524         groupTypeDefinition.setHighestVersion(true);
 525         return groupTypeDefinition;
 526     }
 527
 528     private GroupTypeDefinition createGroupType(String type) {
 529         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 530         groupTypeDefinition.setDescription("description for type " + type);
 531         groupTypeDefinition.setType(type);
 532         groupTypeDefinition.setName(type + "name");
 533         groupTypeDefinition.setIcon(type + "icon");
 534         return groupTypeDefinition;
 535     }
 536
 537     private CapabilityTypeDefinition createCapabilityType(Map<String, PropertyDefinition> properties) {
 538         CapabilityTypeDefinition rootCapabilityTypeDefinition = new CapabilityTypeDefinition();
 539         rootCapabilityTypeDefinition.setType("tosca.capabilities.Root");
 540         rootCapabilityTypeDefinition.setDescription("Dummy root type");
 541         rootCapabilityTypeDefinition.setVersion("1.0");
 542         capabilityTypeOperation.addCapabilityType(rootCapabilityTypeDefinition, true);
 543
 544
 545         CapabilityTypeDefinition parentCapabilityTypeDefinition = new CapabilityTypeDefinition();
 546         parentCapabilityTypeDefinition.setType("tosca.capabilities.Parent");
 547         parentCapabilityTypeDefinition.setDescription("Dummy parent type");
 548         parentCapabilityTypeDefinition.setDerivedFrom("tosca.capabilities.Root");
 549         parentCapabilityTypeDefinition.setVersion("1.0");
 550         PropertyDefinition property = buildProperty("parentProp", "any", "Description");
 551         Map<String, PropertyDefinition> capTypeProperties = new HashMap<>();
 552         capTypeProperties.put("parent_prop", property);
 553         parentCapabilityTypeDefinition.setProperties(capTypeProperties);
 554         capabilityTypeOperation.addCapabilityType(parentCapabilityTypeDefinition, true);
 555
 556
 557         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 558         capabilityTypeDefinition.setDescription("ability to expose routing information of the internal network");
 559         capabilityTypeDefinition.setType("org.openecomp.capabilities.VLANAssignment");
 560         capabilityTypeDefinition.setVersion("1.0");
 561         capabilityTypeDefinition.setDerivedFrom("tosca.capabilities.Parent");
 562
 563         capabilityTypeDefinition.setProperties(properties);
 564
 565         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityTypeResult = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 566         assertTrue("check capability type added", addCapabilityTypeResult.isLeft());
 567
 568         CapabilityTypeDefinition capabilityTypeAdded = addCapabilityTypeResult.left().value();
 569         compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
 570
 571         return capabilityTypeDefinition;
 572     }
 573
 574     private CapabilityDefinition buildCapabilityDefintion(List<ComponentInstanceProperty> properties) {
 575         CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 576         capabilityDefinition.setName("vlan_assignment");
 577         capabilityDefinition.setDescription("ability to expose routing information of the internal network");
 578         capabilityDefinition.setType("org.openecomp.capabilities.VLANAssignment");
 579         capabilityDefinition.setProperties(properties);
 580         return capabilityDefinition;
 581     }
 582
 583     private PropertyDefinition buildProperty(String name, String defaultValue, String description) {
 584         PropertyDefinition property = new PropertyDefinition();
 585         property.setName(name);
 586         property.setDefaultValue(defaultValue);
 587         property.setRequired(true);
 588         property.setDescription(description);
 589         property.setType(ToscaType.STRING.name().toLowerCase());
 590
 591         return property;
 592     }
 593
 594     private void compareBetweenCreatedToSent(CapabilityTypeDefinition expected, CapabilityTypeDefinition actual) {
 595         assertEquals(expected.getDerivedFrom(), actual.getDerivedFrom());
 596         assertEquals(expected.getType(), actual.getType());
 597         assertEquals(expected.getDescription(), actual.getDescription());
 598     }
 599
 600     private void compareBetweenCreatedToSent(GroupTypeDefinition expected, GroupTypeDefinition actual) {
 601         assertEquals(expected.getType(), actual.getType());
 602         assertEquals(expected.getDescription(), actual.getDescription());
 603     }
 604
 605     private <T> void validate(Either<T, TitanOperationStatus> result) {
 606         extractVal(result);
 607     }
 608
 609     private <T> T extractVal(Either<T, TitanOperationStatus> result) {
 610         assertTrue(result.isLeft());
 611         T t = result.left().value();
 612         assertNotNull(t);
 613
 614         return t;
 615     }
 616
 617     private void cleanUp() {
 618         Either<TitanGraph, TitanOperationStatus> graphResult = titanDao.getGraph();
 619         TitanGraph graph = graphResult.left().value();
 620
 621         Iterable<TitanVertex> vertices = graph.query().vertices();
 622         if (vertices != null) {
 623             Iterator<TitanVertex> iterator = vertices.iterator();
 624             while (iterator.hasNext()) {
 625                 TitanVertex vertex = iterator.next();
 626                 vertex.remove();
 627             }
 628
 629         }
 630         titanDao.commit();
 631     }
 632
 633
 634     @Test
 635     public void updateGroupType_returnNotFoundErrorIfTryingToUpdateANonExistingType() {
 636         GroupTypeDefinition currType = createGroupTypeDef();
 637         GroupTypeDefinition updatedType = createGroupTypeDef();
 638         Either<GroupTypeDefinition, StorageOperationStatus> updatedGroupTypeRes = groupTypeOperation.updateGroupType(updatedType, currType);
 639         assertThat(updatedGroupTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 640     }
 641
 642     @Test
 643     public void updateGroupType_basicFields() {
 644         GroupTypeDefinition createdType = createGroupTypeDef("type1", "description1", NULL_STRING);
 645         Either<GroupTypeDefinition, StorageOperationStatus> currGroupType = groupTypeOperation.addGroupType(createdType);
 646
 647         GroupTypeDefinition updatedType = createGroupTypeDef("type1", "description2", NULL_STRING);
 648         updatedType.setName("newName");
 649         updatedType.setIcon("icon");
 650         groupTypeOperation.updateGroupType(updatedType, currGroupType.left().value());
 651
 652         Either<GroupTypeDefinition, StorageOperationStatus> fetchedUpdatedType = groupTypeOperation.getLatestGroupTypeByType(createdType.getType());
 653         GroupTypeDefinition fetchedGroupType = fetchedUpdatedType.left().value();
 654         assertThat(fetchedGroupType.getProperties()).isEmpty();
 655         assertThat(fetchedGroupType)
 656                 .isEqualToIgnoringGivenFields(updatedType, "properties", "capabilities");
 657
 658     }
 659
 660     @Test
 661     public void updateGroupType_updatePropertiesType_FailedDueAttemptToChangePropertyType() {
 662         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 663         GroupTypeDefinition groupType = createGroupTypeDef(prop1);
 664         Either<GroupTypeDefinition, StorageOperationStatus> currGroupType = groupTypeOperation.addGroupType(groupType);
 665
 666         PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "int");
 667         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 668         GroupTypeDefinition updatedGroupType = createGroupTypeDef(updatedProp1, prop3);
 669
 670         Either<GroupTypeDefinition, StorageOperationStatus> updatedGroupTypeRetrieved = groupTypeOperation.updateGroupType(updatedGroupType, currGroupType.left().value());
 671         assertEquals(StorageOperationStatus.MATCH_NOT_FOUND, updatedGroupTypeRetrieved.right().value());
 672     }
 673
 674     @Test
 675     public void validateGroupType_FailedDueAttempToCreateGroupTypeWithPropertyWhichTypeIsDifferentFromTypeOfParentPropertyWithTheSameName() {
 676         GroupTypeDefinition rootGroupType = createGroupTypeDef();
 677         Either<GroupTypeDefinition, StorageOperationStatus> rootGroupTypeRes = groupTypeOperation.addGroupType(rootGroupType);
 678         assertTrue(rootGroupTypeRes.isLeft());
 679
 680         PropertyDefinition prop = createSimpleProperty("val1", "prop", "string");
 681         GroupTypeDefinition groupType1 = createGroupTypeDef("type1", "descr1", rootGroupType.getType(), prop);
 682         Either<GroupTypeDefinition, StorageOperationStatus> groupType1Res = groupTypeOperation.addGroupType(groupType1);
 683         assertTrue(groupType1Res.isLeft());
 684
 685         PropertyDefinition prop1 = createSimpleProperty("33", "prop", "int");
 686         PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
 687         GroupTypeDefinition groupType2 = createGroupTypeDef("type2", "descr", groupType1.getType(), prop1, prop2);
 688
 689         Either<GroupTypeDefinition, StorageOperationStatus> updatedGroupTypeRetrieved = groupTypeOperation.validateUpdateProperties(groupType2);
 690         assertEquals(StorageOperationStatus.PROPERTY_NAME_ALREADY_EXISTS, updatedGroupTypeRetrieved.right().value());
 691     }
 692
 693     @Test
 694     public void updateGroupType_derivedFrom_whenNoPrevDerivedFrom_updateToNewDerivedFrom() {
 695         GroupTypeDefinition rootGroupType = createGroupTypeDef();
 696         GroupTypeDefinition groupType1 = createGroupTypeDef("type1", "descr", NULL_STRING);
 697         GroupTypeDefinition updatedGroupType = createGroupTypeDef("type1", "descr", rootGroupType.getType());
 698         groupTypeOperation.addGroupType(rootGroupType);
 699         Either<GroupTypeDefinition, StorageOperationStatus> currGroupType = groupTypeOperation.addGroupType(groupType1);
 700         groupTypeOperation.updateGroupType(updatedGroupType, currGroupType.left().value());
 701
 702         Either<GroupTypeDefinition, StorageOperationStatus> latestGroupType = groupTypeOperation.getLatestGroupTypeByType(groupType1.getType());
 703         assertThat(latestGroupType.left().value().getDerivedFrom()).isEqualTo(rootGroupType.getType());
 704         verifyDerivedFromNodeEqualsToRootGroupType(rootGroupType, latestGroupType.left().value().getUniqueId());
 705     }
 706
 707     @Test
 708     public void updateGroupType_derivedFrom_updateToNullDerivedFrom_derivedFromDeleted_Failed() {
 709         GroupTypeDefinition rootGroupType = createGroupTypeDef();
 710         GroupTypeDefinition groupType1 = createGroupTypeDef("type1", "descr", rootGroupType.getType());
 711         GroupTypeDefinition updatedGroupType = createGroupTypeDef("type1", "descr", null, new PropertyDefinition[]{});
 712         groupTypeOperation.addGroupType(rootGroupType);
 713         Either<GroupTypeDefinition, StorageOperationStatus> currGroupType = groupTypeOperation.addGroupType(groupType1);
 714
 715         Either<GroupTypeDefinition, StorageOperationStatus> updateGroupTypeRes = groupTypeOperation.updateGroupType(updatedGroupType, currGroupType.left().value());
 716         assertThat(updateGroupTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 717
 718         Either<GroupTypeDefinition, StorageOperationStatus> latestGroupType = groupTypeOperation.getLatestGroupTypeByType(groupType1.getType());
 719         assertThat(latestGroupType.left().value().getDerivedFrom()).isEqualTo(rootGroupType.getType());
 720     }
 721
 722     @Test
 723     public void updateGroupType_updateDerivedFrom() {
 724         GroupTypeDefinition rootGroupType = createGroupTypeDef();
 725         GroupTypeDefinition derivedType1 = createGroupTypeDef("derivedType1", "descr", rootGroupType.getType());
 726         GroupTypeDefinition groupType1 = createGroupTypeDef("type1", "descr", rootGroupType.getType());
 727         GroupTypeDefinition updatedGroupType = createGroupTypeDef("type1", "descr", derivedType1.getType());
 728
 729         groupTypeOperation.addGroupType(rootGroupType);
 730         groupTypeOperation.addGroupType(derivedType1);
 731         Either<GroupTypeDefinition, StorageOperationStatus> currGroupType = groupTypeOperation.addGroupType(groupType1);
 732
 733         groupTypeOperation.updateGroupType(updatedGroupType, currGroupType.left().value());
 734
 735         Either<GroupTypeDefinition, StorageOperationStatus> latestGroupType = groupTypeOperation.getLatestGroupTypeByType(groupType1.getType());
 736         assertThat(latestGroupType.left().value().getDerivedFrom()).isEqualTo(derivedType1.getType());
 737     }
 738
 739     @Test
 740     public void updateGroupType_updateDerivedFrom_CauseEndlessRecursion() {
 741         GroupTypeDefinition rootGroupType = createGroupTypeDef();
 742         GroupTypeDefinition derivedType1 = createGroupTypeDef("derivedType1", "descr", rootGroupType.getType());
 743         GroupTypeDefinition groupType1 = createGroupTypeDef("type1", "descr", derivedType1.getType());
 744         GroupTypeDefinition updatedGroupType = createGroupTypeDef("derivedType1", "descr", groupType1.getType());
 745
 746         groupTypeOperation.addGroupType(rootGroupType);
 747         Either<GroupTypeDefinition, StorageOperationStatus> currGroupType = groupTypeOperation.addGroupType(derivedType1);
 748         groupTypeOperation.addGroupType(groupType1);
 749
 750         Either<GroupTypeDefinition, StorageOperationStatus> updateResult = groupTypeOperation.updateGroupType(updatedGroupType, currGroupType.left().value());
 751         assertThat(updateResult.right().value()).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
 752
 753         Either<GroupTypeDefinition, StorageOperationStatus> latestGroupType = groupTypeOperation.getLatestGroupTypeByType(updatedGroupType.getType());
 754         assertThat(latestGroupType.left().value().getDerivedFrom()).isEqualTo(rootGroupType.getType());
 755     }
 756
 757     private PropertyDefinition duplicateProperty(PropertyDefinition prop1, String updatedValue, String updatedType) {
 758         PropertyDefinition updatedProp1 = new PropertyDefinition(prop1);
 759         updatedProp1.setUniqueId(null);
 760         updatedProp1.setDefaultValue(updatedValue);
 761         updatedProp1.setType(updatedType);
 762         return updatedProp1;
 763     }
 764
 765     private void verifyDerivedFromNodeEqualsToRootGroupType(GroupTypeDefinition rootGroupType, String parentGroupId) {
 766         Either<ImmutablePair<GroupTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), parentGroupId, GraphEdgeLabels.DERIVED_FROM,
 767                 NodeTypeEnum.GroupType, GroupTypeData.class);
 768         assertThat(derivedFromRelation.left().value().getLeft().getGroupTypeDataDefinition())
 769                 .isEqualToComparingFieldByField(rootGroupType);
 770     }
 771
 772     private void verifyDerivedFromRelationDoesntExist(String parentGroupId) {
 773         Either<ImmutablePair<GroupTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.GroupType), parentGroupId, GraphEdgeLabels.DERIVED_FROM,
 774                 NodeTypeEnum.GroupType, GroupTypeData.class);
 775         assertThat(derivedFromRelation.right().value())
 776                 .isEqualTo(TitanOperationStatus.NOT_FOUND);
 777     }
 778
 779     private GroupTypeDefinition createGroupTypeDef() {
 780         return createGroupTypeDef("tosca.groups.Root", "description: The TOSCA Group Type all other TOSCA Group Types derive from", null, new PropertyDefinition[]{});
 781     }
 782
 783     private GroupTypeDefinition createGroupTypeDef(PropertyDefinition ... props) {
 784         return createGroupTypeDef("tosca.groups.Root",  null, props);
 785     }
 786
 787     private GroupTypeDefinition createGroupTypeDef(String type, String derivedFrom, PropertyDefinition ... props) {
 788         GroupTypeDefinition groupType = createGroupTypeDef(type, "description: The TOSCA Group Type all other TOSCA Group Types derive from", derivedFrom);
 789         groupType.setProperties(asList(props));
 790         return groupType;
 791     }
 792
 793     private GroupTypeDefinition createGroupTypeDef(String type, String description, String derivedFrom) {
 794         return createGroupTypeDef(type, description, derivedFrom, null);
 795     }
 796
 797     private GroupTypeDefinition createGroupTypeDef(String type, String description, String derivedFrom,  PropertyDefinition ... props) {
 798         GroupTypeDataDefinition groupTypeDataDefinition = new GroupTypeDataDefinition();
 799         groupTypeDataDefinition.setDescription(description);
 800         groupTypeDataDefinition.setType(type);
 801         groupTypeDataDefinition.setName(type + "name");
 802         groupTypeDataDefinition.setIcon(type + "icon");
 803         groupTypeDataDefinition.setDerivedFrom(derivedFrom);
 804         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(groupTypeDataDefinition);
 805         groupTypeDefinition.setHighestVersion(true);
 806         groupTypeDefinition.setVersion("1.0");
 807         if (props != null) {
 808             groupTypeDefinition.setProperties(asList(props));
 809         }
 810         return groupTypeDefinition;
 811     }
 812
 813 }