java - सेलेनियम वेबड्राइवर-यदि तत्व मौजूद है तो परीक्षण करें




selenium selenium-webdriver (14)

आप अपने प्रयास कैप्चर स्टेटमेंट से पहले सेलेनियम टाइमआउट को छोटा करके कोड को तेजी से चला सकते हैं।

मैं यह जांचने के लिए निम्न कोड का उपयोग करता हूं कि कोई तत्व मौजूद है या नहीं।

protected boolean isElementPresent(By selector) {
    selenium.manage().timeouts().implicitlyWait(1, TimeUnit.SECONDS);
    logger.debug("Is element present"+selector);
    boolean returnVal = true;
    try{
        selenium.findElement(selector);
    } catch (NoSuchElementException e){
        returnVal = false;
    } finally {
        selenium.manage().timeouts().implicitlyWait(15, TimeUnit.SECONDS);
    }
    return returnVal;
}

क्या कोई तत्व मौजूद है या नहीं, इसका परीक्षण करने का कोई तरीका है? कोई भी खोज विधि एक अपवाद में समाप्त हो जाएगी, लेकिन यह वही नहीं है जो मैं चाहता हूं, क्योंकि यह हो सकता है कि कोई तत्व मौजूद न हो और यह ठीक है, यह परीक्षण की विफलता नहीं है, इसलिए अपवाद समाधान नहीं हो सकता है।

मुझे यह पोस्ट मिला है: सेलेनियम सी # वेबड्राइवर: एलिमेंट मौजूद होने तक प्रतीक्षा करें लेकिन यह सी # के लिए है और मैं इसमें बहुत अच्छा नहीं हूं। क्या कोई जावा में कोड का अनुवाद कर सकता है? मुझे खेद है दोस्तों, मैंने ग्रहण में इसे आजमाया लेकिन मुझे जावा कोड में यह सही नहीं मिला।

यह कोड है:

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);
    }
}

आप निहित प्रतीक्षा का प्रयास कर सकते हैं: `

WebDriver driver = new FirefoxDriver();
driver.Manage().Timeouts().ImplicitlyWait(TimeSpan.FromSeconds(10));
driver.Url = "http://somedomain/url_that_delays_loading";
IWebElement myDynamicElement = driver.FindElement(By.Id("someDynamicElement"));

`

या आप स्पष्ट प्रतीक्षा कर सकते हैं: `

IWebDriver driver = new FirefoxDriver();
driver.Url = "http://somedomain/url_that_delays_loading";
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
IWebElement myDynamicElement = wait.Until<IWebElement>((d) =>
    {
        return d.FindElement(By.Id("someDynamicElement"));
    });

`

स्पष्ट होगा कि कुछ क्रिया से पहले तत्व मौजूद है या नहीं। कोड में हर जगह लागू प्रतीक्षा कॉल किया जा सकता है। उदाहरण के लिए कुछ AJAX कार्यों के बाद।

सेलेनियमएचक्यू पेज पर आप और अधिक देख सकते हैं: http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp


एक निजी विधि के बारे में क्या है जो केवल तत्व की तलाश करता है और यह निर्धारित करता है कि यह इस तरह मौजूद है या नहीं:

private boolean existsElement(String id) {
    try {
        driver.findElement(By.id(id));
    } catch (NoSuchElementException e) {
        return false;
    }
    return true;
}

यह काफी आसान होगा और नौकरी करता है।

संपादित करें: यदि आप आईडी के अलावा किसी अन्य चीज़ से तत्व ढूंढना चाहते हैं तो आप आगे भी जा सकते हैं और By elementLocator पैरामीटर के रूप में ले सकते हैं।


कोई विशेष तत्व ढूंढने के लिए मौजूद है या नहीं, हमें findElement () के बजाय findElements () विधि का उपयोग करना होगा।

int i=driver.findElements(By.xpath(".......")).size();
if(i=0)
System.out.println("Element is not present");
else
System.out.println("Element is present");

यह मेरे लिए काम किया है .. मुझे सुझाव है कि मैं गलत हूँ ..


जावा का उपयोग कर निम्नलिखित फ़ंक्शन / मेथोस लिखें:

protected boolean isElementPresent(By by){
        try{
            driver.findElement(by);
            return true;
        }
        catch(NoSuchElementException e){
            return false;
        }
    }

