• Home
• net.serenity-bdd
• serenity-core
• 4.2.3
• source code
• PageObject.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.serenitybdd.core.pages.PageObject Maven / Gradle / Ivy

package net.serenitybdd.core.pages;

import com.google.common.base.Predicate;
import net.serenitybdd.core.Serenity;
import net.serenitybdd.core.SystemTimeouts;
import net.serenitybdd.model.collect.NewList;
import net.serenitybdd.core.di.SerenityInfrastructure;
import net.serenitybdd.model.environment.EnvironmentSpecificConfiguration;
import net.serenitybdd.model.time.SystemClock;
import net.thucydides.model.ThucydidesSystemProperty;
import net.serenitybdd.annotations.WhenPageOpens;
import net.thucydides.model.environment.SystemEnvironmentVariables;
import net.thucydides.core.fluent.ThucydidesFluentAdapter;
import net.thucydides.core.pages.Pages;
import net.thucydides.core.pages.WrongPageError;
import net.thucydides.core.pages.components.Dropdown;
import net.thucydides.core.pages.components.FileToUpload;
import net.thucydides.core.pages.jquery.JQueryEnabledPage;
import net.thucydides.model.reflection.MethodFinder;
import net.thucydides.core.scheduling.FluentWaitWithRefresh;
import net.thucydides.core.scheduling.SerenityFluentWait;
import net.thucydides.core.scheduling.ThucydidesFluentWait;
import net.thucydides.core.steps.PageObjectStepDelayer;
import net.thucydides.core.steps.StepEventBus;
import net.thucydides.core.steps.WaitForBuilder;
import net.thucydides.model.util.EnvironmentVariables;
import net.thucydides.model.util.Inflector;
import net.thucydides.core.webdriver.*;
import net.thucydides.core.webdriver.javascript.JavascriptExecutorFacade;
import net.thucydides.core.webelements.Checkbox;
import net.thucydides.core.webelements.RadioButtonGroup;
import org.apache.commons.lang3.StringUtils;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.*;
import org.openqa.selenium.devtools.DevTools;
import org.openqa.selenium.devtools.HasDevTools;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedCondition;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.Sleeper;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Clock;
import java.time.Duration;
import java.time.temporal.TemporalUnit;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Stream;

import static net.serenitybdd.core.pages.ParameterisedLocator.withArguments;
import static net.serenitybdd.core.selectors.Selectors.xpathOrCssSelector;
import static net.thucydides.model.ThucydidesSystemProperty.*;
import static net.thucydides.core.webdriver.javascript.JavascriptSupport.javascriptIsSupportedIn;

/**
 * A base class representing a WebDriver page object.
 *
 * @author johnsmart
 */
public abstract class PageObject {

    private static final int WAIT_FOR_ELEMENT_PAUSE_LENGTH = 250;

    private static final Logger LOGGER = LoggerFactory.getLogger(PageObject.class);

    private WebDriver driver;

    private Pages pages;

    private MatchingPageExpressions matchingPageExpressions;

    private RenderedPageObjectView renderedView;

    private PageUrls pageUrls;

    private final SystemClock clock;

    private Duration waitForTimeout;
    private Duration waitForElementTimeout;

    private final Sleeper sleeper;
    private final Clock webdriverClock;
    private JavascriptExecutorFacade javascriptExecutorFacade;

    private EnvironmentVariables environmentVariables;

    public static PageObject fromSearchContext(SearchContext searchContext) {
        return null;
    }

    public void setImplicitTimeout(int duration, TemporalUnit unit) {

        waitForElementTimeout = Duration.of(duration, unit);
        setDriverImplicitTimeout(waitForElementTimeout);
    }

    private void setDriverImplicitTimeout(Duration implicitTimeout) {
        if (driver instanceof ConfigurableTimeouts) {
            ((ConfigurableTimeouts) driver).setImplicitTimeout(implicitTimeout);
        } else {
            driver.manage().timeouts().implicitlyWait(Duration.ofMillis(waitForElementTimeout.toMillis()));
        }
    }

    public void resetImplicitTimeout() {
        if (driver instanceof ConfigurableTimeouts) {
            waitForElementTimeout = ((ConfigurableTimeouts) driver).resetTimeouts();
        } else {
            waitForElementTimeout = getDefaultImplicitTimeout();
            driver.manage().timeouts().implicitlyWait(Duration.ofMillis(waitForElementTimeout.toMillis()));
        }
    }

    private Duration getDefaultImplicitTimeout() {
        Long configuredTimeout = new SystemTimeouts(environmentVariables).getImplicitTimeout();
        return Duration.ofMillis(configuredTimeout);
    }

