models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/provider/PdpProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2021 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019-2021 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.pdp.persistence.provider;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.assertj.core.api.Assertions.assertThatCode;
  26 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertNotEquals;
  29 import static org.junit.Assert.assertTrue;
  30
  31 import java.util.ArrayList;
  32 import java.util.Collections;
  33 import java.util.List;
  34 import java.util.Properties;
  35 import org.eclipse.persistence.config.PersistenceUnitProperties;
  36 import org.junit.After;
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.onap.policy.common.utils.coder.StandardCoder;
  40 import org.onap.policy.common.utils.resources.ResourceUtils;
  41 import org.onap.policy.models.base.PfModelException;
  42 import org.onap.policy.models.base.PfModelRuntimeException;
  43 import org.onap.policy.models.base.Validated;
  44 import org.onap.policy.models.dao.DaoParameters;
  45 import org.onap.policy.models.dao.PfDao;
  46 import org.onap.policy.models.dao.PfDaoFactory;
  47 import org.onap.policy.models.dao.impl.DefaultPfDao;
  48 import org.onap.policy.models.pdp.concepts.Pdp;
  49 import org.onap.policy.models.pdp.concepts.PdpGroup;
  50 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  51 import org.onap.policy.models.pdp.concepts.PdpGroups;
  52 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  53 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
  54 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
  55 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  56 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  57 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
  58 import org.onap.policy.models.pdp.enums.PdpState;
  59 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  60 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
  61 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
  62
  63 /**
  64  * Test the {@link SimpleToscaProvider} class.
  65  *
  66  * @author Liam Fallon (liam.fallon@est.tech)
  67  */
  68 public class PdpProviderTest {
  69     private static final String PDP_GROUPS0_JSON = "testdata/PdpGroups0.json";
  70     private static final String PDP_TYPE_IS_NULL = "pdpType is marked .*ull but is null";
  71     private static final String SUBGROUP_IS_NULL = "pdpSubGroup is marked .*ull but is null";
  72     private static final String GROUP_IS_NULL = "pdpGroupName is marked .*ull but is null";
  73     private static final String DAO_IS_NULL = "dao is marked .*ull but is null";
  74     private static final String PDP_GROUP0 = "PdpGroup0";
  75     private static final String GROUP_A = "groupA";
  76     private static final String GROUP_B = "groupB";
  77     private static final ToscaConceptIdentifier MY_POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3");
  78     private static final ToscaConceptIdentifier MY_POLICY2 = new ToscaConceptIdentifier("MyPolicyB", "2.3.4");
  79
  80     private PfDao pfDao;
  81     private StandardCoder standardCoder;
  82     private PdpPolicyStatusBuilder statusBuilder;
  83
  84
  85     /**
  86      * Set up the DAO towards the database.
  87      *
  88      * @throws Exception on database errors
  89      */
  90     @Before
  91     public void setupDao() throws Exception {
  92         final DaoParameters daoParameters = new DaoParameters();
  93         daoParameters.setPluginClass(DefaultPfDao.class.getName());
  94
  95         daoParameters.setPersistenceUnit("ToscaConceptTest");
  96
  97         Properties jdbcProperties = new Properties();
  98         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "policy");
  99         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "P01icY");
 100
 101         // H2, use "org.mariadb.jdbc.Driver" and "jdbc:mariadb://localhost:3306/policy" for locally installed MariaDB
 102         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
 103         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:testdb");
 104
 105         daoParameters.setJdbcProperties(jdbcProperties);
 106
 107         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 108         pfDao.init(daoParameters);
 109     }
 110
 111     /**
 112      * Set up GSON.
 113      */
 114     @Before
 115     public void setupGson() {
 116         standardCoder = new StandardCoder();
 117     }
 118
 119     /**
 120      * Set up Policy Status builder.
 121      */
 122     @Before
 123     public void setupBuilder() {
 124         ToscaConceptIdentifier policyType = new ToscaConceptIdentifier("MyPolicyType", "1.2.4");
 125
 126         statusBuilder = PdpPolicyStatus.builder().deploy(true).pdpType("MyPdpType").policy(MY_POLICY)
 127                         .policyType(policyType).state(State.SUCCESS);
 128     }
 129
 130     @After
 131     public void teardown() {
 132         pfDao.close();
 133     }
 134
 135     @Test
 136     public void testGroupsGet() throws Exception {
 137         assertThatThrownBy(() -> {
 138             new PdpProvider().getPdpGroups(null, null);
 139         }).hasMessageMatching(DAO_IS_NULL);
 140
 141         assertThatThrownBy(() -> {
 142             new PdpProvider().getPdpGroups(null, "name");
 143         }).hasMessageMatching(DAO_IS_NULL);
 144
 145         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 146         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 147
 148         PdpGroups createdPdpGroups0 = new PdpGroups();
 149         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 150         String createdJson = standardCoder.encode(createdPdpGroups0);
 151         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 152
 153         PdpGroups gotPdpGroups0 = new PdpGroups();
 154         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 155
 156         String gotJson = standardCoder.encode(gotPdpGroups0);
 157
 158         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 159     }
 160
 161     @Test
 162     public void testFilteredPdpGroupGet() throws Exception {
 163         assertThatThrownBy(() -> {
 164             new PdpProvider().getFilteredPdpGroups(null, null);
 165         }).hasMessageMatching(DAO_IS_NULL);
 166
 167         assertThatThrownBy(() -> {
 168             new PdpProvider().getFilteredPdpGroups(null, PdpGroupFilter.builder().build());
 169         }).hasMessageMatching(DAO_IS_NULL);
 170
 171         assertThatThrownBy(() -> {
 172             new PdpProvider().getFilteredPdpGroups(pfDao, null);
 173         }).hasMessageMatching("filter is marked .*ull but is null");
 174
 175         String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsForFiltering.json");
 176         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 177
 178         assertEquals(5, new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()).size());
 179
 180         List<ToscaConceptIdentifier> policyTypeList = new ArrayList<>();
 181         policyTypeList.add(new ToscaConceptIdentifier("policy.type.0", "1.2.3"));
 182
 183         List<ToscaConceptIdentifier> policyList = new ArrayList<>();
 184         policyList.add(new ToscaConceptIdentifier("Policy0", "4.5.6"));
 185
 186         // @formatter:off
 187         final PdpGroupFilter filter = PdpGroupFilter.builder()
 188                 .groupState(PdpState.PASSIVE)
 189                 .name(PDP_GROUP0)
 190                 .matchPoliciesExactly(false)
 191                 .matchPolicyTypesExactly(false)
 192                 .pdpState(PdpState.PASSIVE)
 193                 .pdpType("APEX")
 194                 .policyTypeList(policyTypeList)
 195                 .policyList(policyList)
 196                 .build();
 197         // @formatter:on
 198         assertEquals(1, new PdpProvider().getFilteredPdpGroups(pfDao, filter).size());
 199     }
 200
 201     @Test
 202     public void testGroupsCreate() throws Exception {
 203         assertThatThrownBy(() -> {
 204             new PdpProvider().createPdpGroups(null, null);
 205         }).hasMessageMatching(DAO_IS_NULL);
 206
 207         assertThatThrownBy(() -> {
 208             new PdpProvider().createPdpGroups(null, new ArrayList<>());
 209         }).hasMessageMatching(DAO_IS_NULL);
 210
 211         assertThatThrownBy(() -> {
 212             new PdpProvider().createPdpGroups(pfDao, null);
 213         }).hasMessageMatching("pdpGroups is marked .*ull but is null");
 214
 215         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 216         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 217
 218         PdpGroups createdPdpGroups0 = new PdpGroups();
 219         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 220         String createdJson = standardCoder.encode(createdPdpGroups0);
 221         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 222
 223         PdpGroups gotPdpGroups0 = new PdpGroups();
 224         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 225
 226         String gotJson = standardCoder.encode(gotPdpGroups0);
 227         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 228
 229         pdpGroups0.getGroups().get(0).setPdpGroupState(null);
 230         assertThatThrownBy(() -> {
 231             new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups());
 232         }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
 233                         .hasMessageContaining(Validated.IS_NULL);
 234     }
 235
 236     @Test
 237     public void testGroupsCreateNoPdp() throws Exception {
 238         String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsNoPDPs.json");
 239
 240         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 241
 242         PdpGroups createdPdpGroups0 = new PdpGroups();
 243         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 244         assertNotEquals(pdpGroups0, createdPdpGroups0);
 245         pdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).setPdpInstances(new ArrayList<>());
 246         String originalTweakedJson = standardCoder.encode(pdpGroups0);
 247         String createdJson = standardCoder.encode(createdPdpGroups0);
 248         assertEquals(originalTweakedJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 249
 250         PdpGroups gotPdpGroups0 = new PdpGroups();
 251         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, "TestPdpGroup"));
 252
 253         String gotJson = standardCoder.encode(gotPdpGroups0);
 254         assertEquals(originalTweakedJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 255     }
 256
 257     @Test
 258     public void testGroupsUpdate() throws Exception {
 259         assertThatThrownBy(() -> {
 260             new PdpProvider().updatePdpGroups(null, null);
 261         }).hasMessageMatching(DAO_IS_NULL);
 262
 263         assertThatThrownBy(() -> {
 264             new PdpProvider().updatePdpGroups(null, new ArrayList<>());
 265         }).hasMessageMatching(DAO_IS_NULL);
 266
 267         assertThatThrownBy(() -> {
 268             new PdpProvider().updatePdpGroups(pfDao, null);
 269         }).hasMessageMatching("pdpGroups is marked .*ull but is null");
 270
 271         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 272         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 273
 274         PdpGroups createdPdpGroups0 = new PdpGroups();
 275         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 276         String createdJson = standardCoder.encode(createdPdpGroups0);
 277         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 278
 279         PdpGroups gotPdpGroups0 = new PdpGroups();
 280         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 281
 282         String gotJson = standardCoder.encode(gotPdpGroups0);
 283         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 284
 285         String updateJson = ResourceUtils.getResourceAsString("testdata/PdpGroups0Update.json");
 286         PdpGroups updatePdpGroups0 = standardCoder.decode(updateJson, PdpGroups.class);
 287
 288         PdpGroups updatedPdpGroups0 = new PdpGroups();
 289         updatedPdpGroups0.setGroups(new PdpProvider().updatePdpGroups(pfDao, updatePdpGroups0.getGroups()));
 290
 291         List<Pdp> beforePdpInstances = updatePdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
 292         List<Pdp> afterPdpInstances = updatedPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
 293         assertTrue(beforePdpInstances.containsAll(afterPdpInstances));
 294
 295         pdpGroups0.getGroups().get(0).setPdpGroupState(null);
 296         assertThatThrownBy(() -> {
 297             new PdpProvider().updatePdpGroups(pfDao, pdpGroups0.getGroups());
 298         }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
 299                     .hasMessageContaining(Validated.IS_NULL);
 300     }
 301
 302     @Test
 303     public void testPoliciesDelete() throws Exception {
 304         assertThatThrownBy(() -> {
 305             new PdpProvider().deletePdpGroup(null, null);
 306         }).hasMessageMatching(DAO_IS_NULL);
 307
 308         assertThatThrownBy(() -> {
 309             new PdpProvider().deletePdpGroup(null, "name");
 310         }).hasMessageMatching(DAO_IS_NULL);
 311
 312         assertThatThrownBy(() -> {
 313             new PdpProvider().deletePdpGroup(pfDao, null);
 314         }).hasMessageMatching("name is marked .*ull but is null");
 315
 316         assertThatThrownBy(() -> {
 317             new PdpProvider().deletePdpGroup(pfDao, "name");
 318         }).hasMessage("delete of PDP group \"name:0.0.0\" failed, PDP group does not exist");
 319
 320         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 321         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 322
 323         PdpGroups createdPdpGroups0 = new PdpGroups();
 324         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 325         String createdJson = standardCoder.encode(createdPdpGroups0);
 326         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 327
 328         PdpGroups gotPdpGroups0 = new PdpGroups();
 329         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 330
 331         String gotJson = standardCoder.encode(gotPdpGroups0);
 332         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 333
 334         PdpGroup deletedPdpGroup = new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
 335
 336         assertEquals(createdPdpGroups0.getGroups().get(0), deletedPdpGroup);
 337
 338         assertEquals(0, new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0).size());
 339
 340         assertThatThrownBy(() -> {
 341             new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
 342         }).hasMessage("delete of PDP group \"PdpGroup0:0.0.0\" failed, PDP group does not exist");
 343     }
 344
 345     @Test
 346     public void testPdpSubgroupUpdate() throws Exception {
 347         assertThatThrownBy(() -> {
 348             new PdpProvider().updatePdpSubGroup(null, null, null);
 349         }).hasMessageMatching(DAO_IS_NULL);
 350
 351         assertThatThrownBy(() -> {
 352             new PdpProvider().updatePdpSubGroup(null, null, new PdpSubGroup());
 353         }).hasMessageMatching(DAO_IS_NULL);
 354
 355         assertThatThrownBy(() -> {
 356             new PdpProvider().updatePdpSubGroup(null, "name", null);
 357         }).hasMessageMatching(DAO_IS_NULL);
 358
 359         assertThatThrownBy(() -> {
 360             new PdpProvider().updatePdpSubGroup(null, "name", new PdpSubGroup());
 361         }).hasMessageMatching(DAO_IS_NULL);
 362
 363         assertThatThrownBy(() -> {
 364             new PdpProvider().updatePdpSubGroup(pfDao, null, null);
 365         }).hasMessageMatching(GROUP_IS_NULL);
 366
 367         assertThatThrownBy(() -> {
 368             new PdpProvider().updatePdpSubGroup(pfDao, null, new PdpSubGroup());
 369         }).hasMessageMatching(GROUP_IS_NULL);
 370
 371         assertThatThrownBy(() -> {
 372             new PdpProvider().updatePdpSubGroup(pfDao, "name", null);
 373         }).hasMessageMatching(SUBGROUP_IS_NULL);
 374
 375         assertThatThrownBy(() -> {
 376             new PdpProvider().updatePdpSubGroup(pfDao, "name", new PdpSubGroup());
 377         }).hasMessage("parameter \"localName\" is null");
 378
 379         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 380         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 381
 382         PdpGroups createdPdpGroups0 = new PdpGroups();
 383         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 384         String createdJson = standardCoder.encode(createdPdpGroups0);
 385         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 386
 387         PdpGroups gotPdpGroups0 = new PdpGroups();
 388         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 389
 390         String gotJson = standardCoder.encode(gotPdpGroups0);
 391         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 392
 393         PdpSubGroup existingSubGroup = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0);
 394         existingSubGroup.setCurrentInstanceCount(10);
 395         existingSubGroup.setDesiredInstanceCount(10);
 396         new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
 397
 398         List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
 399         assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getCurrentInstanceCount());
 400         assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
 401
 402         existingSubGroup.setDesiredInstanceCount(-1);
 403         assertThatThrownBy(() -> {
 404             new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
 405         }).hasMessageContaining("PDP sub group").hasMessageContaining("desiredInstanceCount")
 406                         .hasMessageContaining("below the minimum value");
 407         existingSubGroup.setDesiredInstanceCount(10);
 408     }
 409
 410     @Test
 411     public void testPdpUpdate() throws Exception {
 412         assertThatThrownBy(() -> {
 413             new PdpProvider().updatePdp(null, null, null, null);
 414         }).hasMessageMatching(DAO_IS_NULL);
 415
 416         assertThatThrownBy(() -> {
 417             new PdpProvider().updatePdp(null, null, null, new Pdp());
 418         }).hasMessageMatching(DAO_IS_NULL);
 419
 420         assertThatThrownBy(() -> {
 421             new PdpProvider().updatePdp(null, null, "TYPE", null);
 422         }).hasMessageMatching(DAO_IS_NULL);
 423
 424         assertThatThrownBy(() -> {
 425             new PdpProvider().updatePdp(null, null, "TYPE", new Pdp());
 426         }).hasMessageMatching(DAO_IS_NULL);
 427
 428         assertThatThrownBy(() -> {
 429             new PdpProvider().updatePdp(null, "name", null, null);
 430         }).hasMessageMatching(DAO_IS_NULL);
 431
 432         assertThatThrownBy(() -> {
 433             new PdpProvider().updatePdp(null, "name", null, new Pdp());
 434         }).hasMessageMatching(DAO_IS_NULL);
 435
 436         assertThatThrownBy(() -> {
 437             new PdpProvider().updatePdp(null, "name", "TYPE", null);
 438         }).hasMessageMatching(DAO_IS_NULL);
 439
 440         assertThatThrownBy(() -> {
 441             new PdpProvider().updatePdp(null, "name", "TYPE", new Pdp());
 442         }).hasMessageMatching(DAO_IS_NULL);
 443
 444         assertThatThrownBy(() -> {
 445             new PdpProvider().updatePdp(pfDao, null, null, null);
 446         }).hasMessageMatching(GROUP_IS_NULL);
 447
 448         assertThatThrownBy(() -> {
 449             new PdpProvider().updatePdp(pfDao, null, null, new Pdp());
 450         }).hasMessageMatching(GROUP_IS_NULL);
 451
 452         assertThatThrownBy(() -> {
 453             new PdpProvider().updatePdp(pfDao, null, "TYPE", null);
 454         }).hasMessageMatching(GROUP_IS_NULL);
 455
 456         assertThatThrownBy(() -> {
 457             new PdpProvider().updatePdp(pfDao, null, "TYPE", new Pdp());
 458         }).hasMessageMatching(GROUP_IS_NULL);
 459
 460         assertThatThrownBy(() -> {
 461             new PdpProvider().updatePdp(pfDao, "name", null, null);
 462         }).hasMessageMatching(SUBGROUP_IS_NULL);
 463
 464         assertThatThrownBy(() -> {
 465             new PdpProvider().updatePdp(pfDao, "name", null, new Pdp());
 466         }).hasMessageMatching(SUBGROUP_IS_NULL);
 467
 468         assertThatThrownBy(() -> {
 469             new PdpProvider().updatePdp(pfDao, "name", "TYPE", null);
 470         }).hasMessageMatching("pdp is marked .*ull but is null");
 471
 472         assertThatThrownBy(() -> {
 473             new PdpProvider().updatePdp(pfDao, "name", "TYPE", new Pdp());
 474         }).hasMessage("parameter \"localName\" is null");
 475
 476         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 477         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 478
 479         PdpGroups createdPdpGroups0 = new PdpGroups();
 480         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 481         String createdJson = standardCoder.encode(createdPdpGroups0);
 482         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 483
 484         PdpGroups gotPdpGroups0 = new PdpGroups();
 485         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 486
 487         String gotJson = standardCoder.encode(gotPdpGroups0);
 488         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 489
 490         Pdp existingPdp = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances().get(0);
 491         existingPdp.setPdpState(PdpState.TEST);
 492         existingPdp.setHealthy(PdpHealthStatus.TEST_IN_PROGRESS);
 493         new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
 494
 495         List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
 496         assertEquals(PdpState.TEST,
 497                 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getPdpState());
 498         assertEquals(PdpHealthStatus.TEST_IN_PROGRESS,
 499                 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getHealthy());
 500
 501         existingPdp.setMessage("");
 502         assertThatThrownBy(() -> {
 503             new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
 504         }).hasMessageContaining("PDP").hasMessageContaining("message").hasMessageContaining(Validated.IS_BLANK);
 505         existingPdp.setMessage("A Message");
 506     }
 507
 508     @Test
 509     public void testGetPdpStatistics() throws PfModelException {
 510         assertThatThrownBy(() -> {
 511             new PdpProvider().getPdpStatistics(null, null);
 512         }).hasMessageMatching(DAO_IS_NULL);
 513
 514         assertThatThrownBy(() -> {
 515             new PdpProvider().getPdpStatistics(null, "name");
 516         }).hasMessageMatching(DAO_IS_NULL);
 517
 518         assertEquals(0, new PdpProvider().getPdpStatistics(pfDao, "name").size());
 519     }
 520
 521     @Test
 522     public void testUpdatePdpStatistics() throws PfModelException {
 523         assertThatThrownBy(() -> {
 524             new PdpProvider().updatePdpStatistics(null, null, null, null, null);
 525         }).hasMessageMatching(DAO_IS_NULL);
 526
 527         assertThatThrownBy(() -> {
 528             new PdpProvider().updatePdpStatistics(null, null, null, null, new PdpStatistics());
 529         }).hasMessageMatching(DAO_IS_NULL);
 530
 531         assertThatThrownBy(() -> {
 532             new PdpProvider().updatePdpStatistics(null, null, null, "inst", null);
 533         }).hasMessageMatching(DAO_IS_NULL);
 534
 535         assertThatThrownBy(() -> {
 536             new PdpProvider().updatePdpStatistics(null, null, null, "inst", new PdpStatistics());
 537         }).hasMessageMatching(DAO_IS_NULL);
 538
 539         assertThatThrownBy(() -> {
 540             new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, null);
 541         }).hasMessageMatching(DAO_IS_NULL);
 542
 543         assertThatThrownBy(() -> {
 544             new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, new PdpStatistics());
 545         }).hasMessageMatching(DAO_IS_NULL);
 546
 547         assertThatThrownBy(() -> {
 548             new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", null);
 549         }).hasMessageMatching(DAO_IS_NULL);
 550
 551         assertThatThrownBy(() -> {
 552             new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", new PdpStatistics());
 553         }).hasMessageMatching(DAO_IS_NULL);
 554
 555         assertThatThrownBy(() -> {
 556             new PdpProvider().updatePdpStatistics(null, "name", null, null, null);
 557         }).hasMessageMatching(DAO_IS_NULL);
 558
 559         assertThatThrownBy(() -> {
 560             new PdpProvider().updatePdpStatistics(null, "name", null, null, new PdpStatistics());
 561         }).hasMessageMatching(DAO_IS_NULL);
 562
 563         assertThatThrownBy(() -> {
 564             new PdpProvider().updatePdpStatistics(null, "name", null, "inst", null);
 565         }).hasMessageMatching(DAO_IS_NULL);
 566
 567         assertThatThrownBy(() -> {
 568             new PdpProvider().updatePdpStatistics(null, "name", null, "inst", new PdpStatistics());
 569         }).hasMessageMatching(DAO_IS_NULL);
 570
 571         assertThatThrownBy(() -> {
 572             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, null);
 573         }).hasMessageMatching(DAO_IS_NULL);
 574
 575         assertThatThrownBy(() -> {
 576             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, new PdpStatistics());
 577         }).hasMessageMatching(DAO_IS_NULL);
 578
 579         assertThatThrownBy(() -> {
 580             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", null);
 581         }).hasMessageMatching(DAO_IS_NULL);
 582
 583         assertThatThrownBy(() -> {
 584             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", new PdpStatistics());
 585         }).hasMessageMatching(DAO_IS_NULL);
 586
 587         assertThatThrownBy(() -> {
 588             new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
 589         }).hasMessageMatching(GROUP_IS_NULL);
 590
 591         assertThatThrownBy(() -> {
 592             new PdpProvider().updatePdpStatistics(pfDao, null, null, null, new PdpStatistics());
 593         }).hasMessageMatching(GROUP_IS_NULL);
 594
 595         assertThatThrownBy(() -> {
 596             new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", null);
 597         }).hasMessageMatching(GROUP_IS_NULL);
 598
 599         assertThatThrownBy(() -> {
 600             new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", new PdpStatistics());
 601         }).hasMessageMatching(GROUP_IS_NULL);
 602
 603         assertThatThrownBy(() -> {
 604             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, null);
 605         }).hasMessageMatching(GROUP_IS_NULL);
 606
 607         assertThatThrownBy(() -> {
 608             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, new PdpStatistics());
 609         }).hasMessageMatching(GROUP_IS_NULL);
 610
 611         assertThatThrownBy(() -> {
 612             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", null);
 613         }).hasMessageMatching(GROUP_IS_NULL);
 614
 615         assertThatThrownBy(() -> {
 616             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", new PdpStatistics());
 617         }).hasMessageMatching(GROUP_IS_NULL);
 618
 619         assertThatThrownBy(() -> {
 620             new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, null);
 621         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 622
 623         assertThatThrownBy(() -> {
 624             new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, new PdpStatistics());
 625         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 626
 627         assertThatThrownBy(() -> {
 628             new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", null);
 629         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 630
 631         assertThatThrownBy(() -> {
 632             new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", new PdpStatistics());
 633         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 634
 635         assertThatThrownBy(() -> {
 636             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, null);
 637         }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
 638
 639         assertThatThrownBy(() -> {
 640             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, new PdpStatistics());
 641         }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
 642
 643         assertThatThrownBy(() -> {
 644             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", null);
 645         }).hasMessageMatching("pdpStatistics is marked .*ull but is null");
 646
 647         new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());
 648     }
 649
 650     @Test
 651     public void testGetAllPolicyStatusPfDao() throws PfModelException {
 652         assertThatThrownBy(() -> {
 653             new PdpProvider().getAllPolicyStatus(null);
 654         }).hasMessageMatching(DAO_IS_NULL);
 655
 656         assertThat(new PdpProvider().getAllPolicyStatus(pfDao)).isEmpty();
 657
 658         PdpProvider provider = loadDeployments();
 659         assertThat(provider.getAllPolicyStatus(pfDao)).hasSize(5);
 660     }
 661
 662     private PdpProvider loadDeployments() {
 663         PdpProvider provider = new PdpProvider();
 664
 665         // same name, different version
 666         final ToscaConceptIdentifier policy3 = new ToscaConceptIdentifier(MY_POLICY.getName(), "10.20.30");
 667
 668         PdpPolicyStatus id1 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp1").policy(MY_POLICY).build();
 669         PdpPolicyStatus id2 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp2").policy(MY_POLICY2).build();
 670         PdpPolicyStatus id3 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp3").policy(policy3).build();
 671         PdpPolicyStatus id4 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp4").policy(MY_POLICY).build();
 672         PdpPolicyStatus id5 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp5").policy(MY_POLICY2).build();
 673         provider.cudPolicyStatus(pfDao, List.of(id1, id2, id3, id4, id5), null, null);
 674
 675         return provider;
 676     }
 677
 678     @Test
 679     public void testGetAllPolicyStatusPfDaoToscaConceptIdentifierOptVersion() throws PfModelException {
 680         assertThatThrownBy(() -> {
 681             new PdpProvider().getAllPolicyStatus(null, new ToscaConceptIdentifierOptVersion("somePdp", null));
 682         }).hasMessageMatching(DAO_IS_NULL);
 683
 684         assertThatThrownBy(() -> {
 685             new PdpProvider().getAllPolicyStatus(pfDao, null);
 686         }).hasMessageContaining("policy").hasMessageContaining("null");
 687
 688         assertThat(new PdpProvider().getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion("somePdp", null)))
 689                         .isEmpty();
 690
 691         PdpProvider provider = loadDeployments();
 692         assertThat(provider.getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion(MY_POLICY))).hasSize(2);
 693         assertThat(provider.getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion(MY_POLICY.getName(), null)))
 694                         .hasSize(3);
 695     }
 696
 697     @Test
 698     public void testGetGroupPolicyStatus() throws PfModelException {
 699         assertThatThrownBy(() -> {
 700             new PdpProvider().getGroupPolicyStatus(null, "someGroup");
 701         }).hasMessageMatching(DAO_IS_NULL);
 702
 703         assertThatThrownBy(() -> {
 704             new PdpProvider().getGroupPolicyStatus(pfDao, null);
 705         }).hasMessageContaining("group").hasMessageContaining("null");
 706
 707         assertThat(new PdpProvider().getGroupPolicyStatus(pfDao, PDP_GROUP0)).isEmpty();
 708
 709         PdpProvider provider = loadDeployments();
 710         assertThat(provider.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(3);
 711     }
 712
 713     @Test
 714     public void cudPolicyStatus() throws PfModelException {
 715         PdpProvider prov = new PdpProvider();
 716
 717         assertThatThrownBy(() -> prov.cudPolicyStatus(null, List.of(), List.of(), List.of()))
 718                         .hasMessageMatching(DAO_IS_NULL);
 719
 720         // null collections should be OK
 721         assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
 722     }
 723
 724     @Test
 725     public void cudPolicyStatus_Create() throws PfModelException {
 726         PdpProvider prov = new PdpProvider();
 727
 728         PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
 729         PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
 730         PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_B).pdpId("idZ").build();
 731         prov.cudPolicyStatus(pfDao, List.of(idx, idy), null, null);
 732         prov.cudPolicyStatus(pfDao, List.of(idz), null, null);
 733
 734         List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
 735         assertThat(records).hasSize(2);
 736
 737         Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
 738         assertThat(records.get(0)).isEqualTo(idx);
 739         assertThat(records.get(1)).isEqualTo(idy);
 740
 741         records = prov.getGroupPolicyStatus(pfDao, GROUP_B);
 742         assertThat(records).hasSize(1);
 743         assertThat(records.get(0)).isEqualTo(idz);
 744     }
 745
 746     @Test
 747     public void cudPolicyStatus_Update() throws PfModelException {
 748         PdpProvider prov = new PdpProvider();
 749
 750         PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("wId").build();
 751         PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("xId").build();
 752         PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("yId").build();
 753         PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("zId").build();
 754         prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
 755
 756         assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
 757
 758         /*
 759          * Now update some records.
 760          */
 761         idx.setState(State.FAILURE);
 762         idz.setState(State.WAITING);
 763         prov.cudPolicyStatus(pfDao, null, List.of(idx, idz), null);
 764         List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
 765         assertThat(records).hasSize(4);
 766
 767         Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
 768         assertThat(records.get(0)).isEqualTo(idw);
 769         assertThat(records.get(1)).isEqualTo(idx);
 770         assertThat(records.get(2)).isEqualTo(idy);
 771         assertThat(records.get(3)).isEqualTo(idz);
 772     }
 773
 774     @Test
 775     public void cudPolicyStatus_Delete() throws PfModelException {
 776         PdpProvider prov = new PdpProvider();
 777
 778         PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("idW").build();
 779         PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
 780         PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
 781         PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("idZ").build();
 782         prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
 783
 784         assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
 785
 786         /*
 787          * Delete some records and then check again.
 788          */
 789         prov.cudPolicyStatus(pfDao, null, null, List.of(idw, idy));
 790
 791         List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
 792         assertThat(records).hasSize(2);
 793
 794         Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
 795         assertThat(records.get(0)).isEqualTo(idx);
 796         assertThat(records.get(1)).isEqualTo(idz);
 797     }
 798
 799     @Test
 800     public void testFromAuthorativeStatus() throws PfModelException {
 801         PdpProvider prov = new PdpProvider();
 802
 803         assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
 804
 805         PdpPolicyStatus ida = statusBuilder.pdpGroup(GROUP_A).pdpId("idA").build();
 806         PdpPolicyStatus idb = statusBuilder.pdpGroup(GROUP_A).pdpId("idB").build();
 807         PdpPolicyStatus idc = statusBuilder.pdpGroup(GROUP_A).pdpId("idC").build();
 808         PdpPolicyStatus idd = statusBuilder.pdpGroup(GROUP_A).pdpId("idD").build();
 809
 810         // make a couple invalid records
 811         idb.setState(null);
 812         idd.setState(null);
 813
 814         List<PdpPolicyStatus> list = List.of(ida, idb, idc, idd);
 815
 816         // @formatter:off
 817         assertThatCode(() -> prov.cudPolicyStatus(pfDao, list, null, null))
 818             .isInstanceOf(PfModelRuntimeException.class)
 819             .hasMessageContaining("1").hasMessageContaining("3")
 820             .hasMessageNotContaining("0").hasMessageNotContaining("2");
 821         // @formatter:on
 822
 823         assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).isEmpty();
 824     }
 825 }