निहित और स्पष्ट प्रतीक्षा में Selenium सिंटैक्स के साथ

In Seleniumविश्वसनीय परीक्षणों को निष्पादित करने में "वेट" कमांड की महत्वपूर्ण भूमिका होती है। इस ट्यूटोरियल में, आप इम्प्लिसिट और एक्सप्लिसिट वेट कमांड के बीच प्रमुख पहलुओं और अंतरों के बारे में जानेंगे। Seleniumसाथ ही, फ्लुएंट वेट के व्यावहारिक उपयोग के बारे में भी बताया गया है।

हमें प्रतीक्षा की आवश्यकता क्यों है? Selenium?

अधिकांश आधुनिक वेब एप्लिकेशन का विकास निम्नलिखित का उपयोग करके किया जाता है: अजाक्स और Javaलिपिजब ब्राउज़र द्वारा कोई पेज लोड किया जाता है, तो जिन तत्वों के साथ हम इंटरैक्ट करना चाहते हैं, वे अलग-अलग समय अंतराल पर लोड हो सकते हैं।

इससे न केवल तत्व की पहचान मुश्किल हो जाती है, बल्कि यदि तत्व समय पर नहीं मिलता है, Selenium फेंक देगा एलिमेंटनॉटविजिबलएक्सेप्शन. Selenium वेट्स, वेबड्राइवर को विफल होने से पहले एक तत्व को खोजने के लिए एक निश्चित समय सीमा प्रदान करके इस सिंक्रोनाइज़ेशन समस्या का समाधान करते हैं।

एक ऐसे परिदृश्य पर विचार करें जिसमें एक ही परीक्षण में अंतर्निहित और स्पष्ट दोनों प्रकार की प्रतीक्षा का उपयोग किया जाता है। मान लीजिए कि अंतर्निहित प्रतीक्षा 20 सेकंड और स्पष्ट प्रतीक्षा 10 सेकंड पर सेट है।

यदि हम किसी ऐसे तत्व की तलाश कर रहे हैं जो कुछ निश्चित नियमों द्वारा नियंत्रित होता है अपेक्षित शर्तें (स्पष्ट प्रतीक्षा) और यदि तत्व 10 सेकंड की स्पष्ट समयसीमा के भीतर स्थित नहीं है, तो वेबड्राइवर त्रुटि उत्पन्न करने से पहले 20 सेकंड की अंतर्निहित समयसीमा पर वापस आ जाता है। एलिमेंटनॉटविजिबलएक्सेप्शन.

Selenium वेबड्राइवर प्रतीक्षा करता है

1. निहित प्रतीक्षा
2. स्पष्ट प्रतीक्षा
3. धाराप्रवाह प्रतीक्षा

निहित प्रतीक्षा Selenium

RSI निहित प्रतीक्षा Selenium यह वेबड्राइवर को NoSuchElementException देने से पहले एक निश्चित अवधि तक प्रतीक्षा करने का निर्देश देता है। डिफ़ॉल्ट मान 0 है। एक बार कॉन्फ़िगर हो जाने पर, वेबड्राइवर विफल होने से पहले उस अवधि के दौरान DOM की जाँच करता है। Selenium वेबड्राइवर ने इम्प्लिसिट वेट की अवधारणा को विरासत में प्राप्त किया। Watir.

नीचे दिए गए उदाहरण में, हम 10 सेकंड की अवधि के साथ एक अप्रत्यक्ष प्रतीक्षा घोषित करते हैं। यदि तत्व उस समय सीमा के भीतर स्थित नहीं होता है, तो एक अपवाद उत्पन्न होता है।

अंतर्निहित प्रतीक्षा सिंटैक्स (Selenium 4):

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

package guru.test99;
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;

public class AppTest {

    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        driver = new ChromeDriver();
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize the browser window
        driver.manage().window().maximize();
        // get the actual value of the title
        aTitle = driver.getTitle();
        // compare the actual title with the expected title
        if (aTitle.equals(eTitle)) {
            System.out.println("Test Passed");
        } else {
            System.out.println("Test Failed");
        }
        // close browser
        driver.close();
    }
}

