2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019 Nordix Foundation.
4 * Modifications Copyright (C) 2019 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.concepts;
24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
25 import static org.junit.Assert.assertEquals;
26 import static org.junit.Assert.assertTrue;
28 import java.util.ArrayList;
29 import java.util.List;
30 import java.util.stream.Collectors;
31 import org.junit.Before;
32 import org.junit.Test;
33 import org.onap.policy.common.utils.coder.CoderException;
34 import org.onap.policy.common.utils.coder.StandardCoder;
35 import org.onap.policy.common.utils.resources.ResourceUtils;
36 import org.onap.policy.models.pdp.enums.PdpState;
37 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
38 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
41 * Test of the {@link PdpGroupFilter} class.
43 * @author Liam Fallon (liam.fallon@est.tech)
45 public class PdpGroupFilterTest {
46 private static final String POLICY_TYPE3 = "policy.type.3";
47 private static final String POLICY_TYPE2 = "policy.type.2";
48 private static final String POLICY_TYPE1 = "policy.type.1";
49 private static final String POLICY_TYPE0 = "policy.type.0";
50 private static final String POLICY3 = "Policy3";
51 private static final String POLICY2 = "Policy2";
52 private static final String POLICY1 = "Policy1";
53 private static final String POLICY0 = "Policy0";
54 private static final String NON_EXISTANT = "Nonexistant";
55 private static final String VERSION9 = "9.9.9";
56 private static final String VERSION7 = "7.8.9";
57 private static final String VERSION4 = "4.5.6";
58 private static final String VERSION1 = "1.2.3";
59 private static final String VERSION0 = "0.1.2";
60 private List<PdpGroup> pdpGroupList;
63 * Set up a PDP group list for filtering.
65 * @throws CoderException on JSON decoding errors
68 public void setupPdpGroupList() throws CoderException {
69 String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsForFiltering.json");
70 PdpGroups pdpGroups = new StandardCoder().decode(originalJson, PdpGroups.class);
71 pdpGroupList = pdpGroups.getGroups();
75 public void testNullList() {
76 PdpGroupFilter filter = PdpGroupFilter.builder().build();
78 assertThatThrownBy(() -> {
80 }).hasMessageMatching("originalList is marked .*ull but is null");
84 public void testFilterNothing() {
85 PdpGroupFilter filter = PdpGroupFilter.builder().build();
87 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
88 assertTrue(filteredList.containsAll(pdpGroupList));
92 public void testFilterName() {
93 PdpGroupFilter filter = PdpGroupFilter.builder().name("PdpGroup0").build();
94 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
95 assertEquals(1, filteredList.size());
97 filter = PdpGroupFilter.builder().name("PdpGroup1").build();
98 filteredList = filter.filter(pdpGroupList);
99 assertEquals(1, filteredList.size());
101 filter = PdpGroupFilter.builder().name("PdpGroup20").build();
102 filteredList = filter.filter(pdpGroupList);
103 assertEquals(1, filteredList.size());
105 filter = PdpGroupFilter.builder().build();
106 filteredList = filter.filter(pdpGroupList);
107 assertEquals(5, filteredList.size());
109 filter = PdpGroupFilter.builder().name("PdpGroup0").build();
110 filteredList = filter.filter(pdpGroupList);
111 assertEquals(1, filteredList.size());
113 filter = PdpGroupFilter.builder().name("PdpGroup19").build();
114 filteredList = filter.filter(pdpGroupList);
115 assertEquals(0, filteredList.size());
119 public void testFilterPdpGroupState() {
120 PdpGroupFilter filter = PdpGroupFilter.builder().groupState(PdpState.ACTIVE).build();
121 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
122 assertEquals(1, filteredList.size());
124 filter = PdpGroupFilter.builder().groupState(PdpState.PASSIVE).build();
125 filteredList = filter.filter(pdpGroupList);
126 assertEquals(2, filteredList.size());
128 filter = PdpGroupFilter.builder().groupState(PdpState.TEST).build();
129 filteredList = filter.filter(pdpGroupList);
130 assertEquals(1, filteredList.size());
132 filter = PdpGroupFilter.builder().groupState(PdpState.SAFE).build();
133 filteredList = filter.filter(pdpGroupList);
134 assertEquals(1, filteredList.size());
136 filter = PdpGroupFilter.builder().groupState(PdpState.TERMINATED).build();
137 filteredList = filter.filter(pdpGroupList);
138 assertEquals(0, filteredList.size());
142 public void testFilterPdpType() {
143 PdpGroupFilter filter = PdpGroupFilter.builder().pdpType("APEX").build();
144 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
145 assertEquals(5, filteredList.size());
147 filter = PdpGroupFilter.builder().pdpType("DROOLS").build();
148 filteredList = filter.filter(pdpGroupList);
149 assertEquals(2, filteredList.size());
151 filter = PdpGroupFilter.builder().pdpType("XACML").build();
152 filteredList = filter.filter(pdpGroupList);
153 assertEquals(1, filteredList.size());
157 public void testFilterPdpState() {
158 PdpGroupFilter filter = PdpGroupFilter.builder().pdpState(PdpState.ACTIVE).build();
159 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
160 assertEquals(3, filteredList.size());
162 filter = PdpGroupFilter.builder().pdpState(PdpState.PASSIVE).build();
163 filteredList = filter.filter(pdpGroupList);
164 assertEquals(3, filteredList.size());
166 filter = PdpGroupFilter.builder().pdpState(PdpState.SAFE).build();
167 filteredList = filter.filter(pdpGroupList);
168 assertEquals(2, filteredList.size());
170 filter = PdpGroupFilter.builder().pdpState(PdpState.TEST).build();
171 filteredList = filter.filter(pdpGroupList);
172 assertEquals(2, filteredList.size());
176 public void testFilterPolicyType() {
177 List<ToscaPolicyTypeIdentifier> identifierList = new ArrayList<>();
179 identifierList.add(new ToscaPolicyTypeIdentifier(NON_EXISTANT, VERSION1));
180 PdpGroupFilter filter =
181 PdpGroupFilter.builder().policyTypeList(identifierList).build();
182 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
183 assertEquals(0, filteredList.size());
184 identifierList.clear();
186 // don't match wild cards
187 identifierList.add(new ToscaPolicyTypeIdentifier(NON_EXISTANT, VERSION1));
188 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
189 final List<PdpGroup> wildCards =
190 pdpGroupList.stream().map(this::makeWildCardPolicyTypes).collect(Collectors.toList());
191 filteredList = filter.filter(wildCards);
192 assertEquals(0, filteredList.size());
193 identifierList.clear();
196 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
197 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
198 filteredList = filter.filter(wildCards);
199 assertEquals(4, filteredList.size());
200 identifierList.clear();
202 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
203 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
204 filteredList = filter.filter(pdpGroupList);
205 assertEquals(4, filteredList.size());
206 identifierList.clear();
208 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
209 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
210 filteredList = filter.filter(pdpGroupList);
211 assertEquals(4, filteredList.size());
212 identifierList.clear();
214 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE2, VERSION7));
215 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
216 filteredList = filter.filter(pdpGroupList);
217 assertEquals(2, filteredList.size());
218 identifierList.clear();
220 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
221 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
222 filteredList = filter.filter(pdpGroupList);
223 assertEquals(2, filteredList.size());
224 identifierList.clear();
226 identifierList.add(new ToscaPolicyTypeIdentifier(NON_EXISTANT, VERSION1));
227 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION9));
228 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
229 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
230 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE2, VERSION7));
231 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
232 filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
233 filteredList = filter.filter(pdpGroupList);
234 assertEquals(5, filteredList.size());
236 filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
237 filteredList = filter.filter(pdpGroupList);
238 assertEquals(0, filteredList.size());
240 identifierList.clear();
241 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
242 filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
243 filteredList = filter.filter(pdpGroupList);
244 assertEquals(2, filteredList.size());
246 identifierList.clear();
247 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
248 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
249 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE2, VERSION7));
250 filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
251 filteredList = filter.filter(pdpGroupList);
252 assertEquals(1, filteredList.size());
254 identifierList.clear();
255 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
256 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
257 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
258 filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
259 filteredList = filter.filter(pdpGroupList);
260 assertEquals(1, filteredList.size());
262 identifierList.clear();
263 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
264 identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
265 filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
266 filteredList = filter.filter(pdpGroupList);
267 assertEquals(1, filteredList.size());
271 * Makes a clone of a PdpGroup, changing all occurrences of supported policy type,
272 * "policy.type.0", to a wild card type, "policy.type.*".
274 * @param group group to be cloned
275 * @return a new PdpGroup containing wild card policy types
277 private PdpGroup makeWildCardPolicyTypes(PdpGroup group) {
278 PdpGroup newGroup = new PdpGroup(group);
280 for (PdpSubGroup subgroup : newGroup.getPdpSubgroups()) {
281 for (ToscaPolicyTypeIdentifier subType : subgroup.getSupportedPolicyTypes()) {
282 if (POLICY_TYPE0.equals(subType.getName())) {
283 subType.setName("policy.type.*");
292 public void testFilterPolicy() {
293 List<ToscaPolicyIdentifier> identifierList = new ArrayList<>();
295 identifierList.add(new ToscaPolicyIdentifier(NON_EXISTANT, VERSION1));
296 PdpGroupFilter filter =
297 PdpGroupFilter.builder().policyList(identifierList).build();
298 List<PdpGroup> filteredList = filter.filter(pdpGroupList);
299 assertEquals(0, filteredList.size());
300 identifierList.clear();
302 identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION9));
303 filter = PdpGroupFilter.builder().policyList(identifierList).build();
304 filteredList = filter.filter(pdpGroupList);
305 assertEquals(0, filteredList.size());
306 identifierList.clear();
308 identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
309 filter = PdpGroupFilter.builder().policyList(identifierList).build();
310 filteredList = filter.filter(pdpGroupList);
311 assertEquals(4, filteredList.size());
312 identifierList.clear();
314 identifierList.add(new ToscaPolicyIdentifier(POLICY1, VERSION4));
315 filter = PdpGroupFilter.builder().policyList(identifierList).build();
316 filteredList = filter.filter(pdpGroupList);
317 assertEquals(1, filteredList.size());
318 identifierList.clear();
320 identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
321 filter = PdpGroupFilter.builder().policyList(identifierList).build();
322 filteredList = filter.filter(pdpGroupList);
323 assertEquals(2, filteredList.size());
324 identifierList.clear();
326 identifierList.add(new ToscaPolicyIdentifier(POLICY3, VERSION1));
327 filter = PdpGroupFilter.builder().policyList(identifierList).build();
328 filteredList = filter.filter(pdpGroupList);
329 assertEquals(1, filteredList.size());
330 identifierList.clear();
332 identifierList.add(new ToscaPolicyIdentifier(NON_EXISTANT, VERSION1));
333 identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION9));
334 identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
335 identifierList.add(new ToscaPolicyIdentifier(POLICY1, VERSION4));
336 identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
337 identifierList.add(new ToscaPolicyIdentifier(POLICY3, VERSION1));
338 filter = PdpGroupFilter.builder().policyList(identifierList).build();
339 filteredList = filter.filter(pdpGroupList);
340 assertEquals(5, filteredList.size());
342 filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
343 filteredList = filter.filter(pdpGroupList);
344 assertEquals(0, filteredList.size());
346 identifierList.clear();
347 identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
348 filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
349 filteredList = filter.filter(pdpGroupList);
350 assertEquals(3, filteredList.size());
352 identifierList.clear();
353 identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
354 identifierList.add(new ToscaPolicyIdentifier(POLICY1, VERSION4));
355 filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
356 filteredList = filter.filter(pdpGroupList);
357 assertEquals(1, filteredList.size());
359 identifierList.clear();
360 identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
361 filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
362 filteredList = filter.filter(pdpGroupList);
363 assertEquals(1, filteredList.size());
365 identifierList.clear();
366 identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
367 identifierList.add(new ToscaPolicyIdentifier(POLICY3, VERSION1));
368 filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
369 filteredList = filter.filter(pdpGroupList);
370 assertEquals(1, filteredList.size());