From a6fb590a17fdfbc81969810bffe1b6616f9be880 Mon Sep 17 00:00:00 2001 From: Henrik Paul Date: Mon, 29 Sep 2014 14:25:35 +0300 Subject: [PATCH] Tests behavior rather than log output (#13334) Change-Id: Id00aa2d79251a6235486d39e66552a9ed4b3c534 --- .../basicfeatures/server/GridSortingTest.java | 250 ++++++++++++------ 1 file changed, 163 insertions(+), 87 deletions(-) diff --git a/uitest/src/com/vaadin/tests/components/grid/basicfeatures/server/GridSortingTest.java b/uitest/src/com/vaadin/tests/components/grid/basicfeatures/server/GridSortingTest.java index acc5bfe51a..e66b8b36d6 100644 --- a/uitest/src/com/vaadin/tests/components/grid/basicfeatures/server/GridSortingTest.java +++ b/uitest/src/com/vaadin/tests/components/grid/basicfeatures/server/GridSortingTest.java @@ -18,25 +18,53 @@ package com.vaadin.tests.components.grid.basicfeatures.server; 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) @@ -44,42 +72,33 @@ public class GridSortingTest extends GridBasicFeaturesTest { // 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); } @@ -87,24 +106,22 @@ public class GridSortingTest extends GridBasicFeaturesTest { // 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(); @@ -115,7 +132,10 @@ public class GridSortingTest extends GridBasicFeaturesTest { // 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"; @@ -124,28 +144,18 @@ public class GridSortingTest extends GridBasicFeaturesTest { "(" + 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); } @@ -153,7 +163,10 @@ public class GridSortingTest extends GridBasicFeaturesTest { // 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", @@ -161,10 +174,6 @@ public class GridSortingTest extends GridBasicFeaturesTest { 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 @@ -191,7 +200,7 @@ public class GridSortingTest extends GridBasicFeaturesTest { } - private void sendKeys(CharSequence... seq) { + private void sendKey(Keys seq) { new Actions(getDriver()).sendKeys(seq).perform(); } @@ -203,68 +212,135 @@ public class GridSortingTest extends GridBasicFeaturesTest { 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 + * null 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) { -- 2.39.5