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

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