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