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