Menunggu secara Implisit dan Eksplisit Selenium dengan Sintaksis

In SeleniumPerintah “Wait” memainkan peran penting dalam menjalankan pengujian yang andal. Dalam tutorial ini, Anda akan mempelajari aspek-aspek kunci dan perbedaan antara perintah Wait Implisit dan Eksplisit. Selenium, beserta penggunaan Fluent Wait secara praktis.

Mengapa Kita Perlu Menunggu Selenium?

Sebagian besar aplikasi web modern dikembangkan menggunakan Ajax ke JavaNaskahSaat sebuah halaman dimuat oleh browser, elemen-elemen yang ingin kita interaksi mungkin dimuat dalam interval waktu yang berbeda.

Hal ini tidak hanya mempersulit identifikasi unsur, tetapi jika unsur tersebut tidak ditemukan tepat waktu, Selenium akan melempar ElementNotVisibleException. Selenium Wait mengatasi masalah sinkronisasi ini dengan memberikan WebDriver jendela waktu yang ditentukan untuk menemukan elemen sebelum gagal.

Pertimbangkan skenario di mana penantian implisit dan eksplisit digunakan dalam pengujian yang sama. Asumsikan penantian implisit diatur ke 20 detik dan penantian eksplisit diatur ke 10 detik.

Jika kita mencari elemen yang diatur oleh hal-hal tertentu Kondisi yang Diharapkan (Explicit Wait) dan elemen tersebut tidak ditemukan dalam jendela eksplisit 10 detik, WebDriver akan kembali ke jendela implisit 20 detik sebelum melempar pengecualian. ElementNotVisibleException.

Selenium WebDriver Menunggu

1. Penantian Tersirat
2. Penantian Eksplisit
3. Penantian Lancar

Tunggu secara implisit Selenium

The Tunggu secara implisit Selenium Menginstruksikan WebDriver untuk menunggu selama durasi yang ditentukan sebelum melempar NoSuchElementException. Nilai defaultnya adalah 0. Setelah dikonfigurasi, WebDriver akan melakukan polling DOM selama durasi tersebut sebelum gagal. Selenium WebDriver mewarisi konsep implicit wait dari Watir.

Pada contoh di bawah ini, kita mendeklarasikan penantian implisit dengan durasi 10 detik. Jika elemen tidak ditemukan dalam rentang waktu tersebut, akan muncul pengecualian.

Sintaks Tunggu Implisit (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();
    }
}

penjelasan dari Code

Pada contoh di atas, perhatikan pernyataan berikut:

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

Selenium Versi 4 menggantikan tanda tangan dua argumen lama (integer ditambah TimeUnit) dengan satu argumen Duration. Kelas Duration mendukung detik, menit, milidetik, dan satuan waktu lainnya melalui fungsi pembantu statis seperti Duration.ofSeconds, Duration.ofMillis, dan Duration.ofMinutes.

Tunggu Eksplisit Selenium

The Tunggu Eksplisit Selenium Perintah ini menginstruksikan WebDriver untuk menunggu kondisi tertentu (Expected Conditions) atau durasi maksimum sebelum melempar ElementNotVisibleException. Ini adalah penantian yang lebih cerdas karena hanya berlaku untuk elemen yang ditentukan. Explicit Wait lebih disukai daripada Implicit Wait setiap kali pengujian perlu menangani konten Ajax yang dimuat secara dinamis.

Setelah penundaan eksplisit dideklarasikan, Anda harus menggunakannya. Kondisi yang Diharapkan, atau Anda dapat mengkonfigurasi frekuensi polling menggunakan Penantian LancarHindari penggunaan Utas.tidur(), karena hal itu menghentikan eksekusi tanpa syarat dan umumnya dianggap sebagai praktik yang buruk.

Pada contoh di bawah ini, kita membuat referensi dari WebDriverTunggu kelas, buat instance-nya dengan webdriver referensi, dan konfigurasikan jendela maksimum 20 detik.

Sintaks Tunggu Eksplisit (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();
    }
}

penjelasan dari Code

Perhatikan kode berikut:

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

Dalam contoh WebDriverWait ini, skrip menunggu hingga 20 detik, seperti yang didefinisikan oleh WebDriverTunggu kelas, sampai Kondisi yang Diharapkan terpenuhi — mana pun yang terjadi lebih dulu.

