Added missing JavaDoc for core classes and AssertJ support module

Author: slu-it

webtester-core/src/main/java/info/novatec/testit/webtester/internal/proxies/impls/DefaultMethodImpl.java

@@ -10,7 +10,6 @@
 @Slf4j
 public class DefaultMethodImpl implements Implementation {
 
-    // TODO nicer implementation?
     private static Constructor<MethodHandles.Lookup> methodHandlesConstructor;
     static {
         try {

webtester-core/src/main/java/info/novatec/testit/webtester/pagefragments/PageFragment.java

@@ -251,7 +251,6 @@ default boolean isNotPresent() {
      * @since 2.0
      */
     default boolean isEnabled() {
-        // TODO: move to separate trait interface
         return webElement().isEnabled();
     }
 
@@ -267,7 +266,6 @@ default boolean isEnabled() {
      * @since 2.0
      */
     default boolean isDisabled() {
-        // TODO: move to separate trait interface
         return !isEnabled();
     }
 

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

@@ -5,22 +5,50 @@
 import info.novatec.testit.webtester.pagefragments.PageFragment;
 
 
+/**
+ * This class is used to configure {@link Wait} operations with custom settings like the {@code timeout}.
+ *
+ * @see Wait
+ * @see WaitUntil
+ * @since 2.0
+ */
 public class ConfiguredWait {
 
-    // TODO document
-
     private final long timeout;
     private final TimeUnit timeUnit;
 
+    /**
+     * Creates a new {@link ConfiguredWait} instance with the given timeout in seconds.
+     *
+     * @param timeout the timeout to use
+     * @since 2.0
+     */
     public ConfiguredWait(long timeout) {
         this(timeout, TimeUnit.SECONDS);
     }
 
+    /**
+     * Creates a new {@link ConfiguredWait} instance with the given timeout in the given {@link TimeUnit}.
+     *
+     * @param timeout the timeout to use
+     * @param timeUnit the unit of time to use
+     * @since 2.0
+     */
     public ConfiguredWait(long timeout, TimeUnit timeUnit) {
         this.timeout = timeout;
         this.timeUnit = timeUnit;
     }
 
+    /**
+     * Creates a {@link WaitUntil fluent wait until} with the timeout settings of this {@link ConfiguredWait} for the given
+     * {@link PageFragment}.
+     *
+     * @param fragment the fragment for the wait until operation
+     * @return the fluent wait instance
+     * @see Wait
+     * @see WaitUntil
+     * @since 2.0
+     */
     public <T extends PageFragment> WaitUntil<T> until(T fragment) {
         return new WaitUntil<>(fragment, timeout, timeUnit);
     }

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

@@ -4,51 +4,134 @@
 import java.util.function.Predicate;
 
 import info.novatec.testit.webtester.conditions.Conditions;
+import info.novatec.testit.webtester.config.Configuration;
 import info.novatec.testit.webtester.pagefragments.PageFragment;
 
 
+/**
+ * This class offers a number of methods which allow for the waiting until a specific condition is met for a {@link
+ * PageFragment}.
+ *
+ * @see Wait
+ * @since 2.0
+ */
 public class WaitUntil<T extends PageFragment> {
 
-    // TODO document
-
     private final T fragment;
     private final long timeout;
     private final TimeUnit timeUnit;
 
+    /**
+     * Creates a new {@link WaitUntil} instance for the given {@link PageFragment}.
+     * The timeout configuration will be taken from the fragment's browser's {@link Configuration}.
+     *
+     * @param fragment the fragment to use
+     * @see Wait
+     * @since 2.0
+     */
     public WaitUntil(T fragment) {
         this.fragment = fragment;
         this.timeout = fragment.getBrowser().configuration().getWaitTimeout();
         this.timeUnit = TimeUnit.SECONDS;
     }
 
+    /**
+     * Creates a new {@link WaitUntil} instance for the given {@link PageFragment} an timeout with {@link TimeUnit}.
+     *
+     * @param fragment the fragment to use
+     * @param timeout the timeout to use
+     * @param timeUnit the time unit to use
+     * @see Wait
+     * @since 2.0
+     */
     public WaitUntil(T fragment, long timeout, TimeUnit timeUnit) {
         this.fragment = fragment;
         this.timeout = timeout;
         this.timeUnit = timeUnit;
     }
 
+    /**
+     * Waits until the given condition is met. A set of default conditions can be initialized from {@link Conditions}.
+     *
+     * @param condition the condition to wait for
+     * @return the same instance for fluent API use
+     * @throws TimeoutException in case the condition is not met within the configured timeout
+     * @see Wait
+     * @see Conditions
+     * @since 2.0
+     */
     public WaitUntil<T> has(Predicate<? super T> condition) throws TimeoutException {
         return is(condition);
     }
 
+    /**
+     * Waits until the given condition is met. A set of default conditions can be initialized from {@link Conditions}.
+     *
+     * @param condition the condition to wait for
+     * @return the same instance for fluent API use
+     * @throws TimeoutException in case the condition is not met within the configured timeout
+     * @see Wait
+     * @see Conditions
+     * @since 2.0
+     */
     public WaitUntil<T> is(Predicate<? super T> condition) throws TimeoutException {
         WaitOperations.waitUntil(timeout, timeUnit, fragment, condition);
         return this;
     }
 
+    /**
+     * Waits until the given condition is NOT met. A set of default conditions can be initialized from {@link Conditions}.
+     *
+     * @param condition the condition to wait for
+     * @return the same instance for fluent API use
+     * @throws TimeoutException in case the condition is not met within the configured timeout
+     * @see Wait
+     * @see Conditions
+     * @since 2.0
+     */
     public WaitUntil<T> isNot(Predicate<? super T> condition) throws TimeoutException {
         return not(condition);
     }
 
+    /**
+     * Waits until the given condition is NOT met. A set of default conditions can be initialized from {@link Conditions}.
+     *
+     * @param condition the condition to wait for
+     * @return the same instance for fluent API use
+     * @throws TimeoutException in case the condition is not met within the configured timeout
+     * @see Wait
+     * @see Conditions
+     * @since 2.0
+     */
     public WaitUntil<T> not(Predicate<? super T> condition) throws TimeoutException {
         WaitOperations.waitUntil(timeout, timeUnit, fragment, Conditions.not(condition));
         return this;
     }
 
+    /**
+     * This method does nothing by it's own. It is intended to be used in order to write more expressive linked wait
+     * statements.
+     * <p>
+     * <b>Example:</b> {@code Wait.until(button).is(visible()).and().not(editable());}
+     *
+     * @return the same instance for fluent API use
+     * @see Wait
+     * @since 2.0
+     */
     public WaitUntil<T> and() {
         return this;
     }
 
+    /**
+     * This method does nothing by it's own. It is intended to be used in order to write more expressive linked wait
+     * statements.
+     * <p>
+     * <b>Example:</b> {@code Wait.until(button).is(visible()).but().not(editable());}
+     *
+     * @return the same instance for fluent API use
+     * @see Wait
+     * @since 2.0
+     */
     public WaitUntil<T> but() {
         return this;
     }

webtester-core/src/test/java/info/novatec/testit/webtester/internal/PostConstructInvokerTest.java

@@ -18,8 +18,6 @@
 
 public class PostConstructInvokerTest {
 
-    // TODO: Usage of TestContext is not Thread safe! Alternatives?
-
     @Test
     public void testInvocationOfPostConstructMethodsOfPageClass(){
 

webtester-support-assertj3/src/main/java/info/novatec/testit/webtester/support/assertj/WebTesterAssertions.java

@@ -16,28 +16,93 @@
 import info.novatec.testit.webtester.support.assertj.assertions.pagefragments.SingleSelectAssert;
 
 
+/**
+ * This class contains a number of entry points for WebTester related {@link Assertions}.
+ *
+ * @see PageFragmentAssert
+ * @see SelectableAssert
+ * @see ButtonAssert
+ * @see SingleSelectAssert
+ * @see MultiSelectAssert
+ * @see GenericTextFieldAssert
+ * @since 2.0
+ */
 public final class WebTesterAssertions extends Assertions {
 
+    /**
+     * Creates a new {@link PageFragmentAssert} for the given {@link PageFragment}.
+     *
+     * @param actual the page fragment to assert
+     * @return the new assert instance
+     * @see PageFragment
+     * @see PageFragmentAssert
+     * @since 2.0
+     */
     public static PageFragmentAssert assertThat(PageFragment actual) {
         return new PageFragmentAssert(actual);
     }
 
+    /**
+     * Creates a new {@link SelectableAssert} for the given {@link Selectable}.
+     *
+     * @param actual the selectable to assert
+     * @return the new assert instance
+     * @see Selectable
+     * @see SelectableAssert
+     * @since 2.0
+     */
     public static SelectableAssert assertThat(Selectable actual) {
         return new SelectableAssert(actual);
     }
 
+    /**
+     * Creates a new {@link ButtonAssert} for the given {@link Button}.
+     *
+     * @param actual the button to assert
+     * @return the new assert instance
+     * @see Button
+     * @see ButtonAssert
+     * @since 2.0
+     */
     public static ButtonAssert assertThat(Button actual) {
         return new ButtonAssert(actual);
     }
 
+    /**
+     * Creates a new {@link SingleSelectAssert} for the given {@link SingleSelect}.
+     *
+     * @param actual the single select to assert
+     * @return the new assert instance
+     * @see SingleSelect
+     * @see SingleSelectAssert
+     * @since 2.0
+     */
     public static SingleSelectAssert assertThat(SingleSelect actual) {
         return new SingleSelectAssert(actual);
     }
 
+    /**
+     * Creates a new {@link MultiSelectAssert} for the given {@link MultiSelect}.
+     *
+     * @param actual the multi select to assert
+     * @return the new assert instance
+     * @see MultiSelect
+     * @see MultiSelectAssert
+     * @since 2.0
+     */
     public static MultiSelectAssert assertThat(MultiSelect actual) {
         return new MultiSelectAssert(actual);
     }
 
+    /**
+     * Creates a new {@link GenericTextFieldAssert} for the given {@link GenericTextField}.
+     *
+     * @param actual the text field to assert
+     * @return the new assert instance
+     * @see GenericTextField
+     * @see GenericTextFieldAssert
+     * @since 2.0
+     */
     public static GenericTextFieldAssert assertThat(GenericTextField actual) {
         return new GenericTextFieldAssert(actual);
     }