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