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

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