2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2021 Nordix Foundation.
4 * Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
5 * ================================================================================
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * SPDX-License-Identifier: Apache-2.0
19 * ============LICENSE_END=========================================================
22 package org.onap.policy.models.pdp.persistence.provider;
24 import static org.assertj.core.api.Assertions.assertThat;
25 import static org.assertj.core.api.Assertions.assertThatCode;
26 import static org.assertj.core.api.Assertions.assertThatThrownBy;
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertNotEquals;
29 import static org.junit.Assert.assertTrue;
31 import java.util.ArrayList;
32 import java.util.Collections;
33 import java.util.List;
34 import java.util.Properties;
35 import org.eclipse.persistence.config.PersistenceUnitProperties;
36 import org.junit.After;
37 import org.junit.Before;
38 import org.junit.Test;
39 import org.onap.policy.common.utils.coder.StandardCoder;
40 import org.onap.policy.common.utils.resources.ResourceUtils;
41 import org.onap.policy.models.base.PfModelException;
42 import org.onap.policy.models.base.PfModelRuntimeException;
43 import org.onap.policy.models.base.Validated;
44 import org.onap.policy.models.dao.DaoParameters;
45 import org.onap.policy.models.dao.PfDao;
46 import org.onap.policy.models.dao.PfDaoFactory;
47 import org.onap.policy.models.dao.impl.DefaultPfDao;
48 import org.onap.policy.models.pdp.concepts.Pdp;
49 import org.onap.policy.models.pdp.concepts.PdpGroup;
50 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
51 import org.onap.policy.models.pdp.concepts.PdpGroups;
52 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
53 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
54 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
55 import org.onap.policy.models.pdp.concepts.PdpStatistics;
56 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
57 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
58 import org.onap.policy.models.pdp.enums.PdpState;
59 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
60 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
61 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
64 * Test the {@link SimpleToscaProvider} class.
66 * @author Liam Fallon (liam.fallon@est.tech)
68 public class PdpProviderTest {
69 private static final String PDP_GROUPS0_JSON = "testdata/PdpGroups0.json";
70 private static final String PDP_TYPE_IS_NULL = "pdpType is marked .*ull but is null";
71 private static final String SUBGROUP_IS_NULL = "pdpSubGroup is marked .*ull but is null";
72 private static final String GROUP_IS_NULL = "pdpGroupName is marked .*ull but is null";
73 private static final String DAO_IS_NULL = "dao is marked .*ull but is null";
74 private static final String PDP_GROUP0 = "PdpGroup0";
75 private static final String GROUP_A = "groupA";
76 private static final String GROUP_B = "groupB";
77 private static final ToscaConceptIdentifier MY_POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3");
78 private static final ToscaConceptIdentifier MY_POLICY2 = new ToscaConceptIdentifier("MyPolicyB", "2.3.4");
81 private StandardCoder standardCoder;
82 private PdpPolicyStatusBuilder statusBuilder;
86 * Set up the DAO towards the database.
88 * @throws Exception on database errors
91 public void setupDao() throws Exception {
92 final DaoParameters daoParameters = new DaoParameters();
93 daoParameters.setPluginClass(DefaultPfDao.class.getName());
95 daoParameters.setPersistenceUnit("ToscaConceptTest");
97 Properties jdbcProperties = new Properties();
98 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "policy");
99 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "P01icY");
101 // H2, use "org.mariadb.jdbc.Driver" and "jdbc:mariadb://localhost:3306/policy" for locally installed MariaDB
102 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
103 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:testdb");
105 daoParameters.setJdbcProperties(jdbcProperties);
107 pfDao = new PfDaoFactory().createPfDao(daoParameters);
108 pfDao.init(daoParameters);
115 public void setupGson() {
116 standardCoder = new StandardCoder();
120 * Set up Policy Status builder.
123 public void setupBuilder() {
124 ToscaConceptIdentifier policyType = new ToscaConceptIdentifier("MyPolicyType", "1.2.4");
126 statusBuilder = PdpPolicyStatus.builder().deploy(true).pdpType("MyPdpType").policy(MY_POLICY)
127 .policyType(policyType).state(State.SUCCESS);
131 public void teardown() {
136 public void testGroupsGet() throws Exception {
137 assertThatThrownBy(() -> {
138 new PdpProvider().getPdpGroups(null, null);
139 }).hasMessageMatching(DAO_IS_NULL);
141 assertThatThrownBy(() -> {
142 new PdpProvider().getPdpGroups(null, "name");
143 }).hasMessageMatching(DAO_IS_NULL);
145 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
146 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
148 PdpGroups createdPdpGroups0 = new PdpGroups();
149 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
150 String createdJson = standardCoder.encode(createdPdpGroups0);
151 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
153 PdpGroups gotPdpGroups0 = new PdpGroups();
154 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
156 String gotJson = standardCoder.encode(gotPdpGroups0);
158 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
162 public void testFilteredPdpGroupGet() throws Exception {
163 assertThatThrownBy(() -> {
164 new PdpProvider().getFilteredPdpGroups(null, null);
165 }).hasMessageMatching(DAO_IS_NULL);
167 assertThatThrownBy(() -> {
168 new PdpProvider().getFilteredPdpGroups(null, PdpGroupFilter.builder().build());
169 }).hasMessageMatching(DAO_IS_NULL);
171 assertThatThrownBy(() -> {
172 new PdpProvider().getFilteredPdpGroups(pfDao, null);
173 }).hasMessageMatching("filter is marked .*ull but is null");
175 String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsForFiltering.json");
176 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
178 assertEquals(5, new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()).size());
180 List<ToscaConceptIdentifier> policyTypeList = new ArrayList<>();
181 policyTypeList.add(new ToscaConceptIdentifier("policy.type.0", "1.2.3"));
183 List<ToscaConceptIdentifier> policyList = new ArrayList<>();
184 policyList.add(new ToscaConceptIdentifier("Policy0", "4.5.6"));
187 final PdpGroupFilter filter = PdpGroupFilter.builder()
188 .groupState(PdpState.PASSIVE)
190 .matchPoliciesExactly(false)
191 .matchPolicyTypesExactly(false)
192 .pdpState(PdpState.PASSIVE)
194 .policyTypeList(policyTypeList)
195 .policyList(policyList)
198 assertEquals(1, new PdpProvider().getFilteredPdpGroups(pfDao, filter).size());
202 public void testGroupsCreate() throws Exception {
203 assertThatThrownBy(() -> {
204 new PdpProvider().createPdpGroups(null, null);
205 }).hasMessageMatching(DAO_IS_NULL);
207 assertThatThrownBy(() -> {
208 new PdpProvider().createPdpGroups(null, new ArrayList<>());
209 }).hasMessageMatching(DAO_IS_NULL);
211 assertThatThrownBy(() -> {
212 new PdpProvider().createPdpGroups(pfDao, null);
213 }).hasMessageMatching("pdpGroups is marked .*ull but is null");
215 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
216 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
218 PdpGroups createdPdpGroups0 = new PdpGroups();
219 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
220 String createdJson = standardCoder.encode(createdPdpGroups0);
221 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
223 PdpGroups gotPdpGroups0 = new PdpGroups();
224 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
226 String gotJson = standardCoder.encode(gotPdpGroups0);
227 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
229 pdpGroups0.getGroups().get(0).setPdpGroupState(null);
230 assertThatThrownBy(() -> {
231 new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups());
232 }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
233 .hasMessageContaining(Validated.IS_NULL);
237 public void testGroupsCreateNoPdp() throws Exception {
238 String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsNoPDPs.json");
240 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
242 PdpGroups createdPdpGroups0 = new PdpGroups();
243 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
244 assertNotEquals(pdpGroups0, createdPdpGroups0);
245 pdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).setPdpInstances(new ArrayList<>());
246 String originalTweakedJson = standardCoder.encode(pdpGroups0);
247 String createdJson = standardCoder.encode(createdPdpGroups0);
248 assertEquals(originalTweakedJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
250 PdpGroups gotPdpGroups0 = new PdpGroups();
251 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, "TestPdpGroup"));
253 String gotJson = standardCoder.encode(gotPdpGroups0);
254 assertEquals(originalTweakedJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
258 public void testGroupsUpdate() throws Exception {
259 assertThatThrownBy(() -> {
260 new PdpProvider().updatePdpGroups(null, null);
261 }).hasMessageMatching(DAO_IS_NULL);
263 assertThatThrownBy(() -> {
264 new PdpProvider().updatePdpGroups(null, new ArrayList<>());
265 }).hasMessageMatching(DAO_IS_NULL);
267 assertThatThrownBy(() -> {
268 new PdpProvider().updatePdpGroups(pfDao, null);
269 }).hasMessageMatching("pdpGroups is marked .*ull but is null");
271 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
272 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
274 PdpGroups createdPdpGroups0 = new PdpGroups();
275 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
276 String createdJson = standardCoder.encode(createdPdpGroups0);
277 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
279 PdpGroups gotPdpGroups0 = new PdpGroups();
280 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
282 String gotJson = standardCoder.encode(gotPdpGroups0);
283 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
285 String updateJson = ResourceUtils.getResourceAsString("testdata/PdpGroups0Update.json");
286 PdpGroups updatePdpGroups0 = standardCoder.decode(updateJson, PdpGroups.class);
288 PdpGroups updatedPdpGroups0 = new PdpGroups();
289 updatedPdpGroups0.setGroups(new PdpProvider().updatePdpGroups(pfDao, updatePdpGroups0.getGroups()));
291 List<Pdp> beforePdpInstances = updatePdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
292 List<Pdp> afterPdpInstances = updatedPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
293 assertTrue(beforePdpInstances.containsAll(afterPdpInstances));
295 pdpGroups0.getGroups().get(0).setPdpGroupState(null);
296 assertThatThrownBy(() -> {
297 new PdpProvider().updatePdpGroups(pfDao, pdpGroups0.getGroups());
298 }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
299 .hasMessageContaining(Validated.IS_NULL);
303 public void testPoliciesDelete() throws Exception {
304 assertThatThrownBy(() -> {
305 new PdpProvider().deletePdpGroup(null, null);
306 }).hasMessageMatching(DAO_IS_NULL);
308 assertThatThrownBy(() -> {
309 new PdpProvider().deletePdpGroup(null, "name");
310 }).hasMessageMatching(DAO_IS_NULL);
312 assertThatThrownBy(() -> {
313 new PdpProvider().deletePdpGroup(pfDao, null);
314 }).hasMessageMatching("name is marked .*ull but is null");
316 assertThatThrownBy(() -> {
317 new PdpProvider().deletePdpGroup(pfDao, "name");
318 }).hasMessage("delete of PDP group \"name:0.0.0\" failed, PDP group does not exist");
320 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
321 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
323 PdpGroups createdPdpGroups0 = new PdpGroups();
324 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
325 String createdJson = standardCoder.encode(createdPdpGroups0);
326 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
328 PdpGroups gotPdpGroups0 = new PdpGroups();
329 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
331 String gotJson = standardCoder.encode(gotPdpGroups0);
332 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
334 PdpGroup deletedPdpGroup = new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
336 assertEquals(createdPdpGroups0.getGroups().get(0), deletedPdpGroup);
338 assertEquals(0, new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0).size());
340 assertThatThrownBy(() -> {
341 new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
342 }).hasMessage("delete of PDP group \"PdpGroup0:0.0.0\" failed, PDP group does not exist");
346 public void testPdpSubgroupUpdate() throws Exception {
347 assertThatThrownBy(() -> {
348 new PdpProvider().updatePdpSubGroup(null, null, null);
349 }).hasMessageMatching(DAO_IS_NULL);
351 assertThatThrownBy(() -> {
352 new PdpProvider().updatePdpSubGroup(null, null, new PdpSubGroup());
353 }).hasMessageMatching(DAO_IS_NULL);
355 assertThatThrownBy(() -> {
356 new PdpProvider().updatePdpSubGroup(null, "name", null);
357 }).hasMessageMatching(DAO_IS_NULL);
359 assertThatThrownBy(() -> {
360 new PdpProvider().updatePdpSubGroup(null, "name", new PdpSubGroup());
361 }).hasMessageMatching(DAO_IS_NULL);
363 assertThatThrownBy(() -> {
364 new PdpProvider().updatePdpSubGroup(pfDao, null, null);
365 }).hasMessageMatching(GROUP_IS_NULL);
367 assertThatThrownBy(() -> {
368 new PdpProvider().updatePdpSubGroup(pfDao, null, new PdpSubGroup());
369 }).hasMessageMatching(GROUP_IS_NULL);
371 assertThatThrownBy(() -> {
372 new PdpProvider().updatePdpSubGroup(pfDao, "name", null);
373 }).hasMessageMatching(SUBGROUP_IS_NULL);
375 assertThatThrownBy(() -> {
376 new PdpProvider().updatePdpSubGroup(pfDao, "name", new PdpSubGroup());
377 }).hasMessage("parameter \"localName\" is null");
379 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
380 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
382 PdpGroups createdPdpGroups0 = new PdpGroups();
383 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
384 String createdJson = standardCoder.encode(createdPdpGroups0);
385 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
387 PdpGroups gotPdpGroups0 = new PdpGroups();
388 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
390 String gotJson = standardCoder.encode(gotPdpGroups0);
391 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
393 PdpSubGroup existingSubGroup = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0);
394 existingSubGroup.setCurrentInstanceCount(10);
395 existingSubGroup.setDesiredInstanceCount(10);
396 new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
398 List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
399 assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getCurrentInstanceCount());
400 assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
402 existingSubGroup.setDesiredInstanceCount(-1);
403 assertThatThrownBy(() -> {
404 new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
405 }).hasMessageContaining("PDP sub group").hasMessageContaining("desiredInstanceCount")
406 .hasMessageContaining("below the minimum value");
407 existingSubGroup.setDesiredInstanceCount(10);
411 public void testPdpUpdate() throws Exception {
412 assertThatThrownBy(() -> {
413 new PdpProvider().updatePdp(null, null, null, null);
414 }).hasMessageMatching(DAO_IS_NULL);
416 assertThatThrownBy(() -> {
417 new PdpProvider().updatePdp(null, null, null, new Pdp());
418 }).hasMessageMatching(DAO_IS_NULL);
420 assertThatThrownBy(() -> {
421 new PdpProvider().updatePdp(null, null, "TYPE", null);
422 }).hasMessageMatching(DAO_IS_NULL);
424 assertThatThrownBy(() -> {
425 new PdpProvider().updatePdp(null, null, "TYPE", new Pdp());
426 }).hasMessageMatching(DAO_IS_NULL);
428 assertThatThrownBy(() -> {
429 new PdpProvider().updatePdp(null, "name", null, null);
430 }).hasMessageMatching(DAO_IS_NULL);
432 assertThatThrownBy(() -> {
433 new PdpProvider().updatePdp(null, "name", null, new Pdp());
434 }).hasMessageMatching(DAO_IS_NULL);
436 assertThatThrownBy(() -> {
437 new PdpProvider().updatePdp(null, "name", "TYPE", null);
438 }).hasMessageMatching(DAO_IS_NULL);
440 assertThatThrownBy(() -> {
441 new PdpProvider().updatePdp(null, "name", "TYPE", new Pdp());
442 }).hasMessageMatching(DAO_IS_NULL);
444 assertThatThrownBy(() -> {
445 new PdpProvider().updatePdp(pfDao, null, null, null);
446 }).hasMessageMatching(GROUP_IS_NULL);
448 assertThatThrownBy(() -> {
449 new PdpProvider().updatePdp(pfDao, null, null, new Pdp());
450 }).hasMessageMatching(GROUP_IS_NULL);
452 assertThatThrownBy(() -> {
453 new PdpProvider().updatePdp(pfDao, null, "TYPE", null);
454 }).hasMessageMatching(GROUP_IS_NULL);
456 assertThatThrownBy(() -> {
457 new PdpProvider().updatePdp(pfDao, null, "TYPE", new Pdp());
458 }).hasMessageMatching(GROUP_IS_NULL);
460 assertThatThrownBy(() -> {
461 new PdpProvider().updatePdp(pfDao, "name", null, null);
462 }).hasMessageMatching(SUBGROUP_IS_NULL);
464 assertThatThrownBy(() -> {
465 new PdpProvider().updatePdp(pfDao, "name", null, new Pdp());
466 }).hasMessageMatching(SUBGROUP_IS_NULL);
468 assertThatThrownBy(() -> {
469 new PdpProvider().updatePdp(pfDao, "name", "TYPE", null);
470 }).hasMessageMatching("pdp is marked .*ull but is null");
472 assertThatThrownBy(() -> {
473 new PdpProvider().updatePdp(pfDao, "name", "TYPE", new Pdp());
474 }).hasMessage("parameter \"localName\" is null");
476 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
477 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
479 PdpGroups createdPdpGroups0 = new PdpGroups();
480 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
481 String createdJson = standardCoder.encode(createdPdpGroups0);
482 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
484 PdpGroups gotPdpGroups0 = new PdpGroups();
485 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
487 String gotJson = standardCoder.encode(gotPdpGroups0);
488 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
490 Pdp existingPdp = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances().get(0);
491 existingPdp.setPdpState(PdpState.TEST);
492 existingPdp.setHealthy(PdpHealthStatus.TEST_IN_PROGRESS);
493 new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
495 List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
496 assertEquals(PdpState.TEST,
497 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getPdpState());
498 assertEquals(PdpHealthStatus.TEST_IN_PROGRESS,
499 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getHealthy());
501 existingPdp.setMessage("");
502 assertThatThrownBy(() -> {
503 new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
504 }).hasMessageContaining("PDP").hasMessageContaining("message").hasMessageContaining(Validated.IS_BLANK);
505 existingPdp.setMessage("A Message");
509 public void testGetPdpStatistics() throws PfModelException {
510 assertThatThrownBy(() -> {
511 new PdpProvider().getPdpStatistics(null, null);
512 }).hasMessageMatching(DAO_IS_NULL);
514 assertThatThrownBy(() -> {
515 new PdpProvider().getPdpStatistics(null, "name");
516 }).hasMessageMatching(DAO_IS_NULL);
518 assertEquals(0, new PdpProvider().getPdpStatistics(pfDao, "name").size());
522 public void testUpdatePdpStatisticsDao() throws PfModelException {
523 assertThatThrownBy(() -> {
524 new PdpProvider().updatePdpStatistics(null, null, null, null, null);
525 }).hasMessageMatching(DAO_IS_NULL);
527 assertThatThrownBy(() -> {
528 new PdpProvider().updatePdpStatistics(null, null, null, null, new PdpStatistics());
529 }).hasMessageMatching(DAO_IS_NULL);
531 assertThatThrownBy(() -> {
532 new PdpProvider().updatePdpStatistics(null, null, null, "inst", null);
533 }).hasMessageMatching(DAO_IS_NULL);
535 assertThatThrownBy(() -> {
536 new PdpProvider().updatePdpStatistics(null, null, null, "inst", new PdpStatistics());
537 }).hasMessageMatching(DAO_IS_NULL);
539 assertThatThrownBy(() -> {
540 new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, null);
541 }).hasMessageMatching(DAO_IS_NULL);
543 assertThatThrownBy(() -> {
544 new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, new PdpStatistics());
545 }).hasMessageMatching(DAO_IS_NULL);
547 assertThatThrownBy(() -> {
548 new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", null);
549 }).hasMessageMatching(DAO_IS_NULL);
551 assertThatThrownBy(() -> {
552 new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", new PdpStatistics());
553 }).hasMessageMatching(DAO_IS_NULL);
555 assertThatThrownBy(() -> {
556 new PdpProvider().updatePdpStatistics(null, "name", null, null, null);
557 }).hasMessageMatching(DAO_IS_NULL);
559 assertThatThrownBy(() -> {
560 new PdpProvider().updatePdpStatistics(null, "name", null, null, new PdpStatistics());
561 }).hasMessageMatching(DAO_IS_NULL);
563 assertThatThrownBy(() -> {
564 new PdpProvider().updatePdpStatistics(null, "name", null, "inst", null);
565 }).hasMessageMatching(DAO_IS_NULL);
567 assertThatThrownBy(() -> {
568 new PdpProvider().updatePdpStatistics(null, "name", null, "inst", new PdpStatistics());
569 }).hasMessageMatching(DAO_IS_NULL);
571 assertThatThrownBy(() -> {
572 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, null);
573 }).hasMessageMatching(DAO_IS_NULL);
575 assertThatThrownBy(() -> {
576 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, new PdpStatistics());
577 }).hasMessageMatching(DAO_IS_NULL);
579 assertThatThrownBy(() -> {
580 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", null);
581 }).hasMessageMatching(DAO_IS_NULL);
583 assertThatThrownBy(() -> {
584 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", new PdpStatistics());
585 }).hasMessageMatching(DAO_IS_NULL);
589 public void testUpdatePdpStatisticsGroup() throws PfModelException {
590 assertThatThrownBy(() -> {
591 new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
592 }).hasMessageMatching(GROUP_IS_NULL);
594 assertThatThrownBy(() -> {
595 new PdpProvider().updatePdpStatistics(pfDao, null, null, null, new PdpStatistics());
596 }).hasMessageMatching(GROUP_IS_NULL);
598 assertThatThrownBy(() -> {
599 new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", null);
600 }).hasMessageMatching(GROUP_IS_NULL);
602 assertThatThrownBy(() -> {
603 new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", new PdpStatistics());
604 }).hasMessageMatching(GROUP_IS_NULL);
606 assertThatThrownBy(() -> {
607 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, null);
608 }).hasMessageMatching(GROUP_IS_NULL);
610 assertThatThrownBy(() -> {
611 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, new PdpStatistics());
612 }).hasMessageMatching(GROUP_IS_NULL);
614 assertThatThrownBy(() -> {
615 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", null);
616 }).hasMessageMatching(GROUP_IS_NULL);
618 assertThatThrownBy(() -> {
619 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", new PdpStatistics());
620 }).hasMessageMatching(GROUP_IS_NULL);
622 assertThatThrownBy(() -> {
623 new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, null);
624 }).hasMessageMatching(PDP_TYPE_IS_NULL);
626 assertThatThrownBy(() -> {
627 new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, new PdpStatistics());
628 }).hasMessageMatching(PDP_TYPE_IS_NULL);
630 assertThatThrownBy(() -> {
631 new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", null);
632 }).hasMessageMatching(PDP_TYPE_IS_NULL);
634 assertThatThrownBy(() -> {
635 new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", new PdpStatistics());
636 }).hasMessageMatching(PDP_TYPE_IS_NULL);
638 assertThatThrownBy(() -> {
639 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, null);
640 }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
642 assertThatThrownBy(() -> {
643 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, new PdpStatistics());
644 }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
646 assertThatThrownBy(() -> {
647 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", null);
648 }).hasMessageMatching("pdpStatistics is marked .*ull but is null");
650 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());
654 public void testGetAllPolicyStatusPfDao() throws PfModelException {
655 assertThatThrownBy(() -> {
656 new PdpProvider().getAllPolicyStatus(null);
657 }).hasMessageMatching(DAO_IS_NULL);
659 assertThat(new PdpProvider().getAllPolicyStatus(pfDao)).isEmpty();
661 PdpProvider provider = loadDeployments();
662 assertThat(provider.getAllPolicyStatus(pfDao)).hasSize(5);
665 private PdpProvider loadDeployments() {
666 PdpProvider provider = new PdpProvider();
668 // same name, different version
669 final ToscaConceptIdentifier policy3 = new ToscaConceptIdentifier(MY_POLICY.getName(), "10.20.30");
671 PdpPolicyStatus id1 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp1").policy(MY_POLICY).build();
672 PdpPolicyStatus id2 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp2").policy(MY_POLICY2).build();
673 PdpPolicyStatus id3 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp3").policy(policy3).build();
674 PdpPolicyStatus id4 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp4").policy(MY_POLICY).build();
675 PdpPolicyStatus id5 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp5").policy(MY_POLICY2).build();
676 provider.cudPolicyStatus(pfDao, List.of(id1, id2, id3, id4, id5), null, null);
682 public void testGetAllPolicyStatusPfDaoToscaConceptIdentifierOptVersion() throws PfModelException {
683 assertThatThrownBy(() -> {
684 new PdpProvider().getAllPolicyStatus(null, new ToscaConceptIdentifierOptVersion("somePdp", null));
685 }).hasMessageMatching(DAO_IS_NULL);
687 assertThatThrownBy(() -> {
688 new PdpProvider().getAllPolicyStatus(pfDao, null);
689 }).hasMessageContaining("policy").hasMessageContaining("null");
691 assertThat(new PdpProvider().getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion("somePdp", null)))
694 PdpProvider provider = loadDeployments();
695 assertThat(provider.getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion(MY_POLICY))).hasSize(2);
696 assertThat(provider.getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion(MY_POLICY.getName(), null)))
701 public void testGetGroupPolicyStatus() throws PfModelException {
702 assertThatThrownBy(() -> {
703 new PdpProvider().getGroupPolicyStatus(null, "someGroup");
704 }).hasMessageMatching(DAO_IS_NULL);
706 assertThatThrownBy(() -> {
707 new PdpProvider().getGroupPolicyStatus(pfDao, null);
708 }).hasMessageContaining("group").hasMessageContaining("null");
710 assertThat(new PdpProvider().getGroupPolicyStatus(pfDao, PDP_GROUP0)).isEmpty();
712 PdpProvider provider = loadDeployments();
713 assertThat(provider.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(3);
717 public void cudPolicyStatus() throws PfModelException {
718 PdpProvider prov = new PdpProvider();
720 assertThatThrownBy(() -> prov.cudPolicyStatus(null, List.of(), List.of(), List.of()))
721 .hasMessageMatching(DAO_IS_NULL);
723 // null collections should be OK
724 assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
728 public void cudPolicyStatus_Create() throws PfModelException {
729 PdpProvider prov = new PdpProvider();
731 PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
732 PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
733 PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_B).pdpId("idZ").build();
734 prov.cudPolicyStatus(pfDao, List.of(idx, idy), null, null);
735 prov.cudPolicyStatus(pfDao, List.of(idz), null, null);
737 List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
738 assertThat(records).hasSize(2);
740 Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
741 assertThat(records.get(0)).isEqualTo(idx);
742 assertThat(records.get(1)).isEqualTo(idy);
744 records = prov.getGroupPolicyStatus(pfDao, GROUP_B);
745 assertThat(records).hasSize(1);
746 assertThat(records.get(0)).isEqualTo(idz);
750 public void cudPolicyStatus_Update() throws PfModelException {
751 PdpProvider prov = new PdpProvider();
753 PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("wId").build();
754 PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("xId").build();
755 PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("yId").build();
756 PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("zId").build();
757 prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
759 assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
762 * Now update some records.
764 idx.setState(State.FAILURE);
765 idz.setState(State.WAITING);
766 prov.cudPolicyStatus(pfDao, null, List.of(idx, idz), null);
767 List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
768 assertThat(records).hasSize(4);
770 Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
771 assertThat(records.get(0)).isEqualTo(idw);
772 assertThat(records.get(1)).isEqualTo(idx);
773 assertThat(records.get(2)).isEqualTo(idy);
774 assertThat(records.get(3)).isEqualTo(idz);
778 public void cudPolicyStatus_Delete() throws PfModelException {
779 PdpProvider prov = new PdpProvider();
781 PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("idW").build();
782 PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
783 PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
784 PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("idZ").build();
785 prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
787 assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
790 * Delete some records and then check again.
792 prov.cudPolicyStatus(pfDao, null, null, List.of(idw, idy));
794 List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
795 assertThat(records).hasSize(2);
797 Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
798 assertThat(records.get(0)).isEqualTo(idx);
799 assertThat(records.get(1)).isEqualTo(idz);
803 public void testFromAuthorativeStatus() throws PfModelException {
804 PdpProvider prov = new PdpProvider();
806 assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
808 PdpPolicyStatus ida = statusBuilder.pdpGroup(GROUP_A).pdpId("idA").build();
809 PdpPolicyStatus idb = statusBuilder.pdpGroup(GROUP_A).pdpId("idB").build();
810 PdpPolicyStatus idc = statusBuilder.pdpGroup(GROUP_A).pdpId("idC").build();
811 PdpPolicyStatus idd = statusBuilder.pdpGroup(GROUP_A).pdpId("idD").build();
813 // make a couple invalid records
817 List<PdpPolicyStatus> list = List.of(ida, idb, idc, idd);
820 assertThatCode(() -> prov.cudPolicyStatus(pfDao, list, null, null))
821 .isInstanceOf(PfModelRuntimeException.class)
822 .hasMessageContaining("1").hasMessageContaining("3")
823 .hasMessageNotContaining("0").hasMessageNotContaining("2");
826 assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).isEmpty();