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

   1 package org.openecomp.sdc.be.model.operations.impl;
   2
   3 import fj.data.Either;
   4 import org.apache.tinkerpop.gremlin.structure.Edge;
   5 import org.junit.After;
   6 import org.junit.BeforeClass;
   7 import org.junit.Test;
   8 import org.junit.runner.RunWith;
   9 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  10 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  11 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  12 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  13 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  14 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  15 import org.openecomp.sdc.be.model.ModelTestBase;
  16 import org.openecomp.sdc.be.model.PropertyDefinition;
  17 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  18 import org.openecomp.sdc.be.model.tosca.ToscaType;
  19 import org.openecomp.sdc.be.resources.data.CapabilityTypeData;
  20 import org.openecomp.sdc.be.resources.data.GroupTypeData;
  21 import org.springframework.test.context.ContextConfiguration;
  22 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  23
  24 import javax.annotation.Resource;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import static com.google.common.collect.Sets.newHashSet;
  30 import static java.util.Arrays.asList;
  31 import static java.util.Collections.singletonList;
  32 import static org.assertj.core.api.Assertions.assertThat;
  33 import static org.junit.Assert.*;
  34
  35 @RunWith(SpringJUnit4ClassRunner.class)
  36 @ContextConfiguration("classpath:application-context-test.xml")
  37 public class GroupTypeOperationTest extends ModelTestBase {
  38     private static final String TOSCA_GROUPS_ROOT = "tosca.groups.Root";
  39
  40     @Resource(name = "titan-generic-dao")
  41     private TitanGenericDao titanDao;
  42
  43     @Resource(name = "capability-type-operation")
  44     private CapabilityTypeOperation capabilityTypeOperation;
  45
  46     @Resource(name = "group-type-operation")
  47     private GroupTypeOperation groupTypeOperation;
  48
  49     @BeforeClass
  50     public static void setupBeforeClass() {
  51         ModelTestBase.init();
  52     }
  53
  54     @After
  55     public void tearDown() {
  56         titanDao.rollback();
  57     }
  58
  59     @Test
  60     public void getAllGroupTypes() {
  61         GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
  62         GroupTypeDefinition type1 = createGroupType("type1");
  63         GroupTypeDefinition type2 = createGroupType("type2");
  64         groupTypeOperation.addGroupType(rootGroupDefinition);
  65         groupTypeOperation.addGroupType(type1);
  66         groupTypeOperation.addGroupType(type2);
  67
  68         List<GroupTypeDefinition> allGroupTypesNoExclusion = groupTypeOperation.getAllGroupTypes(null);
  69         assertThat(allGroupTypesNoExclusion)
  70                 .usingElementComparatorOnFields("type")
  71                 .containsExactlyInAnyOrder(rootGroupDefinition, type1, type2);
  72     }
  73
  74     @Test
  75     public void getAllGroupTypes_whenPassingExclusionList_doNotReturnExcludedTypes() {
  76         GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
  77         GroupTypeDefinition type1 = createGroupType("type1");
  78         GroupTypeDefinition type2 = createGroupType("type2");
  79         groupTypeOperation.addGroupType(rootGroupDefinition);
  80         groupTypeOperation.addGroupType(type1);
  81         groupTypeOperation.addGroupType(type2);
  82
  83         List<GroupTypeDefinition> allGroupTypes = groupTypeOperation.getAllGroupTypes(newHashSet("type1", "type2"));
  84         assertThat(allGroupTypes)
  85                 .usingElementComparatorOnFields("type")
  86                 .containsExactly(rootGroupDefinition);
  87     }
  88
  89     @Test
  90     public void groupTypeWithoutCapabilityTypeCreated() {
  91         GroupTypeData rootNode = getOrCreateRootGroupTypeNode();
  92
  93         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
  94         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
  95         groupTypeDefinition.setDescription("groups l3-networks in network collection");
  96         groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
  97         groupTypeDefinition.setVersion("1.0");
  98
  99         List<PropertyDefinition> properties = asList(
 100                 buildProperty("network_collection_type", "l3-network", "network collection type, defined with default value"),
 101                 buildProperty("network_collection_subtype", "sub-interface", "network collection subtype, defined with default value"),
 102                 buildProperty("network_collection_role", null, "network collection role"),
 103                 buildProperty("network_collection_description", null, "network collection description, free format text"));
 104
 105         groupTypeDefinition.setProperties(properties );
 106
 107         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, false);
 108         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 109         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 110
 111         addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.NetworkCollection", "1.0");
 112         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 113         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 114
 115         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
 116         GroupTypeData groupTypeNode = extractVal(groupTypeResult);
 117
 118         Either<Edge, TitanOperationStatus> edgeResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM);
 119         validate(edgeResult);
 120     }
 121
 122     @Test
 123     public void groupTypeWithCapabilityTypeAndEdgeCreated() {
 124         GroupTypeData rootNode = getOrCreateRootGroupTypeNode();
 125
 126         CapabilityTypeDefinition capabilityTypeDef = createCapabilityType();
 127         Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
 128         CapabilityTypeData capabilityTypeNode = extractVal(capabilityTypeResult);
 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.setCapabilityTypes(asList(capabilityTypeDef));
 135
 136         List<PropertyDefinition> properties = asList(
 137                 buildProperty("vfc_instance_group_role", null, "role of this VFC group"),
 138                 buildProperty("vfc_parent_port_role", null, "common role of parent ports of VFCs in this group"),
 139                 buildProperty("network_collection_role", null, "network collection role assigned to this group"),
 140                 buildProperty("subinterface_role", null, "common role of subinterfaces of VFCs in this group, criteria the group is created"));
 141
 142         groupTypeDefinition.setProperties(properties );
 143
 144         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 145         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 146         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 147
 148         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
 149         GroupTypeData groupTypeNode = extractVal(groupTypeResult);
 150
 151         Either<Edge, TitanOperationStatus> edgeCapTypeResult = titanDao.getEdgeByNodes(groupTypeNode, capabilityTypeNode, GraphEdgeLabels.GROUP_TYPE_CAPABILITY_TYPE);
 152         validate(edgeCapTypeResult);
 153
 154         Either<Edge, TitanOperationStatus> edgeDerivedFromResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM);
 155         validate(edgeDerivedFromResult);
 156     }
 157
 158     @Test
 159     public void testUpgradeGroupTypeWithDerrivedFromEdge() {
 160         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 161         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 162         groupTypeDefinition.setDescription("groups l2-networks in network collection");
 163         groupTypeDefinition.setType("org.openecomp.groups.PrivateCollection");
 164         groupTypeDefinition.setVersion("1.0");
 165
 166         List<PropertyDefinition> properties = singletonList(
 167                 buildProperty("network_collection_type", "l2-network", "network collection type, defined with default value"));
 168
 169         groupTypeDefinition.setProperties(properties );
 170
 171         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 172         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 173         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 174
 175         addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.PrivateCollection", "1.0");
 176         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 177         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 178
 179         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
 180         assertNotNull(upgradeResult);
 181         assertTrue(upgradeResult.isLeft());
 182     }
 183
 184     @Test
 185     public void testUpgradeNonExistingGroupType() {
 186         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 187         groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
 188         groupTypeDefinition.setDescription("groups l2-networks in network collection");
 189         groupTypeDefinition.setType("org.openecomp.groups.MyCollection");
 190         groupTypeDefinition.setVersion("1.0");
 191
 192         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
 193         assertNotNull(upgradeResult);
 194         assertTrue(upgradeResult.isRight());
 195     }
 196
 197     @Test
 198     public void testUpgradeNotDerivedGroupType() {
 199         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 200         groupTypeDefinition.setDescription("groups social-networks in school");
 201         groupTypeDefinition.setType("org.openecomp.groups.Teachers");
 202         groupTypeDefinition.setVersion("1.0");
 203
 204         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 205         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 206         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 207
 208         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
 209         assertNotNull(upgradeResult);
 210         assertTrue(upgradeResult.isLeft());
 211         assertEquals(groupTypeDefinition, upgradeResult.left().value());
 212     }
 213
 214     @Test
 215     public void testUpgradeGroupTypeWithNonExistingParent() {
 216         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 217         groupTypeDefinition.setDescription("groups social-networks in work");
 218         groupTypeDefinition.setType("org.openecomp.groups.Cowokers");
 219         groupTypeDefinition.setVersion("1.0");
 220
 221         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 222         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 223         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 224
 225         groupTypeDefinition.setDerivedFrom("Non.existing.parent");
 226         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
 227         assertNotNull(upgradeResult);
 228         assertTrue(upgradeResult.isRight());
 229     }
 230
 231     @Test
 232     public void testUpgradeGroupType() {
 233         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 234         groupTypeDefinition.setDescription("groups social-networks in university");
 235         groupTypeDefinition.setType("org.openecomp.groups.Students");
 236         groupTypeDefinition.setVersion("1.0");
 237
 238         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
 239         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 240         compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
 241
 242         GroupTypeDefinition parentGroupTypeDefinition = new GroupTypeDefinition();
 243         parentGroupTypeDefinition.setDescription("groups social-networks in university");
 244         parentGroupTypeDefinition.setType("org.openecomp.groups.Parents");
 245         parentGroupTypeDefinition.setVersion("1.0");
 246
 247         Either<GroupTypeDefinition, StorageOperationStatus> addParentGroupTypeResult =  groupTypeOperation.addGroupType(parentGroupTypeDefinition, true);
 248         assertEquals("check group type added", true, addParentGroupTypeResult.isLeft());
 249         compareBetweenCreatedToSent(parentGroupTypeDefinition, addParentGroupTypeResult.left().value());
 250
 251         groupTypeDefinition.setDerivedFrom("org.openecomp.groups.Parents");
 252         Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
 253         assertNotNull(upgradeResult);
 254         assertTrue(upgradeResult.isLeft());
 255         assertEquals(groupTypeDefinition, upgradeResult.left().value());
 256     }
 257
 258
 259     private GroupTypeData getOrCreateRootGroupTypeNode() {
 260         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), TOSCA_GROUPS_ROOT, GroupTypeData.class);
 261         if(groupTypeResult.isLeft()) {
 262             return groupTypeResult.left().value();
 263         }
 264
 265         return createRootGroupTypeNode();
 266     }
 267
 268     private GroupTypeData createRootGroupTypeNode() {
 269         GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
 270         Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(rootGroupDefinition, true);
 271         assertEquals("check group type added", true, addGroupTypeResult.isLeft());
 272
 273         Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), rootGroupDefinition.getType(), GroupTypeData.class);
 274         return extractVal(groupTypeResult);
 275     }
 276
 277     private GroupTypeDefinition createRootGroupDefinition() {
 278         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 279         groupTypeDefinition.setDescription("The TOSCA Group Type all other TOSCA Group Types derive from");
 280         groupTypeDefinition.setType(TOSCA_GROUPS_ROOT);
 281         return groupTypeDefinition;
 282     }
 283
 284     private GroupTypeDefinition createGroupType(String type) {
 285         GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
 286         groupTypeDefinition.setDescription("description for type " + type);
 287         groupTypeDefinition.setType(type);
 288         return groupTypeDefinition;
 289     }
 290
 291     private CapabilityTypeDefinition createCapabilityType() {
 292         CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
 293         capabilityTypeDefinition.setDescription("ability to expose routing information of the internal network");
 294         capabilityTypeDefinition.setType("org.openecomp.capabilities.VLANAssignment");
 295         capabilityTypeDefinition.setVersion("1.0");
 296
 297         Map<String, PropertyDefinition> properties = new HashMap<>();
 298         properties.put("vfc_instance_group_reference",
 299                 buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance"));
 300
 301         capabilityTypeDefinition.setProperties(properties);
 302
 303         Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityTypeResult = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
 304         assertEquals("check capability type added", true, addCapabilityTypeResult.isLeft());
 305
 306         CapabilityTypeDefinition capabilityTypeAdded = addCapabilityTypeResult.left().value();
 307         compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
 308
 309         return capabilityTypeDefinition;
 310     }
 311
 312     private PropertyDefinition buildProperty(String name, String defaultValue, String description) {
 313         PropertyDefinition property = new PropertyDefinition();
 314         property.setName(name);
 315         property.setDefaultValue(defaultValue);
 316         property.setRequired(true);
 317         property.setDescription(description);
 318         property.setType(ToscaType.STRING.name().toLowerCase());
 319
 320         return property;
 321     }
 322
 323     private void compareBetweenCreatedToSent(CapabilityTypeDefinition expected, CapabilityTypeDefinition actual) {
 324         assertEquals(expected.getDerivedFrom(), actual.getDerivedFrom());
 325         assertEquals(expected.getType(), actual.getType());
 326         assertEquals(expected.getDescription(), actual.getDescription());
 327     }
 328
 329     private void compareBetweenCreatedToSent(GroupTypeDefinition expected, GroupTypeDefinition actual) {
 330         assertEquals(expected.getType(), actual.getType());
 331         assertEquals(expected.getDescription(), actual.getDescription());
 332     }
 333
 334     private <T> void validate(Either<T, TitanOperationStatus> result) {
 335         extractVal(result);
 336     }
 337
 338     private <T> T extractVal(Either<T, TitanOperationStatus> result) {
 339         assertTrue(result.isLeft());
 340         T t = result.left().value();
 341         assertNotNull(t);
 342
 343         return t;
 344     }
 345
 346 }