c# - सेलेनियम सी#वेबड्राइवर: एलिमेंट मौजूद होने तक प्रतीक्षा करें




selenium webdriver (13)

मैं यह सुनिश्चित करना चाहता हूं कि वेबड्राइवर सामान शुरू करने से पहले एक तत्व मौजूद है।

मैं इस तरह काम करने के लिए कुछ पाने की कोशिश कर रहा हूँ:

WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0,0,5));
wait.Until(By.Id("login"));

मैं मुख्य रूप से संघर्ष कर रहा हूं कि किसी भी काम को कैसे स्थापित किया जाए ..


अजगर:

from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By

driver.find_element_by_id('someId').click()

WebDriverWait(driver, timeout).until(EC.presence_of_element_located((By.ID, 'someAnotherId'))

ईसी से आप अन्य स्थितियों का चयन भी कर सकते हैं: http://selenium-python.readthedocs.org/api.html#module-selenium.webdriver.support.expected_conditions


आप भी उपयोग कर सकते हैं

ExpectedConditions.ElementExists

तो आप इस तरह की एक तत्व उपलब्धता की खोज करेंगे

new WebDriverWait(driver, TimeSpan.FromSeconds(timeOut)).Until(ExpectedConditions.ElementExists((By.Id(login))));

Source


इस कोड को आज़माएं:

 New WebDriverWait(driver, TimeSpan.FromSeconds(10)).Until(Function(d) d.FindElement(By.Id("controlName")).Displayed)

एक ISARCHContext का उपयोग करने के लिए प्रयुक्त Rn222 और Aknuds1 जो या तो एक तत्व या सूची देता है। और तत्वों की न्यूनतम संख्या निर्दिष्ट की जा सकती है:

public static class SearchContextExtensions
{
    /// <summary>
    ///     Method that finds an element based on the search parameters within a specified timeout.
    /// </summary>
    /// <param name="context">The context where this is searched. Required for extension methods</param>
    /// <param name="by">The search parameters that are used to identify the element</param>
    /// <param name="timeOutInSeconds">The time that the tool should wait before throwing an exception</param>
    /// <returns> The first element found that matches the condition specified</returns>
    public static IWebElement FindElement(this ISearchContext context, By by, uint timeOutInSeconds)
    {
        if (timeOutInSeconds > 0)
        {
            var wait = new DefaultWait<ISearchContext>(context);
            wait.Timeout = TimeSpan.FromSeconds(timeOutInSeconds);
            return wait.Until<IWebElement>(ctx => ctx.FindElement(by));
        }
        return context.FindElement(by);
    }
    /// <summary>
    ///     Method that finds a list of elements based on the search parameters within a specified timeout.
    /// </summary>
    /// <param name="context">The context where this is searched. Required for extension methods</param>
    /// <param name="by">The search parameters that are used to identify the element</param>
    /// <param name="timeoutInSeconds">The time that the tool should wait before throwing an exception</param>
    /// <returns>A list of all the web elements that match the condition specified</returns>
    public static IReadOnlyCollection<IWebElement> FindElements(this ISearchContext context, By by, uint timeoutInSeconds)
    {

        if (timeoutInSeconds > 0)
        {
            var wait = new DefaultWait<ISearchContext>(context);
            wait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
            return wait.Until<IReadOnlyCollection<IWebElement>>(ctx => ctx.FindElements(by));
        }
        return context.FindElements(by);
    }
    /// <summary>
    ///     Method that finds a list of elements with the minimum amount specified based on the search parameters within a specified timeout.<br/>
    /// </summary>
    /// <param name="context">The context where this is searched. Required for extension methods</param>
    /// <param name="by">The search parameters that are used to identify the element</param>
    /// <param name="timeoutInSeconds">The time that the tool should wait before throwing an exception</param>
    /// <param name="minNumberOfElements">
    ///     The minimum number of elements that should meet the criteria before returning the list <para/>
    ///     If this number is not met, an exception will be thrown and no elements will be returned
    ///     even if some did meet the criteria
    /// </param>
    /// <returns>A list of all the web elements that match the condition specified</returns>
    public static IReadOnlyCollection<IWebElement> FindElements(this ISearchContext context, By by, uint timeoutInSeconds, int minNumberOfElements)
    {
        var wait = new DefaultWait<ISearchContext>(context);
        if (timeoutInSeconds > 0)
        {
            wait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
        }

        // Wait until the current context found the minimum number of elements. If not found after timeout, an exception is thrown
        wait.Until<bool>(ctx => ctx.FindElements(by).Count >= minNumberOfElements);

        //If the elements were successfuly found, just return the list
        return context.FindElements(by);
    }

}

उदाहरण का उपयोग:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost");
var main = driver.FindElement(By.Id("main"));
// It can be now used to wait when using elements to search
var btn = main.FindElement(By.Id("button"),10);
btn.Click();
//This will wait up to 10 seconds until a button is found
var button = driver.FindElement(By.TagName("button"),10)
//This will wait up to 10 seconds until a button is found, and return all the buttons found
var buttonList = driver.FindElements(By.TagName("button"),10)
//This will wait for 10 seconds until we find at least 5 buttons
var buttonsMin= driver.FindElements(By.TagName("button"), 10, 5);
driver.Close();

पहला जवाब अच्छा है, मेरी समस्या यह थी कि अनचाहे अपवादों ने वेब ड्राइवर को सही तरीके से बंद नहीं किया और यह वही पहला मूल्य रखा जो मैंने उपयोग किया था जो 1 सेकंड था।

अगर आपको एक ही समस्या मिलती है

restart you visual studio करें और सुनिश्चित करें कि all the exceptions are handled ठीक से all the exceptions are handled सके।


मैं पहले से ही पोस्ट किए गए कई समाधान देखता हूं जो बहुत अच्छा काम करते हैं! हालांकि, अगर किसी को किसी और चीज की ज़रूरत है, तो मैंने सोचा कि मैं दो समाधान पोस्ट करूंगा जो मैंने व्यक्तिगत रूप से सेलेनियम सी # में प्रयोग किया है ताकि परीक्षण किया जा सके कि कोई तत्व मौजूद है या नहीं! उम्मीद है कि यह मदद करता है, चीयर्स!

public static class IsPresent
{
    public static bool isPresent(this IWebDriver driver, By bylocator)
    {

        bool variable = false;
        try
        {
            IWebElement element = driver.FindElement(bylocator);
            variable = element != null;
        }
       catch (NoSuchElementException){

       }
        return variable; 
    }

}

दूसरा दूसरा है

    public static class IsPresent2
{
    public static bool isPresent2(this IWebDriver driver, By bylocator)
    {
        bool variable = true; 
        try
        {
            IWebElement element = driver.FindElement(bylocator);

        }
        catch (NoSuchElementException)
        {
            variable = false; 
        }
        return variable; 
    }

}

यहां @ लॉउडेनवियर के समाधान की एक भिन्नता है जो कई तत्वों को प्राप्त करने के लिए भी काम करती है:

public static class WebDriverExtensions
{
    public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds)
    {
        if (timeoutInSeconds > 0)
        {
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => drv.FindElement(by));
        }
        return driver.FindElement(by);
    }

    public static ReadOnlyCollection<IWebElement> FindElements(this IWebDriver driver, By by, int timeoutInSeconds)
    {
        if (timeoutInSeconds > 0)
        {
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => (drv.FindElements(by).Count > 0) ? drv.FindElements(by) : null);
        }
        return driver.FindElements(by);
    }
}

