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