का स्पष्टीकरण Code

उपरोक्त उदाहरण में, निम्नलिखित कथन पर विचार करें:

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

Selenium 4 ने पुराने दो-आर्गुमेंट सिग्नेचर (पूर्णांक प्लस टाइम यूनिट) को एक सिंगल ड्यूरेशन आर्गुमेंट से बदल दिया है। ड्यूरेशन क्लास सेकंड, मिनट, मिलीसेकंड और अन्य समय इकाइयों को ड्यूरेशन.ऑफसेकंड, ड्यूरेशन.ऑफमिलीसेकंड और ड्यूरेशन.ऑफमिनट जैसे स्टैटिक हेल्पर के माध्यम से सपोर्ट करती है।

स्पष्ट प्रतीक्षा करें Selenium

RSI स्पष्ट प्रतीक्षा करें Selenium यह वेबड्राइवर को एलिमेंटनॉटविजिबलएक्सेप्शन देने से पहले विशिष्ट स्थितियों (अपेक्षित स्थितियाँ) या अधिकतम अवधि तक प्रतीक्षा करने का निर्देश देता है। यह एक बेहतर प्रतीक्षा विधि है क्योंकि यह केवल निर्दिष्ट एलिमेंट पर लागू होती है। जब भी परीक्षण को गतिशील रूप से लोड की गई Ajax सामग्री को संभालने की आवश्यकता होती है, तो इम्प्लिसिट वेट की तुलना में एक्सप्लिसिट वेट को प्राथमिकता दी जाती है।

एक बार स्पष्ट प्रतीक्षा घोषित हो जाने के बाद, आपको इसका उपयोग करना होगा अपेक्षित शर्तेंया आप पोलिंग आवृत्ति को कॉन्फ़िगर कर सकते हैं धाराप्रवाह प्रतीक्षा. प्रयोग करने से बचें धागा.नींद()क्योंकि यह निष्पादन को बिना शर्त रोक देता है और इसे आम तौर पर एक बुरी प्रथा माना जाता है।

नीचे दिए गए उदाहरण में, हम एक संदर्भ बनाते हैं। वेबड्राइवरप्रतीक्षा करें क्लास को इंस्टैंशिएट करें वेबड्राइवर संदर्भ लें और अधिकतम 20 सेकंड की विंडो कॉन्फ़िगर करें।

स्पष्ट प्रतीक्षा सिंटैक्स (Selenium 4):

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));

package guru.test99;

import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;

public class AppTest2 {
    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize the browser window
        driver.manage().window().maximize();
        // get the actual value of the title
        aTitle = driver.getTitle();
        // compare the actual title with the expected title
        if (aTitle.contentEquals(eTitle)) {
            System.out.println("Test Passed");
        } else {
            System.out.println("Test Failed");
        }
        WebElement guru99seleniumlink;
        guru99seleniumlink = wait.until(ExpectedConditions.visibilityOfElementLocated(
            By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));
        guru99seleniumlink.click();
    }
}

का स्पष्टीकरण Code

निम्नलिखित कोड पर विचार करें:

WebElement guru99seleniumlink;
guru99seleniumlink = wait.until(ExpectedConditions.visibilityOfElementLocated(
    By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));
guru99seleniumlink.click();

इस WebDriverWait उदाहरण में, स्क्रिप्ट 20 सेकंड तक प्रतीक्षा करती है, जैसा कि परिभाषित किया गया है। वेबड्राइवरप्रतीक्षा करें कक्षा, जब तक अपेक्षित शर्तें जो भी पहले हो, संतुष्ट हैं।

ऊपर Java कोड शर्त पूरी होने तक 20 सेकंड तक प्रतीक्षा करता है। तत्व की दृश्यता स्थित सत्य होने के लिए।

निम्नलिखित अपेक्षित स्थितियों का उपयोग किया जा सकता है Selenium स्पष्ट प्रतीक्षा:

