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