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
  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         }).hasMessage("originalList is marked @NonNull 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         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
 187         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 188         filteredList = filter.filter(pdpGroupList);
 189         assertEquals(4, filteredList.size());
 190         identifierList.clear();
 191
 192         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
 193         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 194         filteredList = filter.filter(pdpGroupList);
 195         assertEquals(4, filteredList.size());
 196         identifierList.clear();
 197
 198         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE2, VERSION7));
 199         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 200         filteredList = filter.filter(pdpGroupList);
 201         assertEquals(2, filteredList.size());
 202         identifierList.clear();
 203
 204         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
 205         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 206         filteredList = filter.filter(pdpGroupList);
 207         assertEquals(2, filteredList.size());
 208         identifierList.clear();
 209
 210         identifierList.add(new ToscaPolicyTypeIdentifier(NON_EXISTANT, VERSION1));
 211         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION9));
 212         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
 213         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
 214         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE2, VERSION7));
 215         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
 216         filter = PdpGroupFilter.builder().policyTypeList(identifierList).build();
 217         filteredList = filter.filter(pdpGroupList);
 218         assertEquals(5, filteredList.size());
 219
 220         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 221         filteredList = filter.filter(pdpGroupList);
 222         assertEquals(0, filteredList.size());
 223
 224         identifierList.clear();
 225         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
 226         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 227         filteredList = filter.filter(pdpGroupList);
 228         assertEquals(2, filteredList.size());
 229
 230         identifierList.clear();
 231         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
 232         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
 233         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE2, VERSION7));
 234         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 235         filteredList = filter.filter(pdpGroupList);
 236         assertEquals(1, filteredList.size());
 237
 238         identifierList.clear();
 239         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE0, VERSION1));
 240         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
 241         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
 242         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 243         filteredList = filter.filter(pdpGroupList);
 244         assertEquals(1, filteredList.size());
 245
 246         identifierList.clear();
 247         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE1, VERSION4));
 248         identifierList.add(new ToscaPolicyTypeIdentifier(POLICY_TYPE3, VERSION0));
 249         filter = PdpGroupFilter.builder().policyTypeList(identifierList).matchPolicyTypesExactly(true).build();
 250         filteredList = filter.filter(pdpGroupList);
 251         assertEquals(1, filteredList.size());
 252     }
 253
 254     @Test
 255     public void testFilterPolicy() {
 256         List<ToscaPolicyIdentifier> identifierList = new ArrayList<>();
 257
 258         identifierList.add(new ToscaPolicyIdentifier(NON_EXISTANT, VERSION1));
 259         PdpGroupFilter filter =
 260                 PdpGroupFilter.builder().policyList(identifierList).build();
 261         List<PdpGroup> filteredList = filter.filter(pdpGroupList);
 262         assertEquals(0, filteredList.size());
 263         identifierList.clear();
 264
 265         identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION9));
 266         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 267         filteredList = filter.filter(pdpGroupList);
 268         assertEquals(0, filteredList.size());
 269         identifierList.clear();
 270
 271         identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
 272         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 273         filteredList = filter.filter(pdpGroupList);
 274         assertEquals(4, filteredList.size());
 275         identifierList.clear();
 276
 277         identifierList.add(new ToscaPolicyIdentifier(POLICY1, VERSION4));
 278         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 279         filteredList = filter.filter(pdpGroupList);
 280         assertEquals(1, filteredList.size());
 281         identifierList.clear();
 282
 283         identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
 284         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 285         filteredList = filter.filter(pdpGroupList);
 286         assertEquals(2, filteredList.size());
 287         identifierList.clear();
 288
 289         identifierList.add(new ToscaPolicyIdentifier(POLICY3, VERSION1));
 290         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 291         filteredList = filter.filter(pdpGroupList);
 292         assertEquals(1, filteredList.size());
 293         identifierList.clear();
 294
 295         identifierList.add(new ToscaPolicyIdentifier(NON_EXISTANT, VERSION1));
 296         identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION9));
 297         identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
 298         identifierList.add(new ToscaPolicyIdentifier(POLICY1, VERSION4));
 299         identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
 300         identifierList.add(new ToscaPolicyIdentifier(POLICY3, VERSION1));
 301         filter = PdpGroupFilter.builder().policyList(identifierList).build();
 302         filteredList = filter.filter(pdpGroupList);
 303         assertEquals(5, filteredList.size());
 304
 305         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 306         filteredList = filter.filter(pdpGroupList);
 307         assertEquals(0, filteredList.size());
 308
 309         identifierList.clear();
 310         identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
 311         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 312         filteredList = filter.filter(pdpGroupList);
 313         assertEquals(3, filteredList.size());
 314
 315         identifierList.clear();
 316         identifierList.add(new ToscaPolicyIdentifier(POLICY0, VERSION4));
 317         identifierList.add(new ToscaPolicyIdentifier(POLICY1, VERSION4));
 318         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 319         filteredList = filter.filter(pdpGroupList);
 320         assertEquals(1, filteredList.size());
 321
 322         identifierList.clear();
 323         identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
 324         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 325         filteredList = filter.filter(pdpGroupList);
 326         assertEquals(1, filteredList.size());
 327
 328         identifierList.clear();
 329         identifierList.add(new ToscaPolicyIdentifier(POLICY2, VERSION4));
 330         identifierList.add(new ToscaPolicyIdentifier(POLICY3, VERSION1));
 331         filter = PdpGroupFilter.builder().policyList(identifierList).matchPoliciesExactly(true).build();
 332         filteredList = filter.filter(pdpGroupList);
 333         assertEquals(1, filteredList.size());
 334     }
 335 }