    private enum OpenMode {
        CHECK_URL_PATTERNS,
        IGNORE_URL_PATTERNS
    }

    protected PageObject() {
        this.webdriverClock = Clock.systemDefaultZone();
        this.clock = SerenityInfrastructure.getClock();
        this.environmentVariables = SystemEnvironmentVariables.currentEnvironmentVariables();
        this.sleeper = Sleeper.SYSTEM_SLEEPER;
    }

    protected PageObject(final WebDriver driver, Predicate callback) {
        this();
        this.driver = driver;
        callback.apply(this);
    }

    public PageObject(final WebDriver webdriver, final int ajaxTimeout) {
        this();
        setDriver(webdriver, ajaxTimeout);
    }

    public PageObject(final WebDriver driver) {
        this();
        ThucydidesWebDriverSupport.useDriver(driver);
        setDriver(driver);
    }

    public PageObject(final WebDriver driver, final EnvironmentVariables environmentVariables) {
        this();
        this.environmentVariables = environmentVariables;
        setDriver(driver);
    }

    protected void setDriver(WebDriver webdriver, long timeout) {
        this.driver = webdriver;
        if (SerenityInfrastructure.getConfiguration().getBaseUrl() != null) {
            setDefaultBaseUrl(SerenityInfrastructure.getConfiguration().getBaseUrl());
        }
        new DefaultPageObjectInitialiser(getDriver(), timeout).apply(this);
    }

    public  T setDriver(WebDriver webdriver) {
        setDriver(webdriver, getImplicitWaitTimeout().toMillis());
        return (T) this;
    }

    public  T withDriver(WebDriver driver) {
        return setDriver(driver);
    }

    public Duration getWaitForTimeout() {

        if (waitForTimeout == null) {
            int configuredWaitForTimeoutInMilliseconds = fluentWaitTimeout();
            waitForTimeout = Duration.ofMillis(configuredWaitForTimeoutInMilliseconds);
        }
        return waitForTimeout;
    }

    private int fluentWaitTimeout() {
        return (WEBDRIVER_WAIT_FOR_TIMEOUT.integerFrom(environmentVariables,
                WEBDRIVER_TIMEOUTS_FLUENTWAIT.integerFrom(environmentVariables,
                        (int) DefaultTimeouts.DEFAULT_WAIT_FOR_TIMEOUT.toMillis())));
    }

    @Deprecated
    public Duration getWaitForElementTimeout() {
        return getImplicitWaitTimeout();
    }

    public Duration getImplicitWaitTimeout() {

        if (waitForElementTimeout == null) {
            long configuredWaitForTimeoutInMilliseconds = new SystemTimeouts(environmentVariables).getImplicitTimeout();
            waitForElementTimeout = Duration.ofMillis(configuredWaitForTimeoutInMilliseconds);
        }
        return waitForElementTimeout;
    }

    public void setPages(Pages pages) {
        this.pages = pages;
    }

    @Deprecated
    public  T switchToPage(final Class pageObjectClass) {
        if (pages.getDriver() == null) {
            pages.setDriver(driver);
        }

        return pages.getPage(pageObjectClass);
    }

    /**
     * Upload a file via an HTML form.
     * By default, this will look for a file on the file system, at the location provided.
     */
    public FileToUpload upload(final String filename) {
        return new FileToUpload(getDriver(), filename).useRemoteDriver(isDefinedRemoteUrl());
    }

    public FileToUpload uploadData(String data) throws IOException {
        Path datafile = Files.createTempFile("upload", "data");
        Files.write(datafile, data.getBytes(StandardCharsets.UTF_8));
        return new FileToUpload(getDriver(), datafile.toAbsolutePath().toString()).useRemoteDriver(isDefinedRemoteUrl());
    }

    public FileToUpload uploadData(byte[] data) throws IOException {
        Path datafile = Files.createTempFile("upload", "data");
        Files.write(datafile, data);
        return new FileToUpload(getDriver(), datafile.toAbsolutePath().toString()).useRemoteDriver(isDefinedRemoteUrl());
    }

    private boolean isDefinedRemoteUrl() {
        boolean isRemoteUrl = ThucydidesSystemProperty.WEBDRIVER_REMOTE_URL.isDefinedIn(environmentVariables);
        boolean isBrowserStack = ThucydidesSystemProperty.BROWSERSTACK_URL.isDefinedIn(environmentVariables);
        return isRemoteUrl || isBrowserStack;
    }

    private PageUrls getPageUrls() {
        if (pageUrls == null) {
            pageUrls = new PageUrls(this, environmentVariables);
        }
        return pageUrls;
    }

    /**
     * Only for testing purposes.
     */
    public void setPageUrls(PageUrls pageUrls) {
        this.pageUrls = pageUrls;
    }