दावे के दौरान उचित पैरामीटर के साथ विधि को कॉल करें।


जावा में मैंने पाया सबसे सरल तरीका है:

List<WebElement> linkSearch=  driver.findElements(By.id("linkTag"));
int checkLink=linkSearch.size();
if(checkLink!=0){  //do something you want}

मैं कुछ ऐसा उपयोग करूंगा (स्कैला के साथ [पुराना "अच्छा" जावा 8 में कोड इस जैसा हो सकता है]):

object SeleniumFacade {

  def getElement(bySelector: By, maybeParent: Option[WebElement] = None, withIndex: Int = 0)(implicit driver: RemoteWebDriver): Option[WebElement] = {
    val elements = maybeParent match {
      case Some(parent) => parent.findElements(bySelector).asScala
      case None => driver.findElements(bySelector).asScala
    }
    if (elements.nonEmpty) {
      Try { Some(elements(withIndex)) } getOrElse None
    } else None
  }
  ...
}

तो फिर,

val maybeHeaderLink = SeleniumFacade getElement(By.xpath(".//a"), Some(someParentElement))

मैंने पाया कि यह जावा के लिए काम करता है:

WebDriverWait waiter = new WebDriverWait(driver, 5000);
waiter.until( ExpectedConditions.presenceOfElementLocated(by) );
driver.FindElement(by);

यह करना चाहिए:

try {
    driver.findElement(By.id(id));
} catch (NoSuchElementException e) {
    //do what you need here if you were expecting
    //the element wouldn't exist
}

यह जांचने के तरीके हैं कि वेब-एलिमेंट प्रतिनिधित्व है या नहीं :

मैंने XPath को एलिमेंट आइडेंटिफ़ायर / लोकेटर के रूप में उपयोग किया है, लेकिन आप अन्य लोकेटर का भी उपयोग कर सकते हैं।

समाधान I:

public boolean isElementPresent(String xpathOfElement){
    try{
        driver.findElement(By.xpath(xpathOfElement));
        return true;
    }
    catch(NoSuchElementException e){
        return false;
    }
}

समाधान II:

public boolean isElementPresent(String xpathOfElement){
    boolean isPresent = false;
    if(!driver.findElements(By.xpath(xpathOfElement)).isEmpty()){
        isPresent=true;
    }
    return isPresent;
}

समाधान III:

public boolean isElementPresent(String xpathOfElement){
    return driver.findElements(By.xpath(xpathOfElement)).size() > 0;
}

व्यक्तिगत रूप से, मैं हमेशा उपर्युक्त उत्तरों के मिश्रण के लिए जाता हूं और एक पुनः उपयोग करने योग्य स्थैतिक उपयोगिता विधि बनाता हूं जो आकार () <0 सुझाव का उपयोग करता है:

public Class Utility {
   ...
   public static boolean isElementExist(WebDriver driver, By by) {
      return driver.findElements(by).size() < 0;
   ...
}

यह साफ, पुनः उपयोग करने योग्य, रखरखाव योग्य है ... वह सब अच्छी चीजें ;-)


findElements बजाय findElements उपयोग करें।

अगर अपवाद के बजाय कोई मेल खाने वाला तत्व नहीं मिलता है तो findElements एक खाली सूची findElements

यह जांचने के लिए कि कोई तत्व मौजूद है, आप इसे आजमा सकते हैं

Boolean isPresent = driver.findElements(By.yourLocator).size() > 0

यदि यह अस्तित्व में नहीं है तो कम से कम एक तत्व पाया जाता है और झूठा यह सच हो जाएगा।


public boolean isElementFound( String text) {
        try{

            WebElement webElement = appiumDriver.findElement(By.xpath(text));
            System.out.println("isElementFound : true :"+text + "true");

        }catch(NoSuchElementException e){
            System.out.println("isElementFound : false :"+text);
            return false;
        }
        return true;
    }

public static WebElement FindElement(WebDriver driver, By by, int timeoutInSeconds)
{
    WebDriverWait wait = new WebDriverWait(driver, timeoutInSeconds);
    wait.until( ExpectedConditions.presenceOfElementLocated(by) ); //throws a timeout exception if element not present after waiting <timeoutInSeconds> seconds
    return driver.findElement(by);
}




selenium-webdriver