1. अलर्टइज़प्रेजेंट()
2. तत्वचयनस्थितिToBe()
3. elementToBeClickable()
4. तत्व चयनित होना चाहिए()
5. फ़्रेम उपलब्ध होना चाहिए और स्विच टू इट ()
6. तत्वस्थानकीअदृश्यता()
7. टेक्स्ट के साथतत्व की अदृश्यता()
8. उपस्थितिसभीतत्वोंकीस्थितद्वारा()
9. तत्वस्थानकीउपस्थिति()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. शीर्षकहै()
14. शीर्षकशामिल()
15. दृश्यताकी(विजिबिलिटीऑफ()
16. सभीतत्वों की दृश्यता()
17. सभीतत्वोंकीस्थितद्वारादृश्यता()
18. तत्वस्थानकीदृश्यता()

धाराप्रवाह प्रतीक्षा करें Selenium

RSI धाराप्रवाह प्रतीक्षा करें Selenium यह वेबड्राइवर द्वारा किसी स्थिति की प्रतीक्षा करने की अधिकतम अवधि और एलिमेंटनॉटविजिबलएक्सेप्शन उत्पन्न करने से पहले उस स्थिति को सत्यापित करने के लिए पोलिंग आवृत्ति को परिभाषित करता है। फ्लुएंट वेट ऑब्जेक्ट मिलने तक या टाइमआउट समाप्त होने तक नियमित अंतराल पर एलिमेंट की जाँच करता है।

आवृत्ति: नियमित अंतराल पर स्थिति का मूल्यांकन करने के लिए इस चक्र को दोहराया जाता है।

एक ऐसी स्थिति पर विचार करें जहां कोई एलिमेंट अनिश्चित अंतराल पर लोड होता है। एलिमेंट को लोड होने में 10 सेकंड, 20 सेकंड या उससे अधिक समय लग सकता है। यदि हम 20 सेकंड का स्पष्ट वेट टाइम निर्धारित करते हैं, तो स्क्रिप्ट विफल होने से पहले पूरी अवधि तक प्रतीक्षा करेगी। ऐसे मामलों में, फ़्लूएंट वेट सबसे उपयुक्त विकल्प है क्योंकि यह एलिमेंट के मिलने या अंतिम टाइमर समाप्त होने तक निर्दिष्ट आवृत्ति पर पोलिंग करता रहता है।

फ़्लूएंट वेट सिंटैक्स (Selenium 4):

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

पूर्णांक मानों के साथ-साथ टाइम यूनिट स्वीकार करने वाले पुराने हस्ताक्षर को अप्रचलित कर दिया गया था। Selenium 3.11 और हटा दिया गया Selenium 4. ऊपर दिखाया गया अवधि-आधारित एपीआई वर्तमान में अनुशंसित दृष्टिकोण है।

package guru.test99;

import java.time.Duration;
import java.util.NoSuchElementException;
import java.util.function.Function;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.testng.annotations.Test;

public class AppTest3 {
    protected WebDriver driver;

    @Test
    public void guru99tutorials() throws InterruptedException {
        String eTitle = "Demo Guru99 Page";
        String aTitle = "";
        driver = new ChromeDriver();
        // launch Chrome and redirect it to the Base URL
        driver.get("https://demo.guru99.com/test/guru99home/");
        // Maximize the browser window
        driver.manage().window().maximize();
        // get the actual value of the title
        aTitle = driver.getTitle();
        // compare the actual title with the expected title
        if (aTitle.contentEquals(eTitle)) {
            System.out.println("Test Passed");
        } else {
            System.out.println("Test Failed");
        }

        Wait<WebDriver> wait = new FluentWait<>(driver)
            .withTimeout(Duration.ofSeconds(30))
            .pollingEvery(Duration.ofSeconds(5))
            .ignoring(NoSuchElementException.class);

        WebElement clickseleniumlink = wait.until(new Function<WebDriver, WebElement>() {
            public WebElement apply(WebDriver driver) {
                return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));
            }
        });
        // click on the selenium link
        clickseleniumlink.click();
        // close browser
        driver.close();
    }
}

का स्पष्टीकरण Code

निम्नलिखित कोड पर विचार करें:

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))
    .pollingEvery(Duration.ofSeconds(5))
    .ignoring(NoSuchElementException.class);

