models-provider/src/test/java/org/onap/policy/models/provider/impl/DatabasePolicyModelsProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2022 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019, 2021 AT&T Intellectual Property. All rights reserved.
   5  *  Modifications Copyright (C) 2020 Bell Canada. 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  *
  19  * SPDX-License-Identifier: Apache-2.0
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.models.provider.impl;
  24
  25 import static org.assertj.core.api.Assertions.assertThat;
  26 import static org.assertj.core.api.Assertions.assertThatCode;
  27 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  28 import static org.junit.Assert.assertEquals;
  29 import static org.junit.Assert.assertNotNull;
  30 import static org.junit.Assert.assertTrue;
  31
  32 import java.time.Instant;
  33 import java.util.ArrayList;
  34 import java.util.List;
  35 import java.util.Map;
  36 import org.junit.After;
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.onap.policy.models.base.PfModelException;
  40 import org.onap.policy.models.pap.concepts.PolicyAudit;
  41 import org.onap.policy.models.pap.concepts.PolicyAudit.AuditAction;
  42 import org.onap.policy.models.pap.persistence.provider.PolicyAuditProvider.AuditFilter;
  43 import org.onap.policy.models.pdp.concepts.Pdp;
  44 import org.onap.policy.models.pdp.concepts.PdpGroup;
  45 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  46 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  47 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  48 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
  49 import org.onap.policy.models.pdp.enums.PdpState;
  50 import org.onap.policy.models.pdp.persistence.provider.PdpFilterParameters;
  51 import org.onap.policy.models.provider.PolicyModelsProvider;
  52 import org.onap.policy.models.provider.PolicyModelsProviderFactory;
  53 import org.onap.policy.models.provider.PolicyModelsProviderParameters;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  55 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
  56 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
  57 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  58 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType;
  59 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  60 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  61 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  62 import org.onap.policy.models.tosca.authorative.concepts.ToscaTopologyTemplate;
  63 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  64
  65 /**
  66  * Test the database models provider implementation.
  67  *
  68  * @author Liam Fallon (liam.fallon@est.tech)
  69  */
  70 public class DatabasePolicyModelsProviderTest {
  71     private static final String NAME = "name";
  72
  73     private static final String TEMPLATE_IS_NULL = "^serviceTemplate is marked .*on.*ull but is null$";
  74
  75     private static final String SUBGROUP_IS_NULL = "^pdpSubGroup is marked .*on.*ull but is null$";
  76
  77     private static final String GROUP_IS_NULL = "^pdpGroupName is marked .*on.*ull but is null$";
  78
  79     private static final String NAME_IS_NULL = "^name is marked .*on.*ull but is null$";
  80
  81     private static final String FILTER_IS_NULL = "^filter is marked .*on.*ull but is null$";
  82
  83     private static final String GROUP = "group";
  84
  85     private static final String VERSION_100 = "1.0.0";
  86
  87     private static final Instant TIMESTAMP = Instant.EPOCH;
  88
  89     private static final String ORDER = "DESC";
  90
  91     private PolicyModelsProviderParameters parameters;
  92
  93     private PolicyModelsProvider databaseProvider;
  94
  95     /**
  96      * Initialize parameters.
  97      */
  98     @Before
  99     public void setupParameters() {
 100         parameters = new PolicyModelsProviderParameters();
 101         parameters.setDatabaseDriver("org.h2.Driver");
 102         parameters.setDatabaseUrl("jdbc:h2:mem:DatabasePolicyModelsProviderTest");
 103         parameters.setDatabaseUser("policy");
 104         parameters.setDatabasePassword("P01icY");
 105         parameters.setPersistenceUnit("ToscaConceptTest");
 106     }
 107
 108     /**
 109      * Closes the DB.
 110      */
 111     @After
 112     public void tearDown() throws PfModelException {
 113         if (databaseProvider != null) {
 114             databaseProvider.close();
 115         }
 116     }
 117
 118     @Test
 119     public void testInitAndClose() throws Exception {
 120         assertThatThrownBy(() -> {
 121             new DatabasePolicyModelsProviderImpl(null);
 122         }).hasMessageMatching("^parameters is marked .*on.*ull but is null$");
 123
 124         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 125
 126         parameters.setDatabaseUrl("jdbc://www.acmecorp.nonexist");
 127
 128         databaseProvider.close();
 129         databaseProvider.init();
 130
 131         databaseProvider.close();
 132
 133         parameters.setDatabaseUrl("jdbc:h2:mem:DatabasePolicyModelsProviderTest");
 134
 135         parameters.setPersistenceUnit("WileECoyote");
 136
 137         assertThatThrownBy(databaseProvider::init).hasMessageContaining("could not create Data Access Object (DAO)");
 138
 139         parameters.setPersistenceUnit("ToscaConceptTest");
 140
 141         databaseProvider.init();
 142         databaseProvider.close();
 143
 144         assertThatThrownBy(() -> {
 145             databaseProvider.init();
 146             databaseProvider.init();
 147         }).hasMessage("provider is already initialized");
 148
 149         databaseProvider.close();
 150
 151         databaseProvider.close();
 152     }
 153
 154     @Test
 155     public void testProviderMethodsNull() throws Exception {
 156
 157         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 158
 159         assertThatThrownBy(() -> {
 160             databaseProvider.getFilteredPolicyTypes(null);
 161         }).hasMessageMatching(FILTER_IS_NULL);
 162
 163         assertThatThrownBy(() -> {
 164             databaseProvider.getFilteredPolicyTypeList(null);
 165         }).hasMessageMatching(FILTER_IS_NULL);
 166
 167         assertThatThrownBy(() -> {
 168             databaseProvider.createPolicyTypes(null);
 169         }).hasMessageMatching(TEMPLATE_IS_NULL);
 170
 171         assertThatThrownBy(() -> {
 172             databaseProvider.updatePolicyTypes(null);
 173         }).hasMessageMatching(TEMPLATE_IS_NULL);
 174
 175         assertThatThrownBy(() -> {
 176             databaseProvider.deletePolicyType(null, null);
 177         }).hasMessageMatching(NAME_IS_NULL);
 178
 179         assertThatThrownBy(() -> {
 180             databaseProvider.deletePolicyType("aaa", null);
 181         }).hasMessageMatching("^version is marked .*on.*ull but is null$");
 182
 183         assertThatThrownBy(() -> {
 184             databaseProvider.deletePolicyType(null, "aaa");
 185         }).hasMessageMatching(NAME_IS_NULL);
 186
 187         assertThatThrownBy(() -> {
 188             databaseProvider.getFilteredPolicies(null);
 189         }).hasMessageMatching(FILTER_IS_NULL);
 190
 191         assertThatThrownBy(() -> {
 192             databaseProvider.getFilteredPolicyList(null);
 193         }).hasMessageMatching(FILTER_IS_NULL);
 194
 195         assertThatThrownBy(() -> {
 196             databaseProvider.createPolicies(null);
 197         }).hasMessageMatching(TEMPLATE_IS_NULL);
 198
 199         assertThatThrownBy(() -> {
 200             databaseProvider.updatePolicies(null);
 201         }).hasMessageMatching(TEMPLATE_IS_NULL);
 202
 203         assertThatThrownBy(() -> {
 204             databaseProvider.deletePolicy(null, null);
 205         }).hasMessageMatching(NAME_IS_NULL);
 206
 207         assertThatThrownBy(() -> {
 208             databaseProvider.deletePolicy(null, "aaa");
 209         }).hasMessageMatching(NAME_IS_NULL);
 210
 211         assertThatThrownBy(() -> {
 212             databaseProvider.deletePolicy("aaa", null);
 213         }).hasMessageMatching("^version is marked .*on.*ull but is null$");
 214     }
 215
 216     @Test
 217     public void testProviderMethodsNullGroup() throws Exception {
 218
 219         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 220
 221         assertThatThrownBy(() -> {
 222             databaseProvider.getFilteredPdpGroups(null);
 223         }).hasMessageMatching(FILTER_IS_NULL);
 224
 225         assertThatThrownBy(() -> {
 226             databaseProvider.createPdpGroups(null);
 227         }).hasMessageMatching("^pdpGroups is marked .*on.*ull but is null$");
 228
 229         assertThatThrownBy(() -> {
 230             databaseProvider.updatePdpGroups(null);
 231         }).hasMessageMatching("^pdpGroups is marked .*on.*ull but is null$");
 232
 233         assertThatThrownBy(() -> {
 234             databaseProvider.updatePdpSubGroup(null, null);
 235         }).hasMessageMatching(GROUP_IS_NULL);
 236
 237         assertThatThrownBy(() -> {
 238             databaseProvider.updatePdpSubGroup(null, new PdpSubGroup());
 239         }).hasMessageMatching(GROUP_IS_NULL);
 240
 241         assertThatThrownBy(() -> {
 242             databaseProvider.updatePdpSubGroup(NAME, null);
 243         }).hasMessageMatching(SUBGROUP_IS_NULL);
 244
 245         assertThatThrownBy(() -> {
 246             databaseProvider.updatePdpSubGroup(NAME, new PdpSubGroup());
 247         }).hasMessage("parameter \"localName\" is null");
 248
 249         assertThatThrownBy(() -> {
 250             databaseProvider.updatePdp(null, null, null);
 251         }).hasMessageMatching(GROUP_IS_NULL);
 252
 253         assertThatThrownBy(() -> {
 254             databaseProvider.updatePdp(null, null, new Pdp());
 255         }).hasMessageMatching(GROUP_IS_NULL);
 256
 257         assertThatThrownBy(() -> {
 258             databaseProvider.updatePdp(null, "sub", null);
 259         }).hasMessageMatching(GROUP_IS_NULL);
 260
 261         assertThatThrownBy(() -> {
 262             databaseProvider.updatePdp(null, "sub", new Pdp());
 263         }).hasMessageMatching(GROUP_IS_NULL);
 264
 265         assertThatThrownBy(() -> {
 266             databaseProvider.updatePdp(NAME, null, null);
 267         }).hasMessageMatching(SUBGROUP_IS_NULL);
 268
 269         assertThatThrownBy(() -> {
 270             databaseProvider.updatePdp(NAME, null, new Pdp());
 271         }).hasMessageMatching(SUBGROUP_IS_NULL);
 272
 273         assertThatThrownBy(() -> {
 274             databaseProvider.updatePdp(NAME, "sub", null);
 275         }).hasMessageMatching("^pdp is marked .*on.*ull but is null$");
 276
 277         assertThatThrownBy(() -> {
 278             databaseProvider.updatePdp(NAME, "sub", new Pdp());
 279         }).hasMessage("parameter \"localName\" is null");
 280
 281         assertThatThrownBy(() -> {
 282             databaseProvider.deletePdpGroup(null);
 283         }).hasMessageMatching(NAME_IS_NULL);
 284
 285         assertThatThrownBy(() -> {
 286             databaseProvider.createPdpStatistics(null);
 287         }).hasMessageMatching("^pdpStatisticsList is marked .*on.*ull but is null$");
 288
 289         assertThatThrownBy(() -> {
 290             databaseProvider.updatePdpStatistics(null);
 291         }).hasMessageMatching("^pdpStatisticsList is marked .*on.*ull but is null$");
 292
 293         assertThatThrownBy(() -> {
 294             databaseProvider.deletePdpStatistics(null, TIMESTAMP);
 295         }).hasMessageMatching(NAME_IS_NULL);
 296
 297         databaseProvider.close();
 298     }
 299
 300     @Test
 301     public void testProviderMethodsNotInit() throws Exception {
 302         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 303
 304         databaseProvider.close();
 305
 306         assertThatThrownBy(() -> {
 307             databaseProvider.getPolicyTypes(NAME, "version");
 308         }).hasMessage("policy models provider is not initilaized");
 309     }
 310
 311     @Test
 312     public void testProviderMethods() throws PfModelException {
 313         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 314
 315         assertThatThrownBy(() -> databaseProvider.getPolicyTypes(NAME, VERSION_100))
 316                 .hasMessage("service template not found in database");
 317
 318         assertTrue(databaseProvider.getPolicyTypeList(NAME, VERSION_100).isEmpty());
 319
 320         assertThatThrownBy(
 321             () -> databaseProvider.getFilteredPolicyTypes(ToscaEntityFilter.<ToscaPolicyType>builder().build()))
 322                         .hasMessage("service template not found in database");
 323
 324         assertTrue(databaseProvider.getFilteredPolicyTypeList(ToscaEntityFilter.<ToscaPolicyType>builder().build())
 325                 .isEmpty());
 326
 327         assertThatThrownBy(() -> {
 328             databaseProvider.createPolicyTypes(new ToscaServiceTemplate());
 329         }).hasMessage("no policy types specified on service template");
 330
 331         assertThatThrownBy(() -> {
 332             databaseProvider.updatePolicyTypes(new ToscaServiceTemplate());
 333         }).hasMessage("no policy types specified on service template");
 334
 335         assertThatThrownBy(() -> databaseProvider.deletePolicyType(NAME, VERSION_100))
 336                 .hasMessage("service template not found in database");
 337
 338         assertThatThrownBy(() -> databaseProvider.getPolicies(NAME, VERSION_100))
 339                 .hasMessage("service template not found in database");
 340
 341         assertTrue(databaseProvider.getPolicyList(NAME, VERSION_100).isEmpty());
 342
 343         assertThatThrownBy(
 344             () -> databaseProvider.getFilteredPolicies(ToscaTypedEntityFilter.<ToscaPolicy>builder().build()))
 345                         .hasMessage("service template not found in database");
 346
 347         assertTrue(databaseProvider.getFilteredPolicyList(ToscaTypedEntityFilter.<ToscaPolicy>builder().build())
 348                 .isEmpty());
 349
 350         assertThatThrownBy(() -> {
 351             databaseProvider.createPolicies(new ToscaServiceTemplate());
 352         }).hasMessage("topology template not specified on service template");
 353
 354         assertThatThrownBy(() -> {
 355             databaseProvider.updatePolicies(new ToscaServiceTemplate());
 356         }).hasMessage("topology template not specified on service template");
 357
 358         assertThatThrownBy(() -> databaseProvider.deletePolicy("Policy", "0.0.0").getToscaTopologyTemplate())
 359                 .hasMessage("service template not found in database");
 360
 361         assertEquals(0, databaseProvider.getPdpGroups(NAME).size());
 362         assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
 363
 364         assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
 365         assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
 366     }
 367
 368     @Test
 369     public void testProviderMethodsInGroups() throws PfModelException {
 370         PdpGroup pdpGroup = new PdpGroup();
 371         pdpGroup.setName(GROUP);
 372         pdpGroup.setVersion("1.2.3");
 373         pdpGroup.setPdpGroupState(PdpState.ACTIVE);
 374         pdpGroup.setPdpSubgroups(new ArrayList<>());
 375         List<PdpGroup> groupList = new ArrayList<>();
 376         groupList.add(pdpGroup);
 377
 378         PdpSubGroup pdpSubGroup = new PdpSubGroup();
 379         pdpSubGroup.setPdpType("type");
 380         pdpSubGroup.setDesiredInstanceCount(123);
 381         pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
 382         pdpSubGroup.getSupportedPolicyTypes().add(new ToscaConceptIdentifier("type", "7.8.9"));
 383         pdpGroup.getPdpSubgroups().add(pdpSubGroup);
 384
 385         Pdp pdp = new Pdp();
 386         pdp.setInstanceId("type-0");
 387         pdp.setMessage("Hello");
 388         pdp.setPdpState(PdpState.ACTIVE);
 389         pdp.setHealthy(PdpHealthStatus.UNKNOWN);
 390         pdpSubGroup.setPdpInstances(new ArrayList<>());
 391         pdpSubGroup.getPdpInstances().add(pdp);
 392
 393         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 394
 395         assertEquals(123,
 396                 databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
 397         assertEquals(1, databaseProvider.getPdpGroups(GROUP).size());
 398
 399         pdpSubGroup.setDesiredInstanceCount(234);
 400         databaseProvider.updatePdpSubGroup(GROUP, pdpSubGroup);
 401         assertEquals(234,
 402                 databaseProvider.getPdpGroups(GROUP).get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
 403
 404         assertEquals("Hello", databaseProvider.getPdpGroups(GROUP).get(0).getPdpSubgroups().get(0).getPdpInstances()
 405                 .get(0).getMessage());
 406         pdp.setMessage("Howdy");
 407         databaseProvider.updatePdp(GROUP, "type", pdp);
 408         assertEquals("Howdy", databaseProvider.getPdpGroups(GROUP).get(0).getPdpSubgroups().get(0).getPdpInstances()
 409                 .get(0).getMessage());
 410
 411         assertThatThrownBy(() -> {
 412             databaseProvider.deletePdpGroup(NAME);
 413         }).hasMessage("delete of PDP group \"name:0.0.0\" failed, PDP group does not exist");
 414
 415         assertEquals(pdpGroup.getName(), databaseProvider.deletePdpGroup(GROUP).getName());
 416
 417         List<PdpStatistics> statisticsArrayList = makePdpStatisticsList();
 418
 419         assertThat(databaseProvider.getFilteredPdpStatistics(PdpFilterParameters.builder().build())).isEmpty();
 420         assertThat(databaseProvider.createPdpStatistics(statisticsArrayList)).hasSize(1);
 421         assertThat(databaseProvider.updatePdpStatistics(statisticsArrayList)).hasSize(1);
 422     }
 423
 424     @Test
 425     public void testProviderMethodsStatistics() throws PfModelException {
 426         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 427         databaseProvider.createPdpStatistics(makePdpStatisticsList());
 428
 429         assertEquals(NAME, databaseProvider.getFilteredPdpStatistics(PdpFilterParameters.builder().build()).get(0)
 430                         .getPdpInstanceId());
 431         assertEquals(NAME, databaseProvider.getFilteredPdpStatistics(
 432                         PdpFilterParameters.builder().group(GROUP).build()).get(0).getPdpInstanceId());
 433         assertEquals(0, databaseProvider.getFilteredPdpStatistics(
 434                         PdpFilterParameters.builder().group(GROUP).startTime(Instant.now()).build()).size());
 435         assertEquals(NAME, databaseProvider
 436                         .getFilteredPdpStatistics(PdpFilterParameters.builder().group(GROUP).endTime(TIMESTAMP).build())
 437                         .get(0).getPdpInstanceId());
 438         assertEquals(0, databaseProvider.getFilteredPdpStatistics(PdpFilterParameters.builder().group(GROUP)
 439                         .startTime(Instant.now()).endTime(Instant.now()).build()).size());
 440
 441         assertEquals(NAME, databaseProvider
 442                         .getFilteredPdpStatistics(PdpFilterParameters.builder().name(NAME).group(GROUP).build()).get(0)
 443                         .getPdpInstanceId());
 444         assertEquals(0, databaseProvider.getFilteredPdpStatistics(PdpFilterParameters.builder().name(NAME).group(GROUP)
 445                         .startTime(Instant.now()).endTime(Instant.now()).build()).size());
 446
 447         assertEquals(NAME,
 448                         databaseProvider.getFilteredPdpStatistics(
 449                                         PdpFilterParameters.builder().name(NAME).group(GROUP).subGroup("type").build())
 450                                         .get(0).getPdpInstanceId());
 451
 452         assertEquals(0, databaseProvider.getFilteredPdpStatistics(
 453                         PdpFilterParameters.builder().name(NAME).group(GROUP).subGroup("type")
 454                             .startTime(Instant.now()).endTime(Instant.now()).build()).size());
 455
 456         assertEquals(NAME, databaseProvider.getFilteredPdpStatistics(
 457                         PdpFilterParameters.builder().name(NAME).group(GROUP).subGroup("type")
 458                             .sortOrder(ORDER).recordNum(1).build()).get(0).getPdpInstanceId());
 459         assertEquals(NAME, databaseProvider.getFilteredPdpStatistics(
 460                         PdpFilterParameters.builder().name(NAME).group(GROUP).subGroup("type")
 461                             .sortOrder(ORDER).recordNum(5).build()).get(0).getPdpInstanceId());
 462         assertEquals(0, databaseProvider.getFilteredPdpStatistics(
 463                         PdpFilterParameters.builder().name(NAME).group(GROUP).subGroup("type")
 464                             .startTime(Instant.now()).endTime(Instant.now())
 465                             .sortOrder(ORDER).recordNum(5).build()).size());
 466
 467         assertEquals(NAME, databaseProvider.deletePdpStatistics(NAME, null).get(0).getPdpInstanceId());
 468         assertThat(databaseProvider.getFilteredPdpStatistics(PdpFilterParameters.builder().build())).isEmpty();
 469
 470         assertThat(databaseProvider.getAllPolicyStatus()).isEmpty();
 471         assertThat(databaseProvider.getAllPolicyStatus(new ToscaConceptIdentifierOptVersion("MyPolicy", null)))
 472                 .isEmpty();
 473         assertThat(databaseProvider.getGroupPolicyStatus(GROUP)).isEmpty();
 474         assertThatCode(() -> databaseProvider.cudPolicyStatus(null, null, null))
 475             .doesNotThrowAnyException();
 476
 477         databaseProvider.close();
 478     }
 479
 480     @Test
 481     public void testDeletePolicyDeployedInSubgroup() throws PfModelException {
 482         List<ToscaConceptIdentifier> policies = new ArrayList<>();
 483
 484         policies.add(new ToscaConceptIdentifier("p0", "0.0.1"));
 485         policies.add(new ToscaConceptIdentifier("p1", "0.0.1"));
 486
 487         List<ToscaConceptIdentifier> supportedPolicyTypes = new ArrayList<>();
 488         supportedPolicyTypes.add(new ToscaConceptIdentifier("pt2", "0.0.1"));
 489
 490         PdpSubGroup subGroup = new PdpSubGroup();
 491         subGroup.setPdpType("pdpType");
 492         subGroup.setSupportedPolicyTypes(supportedPolicyTypes);
 493         subGroup.setPolicies(policies);
 494
 495         List<PdpSubGroup> pdpSubgroups = new ArrayList<>();
 496         pdpSubgroups.add(subGroup);
 497
 498         PdpGroup pdpGroup = new PdpGroup();
 499         pdpGroup.setName("pdpGroup");
 500         pdpGroup.setPdpGroupState(PdpState.PASSIVE);
 501         pdpGroup.setPdpSubgroups(pdpSubgroups);
 502
 503         List<PdpGroup> pdpGroups = new ArrayList<>();
 504         pdpGroups.add(pdpGroup);
 505
 506         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 507
 508         databaseProvider.createPdpGroups(pdpGroups);
 509
 510         assertThatThrownBy(() -> databaseProvider.deletePolicy("p0", "0.0.1"))
 511                 .hasMessageContaining("policy is in use, it is deployed in PDP group pdpGroup subgroup pdpType");
 512
 513         assertThatThrownBy(() -> databaseProvider.deletePolicy("p3", "0.0.1"))
 514                 .hasMessageContaining("service template not found in database");
 515
 516         databaseProvider.close();
 517     }
 518
 519     @Test
 520     public void testDeletePolicyTypeSupportedInSubgroup() throws PfModelException {
 521         List<ToscaConceptIdentifier> supportedPolicyTypes = new ArrayList<>();
 522         supportedPolicyTypes.add(new ToscaConceptIdentifier("pt1", "0.0.1"));
 523         supportedPolicyTypes.add(new ToscaConceptIdentifier("pt2", "0.0.1"));
 524
 525         PdpSubGroup subGroup = new PdpSubGroup();
 526         subGroup.setPdpType("pdpType");
 527         subGroup.setSupportedPolicyTypes(supportedPolicyTypes);
 528
 529         List<PdpSubGroup> pdpSubgroups = new ArrayList<>();
 530         pdpSubgroups.add(subGroup);
 531
 532         PdpGroup pdpGroup = new PdpGroup();
 533         pdpGroup.setName("pdpGroup");
 534         pdpGroup.setPdpGroupState(PdpState.PASSIVE);
 535         pdpGroup.setPdpSubgroups(pdpSubgroups);
 536
 537         List<PdpGroup> pdpGroups = new ArrayList<>();
 538         pdpGroups.add(pdpGroup);
 539
 540         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 541
 542         databaseProvider.createPdpGroups(pdpGroups);
 543
 544         assertThatThrownBy(() -> databaseProvider.deletePolicyType("pt2", "0.0.1"))
 545                 .hasMessageContaining("policy type is in use, it is referenced in PDP group pdpGroup subgroup pdpType");
 546
 547         assertThatThrownBy(() -> databaseProvider.deletePolicyType("pt0", "0.0.1"))
 548                 .hasMessageContaining("service template not found in database");
 549
 550         databaseProvider.close();
 551     }
 552
 553     @Test
 554     public void testCreateAuditRecords() throws PfModelException {
 555         PolicyAudit audit = PolicyAudit.builder().action(AuditAction.DEPLOYMENT).pdpGroup(GROUP).pdpType(GROUP)
 556                 .policy(new ToscaConceptIdentifier(NAME, VERSION_100)).user("user").build();
 557
 558         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 559
 560         databaseProvider.createAuditRecords(List.of(audit));
 561         List<PolicyAudit> createdAudits = databaseProvider.getAuditRecords(AuditFilter.builder().recordNum(10).build());
 562         assertThat(createdAudits).hasSize(1);
 563
 564         List<PolicyAudit> emptyList = databaseProvider
 565                         .getAuditRecords(AuditFilter.builder().action(AuditAction.UNDEPLOYMENT).recordNum(10).build());
 566         assertThat(emptyList).isEmpty();
 567
 568         assertThatThrownBy(() -> databaseProvider.createAuditRecords(null))
 569                 .hasMessageContaining("audits is marked non-null but is null");
 570
 571         databaseProvider.close();
 572     }
 573
 574     @Test
 575     public void testToscaNodeTemplateHandling() throws PfModelException {
 576         databaseProvider = new PolicyModelsProviderFactory().createPolicyModelsProvider(parameters);
 577
 578         ToscaServiceTemplate serviceTemplate = makeNodeTemplate();
 579
 580         assertEquals("1.0.1",
 581             databaseProvider.createToscaNodeTemplates(serviceTemplate).getToscaTopologyTemplate().getNodeTemplates()
 582                 .get("metadataSet1").getVersion());
 583         assertEquals(1, databaseProvider.getNodeTemplateMetadataSets(null, null).size());
 584
 585         ToscaNodeTemplate nodeTemplate1 = serviceTemplate.getToscaTopologyTemplate().getNodeTemplates()
 586             .get("metadataSet1");
 587         nodeTemplate1.setMetadata(Map.of("dummyKey", "updatedValue"));
 588         serviceTemplate.getToscaTopologyTemplate().setNodeTemplates(Map.of("metadataSet1:1.0.1", nodeTemplate1));
 589         assertEquals("updatedValue", databaseProvider.updateToscaNodeTemplates(serviceTemplate)
 590             .getToscaTopologyTemplate().getNodeTemplates().get("metadataSet1").getMetadata().get("dummyKey"));
 591
 592         assertThatThrownBy(() -> {
 593             databaseProvider.deleteToscaNodeTemplate("invalidName", "1.0.1");
 594         }).hasMessage("node template invalidName:1.0.1 not found");
 595
 596         databaseProvider.close();
 597     }
 598
 599     private List<PdpStatistics> makePdpStatisticsList() {
 600         PdpStatistics pdpStatistics = new PdpStatistics();
 601         pdpStatistics.setPdpInstanceId(NAME);
 602         pdpStatistics.setTimeStamp(TIMESTAMP);
 603         pdpStatistics.setPdpGroupName(GROUP);
 604         pdpStatistics.setPdpSubGroupName("type");
 605         List<PdpStatistics> statisticsArrayList = List.of(pdpStatistics);
 606         return statisticsArrayList;
 607     }
 608
 609     private ToscaServiceTemplate makeNodeTemplate() {
 610         ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
 611         serviceTemplate.setToscaDefinitionsVersion("sample:1.1.0");
 612         serviceTemplate.setToscaTopologyTemplate(new ToscaTopologyTemplate());
 613         serviceTemplate.setNodeTypes(Map.of("org.onap.policy.metadataSet:1.0.0", new ToscaNodeType()));
 614         ToscaNodeTemplate nodeTemplate1 = new ToscaNodeTemplate();
 615         nodeTemplate1.setName("metadataSet1");
 616         nodeTemplate1.setVersion("1.0.1");
 617         nodeTemplate1.setType("org.onap.policy.metadataSet");
 618         nodeTemplate1.setTypeVersion("1.0.0");
 619         nodeTemplate1.setMetadata(Map.of("dummyKey", "dummyValue"));
 620
 621         serviceTemplate.getToscaTopologyTemplate().setNodeTemplates(Map.of("metadataSet1", nodeTemplate1));
 622
 623         return serviceTemplate;
 624     }
 625 }