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

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