Add a data provider wrapper with a configurable filter (#8280)

* Add a data provider wrapper with a configurable filter

This is one of many steps towards #8245

2 files changed, 121 insertions, 17 deletions

diff --git a/server/src/test/java/com/vaadin/data/provider/BackendDataProviderTest.java b/server/src/test/java/com/vaadin/data/provider/BackendDataProviderTest.java
index 797f14957c..e2f5211d00 100644
--- a/server/src/test/java/com/vaadin/data/provider/BackendDataProviderTest.java
+++ b/server/src/test/java/com/vaadin/data/provider/BackendDataProviderTest.java
@@ -23,7 +23,7 @@ public class BackendDataProviderTest extends
                 Comparator.comparing(StrBean::getRandomNumber));
     }
 
-    private Comparator<StrBean> getComparator(SortOrder<String> so) {
+    private static Comparator<StrBean> getComparator(SortOrder<String> so) {
         Comparator<StrBean> comparator = propertyToComparatorMap
                 .get(so.getSorted());
         if (so.getDirection() == SortDirection.DESCENDING) {
@@ -32,24 +32,32 @@ public class BackendDataProviderTest extends
         return comparator;
     }
 
+    public static class StrBeanBackEndDataProvider extends
+            CallbackDataProvider<StrBean, SerializablePredicate<StrBean>> {
+
+        public StrBeanBackEndDataProvider(List<StrBean> data) {
+            super(query -> {
+                Stream<StrBean> stream = data.stream().filter(
+                        t -> query.getFilter().orElse(s -> true).test(t));
+                if (!query.getSortOrders().isEmpty()) {
+                    Comparator<StrBean> sorting = query.getSortOrders().stream()
+                            .map(BackendDataProviderTest::getComparator)
+                            .reduce((c1, c2) -> c1.thenComparing(c2)).get();
+                    stream = stream.sorted(sorting);
+                }
+                List<StrBean> list = stream.skip(query.getOffset())
+                        .limit(query.getLimit()).collect(Collectors.toList());
+                list.forEach(s -> System.err.println(s.toString()));
+                return list.stream();
+            }, query -> (int) data.stream()
+                    .filter(t -> query.getFilter().orElse(s -> true).test(t))
+                    .count());
+        }
+    }
+
     @Override
     protected BackEndDataProvider<StrBean, SerializablePredicate<StrBean>> createDataProvider() {
-        return dataProvider = new CallbackDataProvider<>(query -> {
-            Stream<StrBean> stream = data.stream()
-                    .filter(t -> query.getFilter().orElse(s -> true).test(t));
-            if (!query.getSortOrders().isEmpty()) {
-                Comparator<StrBean> sorting = query.getSortOrders().stream()
-                        .map(this::getComparator)
-                        .reduce((c1, c2) -> c1.thenComparing(c2)).get();
-                stream = stream.sorted(sorting);
-            }
-            List<StrBean> list = stream.skip(query.getOffset())
-                    .limit(query.getLimit()).collect(Collectors.toList());
-            list.forEach(s -> System.err.println(s.toString()));
-            return list.stream();
-        }, query -> (int) data.stream()
-                .filter(t -> query.getFilter().orElse(s -> true).test(t))
-                .count());
+        return dataProvider = new StrBeanBackEndDataProvider(data);
     }
 
     @Override
diff --git a/server/src/test/java/com/vaadin/data/provider/ConfigurableFilterDataProviderWrapperTest.java b/server/src/test/java/com/vaadin/data/provider/ConfigurableFilterDataProviderWrapperTest.java
new file mode 100644
index 0000000000..115e4fd6bd
--- /dev/null
+++ b/server/src/test/java/com/vaadin/data/provider/ConfigurableFilterDataProviderWrapperTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.data.provider;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.vaadin.data.provider.BackendDataProviderTest.StrBeanBackEndDataProvider;
+import com.vaadin.server.SerializablePredicate;
+
+public class ConfigurableFilterDataProviderWrapperTest {
+    private static SerializablePredicate<StrBean> xyzFilter = item -> item
+            .getValue().equals("Xyz");
+
+    private StrBeanBackEndDataProvider backEndProvider = new StrBeanBackEndDataProvider(
+            StrBean.generateRandomBeans(100));
+    private ConfigurableFilterDataProvider<StrBean, Void, SerializablePredicate<StrBean>> configurableVoid = backEndProvider
+            .withConfigurableFilter();
+    private ConfigurableFilterDataProvider<StrBean, SerializablePredicate<StrBean>, SerializablePredicate<StrBean>> configurablePredicate = backEndProvider
+            .withConfigurableFilter((configuredFilter, queryFilter) -> item -> {
+                if (configuredFilter != null && !configuredFilter.test(item)) {
+                    return false;
+                }
+
+                return queryFilter.test(item);
+            });
+
+    @Test
+    public void void_setFilter() {
+        configurableVoid.setFilter(xyzFilter);
+
+        Assert.assertEquals("Set filter should be used", 1,
+                configurableVoid.size(new Query<>()));
+
+        configurableVoid.setFilter(null);
+
+        Assert.assertEquals("null filter should return all items", 100,
+                configurableVoid.size(new Query<>()));
+    }
+
+    @Test(expected = Exception.class)
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public void void_nonNullQueryFilter_throws() {
+        configurableVoid
+                .size((Query) new Query<StrBean, String>("invalid filter"));
+    }
+
+    @Test
+    public void predicate_setFilter() {
+        configurablePredicate.setFilter(xyzFilter);
+
+        Assert.assertEquals("Set filter should be used", 1,
+                configurablePredicate.size(new Query<>()));
+
+        configurablePredicate.setFilter(null);
+
+        Assert.assertEquals("null filter should return all items", 100,
+                configurablePredicate.size(new Query<>()));
+    }
+
+    @Test
+    public void predicate_queryFilter() {
+        Assert.assertEquals("Query filter should be used", 1,
+                configurablePredicate.size(new Query<>(xyzFilter)));
+
+        Assert.assertEquals("null query filter should return all items", 100,
+                configurablePredicate.size(new Query<>()));
+    }
+
+    @Test
+    public void predicate_combinedFilters() {
+        configurablePredicate.setFilter(item -> item.getValue().equals("Foo"));
+
+        Assert.assertEquals("Both filters should be used", 0,
+                configurablePredicate.size(new Query<>(xyzFilter)));
+
+        configurablePredicate.setFilter(null);
+
+        Assert.assertEquals("Only zyz filter should be used", 1,
+                configurablePredicate.size(new Query<>(xyzFilter)));
+    }
+
+}