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