Java tutorial
/* * 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.tests.tb3; import java.io.IOException; import java.io.InputStream; import java.io.StringWriter; import java.lang.reflect.Field; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.logging.Level; import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.StringUtils; import org.apache.http.HttpHost; import org.apache.http.HttpResponse; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicHttpEntityEnclosingRequest; import org.junit.Assert; import org.junit.Rule; import org.junit.rules.TestName; import org.junit.runner.RunWith; import org.openqa.selenium.By; import org.openqa.selenium.Dimension; import org.openqa.selenium.JavascriptExecutor; import org.openqa.selenium.NoSuchElementException; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.interactions.Actions; import org.openqa.selenium.interactions.HasInputDevices; import org.openqa.selenium.interactions.Keyboard; import org.openqa.selenium.interactions.Mouse; import org.openqa.selenium.interactions.internal.Coordinates; import org.openqa.selenium.internal.Locatable; import org.openqa.selenium.internal.WrapsElement; import org.openqa.selenium.remote.DesiredCapabilities; import org.openqa.selenium.remote.HttpCommandExecutor; import org.openqa.selenium.remote.RemoteWebDriver; import org.openqa.selenium.support.ui.ExpectedCondition; import org.openqa.selenium.support.ui.ExpectedConditions; import org.openqa.selenium.support.ui.WebDriverWait; import com.vaadin.server.LegacyApplication; import com.vaadin.server.UIProvider; import com.vaadin.testbench.TestBenchDriverProxy; import com.vaadin.testbench.TestBenchElement; import com.vaadin.testbench.annotations.BrowserConfiguration; import com.vaadin.testbench.elements.CheckBoxElement; import com.vaadin.testbench.elements.LabelElement; import com.vaadin.testbench.elements.TableElement; import com.vaadin.testbench.elements.VerticalLayoutElement; import com.vaadin.testbench.parallel.Browser; import com.vaadin.testbench.parallel.BrowserUtil; import com.vaadin.testbench.parallel.ParallelTest; import com.vaadin.ui.UI; import elemental.json.JsonObject; import elemental.json.impl.JsonUtil; /** * Base class for TestBench 3+ tests. All TB3+ tests in the project should * extend this class. * * Provides: * <ul> * <li>Helpers for browser selection</li> * <li>Hub connection setup and teardown</li> * <li>Automatic generation of URL for a given test on the development server * using {@link #getUIClass()} or by automatically finding an enclosing UI class * and based on requested features, e.g. {@link #isDebug()}, * {@link #isPush()}</li> * <li>Generic helpers for creating TB3+ tests</li> * </ul> * * @author Vaadin Ltd */ @RunWith(TB3Runner.class) public abstract class AbstractTB3Test extends ParallelTest { @Rule public TestName testName = new TestName(); @Rule public RetryOnFail retry = new RetryOnFail(); /** * Height of the screenshots we want to capture */ private static final int SCREENSHOT_HEIGHT = 850; /** * Width of the screenshots we want to capture */ private static final int SCREENSHOT_WIDTH = 1500; /** * Timeout used by the TB grid */ private static final int BROWSER_TIMEOUT_IN_MS = 30 * 1000; protected static DesiredCapabilities PHANTOMJS2() { DesiredCapabilities phantomjs2 = new VaadinBrowserFactory().create(Browser.PHANTOMJS, "2"); // Hack for the test cluster phantomjs2.setCapability("phantomjs.binary.path", "/usr/bin/phantomjs2"); return phantomjs2; } private boolean debug = false; private boolean push = false; static { com.vaadin.testbench.Parameters.setScreenshotComparisonCursorDetection(true); } /** * Connect to the hub using a remote web driver, set the canvas size and * opens the initial URL as specified by {@link #getTestUrl()} * * @throws Exception */ @Override public void setup() throws Exception { super.setup(); int w = SCREENSHOT_WIDTH; int h = SCREENSHOT_HEIGHT; try { testBench().resizeViewPortTo(w, h); } catch (UnsupportedOperationException e) { // Opera does not support this... } } /** * Method for closing the tested application. */ protected void closeApplication() { if (driver != null) { try { openTestURL("closeApplication"); } catch (Exception e) { e.printStackTrace(); } } } protected WebElement getTooltipErrorElement() { WebElement tooltip = getDriver().findElement(com.vaadin.testbench.By.className("v-tooltip")); return tooltip.findElement(By.className("v-errormessage")); } protected WebElement getTooltipElement() { return getDriver().findElement(com.vaadin.testbench.By.className("v-tooltip-text")); } protected Coordinates getCoordinates(TestBenchElement element) { return ((Locatable) element.getWrappedElement()).getCoordinates(); } private boolean hasDebugMessage(String message) { return getDebugMessage(message) != null; } private WebElement getDebugMessage(String message) { return driver.findElement( By.xpath(String.format("//span[@class='v-debugwindow-message' and text()='%s']", message))); } protected void waitForDebugMessage(final String expectedMessage) { waitForDebugMessage(expectedMessage, 30); } protected void waitForDebugMessage(final String expectedMessage, int timeout) { waitUntil(new ExpectedCondition<Boolean>() { @Override public Boolean apply(WebDriver input) { return hasDebugMessage(expectedMessage); } }, timeout); } protected void clearDebugMessages() { driver.findElement(By.xpath("//button[@class='v-debugwindow-button' and @title='Clear log']")).click(); } protected void waitUntilRowIsVisible(final TableElement table, final int row) { waitUntil(new ExpectedCondition<Object>() { @Override public Object apply(WebDriver input) { try { return table.getCell(row, 0) != null; } catch (NoSuchElementException e) { return false; } } }); } protected void scrollTable(TableElement table, int rows, int rowToWait) { testBenchElement(table.findElement(By.className("v-scrollable"))).scroll(rows * 30); waitUntilRowIsVisible(table, rowToWait); } /** * Opens the given test (defined by {@link #getTestUrl()}, optionally with * debug window and/or push (depending on {@link #isDebug()} and * {@link #isPush()}. */ protected void openTestURL() { openTestURL(new String[0]); } /** * Opens the given test (defined by {@link #getTestUrl()}, optionally with * debug window and/or push (depending on {@link #isDebug()} and * {@link #isPush()}. */ protected void openTestURL(String... parameters) { openTestURL(getUIClass(), parameters); } /** * Opens the given test (defined by {@link #getTestUrl()}, optionally with * debug window and/or push (depending on {@link #isDebug()} and * {@link #isPush()}. */ protected void openTestURL(Class<?> uiClass, String... parameters) { openTestURL(uiClass, new HashSet<>(Arrays.asList(parameters))); } private void openTestURL(Class<?> uiClass, Set<String> parameters) { String url = getTestURL(uiClass); if (isDebug()) { parameters.add("debug"); } if (LegacyApplication.class.isAssignableFrom(uiClass)) { parameters.add("restartApplication"); } if (parameters.size() > 0) { url += "?" + StringUtils.join(parameters, "&"); } driver.get(url); } /** * Returns the full URL to be used for the test * * @return the full URL for the test */ protected String getTestUrl() { return StringUtils.strip(getBaseURL(), "/") + getDeploymentPath(); } /** * Returns the full URL to be used for the test for the provided UI class. * * @return the full URL for the test */ protected String getTestURL(Class<?> uiClass) { return StringUtils.strip(getBaseURL(), "/") + getDeploymentPath(uiClass); } /** * Used to determine what URL to initially open for the test * * @return the host name of development server */ protected abstract String getDeploymentHostname(); /** * Used to determine what port the test is running on * * @return The port teh test is running on, by default 8888 */ protected abstract int getDeploymentPort(); /** * Produces a collection of browsers to run the test on. This method is * executed by the test runner when determining how many test methods to * invoke and with what parameters. For each returned value a test method is * ran and before running that, * {@link #setDesiredCapabilities(DesiredCapabilities)} is invoked with the * value returned by this method. * * This method is not static to allow overriding it in sub classes. By * default runs the test only on Firefox * * @return The browsers to run the test on */ @BrowserConfiguration public List<DesiredCapabilities> getBrowsersToTest() { return Collections.singletonList(Browser.FIREFOX.getDesiredCapabilities()); } /** * Finds an element based on the part of a TB2 style locator following the * :: (e.g. vaadin=runLabelModes::PID_Scheckboxaction-Enabled/domChild[0] -> * PID_Scheckboxaction-Enabled/domChild[0]). * * @param vaadinLocator * The part following :: of the vaadin locator string * @return */ protected WebElement vaadinElement(String vaadinLocator) { return driver.findElement(vaadinLocator(vaadinLocator)); } /** * Uses JavaScript to determine the currently focused element. * * @return Focused element or null */ protected WebElement getFocusedElement() { Object focusedElement = executeScript("return document.activeElement"); if (null != focusedElement) { return (WebElement) focusedElement; } else { return null; } } /** * Executes the given Javascript * * @param script * the script to execute * @return whatever * {@link org.openqa.selenium.JavascriptExecutor#executeScript(String, Object...)} * returns */ protected Object executeScript(String script, Object... args) { return ((JavascriptExecutor) getDriver()).executeScript(script, args); } /** * Find a Vaadin element based on its id given using Component.setId * * @param id * The id to locate * @return */ public WebElement vaadinElementById(String id) { return driver.findElement(By.id(id)); } /** * Finds a {@link By} locator based on the part of a TB2 style locator * following the :: (e.g. * vaadin=runLabelModes::PID_Scheckboxaction-Enabled/domChild[0] -> * PID_Scheckboxaction-Enabled/domChild[0]). * * @param vaadinLocator * The part following :: of the vaadin locator string * @return */ public org.openqa.selenium.By vaadinLocator(String vaadinLocator) { String base = getApplicationId(getDeploymentPath()); base += "::"; return com.vaadin.testbench.By.vaadin(base + vaadinLocator); } /** * Constructs a {@link By} locator for the id given using Component.setId * * @param id * The id to locate * @return a locator for the given id */ public By vaadinLocatorById(String id) { return vaadinLocator("PID_S" + id); } /** * Waits up to 10s for the given condition to become true. Use e.g. as * {@link #waitUntil(ExpectedConditions.textToBePresentInElement(by, text))} * * @param condition * the condition to wait for to become true */ protected <T> void waitUntil(ExpectedCondition<T> condition) { waitUntil(condition, 10); } /** * Waits the given number of seconds for the given condition to become true. * Use e.g. as * {@link #waitUntil(ExpectedConditions.textToBePresentInElement(by, text))} * * @param condition * the condition to wait for to become true */ protected <T> void waitUntil(ExpectedCondition<T> condition, long timeoutInSeconds) { new WebDriverWait(driver, timeoutInSeconds).until(condition); } /** * Waits up to 10s for the given condition to become false. Use e.g. as * {@link #waitUntilNot(ExpectedConditions.textToBePresentInElement(by, * text))} * * @param condition * the condition to wait for to become false */ protected <T> void waitUntilNot(ExpectedCondition<T> condition) { waitUntilNot(condition, 10); } /** * Waits the given number of seconds for the given condition to become * false. Use e.g. as * {@link #waitUntilNot(ExpectedConditions.textToBePresentInElement(by, * text))} * * @param condition * the condition to wait for to become false */ protected <T> void waitUntilNot(ExpectedCondition<T> condition, long timeoutInSeconds) { waitUntil(ExpectedConditions.not(condition), timeoutInSeconds); } protected void waitForElementPresent(final By by) { waitUntil(ExpectedConditions.presenceOfElementLocated(by)); } protected void waitForElementNotPresent(final By by) { waitUntil(new ExpectedCondition<Boolean>() { @Override public Boolean apply(WebDriver input) { return input.findElements(by).isEmpty(); } }); } protected void waitForElementVisible(final By by) { waitUntil(ExpectedConditions.visibilityOfElementLocated(by)); } /** * Checks if the given element has the given class name. * * Matches only full class names, i.e. has ("foo") does not match * class="foobar" * * @param element * @param className * @return */ protected boolean hasCssClass(WebElement element, String className) { String classes = element.getAttribute("class"); if (classes == null || classes.isEmpty()) { return (className == null || className.isEmpty()); } for (String cls : classes.split(" ")) { if (className.equals(cls)) { return true; } } return false; } /** * For tests extending AbstractTestUIWithLog, returns the element for the * Nth log row * * @param rowNr * The log row to retrieve * @return the Nth log row */ protected WebElement getLogRowElement(int rowNr) { return vaadinElementById("Log_row_" + rowNr); } /** * For tests extending AbstractTestUIWithLog, returns the text in the Nth * log row * * @param rowNr * The log row to retrieve text for * @return the text in the log row */ protected String getLogRow(int rowNr) { return getLogRowElement(rowNr).getText(); } /** * Asserts that {@literal a} is >= {@literal b} * * @param message * The message to include in the {@link AssertionError} * @param a * @param b * @throws AssertionError * If comparison fails */ public static final <T> void assertGreaterOrEqual(String message, Comparable<T> a, T b) throws AssertionError { if (a.compareTo(b) >= 0) { return; } throw new AssertionError(decorate(message, a, b)); } /** * Asserts that {@literal a} is > {@literal b} * * @param message * The message to include in the {@link AssertionError} * @param a * @param b * @throws AssertionError * If comparison fails */ public static final <T> void assertGreater(String message, Comparable<T> a, T b) throws AssertionError { if (a.compareTo(b) > 0) { return; } throw new AssertionError(decorate(message, a, b)); } /** * Asserts that {@literal a} is <= {@literal b} * * @param message * The message to include in the {@link AssertionError} * @param a * @param b * @throws AssertionError * If comparison fails */ public static final <T> void assertLessThanOrEqual(String message, Comparable<T> a, T b) throws AssertionError { if (a.compareTo(b) <= 0) { return; } throw new AssertionError(decorate(message, a, b)); } /** * Asserts that {@literal a} is < {@literal b} * * @param message * The message to include in the {@link AssertionError} * @param a * @param b * @throws AssertionError * If comparison fails */ public static final <T> void assertLessThan(String message, Comparable<T> a, T b) throws AssertionError { if (a.compareTo(b) < 0) { return; } throw new AssertionError(decorate(message, a, b)); } private static <T> String decorate(String message, Comparable<T> a, T b) { message = message.replace("{0}", a.toString()); message = message.replace("{1}", b.toString()); return message; } /** * Returns the path that should be used for the test. The path contains the * full path (appended to hostname+port) and must start with a slash. * * @param push * true if "?debug" should be added * @param debug * true if /run-push should be used instead of /run * * @return The URL path to the UI class to test */ protected String getDeploymentPath() { Class<?> uiClass = getUIClass(); if (uiClass != null) { return getDeploymentPath(uiClass); } throw new IllegalArgumentException("Unable to determine path for " + getClass().getCanonicalName()); } /** * Returns the UI class the current test is connected to (or in special * cases UIProvider or LegacyApplication). Uses the enclosing class if the * test class is a static inner class to a UI class. * * Test which are not enclosed by a UI class must implement this method and * return the UI class they want to test. * * Note that this method will update the test name to the enclosing class to * be compatible with TB2 screenshot naming * * @return the UI class the current test is connected to */ protected Class<?> getUIClass() { try { // Convention: SomeUITest uses the SomeUI UI class String uiClassName = getClass().getName().replaceFirst("Test$", ""); Class<?> cls = Class.forName(uiClassName); if (isSupportedRunnerClass(cls)) { return cls; } } catch (Exception e) { } throw new RuntimeException( "Could not determine UI class. Ensure the test is named UIClassTest and is in the same package as the UIClass"); } /** * @return true if the given class is supported by ApplicationServletRunner */ @SuppressWarnings("deprecation") private boolean isSupportedRunnerClass(Class<?> cls) { if (UI.class.isAssignableFrom(cls)) { return true; } if (UIProvider.class.isAssignableFrom(cls)) { return true; } if (LegacyApplication.class.isAssignableFrom(cls)) { return true; } return false; } /** * Returns whether to run the test in debug mode (with the debug console * open) or not * * @return true to run with the debug window open, false by default */ protected final boolean isDebug() { return debug; } /** * Sets whether to run the test in debug mode (with the debug console open) * or not. * * @param debug * true to open debug window, false otherwise */ protected final void setDebug(boolean debug) { this.debug = debug; } /** * Returns whether to run the test with push enabled (using /run-push) or * not. Note that push tests can and should typically be created using @Push * on the UI instead of overriding this method * * @return true if /run-push is used, false otherwise */ protected final boolean isPush() { return push; } /** * Sets whether to run the test with push enabled (using /run-push) or not. * Note that push tests can and should typically be created using @Push on * the UI instead of overriding this method * * @param push * true to use /run-push in the test, false otherwise */ protected final void setPush(boolean push) { this.push = push; } /** * Returns the path for the given UI class when deployed on the test server. * The path contains the full path (appended to hostname+port) and must * start with a slash. * * This method takes into account {@link #isPush()} and {@link #isDebug()} * when the path is generated. * * @param uiClass * @param push * true if "?debug" should be added * @param debug * true if /run-push should be used instead of /run * @return The path to the given UI class */ protected String getDeploymentPath(Class<?> uiClass) { String runPath = "/run"; if (isPush()) { runPath = "/run-push"; } if (UI.class.isAssignableFrom(uiClass) || UIProvider.class.isAssignableFrom(uiClass) || LegacyApplication.class.isAssignableFrom(uiClass)) { return runPath + "/" + uiClass.getCanonicalName(); } else { throw new IllegalArgumentException( "Unable to determine path for enclosing class " + uiClass.getCanonicalName()); } } /** * Used to determine what URL to initially open for the test * * @return The base URL for the test. Does not include a trailing slash. */ protected String getBaseURL() { return "http://" + getDeploymentHostname() + ":" + getDeploymentPort(); } /** * Generates the application id based on the URL in a way compatible with * VaadinServletService. * * @param pathWithQueryParameters * The path part of the URL, possibly still containing query * parameters * @return The application ID string used in Vaadin locators */ private String getApplicationId(String pathWithQueryParameters) { // Remove any possible URL parameters String pathWithoutQueryParameters = pathWithQueryParameters.replaceAll("\\?.*", ""); if ("".equals(pathWithoutQueryParameters)) { return "ROOT"; } // Retain only a-z and numbers return pathWithoutQueryParameters.replaceAll("[^a-zA-Z0-9]", ""); } /** * Sleeps for the given number of ms but ensures that the browser connection * does not time out. * * @param timeoutMillis * Number of ms to wait */ protected void sleep(int timeoutMillis) { while (timeoutMillis > 0) { int d = Math.min(BROWSER_TIMEOUT_IN_MS, timeoutMillis); try { Thread.sleep(d); } catch (InterruptedException e) { throw new RuntimeException(e); } timeoutMillis -= d; // Do something to keep the connection alive getDriver().getTitle(); } } /** * Called by the test runner whenever there is an exception in the test that * will cause termination of the test * * @param t * the throwable which caused the termination */ public void onUncaughtException(Throwable t) { // Do nothing by default } /** * Returns the mouse object for doing mouse commands * * @return Returns the mouse */ public Mouse getMouse() { return ((HasInputDevices) getDriver()).getMouse(); } /** * Returns the keyboard object for controlling keyboard events * * @return Return the keyboard */ public Keyboard getKeyboard() { return ((HasInputDevices) getDriver()).getKeyboard(); } public void hitButton(String id) { driver.findElement(By.id(id)).click(); } protected void openDebugLogTab() { waitUntil(new ExpectedCondition<Boolean>() { @Override public Boolean apply(WebDriver input) { WebElement element = getDebugLogButton(); return element != null; } }, 15); getDebugLogButton().click(); } private WebElement getDebugLogButton() { return findElement(By.xpath("//button[@title='Debug message log']")); } protected void assertNoDebugMessage(Level level) { // class="v-debugwindow-row Level.getName()" List<WebElement> logElements = driver.findElements(By.xpath(String.format( "//div[@class='v-debugwindow-row %s']/span[@class='v-debugwindow-message']", level.getName()))); if (!logElements.isEmpty()) { String logRows = ""; for (WebElement e : logElements) { logRows += "\n" + e.getText(); } Assert.fail("Found debug messages with level " + level.getName() + ": " + logRows); } } /** * Should the "require window focus" be enabled for Internet Explorer. * RequireWindowFocus makes tests more stable but seems to be broken with * certain commands such as sendKeys. Therefore it is not enabled by default * for all tests * * @return true, to use the "require window focus" feature, false otherwise */ protected boolean requireWindowFocusForIE() { return false; } /** * Should the "enable persistent hover" be enabled for Internet Explorer. * * Persistent hovering causes continuous firing of mouse over events at the * last location the mouse cursor has been moved to. This is to avoid * problems where the real mouse cursor is inside the browser window and * Internet Explorer uses that location for some undefined operation * (http:// * jimevansmusic.blogspot.fi/2012/06/whats-wrong-with-internet-explorer * .html) * * @return true, to use the "persistent hover" feature, false otherwise */ protected boolean usePersistentHoverForIE() { return true; } /** * Should the "native events" be enabled for Internet Explorer. * <p> * Native events sometimes cause failure in clicking on buttons/checkboxes * but are possibly needed for some operations. * * @return true, to use "native events", false to use generated Javascript * events */ protected boolean useNativeEventsForIE() { return true; } // FIXME: Remove this once TB4 getRemoteControlName works properly private RemoteWebDriver getRemoteDriver() { WebDriver d = getDriver(); if (d instanceof TestBenchDriverProxy) { try { Field f = TestBenchDriverProxy.class.getDeclaredField("actualDriver"); f.setAccessible(true); return (RemoteWebDriver) f.get(d); } catch (Exception e) { e.printStackTrace(); } } if (d instanceof RemoteWebDriver) { return (RemoteWebDriver) d; } return null; } // FIXME: Remove this once TB4 getRemoteControlName works properly protected String getRemoteControlName() { try { RemoteWebDriver d = getRemoteDriver(); if (d == null) { return null; } HttpCommandExecutor ce = (HttpCommandExecutor) d.getCommandExecutor(); String hostName = ce.getAddressOfRemoteServer().getHost(); int port = ce.getAddressOfRemoteServer().getPort(); HttpHost host = new HttpHost(hostName, port); DefaultHttpClient client = new DefaultHttpClient(); URL sessionURL = new URL( "http://" + hostName + ":" + port + "/grid/api/testsession?session=" + d.getSessionId()); BasicHttpEntityEnclosingRequest r = new BasicHttpEntityEnclosingRequest("POST", sessionURL.toExternalForm()); HttpResponse response = client.execute(host, r); JsonObject object = extractObject(response); URL myURL = new URL(object.getString("proxyId")); if ((myURL.getHost() != null) && (myURL.getPort() != -1)) { return myURL.getHost(); } } catch (Exception e) { e.printStackTrace(); } return null; } protected boolean logContainsText(String string) { List<String> logs = getLogs(); for (String text : logs) { if (text.contains(string)) { return true; } } return false; } protected List<String> getLogs() { VerticalLayoutElement log = $(VerticalLayoutElement.class).id("Log"); List<LabelElement> logLabels = log.$(LabelElement.class).all(); List<String> logTexts = new ArrayList<>(); for (LabelElement label : logLabels) { logTexts.add(label.getText()); } return logTexts; } private static JsonObject extractObject(HttpResponse resp) throws IOException { InputStream contents = resp.getEntity().getContent(); StringWriter writer = new StringWriter(); IOUtils.copy(contents, writer, "UTF8"); return JsonUtil.parse(writer.toString()); } protected void click(CheckBoxElement checkbox) { WebElement cb = checkbox.findElement(By.xpath("input")); if (BrowserUtil.isChrome(getDesiredCapabilities())) { testBenchElement(cb).click(0, 0); } else if (BrowserUtil.isFirefox(getDesiredCapabilities())) { // Firefox workaround getCommandExecutor().executeScript("arguments[0].click()", cb); } else { cb.click(); } } protected void clickElement(WebElement element) { if (BrowserUtil.isFirefox(getDesiredCapabilities())) { // Workaround for Selenium/TB and Firefox 45 issue ((TestBenchElement) (element)).clickHiddenElement(); } else { element.click(); } } protected void contextClickElement(WebElement element) { if (BrowserUtil.isFirefox(getDesiredCapabilities())) { // Workaround for Selenium/TB and Firefox 45 issue getCommandExecutor().executeScript( "var ev = document.createEvent('HTMLEvents'); ev.initEvent('contextmenu', true, false); arguments[0].dispatchEvent(ev);", element); } else { new Actions(getDriver()).contextClick(element).perform(); } } protected boolean isLoadingIndicatorVisible() { WebElement loadingIndicator = findElement(By.className("v-loading-indicator")); return loadingIndicator.isDisplayed(); } protected void waitUntilLoadingIndicatorVisible() { waitUntil(input -> isLoadingIndicatorVisible()); } protected void waitUntilLoadingIndicatorNotVisible() { waitUntil(input -> !isLoadingIndicatorVisible()); } /** * Selects a menu item. By default, this will click on the menu item. * * @param menuCaption * caption of the menu item */ protected void selectMenu(String menuCaption) { selectMenu(menuCaption, true); } /** * Selects a menu item. * * @param menuCaption * caption of the menu item * @param click * <code>true</code> if should click the menu item; * <code>false</code> if not */ protected void selectMenu(String menuCaption, boolean click) { WebElement menuElement = getMenuElement(menuCaption); Dimension size = menuElement.getSize(); new Actions(getDriver()).moveToElement(menuElement, size.width - 10, size.height / 2).perform(); if (click) { new Actions(getDriver()).click().perform(); } } /** * Finds the menu item from the DOM based on menu item caption. * * @param menuCaption * caption of the menu item * @return the found menu item * @throws NoSuchElementException * if menu item is not found */ protected WebElement getMenuElement(String menuCaption) throws NoSuchElementException { return getDriver().findElement(By.xpath("//span[text() = '" + menuCaption + "']")); } /** * Selects a submenu described by a path of menus from the first MenuBar in * the UI. * * @param menuCaptions * array of menu captions */ protected void selectMenuPath(String... menuCaptions) { selectMenu(menuCaptions[0], true); // Move to the menu item opened below the menu bar. new Actions(getDriver()).moveByOffset(0, getMenuElement(menuCaptions[0]).getSize().getHeight()).perform(); for (int i = 1; i < menuCaptions.length - 1; i++) { selectMenu(menuCaptions[i]); new Actions(getDriver()).moveByOffset(40, 0).build().perform(); } selectMenu(menuCaptions[menuCaptions.length - 1], true); } /** * Asserts that an element is present * * @param by * the locatore for the element */ protected void assertElementPresent(By by) { Assert.assertTrue("Element is not present", isElementPresent(by)); } /** * Asserts that an element is not present * * @param by * the locatore for the element */ protected void assertElementNotPresent(By by) { Assert.assertFalse("Element is present", isElementPresent(by)); } /** * Asserts that no error notifications are shown. Requires the use of * "?debug" as exceptions are otherwise not shown as notifications. */ protected void assertNoErrorNotifications() { Assert.assertFalse("Error notification with client side exception is shown", isNotificationPresent("error")); } /** * Asserts that no system notifications are shown. */ protected void assertNoSystemNotifications() { Assert.assertFalse("Error notification with system error exception is shown", isNotificationPresent("system")); } /** * Asserts that a system notification is shown. */ protected void assertSystemNotification() { Assert.assertTrue("Error notification with system error exception is not shown", isNotificationPresent("system")); } private boolean isNotificationPresent(String type) { if ("error".equals(type)) { Assert.assertTrue("Debug window must be open to be able to see error notifications", isDebugWindowOpen()); } return isElementPresent(By.className("v-Notification-" + type)); } private boolean isDebugWindowOpen() { return isElementPresent(By.className("v-debugwindow")); } protected void assertNoHorizontalScrollbar(WebElement element, String errorMessage) { // IE rounds clientWidth/clientHeight down and scrollHeight/scrollWidth // up, so using clientWidth/clientHeight will fail if the element height // is not an integer int clientWidth = getClientWidth(element); int scrollWidth = getScrollWidth(element); boolean hasScrollbar = scrollWidth > clientWidth; Assert.assertFalse("The element should not have a horizontal scrollbar (scrollWidth: " + scrollWidth + ", clientWidth: " + clientWidth + "): " + errorMessage, hasScrollbar); } protected void assertNoVerticalScrollbar(WebElement element, String errorMessage) { // IE rounds clientWidth/clientHeight down and scrollHeight/scrollWidth // up, so using clientWidth/clientHeight will fail if the element height // is not an integer int clientHeight = getClientHeight(element); int scrollHeight = getScrollHeight(element); boolean hasScrollbar = scrollHeight > clientHeight; Assert.assertFalse("The element should not have a vertical scrollbar (scrollHeight: " + scrollHeight + ", clientHeight: " + clientHeight + "): " + errorMessage, hasScrollbar); } protected int getScrollHeight(WebElement element) { return ((Number) executeScript("return arguments[0].scrollHeight;", element)).intValue(); } protected int getScrollWidth(WebElement element) { return ((Number) executeScript("return arguments[0].scrollWidth;", element)).intValue(); } /** * Returns client height rounded up instead of as double because of IE9 * issues: https://dev.vaadin.com/ticket/18469 */ protected int getClientHeight(WebElement e) { String script = "var cs = window.getComputedStyle(arguments[0]);" + "return Math.ceil(parseFloat(cs.height)+parseFloat(cs.paddingTop)+parseFloat(cs.paddingBottom));"; return ((Number) executeScript(script, e)).intValue(); } /** * Returns client width rounded up instead of as double because of IE9 * issues: https://dev.vaadin.com/ticket/18469 */ protected int getClientWidth(WebElement e) { String script = "var cs = window.getComputedStyle(arguments[0]);" + "var h = parseFloat(cs.width)+parseFloat(cs.paddingLeft)+parseFloat(cs.paddingRight);" + "return Math.ceil(h);"; return ((Number) executeScript(script, e)).intValue(); } protected void assertElementsEquals(WebElement expectedElement, WebElement actualElement) { while (expectedElement instanceof WrapsElement) { expectedElement = ((WrapsElement) expectedElement).getWrappedElement(); } while (actualElement instanceof WrapsElement) { actualElement = ((WrapsElement) actualElement).getWrappedElement(); } Assert.assertEquals(expectedElement, actualElement); } protected WebElement getActiveElement() { return (WebElement) executeScript("return document.activeElement;"); } protected void waitForThemeToChange(final String theme) { final WebElement rootDiv = findElement(By.xpath("//div[contains(@class,'v-app')]")); waitUntil(new ExpectedCondition<Boolean>() { @Override public Boolean apply(WebDriver input) { String rootClass = rootDiv.getAttribute("class").trim(); return rootClass.contains(theme); } }, 30); } }