Implement GridSortOrder and SortOrderBuilders (#8338)

3 files changed, 82 insertions, 15 deletions

diff --git a/server/src/test/java/com/vaadin/data/provider/DataProviderTestBase.java b/server/src/test/java/com/vaadin/data/provider/DataProviderTestBase.java
index ebdcdd105c..84f011abf8 100644
--- a/server/src/test/java/com/vaadin/data/provider/DataProviderTestBase.java
+++ b/server/src/test/java/com/vaadin/data/provider/DataProviderTestBase.java
@@ -82,7 +82,8 @@ public abstract class DataProviderTestBase<D extends DataProvider<StrBean, Seria
                 .thenComparing(StrBean::getId);
 
         List<StrBean> list = dataProvider
-                .fetch(createQuery(Sort.asc("value").thenAsc("randomNumber")
+                .fetch(createQuery(
+                        QuerySortOrder.asc("value").thenAsc("randomNumber")
                         .thenAsc("id").build(), comp))
                 .collect(Collectors.toList());
 
@@ -104,10 +105,10 @@ public abstract class DataProviderTestBase<D extends DataProvider<StrBean, Seria
     public void testDefaultSortWithSpecifiedPostSort() {
         Comparator<StrBean> comp = Comparator.comparing(StrBean::getValue)
                 .thenComparing(Comparator.comparing(StrBean::getId).reversed());
-        setSortOrder(Sort.asc("value").thenDesc("id").build(), comp);
+        setSortOrder(QuerySortOrder.asc("value").thenDesc("id").build(), comp);
 
         List<StrBean> list = dataProvider
-                .fetch(createQuery(Sort.asc("randomNumber").build(),
+                .fetch(createQuery(QuerySortOrder.asc("randomNumber").build(),
                         Comparator.comparing(StrBean::getRandomNumber)))
                 .collect(Collectors.toList());
 
@@ -136,7 +137,7 @@ public abstract class DataProviderTestBase<D extends DataProvider<StrBean, Seria
 
     @Test
     public void testDefaultSortWithFunction() {
-        setSortOrder(Sort.asc("value").build(),
+        setSortOrder(QuerySortOrder.asc("value").build(),
                 Comparator.comparing(StrBean::getValue));
 
         List<StrBean> list = dataProvider.fetch(new Query<>())
diff --git a/server/src/test/java/com/vaadin/data/provider/SortOrderBuildersTest.java b/server/src/test/java/com/vaadin/data/provider/SortOrderBuildersTest.java
new file mode 100644
index 0000000000..e289686040
--- /dev/null
+++ b/server/src/test/java/com/vaadin/data/provider/SortOrderBuildersTest.java
@@ -0,0 +1,66 @@
+package com.vaadin.data.provider;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.vaadin.shared.data.sort.SortDirection;
+import com.vaadin.ui.Grid;
+import com.vaadin.ui.Grid.Column;
+import com.vaadin.ui.renderers.NumberRenderer;
+
+public class SortOrderBuildersTest {
+
+    @Test
+    public void gridSortOrderBuilder() {
+        Grid<String> grid = new Grid<>();
+        Column<String, String> col1 = grid.addColumn(string -> string);
+        Column<String, Number> col2 = grid.addColumn(string -> 1,
+                new NumberRenderer());
+        Column<String, ?> col3 = grid
+                .addColumn(string -> LocalDate.of(0, 0, 0));
+
+        // construct with asc
+        verifySortOrders(
+                Arrays.asList(
+                        new GridSortOrder<>(col1, SortDirection.ASCENDING),
+                        new GridSortOrder<>(col2, SortDirection.DESCENDING),
+                        new GridSortOrder<>(col3, SortDirection.ASCENDING)),
+                GridSortOrder.asc(col1).thenDesc(col2).thenAsc(col3).build());
+        // construct with desc
+        verifySortOrders(
+                Arrays.asList(
+                        new GridSortOrder<>(col1, SortDirection.DESCENDING),
+                        new GridSortOrder<>(col2, SortDirection.DESCENDING),
+                        new GridSortOrder<>(col3, SortDirection.ASCENDING)),
+                GridSortOrder.desc(col1).thenDesc(col2).thenAsc(col3).build());
+    }
+
+    @Test
+    public void querySortOrderBuilder() {
+        verifySortOrders(
+                Arrays.asList(new QuerySortOrder("a", SortDirection.ASCENDING),
+                        new QuerySortOrder("b", SortDirection.DESCENDING),
+                        new QuerySortOrder("c", SortDirection.ASCENDING)),
+                QuerySortOrder.asc("a").thenDesc("b").thenAsc("c").build());
+        verifySortOrders(
+                Arrays.asList(new QuerySortOrder("a", SortDirection.DESCENDING),
+                        new QuerySortOrder("b", SortDirection.DESCENDING),
+                        new QuerySortOrder("c", SortDirection.ASCENDING)),
+                QuerySortOrder.desc("a").thenDesc("b").thenAsc("c").build());
+    }
+
+    private <T extends SortOrder<?>> void verifySortOrders(List<T> order1,
+            List<T> order2) {
+        Assert.assertEquals(order1.size(), order2.size());
+        for (int i = 0; i < order1.size(); i++) {
+            Assert.assertEquals(order1.get(i).getDirection(),
+                    order2.get(i).getDirection());
+            Assert.assertEquals(order1.get(i).getSorted(),
+                    order1.get(i).getSorted());
+        }
+    }
+}
diff --git a/server/src/test/java/com/vaadin/tests/server/component/grid/GridTest.java b/server/src/test/java/com/vaadin/tests/server/component/grid/GridTest.java
index 73ef2fceeb..601a63115e 100644
--- a/server/src/test/java/com/vaadin/tests/server/component/grid/GridTest.java
+++ b/server/src/test/java/com/vaadin/tests/server/component/grid/GridTest.java
@@ -16,7 +16,7 @@ import org.junit.Before;
 import org.junit.Test;
 
 import com.vaadin.data.ValueProvider;
-import com.vaadin.data.provider.SortOrder;
+import com.vaadin.data.provider.GridSortOrder;
 import com.vaadin.event.selection.SelectionEvent;
 import com.vaadin.shared.data.sort.SortDirection;
 import com.vaadin.shared.ui.grid.HeightMode;
@@ -179,7 +179,7 @@ public class GridTest {
         Column<String, ?> column = grid.getColumns().get(1);
         grid.sort(column);
 
-        SortOrder<Column<String, ?>> sortOrder = grid.getSortOrder().get(0);
+        GridSortOrder<String> sortOrder = grid.getSortOrder().get(0);
         Assert.assertEquals(column, sortOrder.getSorted());
         Assert.assertEquals(SortDirection.ASCENDING, sortOrder.getDirection());
     }
@@ -189,7 +189,7 @@ public class GridTest {
         Column<String, ?> column = grid.getColumns().get(1);
         grid.sort(column, SortDirection.DESCENDING);
 
-        SortOrder<Column<String, ?>> sortOrder = grid.getSortOrder().get(0);
+        GridSortOrder<String> sortOrder = grid.getSortOrder().get(0);
         Assert.assertEquals(column, sortOrder.getSorted());
         Assert.assertEquals(SortDirection.DESCENDING, sortOrder.getDirection());
     }
@@ -198,12 +198,12 @@ public class GridTest {
     public void setSortOrder() {
         Column<String, ?> column1 = grid.getColumns().get(1);
         Column<String, ?> column2 = grid.getColumns().get(2);
-        List<SortOrder<Column<String, ?>>> order = Arrays.asList(
-                new SortOrder<>(column2, SortDirection.DESCENDING),
-                new SortOrder<>(column1, SortDirection.ASCENDING));
+        List<GridSortOrder<String>> order = Arrays.asList(
+                new GridSortOrder<>(column2, SortDirection.DESCENDING),
+                new GridSortOrder<>(column1, SortDirection.ASCENDING));
         grid.setSortOrder(order);
 
-        List<SortOrder<Column<String, ?>>> sortOrder = grid.getSortOrder();
+        List<GridSortOrder<String>> sortOrder = grid.getSortOrder();
         Assert.assertEquals(column2, sortOrder.get(0).getSorted());
         Assert.assertEquals(SortDirection.DESCENDING,
                 sortOrder.get(0).getDirection());
@@ -228,7 +228,7 @@ public class GridTest {
         Column<String, ?> column1 = grid.getColumns().get(1);
         Column<String, ?> column2 = grid.getColumns().get(2);
 
-        List<SortOrder<Column<String, ?>>> list = new ArrayList<>();
+        List<GridSortOrder<String>> list = new ArrayList<>();
         AtomicReference<Boolean> fired = new AtomicReference<>();
         grid.addSortListener(event -> {
             Assert.assertTrue(list.isEmpty());
@@ -241,9 +241,9 @@ public class GridTest {
         Assert.assertEquals(SortDirection.DESCENDING,
                 list.get(0).getDirection());
 
-        List<SortOrder<Column<String, ?>>> order = Arrays.asList(
-                new SortOrder<>(column2, SortDirection.DESCENDING),
-                new SortOrder<>(column1, SortDirection.ASCENDING));
+        List<GridSortOrder<String>> order = Arrays.asList(
+                new GridSortOrder<>(column2, SortDirection.DESCENDING),
+                new GridSortOrder<>(column1, SortDirection.ASCENDING));
         list.clear();
 
         grid.setSortOrder(order);