From c8d0a3d8b7df3b09ce3405f1192754fdef7026d3 Mon Sep 17 00:00:00 2001 From: Jim Hahn Date: Sat, 13 Apr 2019 09:05:13 -0400 Subject: Add prefix matching for policy version Re-introduced regular expressions to match policy version so that the policy version found in the metadata, which is just the major number, can be matched with a policy's version, which is of the form, major.minor.patch. Simplified equals() test, as we already know "text!=null". Added filterPrefixPred() and modified policy filter to use it when matching versions, as it is simpler to use when matching a version prefix. Also added tests to PfObjectFilterTest to test each of the XxxPred() methods. Change-Id: I0734873f701a539e883fe25b8eecfdde60cc8b6d Issue-ID: POLICY-1542 Signed-off-by: Jim Hahn --- .../onap/policy/models/base/PfObjectFilter.java | 71 ++++++++++++++++++++-- .../policy/models/base/PfObjectFilterTest.java | 51 +++++++++++++++- 2 files changed, 117 insertions(+), 5 deletions(-) (limited to 'models-base') diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java b/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java index 35319b4fd..f4e457192 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java @@ -24,6 +24,9 @@ package org.onap.policy.models.base; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.regex.Pattern; /** * Interface for filtering a list of concepts. @@ -41,14 +44,74 @@ public interface PfObjectFilter> { public List filter(final List originalList); /** - * Check if a value matches a regular expression. + * Check if a value exactly equals some text. * * @param value the incoming value to check - * @param pattern the pattern to check against + * @param text the desired text to check against * @return match or not */ - public default boolean filterString(final String value, final String pattern) { - return value == null || pattern == null || value.equals(pattern); + public default boolean filterString(final String value, final String text) { + return value == null || text == null || value.equals(text); + } + + /** + * Gets a predicate used to filter an item in a list by exactly matching an extracted value + * with some text. + * + * @param text the desired text to check against, or {@code null} if to accept everything + * @param extractor function to extract the value, to be matched, from a list item + * @return a predicate to match a value from a list item + */ + public default Predicate filterStringPred(final String text, Function extractor) { + // if null text, then everything matches + if (text == null) { + return item -> true; + } + + return item -> text.equals(extractor.apply(item)); + } + + /** + * Gets a predicate used to filter an item in a list by comparing the start of an + * extracted value with a prefix. + * + * @param prefix the desired prefix to check against, or {@code null} if to accept + * everything + * @param extractor function to extract the value, to be matched, from a list item + * @return a predicate to match a prefix with a value from a list item + */ + public default Predicate filterPrefixPred(final String prefix, Function extractor) { + // if null prefix, then everything matches + if (prefix == null) { + return item -> true; + } + + return item -> { + String value = extractor.apply(item); + return (value != null && value.startsWith(prefix)); + }; + } + + /** + * Gets a predicate used to filter an item in a list by matching an extracted value + * with a regular expression. + * + * @param pattern regular expression to match, or {@code null} if to accept everything + * @param extractor function to extract the value, to be matched, from a list item + * @return a predicate to match a value from a list item using a regular expression + */ + public default Predicate filterRegexpPred(final String pattern, Function extractor) { + // if null pattern, then everything matches + if (pattern == null) { + return item -> true; + } + + Pattern pat = Pattern.compile(pattern); + + return item -> { + String value = extractor.apply(item); + return (value != null && pat.matcher(value).matches()); + }; } /** diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java index 686342111..291a7d402 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java @@ -1,6 +1,7 @@ /*- * ============LICENSE_START======================================================= * Copyright (C) 2019 Nordix Foundation. + * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,7 +27,9 @@ import static org.junit.Assert.assertTrue; import java.util.ArrayList; import java.util.List; - +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Predicate; import org.junit.Test; import org.onap.policy.models.base.testconcepts.DummyPfObject; @@ -100,5 +103,51 @@ public class PfObjectFilterTest { latestVersionList.remove(1); List newestVersionList = dof.latestVersionFilter(latestVersionList); assertEquals(latestVersionList, newestVersionList); + + MyFilter filter = new MyFilter(); + + assertEquals(true, filter.filterString(null, "Hello")); + + DummyPfObject doNullVersion = new DummyPfObject(); + do5.setName("bbbbb"); + + assertEquals(false, filter(filter::filterStringPred, DummyPfObject::getVersion, doNullVersion, "1.0.0")); + assertEquals(false, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, "1")); + assertEquals(false, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, "2.0.0")); + assertEquals(true, filter(filter::filterStringPred, DummyPfObject::getVersion, doNullVersion, null)); + assertEquals(true, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, null)); + assertEquals(true, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, "1.0.0")); + + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, doNullVersion, "1.")); + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.1")); + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.1")); + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "2")); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, doNullVersion, null)); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, null)); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.")); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.0.")); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.0.0")); + + assertEquals(false, filter(filter::filterRegexpPred, DummyPfObject::getVersion, doNullVersion, "1[.].*")); + assertEquals(false, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "2[.].*")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, doNullVersion, null)); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, null)); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1[.].*")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1[.]0[.].*")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1[.]0[.]0")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1....")); + } + + private boolean filter(BiFunction, Predicate> predMaker, + Function extractor, DummyPfObject dpo, String text) { + Predicate pred = predMaker.apply(text, extractor); + return pred.test(dpo); + } + + private static class MyFilter implements PfObjectFilter { + @Override + public List filter(List originalList) { + return null; + } } } -- cgit 1.2.3-korg