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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 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 org.assertj.core.api.Assertions.assertThat;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertTrue;
  28
  29 import org.janusgraph.core.JanusGraph;
  30 import org.janusgraph.core.JanusGraphVertex;
  31 import fj.data.Either;
  32 import java.util.Iterator;
  33 import java.util.List;
  34 import java.util.stream.Stream;
  35 import org.apache.commons.lang3.StringUtils;
  36 import org.apache.commons.lang3.tuple.ImmutablePair;
  37 import org.junit.Before;
  38 import org.junit.BeforeClass;
  39 import org.junit.Test;
  40 import org.junit.runner.RunWith;
  41 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  42 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  43 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  44 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  45 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
  46 import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  48 import org.openecomp.sdc.be.model.ModelTestBase;
  49 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  50 import org.openecomp.sdc.be.model.PropertyDefinition;
  51 import org.openecomp.sdc.be.model.operations.StorageException;
  52 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  53 import org.openecomp.sdc.be.resources.data.PolicyTypeData;
  54 import org.springframework.beans.factory.annotation.Autowired;
  55 import org.springframework.test.context.ContextConfiguration;
  56 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  57
  58 @RunWith(SpringJUnit4ClassRunner.class)
  59 @ContextConfiguration("classpath:application-context-test.xml")
  60 public class PolicyTypeOperationTest extends ModelTestBase {
  61
  62     private static final String NULL_STRING = null;
  63     @Autowired
  64     private PolicyTypeOperation policyTypeOperation;
  65
  66     @Autowired
  67     private HealingJanusGraphGenericDao janusGraphGenericDao;
  68
  69     @BeforeClass
  70     public static void setupBeforeClass() {
  71         ModelTestBase.init();
  72
  73     }
  74
  75     @Before
  76     public void cleanUp() {
  77         JanusGraphGenericDao janusGraphGenericDao = policyTypeOperation.janusGraphGenericDao;
  78         Either<JanusGraph, JanusGraphOperationStatus> graphResult = janusGraphGenericDao.getGraph();
  79         JanusGraph graph = graphResult.left().value();
  80
  81         Iterable<JanusGraphVertex> vertices = graph.query().vertices();
  82         if (vertices != null) {
  83             Iterator<JanusGraphVertex> iterator = vertices.iterator();
  84             while (iterator.hasNext()) {
  85                 JanusGraphVertex vertex = iterator.next();
  86                 vertex.remove();
  87             }
  88
  89         }
  90         janusGraphGenericDao.commit();
  91     }
  92
  93     @Test
  94     public void testAddPolicyType() {
  95         PolicyTypeDefinition policyTypePreCreate = createPolicyTypeDef();
  96         assertTrue(StringUtils.isEmpty(policyTypePreCreate.getUniqueId()));
  97         Either<PolicyTypeDefinition, StorageOperationStatus> addPolicyType = policyTypeOperation.addPolicyType(policyTypePreCreate);
  98         assertTrue(addPolicyType.isLeft());
  99         PolicyTypeDefinition policyTypePostCreate = addPolicyType.left().value();
 100         assertThat(policyTypePostCreate.getUniqueId()).isNotEmpty();
 101         assertThat(policyTypePostCreate)
 102                 .isEqualToComparingOnlyGivenFields(policyTypePreCreate, "name", "icon", "description", "type");
 103     }
 104
 105     @Test
 106     public void testGetLatestPolicyTypeByType() {
 107         PolicyTypeDefinition policyTypeCreated = policyTypeOperation.addPolicyType(createPolicyTypeDef()).left().value();
 108         Either<PolicyTypeDefinition, StorageOperationStatus> eitherPolicyTypeFetched = policyTypeOperation.getLatestPolicyTypeByType(policyTypeCreated.getType());
 109         assertTrue(eitherPolicyTypeFetched.isLeft());
 110         PolicyTypeDefinition policyTypeFetched = eitherPolicyTypeFetched.left().value();
 111         assertEquals(policyTypeFetched.toString(), policyTypeCreated.toString());
 112     }
 113
 114     @Test
 115     public void testGetLatestPolicyTypeByType_derivedFromFetchedCorrectly() {
 116         PolicyTypeDefinition rootPolicyType = createRootPolicyTypeOnGraph();
 117         String derivedFromRootType = rootPolicyType.getType();
 118         PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", derivedFromRootType);
 119         policyTypeOperation.addPolicyType(policyType1);
 120         Either<PolicyTypeDefinition, StorageOperationStatus> eitherPolicyTypeFetched = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
 121         assertThat(eitherPolicyTypeFetched.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType());
 122     }
 123
 124     @Test
 125     public void testGetLatestPolicyTypeByType_whenGettingTypeGetPropertiesFromAllDerivedFromChain_policyTypeHasNoDirectProps() {
 126         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 127         PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
 128         PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", null, prop1, prop2);
 129         PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.type2", "desc3", policyType1.getType(), null);
 130         addPolicyTypesToDB(policyType1, policyType2);
 131         Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType2 = policyTypeOperation.getLatestPolicyTypeByType(policyType2.getType());
 132         assertThat(latestPolicyType2.isLeft()).isTrue();
 133         assertThat(latestPolicyType2.left().value().getProperties())
 134                 .usingElementComparatorOnFields("defaultValue", "name", "type")
 135                 .containsExactlyInAnyOrder(prop1, prop2);
 136     }
 137
 138     @Test
 139     public void testGetLatestPolicyTypeByType_whenGettingTypeGetPropertiesFromAllDerivedFromChain() {
 140         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 141         PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
 142         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 143
 144         PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(prop1);
 145         PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", rootPolicyType.getType(), null);
 146         PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.type2", "desc2", policyType1.getType(), prop2);
 147         PolicyTypeDefinition policyType3 = createPolicyTypeDef("tosca.policies.type3", "desc3", policyType2.getType(), null);
 148         PolicyTypeDefinition policyType4 = createPolicyTypeDef("tosca.policies.type4", "desc4", policyType3.getType(), prop3);
 149
 150         addPolicyTypesToDB(rootPolicyType, policyType1, policyType2, policyType3, policyType4);
 151
 152         Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType3 = policyTypeOperation.getLatestPolicyTypeByType(policyType4.getType());
 153         assertThat(latestPolicyType3.isLeft()).isTrue();
 154         assertThat(latestPolicyType3.left().value().getProperties())
 155                 .usingElementComparatorOnFields("defaultValue", "name", "type")
 156                 .containsExactlyInAnyOrder(prop1, prop2, prop3);
 157     }
 158
 159     @Test(expected = StorageException.class)
 160     public void getAllPolicyTypes_noPolicies() {
 161         policyTypeOperation.getAllPolicyTypes(null);
 162     }
 163
 164     @Test
 165     public void getAllPolicyTypes() {
 166         PolicyTypeDefinition policyType1 = createPolicyTypeDef();
 167         PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.test1", "desc1", "tosca.policies.Root");
 168         addPolicyTypesToDB(policyType1, policyType2);
 169         List<PolicyTypeDefinition> allPolicyTypesWithNoExcluded = policyTypeOperation.getAllPolicyTypes(null);
 170         assertThat(allPolicyTypesWithNoExcluded).hasSize(2);
 171         assertThat(allPolicyTypesWithNoExcluded).usingElementComparatorOnFields("uniqueId", "description", "version", "type")
 172                 .containsExactlyInAnyOrder(policyType1, policyType2);
 173     }
 174
 175     @Test
 176     public void getAllPolicyTypes_whenPassingExcludedTypeList_dontReturnExcludedTypes() {
 177         PolicyTypeDefinition policyType1 = createPolicyTypeDef();
 178         PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.test1", "desc1", "tosca.policies.Root");
 179         PolicyTypeDefinition policyType3 = createPolicyTypeDef("tosca.policies.test2", "desc2", "tosca.policies.Root");
 180         policyTypeOperation.addPolicyType(policyType1);
 181         policyTypeOperation.addPolicyType(policyType2);
 182         policyTypeOperation.addPolicyType(policyType3);
 183         List<PolicyTypeDefinition> allPolicyTypes = policyTypeOperation.getAllPolicyTypes(newHashSet("tosca.policies.test1", "tosca.policies.test2"));
 184         assertThat(allPolicyTypes).hasSize(1);
 185         assertThat(allPolicyTypes).usingElementComparatorOnFields("type")
 186                                                  .containsExactly(policyType1);
 187     }
 188
 189     @Test
 190     public void addPolicyType_whenDerivedFromNodeNotExist_returnNotFound() {
 191         PolicyTypeDefinition type1 = createPolicyTypeDef("tosca.policies.type1", "desc1", "derivedFrom");
 192         Either<PolicyTypeDefinition, StorageOperationStatus> addedPolicyTypeResult = policyTypeOperation.addPolicyType(type1);
 193         assertThat(addedPolicyTypeResult.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 194     }
 195
 196     @Test//bug379696
 197     public void addPolicyType_derivedFromAddedCorrectly() {
 198         PolicyTypeDefinition rootPolicyType = createRootPolicyTypeOnGraph();
 199         String derivedFromRootType = rootPolicyType.getType();
 200         PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", derivedFromRootType);
 201         Either<PolicyTypeDefinition, StorageOperationStatus> addedPolicyTypeResult = policyTypeOperation.addPolicyType(policyType1);
 202         assertThat(addedPolicyTypeResult.isLeft()).isTrue();
 203
 204         Either<PolicyTypeDefinition, StorageOperationStatus> fetchedPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
 205         PolicyTypeDefinition fetchedPolicyTypeVal = fetchedPolicyType.left().value();
 206         assertThat(fetchedPolicyTypeVal.getDerivedFrom()).isEqualTo(derivedFromRootType);
 207         verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, fetchedPolicyTypeVal.getUniqueId());
 208
 209     }
 210
 211     @Test
 212     public void updatePolicyType_returnNotFoundErrorIfTryingToUpdateANonExistingType() {
 213         PolicyTypeDefinition currType = createPolicyTypeDef();
 214         PolicyTypeDefinition updatedType = createPolicyTypeDef();
 215         Either<PolicyTypeDefinition, StorageOperationStatus> updatePolicyTypeRes = policyTypeOperation.updatePolicyType(updatedType, currType);
 216         assertThat(updatePolicyTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
 217     }
 218
 219     @Test
 220     public void updatePolicyType_basicFields() {
 221         PolicyTypeDefinition createdType = createPolicyTypeDef("type1", "description1", NULL_STRING);
 222         Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(createdType);
 223
 224         PolicyTypeDefinition updatedType = createPolicyTypeDef("type1", "description2", NULL_STRING);
 225         updatedType.setName("newName");
 226         updatedType.setIcon("icon");
 227         policyTypeOperation.updatePolicyType(updatedType, currPolicyType.left().value());
 228
 229         Either<PolicyTypeDefinition, StorageOperationStatus> fetchedUpdatedType = policyTypeOperation.getLatestPolicyTypeByType(createdType.getType());
 230         PolicyTypeDefinition fetchedPolicyType = fetchedUpdatedType.left().value();
 231         assertThat(fetchedPolicyType.getProperties()).isEmpty();
 232         assertThat(fetchedPolicyType)
 233                 .isEqualToIgnoringGivenFields(updatedType, "properties");
 234
 235     }
 236
 237     @Test
 238     public void updatePolicyType_updateProperties() {
 239         PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
 240         PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
 241         PolicyTypeDefinition policyType = createPolicyTypeDef(prop1);
 242         Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType);
 243
 244         PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "int");
 245         PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
 246         PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef(updatedProp1, prop3);
 247
 248         policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
 249
 250         Either<PolicyTypeDefinition, StorageOperationStatus> fetchedUpdatedType = policyTypeOperation.getLatestPolicyTypeByType(policyType.getType());
 251         assertThat(fetchedUpdatedType.left().value().getProperties())
 252                 .usingElementComparatorOnFields("name", "defaultValue", "type")
 253                 .containsExactlyInAnyOrder(updatedProp1, prop3);
 254
 255     }
 256
 257     @Test
 258     public void updatePolicyType_derivedFrom_whenNoPrevDerivedFrom_updateToNewDerivedFrom() {
 259         PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
 260         PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", NULL_STRING);
 261         PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", rootPolicyType.getType());
 262         policyTypeOperation.addPolicyType(rootPolicyType);
 263         Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1);
 264         policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
 265
 266         Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
 267         assertThat(latestPolicyType.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType());
 268         verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, latestPolicyType.left().value().getUniqueId());
 269     }
 270
 271     @Test
 272     public void updatePolicyType_derivedFrom_updateToNullDerivedFrom_derivedFromDeleted() {
 273         PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
 274         PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", rootPolicyType.getType());
 275         PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", null, new PropertyDefinition[]{});
 276         policyTypeOperation.addPolicyType(rootPolicyType);
 277         Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1);
 278
 279         policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
 280
 281         Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
 282         assertThat(latestPolicyType.left().value().getDerivedFrom()).isNull();
 283         verifyDerivedFromRelationDoesntExist(latestPolicyType.left().value().getUniqueId());
 284     }
 285
 286     @Test
 287     public void updatePolicyType_updateDerivedFrom() {
 288         PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
 289         PolicyTypeDefinition derivedType1 = createPolicyTypeDef("derivedType1", "descr", NULL_STRING);
 290         PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", derivedType1.getType());
 291         PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", rootPolicyType.getType());
 292
 293         policyTypeOperation.addPolicyType(rootPolicyType);
 294         policyTypeOperation.addPolicyType(derivedType1);
 295         Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1);
 296
 297         policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
 298
 299         Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
 300         assertThat(latestPolicyType.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType());
 301         verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, latestPolicyType.left().value().getUniqueId());
 302     }
 303
 304     private PropertyDefinition duplicateProperty(PropertyDefinition prop1, String updatedValue, String updatedType) {
 305         PropertyDefinition updatedProp1 = new PropertyDefinition(prop1);
 306         updatedProp1.setUniqueId(null);
 307         updatedProp1.setDefaultValue(updatedValue);
 308         updatedProp1.setType(updatedType);
 309         return updatedProp1;
 310     }
 311
 312     private void verifyDerivedFromNodeEqualsToRootPolicyType(PolicyTypeDefinition rootPolicyType, String parentPolicyId) {
 313         Either<ImmutablePair<PolicyTypeData, GraphEdge>, JanusGraphOperationStatus> derivedFromRelation = janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM,
 314                 NodeTypeEnum.PolicyType, PolicyTypeData.class);
 315         assertThat(derivedFromRelation.left().value().getLeft().getPolicyTypeDataDefinition())
 316                 .isEqualToComparingFieldByField(rootPolicyType);
 317     }
 318
 319     private void verifyDerivedFromRelationDoesntExist(String parentPolicyId) {
 320         Either<ImmutablePair<PolicyTypeData, GraphEdge>, JanusGraphOperationStatus> derivedFromRelation = janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM,
 321                 NodeTypeEnum.PolicyType, PolicyTypeData.class);
 322         assertThat(derivedFromRelation.right().value())
 323                 .isEqualTo(JanusGraphOperationStatus.NOT_FOUND);
 324     }
 325
 326     private PolicyTypeDefinition createRootPolicyTypeOnGraph() {
 327         PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
 328         policyTypeOperation.addPolicyType(rootPolicyType);
 329         return rootPolicyType;
 330
 331     }
 332
 333     private PolicyTypeDefinition createPolicyTypeDef() {
 334         return createPolicyTypeDef("tosca.policies.Root", "description: The TOSCA Policy Type all other TOSCA Policy Types derive from", null, new PropertyDefinition[]{});
 335     }
 336
 337     private PolicyTypeDefinition createPolicyTypeDef(PropertyDefinition ... props) {
 338         return createPolicyTypeDef("tosca.policies.Root",  null, props);
 339     }
 340
 341     private PolicyTypeDefinition createPolicyTypeDef(String type, String derivedFrom, PropertyDefinition ... props) {
 342         PolicyTypeDefinition policyType = createPolicyTypeDef(type, "description: The TOSCA Policy Type all other TOSCA Policy Types derive from", derivedFrom);
 343         policyType.setProperties(asList(props));
 344         return policyType;
 345     }
 346
 347     private PolicyTypeDefinition createPolicyTypeDef(String type, String description, String derivedFrom) {
 348         return createPolicyTypeDef(type, description, derivedFrom, null);
 349     }
 350
 351     private PolicyTypeDefinition createPolicyTypeDef(String type, String description, String derivedFrom,  PropertyDefinition ... props) {
 352         PolicyTypeDataDefinition policyTypeDataDefinition = new PolicyTypeDataDefinition();
 353         policyTypeDataDefinition.setDescription(description);
 354         policyTypeDataDefinition.setType(type);
 355         policyTypeDataDefinition.setName(type + "name");
 356         policyTypeDataDefinition.setIcon(type + "icon");
 357         policyTypeDataDefinition.setDerivedFrom(derivedFrom);
 358         PolicyTypeDefinition policyTypeDefinition = new PolicyTypeDefinition(policyTypeDataDefinition);
 359         policyTypeDefinition.setHighestVersion(true);
 360         policyTypeDefinition.setVersion("1.0");
 361         if (props != null) {
 362             policyTypeDefinition.setProperties(asList(props));
 363         }
 364         return policyTypeDefinition;
 365     }
 366
 367     private void addPolicyTypesToDB(PolicyTypeDefinition ... policyTypeDefinitions) {
 368         Stream.of(policyTypeDefinitions).forEach(policyTypeOperation::addPolicyType);
 369     }
 370
 371
 372 }