Atas Java Kode tersebut menunggu hingga 20 detik untuk kondisi tersebut. visibilitasElemenTerletak untuk menjadi kenyataan.

Kondisi yang Diharapkan berikut ini dapat digunakan dalam Selenium Tunggu Eksplisit:

1. peringatanIsPresent()
2. elemenSelectionStateToBe()
3. elemenToBeClickable()
4. elemenToBeSelected()
5. frameToBeAvailableAndSwitchToIt()
6. tembus pandangOfTheElementLocated()
7. tembus pandangElemenDenganTeks()
8. kehadiranSemuaElementsLocatedBy()
9. kehadiranElementLocated()
10. textToBePresentInElement()
11. textToBePresentInElementLocated()
12. textToBePresentInElementValue()
13. judulIs()
14. judulBerisi()
15. visibilitas()
16. visibilitasSemuaElemen()
17. visibilitasSemuaElementsLocatedBy()
18. visibilitasOfElementLocated()

Lancar Tunggu masuk Selenium

The Lancar Tunggu masuk Selenium Menentukan durasi maksimum bagi WebDriver untuk menunggu suatu kondisi, beserta frekuensi polling untuk memverifikasi kondisi tersebut sebelum melempar ElementNotVisibleException. Fluent Wait memeriksa elemen secara berkala hingga objek ditemukan atau waktu habis.

Frekuensi: Siklus berulang untuk mengevaluasi kondisi secara berkala.

Pertimbangkan skenario di mana sebuah elemen dimuat pada interval yang tidak dapat diprediksi. Elemen tersebut mungkin dimuat dalam 10 detik, 20 detik, atau lebih lama. Jika kita menetapkan waktu tunggu eksplisit selama 20 detik, skrip akan menunggu selama durasi penuh sebelum gagal. Dalam kasus seperti itu, Fluent Wait adalah pilihan yang ideal karena ia melakukan polling pada frekuensi yang ditentukan hingga elemen ditemukan atau timer terakhir berakhir.

Sintaks Tunggu Lancar (Selenium 4):

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

Tanda tangan lama yang menerima nilai integer ditambah TimeUnit telah usang pada Selenium 3.11 dan dihapus di Selenium 4. API berbasis Durasi yang ditunjukkan di atas adalah pendekatan yang direkomendasikan saat ini.

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

penjelasan dari Code

Perhatikan kode berikut:

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

Pada contoh di atas, kita mendeklarasikan Fluent Wait dengan batas waktu 30 detik, frekuensi polling 5 detik, dan mengabaikan Tidak Ada Pengecualian Elemen Seperti Itu.

Perhatikan kode berikut:

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

