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