यहां मेरा समाधान है, आप तत्व परिवर्तनों से पहले लंबे समय तक प्रतीक्षा नहीं करना चाहते हैं। इस कोड में वेबड्राइवर जारी रहने से पहले 2 सेकंड तक इंतजार कर रहा है।

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromMilliseconds(2000));
wait.Until(ExpectedConditions.VisibilityOfAllElementsLocatedBy(By.Name("html-name")));


वैकल्पिक रूप से आप अंतर्निहित प्रतीक्षा का उपयोग कर सकते हैं:

driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);

एक अंतर्निहित प्रतीक्षा वेबड्राइवर को एक तत्व या तत्व खोजने की कोशिश करते समय डीओएम को मतदान करने के लिए बताने के लिए बताना है यदि वे तत्काल उपलब्ध नहीं हैं। डिफ़ॉल्ट सेटिंग 0 है। सेट करने के बाद, अंतर्निहित प्रतीक्षा WebDriver ऑब्जेक्ट इंस्टेंस के जीवन के लिए सेट की गई है।


सेलेनियम में हालत के लिए इंतजार करना था, इस धागे में उतरा और यहां मैं अब उपयोग कर रहा हूं:

    WebDriverWait wait = new WebDriverWait(m_driver, TimeSpan.FromSeconds(10));
    wait.Until(d => ReadCell(row, col) != "");