Fungsi ini mengidentifikasi WebElement pada halaman (di sini, Selenium (tautan di halaman beranda). Dengan interval polling 5 detik dan batas waktu 30 detik, fungsi tunggu memeriksa elemen setiap 5 detik selama maksimal 30 detik. Jika elemen ditemukan dalam rentang waktu tersebut, skrip akan dilanjutkan. Jika tidak, akan terjadi kesalahan. ElementNotVisibleException dilempar.

Juga Periksa: Selenium Tutorial IDE untuk Pemula

Perbedaan Antara Tunggu Implisit Vs Tunggu Eksplisit

Tabel di bawah ini menyoroti perbedaan utama antara Implicit Wait dan Explicit Wait dalam Selenium.

Penantian Tersirat	Penantian Eksplisit
Waktu tunggu implisit diterapkan pada semua elemen dalam skrip.	Waktu tunggu eksplisit hanya diterapkan pada elemen yang ditargetkan secara spesifik.
Dalam Implicit Wait, ExpectedConditions tidak ditentukan untuk elemen tersebut.	Dalam Explicit Wait, ExpectedConditions harus didefinisikan untuk elemen tersebut.
Disarankan untuk menggunakannya saat elemen dimuat dalam jendela tunggu implisit yang telah dikonfigurasi.	Disarankan digunakan ketika elemen membutuhkan waktu lebih lama untuk dimuat dan ketika memvalidasi status elemen seperti visibilityOfElementLocated, elementToBeClickable, atau elementToBeSelected.
Ditetapkan sekali dan diterapkan untuk siklus hidup instance WebDriver.	Tetapkan per elemen atau per pemeriksaan, memberikan kontrol yang lebih baik.

Cara Memilih Strategi Menunggu yang Tepat

Memilih perintah tunggu yang tepat secara langsung memengaruhi stabilitas skrip dan waktu eksekusi. Gunakan kerangka kerja pengambilan keputusan ini untuk memilih opsi yang sesuai untuk setiap skenario.

1. Identifikasi pola beban: Periksa apakah elemen tersebut muncul pada waktu tetap, setelah respons Ajax, atau pada interval yang tidak dapat diprediksi. Beban tetap cocok untuk Implicit Wait, sedangkan beban yang tidak dapat diprediksi memerlukan Fluent Wait.
2. Hindari mencampur Implicit Wait dan Explicit Wait: Menggabungkan keduanya dapat menyebabkan penundaan yang tidak terduga karena waktu tunggu yang lebih lama mungkin akan lebih dominan. Selenium Dokumentasi merekomendasikan hanya menggunakan satu strategi per sesi WebDriver.
3. Secara default, tunggu secara eksplisit untuk konten dinamis: Ketika halaman bergantung pada Ajax, rendering bersyarat, atau animasi, Explicit Wait dengan ExpectedConditions akan menargetkan elemen yang tepat yang relevan.
4. Gunakan Fluent Wait untuk pengaturan waktu variabel: Jika waktu pemuatan elemen bervariasi antar proses, konfigurasikan Fluent Wait dengan interval polling. Polling mengurangi total waktu tunggu dibandingkan dengan waktu tunggu tunggal yang lama.
5. Ganti Thread.sleep: Penggunaan perintah `sleep` secara langsung (hardcoded) memperlambat rangkaian pengujian dan menyembunyikan masalah waktu yang sebenarnya. Gantikan dengan `conditional wait` untuk menjaga eksekusi tetap cepat dan deterministik.
6. Sesuaikan nilai batas waktu: Mulailah dengan waktu tunggu yang singkat (5–10 detik) dan tingkatkan hanya jika kegagalan menunjukkan beban yang benar-benar lambat. Waktu tunggu default yang lama menutupi penurunan kinerja.
7. Pertahankan waktu tunggu di utilitas pembantu: Pusatkan logika tunggu dalam kelas pembantu sehingga perubahan kebijakan batas waktu berlaku di seluruh rangkaian pengujian.

Dengan mengikuti kerangka kerja ini, para insinyur otomatisasi dapat membangun skrip yang tangguh yang beradaptasi dengan waktu aplikasi sebenarnya tanpa menjadi lambat atau rapuh.

Kesalahan Umum yang Harus Dihindari Selenium Menunggu

Bahkan penguji berpengalaman pun bisa terjebak dalam beberapa jebakan berulang saat bekerja dengan... Selenium Menunggu. Menghindari masalah ini membuat skrip tetap cepat, deterministik, dan mudah dipelihara di berbagai tim dan lingkungan.

Kesalahan umum pertama adalah penggunaan Thread.sleep yang berlebihan. Jeda yang dikodekan secara permanen memaksa skrip untuk menunggu selama durasi penuh terlepas dari ketersediaan elemen yang sebenarnya, yang meningkatkan total waktu eksekusi. Ganti jeda tersebut dengan Explicit atau Fluent Wait sehingga skrip berjalan segera setelah kondisi terpenuhi.

Kesalahan kedua adalah mencampur Implicit Wait dan Explicit Wait dalam pengujian yang sama. Kedua mekanisme tersebut dapat saling melengkapi, menciptakan waktu tunggu yang tidak terduga dan sulit untuk di-debug. Pilih satu strategi per sesi WebDriver dan terapkan secara konsisten.

Kesalahan ketiga adalah menetapkan batas waktu terlalu tinggi "hanya untuk berjaga-jaga." Jendela waktu default yang panjang menyembunyikan masalah kinerja yang sebenarnya dan memperlambat umpan balik dalam pipeline integrasi berkelanjutan. Mulailah dengan batas waktu yang singkat dan perpanjang hanya ketika log kegagalan membuktikan adanya masalah waktu yang nyata.

Juga Periksa: Selenium Tutorial untuk Pemula: Pelajari WebDriver dalam 7 Hari

Pertanyaan Umum Demo Slot