Feature/13 element finder

src/main/java/aquality/selenium/core/applications/AqualityModule.java

@@ -1,6 +1,8 @@
 package aquality.selenium.core.applications;
 
 import aquality.selenium.core.configurations.*;
+import aquality.selenium.core.elements.IElementsModule;
+import aquality.selenium.core.elements.interfaces.IElementFinder;
 import aquality.selenium.core.localization.ILocalizationManager;
 import aquality.selenium.core.localization.ILocalizationModule;
 import aquality.selenium.core.localization.ILocalizedLogger;
@@ -18,7 +20,7 @@
  * Describes all dependencies which is registered for the project.
  */
 public class AqualityModule<T extends IApplication> extends AbstractModule
-        implements ILocalizationModule, IUtilitiesModule, IWaitingsModule {
+        implements ILocalizationModule, IUtilitiesModule, IWaitingsModule, IElementsModule {
 
     private final Provider<T> applicationProvider;
 
@@ -42,5 +44,6 @@ protected void configure() {
         bind(ILocalizationManager.class).to(getLocalizationManagerImplementation()).in(Singleton.class);
         bind(ILocalizedLogger.class).to(getLocalizedLoggerImplementation()).in(Singleton.class);
         bind(IConditionalWait.class).to(getConditionalWaitImplementation());
+        bind(IElementFinder.class).to(getElementFinderImplementation());
     }
 }

src/main/java/aquality/selenium/core/elements/DesiredState.java

@@ -0,0 +1,47 @@
+package aquality.selenium.core.elements;
+
+import org.openqa.selenium.WebElement;
+
+import java.util.function.Predicate;
+
+/**
+ * Defines desired state for element with ability to handle exceptions.
+ */
+public class DesiredState {
+
+    private final Predicate<WebElement> desiredStatePredicate;
+    private final String stateName;
+    private boolean isCatchingTimeoutException;
+    private boolean isThrowingNoSuchElementException;
+
+    public DesiredState(Predicate<WebElement> desiredStatePredicate, String stateName){
+        this.desiredStatePredicate = desiredStatePredicate;
+        this.stateName = stateName;
+    }
+
+    public Predicate<WebElement> getElementStateCondition() {
+        return desiredStatePredicate;
+    }
+
+    public String getStateName() {
+        return stateName;
+    }
+
+    public DesiredState withCatchingTimeoutException(){
+        this.isCatchingTimeoutException = true;
+        return this;
+    }
+
+    public DesiredState withThrowingNoSuchElementException(){
+        this.isThrowingNoSuchElementException = true;
+        return this;
+    }
+
+    public boolean isCatchingInTimeoutException() {
+        return isCatchingTimeoutException;
+    }
+
+    public boolean isThrowingNoSuchElementException() {
+        return isThrowingNoSuchElementException;
+    }
+}

src/main/java/aquality/selenium/core/elements/ElementFinder.java

@@ -0,0 +1,80 @@
+package aquality.selenium.core.elements;
+
+import aquality.selenium.core.elements.interfaces.IElementFinder;
+import aquality.selenium.core.localization.ILocalizedLogger;
+import aquality.selenium.core.waitings.IConditionalWait;
+import com.google.inject.Inject;
+import org.openqa.selenium.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Implementation of IElementFinder.
+ */
+public class ElementFinder implements IElementFinder {
+    private final ILocalizedLogger localizedLogger;
+    private final IConditionalWait conditionalWait;
+
+    @Inject
+    public ElementFinder(ILocalizedLogger localizedLogger, IConditionalWait conditionalWait) {
+        this.localizedLogger = localizedLogger;
+        this.conditionalWait = conditionalWait;
+    }
+
+    @Override
+    public List<WebElement> findElements(By locator, DesiredState desiredState, Long timeoutInSeconds) {
+        AtomicBoolean wasAnyElementFound = new AtomicBoolean(false);
+        List<WebElement> resultElements = new ArrayList<>();
+        try {
+            conditionalWait.waitFor(driver ->
+                            tryToFindElements(locator, desiredState, wasAnyElementFound, resultElements, driver),
+                    timeoutInSeconds,
+                    null);
+        } catch (TimeoutException e) {
+            handleTimeoutException(e, locator, desiredState, wasAnyElementFound.get());
+        }
+
+        return resultElements;
+    }
+
+    protected boolean tryToFindElements(By locator, DesiredState desiredState, AtomicBoolean wasAnyElementFound,
+                                        List<WebElement> resultElements, SearchContext context) {
+        List<WebElement> currentFoundElements = context.findElements(locator);
+        wasAnyElementFound.set(!currentFoundElements.isEmpty());
+        currentFoundElements
+                .stream()
+                .filter(desiredState.getElementStateCondition())
+                .forEachOrdered(resultElements::add);
+        return !resultElements.isEmpty();
+    }
+
+    /**
+     * depends on configuration of DesiredState object it can be required to throw or not NoSuchElementException
+     *
+     * @param exception          TimeoutException to handle
+     * @param locator            locator that is using to find elements
+     * @param desiredState       DesiredState object
+     * @param wasAnyElementFound was any element found by locator or not.
+     */
+    protected void handleTimeoutException(TimeoutException exception, By locator, DesiredState desiredState, boolean wasAnyElementFound) {
+        String message = String.format("No elements with locator '%1$s' were found in %2$s state", locator, desiredState.getStateName());
+        if (desiredState.isCatchingInTimeoutException()) {
+            if (!wasAnyElementFound) {
+                if (desiredState.isThrowingNoSuchElementException()) {
+                    throw new NoSuchElementException(message);
+                }
+                localizedLogger.debug("loc.no.elements.found.in.state", locator, desiredState.getStateName());
+            } else {
+                localizedLogger.debug("loc.elements.were.found.but.not.in.state", locator, desiredState.getStateName());
+            }
+        } else {
+            String combinedMessage = String.format("%1$s: %2$s", exception.getMessage(), message);
+            if (desiredState.isThrowingNoSuchElementException() && !wasAnyElementFound) {
+                throw new NoSuchElementException(combinedMessage);
+            }
+            throw new TimeoutException(combinedMessage);
+        }
+    }
+}

src/main/java/aquality/selenium/core/elements/ElementState.java

@@ -0,0 +1,17 @@
+package aquality.selenium.core.elements;
+
+public enum ElementState {
+    DISPLAYED("displayed"),
+    EXISTS_IN_ANY_STATE("exists");
+
+    private final String state;
+
+    ElementState(String state) {
+        this.state = state;
+    }
+
+    @Override
+    public String toString() {
+        return state;
+    }
+}

src/main/java/aquality/selenium/core/elements/IElementsModule.java

@@ -0,0 +1,15 @@
+package aquality.selenium.core.elements;
+
+import aquality.selenium.core.elements.interfaces.IElementFinder;
+
+/**
+ * Describes implementations of elements services to be registered in DI container.
+ */
+public interface IElementsModule {
+    /**
+     * @return class which implements IElementFinder
+     */
+    default Class<? extends IElementFinder> getElementFinderImplementation() {
+        return ElementFinder.class;
+    }
+}

src/main/java/aquality/selenium/core/elements/RelativeElementFinder.java

@@ -0,0 +1,48 @@
+package aquality.selenium.core.elements;
+
+import aquality.selenium.core.localization.ILocalizedLogger;
+import aquality.selenium.core.waitings.IConditionalWait;
+import org.openqa.selenium.By;
+import org.openqa.selenium.SearchContext;
+import org.openqa.selenium.WebElement;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+
+/**
+ * Implementation of IElementFinder for a relative SearchContext.
+ */
+public class RelativeElementFinder extends ElementFinder {
+    private final IConditionalWait conditionalWait;
+    private final Supplier<SearchContext> searchContextSupplier;
+
+    public RelativeElementFinder(ILocalizedLogger localizedLogger, IConditionalWait conditionalWait,
+                                 Supplier<SearchContext> searchContextSupplier) {
+        super(localizedLogger, conditionalWait);
+        this.conditionalWait = conditionalWait;
+        this.searchContextSupplier = searchContextSupplier;
+    }
+
+    @Override
+    public List<WebElement> findElements(By locator, DesiredState desiredState, Long timeoutInSeconds) {
+        AtomicBoolean wasAnyElementFound = new AtomicBoolean(false);
+        List<WebElement> resultElements = new ArrayList<>();
+        try {
+            conditionalWait.waitForTrue(() ->
+                            tryToFindElements(locator, desiredState, wasAnyElementFound, resultElements,
+                                    searchContextSupplier.get()),
+                    timeoutInSeconds,
+                    null);
+        } catch (TimeoutException e) {
+            handleTimeoutException(new org.openqa.selenium.TimeoutException(e.getMessage(), e), locator, desiredState,
+                    wasAnyElementFound.get());
+        } catch (org.openqa.selenium.TimeoutException e) {
+            handleTimeoutException(e, locator, desiredState, wasAnyElementFound.get());
+        }
+
+        return resultElements;
+    }
+}