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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2021 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.ToscaConceptIdentifier;
  38
  39 /**
  40  * Test of the {@link PdpGroupFilter} class.
  41  *
  42  * @author Liam Fallon (liam.fallon@est.tech)
  43  */
  44 public class PdpGroupFilterTest {
  45     private static final String POLICY_TYPE3 = "policy.type.3";
  46     private static final String POLICY_TYPE2 = "policy.type.2";
  47     private static final String POLICY_TYPE1 = "policy.type.1";
  48     private static final String POLICY_TYPE0 = "policy.type.0";
  49     private static final String POLICY3 = "Policy3";
  50     private static final String POLICY2 = "Policy2";
  51     private static final String POLICY1 = "Policy1";
  52     private static final String POLICY0 = "Policy0";
  53     private static final String NON_EXISTANT = "Nonexistant";
  54     private static final String VERSION9 = "9.9.9";
  55     private static final String VERSION7 = "7.8.9";
  56     private static final String VERSION4 = "4.5.6";
  57     private static final String VERSION1 = "1.2.3";
  58     private static final String VERSION0 = "0.1.2";
  59     private List<PdpGroup> pdpGroupList;
  60
  61     /**
  62      * Set up a PDP group list for filtering.
  63      *
  64      * @throws CoderException on JSON decoding errors
  65      */
  66     @Before
  67     public void setupPdpGroupList() throws CoderException {
  68         String originalJson = ResourceUtils.getResourceAsString("testdata/PdpGroupsForFiltering.json");
  69         PdpGroups pdpGroups = new StandardCoder().decode(originalJson, PdpGroups.class);
  70         pdpGroupList = pdpGroups.getGroups();
  71     }
  72
  73     @Test
  74     public void testNullList() {
  75         PdpGroupFilter filter = PdpGroupFilter.builder().build();
  76
  77         assertThatThrownBy(() -> {
  78             filter.filter(null);
  79         }).hasMessageMatching("originalList is marked .*ull but is null");
  80     }
  81
  82     @Test
  83     public void testFilterNothing() {
  84         PdpGroupFilter filter = PdpGroupFilter.builder().build();
  85
  86         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
  87         assertTrue(filteredList.containsAll(pdpGroupList));
  88     }
  89
  90     @Test
  91     public void testFilterName() {
  92         PdpGroupFilter filter = PdpGroupFilter.builder().name("PdpGroup0").build();
  93         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
  94         assertEquals(1, filteredList.size());
  95
  96         filter = PdpGroupFilter.builder().name("PdpGroup1").build();
  97         filteredList = filter.filter(pdpGroupList);
  98         assertEquals(1, filteredList.size());
  99
 100         filter = PdpGroupFilter.builder().name("PdpGroup20").build();
 101         filteredList = filter.filter(pdpGroupList);
 102         assertEquals(1, filteredList.size());
 103
 104         filter = PdpGroupFilter.builder().build();
 105         filteredList = filter.filter(pdpGroupList);
 106         assertEquals(5, filteredList.size());
 107
 108         filter = PdpGroupFilter.builder().name("PdpGroup0").build();
 109         filteredList = filter.filter(pdpGroupList);
 110         assertEquals(1, filteredList.size());
 111
 112         filter = PdpGroupFilter.builder().name("PdpGroup19").build();
 113         filteredList = filter.filter(pdpGroupList);
 114         assertEquals(0, filteredList.size());
 115     }
 116
 117     @Test
 118     public void testFilterPdpGroupState() {
 119         PdpGroupFilter filter = PdpGroupFilter.builder().groupState(PdpState.ACTIVE).build();
 120         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 121         assertEquals(1, filteredList.size());
 122
 123         filter = PdpGroupFilter.builder().groupState(PdpState.PASSIVE).build();
 124         filteredList = filter.filter(pdpGroupList);
 125         assertEquals(2, filteredList.size());
 126
 127         filter = PdpGroupFilter.builder().groupState(PdpState.TEST).build();
 128         filteredList = filter.filter(pdpGroupList);
 129         assertEquals(1, filteredList.size());
 130
 131         filter = PdpGroupFilter.builder().groupState(PdpState.SAFE).build();
 132         filteredList = filter.filter(pdpGroupList);
 133         assertEquals(1, filteredList.size());
 134
 135         filter = PdpGroupFilter.builder().groupState(PdpState.TERMINATED).build();
 136         filteredList = filter.filter(pdpGroupList);
 137         assertEquals(0, filteredList.size());
 138     }
 139
 140     @Test
 141     public void testFilterPdpType() {
 142         PdpGroupFilter filter = PdpGroupFilter.builder().pdpType("APEX").build();
 143         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 144         assertEquals(5, filteredList.size());
 145
 146         filter = PdpGroupFilter.builder().pdpType("DROOLS").build();
 147         filteredList = filter.filter(pdpGroupList);
 148         assertEquals(2, filteredList.size());
 149
 150         filter = PdpGroupFilter.builder().pdpType("XACML").build();
 151         filteredList = filter.filter(pdpGroupList);
 152         assertEquals(1, filteredList.size());
 153     }
 154
 155     @Test
 156     public void testFilterPdpState() {
 157         PdpGroupFilter filter = PdpGroupFilter.builder().pdpState(PdpState.ACTIVE).build();
 158         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 159         assertEquals(3, filteredList.size());
 160
 161         filter = PdpGroupFilter.builder().pdpState(PdpState.PASSIVE).build();
 162         filteredList = filter.filter(pdpGroupList);
 163         assertEquals(3, filteredList.size());
 164
 165         filter = PdpGroupFilter.builder().pdpState(PdpState.SAFE).build();
 166         filteredList = filter.filter(pdpGroupList);
 167         assertEquals(2, filteredList.size());
 168
 169         filter = PdpGroupFilter.builder().pdpState(PdpState.TEST).build();
 170         filteredList = filter.filter(pdpGroupList);
 171         assertEquals(2, filteredList.size());
 172     }
 173
 174     @Test
 175     public void testFilterPolicyType() {
 176         List<ToscaConceptIdentifier> identifierList = new ArrayList<>();
 177
 178         identifierList.add(new ToscaConceptIdentifier(NON_EXISTANT, VERSION1));
 179         PdpGroupFilter filter =
 180                 PdpGroupFilter.builder().policyTypeList(identifierList).build();
 181         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 182         assertEquals(0, filteredList.size());
 183         identifierList.clear();
 184
 185         // don't match wild cards
 186         identifierList.add(new ToscaConceptIdentifier(NON_EXISTANT, VERSION1));
 187         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 188         final List<PdpGroup> wildCards =
 189                         pdpGroupList.stream().map(this::makeWildCardPolicyTypes).collect(Collectors.toList());
 190         filteredList = filter.filter(wildCards);
 191         assertEquals(0, filteredList.size());
 192         identifierList.clear();
 193
 194         // match wild cards
 195         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION1));
 196         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 197         filteredList = filter.filter(wildCards);
 198         assertEquals(4, filteredList.size());
 199         identifierList.clear();
 200
 201         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION1));
 202         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 203         filteredList = filter.filter(pdpGroupList);
 204         assertEquals(4, filteredList.size());
 205         identifierList.clear();
 206
 207         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE1, VERSION4));
 208         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 209         filteredList = filter.filter(pdpGroupList);
 210         assertEquals(4, filteredList.size());
 211         identifierList.clear();
 212
 213         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE2, VERSION7));
 214         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 215         filteredList = filter.filter(pdpGroupList);
 216         assertEquals(2, filteredList.size());
 217         identifierList.clear();
 218
 219         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE3, VERSION0));
 220         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 221         filteredList = filter.filter(pdpGroupList);
 222         assertEquals(2, filteredList.size());
 223         identifierList.clear();
 224
 225         identifierList.add(new ToscaConceptIdentifier(NON_EXISTANT, VERSION1));
 226         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION9));
 227         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION1));
 228         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE1, VERSION4));
 229         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE2, VERSION7));
 230         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE3, VERSION0));
 231         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 232         filteredList = filter.filter(pdpGroupList);
 233         assertEquals(5, filteredList.size());
 234
 235         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 236         filteredList = filter.filter(pdpGroupList);
 237         assertEquals(0, filteredList.size());
 238
 239         identifierList.clear();
 240         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION1));
 241         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 242         filteredList = filter.filter(pdpGroupList);
 243         assertEquals(2, filteredList.size());
 244
 245         identifierList.clear();
 246         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION1));
 247         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE1, VERSION4));
 248         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE2, VERSION7));
 249         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 250         filteredList = filter.filter(pdpGroupList);
 251         assertEquals(1, filteredList.size());
 252
 253         identifierList.clear();
 254         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE0, VERSION1));
 255         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE1, VERSION4));
 256         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE3, VERSION0));
 257         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 258         filteredList = filter.filter(pdpGroupList);
 259         assertEquals(1, filteredList.size());
 260
 261         identifierList.clear();
 262         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE1, VERSION4));
 263         identifierList.add(new ToscaConceptIdentifier(POLICY_TYPE3, VERSION0));
 264         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 265         filteredList = filter.filter(pdpGroupList);
 266         assertEquals(1, filteredList.size());
 267     }
 268
 269     /**
 270      * Makes a clone of a PdpGroup, changing all occurrences of supported policy type,
 271      * "policy.type.0", to a wild card type, "policy.type.*".
 272      *
 273      * @param group group to be cloned
 274      * @return a new PdpGroup containing wild card policy types
 275      */
 276     private PdpGroup makeWildCardPolicyTypes(PdpGroup group) {
 277         PdpGroup newGroup = new PdpGroup(group);
 278
 279         for (PdpSubGroup subgroup : newGroup.getPdpSubgroups()) {
 280             for (ToscaConceptIdentifier subType : subgroup.getSupportedPolicyTypes()) {
 281                 if (POLICY_TYPE0.equals(subType.getName())) {
 282                     subType.setName("policy.type.*");
 283                 }
 284             }
 285         }
 286
 287         return newGroup;
 288     }
 289
 290     @Test
 291     public void testFilterPolicy() {
 292         List<ToscaConceptIdentifier> identifierList = new ArrayList<>();
 293
 294         identifierList.add(new ToscaConceptIdentifier(NON_EXISTANT, VERSION1));
 295         PdpGroupFilter filter =
 296                 PdpGroupFilter.builder().policyList(identifierList).build();
 297         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 298         assertEquals(0, filteredList.size());
 299         identifierList.clear();
 300
 301         identifierList.add(new ToscaConceptIdentifier(POLICY0, VERSION9));
 302         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 303         filteredList = filter.filter(pdpGroupList);
 304         assertEquals(0, filteredList.size());
 305         identifierList.clear();
 306
 307         identifierList.add(new ToscaConceptIdentifier(POLICY0, VERSION4));
 308         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 309         filteredList = filter.filter(pdpGroupList);
 310         assertEquals(4, filteredList.size());
 311         identifierList.clear();
 312
 313         identifierList.add(new ToscaConceptIdentifier(POLICY1, VERSION4));
 314         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 315         filteredList = filter.filter(pdpGroupList);
 316         assertEquals(1, filteredList.size());
 317         identifierList.clear();
 318
 319         identifierList.add(new ToscaConceptIdentifier(POLICY2, VERSION4));
 320         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 321         filteredList = filter.filter(pdpGroupList);
 322         assertEquals(2, filteredList.size());
 323         identifierList.clear();
 324
 325         identifierList.add(new ToscaConceptIdentifier(POLICY3, VERSION1));
 326         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 327         filteredList = filter.filter(pdpGroupList);
 328         assertEquals(1, filteredList.size());
 329         identifierList.clear();
 330
 331         identifierList.add(new ToscaConceptIdentifier(NON_EXISTANT, VERSION1));
 332         identifierList.add(new ToscaConceptIdentifier(POLICY0, VERSION9));
 333         identifierList.add(new ToscaConceptIdentifier(POLICY0, VERSION4));
 334         identifierList.add(new ToscaConceptIdentifier(POLICY1, VERSION4));
 335         identifierList.add(new ToscaConceptIdentifier(POLICY2, VERSION4));
 336         identifierList.add(new ToscaConceptIdentifier(POLICY3, VERSION1));
 337         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 338         filteredList = filter.filter(pdpGroupList);
 339         assertEquals(5, filteredList.size());
 340
 341         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 342         filteredList = filter.filter(pdpGroupList);
 343         assertEquals(0, filteredList.size());
 344
 345         identifierList.clear();
 346         identifierList.add(new ToscaConceptIdentifier(POLICY0, VERSION4));
 347         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 348         filteredList = filter.filter(pdpGroupList);
 349         assertEquals(3, filteredList.size());
 350
 351         identifierList.clear();
 352         identifierList.add(new ToscaConceptIdentifier(POLICY0, VERSION4));
 353         identifierList.add(new ToscaConceptIdentifier(POLICY1, VERSION4));
 354         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 355         filteredList = filter.filter(pdpGroupList);
 356         assertEquals(1, filteredList.size());
 357
 358         identifierList.clear();
 359         identifierList.add(new ToscaConceptIdentifier(POLICY2, VERSION4));
 360         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 361         filteredList = filter.filter(pdpGroupList);
 362         assertEquals(1, filteredList.size());
 363
 364         identifierList.clear();
 365         identifierList.add(new ToscaConceptIdentifier(POLICY2, VERSION4));
 366         identifierList.add(new ToscaConceptIdentifier(POLICY3, VERSION1));
 367         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 368         filteredList = filter.filter(pdpGroupList);
 369         assertEquals(1, filteredList.size());
 370     }
 371 }