    public void setWaitForTimeout(final long waitForTimeoutInMilliseconds) {
        this.waitForTimeout = Duration.ofMillis(waitForTimeoutInMilliseconds);
        getRenderedView().setWaitForTimeout(this.waitForTimeout);
    }

    public void setWaitForElementTimeout(final long waitForTimeoutInMilliseconds) {
        this.waitForElementTimeout = Duration.ofMillis(waitForTimeoutInMilliseconds);
    }

    protected RenderedPageObjectView getRenderedView() {
        if (renderedView == null) {
            renderedView = new RenderedPageObjectView(getDriver(), this, getWaitForTimeout(), true);
        }
        return renderedView;
    }

    protected SystemClock getClock() {
        return clock;
    }

    private MatchingPageExpressions getMatchingPageExpressions() {
        if (matchingPageExpressions == null) {
            matchingPageExpressions = new MatchingPageExpressions(this);
        }
        return matchingPageExpressions;
    }

    public WebDriver getDriver() {
        if (driver == null) {
            driver = Serenity.getDriver();
        }
        return driver;
    }

    /**
     * Determines if the current driver is equipped with Chrome Dev Tools
     */
    public boolean hasDevTools() {
        if (getDriver() instanceof WebDriverFacade) {
            return (((WebDriverFacade) getDriver()).getProxiedDriver() instanceof HasDevTools);
        } else {
            return (getDriver() instanceof HasDevTools);
        }
    }

    public Optional maybeGetDevTools() {
       return Optional.ofNullable(getDevTools());
    }

    public DevTools getDevTools() {
        if (!hasDevTools()) {
            return null;
        }
        if (getDriver() instanceof WebDriverFacade) {
            return ((HasDevTools) ((WebDriverFacade) getDriver()).getProxiedDriver()).getDevTools();
        } else {
            return ((HasDevTools) getDriver()).getDevTools();
        }
    }

    public String getTitle() {
        return driver.getTitle();
    }

    public boolean matchesAnyUrl() {
        return thereAreNoPatternsDefined();
    }

    /**
     * Does this page object work for this URL? When matching a URL, we check
     * with and without trailing slashes
     */
    public final boolean compatibleWithUrl(final String currentUrl) {
        return thereAreNoPatternsDefined() || matchUrlAgainstEachPattern(currentUrl);
    }

    private boolean matchUrlAgainstEachPattern(final String currentUrl) {
        return getMatchingPageExpressions().matchUrlAgainstEachPattern(currentUrl);
    }

    private boolean thereAreNoPatternsDefined() {
        return getMatchingPageExpressions().isEmpty();
    }

    public PageObject waitForRenderedElements(final By byElementCriteria) {
        getRenderedView().waitFor(byElementCriteria);
        return this;
    }

    /**
     * @deprecated TimeUnit has been replaced by TemporalUnit in Selenium. For more consistancy use a TemporalUnit parameter.
     */
    @Deprecated
    public RenderedPageObjectView withTimeoutOf(int timeout, TimeUnit units) {
        return withTimeoutOf(Duration.of(timeout, TemporalUnitConverter.fromTimeUnit(units)));
    }

    public RenderedPageObjectView withTimeoutOf(int timeout, TemporalUnit units) {
        return withTimeoutOf(Duration.of(timeout, units));
    }

    public RenderedPageObjectView withTimeoutOf(Duration timeout) {
        return new RenderedPageObjectView(getDriver(), this, timeout, false);
    }

    /**
     * Alternative to withTimeoutOf()
     */
    public RenderedPageObjectView waitingForNoLongerThan(int timeout, TimeUnit units) {
        return withTimeoutOf(Duration.of(timeout, TemporalUnitConverter.fromTimeUnit(units)));
    }

    /**
     * Alternative to withTimeoutOf() using a DSL
     */
    public WaitingBuilder waitingForNoLongerThan(int timeout) {
        return new WaitingBuilder(timeout, this);
    }

    public static class WaitingBuilder {

        private final int timeout;
        private final PageObject page;

        public WaitingBuilder(int timeout, PageObject page) {
            this.timeout = timeout;
            this.page = page;
        }

        public RenderedPageObjectView milliseconds() {
            return page.withTimeoutOf(Duration.ofMillis(timeout));
        }
        public RenderedPageObjectView seconds() {
            return page.withTimeoutOf(Duration.ofSeconds(timeout));
        }
        public RenderedPageObjectView minutes() {
            return page.withTimeoutOf(Duration.ofMinutes(timeout));
        }
    }


    public PageObject waitFor(String xpathOrCssSelector, Object firstArgument, Object... arguments) {
        List