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