import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-
-import java.io.IOException;
+import static org.junit.Assert.fail;
import org.junit.Test;
import org.openqa.selenium.Keys;
import org.openqa.selenium.interactions.Actions;
+import com.vaadin.shared.ui.grid.SortDirection;
import com.vaadin.tests.components.grid.GridElement;
+import com.vaadin.tests.components.grid.GridElement.GridCellElement;
import com.vaadin.tests.components.grid.basicfeatures.GridBasicFeatures;
import com.vaadin.tests.components.grid.basicfeatures.GridBasicFeaturesTest;
public class GridSortingTest extends GridBasicFeaturesTest {
+ private static class SortInfo {
+ public final int sortOrder;
+ public final SortDirection sortDirection;
+
+ private SortInfo(int sortOrder, SortDirection sortDirection) {
+ this.sortOrder = sortOrder;
+ this.sortDirection = sortDirection;
+ }
+ }
+
+ private static class SortInfoWithColumn extends SortInfo {
+ public final int columnIndex;
+
+ private SortInfoWithColumn(int columnIndex, int sortOrder,
+ SortDirection sortDirection) {
+ super(sortOrder, sortDirection);
+ this.columnIndex = columnIndex;
+ }
+ }
+
+ private static SortInfo _(int sortOrder, SortDirection sortDirection) {
+ return new SortInfo(sortOrder, sortDirection);
+ }
+
+ private static SortInfoWithColumn _(int columnIndex, int sortOrder,
+ SortDirection sortDirection) {
+ return new SortInfoWithColumn(columnIndex, sortOrder, sortDirection);
+ }
+
@Test
- public void testProgrammaticSorting() throws IOException {
+ public void testProgrammaticSorting() throws Exception {
openTestURL();
- GridElement grid = getGridElement();
-
// Sorting by column 9 is sorting by row index that is represented as a
// String.
// First cells for first 3 rows are (9, 0), (99, 0) and (999, 0)
// Verify that programmatic sorting calls are identified as originating
// from API
- assertEquals("3. Sort order: [Column 9 DESCENDING] by API",
- getLogRow(0));
-
- assertTrue("Column 9 should have the sort-desc stylename", grid
- .getHeaderCell(0, 9).getAttribute("class")
- .contains("sort-desc"));
+ assertColumnsAreSortedAs(_(9, 1, SortDirection.DESCENDING));
String row = "";
for (int i = 0; i < 3; ++i) {
row += "9";
- assertEquals(
- "Grid is not sorted by Column 9 using descending direction.",
- "(" + row + ", 0)", grid.getCell(i, 0).getText());
+ String expected = "(" + row + ", 0)";
+ String cellValue = getGridElement().getCell(i, 0).getText();
+ assertEquals("Grid is not sorted by Column 9 "
+ + "using descending direction.", expected, cellValue);
}
// Column 10 is random numbers from Random with seed 13334
sortBy("Column 10, ASC");
- assertFalse(
- "Column 9 should no longer have the sort-desc stylename",
- grid.getHeaderCell(0, 9).getAttribute("class")
+ assertFalse("Column 9 should no longer have the sort-desc stylename",
+ getGridElement().getHeaderCell(0, 9).getAttribute("class")
.contains("sort-desc"));
- assertTrue("Column 10 should have the sort-asc stylename", grid
- .getHeaderCell(0, 10).getAttribute("class")
- .contains("sort-asc"));
- // Not cleaning up correctly causes exceptions when scrolling.
- grid.scrollToRow(50);
- assertFalse("Scrolling caused and exception when shuffled.",
- getLogRow(0).contains("Exception"));
+ assertColumnsAreSortedAs(_(10, 1, SortDirection.ASCENDING));
for (int i = 0; i < 5; ++i) {
- assertGreater(
- "Grid is not sorted by Column 10 using ascending direction",
- Integer.parseInt(grid.getCell(i + 1, 10).getText()),
- Integer.parseInt(grid.getCell(i, 10).getText()));
+ Integer firstRow = Integer.valueOf(getGridElement().getCell(i + 1,
+ 10).getText());
+ Integer secondRow = Integer.valueOf(getGridElement().getCell(i, 10)
+ .getText());
+ assertGreater("Grid is not sorted by Column 10 using"
+ + " ascending direction", firstRow, secondRow);
}
// 2, 1 and 0.
sortBy("Column 7, DESC");
for (int i = 0; i < 3; ++i) {
- assertEquals(
- "Grid is not sorted by Column 7 using descending direction",
- "(" + i + ", 0)",
- grid.getCell(GridBasicFeatures.ROWS - (i + 1), 0).getText());
+ String expected = "(" + i + ", 0)";
+ String cellContent = getGridElement().getCell(
+ GridBasicFeatures.ROWS - (i + 1), 0).getText();
+ assertEquals("Grid is not sorted by Column 7 using "
+ + "descending direction", expected, cellContent);
}
- assertFalse(
- "Column 10 should no longer have the sort-asc stylename",
- grid.getHeaderCell(0, 10).getAttribute("class")
+ assertFalse("Column 10 should no longer have the sort-asc stylename",
+ getGridElement().getHeaderCell(0, 10).getAttribute("class")
.contains("sort-asc"));
- assertTrue("Column 7 should have the sort-desc stylename", grid
- .getHeaderCell(0, 7).getAttribute("class")
- .contains("sort-desc"));
+ assertColumnsAreSortedAs(_(7, 1, SortDirection.DESCENDING));
}
@Test
- public void testUserSorting() throws InterruptedException {
+ public void testMouseSorting() throws Exception {
openTestURL();
GridElement grid = getGridElement();
// Click header twice to sort descending
grid.getHeaderCell(0, 9).click();
+ assertColumnsAreSortedAs(_(9, 1, SortDirection.ASCENDING));
grid.getHeaderCell(0, 9).click();
+ assertColumnsAreSortedAs(_(9, 1, SortDirection.DESCENDING));
+
String row = "";
for (int i = 0; i < 3; ++i) {
row += "9";
"(" + row + ", 0)", grid.getCell(i, 0).getText());
}
- assertEquals("2. Sort order: [Column 9 ASCENDING] by USER",
- getLogRow(2));
- assertEquals("4. Sort order: [Column 9 DESCENDING] by USER",
- getLogRow(0));
-
// Column 10 is random numbers from Random with seed 13334
// Click header to sort ascending
grid.getHeaderCell(0, 10).click();
-
- assertEquals("6. Sort order: [Column 10 ASCENDING] by USER",
- getLogRow(0));
-
- // Not cleaning up correctly causes exceptions when scrolling.
- grid.scrollToRow(50);
- assertFalse("Scrolling caused and exception when shuffled.",
- getLogRow(0).contains("Exception"));
+ assertColumnsAreSortedAs(_(10, 1, SortDirection.ASCENDING));
for (int i = 0; i < 5; ++i) {
+ Integer firstRow = Integer.valueOf(grid.getCell(i + 1, 10)
+ .getText());
+ Integer secondRow = Integer.valueOf(grid.getCell(i, 10).getText());
assertGreater(
"Grid is not sorted by Column 10 using ascending direction",
- Integer.parseInt(grid.getCell(i + 1, 10).getText()),
- Integer.parseInt(grid.getCell(i, 10).getText()));
+ firstRow, secondRow);
}
// 2, 1 and 0.
// Click header twice to sort descending
grid.getHeaderCell(0, 7).click();
+ assertColumnsAreSortedAs(_(7, 1, SortDirection.ASCENDING));
grid.getHeaderCell(0, 7).click();
+ assertColumnsAreSortedAs(_(7, 1, SortDirection.DESCENDING));
+
for (int i = 0; i < 3; ++i) {
assertEquals(
"Grid is not sorted by Column 7 using descending direction",
grid.getCell(GridBasicFeatures.ROWS - (i + 1), 0).getText());
}
- assertEquals("9. Sort order: [Column 7 ASCENDING] by USER",
- getLogRow(3));
- assertEquals("11. Sort order: [Column 7 DESCENDING] by USER",
- getLogRow(1));
}
@Test
}
- private void sendKeys(CharSequence... seq) {
+ private void sendKey(Keys seq) {
new Actions(getDriver()).sendKeys(seq).perform();
}
new Actions(getDriver()).keyUp(key).perform();
}
- private void assertLog(String expected) {
- assertEquals(expected, getLogRow(0));
- }
-
@Test
public void testKeyboardSorting() {
openTestURL();
- //
- // NOTE: This is a work-around to get the focus to the first header
- // cell.
- // We can't use element.focus() because TestBench (or, rather, Selenium
- // beneath it) has rather interesting bugs regarding focus handling.
- //
+ /*
+ * We can't click on the header directly, since it will sort the header
+ * immediately. We need to focus some other column first, and only then
+ * navigate there.
+ */
getGridElement().getCell(0, 0).click();
- sendKeys(Keys.ARROW_UP);
+ sendKey(Keys.ARROW_UP);
// Sort ASCENDING on first column
- sendKeys(Keys.ENTER);
- assertLog("2. Sort order: [Column 0 ASCENDING] by USER");
+ sendKey(Keys.ENTER);
+ assertColumnsAreSortedAs(_(1, SortDirection.ASCENDING));
// Move to next column
- sendKeys(Keys.RIGHT);
+ sendKey(Keys.RIGHT);
// Add this column to the existing sorting group
holdKey(Keys.SHIFT);
- sendKeys(Keys.ENTER);
+ sendKey(Keys.ENTER);
releaseKey(Keys.SHIFT);
- assertLog("4. Sort order: [Column 0 ASCENDING, Column 1 ASCENDING] by USER");
+ assertColumnsAreSortedAs(_(1, SortDirection.ASCENDING),
+ _(2, SortDirection.ASCENDING));
// Move to next column
- sendKeys(Keys.RIGHT);
+ sendKey(Keys.RIGHT);
// Add a third column to the sorting group
holdKey(Keys.SHIFT);
- sendKeys(Keys.ENTER);
+ sendKey(Keys.ENTER);
releaseKey(Keys.SHIFT);
- assertLog("6. Sort order: [Column 0 ASCENDING, Column 1 ASCENDING, Column 2 ASCENDING] by USER");
+ assertColumnsAreSortedAs(_(1, SortDirection.ASCENDING),
+ _(2, SortDirection.ASCENDING), _(3, SortDirection.ASCENDING));
// Move back to the second column
- sendKeys(Keys.LEFT);
+ sendKey(Keys.LEFT);
// Change sort direction of the second column to DESCENDING
holdKey(Keys.SHIFT);
- sendKeys(Keys.ENTER);
+ sendKey(Keys.ENTER);
releaseKey(Keys.SHIFT);
- assertLog("8. Sort order: [Column 0 ASCENDING, Column 1 DESCENDING, Column 2 ASCENDING] by USER");
+ assertColumnsAreSortedAs(_(1, SortDirection.ASCENDING),
+ _(2, SortDirection.DESCENDING), _(3, SortDirection.ASCENDING));
// Move back to the third column
- sendKeys(Keys.RIGHT);
+ sendKey(Keys.RIGHT);
// Set sorting to third column, ASCENDING
- sendKeys(Keys.ENTER);
- assertLog("10. Sort order: [Column 2 ASCENDING] by USER");
+ sendKey(Keys.ENTER);
+ assertColumnsAreSortedAs(_(2, 1, SortDirection.ASCENDING));
// Move to the fourth column
- sendKeys(Keys.RIGHT);
+ sendKey(Keys.RIGHT);
// Make sure that single-column sorting also works as expected
- sendKeys(Keys.ENTER);
- assertLog("12. Sort order: [Column 3 ASCENDING] by USER");
+ sendKey(Keys.ENTER);
+ assertColumnsAreSortedAs(_(3, 1, SortDirection.ASCENDING));
+
+ }
+
+ private void assertColumnsAreSortedAs(SortInfoWithColumn... sortInfos) {
+ for (SortInfoWithColumn sortInfo : sortInfos) {
+ assertSort(sortInfo, sortInfo.columnIndex,
+ onlyOneColumnIsSorted(sortInfos));
+ }
+ }
+
+ /**
+ * @param sortDirections
+ * <code>null</code> if not interested in that index, otherwise a
+ * direction that the column needs to be sorted as
+ */
+ private void assertColumnsAreSortedAs(SortInfo... sortInfos) {
+ for (int column = 0; column < sortInfos.length; column++) {
+ SortInfo sortInfo = sortInfos[column];
+ assertSort(sortInfo, column, onlyOneColumnIsSorted(sortInfos));
+ }
+ }
+
+ private void assertSort(SortInfo sortInfo, int column,
+ boolean onlyOneColumnIsSorted) {
+ if (sortInfo == null) {
+ return;
+ }
+ GridCellElement headerCell = getGridElement().getHeaderCell(0, column);
+ String classValue = headerCell.getAttribute("class");
+
+ boolean isSortedAscending = sortInfo.sortDirection == SortDirection.ASCENDING
+ && classValue.contains("sort-asc");
+ boolean isSortedDescending = sortInfo.sortDirection == SortDirection.DESCENDING
+ && classValue.contains("sort-desc");
+
+ if (isSortedAscending || isSortedDescending) {
+ String sortOrderAttribute = headerCell.getAttribute("sort-order");
+
+ if (sortOrderAttribute == null) {
+ if (!(sortInfo.sortOrder == 1 && onlyOneColumnIsSorted)) {
+ fail("missing sort-order element attribute from column "
+ + column);
+ }
+ } else {
+ assertEquals("sort order was not as expected",
+ String.valueOf(sortInfo.sortOrder), sortOrderAttribute);
+ }
+ } else {
+ fail("column index " + column + " was not sorted as "
+ + sortInfo.sortDirection + " (class: " + classValue + ")");
+ }
+ }
+
+ private static boolean onlyOneColumnIsSorted(SortInfo[] sortInfos) {
+
+ boolean foundSortedColumn = false;
+ for (SortInfo sortInfo : sortInfos) {
+ if (sortInfo == null) {
+ continue;
+ }
+
+ if (!foundSortedColumn) {
+ foundSortedColumn = true;
+ } else {
+ // two columns were sorted
+ return false;
+ }
+ }
+ return foundSortedColumn;
}
private void sortBy(String column) {
projects / vaadin-framework.git / commitdiff