ऊपर दिए गए उदाहरण में, हम 30 सेकंड के टाइमआउट, 5 सेकंड की पोलिंग फ़्रीक्वेंसी और अनदेखी के साथ एक फ़्लूएंट वेट घोषित करते हैं। कोई ऐसाएलिमेंटएक्सेप्शन नहीं.

निम्नलिखित कोड पर विचार करें:

public WebElement apply(WebDriver driver) {
    return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));
}

यह फ़ंक्शन पृष्ठ पर वेबएलिमेंट की पहचान करता है (यहाँ, Selenium होमपेज पर लिंक)। 5 सेकंड के पोलिंग अंतराल और 30 सेकंड के टाइमआउट के साथ, प्रतीक्षा प्रक्रिया अधिकतम 30 सेकंड तक हर 5 सेकंड में एलिमेंट की जाँच करती है। यदि एलिमेंट उस समय सीमा के भीतर मौजूद है, तो स्क्रिप्ट आगे बढ़ती है। अन्यथा, एक एलिमेंटनॉटविजिबलएक्सेप्शन फेंका जाता है.

इसके अलावा चेक करें: Selenium शुरुआती लोगों के लिए IDE ट्यूटोरियल

निहित प्रतीक्षा बनाम स्पष्ट प्रतीक्षा के बीच अंतर

नीचे दी गई तालिका इम्प्लिसिट वेट और एक्सप्लिसिट वेट के बीच प्रमुख अंतरों को दर्शाती है। Selenium.

निहित प्रतीक्षा	स्पष्ट प्रतीक्षा
स्क्रिप्ट के सभी तत्वों पर अंतर्निहित प्रतीक्षा समय लागू होता है।	स्पष्ट प्रतीक्षा समय केवल विशेष रूप से लक्षित तत्वों पर ही लागू होता है।
इम्प्लिसिट वेट में, एलिमेंट के लिए एक्सपेक्टेड कंडीशंस निर्दिष्ट नहीं की जाती हैं।	एक्सप्लिसिट वेट में, एलिमेंट के लिए एक्सपेक्टेड कंडीशंस को परिभाषित किया जाना चाहिए।
कॉन्फ़िगर किए गए अप्रत्यक्ष प्रतीक्षा विंडो के भीतर तत्वों के लोड होने पर इसकी अनुशंसा की जाती है।	यह तब अनुशंसित है जब तत्वों को लोड होने में अधिक समय लगता है और जब तत्वों की स्थिति जैसे कि visibilityOfElementLocated, elementToBeClickable, या elementToBeSelected को मान्य किया जा रहा हो।
इसे एक बार सेट किया जाता है और वेबड्राइवर इंस्टेंस के जीवनचक्र के लिए लागू किया जाता है।	प्रत्येक तत्व या प्रत्येक जांच के लिए अलग-अलग सेटिंग करें, जिससे बेहतर नियंत्रण मिलता है।

सही प्रतीक्षा रणनीति कैसे चुनें

सही प्रतीक्षा कमांड का चयन स्क्रिप्ट की स्थिरता और निष्पादन समय को सीधे प्रभावित करता है। प्रत्येक परिदृश्य के लिए उपयुक्त विकल्प चुनने के लिए इस निर्णय ढांचे का उपयोग करें।

