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-2020 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.assertThatThrownBy;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertNotEquals;
  27 import static org.junit.Assert.assertTrue;
  28
  29 import java.util.ArrayList;
  30 import java.util.List;
  31 import java.util.Properties;
  32 import org.eclipse.persistence.config.PersistenceUnitProperties;
  33 import org.junit.After;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.onap.policy.common.utils.coder.StandardCoder;
  37 import org.onap.policy.common.utils.resources.ResourceUtils;
  38 import org.onap.policy.models.base.PfModelException;
  39 import org.onap.policy.models.base.Validated;
  40 import org.onap.policy.models.dao.DaoParameters;
  41 import org.onap.policy.models.dao.PfDao;
  42 import org.onap.policy.models.dao.PfDaoFactory;
  43 import org.onap.policy.models.dao.impl.DefaultPfDao;
  44 import org.onap.policy.models.pdp.concepts.Pdp;
  45 import org.onap.policy.models.pdp.concepts.PdpGroup;
  46 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  47 import org.onap.policy.models.pdp.concepts.PdpGroups;
  48 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  49 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  50 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
  51 import org.onap.policy.models.pdp.enums.PdpState;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  53 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
  54
  55 /**
  56  * Test the {@link SimpleToscaProvider} class.
  57  *
  58  * @author Liam Fallon (liam.fallon@est.tech)
  59  */
  60 public class PdpProviderTest {
  61     private static final String PDP_GROUPS0_JSON = "testdata/PdpGroups0.json";
  62     private static final String PDP_TYPE_IS_NULL = "pdpType is marked .*ull but is null";
  63     private static final String SUBGROUP_IS_NULL = "pdpSubGroup is marked .*ull but is null";
  64     private static final String GROUP_IS_NULL = "pdpGroupName is marked .*ull but is null";
  65     private static final String DAO_IS_NULL = "dao is marked .*ull but is null";
  66     private static final String PDP_GROUP0 = "PdpGroup0";
  67     private PfDao pfDao;
  68     private StandardCoder standardCoder;
  69
  70
  71     /**
  72      * Set up the DAO towards the database.
  73      *
  74      * @throws Exception on database errors
  75      */
  76     @Before
  77     public void setupDao() throws Exception {
  78         final DaoParameters daoParameters = new DaoParameters();
  79         daoParameters.setPluginClass(DefaultPfDao.class.getName());
  80
  81         daoParameters.setPersistenceUnit("ToscaConceptTest");
  82
  83         Properties jdbcProperties = new Properties();
  84         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "policy");
  85         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "P01icY");
  86
  87         // H2, use "org.mariadb.jdbc.Driver" and "jdbc:mariadb://localhost:3306/policy" for locally installed MariaDB
  88         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
  89         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:testdb");
  90
  91         daoParameters.setJdbcProperties(jdbcProperties);
  92
  93         pfDao = new PfDaoFactory().createPfDao(daoParameters);
  94         pfDao.init(daoParameters);
  95     }
  96
  97     /**
  98      * Set up GSON.
  99      */
 100     @Before
 101     public void setupGson() {
 102         standardCoder = new StandardCoder();
 103     }
 104
 105     @After
 106     public void teardown() {
 107         pfDao.close();
 108     }
 109
 110     @Test
 111     public void testGroupsGet() throws Exception {
 112         assertThatThrownBy(() -> {
 113             new PdpProvider().getPdpGroups(null, null);
 114         }).hasMessageMatching(DAO_IS_NULL);
 115
 116         assertThatThrownBy(() -> {
 117             new PdpProvider().getPdpGroups(null, "name");
 118         }).hasMessageMatching(DAO_IS_NULL);
 119
 120         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 121         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 122
 123         PdpGroups createdPdpGroups0 = new PdpGroups();
 124         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 125         String createdJson = standardCoder.encode(createdPdpGroups0);
 126         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 127
 128         PdpGroups gotPdpGroups0 = new PdpGroups();
 129         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 130
 131         String gotJson = standardCoder.encode(gotPdpGroups0);
 132
 133         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 134     }
 135
 136     @Test
 137     public void testFilteredPdpGroupGet() throws Exception {
 138         assertThatThrownBy(() -> {
 139             new PdpProvider().getFilteredPdpGroups(null, null);
 140         }).hasMessageMatching(DAO_IS_NULL);
 141
 142         assertThatThrownBy(() -> {
 143             new PdpProvider().getFilteredPdpGroups(null, PdpGroupFilter.builder().build());
 144         }).hasMessageMatching(DAO_IS_NULL);
 145
 146         assertThatThrownBy(() -> {
 147             new PdpProvider().getFilteredPdpGroups(pfDao, null);
 148         }).hasMessageMatching("filter is marked .*ull but is null");
 149
 150         String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsForFiltering.json");
 151         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 152
 153         assertEquals(5, new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()).size());
 154
 155         List<ToscaConceptIdentifier> policyTypeList = new ArrayList<>();
 156         policyTypeList.add(new ToscaConceptIdentifier("policy.type.0", "1.2.3"));
 157
 158         List<ToscaConceptIdentifier> policyList = new ArrayList<>();
 159         policyList.add(new ToscaConceptIdentifier("Policy0", "4.5.6"));
 160
 161         // @formatter:off
 162         final PdpGroupFilter filter = PdpGroupFilter.builder()
 163                 .groupState(PdpState.PASSIVE)
 164                 .name(PDP_GROUP0)
 165                 .matchPoliciesExactly(false)
 166                 .matchPolicyTypesExactly(false)
 167                 .pdpState(PdpState.PASSIVE)
 168                 .pdpType("APEX")
 169                 .policyTypeList(policyTypeList)
 170                 .policyList(policyList)
 171                 .build();
 172         // @formatter:on
 173         assertEquals(1, new PdpProvider().getFilteredPdpGroups(pfDao, filter).size());
 174     }
 175
 176     @Test
 177     public void testGroupsCreate() throws Exception {
 178         assertThatThrownBy(() -> {
 179             new PdpProvider().createPdpGroups(null, null);
 180         }).hasMessageMatching(DAO_IS_NULL);
 181
 182         assertThatThrownBy(() -> {
 183             new PdpProvider().createPdpGroups(null, new ArrayList<>());
 184         }).hasMessageMatching(DAO_IS_NULL);
 185
 186         assertThatThrownBy(() -> {
 187             new PdpProvider().createPdpGroups(pfDao, null);
 188         }).hasMessageMatching("pdpGroups is marked .*ull but is null");
 189
 190         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 191         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 192
 193         PdpGroups createdPdpGroups0 = new PdpGroups();
 194         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 195         String createdJson = standardCoder.encode(createdPdpGroups0);
 196         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 197
 198         PdpGroups gotPdpGroups0 = new PdpGroups();
 199         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 200
 201         String gotJson = standardCoder.encode(gotPdpGroups0);
 202         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 203
 204         pdpGroups0.getGroups().get(0).setPdpGroupState(null);
 205         assertThatThrownBy(() -> {
 206             new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups());
 207         }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
 208                         .hasMessageContaining(Validated.IS_NULL);
 209     }
 210
 211     @Test
 212     public void testGroupsCreateNoPdp() throws Exception {
 213         String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsNoPDPs.json");
 214
 215         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 216
 217         PdpGroups createdPdpGroups0 = new PdpGroups();
 218         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 219         assertNotEquals(pdpGroups0, createdPdpGroups0);
 220         pdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).setPdpInstances(new ArrayList<>());
 221         String originalTweakedJson = standardCoder.encode(pdpGroups0);
 222         String createdJson = standardCoder.encode(createdPdpGroups0);
 223         assertEquals(originalTweakedJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 224
 225         PdpGroups gotPdpGroups0 = new PdpGroups();
 226         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, "TestPdpGroup"));
 227
 228         String gotJson = standardCoder.encode(gotPdpGroups0);
 229         assertEquals(originalTweakedJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 230     }
 231
 232     @Test
 233     public void testGroupsUpdate() throws Exception {
 234         assertThatThrownBy(() -> {
 235             new PdpProvider().updatePdpGroups(null, null);
 236         }).hasMessageMatching(DAO_IS_NULL);
 237
 238         assertThatThrownBy(() -> {
 239             new PdpProvider().updatePdpGroups(null, new ArrayList<>());
 240         }).hasMessageMatching(DAO_IS_NULL);
 241
 242         assertThatThrownBy(() -> {
 243             new PdpProvider().updatePdpGroups(pfDao, null);
 244         }).hasMessageMatching("pdpGroups is marked .*ull but is null");
 245
 246         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 247         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 248
 249         PdpGroups createdPdpGroups0 = new PdpGroups();
 250         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 251         String createdJson = standardCoder.encode(createdPdpGroups0);
 252         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 253
 254         PdpGroups gotPdpGroups0 = new PdpGroups();
 255         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 256
 257         String gotJson = standardCoder.encode(gotPdpGroups0);
 258         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 259
 260         String updateJson = ResourceUtils.getResourceAsString("testdata/PdpGroups0Update.json");
 261         PdpGroups updatePdpGroups0 = standardCoder.decode(updateJson, PdpGroups.class);
 262
 263         PdpGroups updatedPdpGroups0 = new PdpGroups();
 264         updatedPdpGroups0.setGroups(new PdpProvider().updatePdpGroups(pfDao, updatePdpGroups0.getGroups()));
 265
 266         List<Pdp> beforePdpInstances = updatePdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
 267         List<Pdp> afterPdpInstances = updatedPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
 268         assertTrue(beforePdpInstances.containsAll(afterPdpInstances));
 269
 270         pdpGroups0.getGroups().get(0).setPdpGroupState(null);
 271         assertThatThrownBy(() -> {
 272             new PdpProvider().updatePdpGroups(pfDao, pdpGroups0.getGroups());
 273         }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
 274                     .hasMessageContaining(Validated.IS_NULL);
 275     }
 276
 277     @Test
 278     public void testPoliciesDelete() throws Exception {
 279         assertThatThrownBy(() -> {
 280             new PdpProvider().deletePdpGroup(null, null);
 281         }).hasMessageMatching(DAO_IS_NULL);
 282
 283         assertThatThrownBy(() -> {
 284             new PdpProvider().deletePdpGroup(null, "name");
 285         }).hasMessageMatching(DAO_IS_NULL);
 286
 287         assertThatThrownBy(() -> {
 288             new PdpProvider().deletePdpGroup(pfDao, null);
 289         }).hasMessageMatching("name is marked .*ull but is null");
 290
 291         assertThatThrownBy(() -> {
 292             new PdpProvider().deletePdpGroup(pfDao, "name");
 293         }).hasMessage("delete of PDP group \"name:0.0.0\" failed, PDP group does not exist");
 294
 295         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 296         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 297
 298         PdpGroups createdPdpGroups0 = new PdpGroups();
 299         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 300         String createdJson = standardCoder.encode(createdPdpGroups0);
 301         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 302
 303         PdpGroups gotPdpGroups0 = new PdpGroups();
 304         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 305
 306         String gotJson = standardCoder.encode(gotPdpGroups0);
 307         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 308
 309         PdpGroup deletedPdpGroup = new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
 310
 311         assertEquals(createdPdpGroups0.getGroups().get(0), deletedPdpGroup);
 312
 313         assertEquals(0, new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0).size());
 314
 315         assertThatThrownBy(() -> {
 316             new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
 317         }).hasMessage("delete of PDP group \"PdpGroup0:0.0.0\" failed, PDP group does not exist");
 318     }
 319
 320     @Test
 321     public void testPdpSubgroupUpdate() throws Exception {
 322         assertThatThrownBy(() -> {
 323             new PdpProvider().updatePdpSubGroup(null, null, null);
 324         }).hasMessageMatching(DAO_IS_NULL);
 325
 326         assertThatThrownBy(() -> {
 327             new PdpProvider().updatePdpSubGroup(null, null, new PdpSubGroup());
 328         }).hasMessageMatching(DAO_IS_NULL);
 329
 330         assertThatThrownBy(() -> {
 331             new PdpProvider().updatePdpSubGroup(null, "name", null);
 332         }).hasMessageMatching(DAO_IS_NULL);
 333
 334         assertThatThrownBy(() -> {
 335             new PdpProvider().updatePdpSubGroup(null, "name", new PdpSubGroup());
 336         }).hasMessageMatching(DAO_IS_NULL);
 337
 338         assertThatThrownBy(() -> {
 339             new PdpProvider().updatePdpSubGroup(pfDao, null, null);
 340         }).hasMessageMatching(GROUP_IS_NULL);
 341
 342         assertThatThrownBy(() -> {
 343             new PdpProvider().updatePdpSubGroup(pfDao, null, new PdpSubGroup());
 344         }).hasMessageMatching(GROUP_IS_NULL);
 345
 346         assertThatThrownBy(() -> {
 347             new PdpProvider().updatePdpSubGroup(pfDao, "name", null);
 348         }).hasMessageMatching(SUBGROUP_IS_NULL);
 349
 350         assertThatThrownBy(() -> {
 351             new PdpProvider().updatePdpSubGroup(pfDao, "name", new PdpSubGroup());
 352         }).hasMessage("parameter \"localName\" is null");
 353
 354         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 355         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 356
 357         PdpGroups createdPdpGroups0 = new PdpGroups();
 358         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 359         String createdJson = standardCoder.encode(createdPdpGroups0);
 360         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 361
 362         PdpGroups gotPdpGroups0 = new PdpGroups();
 363         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 364
 365         String gotJson = standardCoder.encode(gotPdpGroups0);
 366         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 367
 368         PdpSubGroup existingSubGroup = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0);
 369         existingSubGroup.setCurrentInstanceCount(10);
 370         existingSubGroup.setDesiredInstanceCount(10);
 371         new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
 372
 373         List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
 374         assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getCurrentInstanceCount());
 375         assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
 376
 377         existingSubGroup.setDesiredInstanceCount(-1);
 378         assertThatThrownBy(() -> {
 379             new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
 380         }).hasMessageContaining("PDP sub group").hasMessageContaining("desiredInstanceCount")
 381                         .hasMessageContaining("below the minimum value");
 382         existingSubGroup.setDesiredInstanceCount(10);
 383     }
 384
 385     @Test
 386     public void testPdpUpdate() throws Exception {
 387         assertThatThrownBy(() -> {
 388             new PdpProvider().updatePdp(null, null, null, null);
 389         }).hasMessageMatching(DAO_IS_NULL);
 390
 391         assertThatThrownBy(() -> {
 392             new PdpProvider().updatePdp(null, null, null, new Pdp());
 393         }).hasMessageMatching(DAO_IS_NULL);
 394
 395         assertThatThrownBy(() -> {
 396             new PdpProvider().updatePdp(null, null, "TYPE", null);
 397         }).hasMessageMatching(DAO_IS_NULL);
 398
 399         assertThatThrownBy(() -> {
 400             new PdpProvider().updatePdp(null, null, "TYPE", new Pdp());
 401         }).hasMessageMatching(DAO_IS_NULL);
 402
 403         assertThatThrownBy(() -> {
 404             new PdpProvider().updatePdp(null, "name", null, null);
 405         }).hasMessageMatching(DAO_IS_NULL);
 406
 407         assertThatThrownBy(() -> {
 408             new PdpProvider().updatePdp(null, "name", null, new Pdp());
 409         }).hasMessageMatching(DAO_IS_NULL);
 410
 411         assertThatThrownBy(() -> {
 412             new PdpProvider().updatePdp(null, "name", "TYPE", null);
 413         }).hasMessageMatching(DAO_IS_NULL);
 414
 415         assertThatThrownBy(() -> {
 416             new PdpProvider().updatePdp(null, "name", "TYPE", new Pdp());
 417         }).hasMessageMatching(DAO_IS_NULL);
 418
 419         assertThatThrownBy(() -> {
 420             new PdpProvider().updatePdp(pfDao, null, null, null);
 421         }).hasMessageMatching(GROUP_IS_NULL);
 422
 423         assertThatThrownBy(() -> {
 424             new PdpProvider().updatePdp(pfDao, null, null, new Pdp());
 425         }).hasMessageMatching(GROUP_IS_NULL);
 426
 427         assertThatThrownBy(() -> {
 428             new PdpProvider().updatePdp(pfDao, null, "TYPE", null);
 429         }).hasMessageMatching(GROUP_IS_NULL);
 430
 431         assertThatThrownBy(() -> {
 432             new PdpProvider().updatePdp(pfDao, null, "TYPE", new Pdp());
 433         }).hasMessageMatching(GROUP_IS_NULL);
 434
 435         assertThatThrownBy(() -> {
 436             new PdpProvider().updatePdp(pfDao, "name", null, null);
 437         }).hasMessageMatching(SUBGROUP_IS_NULL);
 438
 439         assertThatThrownBy(() -> {
 440             new PdpProvider().updatePdp(pfDao, "name", null, new Pdp());
 441         }).hasMessageMatching(SUBGROUP_IS_NULL);
 442
 443         assertThatThrownBy(() -> {
 444             new PdpProvider().updatePdp(pfDao, "name", "TYPE", null);
 445         }).hasMessageMatching("pdp is marked .*ull but is null");
 446
 447         assertThatThrownBy(() -> {
 448             new PdpProvider().updatePdp(pfDao, "name", "TYPE", new Pdp());
 449         }).hasMessage("parameter \"localName\" is null");
 450
 451         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 452         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 453
 454         PdpGroups createdPdpGroups0 = new PdpGroups();
 455         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 456         String createdJson = standardCoder.encode(createdPdpGroups0);
 457         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 458
 459         PdpGroups gotPdpGroups0 = new PdpGroups();
 460         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 461
 462         String gotJson = standardCoder.encode(gotPdpGroups0);
 463         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 464
 465         Pdp existingPdp = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances().get(0);
 466         existingPdp.setPdpState(PdpState.TEST);
 467         existingPdp.setHealthy(PdpHealthStatus.TEST_IN_PROGRESS);
 468         new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
 469
 470         List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
 471         assertEquals(PdpState.TEST,
 472                 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getPdpState());
 473         assertEquals(PdpHealthStatus.TEST_IN_PROGRESS,
 474                 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getHealthy());
 475
 476         existingPdp.setMessage("");
 477         assertThatThrownBy(() -> {
 478             new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
 479         }).hasMessageContaining("PDP").hasMessageContaining("message").hasMessageContaining(Validated.IS_BLANK);
 480         existingPdp.setMessage("A Message");
 481     }
 482
 483     @Test
 484     public void testGetPdpStatistics() throws PfModelException {
 485         assertThatThrownBy(() -> {
 486             new PdpProvider().getPdpStatistics(null, null);
 487         }).hasMessageMatching(DAO_IS_NULL);
 488
 489         assertThatThrownBy(() -> {
 490             new PdpProvider().getPdpStatistics(null, "name");
 491         }).hasMessageMatching(DAO_IS_NULL);
 492
 493         assertEquals(0, new PdpProvider().getPdpStatistics(pfDao, "name").size());
 494     }
 495
 496     @Test
 497     public void testUpdatePdpStatistics() throws PfModelException {
 498         assertThatThrownBy(() -> {
 499             new PdpProvider().updatePdpStatistics(null, null, null, null, null);
 500         }).hasMessageMatching(DAO_IS_NULL);
 501
 502         assertThatThrownBy(() -> {
 503             new PdpProvider().updatePdpStatistics(null, null, null, null, new PdpStatistics());
 504         }).hasMessageMatching(DAO_IS_NULL);
 505
 506         assertThatThrownBy(() -> {
 507             new PdpProvider().updatePdpStatistics(null, null, null, "inst", null);
 508         }).hasMessageMatching(DAO_IS_NULL);
 509
 510         assertThatThrownBy(() -> {
 511             new PdpProvider().updatePdpStatistics(null, null, null, "inst", new PdpStatistics());
 512         }).hasMessageMatching(DAO_IS_NULL);
 513
 514         assertThatThrownBy(() -> {
 515             new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, null);
 516         }).hasMessageMatching(DAO_IS_NULL);
 517
 518         assertThatThrownBy(() -> {
 519             new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, new PdpStatistics());
 520         }).hasMessageMatching(DAO_IS_NULL);
 521
 522         assertThatThrownBy(() -> {
 523             new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", null);
 524         }).hasMessageMatching(DAO_IS_NULL);
 525
 526         assertThatThrownBy(() -> {
 527             new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", new PdpStatistics());
 528         }).hasMessageMatching(DAO_IS_NULL);
 529
 530         assertThatThrownBy(() -> {
 531             new PdpProvider().updatePdpStatistics(null, "name", null, null, null);
 532         }).hasMessageMatching(DAO_IS_NULL);
 533
 534         assertThatThrownBy(() -> {
 535             new PdpProvider().updatePdpStatistics(null, "name", null, null, new PdpStatistics());
 536         }).hasMessageMatching(DAO_IS_NULL);
 537
 538         assertThatThrownBy(() -> {
 539             new PdpProvider().updatePdpStatistics(null, "name", null, "inst", null);
 540         }).hasMessageMatching(DAO_IS_NULL);
 541
 542         assertThatThrownBy(() -> {
 543             new PdpProvider().updatePdpStatistics(null, "name", null, "inst", new PdpStatistics());
 544         }).hasMessageMatching(DAO_IS_NULL);
 545
 546         assertThatThrownBy(() -> {
 547             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, null);
 548         }).hasMessageMatching(DAO_IS_NULL);
 549
 550         assertThatThrownBy(() -> {
 551             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, new PdpStatistics());
 552         }).hasMessageMatching(DAO_IS_NULL);
 553
 554         assertThatThrownBy(() -> {
 555             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", null);
 556         }).hasMessageMatching(DAO_IS_NULL);
 557
 558         assertThatThrownBy(() -> {
 559             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", new PdpStatistics());
 560         }).hasMessageMatching(DAO_IS_NULL);
 561
 562         assertThatThrownBy(() -> {
 563             new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
 564         }).hasMessageMatching(GROUP_IS_NULL);
 565
 566         assertThatThrownBy(() -> {
 567             new PdpProvider().updatePdpStatistics(pfDao, null, null, null, new PdpStatistics());
 568         }).hasMessageMatching(GROUP_IS_NULL);
 569
 570         assertThatThrownBy(() -> {
 571             new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", null);
 572         }).hasMessageMatching(GROUP_IS_NULL);
 573
 574         assertThatThrownBy(() -> {
 575             new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", new PdpStatistics());
 576         }).hasMessageMatching(GROUP_IS_NULL);
 577
 578         assertThatThrownBy(() -> {
 579             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, null);
 580         }).hasMessageMatching(GROUP_IS_NULL);
 581
 582         assertThatThrownBy(() -> {
 583             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, new PdpStatistics());
 584         }).hasMessageMatching(GROUP_IS_NULL);
 585
 586         assertThatThrownBy(() -> {
 587             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", null);
 588         }).hasMessageMatching(GROUP_IS_NULL);
 589
 590         assertThatThrownBy(() -> {
 591             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", new PdpStatistics());
 592         }).hasMessageMatching(GROUP_IS_NULL);
 593
 594         assertThatThrownBy(() -> {
 595             new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, null);
 596         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 597
 598         assertThatThrownBy(() -> {
 599             new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, new PdpStatistics());
 600         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 601
 602         assertThatThrownBy(() -> {
 603             new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", null);
 604         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 605
 606         assertThatThrownBy(() -> {
 607             new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", new PdpStatistics());
 608         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 609
 610         assertThatThrownBy(() -> {
 611             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, null);
 612         }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
 613
 614         assertThatThrownBy(() -> {
 615             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, new PdpStatistics());
 616         }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
 617
 618         assertThatThrownBy(() -> {
 619             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", null);
 620         }).hasMessageMatching("pdpStatistics is marked .*ull but is null");
 621
 622         new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());
 623     }
 624 }