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 testUpdatePdpStatistics() 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);
587 assertThatThrownBy(() -> {
588 new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
589 }).hasMessageMatching(GROUP_IS_NULL);
591 assertThatThrownBy(() -> {
592 new PdpProvider().updatePdpStatistics(pfDao, null, null, null, new PdpStatistics());
593 }).hasMessageMatching(GROUP_IS_NULL);
595 assertThatThrownBy(() -> {
596 new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", null);
597 }).hasMessageMatching(GROUP_IS_NULL);
599 assertThatThrownBy(() -> {
600 new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", new PdpStatistics());
601 }).hasMessageMatching(GROUP_IS_NULL);
603 assertThatThrownBy(() -> {
604 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, null);
605 }).hasMessageMatching(GROUP_IS_NULL);
607 assertThatThrownBy(() -> {
608 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, new PdpStatistics());
609 }).hasMessageMatching(GROUP_IS_NULL);
611 assertThatThrownBy(() -> {
612 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", null);
613 }).hasMessageMatching(GROUP_IS_NULL);
615 assertThatThrownBy(() -> {
616 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", new PdpStatistics());
617 }).hasMessageMatching(GROUP_IS_NULL);
619 assertThatThrownBy(() -> {
620 new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, null);
621 }).hasMessageMatching(PDP_TYPE_IS_NULL);
623 assertThatThrownBy(() -> {
624 new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, new PdpStatistics());
625 }).hasMessageMatching(PDP_TYPE_IS_NULL);
627 assertThatThrownBy(() -> {
628 new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", null);
629 }).hasMessageMatching(PDP_TYPE_IS_NULL);
631 assertThatThrownBy(() -> {
632 new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", new PdpStatistics());
633 }).hasMessageMatching(PDP_TYPE_IS_NULL);
635 assertThatThrownBy(() -> {
636 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, null);
637 }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
639 assertThatThrownBy(() -> {
640 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, new PdpStatistics());
641 }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
643 assertThatThrownBy(() -> {
644 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", null);
645 }).hasMessageMatching("pdpStatistics is marked .*ull but is null");
647 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());
651 public void testGetAllPolicyStatusPfDao() throws PfModelException {
652 assertThatThrownBy(() -> {
653 new PdpProvider().getAllPolicyStatus(null);
654 }).hasMessageMatching(DAO_IS_NULL);
656 assertThat(new PdpProvider().getAllPolicyStatus(pfDao)).isEmpty();
658 PdpProvider provider = loadDeployments();
659 assertThat(provider.getAllPolicyStatus(pfDao)).hasSize(5);
662 private PdpProvider loadDeployments() {
663 PdpProvider provider = new PdpProvider();
665 // same name, different version
666 final ToscaConceptIdentifier policy3 = new ToscaConceptIdentifier(MY_POLICY.getName(), "10.20.30");
668 PdpPolicyStatus id1 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp1").policy(MY_POLICY).build();
669 PdpPolicyStatus id2 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp2").policy(MY_POLICY2).build();
670 PdpPolicyStatus id3 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp3").policy(policy3).build();
671 PdpPolicyStatus id4 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp4").policy(MY_POLICY).build();
672 PdpPolicyStatus id5 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp5").policy(MY_POLICY2).build();
673 provider.cudPolicyStatus(pfDao, List.of(id1, id2, id3, id4, id5), null, null);
679 public void testGetAllPolicyStatusPfDaoToscaConceptIdentifierOptVersion() throws PfModelException {
680 assertThatThrownBy(() -> {
681 new PdpProvider().getAllPolicyStatus(null, new ToscaConceptIdentifierOptVersion("somePdp", null));
682 }).hasMessageMatching(DAO_IS_NULL);
684 assertThatThrownBy(() -> {
685 new PdpProvider().getAllPolicyStatus(pfDao, null);
686 }).hasMessageContaining("policy").hasMessageContaining("null");
688 assertThat(new PdpProvider().getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion("somePdp", null)))
691 PdpProvider provider = loadDeployments();
692 assertThat(provider.getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion(MY_POLICY))).hasSize(2);
693 assertThat(provider.getAllPolicyStatus(pfDao, new ToscaConceptIdentifierOptVersion(MY_POLICY.getName(), null)))
698 public void testGetGroupPolicyStatus() throws PfModelException {
699 assertThatThrownBy(() -> {
700 new PdpProvider().getGroupPolicyStatus(null, "someGroup");
701 }).hasMessageMatching(DAO_IS_NULL);
703 assertThatThrownBy(() -> {
704 new PdpProvider().getGroupPolicyStatus(pfDao, null);
705 }).hasMessageContaining("group").hasMessageContaining("null");
707 assertThat(new PdpProvider().getGroupPolicyStatus(pfDao, PDP_GROUP0)).isEmpty();
709 PdpProvider provider = loadDeployments();
710 assertThat(provider.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(3);
714 public void cudPolicyStatus() throws PfModelException {
715 PdpProvider prov = new PdpProvider();
717 assertThatThrownBy(() -> prov.cudPolicyStatus(null, List.of(), List.of(), List.of()))
718 .hasMessageMatching(DAO_IS_NULL);
720 // null collections should be OK
721 assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
725 public void cudPolicyStatus_Create() throws PfModelException {
726 PdpProvider prov = new PdpProvider();
728 PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
729 PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
730 PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_B).pdpId("idZ").build();
731 prov.cudPolicyStatus(pfDao, List.of(idx, idy), null, null);
732 prov.cudPolicyStatus(pfDao, List.of(idz), null, null);
734 List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
735 assertThat(records).hasSize(2);
737 Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
738 assertThat(records.get(0)).isEqualTo(idx);
739 assertThat(records.get(1)).isEqualTo(idy);
741 records = prov.getGroupPolicyStatus(pfDao, GROUP_B);
742 assertThat(records).hasSize(1);
743 assertThat(records.get(0)).isEqualTo(idz);
747 public void cudPolicyStatus_Update() throws PfModelException {
748 PdpProvider prov = new PdpProvider();
750 PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("wId").build();
751 PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("xId").build();
752 PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("yId").build();
753 PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("zId").build();
754 prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
756 assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
759 * Now update some records.
761 idx.setState(State.FAILURE);
762 idz.setState(State.WAITING);
763 prov.cudPolicyStatus(pfDao, null, List.of(idx, idz), null);
764 List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
765 assertThat(records).hasSize(4);
767 Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
768 assertThat(records.get(0)).isEqualTo(idw);
769 assertThat(records.get(1)).isEqualTo(idx);
770 assertThat(records.get(2)).isEqualTo(idy);
771 assertThat(records.get(3)).isEqualTo(idz);
775 public void cudPolicyStatus_Delete() throws PfModelException {
776 PdpProvider prov = new PdpProvider();
778 PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("idW").build();
779 PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
780 PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
781 PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("idZ").build();
782 prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
784 assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
787 * Delete some records and then check again.
789 prov.cudPolicyStatus(pfDao, null, null, List.of(idw, idy));
791 List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
792 assertThat(records).hasSize(2);
794 Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
795 assertThat(records.get(0)).isEqualTo(idx);
796 assertThat(records.get(1)).isEqualTo(idz);
800 public void testFromAuthorativeStatus() throws PfModelException {
801 PdpProvider prov = new PdpProvider();
803 assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
805 PdpPolicyStatus ida = statusBuilder.pdpGroup(GROUP_A).pdpId("idA").build();
806 PdpPolicyStatus idb = statusBuilder.pdpGroup(GROUP_A).pdpId("idB").build();
807 PdpPolicyStatus idc = statusBuilder.pdpGroup(GROUP_A).pdpId("idC").build();
808 PdpPolicyStatus idd = statusBuilder.pdpGroup(GROUP_A).pdpId("idD").build();
810 // make a couple invalid records
814 List<PdpPolicyStatus> list = List.of(ida, idb, idc, idd);
817 assertThatCode(() -> prov.cudPolicyStatus(pfDao, list, null, null))
818 .isInstanceOf(PfModelRuntimeException.class)
819 .hasMessageContaining("1").hasMessageContaining("3")
820 .hasMessageNotContaining("0").hasMessageNotContaining("2");
823 assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).isEmpty();