2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2021 Nordix Foundation.
4 * Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
5 * ================================================================================
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
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.assertThatThrownBy;
25 import static org.junit.Assert.assertEquals;
26 import static org.junit.Assert.assertNotEquals;
27 import static org.junit.Assert.assertTrue;
29 import java.util.ArrayList;
30 import java.util.List;
31 import java.util.Properties;
32 import org.eclipse.persistence.config.PersistenceUnitProperties;
33 import org.junit.After;
34 import org.junit.Before;
35 import org.junit.Test;
36 import org.onap.policy.common.utils.coder.StandardCoder;
37 import org.onap.policy.common.utils.resources.ResourceUtils;
38 import org.onap.policy.models.base.PfModelException;
39 import org.onap.policy.models.base.Validated;
40 import org.onap.policy.models.dao.DaoParameters;
41 import org.onap.policy.models.dao.PfDao;
42 import org.onap.policy.models.dao.PfDaoFactory;
43 import org.onap.policy.models.dao.impl.DefaultPfDao;
44 import org.onap.policy.models.pdp.concepts.Pdp;
45 import org.onap.policy.models.pdp.concepts.PdpGroup;
46 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
47 import org.onap.policy.models.pdp.concepts.PdpGroups;
48 import org.onap.policy.models.pdp.concepts.PdpStatistics;
49 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
50 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
51 import org.onap.policy.models.pdp.enums.PdpState;
52 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
53 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
56 * Test the {@link SimpleToscaProvider} class.
58 * @author Liam Fallon (liam.fallon@est.tech)
60 public class PdpProviderTest {
61 private static final String PDP_GROUPS0_JSON = "testdata/PdpGroups0.json";
62 private static final String PDP_TYPE_IS_NULL = "pdpType is marked .*ull but is null";
63 private static final String SUBGROUP_IS_NULL = "pdpSubGroup is marked .*ull but is null";
64 private static final String GROUP_IS_NULL = "pdpGroupName is marked .*ull but is null";
65 private static final String DAO_IS_NULL = "dao is marked .*ull but is null";
66 private static final String PDP_GROUP0 = "PdpGroup0";
68 private StandardCoder standardCoder;
72 * Set up the DAO towards the database.
74 * @throws Exception on database errors
77 public void setupDao() throws Exception {
78 final DaoParameters daoParameters = new DaoParameters();
79 daoParameters.setPluginClass(DefaultPfDao.class.getName());
81 daoParameters.setPersistenceUnit("ToscaConceptTest");
83 Properties jdbcProperties = new Properties();
84 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "policy");
85 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "P01icY");
87 // H2, use "org.mariadb.jdbc.Driver" and "jdbc:mariadb://localhost:3306/policy" for locally installed MariaDB
88 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
89 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:testdb");
91 daoParameters.setJdbcProperties(jdbcProperties);
93 pfDao = new PfDaoFactory().createPfDao(daoParameters);
94 pfDao.init(daoParameters);
101 public void setupGson() {
102 standardCoder = new StandardCoder();
106 public void teardown() {
111 public void testGroupsGet() throws Exception {
112 assertThatThrownBy(() -> {
113 new PdpProvider().getPdpGroups(null, null);
114 }).hasMessageMatching(DAO_IS_NULL);
116 assertThatThrownBy(() -> {
117 new PdpProvider().getPdpGroups(null, "name");
118 }).hasMessageMatching(DAO_IS_NULL);
120 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
121 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
123 PdpGroups createdPdpGroups0 = new PdpGroups();
124 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
125 String createdJson = standardCoder.encode(createdPdpGroups0);
126 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
128 PdpGroups gotPdpGroups0 = new PdpGroups();
129 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
131 String gotJson = standardCoder.encode(gotPdpGroups0);
133 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
137 public void testFilteredPdpGroupGet() throws Exception {
138 assertThatThrownBy(() -> {
139 new PdpProvider().getFilteredPdpGroups(null, null);
140 }).hasMessageMatching(DAO_IS_NULL);
142 assertThatThrownBy(() -> {
143 new PdpProvider().getFilteredPdpGroups(null, PdpGroupFilter.builder().build());
144 }).hasMessageMatching(DAO_IS_NULL);
146 assertThatThrownBy(() -> {
147 new PdpProvider().getFilteredPdpGroups(pfDao, null);
148 }).hasMessageMatching("filter is marked .*ull but is null");
150 String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsForFiltering.json");
151 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
153 assertEquals(5, new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()).size());
155 List<ToscaConceptIdentifier> policyTypeList = new ArrayList<>();
156 policyTypeList.add(new ToscaConceptIdentifier("policy.type.0", "1.2.3"));
158 List<ToscaConceptIdentifier> policyList = new ArrayList<>();
159 policyList.add(new ToscaConceptIdentifier("Policy0", "4.5.6"));
162 final PdpGroupFilter filter = PdpGroupFilter.builder()
163 .groupState(PdpState.PASSIVE)
165 .matchPoliciesExactly(false)
166 .matchPolicyTypesExactly(false)
167 .pdpState(PdpState.PASSIVE)
169 .policyTypeList(policyTypeList)
170 .policyList(policyList)
173 assertEquals(1, new PdpProvider().getFilteredPdpGroups(pfDao, filter).size());
177 public void testGroupsCreate() throws Exception {
178 assertThatThrownBy(() -> {
179 new PdpProvider().createPdpGroups(null, null);
180 }).hasMessageMatching(DAO_IS_NULL);
182 assertThatThrownBy(() -> {
183 new PdpProvider().createPdpGroups(null, new ArrayList<>());
184 }).hasMessageMatching(DAO_IS_NULL);
186 assertThatThrownBy(() -> {
187 new PdpProvider().createPdpGroups(pfDao, null);
188 }).hasMessageMatching("pdpGroups is marked .*ull but is null");
190 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
191 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
193 PdpGroups createdPdpGroups0 = new PdpGroups();
194 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
195 String createdJson = standardCoder.encode(createdPdpGroups0);
196 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
198 PdpGroups gotPdpGroups0 = new PdpGroups();
199 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
201 String gotJson = standardCoder.encode(gotPdpGroups0);
202 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
204 pdpGroups0.getGroups().get(0).setPdpGroupState(null);
205 assertThatThrownBy(() -> {
206 new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups());
207 }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
208 .hasMessageContaining(Validated.IS_NULL);
212 public void testGroupsCreateNoPdp() throws Exception {
213 String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsNoPDPs.json");
215 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
217 PdpGroups createdPdpGroups0 = new PdpGroups();
218 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
219 assertNotEquals(pdpGroups0, createdPdpGroups0);
220 pdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).setPdpInstances(new ArrayList<>());
221 String originalTweakedJson = standardCoder.encode(pdpGroups0);
222 String createdJson = standardCoder.encode(createdPdpGroups0);
223 assertEquals(originalTweakedJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
225 PdpGroups gotPdpGroups0 = new PdpGroups();
226 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, "TestPdpGroup"));
228 String gotJson = standardCoder.encode(gotPdpGroups0);
229 assertEquals(originalTweakedJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
233 public void testGroupsUpdate() throws Exception {
234 assertThatThrownBy(() -> {
235 new PdpProvider().updatePdpGroups(null, null);
236 }).hasMessageMatching(DAO_IS_NULL);
238 assertThatThrownBy(() -> {
239 new PdpProvider().updatePdpGroups(null, new ArrayList<>());
240 }).hasMessageMatching(DAO_IS_NULL);
242 assertThatThrownBy(() -> {
243 new PdpProvider().updatePdpGroups(pfDao, null);
244 }).hasMessageMatching("pdpGroups is marked .*ull but is null");
246 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
247 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
249 PdpGroups createdPdpGroups0 = new PdpGroups();
250 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
251 String createdJson = standardCoder.encode(createdPdpGroups0);
252 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
254 PdpGroups gotPdpGroups0 = new PdpGroups();
255 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
257 String gotJson = standardCoder.encode(gotPdpGroups0);
258 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
260 String updateJson = ResourceUtils.getResourceAsString("testdata/PdpGroups0Update.json");
261 PdpGroups updatePdpGroups0 = standardCoder.decode(updateJson, PdpGroups.class);
263 PdpGroups updatedPdpGroups0 = new PdpGroups();
264 updatedPdpGroups0.setGroups(new PdpProvider().updatePdpGroups(pfDao, updatePdpGroups0.getGroups()));
266 List<Pdp> beforePdpInstances = updatePdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
267 List<Pdp> afterPdpInstances = updatedPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances();
268 assertTrue(beforePdpInstances.containsAll(afterPdpInstances));
270 pdpGroups0.getGroups().get(0).setPdpGroupState(null);
271 assertThatThrownBy(() -> {
272 new PdpProvider().updatePdpGroups(pfDao, pdpGroups0.getGroups());
273 }).hasMessageContaining("PDP group").hasMessageContaining("pdpGroupState")
274 .hasMessageContaining(Validated.IS_NULL);
278 public void testPoliciesDelete() throws Exception {
279 assertThatThrownBy(() -> {
280 new PdpProvider().deletePdpGroup(null, null);
281 }).hasMessageMatching(DAO_IS_NULL);
283 assertThatThrownBy(() -> {
284 new PdpProvider().deletePdpGroup(null, "name");
285 }).hasMessageMatching(DAO_IS_NULL);
287 assertThatThrownBy(() -> {
288 new PdpProvider().deletePdpGroup(pfDao, null);
289 }).hasMessageMatching("name is marked .*ull but is null");
291 assertThatThrownBy(() -> {
292 new PdpProvider().deletePdpGroup(pfDao, "name");
293 }).hasMessage("delete of PDP group \"name:0.0.0\" failed, PDP group does not exist");
295 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
296 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
298 PdpGroups createdPdpGroups0 = new PdpGroups();
299 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
300 String createdJson = standardCoder.encode(createdPdpGroups0);
301 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
303 PdpGroups gotPdpGroups0 = new PdpGroups();
304 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
306 String gotJson = standardCoder.encode(gotPdpGroups0);
307 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
309 PdpGroup deletedPdpGroup = new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
311 assertEquals(createdPdpGroups0.getGroups().get(0), deletedPdpGroup);
313 assertEquals(0, new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0).size());
315 assertThatThrownBy(() -> {
316 new PdpProvider().deletePdpGroup(pfDao, PDP_GROUP0);
317 }).hasMessage("delete of PDP group \"PdpGroup0:0.0.0\" failed, PDP group does not exist");
321 public void testPdpSubgroupUpdate() throws Exception {
322 assertThatThrownBy(() -> {
323 new PdpProvider().updatePdpSubGroup(null, null, null);
324 }).hasMessageMatching(DAO_IS_NULL);
326 assertThatThrownBy(() -> {
327 new PdpProvider().updatePdpSubGroup(null, null, new PdpSubGroup());
328 }).hasMessageMatching(DAO_IS_NULL);
330 assertThatThrownBy(() -> {
331 new PdpProvider().updatePdpSubGroup(null, "name", null);
332 }).hasMessageMatching(DAO_IS_NULL);
334 assertThatThrownBy(() -> {
335 new PdpProvider().updatePdpSubGroup(null, "name", new PdpSubGroup());
336 }).hasMessageMatching(DAO_IS_NULL);
338 assertThatThrownBy(() -> {
339 new PdpProvider().updatePdpSubGroup(pfDao, null, null);
340 }).hasMessageMatching(GROUP_IS_NULL);
342 assertThatThrownBy(() -> {
343 new PdpProvider().updatePdpSubGroup(pfDao, null, new PdpSubGroup());
344 }).hasMessageMatching(GROUP_IS_NULL);
346 assertThatThrownBy(() -> {
347 new PdpProvider().updatePdpSubGroup(pfDao, "name", null);
348 }).hasMessageMatching(SUBGROUP_IS_NULL);
350 assertThatThrownBy(() -> {
351 new PdpProvider().updatePdpSubGroup(pfDao, "name", new PdpSubGroup());
352 }).hasMessage("parameter \"localName\" is null");
354 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
355 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
357 PdpGroups createdPdpGroups0 = new PdpGroups();
358 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
359 String createdJson = standardCoder.encode(createdPdpGroups0);
360 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
362 PdpGroups gotPdpGroups0 = new PdpGroups();
363 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
365 String gotJson = standardCoder.encode(gotPdpGroups0);
366 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
368 PdpSubGroup existingSubGroup = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0);
369 existingSubGroup.setCurrentInstanceCount(10);
370 existingSubGroup.setDesiredInstanceCount(10);
371 new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
373 List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
374 assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getCurrentInstanceCount());
375 assertEquals(10, afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getDesiredInstanceCount());
377 existingSubGroup.setDesiredInstanceCount(-1);
378 assertThatThrownBy(() -> {
379 new PdpProvider().updatePdpSubGroup(pfDao, PDP_GROUP0, existingSubGroup);
380 }).hasMessageContaining("PDP sub group").hasMessageContaining("desiredInstanceCount")
381 .hasMessageContaining("below the minimum value");
382 existingSubGroup.setDesiredInstanceCount(10);
386 public void testPdpUpdate() throws Exception {
387 assertThatThrownBy(() -> {
388 new PdpProvider().updatePdp(null, null, null, null);
389 }).hasMessageMatching(DAO_IS_NULL);
391 assertThatThrownBy(() -> {
392 new PdpProvider().updatePdp(null, null, null, new Pdp());
393 }).hasMessageMatching(DAO_IS_NULL);
395 assertThatThrownBy(() -> {
396 new PdpProvider().updatePdp(null, null, "TYPE", null);
397 }).hasMessageMatching(DAO_IS_NULL);
399 assertThatThrownBy(() -> {
400 new PdpProvider().updatePdp(null, null, "TYPE", new Pdp());
401 }).hasMessageMatching(DAO_IS_NULL);
403 assertThatThrownBy(() -> {
404 new PdpProvider().updatePdp(null, "name", null, null);
405 }).hasMessageMatching(DAO_IS_NULL);
407 assertThatThrownBy(() -> {
408 new PdpProvider().updatePdp(null, "name", null, new Pdp());
409 }).hasMessageMatching(DAO_IS_NULL);
411 assertThatThrownBy(() -> {
412 new PdpProvider().updatePdp(null, "name", "TYPE", null);
413 }).hasMessageMatching(DAO_IS_NULL);
415 assertThatThrownBy(() -> {
416 new PdpProvider().updatePdp(null, "name", "TYPE", new Pdp());
417 }).hasMessageMatching(DAO_IS_NULL);
419 assertThatThrownBy(() -> {
420 new PdpProvider().updatePdp(pfDao, null, null, null);
421 }).hasMessageMatching(GROUP_IS_NULL);
423 assertThatThrownBy(() -> {
424 new PdpProvider().updatePdp(pfDao, null, null, new Pdp());
425 }).hasMessageMatching(GROUP_IS_NULL);
427 assertThatThrownBy(() -> {
428 new PdpProvider().updatePdp(pfDao, null, "TYPE", null);
429 }).hasMessageMatching(GROUP_IS_NULL);
431 assertThatThrownBy(() -> {
432 new PdpProvider().updatePdp(pfDao, null, "TYPE", new Pdp());
433 }).hasMessageMatching(GROUP_IS_NULL);
435 assertThatThrownBy(() -> {
436 new PdpProvider().updatePdp(pfDao, "name", null, null);
437 }).hasMessageMatching(SUBGROUP_IS_NULL);
439 assertThatThrownBy(() -> {
440 new PdpProvider().updatePdp(pfDao, "name", null, new Pdp());
441 }).hasMessageMatching(SUBGROUP_IS_NULL);
443 assertThatThrownBy(() -> {
444 new PdpProvider().updatePdp(pfDao, "name", "TYPE", null);
445 }).hasMessageMatching("pdp is marked .*ull but is null");
447 assertThatThrownBy(() -> {
448 new PdpProvider().updatePdp(pfDao, "name", "TYPE", new Pdp());
449 }).hasMessage("parameter \"localName\" is null");
451 String originalJson = ResourceUtils.getResourceAsString(PDP_GROUPS0_JSON);
452 PdpGroups pdpGroups0 = standardCoder.decode(originalJson, PdpGroups.class);
454 PdpGroups createdPdpGroups0 = new PdpGroups();
455 createdPdpGroups0.setGroups(new PdpProvider().createPdpGroups(pfDao, pdpGroups0.getGroups()));
456 String createdJson = standardCoder.encode(createdPdpGroups0);
457 assertEquals(originalJson.replaceAll("\\s+", ""), createdJson.replaceAll("\\s+", ""));
459 PdpGroups gotPdpGroups0 = new PdpGroups();
460 gotPdpGroups0.setGroups(new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0));
462 String gotJson = standardCoder.encode(gotPdpGroups0);
463 assertEquals(originalJson.replaceAll("\\s+", ""), gotJson.replaceAll("\\s+", ""));
465 Pdp existingPdp = gotPdpGroups0.getGroups().get(0).getPdpSubgroups().get(0).getPdpInstances().get(0);
466 existingPdp.setPdpState(PdpState.TEST);
467 existingPdp.setHealthy(PdpHealthStatus.TEST_IN_PROGRESS);
468 new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
470 List<PdpGroup> afterUpdatePdpGroups = new PdpProvider().getPdpGroups(pfDao, PDP_GROUP0);
471 assertEquals(PdpState.TEST,
472 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getPdpState());
473 assertEquals(PdpHealthStatus.TEST_IN_PROGRESS,
474 afterUpdatePdpGroups.get(0).getPdpSubgroups().get(0).getPdpInstances().get(0).getHealthy());
476 existingPdp.setMessage("");
477 assertThatThrownBy(() -> {
478 new PdpProvider().updatePdp(pfDao, PDP_GROUP0, "APEX", existingPdp);
479 }).hasMessageContaining("PDP").hasMessageContaining("message").hasMessageContaining(Validated.IS_BLANK);
480 existingPdp.setMessage("A Message");
484 public void testGetPdpStatistics() throws PfModelException {
485 assertThatThrownBy(() -> {
486 new PdpProvider().getPdpStatistics(null, null);
487 }).hasMessageMatching(DAO_IS_NULL);
489 assertThatThrownBy(() -> {
490 new PdpProvider().getPdpStatistics(null, "name");
491 }).hasMessageMatching(DAO_IS_NULL);
493 assertEquals(0, new PdpProvider().getPdpStatistics(pfDao, "name").size());
497 public void testUpdatePdpStatistics() throws PfModelException {
498 assertThatThrownBy(() -> {
499 new PdpProvider().updatePdpStatistics(null, null, null, null, null);
500 }).hasMessageMatching(DAO_IS_NULL);
502 assertThatThrownBy(() -> {
503 new PdpProvider().updatePdpStatistics(null, null, null, null, new PdpStatistics());
504 }).hasMessageMatching(DAO_IS_NULL);
506 assertThatThrownBy(() -> {
507 new PdpProvider().updatePdpStatistics(null, null, null, "inst", null);
508 }).hasMessageMatching(DAO_IS_NULL);
510 assertThatThrownBy(() -> {
511 new PdpProvider().updatePdpStatistics(null, null, null, "inst", new PdpStatistics());
512 }).hasMessageMatching(DAO_IS_NULL);
514 assertThatThrownBy(() -> {
515 new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, null);
516 }).hasMessageMatching(DAO_IS_NULL);
518 assertThatThrownBy(() -> {
519 new PdpProvider().updatePdpStatistics(null, null, "TYPE", null, new PdpStatistics());
520 }).hasMessageMatching(DAO_IS_NULL);
522 assertThatThrownBy(() -> {
523 new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", null);
524 }).hasMessageMatching(DAO_IS_NULL);
526 assertThatThrownBy(() -> {
527 new PdpProvider().updatePdpStatistics(null, null, "TYPE", "inst", new PdpStatistics());
528 }).hasMessageMatching(DAO_IS_NULL);
530 assertThatThrownBy(() -> {
531 new PdpProvider().updatePdpStatistics(null, "name", null, null, null);
532 }).hasMessageMatching(DAO_IS_NULL);
534 assertThatThrownBy(() -> {
535 new PdpProvider().updatePdpStatistics(null, "name", null, null, new PdpStatistics());
536 }).hasMessageMatching(DAO_IS_NULL);
538 assertThatThrownBy(() -> {
539 new PdpProvider().updatePdpStatistics(null, "name", null, "inst", null);
540 }).hasMessageMatching(DAO_IS_NULL);
542 assertThatThrownBy(() -> {
543 new PdpProvider().updatePdpStatistics(null, "name", null, "inst", new PdpStatistics());
544 }).hasMessageMatching(DAO_IS_NULL);
546 assertThatThrownBy(() -> {
547 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, null);
548 }).hasMessageMatching(DAO_IS_NULL);
550 assertThatThrownBy(() -> {
551 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", null, new PdpStatistics());
552 }).hasMessageMatching(DAO_IS_NULL);
554 assertThatThrownBy(() -> {
555 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", null);
556 }).hasMessageMatching(DAO_IS_NULL);
558 assertThatThrownBy(() -> {
559 new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", new PdpStatistics());
560 }).hasMessageMatching(DAO_IS_NULL);
562 assertThatThrownBy(() -> {
563 new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
564 }).hasMessageMatching(GROUP_IS_NULL);
566 assertThatThrownBy(() -> {
567 new PdpProvider().updatePdpStatistics(pfDao, null, null, null, new PdpStatistics());
568 }).hasMessageMatching(GROUP_IS_NULL);
570 assertThatThrownBy(() -> {
571 new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", null);
572 }).hasMessageMatching(GROUP_IS_NULL);
574 assertThatThrownBy(() -> {
575 new PdpProvider().updatePdpStatistics(pfDao, null, null, "inst", new PdpStatistics());
576 }).hasMessageMatching(GROUP_IS_NULL);
578 assertThatThrownBy(() -> {
579 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, null);
580 }).hasMessageMatching(GROUP_IS_NULL);
582 assertThatThrownBy(() -> {
583 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", null, new PdpStatistics());
584 }).hasMessageMatching(GROUP_IS_NULL);
586 assertThatThrownBy(() -> {
587 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", null);
588 }).hasMessageMatching(GROUP_IS_NULL);
590 assertThatThrownBy(() -> {
591 new PdpProvider().updatePdpStatistics(pfDao, null, "TYPE", "inst", new PdpStatistics());
592 }).hasMessageMatching(GROUP_IS_NULL);
594 assertThatThrownBy(() -> {
595 new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, null);
596 }).hasMessageMatching(PDP_TYPE_IS_NULL);
598 assertThatThrownBy(() -> {
599 new PdpProvider().updatePdpStatistics(pfDao, "name", null, null, new PdpStatistics());
600 }).hasMessageMatching(PDP_TYPE_IS_NULL);
602 assertThatThrownBy(() -> {
603 new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", null);
604 }).hasMessageMatching(PDP_TYPE_IS_NULL);
606 assertThatThrownBy(() -> {
607 new PdpProvider().updatePdpStatistics(pfDao, "name", null, "inst", new PdpStatistics());
608 }).hasMessageMatching(PDP_TYPE_IS_NULL);
610 assertThatThrownBy(() -> {
611 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, null);
612 }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
614 assertThatThrownBy(() -> {
615 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", null, new PdpStatistics());
616 }).hasMessageMatching("pdpInstanceId is marked .*ull but is null");
618 assertThatThrownBy(() -> {
619 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", null);
620 }).hasMessageMatching("pdpStatistics is marked .*ull but is null");
622 new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());