added exception wait time out in config file to handle tolerant methods (#43)

* added exception wait time out to handle tolerant methods

* applied the changes as mentioned in the review comments for tolerant methods

* Changed the method to package private to not expose this method

* Added test to validate the tolerant method without passing wait time for method

* changed the variable names for the TolerantAction object as mentioned

Author: balu836

src/main/java/uk/co/evoco/webdriver/configuration/TolerantActionExceptions.java

@@ -0,0 +1,46 @@
+package uk.co.evoco.webdriver.configuration;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.List;
+
+public class TolerantActionExceptions {
+
+    private String waitTimeoutInSeconds;
+    private List<String> exceptionsToHandle;
+
+    /**
+     *
+     * @return the tolerant action wait time in seconds
+     */
+    String getWaitTimeoutInSeconds() {
+        return waitTimeoutInSeconds;
+    }
+
+    /**
+     *
+     * @param waitTimeoutInSeconds set the tolerant action wait time in seconds
+     */
+    @JsonProperty("waitTimeoutInSeconds")
+    public void setWaitTimeoutInSeconds(String waitTimeoutInSeconds) {
+        this.waitTimeoutInSeconds = waitTimeoutInSeconds;
+    }
+
+    /**
+     *
+     * @return Exceptions list that we will use to tolerate in tolerable action wrappers
+     */
+    public List<String> getExceptionsToHandle() {
+        return exceptionsToHandle;
+    }
+
+    /**
+     *
+     * @param exceptionsToHandle sets the list of exceptions for WebDriver that we will retry
+     *                                            on when using our tolerant wrapper
+     */
+    @JsonProperty("exceptionsToHandle")
+    public void setExceptionsToHandle(List<String> exceptionsToHandle) {
+        this.exceptionsToHandle = exceptionsToHandle;
+    }
+}

src/main/java/uk/co/evoco/webdriver/configuration/WebDriverConfig.java

@@ -7,7 +7,6 @@
 
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
@@ -23,8 +22,8 @@ public class WebDriverConfig {
     private JsonNode testConfig;
     private GridConfig gridConfig;
     private RunType runType;
-    private List<String> exceptionsToHandleOnTolerantActions;
     private Map<String, ObjectNode> browserPreferences;
+    private TolerantActionExceptions tolerantActionExceptions;
 
     /**
      *
@@ -185,19 +184,30 @@ public void setRunType(String runType) {
 
     /**
      *
-     * @return Exceptions list that we will use to tolerate in tolerable action wrappers
+     * @return the tolerant action exceptions config
      */
-    public List<String> getExceptionsToHandleOnTolerantActions() {
-        return exceptionsToHandleOnTolerantActions;
+
+    public TolerantActionExceptions getTolerantActionExceptions() {
+        return tolerantActionExceptions;
+    }
+
+    /**
+     *
+     * @param tolerantActionExceptions set the tolerant action exceptions and tolerant action wait time in Seconds
+     */
+    @JsonProperty("tolerantActionExceptions")
+    public void setTolerantActionExceptions(TolerantActionExceptions tolerantActionExceptions) {
+        this.tolerantActionExceptions = tolerantActionExceptions;
     }
 
     /**
      *
-     * @param exceptionsToHandleOnTolerantActions sets the list of exceptions for WebDriver that we will retry
-     *                                            on when using our tolerant wrapper
+     * @return tolerant action wait time in seconds if user specify the time in config file
+     * other wise return default webdriver time out
      */
-    @JsonProperty("exceptionsToHandleOnTolerantActions")
-    public void setExceptionsToHandleOnTolerantActions(List<String> exceptionsToHandleOnTolerantActions) {
-        this.exceptionsToHandleOnTolerantActions = exceptionsToHandleOnTolerantActions;
+    public int getTolerantActionWaitTimeoutInSeconds() {
+        return Optional.ofNullable(tolerantActionExceptions.getWaitTimeoutInSeconds())
+                .map(Integer::parseInt)
+                .orElse((int) webDriverWaitTimeout);
     }
 }

src/main/java/uk/co/evoco/webdriver/utils/ClickUtils.java

@@ -1,6 +1,7 @@
 package uk.co.evoco.webdriver.utils;
 
 import org.openqa.selenium.WebElement;
+import uk.co.evoco.webdriver.configuration.TestConfigManager;
 
 import java.util.Optional;
 
@@ -19,4 +20,9 @@ public final class ClickUtils extends TolerantInteraction {
     public static void tolerantClick(WebElement webElement, int timeout) throws Throwable {
         new SendKeysUtils().tolerantInteraction(webElement, Optional.empty(), timeout);
     }
+
+    public static void tolerantClick(WebElement webElement) throws Throwable {
+        new SendKeysUtils().tolerantInteraction(webElement, Optional.empty(),
+                TestConfigManager.get().getTolerantActionWaitTimeoutInSeconds());
+    }
 }

src/main/java/uk/co/evoco/webdriver/utils/RadioButtonUtils.java

@@ -1,6 +1,7 @@
 package uk.co.evoco.webdriver.utils;
 
 import org.openqa.selenium.WebElement;
+import uk.co.evoco.webdriver.configuration.TestConfigManager;
 
 import java.util.List;
 
@@ -12,7 +13,8 @@ public final class RadioButtonUtils extends TolerantInteraction {
     /**
      * Given a list of WebElements that locate the labels of the radio buttons,
      * finds the radio button with the given visible label text and selects it.
-     * @param webElements active WebElements, already located
+     *
+     * @param webElements      active WebElements, already located
      * @param visibleLabelText text that is visible on the page in the label tags
      */
     public static void selectByLabel(List<WebElement> webElements, String visibleLabelText) {
@@ -25,14 +27,19 @@ public static void selectByLabel(List<WebElement> webElements, String visibleLab
     }
 
     /**
-     *
-     * @param webElements active WebElements, already located
+     * @param webElements      active WebElements, already located
      * @param visibleLabelText text that is visible on the page in the label tags
-     * @param timeout time in seconds to keep trying
+     * @param timeout          time in seconds to keep trying
      * @throws Throwable any unhandled or un-tolerated exception
      */
     public static void tolerantSelectByLabel(List<WebElement> webElements, String visibleLabelText, int timeout)
             throws Throwable {
         new RadioButtonUtils().tolerantInteraction(webElements, visibleLabelText, timeout);
     }
+
+    public static void tolerantSelectByLabel(List<WebElement> webElements, String visibleLabelText)
+            throws Throwable {
+        new RadioButtonUtils().tolerantInteraction(webElements, visibleLabelText,
+                TestConfigManager.get().getTolerantActionWaitTimeoutInSeconds());
+    }
 }

src/main/java/uk/co/evoco/webdriver/utils/SelectBoxUtils.java

@@ -2,6 +2,7 @@
 
 import org.openqa.selenium.WebElement;
 import org.openqa.selenium.support.ui.Select;
+import uk.co.evoco.webdriver.configuration.TestConfigManager;
 
 import java.util.Optional;
 
@@ -14,6 +15,7 @@ public final class SelectBoxUtils extends TolerantInteraction {
 
     /**
      * Selects an option that has a matching value attribute in the Options tag markup
+     *
      * @param selectBox active WebElement, already located
      * @param htmlValue HTML value attribute
      */
@@ -25,8 +27,9 @@ public static void itemByHtmlValueAttribute(WebElement selectBox, String htmlVal
     /**
      * Selects an option by the index of the option in the list.
      * The input is NOT zero based, we're normalising the input internally.
+     *
      * @param selectBox active WebElement, already located
-     * @param index index in order of display
+     * @param index     index in order of display
      */
     public static void itemByIndex(WebElement selectBox, int index) {
         int normalisedIndex = index - 1;
@@ -36,7 +39,8 @@ public static void itemByIndex(WebElement selectBox, int index) {
 
     /**
      * Selects an option by the text that is visible in the select box
-     * @param selectBox active WebElement, already located
+     *
+     * @param selectBox   active WebElement, already located
      * @param visibleText visible text in the select box (NOT the HTML value attribute)
      */
     public static void itemByVisibleText(WebElement selectBox, String visibleText) {
@@ -45,42 +49,47 @@ public static void itemByVisibleText(WebElement selectBox, String visibleText) {
     }
 
     /**
-     *
      * @param webElement active WebElement, already located
-     * @param htmlValue HTML value attribute
-     * @param timeout time in seconds to keep trying
+     * @param htmlValue  HTML value attribute
+     * @param timeout    time in seconds to keep trying
      * @throws Throwable any unhandled or un-tolerated exception
      */
-    public static void tolerantItemByHtmlValueAttribute(WebElement webElement,  String htmlValue, int timeout)
+    public static void tolerantItemByHtmlValueAttribute(WebElement webElement, String htmlValue, int timeout)
             throws Throwable {
         new SendKeysUtils().tolerantInteraction(
                 webElement, SelectBoxInteractionType.BY_VALUE, Optional.of(htmlValue), Optional.empty(), timeout);
     }
 
     /**
-     *
-     * @param webElement active WebElement, already located
+     * @param webElement  active WebElement, already located
      * @param visibleText visible text in the select box (NOT the HTML value attribute)
-     * @param timeout time in seconds to keep trying
+     * @param timeout     time in seconds to keep trying
      * @throws Throwable any unhandled or un-tolerated exception
      */
-    public static void tolerantItemByVisibleText(WebElement webElement,  String visibleText, int timeout)
+    public static void tolerantItemByVisibleText(WebElement webElement, String visibleText, int timeout)
             throws Throwable {
         new SendKeysUtils().tolerantInteraction(
                 webElement, SelectBoxInteractionType.BY_VISIBLE_TEXT,
                 Optional.of(visibleText), Optional.empty(), timeout);
     }
 
     /**
-     *
      * @param webElement active WebElement, already located
-     * @param index index in order of display
-     * @param timeout time in seconds to keep trying
+     * @param index      index in order of display
+     * @param timeout    time in seconds to keep trying
      * @throws Throwable any unhandled or un-tolerated exception
      */
-    public static void tolerantItemByIndex(WebElement webElement,  int index, int timeout) throws Throwable {
+    public static void tolerantItemByIndex(WebElement webElement, int index, int timeout) throws Throwable {
         new SendKeysUtils().tolerantInteraction(
                 webElement, SelectBoxInteractionType.BY_INDEX, Optional.empty(), Optional.of(index), timeout);
     }
 
+    public static void tolerantItemByVisibleText(WebElement webElement, String visibleText)
+            throws Throwable {
+        new SendKeysUtils().tolerantInteraction(
+                webElement, SelectBoxInteractionType.BY_VISIBLE_TEXT,
+                Optional.of(visibleText), Optional.empty(),
+                TestConfigManager.get().getTolerantActionWaitTimeoutInSeconds());
+    }
+
 }

src/main/java/uk/co/evoco/webdriver/utils/SendKeysUtils.java

@@ -1,19 +1,24 @@
 package uk.co.evoco.webdriver.utils;
 
 import org.openqa.selenium.WebElement;
+import uk.co.evoco.webdriver.configuration.TestConfigManager;
 
 import java.util.Optional;
 
 public final class SendKeysUtils extends TolerantInteraction {
 
     /**
-     *
      * @param webElement active WebElement, already located
      * @param textToType text that should be typed
-     * @param timeout time in seconds to keep trying
+     * @param timeout    time in seconds to keep trying
      * @throws Throwable any unhandled or un-tolerated exception
      */
     public static void tolerantType(WebElement webElement, String textToType, int timeout) throws Throwable {
         new SendKeysUtils().tolerantInteraction(webElement, Optional.of(textToType), timeout);
     }
+
+    public static void tolerantType(WebElement webElement, String textToType) throws Throwable {
+        new SendKeysUtils().tolerantInteraction(webElement, Optional.of(textToType),
+                TestConfigManager.get().getTolerantActionWaitTimeoutInSeconds());
+    }
 }

src/main/java/uk/co/evoco/webdriver/utils/TolerantInteraction.java

@@ -190,7 +190,8 @@ private void interact(Select selectBox, int index) {
     }
 
     private Throwable propagateIfNotIgnored(Throwable e) throws Throwable {
-        for (String ignoredException : TestConfigManager.get().getExceptionsToHandleOnTolerantActions()) {
+        for (String ignoredException : TestConfigManager.get()
+                .getTolerantActionExceptions().getExceptionsToHandle()) {
             if (Class.forName(ignoredException).isInstance(e)) {
                 logger.info("Exception {} will be ignored", ignoredException);
             } else {

src/test/java/uk/co/evoco/webdriver/configuration/WebDriverConfigTests.java

@@ -91,4 +91,22 @@ public void testSettingBaseUrlWithBadUrlGivesGoodException() {
             webDriverConfig.setBaseUrl("bad-url");
         });
     }
+
+    @Test
+    public void testExceptionsWaitTimeOutReturnValue() throws IOException {
+        WebDriverConfig webDriverConfig = JsonUtils.fromFile(
+                ClassLoader.getSystemResourceAsStream("fixtures/sample-config-with-tolerant-action-wait-time.json")
+                , WebDriverConfig.class);
+        assertThat(webDriverConfig.getTolerantActionWaitTimeoutInSeconds(), is(5));
+
+    }
+
+    @Test
+    public void testExceptionsWaitTimeOutNotReturnValue() throws IOException {
+        WebDriverConfig webDriverConfig = JsonUtils.fromFile(
+                ClassLoader.getSystemResourceAsStream("fixtures/sample-config-with-out-tolerant-action-wait-time.json")
+                , WebDriverConfig.class);
+        assertThat(webDriverConfig.getTolerantActionWaitTimeoutInSeconds(), is(30));
+
+    }
 }

src/test/java/uk/co/evoco/webdriver/utils/WebDriverUtilsIT.java

@@ -101,4 +101,12 @@ public void testCanClickOnHrefWithTolerantPollingWaitBeforeClickingHelperWhenEle
             ClickUtils.tolerantClick(element, 5);
         });
     }
+
+    @Test
+    public void testCanClickOnHrefWithTolerantPollingWaitTimeGetFromConfigBeforeClickingHelperWhenElementIsDisabledAllTheTime() {
+        assertThrows(TimeoutException.class, () -> {
+            WebElement element = webDriver.findElement(By.id("clickutils-href-always-disabled"));
+            ClickUtils.tolerantClick(element);
+        });
+    }
 }

src/test/resources/config.json

@@ -10,16 +10,19 @@
   "gridConfig": {
     "url": "http://localhost:4444/wd/hub"
   },
-  "browserPreferences" : {
+  "browserPreferences": {
     "firefox": {
       "browser.download.defaultFolder": "downloads/reports",
       "pdfjs.disabled": true,
       "browser.download.folderList": 2
     }
   },
-  "exceptionsToHandleOnTolerantActions": [
-    "StaleElementReferenceException",
-    "ElementClickInterceptedException",
-    "ElementNotInteractableException"
-  ]
+  "tolerantActionExceptions": {
+    "waitTimeoutInSeconds": 5,
+    "exceptionsToHandle": [
+      "StaleElementReferenceException",
+      "ElementClickInterceptedException",
+      "ElementNotInteractableException"
+    ]
+  }
 }