ReadCell(row, col) != "" कोई शर्त हो सकती है। इस तरह से क्योंकि:

  • यह मेरा है
  • इनलाइनिंग की अनुमति देता है

माइक क्वान द्वारा प्रदान किए गए समाधान का उपयोग करने से समग्र परीक्षण प्रदर्शन में असर पड़ सकता है, क्योंकि सभी खोज निष्कर्ष कॉलों में अंतर्निहित प्रतीक्षा का उपयोग किया जाएगा। कई बार जब आप कोई तत्व मौजूद नहीं होता है तो आप FindElement को तुरंत विफल करना चाहते हैं (आप किसी विकृत पृष्ठ, अनुपलब्ध तत्वों आदि के लिए परीक्षण कर रहे हैं)। निहित प्रतीक्षा के साथ ये ऑपरेशन अपवाद फेंकने से पहले पूरे टाइमआउट की समयसीमा समाप्त होने का इंतजार करेंगे। डिफ़ॉल्ट निहित प्रतीक्षा 0 सेकंड पर सेट है।

मैंने IWebDriver को एक छोटी एक्सटेंशन विधि लिखी है जो FindElement () विधि में टाइमआउट (सेकेंड में) पैरामीटर जोड़ती है। यह काफी आत्म-व्याख्यात्मक है:

public static class WebDriverExtensions
{
    public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds)
    {
        if (timeoutInSeconds > 0)
        {
            var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
            return wait.Until(drv => drv.FindElement(by));
        }
        return driver.FindElement(by);
    }
}

मैंने WebDriverWait ऑब्जेक्ट को कैश नहीं किया क्योंकि इसकी सृजन बहुत सस्ता है, इस एक्सटेंशन का उपयोग विभिन्न वेबड्राइवर ऑब्जेक्ट्स के लिए एक साथ किया जा सकता है, और अंततः आवश्यकता होने पर मैं ऑप्टिमाइज़ेशन करता हूं।

उपयोग सीधे आगे है:

var driver = new FirefoxDriver();
driver.Navigate().GoToUrl("http://localhost/mypage");
var btn = driver.FindElement(By.CssSelector("#login_button"));
btn.Click();
var employeeLabel = driver.FindElement(By.CssSelector("#VCC_VSL"), 10);
Assert.AreEqual("Employee", employeeLabel.Text);
driver.Close();

 new WebDriverWait(driver, TimeSpan.FromSeconds(10)).
   Until(ExpectedConditions.PresenceOfAllElementsLocatedBy((By.Id("toast-container"))));

public bool doesWebElementExist(string linkexist)
{
     try
     {
        driver.FindElement(By.XPath(linkexist));
        return true;
     }
     catch (NoSuchElementException e)
     {
        return false;
     }
}




automated-tests