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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 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.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.dao.DaoParameters;
  40 import org.onap.policy.models.dao.PfDao;
  41 import org.onap.policy.models.dao.PfDaoFactory;
  42 import org.onap.policy.models.dao.impl.DefaultPfDao;
  43 import org.onap.policy.models.pdp.concepts.Pdp;
  44 import org.onap.policy.models.pdp.concepts.PdpGroup;
  45 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  46 import org.onap.policy.models.pdp.concepts.PdpGroups;
  47 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  48 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  49 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
  50 import org.onap.policy.models.pdp.enums.PdpState;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
  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<ToscaPolicyTypeIdentifier> policyTypeList = new ArrayList<>();
 156         policyTypeList.add(new ToscaPolicyTypeIdentifier("policy.type.0", "1.2.3"));
 157
 158         List<ToscaPolicyIdentifier> policyList = new ArrayList<>();
 159         policyList.add(new ToscaPolicyIdentifier("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("INVALID:pdpGroupState may not be null");
 208     }
 209
 210     @Test
 211     public void testGroupsCreateNoPdp() throws Exception {
 212         String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsNoPDPs.json");
 213
 214         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 215
 216         PdpGroups createdPdpGroups0 = new PdpGroups();
 217         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 218         assertNotEquals(pdpGroups0, createdPdpGroups0);
 219         pdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).setPdpInstances(new ArrayList<>());
 220         String originalTweakedJson = standardCoder.encode(pdpGroups0);
 221         String createdJson = standardCoder.encode(createdPdpGroups0);
 222         assertEquals(originalTweakedJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 223
 224         PdpGroups gotPdpGroups0 = new PdpGroups();
 225         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, "TestPdpGroup"));
 226
 227         String gotJson = standardCoder.encode(gotPdpGroups0);
 228         assertEquals(originalTweakedJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 229     }
 230
 231     @Test
 232     public void testGroupsUpdate() throws Exception {
 233         assertThatThrownBy(() -> {
 234             new PdpProvider().updatePdpGroups(null, null);
 235         }).hasMessageMatching(DAO_IS_NULL);
 236
 237         assertThatThrownBy(() -> {
 238             new PdpProvider().updatePdpGroups(null, new ArrayList<>());
 239         }).hasMessageMatching(DAO_IS_NULL);
 240
 241         assertThatThrownBy(() -> {
 242             new PdpProvider().updatePdpGroups(pfDao, null);
 243         }).hasMessageMatching("pdpGroups is marked .*ull but is null");
 244
 245         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 246         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 247
 248         PdpGroups createdPdpGroups0 = new PdpGroups();
 249         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 250         String createdJson = standardCoder.encode(createdPdpGroups0);
 251         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 252
 253         PdpGroups gotPdpGroups0 = new PdpGroups();
 254         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 255
 256         String gotJson = standardCoder.encode(gotPdpGroups0);
 257         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 258
 259         String updateJson = ResourceUtils.getResourceAsString("testdata/PdpGroups0Update.json");
 260         PdpGroups updatePdpGroups0 = standardCoder.decode(updateJson, PdpGroups.class);
 261
 262         PdpGroups updatedPdpGroups0 = new PdpGroups();
 263         updatedPdpGroups0.setGroups(new PdpProvider().updatePdpGroups(pfDao, updatePdpGroups0.getGroups()));
 264
 265         List<Pdp> beforePdpInstances = updatePdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
 266         List<Pdp> afterPdpInstances = updatedPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
 267         assertTrue(beforePdpInstances.containsAll(afterPdpInstances));
 268
 269         pdpGroups0.getGroups().get(0).setPdpGroupState(null);
 270         assertThatThrownBy(() -> {
 271             new PdpProvider().updatePdpGroups(pfDao, pdpGroups0.getGroups());
 272         }).hasMessageContaining("INVALID:pdpGroupState may not be null");
 273     }
 274
 275     @Test
 276     public void testPoliciesDelete() throws Exception {
 277         assertThatThrownBy(() -> {
 278             new PdpProvider().deletePdpGroup(null, null);
 279         }).hasMessageMatching(DAO_IS_NULL);
 280
 281         assertThatThrownBy(() -> {
 282             new PdpProvider().deletePdpGroup(null, "name");
 283         }).hasMessageMatching(DAO_IS_NULL);
 284
 285         assertThatThrownBy(() -> {
 286             new PdpProvider().deletePdpGroup(pfDao, null);
 287         }).hasMessageMatching("name is marked .*ull but is null");
 288
 289         assertThatThrownBy(() -> {
 290             new PdpProvider().deletePdpGroup(pfDao, "name");
 291         }).hasMessage("delete of PDP group \"name:0.0.0\" failed, PDP group does not exist");
 292
 293         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 294         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 295
 296         PdpGroups createdPdpGroups0 = new PdpGroups();
 297         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 298         String createdJson = standardCoder.encode(createdPdpGroups0);
 299         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 300
 301         PdpGroups gotPdpGroups0 = new PdpGroups();
 302         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 303
 304         String gotJson = standardCoder.encode(gotPdpGroups0);
 305         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 306
 307         PdpGroup deletedPdpGroup = new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
 308
 309         assertEquals(createdPdpGroups0.getGroups().get(0), deletedPdpGroup);
 310
 311         assertEquals(0, new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0).size());
 312
 313         assertThatThrownBy(() -> {
 314             new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
 315         }).hasMessage("delete of PDP group \"PdpGroup0:0.0.0\" failed, PDP group does not exist");
 316     }
 317
 318     @Test
 319     public void testPdpSubgroupUpdate() throws Exception {
 320         assertThatThrownBy(() -> {
 321             new PdpProvider().updatePdpSubGroup(null, null, null);
 322         }).hasMessageMatching(DAO_IS_NULL);
 323
 324         assertThatThrownBy(() -> {
 325             new PdpProvider().updatePdpSubGroup(null, null, new PdpSubGroup());
 326         }).hasMessageMatching(DAO_IS_NULL);
 327
 328         assertThatThrownBy(() -> {
 329             new PdpProvider().updatePdpSubGroup(null, "name", null);
 330         }).hasMessageMatching(DAO_IS_NULL);
 331
 332         assertThatThrownBy(() -> {
 333             new PdpProvider().updatePdpSubGroup(null, "name", new PdpSubGroup());
 334         }).hasMessageMatching(DAO_IS_NULL);
 335
 336         assertThatThrownBy(() -> {
 337             new PdpProvider().updatePdpSubGroup(pfDao, null, null);
 338         }).hasMessageMatching(GROUP_IS_NULL);
 339
 340         assertThatThrownBy(() -> {
 341             new PdpProvider().updatePdpSubGroup(pfDao, null, new PdpSubGroup());
 342         }).hasMessageMatching(GROUP_IS_NULL);
 343
 344         assertThatThrownBy(() -> {
 345             new PdpProvider().updatePdpSubGroup(pfDao, "name", null);
 346         }).hasMessageMatching(SUBGROUP_IS_NULL);
 347
 348         assertThatThrownBy(() -> {
 349             new PdpProvider().updatePdpSubGroup(pfDao, "name", new PdpSubGroup());
 350         }).hasMessage("parameter \"localName\" is null");
 351
 352         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 353         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 354
 355         PdpGroups createdPdpGroups0 = new PdpGroups();
 356         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 357         String createdJson = standardCoder.encode(createdPdpGroups0);
 358         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 359
 360         PdpGroups gotPdpGroups0 = new PdpGroups();
 361         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 362
 363         String gotJson = standardCoder.encode(gotPdpGroups0);
 364         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 365
 366         PdpSubGroup existingSubGroup = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0);
 367         existingSubGroup.setCurrentInstanceCount(10);
 368         existingSubGroup.setDesiredInstanceCount(10);
 369         new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
 370
 371         List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
 372         assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getCurrentInstanceCount());
 373         assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
 374
 375         existingSubGroup.setDesiredInstanceCount(-1);
 376         assertThatThrownBy(() -> {
 377             new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
 378         }).hasMessageContaining("INVALID:the desired instance count of a PDP sub group may not be negative");
 379         existingSubGroup.setDesiredInstanceCount(10);
 380     }
 381
 382     @Test
 383     public void testPdpUpdate() throws Exception {
 384         assertThatThrownBy(() -> {
 385             new PdpProvider().updatePdp(null, null, null, null);
 386         }).hasMessageMatching(DAO_IS_NULL);
 387
 388         assertThatThrownBy(() -> {
 389             new PdpProvider().updatePdp(null, null, null, new Pdp());
 390         }).hasMessageMatching(DAO_IS_NULL);
 391
 392         assertThatThrownBy(() -> {
 393             new PdpProvider().updatePdp(null, null, "TYPE", null);
 394         }).hasMessageMatching(DAO_IS_NULL);
 395
 396         assertThatThrownBy(() -> {
 397             new PdpProvider().updatePdp(null, null, "TYPE", new Pdp());
 398         }).hasMessageMatching(DAO_IS_NULL);
 399
 400         assertThatThrownBy(() -> {
 401             new PdpProvider().updatePdp(null, "name", null, null);
 402         }).hasMessageMatching(DAO_IS_NULL);
 403
 404         assertThatThrownBy(() -> {
 405             new PdpProvider().updatePdp(null, "name", null, new Pdp());
 406         }).hasMessageMatching(DAO_IS_NULL);
 407
 408         assertThatThrownBy(() -> {
 409             new PdpProvider().updatePdp(null, "name", "TYPE", null);
 410         }).hasMessageMatching(DAO_IS_NULL);
 411
 412         assertThatThrownBy(() -> {
 413             new PdpProvider().updatePdp(null, "name", "TYPE", new Pdp());
 414         }).hasMessageMatching(DAO_IS_NULL);
 415
 416         assertThatThrownBy(() -> {
 417             new PdpProvider().updatePdp(pfDao, null, null, null);
 418         }).hasMessageMatching(GROUP_IS_NULL);
 419
 420         assertThatThrownBy(() -> {
 421             new PdpProvider().updatePdp(pfDao, null, null, new Pdp());
 422         }).hasMessageMatching(GROUP_IS_NULL);
 423
 424         assertThatThrownBy(() -> {
 425             new PdpProvider().updatePdp(pfDao, null, "TYPE", null);
 426         }).hasMessageMatching(GROUP_IS_NULL);
 427
 428         assertThatThrownBy(() -> {
 429             new PdpProvider().updatePdp(pfDao, null, "TYPE", new Pdp());
 430         }).hasMessageMatching(GROUP_IS_NULL);
 431
 432         assertThatThrownBy(() -> {
 433             new PdpProvider().updatePdp(pfDao, "name", null, null);
 434         }).hasMessageMatching(SUBGROUP_IS_NULL);
 435
 436         assertThatThrownBy(() -> {
 437             new PdpProvider().updatePdp(pfDao, "name", null, new Pdp());
 438         }).hasMessageMatching(SUBGROUP_IS_NULL);
 439
 440         assertThatThrownBy(() -> {
 441             new PdpProvider().updatePdp(pfDao, "name", "TYPE", null);
 442         }).hasMessageMatching("pdp is marked .*ull but is null");
 443
 444         assertThatThrownBy(() -> {
 445             new PdpProvider().updatePdp(pfDao, "name", "TYPE", new Pdp());
 446         }).hasMessage("parameter \"localName\" is null");
 447
 448         String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
 449         PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
 450
 451         PdpGroups createdPdpGroups0 = new PdpGroups();
 452         createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
 453         String createdJson = standardCoder.encode(createdPdpGroups0);
 454         assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
 455
 456         PdpGroups gotPdpGroups0 = new PdpGroups();
 457         gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
 458
 459         String gotJson = standardCoder.encode(gotPdpGroups0);
 460         assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
 461
 462         Pdp existingPdp = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances().get(0);
 463         existingPdp.setPdpState(PdpState.TEST);
 464         existingPdp.setHealthy(PdpHealthStatus.TEST_IN_PROGRESS);
 465         new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
 466
 467         List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
 468         assertEquals(PdpState.TEST,
 469                 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getPdpState());
 470         assertEquals(PdpHealthStatus.TEST_IN_PROGRESS,
 471                 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getHealthy());
 472
 473         existingPdp.setMessage("");
 474         assertThatThrownBy(() -> {
 475             new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
 476         }).hasMessageContaining("INVALID:message may not be blank");
 477         existingPdp.setMessage("A Message");
 478     }
 479
 480     @Test
 481     public void testGetPdpStatistics() throws PfModelException {
 482         assertThatThrownBy(() -> {
 483             new PdpProvider().getPdpStatistics(null, null);
 484         }).hasMessageMatching(DAO_IS_NULL);
 485
 486         assertThatThrownBy(() -> {
 487             new PdpProvider().getPdpStatistics(null, "name");
 488         }).hasMessageMatching(DAO_IS_NULL);
 489
 490         assertEquals(0, new PdpProvider().getPdpStatistics(pfDao, "name").size());
 491     }
 492
 493     @Test
 494     public void testUpdatePdpStatistics() throws PfModelException {
 495         assertThatThrownBy(() -> {
 496             new PdpProvider().updatePdpStatistics(null, null, null, null, null);
 497         }).hasMessageMatching(DAO_IS_NULL);
 498
 499         assertThatThrownBy(() -> {
 500             new PdpProvider().updatePdpStatistics(null, null, null, null, new PdpStatistics());
 501         }).hasMessageMatching(DAO_IS_NULL);
 502
 503         assertThatThrownBy(() -> {
 504             new PdpProvider().updatePdpStatistics(null, null, null, "inst", null);
 505         }).hasMessageMatching(DAO_IS_NULL);
 506
 507         assertThatThrownBy(() -> {
 508             new PdpProvider().updatePdpStatistics(null, null, null, "inst", new PdpStatistics());
 509         }).hasMessageMatching(DAO_IS_NULL);
 510
 511         assertThatThrownBy(() -> {
 512             new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, null);
 513         }).hasMessageMatching(DAO_IS_NULL);
 514
 515         assertThatThrownBy(() -> {
 516             new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, new PdpStatistics());
 517         }).hasMessageMatching(DAO_IS_NULL);
 518
 519         assertThatThrownBy(() -> {
 520             new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", null);
 521         }).hasMessageMatching(DAO_IS_NULL);
 522
 523         assertThatThrownBy(() -> {
 524             new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", new PdpStatistics());
 525         }).hasMessageMatching(DAO_IS_NULL);
 526
 527         assertThatThrownBy(() -> {
 528             new PdpProvider().updatePdpStatistics(null, "name", null, null, null);
 529         }).hasMessageMatching(DAO_IS_NULL);
 530
 531         assertThatThrownBy(() -> {
 532             new PdpProvider().updatePdpStatistics(null, "name", null, null, new PdpStatistics());
 533         }).hasMessageMatching(DAO_IS_NULL);
 534
 535         assertThatThrownBy(() -> {
 536             new PdpProvider().updatePdpStatistics(null, "name", null, "inst", null);
 537         }).hasMessageMatching(DAO_IS_NULL);
 538
 539         assertThatThrownBy(() -> {
 540             new PdpProvider().updatePdpStatistics(null, "name", null, "inst", new PdpStatistics());
 541         }).hasMessageMatching(DAO_IS_NULL);
 542
 543         assertThatThrownBy(() -> {
 544             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, null);
 545         }).hasMessageMatching(DAO_IS_NULL);
 546
 547         assertThatThrownBy(() -> {
 548             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, new PdpStatistics());
 549         }).hasMessageMatching(DAO_IS_NULL);
 550
 551         assertThatThrownBy(() -> {
 552             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", null);
 553         }).hasMessageMatching(DAO_IS_NULL);
 554
 555         assertThatThrownBy(() -> {
 556             new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", new PdpStatistics());
 557         }).hasMessageMatching(DAO_IS_NULL);
 558
 559         assertThatThrownBy(() -> {
 560             new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
 561         }).hasMessageMatching(GROUP_IS_NULL);
 562
 563         assertThatThrownBy(() -> {
 564             new PdpProvider().updatePdpStatistics(pfDao, null, null, null, new PdpStatistics());
 565         }).hasMessageMatching(GROUP_IS_NULL);
 566
 567         assertThatThrownBy(() -> {
 568             new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", null);
 569         }).hasMessageMatching(GROUP_IS_NULL);
 570
 571         assertThatThrownBy(() -> {
 572             new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", new PdpStatistics());
 573         }).hasMessageMatching(GROUP_IS_NULL);
 574
 575         assertThatThrownBy(() -> {
 576             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, null);
 577         }).hasMessageMatching(GROUP_IS_NULL);
 578
 579         assertThatThrownBy(() -> {
 580             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, new PdpStatistics());
 581         }).hasMessageMatching(GROUP_IS_NULL);
 582
 583         assertThatThrownBy(() -> {
 584             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", null);
 585         }).hasMessageMatching(GROUP_IS_NULL);
 586
 587         assertThatThrownBy(() -> {
 588             new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", new PdpStatistics());
 589         }).hasMessageMatching(GROUP_IS_NULL);
 590
 591         assertThatThrownBy(() -> {
 592             new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, null);
 593         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 594
 595         assertThatThrownBy(() -> {
 596             new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, new PdpStatistics());
 597         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 598
 599         assertThatThrownBy(() -> {
 600             new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", null);
 601         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 602
 603         assertThatThrownBy(() -> {
 604             new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", new PdpStatistics());
 605         }).hasMessageMatching(PDP_TYPE_IS_NULL);
 606
 607         assertThatThrownBy(() -> {
 608             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, null);
 609         }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
 610
 611         assertThatThrownBy(() -> {
 612             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, new PdpStatistics());
 613         }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
 614
 615         assertThatThrownBy(() -> {
 616             new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", null);
 617         }).hasMessageMatching("pdpStatistics is marked .*ull but is null");
 618
 619         new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());
 620     }
 621 }