1. लोड पैटर्न की पहचान करें: जांचें कि एलिमेंट Ajax रिस्पॉन्स के बाद एक निश्चित समय पर दिखाई देता है या अप्रत्याशित अंतराल पर। निश्चित लोड के लिए इम्प्लिसिट वेट उपयुक्त है, जबकि अप्रत्याशित लोड के लिए फ्लुएंट वेट का उपयोग किया जाता है।
2. इम्प्लिसिट और एक्सप्लिसिट वेट्स को आपस में मिलाने से बचें: दोनों को मिलाने से अप्रत्याशित देरी हो सकती है क्योंकि अधिक प्रतीक्षा अवधि हावी हो सकती है। Selenium दस्तावेज़ में प्रति वेबड्राइवर सत्र केवल एक ही रणनीति का उपयोग करने की अनुशंसा की गई है।
3. गतिशील सामग्री के लिए डिफ़ॉल्ट रूप से स्पष्ट प्रतीक्षा करें: जब पेज Ajax, कंडीशनल रेंडरिंग या एनिमेशन पर निर्भर करते हैं, तो Explicit Wait with ExpectedConditions ठीक उसी एलिमेंट को टारगेट करता है जो मायने रखता है।
4. परिवर्तनीय समय निर्धारण के लिए फ़्लूएंट वेट का उपयोग करें: जब एलिमेंट लोड होने का समय अलग-अलग रन में बदलता रहता है, तो फ्लुएंट वेट को पोलिंग अंतराल के साथ कॉन्फ़िगर करें। पोलिंग से एक लंबे टाइमआउट की तुलना में कुल प्रतीक्षा समय कम हो जाता है।
5. Thread.sleep को बदलें: हार्डकोडेड स्लीप टेस्ट सूट को धीमा कर देते हैं और वास्तविक टाइमिंग समस्याओं को छिपा देते हैं। निष्पादन को तेज़ और निश्चित बनाए रखने के लिए इन्हें कंडीशनल वेट से बदलें।
6. ट्यून टाइमआउट मान: शुरुआत में कम समय अंतराल (5-10 सेकंड) रखें और विफलताओं के कारण वास्तविक धीमी लोडिंग होने पर ही इसे बढ़ाएं। लंबे डिफ़ॉल्ट समय अंतराल प्रदर्शन में गिरावट को छिपा देते हैं।
7. सहायक उपयोगिताओं में प्रतीक्षा रखें: प्रतीक्षा तर्क को एक सहायक वर्ग में केंद्रीकृत करें ताकि टाइमआउट नीति में किए गए परिवर्तन संपूर्ण परीक्षण सूट पर लागू हों।

इस ढांचे का पालन करके, स्वचालन इंजीनियर ऐसे लचीले स्क्रिप्ट बना सकते हैं जो धीमे या कमजोर हुए बिना वास्तविक अनुप्रयोग समय के अनुकूल हो जाते हैं।

इन सामान्य गलतियों से बचें Selenium वेट्स

अनुभवी परीक्षक भी काम करते समय कुछ चुनिंदा गलतियों का शिकार हो जाते हैं। Selenium प्रतीक्षा की समस्या से बचने से स्क्रिप्ट तेज, निश्चित और टीमों और वातावरणों में बनाए रखने में आसान रहती हैं।

पहली आम गलती Thread.sleep का ज़रूरत से ज़्यादा इस्तेमाल करना है। हार्डकोडेड पॉज़ स्क्रिप्ट को एलिमेंट की उपलब्धता की परवाह किए बिना पूरी अवधि तक इंतज़ार करने के लिए मजबूर करता है, जिससे कुल रन टाइम बढ़ जाता है। ऐसे पॉज़ को Explicit या Fluent Wait से बदलें ताकि स्क्रिप्ट शर्त पूरी होते ही आगे बढ़ जाए।

दूसरी गलती है इम्प्लिसिट और एक्सप्लिसिट वेट्स को एक ही टेस्ट में मिलाना। ये दोनों मैकेनिज्म मिलकर अप्रत्याशित टाइमआउट उत्पन्न कर सकते हैं, जिन्हें डीबग करना मुश्किल होता है। प्रत्येक वेबड्राइवर सेशन के लिए एक ही रणनीति चुनें और उसे लगातार लागू करें।

तीसरी गलती है "सिर्फ एहतियात के तौर पर" टाइमआउट को बहुत ज़्यादा सेट करना। लंबे डिफ़ॉल्ट टाइमआउट वास्तविक प्रदर्शन समस्याओं को छिपा देते हैं और निरंतर एकीकरण पाइपलाइनों में फ़ीडबैक को धीमा कर देते हैं। कम टाइमआउट से शुरुआत करें और उन्हें तभी बढ़ाएँ जब विफलता लॉग से पता चले कि वास्तव में कोई समय संबंधी समस्या मौजूद है।

इसके अलावा चेक करें: Selenium शुरुआती लोगों के लिए ट्यूटोरियल: 7 दिनों में वेबड्राइवर सीखें

अक्सर पूछे जाने वाले प्रश्न