Refactored the Wait API's internal class structure and overall design

The API (Wait.java) didn't actually change but  a lot of the internal classes did:
- Sleeper abstraction to allow for better testability
- Reduced visibility of most classes to the package
- Added additional wait operation for waiting until a given boolean supplier returns true
- Replaced WaitOperations with a much more streamlined and less complex class Waiter

Author: slu-it

webtester-core/src/main/java/info/novatec/testit/webtester/WebTesterException.java

@@ -16,4 +16,8 @@ protected WebTesterException(String message, Throwable cause) {
         super(message, cause);
     }
 
+    protected WebTesterException(Throwable cause) {
+        super(cause);
+    }
+
 }

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/ConfiguredWait.java

@@ -1,57 +1,75 @@
 package info.novatec.testit.webtester.waiting;
 
-import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
 
-import info.novatec.testit.webtester.pagefragments.PageFragment;
+import lombok.AccessLevel;
+import lombok.Getter;
 
 
 /**
- * This class is used to configure {@link Wait} operations with custom settings like the {@code timeout}.
+ * This class is used to configure {@link Wait} operations with custom settings like a {@code timeout}.
  *
  * @see Wait
  * @see WaitUntil
+ * @see Waiter
+ * @see WaitConfig
  * @since 2.0
  */
+@Getter(AccessLevel.PACKAGE)
 public class ConfiguredWait {
 
-    private final long timeout;
-    private final TimeUnit timeUnit;
+    /**
+     * The {@link Waiter} to use when executing wait operations.
+     */
+    private final Waiter waiter;
+    /**
+     * The {@link WaitConfig} to use when deciding how long to wait.
+     */
+    private final WaitConfig config;
 
     /**
-     * Creates a new {@link ConfiguredWait} instance with the given timeout in seconds.
+     * Creates a new {@link ConfiguredWait} instance with the given {@link Waiter} and {@link WaitConfig}.
      *
-     * @param timeout the timeout to use
+     * @param waiter the waiter to use
+     * @param config the configuration to use
+     * @see Waiter
+     * @see WaitConfig
      * @since 2.0
      */
-    public ConfiguredWait(long timeout) {
-        this(timeout, TimeUnit.SECONDS);
+    ConfiguredWait(Waiter waiter, WaitConfig config) {
+        this.waiter = waiter;
+        this.config = config;
     }
 
     /**
-     * Creates a new {@link ConfiguredWait} instance with the given timeout in the given {@link TimeUnit}.
+     * Creates a {@link WaitUntil} with this {@link ConfiguredWait}'s {@link ConfiguredWait} for the given object.
      *
-     * @param timeout the timeout to use
-     * @param timeUnit the unit of time to use
+     * @param object the object for the wait until operation
+     * @param <T> the type of object
+     * @return the fluent wait instance
+     * @see Wait
+     * @see WaitUntil
+     * @see Waiter
+     * @see WaitConfig
      * @since 2.0
      */
-    public ConfiguredWait(long timeout, TimeUnit timeUnit) {
-        this.timeout = timeout;
-        this.timeUnit = timeUnit;
+    public <T> WaitUntil<T> until(T object) {
+        return new WaitUntil<>(waiter, config, object);
     }
 
     /**
-     * Creates a {@link WaitUntil fluent wait until} with the timeout settings of this {@link ConfiguredWait} for the given
-     * {@link PageFragment}.
+     * Executes a wait operation based on this {@link ConfiguredWait}'s {@link ConfiguredWait} and the given boolean
+     * supplier. The wait is executed until either the supplier returns <code>true</code> or the timeout is reached.
      *
-     * @param fragment the fragment for the wait until operation
-     * @param <T> the type of the page fragment subclass
-     * @return the fluent wait instance
+     * @param condition the supplier for the wait until operation
      * @see Wait
      * @see WaitUntil
+     * @see Waiter
+     * @see WaitConfig
      * @since 2.0
      */
-    public <T extends PageFragment> WaitUntil<T> until(T fragment) {
-        return new WaitUntil<>(fragment, timeout, timeUnit);
+    public void until(Supplier<Boolean> condition) {
+        waiter.waitUntil(config, condition);
     }
 
 }

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/CurrentThreadSleeper.java

@@ -0,0 +1,20 @@
+package info.novatec.testit.webtester.waiting;
+
+/**
+ * This implementation of {@link Sleeper} will execute the sleep on the current {@link Thread}.
+ *
+ * @see Sleeper
+ * @since 2.0
+ */
+class CurrentThreadSleeper implements Sleeper {
+
+    @Override
+    public void sleep(long milliseconds) throws InterruptionException {
+        try {
+            Thread.sleep(milliseconds);
+        } catch (java.lang.InterruptedException e) {
+            throw new InterruptionException(e);
+        }
+    }
+
+}

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/InterruptionException.java

@@ -0,0 +1,19 @@
+package info.novatec.testit.webtester.waiting;
+
+import info.novatec.testit.webtester.WebTesterException;
+
+
+/**
+ * This {@link WebTesterException} is thrown in case a wait operation is interrupted.
+ *
+ * @see Wait
+ * @see WaitUntil
+ * @since 2.0
+ */
+public class InterruptionException extends WebTesterException {
+
+    public InterruptionException(Throwable cause) {
+        super(cause);
+    }
+
+}

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/Sleeper.java

@@ -0,0 +1,17 @@
+package info.novatec.testit.webtester.waiting;
+
+/**
+ * Implementations of this interface can be used to trigger a 'sleep' state for a certain amount of time.
+ *
+ * @since 2.0
+ */
+interface Sleeper {
+    /**
+     * Sleep for the given amount of milliseconds.
+     *
+     * @param milliseconds the milliseconds to sleep
+     * @throws InterruptionException in case the sleep operation is interrupted
+     * @since 2.0
+     */
+    void sleep(long milliseconds) throws InterruptionException;
+}

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/TimeoutException.java

@@ -2,6 +2,14 @@
 
 import info.novatec.testit.webtester.WebTesterException;
 
+
+/**
+ * This {@link WebTesterException} is thrown in case a wait operation timed out.
+ *
+ * @see Wait
+ * @see WaitUntil
+ * @since 2.0
+ */
 public class TimeoutException extends WebTesterException {
 
     public TimeoutException(String message) {

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/Wait.java

@@ -6,8 +6,7 @@
 
 
 /**
- * This class aims to provide a fluent API for wait operations.
- * It is currently considered 'beta' and is subject to (possibly breaking) changes.
+ * This class provides a fluent API for wait operations.
  * <p>
  * <b>Example:</b>
  * <pre>
@@ -18,60 +17,87 @@
  * Wait.until(fragment).is(visible()).but().not(editable());
  * </pre>
  *
- * @see WaitOperations
+ * @see Waiter
  * @since 2.0
  */
 public final class Wait {
 
+    /**
+     * The {@link Waiter} to use when executing wait operations.
+     * This field is package-private in order to allow for it to be tests.
+     */
+    private static Waiter waiter = new Waiter();
+
     private Wait() {
         // utility class constructor
     }
 
     /**
      * Creates a {@link ConfiguredWait configured fluent wait} with a custom timeout.
+     * <p>
+     * <b>Note:</b> see {@link WaitConfig} for defaults besides the timeout!
      *
      * @param timeout the timeout in seconds
      * @return the fluent wait instance
      * @see Wait
      * @see ConfiguredWait
+     * @see WaitConfig
      * @since 2.0
      */
-    public static ConfiguredWait withTimeoutOf(long timeout) {
-        return withTimeoutOf(timeout, TimeUnit.SECONDS);
+    public static ConfiguredWait withTimeoutOf(int timeout) {
+        return new ConfiguredWait(waiter, new WaitConfig().setTimeout(timeout));
     }
 
     /**
      * Creates a {@link ConfiguredWait configured fluent wait} with a custom timeout and time unit.
+     * <p>
+     * <b>Note:</b> see {@link WaitConfig} for defaults besides the timeout!
      *
      * @param timeout the timeout value
      * @param timeUnit the time unit the value is specified as
      * @return the fluent wait instance
      * @see Wait
      * @see ConfiguredWait
+     * @see WaitConfig
      * @since 2.0
      */
-    public static ConfiguredWait withTimeoutOf(long timeout, TimeUnit timeUnit) {
-        return new ConfiguredWait(timeout, timeUnit);
+    public static ConfiguredWait withTimeoutOf(int timeout, TimeUnit timeUnit) {
+        return new ConfiguredWait(waiter, new WaitConfig().setTimeout(timeout).setTimeUnit(timeUnit));
     }
 
     /**
-     * Creates a {@link WaitUntil fluent wait until} with the default timeout of the browser the given
-     * {@link PageFragment fragment} was created in.
+     * Creates a {@link WaitUntil} with the default timeout configuration of {@link WaitConfig} for the given object.
+     *
+     * @param object the object for the wait until operation
+     * @param <T> the type of the object
+     * @return the fluent wait instance
+     * @see Wait
+     * @see WaitUntil
+     * @see WaitConfig
+     * @since 2.0
+     */
+    public static <T> WaitUntil<T> until(T object) {
+        return new WaitUntil<>(waiter, new WaitConfig(), object);
+    }
+
+    /**
+     * Creates a {@link WaitUntil} with the default timeout from the given {@link PageFragment}'s configuration.
      *
      * @param fragment the fragment for the wait until operation
      * @param <T> the type of the page fragment subclass
      * @return the fluent wait instance
      * @see Wait
      * @see WaitUntil
+     * @see WaitConfig
      * @since 2.0
      */
     public static <T extends PageFragment> WaitUntil<T> until(T fragment) {
-        return new WaitUntil<>(fragment);
+        return new WaitUntil<>(waiter, WaitConfig.from(fragment), fragment);
     }
 
     /**
      * Waits the given amount of time with the given unit.
-     *
+     * <p>
      * <b>Example:</b>
      * <pre>
      * Wait.exactly(10, TimeUnit.SECONDS);
@@ -83,7 +109,7 @@ public static <T extends PageFragment> WaitUntil<T> until(T fragment) {
      * @since 2.0
      */
     public static void exactly(long duration, TimeUnit timeUnit) {
-        WaitOperations.wait(duration, timeUnit);
+        waiter.waitExactly(duration, timeUnit);
     }
 
 }

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/WaitConfig.java

@@ -0,0 +1,91 @@
+package info.novatec.testit.webtester.waiting;
+
+import java.util.concurrent.TimeUnit;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import info.novatec.testit.webtester.browser.Browser;
+import info.novatec.testit.webtester.config.Configuration;
+import info.novatec.testit.webtester.pagefragments.PageFragment;
+
+
+/**
+ * This class is used to store configuration parameters for wait operations. This includes a timeout, the unit of the
+ * timeout
+ * as well as an invervall which should be used by periodical check waits like a 'wait until X'.
+ *
+ * @see Wait
+ * @see WaitUntil
+ * @since 2.0
+ */
+@Getter
+@Setter
+@Accessors(chain = true)
+@SuppressWarnings("PMD")
+public class WaitConfig {
+
+    public static final int DEFAULT_TIMEOUT = 2;
+    public static final TimeUnit DEFAULT_TIME_UNIT = TimeUnit.SECONDS;
+    public static final long DEFAULT_INTERVAL = 100L;
+
+    /**
+     * The timeout to use. It's actual value is relative to it's {@link #timeUnit}.
+     */
+    private int timeout = DEFAULT_TIMEOUT;
+    /**
+     * The time unit to use when evaluating the {@link #timeout}.
+     */
+    private TimeUnit timeUnit = DEFAULT_TIME_UNIT;
+    /**
+     * The interval in which to check conditions of 'wait until X' style wait operations.
+     */
+    private long interval = DEFAULT_INTERVAL;
+
+    /**
+     * Converts the set {@link #timeout} into milliseconds.
+     *
+     * @return the timeout in milliseconds
+     * @since 2.0
+     */
+    public long getTimeoutInMillis() {
+        return timeUnit.toMillis(timeout);
+    }
+
+    /**
+     * Creates a new {@link WaitConfig} from the given {@link PageFragment}'s {@link Configuration}.
+     *
+     * @param fragment the fragment who's configuration should be used
+     * @return the new wait config instance
+     * @since 2.0
+     */
+    static WaitConfig from(PageFragment fragment) {
+        return from(fragment.getBrowser());
+    }
+
+    /**
+     * Creates a new {@link WaitConfig} from the given {@link Browser}'s {@link Configuration}.
+     *
+     * @param browser the browser who's configuration should be used
+     * @return the new wait config instance
+     * @since 2.0
+     */
+    static WaitConfig from(Browser browser) {
+        return from(browser.configuration());
+    }
+
+    /**
+     * Creates a new {@link WaitConfig} from the given {@link Configuration}.
+     *
+     * @param configuration the configuration to used
+     * @return the new wait config instance
+     * @since 2.0
+     */
+    static WaitConfig from(Configuration configuration) {
+        return new WaitConfig().setTimeout(configuration.getWaitTimeout())
+            .setTimeUnit(TimeUnit.SECONDS)
+            .setInterval(configuration.getWaitInterval());
+    }
+
+}