All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.coveros.selenified.element.check.WaitForEquals Maven / Gradle / Ivy

/*
 * Copyright 2019 Coveros, Inc.
 *
 * This file is part of Selenified.
 *
 * Selenified is licensed under the Apache License, Version
 * 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy
 * of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package com.coveros.selenified.element.check;

import com.coveros.selenified.element.Element;
import com.coveros.selenified.utilities.Reporter;
import org.openqa.selenium.TimeoutException;
import org.openqa.selenium.support.ui.ExpectedCondition;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.util.Arrays;

import static com.coveros.selenified.utilities.Constants.*;

/**
 * WaitForEquals implements Equals to provide some additional wait capabilities.
 * It will handle all waits performed on the actual element. These
 * waits are custom to the framework, and in addition to providing easy object
 * oriented capabilities, they take screenshots with each failed wait to
 * provide additional traceability, and assist in troubleshooting and debugging
 * failing tests. Equals checks that elements have a particular value associated
 * to them.
 *
 * @author Max Saperstone
 * @version 3.2.0
 * @lastupdate 6/25/2019
 */
public class WaitForEquals extends Equals {

    /**
     * The default constructor passing in the element and output file
     *
     * @param element      - the element under test
     * @param reporter - the file to write all logging out to
     */
    public WaitForEquals(Element element, Reporter reporter) {
        this.element = element;
        this.reporter = reporter;
    }

    // ///////////////////////////////////////
    // waiting functionality
    // ///////////////////////////////////////

    /**
     * Waits for the element has a the expected number of matches on the page, e.g.
     * how many elements match the locator and target provided.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedMatches the expected number of elements matching the locator
     */
    public void matches(int expectedMatches) {
        matches(expectedMatches, defaultWait);
    }

    /**
     * Waits for the element has a css attribute with a value equal to the
     * value provided. If the element isn't present, or the css doesn't contain
     * the desired attribute, this will constitute a failure, same as a
     * mismatch. The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param attribute     - the css attribute to be checked
     * @param expectedValue the expected css value of the passed attribute of the element
     */
    public void cssValue(String attribute, String expectedValue) {
        cssValue(attribute, expectedValue, defaultWait);
    }

    /**
     * Waits for the element's class equals the provided expected class. If
     * the element isn't present, this will constitute a failure, same as a
     * mismatch. The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedClass - the full expected class value
     */
    public void clazz(String expectedClass) {
        clazz(expectedClass, defaultWait);
    }

    /**
     * Waits for the element has an attribute with a value equals to the
     * value provided. If the element isn't present, or the element does not
     * have the attribute, this will constitute a failure, same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param attribute     - the attribute to be checked
     * @param expectedValue the expected value of the passed attribute of the element
     */
    public void attribute(String attribute, String expectedValue) {
        attribute(attribute, expectedValue, defaultWait);
    }

    /**
     * Waits for the element's text equals the provided expected text. If
     * the element isn't present, this will constitute a failure, same as a
     * mismatch. The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedText the expected value of the element
     */
    public void text(String expectedText) {
        text(expectedText, defaultWait);
    }

    /**
     * Waits for the element's text in a particular cell equals the provided
     * expected text. If the element isn't present, or a table, this will
     * constitute a failure, same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param row  - the number of the row in the table - note, row numbering
     *             starts at 1, NOT 0
     * @param col  - the number of the column in the table - note, column
     *             numbering starts at 1, NOT 0
     * @param text - what text do we expect to be in the table cell
     */
    public void text(int row, int col, String text) {
        text(row, col, text, defaultWait);
    }

    /**
     * Waits for the element's value equals the provided expected value. If
     * the element isn't present or an input, this will constitute a failure,
     * same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedValue the expected input value of the element
     */
    public void value(String expectedValue) {
        value(expectedValue, defaultWait);
    }

    /**
     * Waits for the element's selected option equals the provided expected
     * option. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedText the expected input text of the element
     */
    public void selectedOption(String expectedText) {
        selectedOption(expectedText, defaultWait);
    }

