models-pdp/src/test/java/org/onap/policy/models/pdp/concepts/PdpGroupFilterTest.java

   1 /*-
   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
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.models.pdp.concepts;
  23
  24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertTrue;
  27
  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;
  39
  40 /**
  41  * Test of the {@link PdpGroupFilter} class.
  42  *
  43  * @author Liam Fallon (liam.fallon@est.tech)
  44  */
  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;
  61
  62     /**
  63      * Set up a PDP group list for filtering.
  64      *
  65      * @throws CoderException on JSON decoding errors
  66      */
  67     @Before
  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();
  72     }
  73
  74     @Test
  75     public void testNullList() {
  76         PdpGroupFilter filter = PdpGroupFilter.builder().build();
  77
  78         assertThatThrownBy(() -> {
  79             filter.filter(null);
  80         }).hasMessageMatching("originalList is marked .*ull but is null");
  81     }
  82
  83     @Test
  84     public void testFilterNothing() {
  85         PdpGroupFilter filter = PdpGroupFilter.builder().build();
  86
  87         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
  88         assertTrue(filteredList.containsAll(pdpGroupList));
  89     }
  90
  91     @Test
  92     public void testFilterName() {
  93         PdpGroupFilter filter = PdpGroupFilter.builder().name("PdpGroup0").build();
  94         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
  95         assertEquals(1, filteredList.size());
  96
  97         filter = PdpGroupFilter.builder().name("PdpGroup1").build();
  98         filteredList = filter.filter(pdpGroupList);
  99         assertEquals(1, filteredList.size());
 100
 101         filter = PdpGroupFilter.builder().name("PdpGroup20").build();
 102         filteredList = filter.filter(pdpGroupList);
 103         assertEquals(1, filteredList.size());
 104
 105         filter = PdpGroupFilter.builder().build();
 106         filteredList = filter.filter(pdpGroupList);
 107         assertEquals(5, filteredList.size());
 108
 109         filter = PdpGroupFilter.builder().name("PdpGroup0").build();
 110         filteredList = filter.filter(pdpGroupList);
 111         assertEquals(1, filteredList.size());
 112
 113         filter = PdpGroupFilter.builder().name("PdpGroup19").build();
 114         filteredList = filter.filter(pdpGroupList);
 115         assertEquals(0, filteredList.size());
 116     }
 117
 118     @Test
 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());
 123
 124         filter = PdpGroupFilter.builder().groupState(PdpState.PASSIVE).build();
 125         filteredList = filter.filter(pdpGroupList);
 126         assertEquals(2, filteredList.size());
 127
 128         filter = PdpGroupFilter.builder().groupState(PdpState.TEST).build();
 129         filteredList = filter.filter(pdpGroupList);
 130         assertEquals(1, filteredList.size());
 131
 132         filter = PdpGroupFilter.builder().groupState(PdpState.SAFE).build();
 133         filteredList = filter.filter(pdpGroupList);
 134         assertEquals(1, filteredList.size());
 135
 136         filter = PdpGroupFilter.builder().groupState(PdpState.TERMINATED).build();
 137         filteredList = filter.filter(pdpGroupList);
 138         assertEquals(0, filteredList.size());
 139     }
 140
 141     @Test
 142     public void testFilterPdpType() {
 143         PdpGroupFilter filter = PdpGroupFilter.builder().pdpType("APEX").build();
 144         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 145         assertEquals(5, filteredList.size());
 146
 147         filter = PdpGroupFilter.builder().pdpType("DROOLS").build();
 148         filteredList = filter.filter(pdpGroupList);
 149         assertEquals(2, filteredList.size());
 150
 151         filter = PdpGroupFilter.builder().pdpType("XACML").build();
 152         filteredList = filter.filter(pdpGroupList);
 153         assertEquals(1, filteredList.size());
 154     }
 155
 156     @Test
 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());
 161
 162         filter = PdpGroupFilter.builder().pdpState(PdpState.PASSIVE).build();
 163         filteredList = filter.filter(pdpGroupList);
 164         assertEquals(3, filteredList.size());
 165
 166         filter = PdpGroupFilter.builder().pdpState(PdpState.SAFE).build();
 167         filteredList = filter.filter(pdpGroupList);
 168         assertEquals(2, filteredList.size());
 169
 170         filter = PdpGroupFilter.builder().pdpState(PdpState.TEST).build();
 171         filteredList = filter.filter(pdpGroupList);
 172         assertEquals(2, filteredList.size());
 173     }
 174
 175     @Test
 176     public void testFilterPolicyType() {
 177         List<ToscaPolicyTypeIdentifier> identifierList = new ArrayList<>();
 178
 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();
 185
 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();
 194
 195         // match wild cards
 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();
 201
 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();
 207
 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();
 213
 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();
 219
 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();
 225
 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());
 235
 236         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 237         filteredList = filter.filter(pdpGroupList);
 238         assertEquals(0, filteredList.size());
 239
 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());
 245
 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());
 253
 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());
 261
 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());
 268     }
 269
 270     /**
 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.*".
 273      *
 274      * @param group group to be cloned
 275      * @return a new PdpGroup containing wild card policy types
 276      */
 277     private PdpGroup makeWildCardPolicyTypes(PdpGroup group) {
 278         PdpGroup newGroup = new PdpGroup(group);
 279
 280         for (PdpSubGroup subgroup : newGroup.getPdpSubgroups()) {
 281             for (ToscaPolicyTypeIdentifier subType : subgroup.getSupportedPolicyTypes()) {
 282                 if (POLICY_TYPE0.equals(subType.getName())) {
 283                     subType.setName("policy.type.*");
 284                 }
 285             }
 286         }
 287
 288         return newGroup;
 289     }
 290
 291     @Test
 292     public void testFilterPolicy() {
 293         List<ToscaPolicyIdentifier> identifierList = new ArrayList<>();
 294
 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();
 301
 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();
 307
 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();
 313
 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();
 319
 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();
 325
 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();
 331
 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());
 341
 342         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 343         filteredList = filter.filter(pdpGroupList);
 344         assertEquals(0, filteredList.size());
 345
 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());
 351
 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());
 358
 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());
 364
 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());
 371     }
 372 }