    /**
     * Waits for the element's selected value equals the provided expected
     * value. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedValue the expected input value of the element
     */
    public void selectedValue(String expectedValue) {
        selectedValue(expectedValue, defaultWait);
    }

    /**
     * Waits for the element's select options equal the provided expected
     * options. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedOptions the expected input value of the element
     */
    public void selectOptions(String... expectedOptions) {
        selectOptions(expectedOptions, defaultWait);
    }

    /**
     * Waits for the element's select values equal the provided expected
     * values. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The default wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedValues the expected input value of the element
     */
    public void selectValues(String... expectedValues) {
        selectValues(expectedValues, defaultWait);
    }

    ///////////////////////////////////////////////////
    // Our actual full implementation of the above overloaded methods
    ///////////////////////////////////////////////////

    /**
     * Waits for the element has a the expected number of matches on the page, e.g.
     * how many elements match the locator and target provided.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedMatches - the expected number of elements matching the locator
     * @param seconds         - how many seconds to wait for
     */
    public void matches(int expectedMatches, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = 0;
            if (expectedMatches > 0) {
                timeTook = elementPresent(seconds);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> element.get().matchCount() == expectedMatches);
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkMatches(expectedMatches, seconds, timeTook);
        } catch (TimeoutException e) {
            checkMatches(expectedMatches, seconds, seconds);
        }
    }

    /**
     * Waits for the element has a css attribute with a value equal to the
     * value provided. If the element isn't present, or the css doesn't contain
     * the desired attribute, this will constitute a failure, same as a
     * mismatch. The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param attribute     - the css attribute to be checked
     * @param expectedValue - the expected css value of the passed attribute of the element
     * @param seconds       - how many seconds to wait for
     */
    public void cssValue(String attribute, String expectedValue, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> expectedValue.equals(element.get().css(attribute)));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkCssValue(attribute, expectedValue, seconds, timeTook);
        } catch (TimeoutException e) {
            checkCssValue(attribute, expectedValue, seconds, seconds);
        }
    }

    /**
     * Waits for the element's class equals the provided expected class. If
     * the element isn't present, this will constitute a failure, same as a
     * mismatch. The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedClass - the full expected class value
     * @param seconds       - how many seconds to wait for
     */
    public void clazz(String expectedClass, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> (expectedClass == null ? element.get().attribute(CLASS) == null : expectedClass.equals(element.get().attribute(CLASS))));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkClazz(expectedClass, seconds, timeTook);
        } catch (TimeoutException e) {
            checkClazz(expectedClass, seconds, seconds);
        }
    }

    /**
     * Waits for the element has an attribute with a value equals to the
     * value provided. If the element isn't present, or the element does not
     * have the attribute, this will constitute a failure, same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param attribute     - the attribute to be checked
     * @param expectedValue - the expected value of the passed attribute of the element
     * @param seconds       - how many seconds to wait for
     */
    public void attribute(String attribute, String expectedValue, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> expectedValue.equals(element.get().attribute(attribute)));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkAttribute(attribute, expectedValue, seconds, timeTook);
        } catch (TimeoutException e) {
            checkAttribute(attribute, expectedValue, seconds, seconds);
        }
    }

    /**
     * Waits for the element's text equals the provided expected text. If
     * the element isn't present, this will constitute a failure, same as a
     * mismatch. The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedText - the expected value of the element
     * @param seconds      - how many seconds to wait for
     */
    public void text(String expectedText, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until(ExpectedConditions.textToBePresentInElementLocated(element.defineByElement(), expectedText));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkText(expectedText, seconds, timeTook);
        } catch (TimeoutException e) {
            checkText(expectedText, seconds, seconds);
        }
    }

    /**
     * Waits for the element's text in a particular cell equals the provided
     * expected text. If the element isn't present, or a table, this will
     * constitute a failure, same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param row          - the number of the row in the table - note, row numbering
     *                     starts at 1, NOT 0
     * @param col          - the number of the column in the table - note, column
     *                     numbering starts at 1, NOT 0
     * @param expectedText - what text do we expect to be in the table cell
     * @param seconds      - how many seconds to wait for
     */
    public void text(int row, int col, String expectedText, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            if (!element.is().table()) {
                throw new TimeoutException(ELEMENT_NOT_TABLE);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> element.get().tableCell(row, col).get().text().equals(expectedText));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkText(row, col, expectedText, seconds, timeTook);
        } catch (TimeoutException e) {
            checkText(row, col, expectedText, seconds, seconds);
        }
    }

    /**
     * Waits for the element's value equals the provided expected value. If
     * the element isn't present or an input, this will constitute a failure,
     * same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedValue - the expected input value of the element
     * @param seconds       - how many seconds to wait for
     */
    public void value(String expectedValue, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until(ExpectedConditions.textToBePresentInElementValue(element.defineByElement(), expectedValue));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkValue(expectedValue, seconds, timeTook);
        } catch (TimeoutException e) {
            checkValue(expectedValue, seconds, seconds);
        }
    }

    /**
     * Waits for the element's selected option equals the provided expected
     * option. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedText - the expected input text of the element
     * @param seconds      - how many seconds to wait for
     */
    public void selectedOption(String expectedText, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            if (!element.is().select()) {
                throw new TimeoutException(ELEMENT_NOT_SELECT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> element.get().selectedOption().equals(expectedText));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkSelectedOption(expectedText, seconds, timeTook);
        } catch (TimeoutException e) {
            checkSelectedOption(expectedText, seconds, seconds);
        }
    }

    /**
     * Waits for the element's selected value equals the provided expected
     * value. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedValue - the expected input value of the element
     * @param seconds       - how many seconds to wait for
     */
    public void selectedValue(String expectedValue, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            if (!element.is().select()) {
                throw new TimeoutException(ELEMENT_NOT_SELECT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> element.get().selectedValue().equals(expectedValue));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkSelectedValue(expectedValue, seconds, timeTook);
        } catch (TimeoutException e) {
            checkSelectedValue(expectedValue, seconds, seconds);
        }
    }

    /**
     * Waits for the element's select options equal the provided expected
     * options. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedOptions - the expected input value of the element
     * @param seconds         - how many seconds to wait for
     */
    public void selectOptions(String[] expectedOptions, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            if (!element.is().select()) {
                throw new TimeoutException(ELEMENT_NOT_SELECT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> Arrays.toString(element.get().selectOptions()).equals(Arrays.toString(expectedOptions)));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkSelectOptions(expectedOptions, seconds, timeTook);
        } catch (TimeoutException e) {
            checkSelectOptions(expectedOptions, seconds, seconds);
        }
    }

    /**
     * Waits for the element's select values equal the provided expected
     * values. If the element isn't present or a select, this will constitute a
     * failure, same as a mismatch.
     * The provided wait time will be used and if the element doesn't
     * have the desired match count at that time, it will fail, and log
     * the issue with a screenshot for traceability and added debugging support.
     *
     * @param expectedValues - the expected input value of the element
     * @param seconds        - how many seconds to wait for
     */
    public void selectValues(String[] expectedValues, double seconds) {
        double end = System.currentTimeMillis() + (seconds * 1000);
        try {
            double timeTook = elementPresent(seconds);
            if (timeTook >= seconds) {
                throw new TimeoutException(ELEMENT_NOT_PRESENT);
            }
            if (!element.is().select()) {
                throw new TimeoutException(ELEMENT_NOT_SELECT);
            }
            WebDriverWait wait = new WebDriverWait(element.getDriver(), (long) (seconds - timeTook), defaultPoll);
            wait.until((ExpectedCondition) d -> !Arrays.toString(element.get().selectValues()).equals(Arrays.toString(expectedValues)));
            timeTook = Math.min((seconds * 1000) - (end - System.currentTimeMillis()), seconds * 1000) / 1000;
            checkSelectValues(expectedValues, seconds, timeTook);
        } catch (TimeoutException e) {
            checkSelectValues(expectedValues, seconds, seconds);
        }
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy