সরাসরি পর্বে যান
পর্ব ৩৮ · ৮২-এর মধ্যে · মডিউল ৬

Selenium WebDriver — wait, browser driver আর Grid

Selenium WebDriver — Waits, Browser Drivers and Grid

Taught in Bangla, this lesson explains the W3C WebDriver protocol, where each Selenium command is an HTTP request to a driver such as msedgedriver. It uses Selenium 4.52 with Selenium Manager, By locators and pytest fixtures. Real runs on the Bazarghar demo shop show a badge read too early returning '0', an explicit wait succeeding in 0.45 seconds, and mixed implicit and explicit waits stretching a 2 second wait to 5. Alerts, tabs, iframes, stale elements, Grid and an honest Playwright comparison follow.

এই পর্বে যা শিখবেন

  • WebDriver protocol কীভাবে কাজ করে: একটি click-এর পেছনে কোন HTTP request আর কোন উত্তর যায়, আর BiDi কেন আসছে
  • Selenium 4-এর Python API, Selenium Manager, By দিয়ে element খোঁজা আর pytest-এর fixture-এ driver সাজানো
  • Implicit wait আর explicit wait-এর পার্থক্য, আর দুটি মেশালে অপেক্ষার সময় কেন অপ্রত্যাশিতভাবে বাড়ে
  • Alert, নতুন tab, iframe আর stale element সামলানো; Selenium Grid-এর গঠন
  • Selenium আর Playwright-এর সৎ তুলনা, আর AI-এর লেখা Selenium test যাচাইয়ের চেকলিস্ট

১ · Selenium কী, আর এখনো কেন শেখা দরকার

রিকশাওয়ালাকে আপনি বলেন “ডানে যান, এখানে থামুন”। আপনি নিজে প্যাডেল চালান না, শুধু নির্দেশ দেন; রিকশা চালানোর কৌশল তাঁর। Selenium ঠিক এই সম্পর্ক তৈরি করে: আপনার test নির্দেশ দেয় “এই পাতা খোলা, এই button চাপা, এই লেখা পড়া”, আর browser নিজে সেটি করে। মাঝখানের নির্দেশের ভাষাটির নাম WebDriver.

এই মডিউলের আগের পর্বগুলোতে (পর্ব ৩৬ আর পর্ব ৩৭, Playwright) একই কাজ Playwright দিয়ে দেখা হয়েছে। তাহলে Selenium কেন? তিনটি বাস্তব কারণ। প্রথমত, বহু প্রতিষ্ঠানে বছরের পর বছর ধরে লেখা হাজার হাজার Selenium test চলছে; সেগুলো রক্ষণাবেক্ষণ করা, বাড়ানো আর ধীরে ধীরে নতুন tool-এ নেওয়া একজন automation tester বা SDET-এর দৈনন্দিন কাজ। দ্বিতীয়ত, WebDriver একটি W3C মানদণ্ড, যা browser-নির্মাতারা নিজেরাই বাস্তবায়ন করেন; mobile-এর Appium-ও (পর্ব ৬৯) একই protocol-এর ওপর দাঁড়ানো। তৃতীয়ত, ইন্টারভিউতে “implicit আর explicit wait-এর পার্থক্য কী” প্রশ্নটি এখনো সবচেয়ে চেনা প্রশ্নগুলোর একটি।

এই পর্বের সব test চলবে কোর্সের নিজস্ব বাজারঘর app-এ, নিজের কম্পিউটারে, 127.0.0.1-এ। কাজটি পর্ব ৩৬-এর মতোই: মিতু login করে সয়াবিন তেলের পাতায় যান, “কার্টে যোগ করুন” চাপেন, আর ওপরের cart badge ০ থেকে ১ হয়। শর্ত একটাই, badge বদলায় ৪০০ ms দেরিতে: app-এর JavaScript আগে fetch দিয়ে server-এ যোগ করে, তারপর ইচ্ছাকৃত বিরতি দিয়ে badge আর একটি toast বার্তা দেখায়। Element খোঁজার কৌশল (CSS selector, XPath, data-testid) পর্ব ৩৫-এর বিষয়; এখানে শুধু Selenium-এ সেগুলো কীভাবে লিখতে হয়, তা দেখব। HTML-এর selector ভুলে গেলে HTML ও CSS কোর্সের পর্ব ১৭ দেখে নিন।

২০০৪ সালে ThoughtWorks-এ Jason Huggins একটি ভেতরের app পরীক্ষার জন্য JavaScript-এ একটি test runner লেখেন, যা পরে Selenium নামে পরিচিত হয়। প্রচলিত গল্প বলে, নামটি তখনকার একটি বাণিজ্যিক test tool-কে নিয়ে মজা থেকে এসেছিল (selenium বা সেলেনিয়াম পারদের বিষক্রিয়ার একটি প্রতিষেধক হিসেবে পরিচিত); গল্পটি বহুল প্রচারিত, তবে একে নিশ্চিত ইতিহাস না ভাবাই ভালো। প্রায় একই সময়ে Simon Stewart শুরু করেন WebDriver, যা browser-এর ভেতরে JavaScript ঢুকিয়ে নয়, browser-কে বাইরে থেকে সরাসরি চালাত। ২০১১ সালে Selenium 2-এ দুটি প্রকল্প এক হয়। ২০১৮ সালের জুনে W3C WebDriver মানদণ্ড Recommendation হয়, আর ২০২১ সালের অক্টোবরে আসে Selenium 4, যা পুরোপুরি এই W3C protocol-এ চলে।

২ · WebDriver protocol — একটি click-এর পেছনে কী ঘটে

WebDriver-এর মূল চিন্তা সহজ। প্রতিটি browser-এর জন্য একটি আলাদা ছোট program থাকে, যার নাম browser driver: Edge-এর msedgedriver, Chrome-এর chromedriver, Firefox-এর geckodriver, Safari-র safaridriver. Driver নিজের কম্পিউটারে একটি ছোট HTTP server চালায়। আপনার Selenium client (Python, Java, C# বা অন্য ভাষার library) সেই server-এ সাধারণ HTTP request পাঠায়, body-তে JSON. প্রতিটি কাজের একটি নির্দিষ্ট ঠিকানা: নতুন session খুলতে POST /session, পাতা খুলতে POST /session/{id}/url, element খুঁজতে POST /session/{id}/element, click করতে POST /session/{id}/element/{eid}/click. HTTP-র method আর status code নিয়ে পর্ব ২৯-এ বিস্তারিত আছে।

WebDriver-এর পথ: test থেকে browser

pytest + Selenium → HTTP/JSON (W3C WebDriver) → msedgedriver → Edge → বাজারঘর; Grid আর BiDi বিকল্প পথ

pytest → Selenium client → HTTP/JSON → msedgedriver → Edge → বাজারঘর; বিকল্প: Grid; BiDi WebSocket pytest + Selenium 4 driver.find_element(...) .click() · WebDriverWait HTTP + JSON W3C WebDriver msedgedriver localhost-এ ছোট server Selenium Manager আনে Grid বিকল্প পথ Router → Distributor → Node-এ driver আর browser port 4444 Edge (headless) ক্লিক, টাইপ, পড়া পাতার JS নিজের মতো বাজারঘর app 127.0.0.1 · শুধু নিজের কম্পিউটারে WebDriver BiDi WebSocket · দুই দিকেই বার্তা browser নিজে জানায়: console, network
ছবি ৩৮.১ — প্রতিটি Selenium command একটি HTTP request. Driver browser-কে চালায়, কিন্তু পাতার JavaScript কখন কাজ শেষ করবে, তা জানে না। Grid একই protocol বহু মেশিনে ছড়িয়ে দেয়, আর BiDi browser-কে নিজে থেকে কথা বলার পথ দেয়।

কথাটি তত্ত্বে না রেখে চোখে দেখা যাক। Selenium-এর Python client-এর ভেতরের log চালু করলে প্রতিটি request আর উত্তর ছাপা হয়। বাজারঘরের তেলের পাতায় button খোঁজা আর click করার সত্যিকারের log (Selenium 4.52.0, Edge 157; session id আর element id ছোট করা, port আর পূর্ণ id প্রতিবার বদলায়) নিচের stepper-এ এক ধাপ করে দেখুন:

  1. Testfind_elementPython
  2. DrivermsedgedriverHTTP server
  3. EdgeDOMআসল browser
  4. পাতার JSfetch + 400 msনিজের সময়ে
HTTP-তে যা গেল আর এলো
request
response
Python পেল
  1. Test-এর এক লাইন। driver.find_element(By.CSS_SELECTOR, "[data-testid='add-to-cart']"). Python-এর কাছে এটি একটি function call; ভেতরে Selenium এটিকে একটি HTTP request-এ বদলাবে।
  2. Request গেল driver-এ। Log-এ লাইনটি: POST http://localhost:2256/session/98c5…/element, body-তে using আর value. Port 2256 এই run-এ driver নিজে বেছে নিয়েছিল। Session id প্রতিটি browser খোলার সময় নতুন হয়।
  3. Driver browser-এ খুঁজে উত্তর দিল। status=200, আর body-তে একটি অদ্ভুত key: element-6066-11e4-a52e-4f735466cecf. এটি W3C মানদণ্ডে স্থির করা “web element identifier”; মানটি (f.CFBB…e.6) ওই পাতায় ওই element-এর একটি হাতল। Python পেল একটি WebElement object, যার ভেতরে শুধু এই id.
  4. Click-ও একটি request. btn.click() পাঠাল POST …/element/f.CFBB…e.6/click, body ফাঁকা {}. খেয়াল করুন, element আবার খোঁজা হয়নি; আগের id-ই ব্যবহার হলো। পাতা বদলে গেলে এই id অচল হয়, যার নাম stale element (§৬)।
  5. Driver click করল, উত্তর {value: null}. মানদণ্ড অনুযায়ী driver element-টিকে দৃশ্যমান জায়গায় আনে, দেখে অন্য কিছু ওপরে ঢেকে আছে কি না (ঢাকা থাকলে element click intercepted), তারপর mouse-এর ঘটনা পাঠায়। উত্তর 200, value null: “click করেছি”, এর বেশি কিছু নয়।
  6. এরপর পাতার JavaScript নিজের সময়ে চলে। Click-এর ঘটনায় বাজারঘরের JS fetch পাঠায়, উত্তর আসে, তারপর ৪০০ ms বিরতি দিয়ে badge “1” করে। WebDriver এই কাজের কথা জানে না, কারণ এটি পাতার নিজের ব্যাপার। Python ততক্ষণে পরের লাইনে চলে গেছে। এই পর্বের বাকি সব কিছু এই এক ফাঁক থেকে জন্মায়।

BiDi: browser-এর দিক থেকেও কথা

পুরোনো WebDriver একমুখী: test জিজ্ঞেস করে, browser উত্তর দেয়। কিন্তু console-এ কোনো error এলো কি না, কোন network request গেল, এমন ঘটনা browser নিজে থেকে জানাতে পারে না; test-কে বারবার জিজ্ঞেস করতে হয়। Chrome-এর DevTools Protocol (CDP) এই দুই-মুখী কাজ বহু বছর ধরে করে, কিন্তু সেটি একটি browser-এর নিজস্ব। WebDriver BiDi হলো W3C-তে এখনো তৈরি হতে থাকা নতুন মানদণ্ড, যা WebSocket-এর ওপর দুই দিকেই বার্তা চালায়, সব browser-এর জন্য এক নিয়মে। Selenium 4-এ এটি ধাপে ধাপে যুক্ত হচ্ছে; §৬-এ একটি ছোট সত্যিকারের উদাহরণ দেখবেন।

৩ · Selenium 4 Python API, Selenium Manager আর By

নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো হয়েছে: Selenium 4.52.0 (Apache-2.0 লাইসেন্স), pytest 9.2.0 (MIT), Python 3.12, আর আগে থেকে ইনস্টল করা Microsoft Edge 157, headless অবস্থায়। Driver msedgedriver 157.0.4341.60, যা Microsoft নিজের শর্তে বিনামূল্যে দেয়। Path নিরপেক্ষ করা।

# টার্মিনাল ১: বাজারঘর app, test mode, নতুন seed
cd bazarghar
BAZARGHAR_TEST_MODE=1 uv run bazarghar --port 8794 --test-mode --reset

# টার্মিনাল ২: UI test প্রকল্প
mkdir bazarghar-ui-tests && cd bazarghar-ui-tests
uv init --vcs none --author-from none
uv add selenium pytest
export SE_AVOID_STATS=true             # Selenium Manager-এর usage পরিসংখ্যান বন্ধ
export SE_CACHE_PATH=~/bazarghar-ui-tests/se-cache   # driver কোথায় থাকবে
BAZARGHAR_URL=http://127.0.0.1:8794 uv run pytest -v

এখানে Selenium Manager-এর কথা বলা দরকার। আগে Selenium-এ test লেখার প্রথম ঝামেলা ছিল driver: browser আপডেট হলো, driver পুরোনো রইল, আর test-এ এলো “this version of driver only supports version …” ধরনের বার্তা। Selenium 4.6 (২০২২-এর শেষ দিক) থেকে client-এর সাথে Rust-এ লেখা একটি ছোট program আসে, যা প্রথম run-এ ইনস্টল করা browser-এর version দেখে, মানানসই driver নামায় আর cache-এ রাখে। আমাদের run-এ cache-এর se-metadata.json-এ লেখা ছিল "driver_name": "msedgedriver", "driver_version": "157.0.4341.60". ডিফল্ট cache থাকে ব্যবহারকারীর home-এর .cache/selenium-এ; SE_CACHE_PATH দিয়ে প্রকল্পের ভেতরে রাখলে পরিষ্কার করা সহজ। আর ডিফল্টভাবে Selenium Manager বেনামি usage পরিসংখ্যান পাঠায়; SE_AVOID_STATS=true সেটি বন্ধ করে, তাই প্রথম run-এর আগেই এটি বসানো হয়েছে (metadata-তে "stats": [] দেখা যাচ্ছে)। CI-তে, যেখানে internet নেই, driver আগে থেকে রেখে Service-এ তার path দেওয়াও চলে।

এবার conftest.py, তিনটি fixture-সহ। প্রথমটি প্রতিটি test-এর আগে app-এর test-mode reset ডাকে (পর্ব ৩১-এর মতো), দ্বিতীয়টি browser খোলে-বন্ধ করে, তৃতীয়টি login করে:

import os
import urllib.request

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

BASE = os.environ.get("BAZARGHAR_URL", "http://127.0.0.1:8765")


@pytest.fixture(autouse=True)
def fresh_data():
    req = urllib.request.Request(BASE + "/api/test/reset", method="POST")
    with urllib.request.urlopen(req, timeout=5) as r:
        assert r.status == 200


@pytest.fixture
def driver():
    opts = webdriver.EdgeOptions()
    opts.add_argument("--headless=new")
    opts.add_argument("--window-size=1280,900")
    d = webdriver.Edge(options=opts)       # Selenium Manager finds msedgedriver
    yield d
    d.quit()


@pytest.fixture
def login(driver):
    def _login(user):
        driver.get(BASE + "/login")
        driver.find_element(By.CSS_SELECTOR, "[data-testid='login-email']").send_keys(f"{user}@bazarghar.test")
        driver.find_element(By.CSS_SELECTOR, "[data-testid='login-password']").send_keys(f"{user}1234")
        driver.find_element(By.CSS_SELECTOR, "[data-testid='login-submit']").click()
        WebDriverWait(driver, 5).until(                  # wait for the redirect
            EC.presence_of_element_located((By.CSS_SELECTOR, "[data-testid='nav-user']")))
    return _login

driver fixture: প্রতিটি test নতুন browser আর নতুন session পায়, শেষে quit() browser আর driver দুটিই বন্ধ করে। quit() না ডাকলে প্রতিটি test একটি করে Edge আর msedgedriver ঝুলিয়ে রাখে; CI মেশিনে কয়েকশো test-এর পরে memory শেষ। yield থাকায় test ব্যর্থ হলেও teardown চলে (পর্ব ২৩)। --headless=new মানে জানালা ছাড়া আসল browser, অর্থাৎ headless browser. জানালার মাপ বেঁধে দেওয়া জরুরি; মাপ বদলালে responsive layout বদলায়, আর element লুকিয়ে যেতে পারে।

login-এর শেষ লাইনটি: এটি প্রথম খসড়ায় ছিল না। কেন যোগ হলো, তা §৫-এর শেষে একটি সত্যিকারের flaky ঘটনার গল্প। Password-গুলো seed-এর বানানো মান, কোনো আসল গোপন তথ্য নয়।

By: Selenium-এ element খোঁজার আটটি উপায়

Selenium-এ locator লেখা হয় By আর একটি string দিয়ে। find_element প্রথম মিলটি দেয়, না পেলে exception; find_elements একটি তালিকা দেয়, না পেলে খালি তালিকা, exception নয়। কোনটি কখন ভালো, তার বিস্তারিত পর্ব ৩৫-এ; সংক্ষেপে নিচের ছক:

Byবাজারঘরে উদাহরণমন্তব্য
By.CSS_SELECTOR[data-testid='cart-count']সবচেয়ে বেশি ব্যবহৃত; data-testid-এর সাথে স্থির
By.IDsearch-inputid সত্যিই অনন্য ও স্থির হলে ভালো
By.XPATH//button[text()='কার্টে যোগ করুন']লেখা বা পূর্বপুরুষ ধরে খোঁজা যায়; লম্বা পথ ভঙ্গুর
By.NAMEqtyform-এর ঘরে কাজের
By.LINK_TEXTলগইনলেখা বদলালে বা অনুবাদ হলে ভাঙে
By.PARTIAL_LINK_TEXT, By.TAG_NAME, By.CLASS_NAMEh1, badgeসাধারণত একাধিক মিল; সাবধানে

Playwright-এর get_by_role-এর মতো “role আর accessible name” দিয়ে সরাসরি খোঁজা Selenium-এ ভেতরে নেই; Selenium 4-এ এর বদলে আছে “relative locator” (locate_with(By.TAG_NAME, "button").below(...)), যা layout-এর অবস্থান দিয়ে খোঁজে, তবে এটি বাস্তবে কম ব্যবহৃত। তাই Selenium-এর দলে data-testid দিয়ে CSS selector সবচেয়ে প্রচলিত। আর XPath লিখলে বাংলা লেখার Unicode রূপ (যেমন একই অক্ষর দুই রকম কোডে) মিলছে কি না যাচাই করুন; এই ফাঁদটি পর্ব ৩৫-এ আছে।

৪ · Wait ছাড়া test, আর explicit wait দিয়ে সমাধান

মোবাইল রিচার্জ করলে টাকা কাটার বার্তা আসে সাথে সাথে, কিন্তু ব্যালান্স বাড়ার বার্তা আসে কয়েক সেকেন্ড পরে। “রিচার্জ চাপলাম, সাথে সাথে ব্যালান্স দেখলাম, বাড়েনি, তাই রিচার্জ ব্যর্থ”, এই সিদ্ধান্ত ভুল। আবার “পাঁচ মিনিট বসে থাকি, তারপর দেখি” সময়ের অপচয়। ঠিক পথ: কিছুক্ষণ পরপর দেখা, বাড়লেই থামা, আর একটি সীমা ঠিক করা, যার পরে সত্যিই অভিযোগ করবেন। এটিই explicit wait.

পাঁচটি test, একই কাজের পাঁচ রকম লেখা। প্রথম দুটি সরল, কোনো অপেক্ষা নেই; মাঝের দুটি implicit wait দিয়ে; শেষটি explicit wait দিয়ে:

import time

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

from conftest import BASE

BADGE = (By.CSS_SELECTOR, "[data-testid='cart-count']")
ADD = (By.CSS_SELECTOR, "[data-testid='add-to-cart']")
TOAST_SHOWN = (By.CSS_SELECTOR, "[data-testid='toast'].show")


def open_oil(driver, login):
    login("mitu")
    driver.get(BASE + "/products/3")
    assert driver.find_element(*BADGE).text == "0"


def test_naive_read_badge(driver, login):
    open_oil(driver, login)
    driver.find_element(*ADD).click()
    assert driver.find_element(*BADGE).text == "1"      # read at once


def test_naive_find_toast(driver, login):
    open_oil(driver, login)
    driver.find_element(*ADD).click()
    driver.find_element(*TOAST_SHOWN)                    # NoSuchElementException


def test_implicit_wait_badge_first(driver, login):
    driver.implicitly_wait(2)
    open_oil(driver, login)
    driver.find_element(*ADD).click()
    assert driver.find_element(*BADGE).text == "1"       # element exists: no wait


def test_implicit_wait_toast_first(driver, login):
    driver.implicitly_wait(2)
    open_oil(driver, login)
    driver.find_element(*ADD).click()
    toast = driver.find_element(*TOAST_SHOWN)            # polled up to 2 s: found
    print("toast:", toast.text)
    assert driver.find_element(*BADGE).text == "1"       # passes only by luck


def test_explicit_wait(driver, login):
    open_oil(driver, login)
    driver.find_element(*ADD).click()
    t0 = time.perf_counter()
    wait = WebDriverWait(driver, timeout=5, poll_frequency=0.1)
    wait.until(EC.text_to_be_present_in_element(BADGE, "1"))
    toast = wait.until(EC.visibility_of_element_located(TOAST_SHOWN))
    print(f"badge=1 after {time.perf_counter() - t0:.2f}s, toast: {toast.text}")
    assert wait.until(EC.element_to_be_clickable(ADD))   # button enabled again

সত্যিকারের আউটপুট (-s দিয়ে print দেখানো, --tb=line দিয়ে প্রতিটি ব্যর্থতা এক লাইনে; driver-এর লম্বা stacktrace আর path ছাঁটা):

$ uv run pytest -v -s --tb=line tests/test_cart.py
collected 5 items

tests/test_cart.py::test_naive_read_badge FAILED
tests/test_cart.py::test_naive_find_toast FAILED
tests/test_cart.py::test_implicit_wait_badge_first FAILED
tests/test_cart.py::test_implicit_wait_toast_first toast: কার্টে যোগ হয়েছে
PASSED
tests/test_cart.py::test_explicit_wait badge=1 after 0.45s, toast: কার্টে যোগ হয়েছে
PASSED

================================== FAILURES ===================================
tests/test_cart.py:23: AssertionError: assert '0' == '1'
…errorhandler.py:234: selenium.common.exceptions.NoSuchElementException: Message:
  no such element: Unable to locate element:
  {"method":"css selector","selector":"[data-testid='toast'].show"}
  (Session info: MicrosoftEdge=157.0.4341.60)
tests/test_cart.py:36: AssertionError: assert '0' == '1'
=========================== short test summary info ===========================
FAILED tests/test_cart.py::test_naive_read_badge - AssertionError: assert '0'...
FAILED tests/test_cart.py::test_naive_find_toast - selenium.common.exceptions...
FAILED tests/test_cart.py::test_implicit_wait_badge_first - AssertionError: a...
======================== 3 failed, 2 passed in 18.66s =========================

১. test_naive_read_badge: assert '0' == '1'. Click-এর উত্তর ফেরার মুহূর্তে badge-এর element আছে, কিন্তু লেখা এখনো পুরোনো। Test ভুল কারণে লাল: app ঠিক, test অধৈর্য।

২. test_naive_find_toast: NoSuchElementException. Toast-এর .show class ৪০০ ms পরে আসে, আর find_element ডিফল্টভাবে একবারই খোঁজে। Selenium-এ implicit wait-এর ডিফল্ট মান শূন্য।

৩ আর ৪, implicit wait-এর দুই মুখ: implicitly_wait(2) বলে “element না পেলে ২ সেকেন্ড পর্যন্ত খোঁজা চালিয়ে যাওয়া”। Badge-এর element তো আগে থেকেই আছে, তাই খোঁজা সাথে সাথে শেষ, লেখা “0”, test লাল। অথচ ঠিক একই wait নিয়ে চতুর্থ test সবুজ! কারণ সেটি আগে toast খুঁজেছে; toast দেখা দিতে ৪০০ ms লেগেছে, আর সেই একই মুহূর্তে badge-ও “1” হয়ে গেছে। চতুর্থ test পাস করেছে ভাগ্যে, নকশায় নয়: কাল কেউ লাইন দুটির ক্রম বদলালে, বা app badge আর toast আলাদা সময়ে দেখালে, এটি ভাঙবে।

৫. test_explicit_wait: যে শর্তটি আসলে চাই, সেটিই অপেক্ষার বিষয়: “badge-এর লেখায় 1 আছে”। শর্ত মিলেছে ০.৪৫ সেকেন্ডে, অর্থাৎ app-এর ৪০০ ms বিরতি আর fetch-এর সময়। তারপর toast দৃশ্যমান কি না, আর button আবার চাপার মতো হয়েছে কি না (app কাজের সময় button disabled রাখে)। কোনো time.sleep নেই, তবু test ঠিক যতটুকু দরকার ততটুকুই অপেক্ষা করেছে। প্রতিটি test-এ প্রায় ৩–৪ সেকেন্ড গেছে browser খোলা আর login-এ, অপেক্ষায় নয়।

expected_conditions: তৈরি শর্তের বাক্স

WebDriverWait(driver, timeout, poll_frequency)-এর until() একটি function নেয়, যা driver পেয়ে কিছু একটা ফেরত দেয়। ফল “সত্য” হলে অপেক্ষা শেষ, সেই মান ফেরত; মিথ্যা হলে poll_frequency (ডিফল্ট ০.৫ সেকেন্ড) ঘুমিয়ে আবার; সময় পেরোলে TimeoutException. খোঁজার সময় NoSuchElementException এলে সেটি ডিফল্টভাবে উপেক্ষা করা হয়, অর্থাৎ “এখনো নেই” হিসেবে ধরা হয়। expected_conditions-এ চেনা শর্তগুলো তৈরি থাকে:

শর্তকখন সত্যবাজারঘরে ব্যবহার
presence_of_element_locatedDOM-এ আছে (দেখা যাক বা না যাক)login-এর পরে nav-user
visibility_of_element_locatedআছে এবং দেখা যায়toast
text_to_be_present_in_elementelement-এর লেখায় অংশটি আছেbadge “1”
element_to_be_clickableদেখা যায় এবং enabledadd-to-cart আবার সক্রিয়
invisibility_of_element_locatedনেই, বা আছে কিন্তু লুকানোloading চিহ্ন সরে গেছে
url_contains, title_isঠিকানা বা শিরোনাম মেলেcheckout-এর পরে order পাতা
alert_is_present, number_of_windows_to_be, frame_to_be_available_and_switch_to_italert, নতুন জানালা, frame তৈরি§৬

একটি সূক্ষ্ম কথা: text_to_be_present_in_element(BADGE, "1") “অংশ আছে” দেখে, সমান কি না নয়। Badge “10” হলেও সত্য হতো। হুবহু মেলাতে চাইলে নিজের ছোট শর্ত লিখুন, যেমন lambda d: d.find_element(*BADGE).text == "1". until() যেকোনো callable নেয়, তাই এটিই explicit wait-এর আসল শক্তি: expected condition মানে শুধু একটি ছোট function.

নিচের stepper-এ explicit wait-এর polling ধাপে ধাপে দেখুন। মানগুলো একটি আলাদা সত্যিকারের run থেকে, যেখানে শর্তের function প্রতিবার ডাকা হলে সময় আর badge-এর লেখা ছাপত (poll_frequency=0.1):

WebDriverWait(driver, 5, poll_frequency=0.1)
সময় (click থেকে)
badge-এর লেখা
শর্তের ফল
পাতার ভেতরে
  1. Click শেষ, ঘড়ি শুরু। click()-এর উত্তর এসেছে, পাতার JS এখন fetch পাঠাচ্ছে। WebDriverWait তৈরি হলো: সর্বোচ্চ ৫ সেকেন্ড, প্রতি ০.১ সেকেন্ডে একবার দেখা।
  2. প্রথম দেখা, ০.০১ s: শর্তের function একটি find_element আর একটি .text পাঠাল, অর্থাৎ দুটি HTTP request. লেখা '0', ফল False. সময় বাকি আছে, তাই ০.১ সেকেন্ড ঘুম।
  3. দ্বিতীয় দেখা, ০.১২ s: এখনো '0'. খেয়াল করুন, দুই দেখার ফাঁক ০.১১ সেকেন্ড, ০.১০ নয়: ০.১ ঘুম আর request-গুলোর প্রায় ০.০১ সেকেন্ড।
  4. তৃতীয় দেখা, ০.২৩ s: '0'. পাতায় app-এর ৪০০ ms বিরতি চলছে। এই সময়ে test কিছুই নষ্ট করছে না, শুধু হালকা প্রশ্ন করে যাচ্ছে।
  5. চতুর্থ দেখা, ০.৩৪ s: এখনো '0'. time.sleep(0.3) লিখলে test এখানে ব্যর্থ হতো; sleep(2) লিখলে পাস করত, কিন্তু প্রতিবার দেড় সেকেন্ডের বেশি নষ্ট হতো।
  6. পঞ্চম দেখা, ০.৪৫ s: '1', শর্ত True, until() সাথে সাথে ফিরল। মোট অপেক্ষা ০.৪৫ সেকেন্ড, আসল দেরির প্রায় সমান। Poll যত ঘন, শর্ত মেলার পরে তত কম বাড়তি সময়; কিন্তু প্রতিটি poll দুটি request, তাই খুব ঘন poll (যেমন ০.০১) driver-কে অকারণে ব্যস্ত রাখে। ০.১ থেকে ০.৫ সেকেন্ড সাধারণ পছন্দ।

এবার একই ধারণা নিজের হাতে চালান। নিচের JavaScript block একটি ছোট পাতায় বাজারঘরের মতো দেরিতে বদলানো badge বানায়, তারপর Selenium-এর দুই রকম wait-এর সরল নকল দিয়ে পড়ে। findElement implicit wait-এর মতো শুধু “element আছে কি না” দেখে; until explicit wait-এর মতো যেকোনো শর্ত দেখে। সময় ১০০ ms-এর গুণিতকে গোল করা:

const sleep = ms => new Promise(r => setTimeout(r, ms));
const $ = s => document.querySelector(s);
const since = t0 => Math.round((Date.now() - t0) / 100) * 100 + ' ms';
function clickAdd() {     // like app.js: badge + toast change 400 ms later
  $('#badge').textContent = '0'; $('#toast').className = '';
  setTimeout(() => { $('#badge').textContent = '1'; $('#toast').className = 'show'; }, 400);
  return Date.now();
}
async function findElement(sel, implicitMs) {   // implicit: "does it exist?"
  for (const end = Date.now() + implicitMs; !$(sel); await sleep(50))
    if (Date.now() >= end) throw new Error('NoSuchElement ' + sel);
  return $(sel);
}
async function until(cond, timeoutMs, pollMs) { // explicit: any condition
  const end = Date.now() + timeoutMs;
  for (;;) {
    try { if (await cond()) return true; } catch (e) {}
    if (Date.now() > end) throw new Error('Timeout ' + timeoutMs + ' ms');
    await sleep(pollMs);
  }
}
(async () => {
  let t0 = clickAdd();
  console.log('1 no wait:', $('#badge').textContent, since(t0));
  await sleep(600); t0 = clickAdd();
  console.log('2 implicit, badge:', (await findElement('#badge', 2000)).textContent, since(t0));
  await sleep(600); t0 = clickAdd(); await findElement('#toast.show', 2000);
  console.log('3 implicit, toast first:', $('#badge').textContent, since(t0));
  await sleep(600); t0 = clickAdd(); await until(() => $('#badge').textContent === '1', 5000, 100);
  console.log('4 explicit text==1:', $('#badge').textContent, since(t0));
  t0 = Date.now();
  try { await until(() => findElement('#ghost', 1000), 500, 100); }
  catch (e) { console.log('5 implicit 1000 + explicit 500:', e.message, since(t0)); }
})();

আসল আউটপুট:

1 no wait: 0 0 ms
2 implicit, badge: 0 0 ms
3 implicit, toast first: 1 400 ms
4 explicit text==1: 1 400 ms
5 implicit 1000 + explicit 500: Timeout 500 ms 1000 ms

ডেস্কটপের Selenium run-এর প্রতিটি আচরণ এখানে ফিরে এসেছে। সারি ১: অপেক্ষা ছাড়া পড়লে “0”. সারি ২: implicit wait থাকলেও badge “0”, আর সময় ০ ms, কারণ element আগে থেকেই ছিল, খোঁজা সাথে সাথে শেষ। সারি ৩: আগে toast খুঁজলে ৪০০ ms অপেক্ষা হয়, আর তার “পার্শ্বফলে” badge-ও “1”: ভাগ্যের পাস। সারি ৪: explicit wait সঠিক শর্তের জন্য অপেক্ষা করে ৪০০ ms-এ “1” পেয়েছে। সারি ৫ মেশানোর ফাঁদ: বার্তা বলছে সীমা ৫০০ ms, অথচ আসলে লেগেছে ১০০০ ms, কারণ শর্তের ভেতরের প্রথম খোঁজাই implicit-এর পুরো ১০০০ ms আটকে ছিল। Browser-এর timer-এর সামান্য দেরিতে কখনো ৫০০ বা ১১০০ দেখাতে পারে; গোল করার কারণে সাধারণত একই সংখ্যা আসে। clickAdd-এর ৪০০ বদলে ১৫০০ করে আবার চালান: কোন সারি বদলায়?

৫ · Implicit আর explicit wait মেশানোর ফাঁদ

অনেক পুরোনো Selenium প্রকল্পে শুরুতেই একটি লাইন থাকে: driver.implicitly_wait(10), “যাতে সব জায়গায় একটু অপেক্ষা হয়”। তারপর কোথাও কোথাও WebDriverWait-ও যোগ হয়। Selenium-এর নিজস্ব documentation স্পষ্ট সতর্ক করে: দুটি মেশাবেন না, এতে অপেক্ষার সময় অনুমান করা যায় না। কেন, তা বোঝার চাবি হলো দুটি wait চলে দুই জায়গায়। Implicit wait একটি session-এর সেটিং, যা driver-এর ভেতরে প্রতিটি element খোঁজায় লাগে। Explicit wait চলে আপনার Python-এ, যা শর্তটি বারবার ডাকে। দুটি একসাথে থাকলে explicit wait-এর প্রতিটি ডাক নিজেই implicit wait-এর পুরো সময় আটকে থাকতে পারে।

মাপা যাক। বাজারঘরের home পাতায় এমন একটি element খোঁজা হলো, যা কখনো আসবে না ([data-testid='never-there']), তিন রকম জোড়ায়, poll_frequency=0.5. শেষে উল্টো দিক: implicit ৫ সেকেন্ড রেখে “element চলে গেছে কি না” দেখা, explicit সীমা ২ সেকেন্ড। সত্যিকারের আউটপুট:

$ uv run python mixing.py
implicit=0s explicit=2s -> TimeoutException after 2.0s
implicit=5s explicit=2s -> TimeoutException after 5.0s
implicit=3s explicit=7s -> TimeoutException after 10.2s
implicit=5s, wait 2s for 'gone' -> True after 5.0s

প্রথম সারি প্রত্যাশিত: implicit শূন্য, তাই ২ সেকেন্ডের wait ২ সেকেন্ডেই শেষ। দ্বিতীয় সারিতে ২ সেকেন্ডের wait চলেছে ৫ সেকেন্ড, কারণ প্রথম ডাকটিই driver-এর ভেতরে ৫ সেকেন্ড আটকে ছিল। তৃতীয় সারি সবচেয়ে শিক্ষণীয়: ৭ সেকেন্ডের wait, ৩ সেকেন্ডের implicit, অথচ মোট ১০.২ সেকেন্ড, দুটির কোনোটির সমান নয়। চতুর্থটি উল্টো দিকের ফাঁদ: “লুকিয়েছে কি না” দেখার শর্ত প্রথমে element খোঁজে, আর না পেয়ে সত্য বলে; কিন্তু “না পাওয়া” প্রমাণ করতেই implicit wait পুরো ৫ সেকেন্ড খেয়েছে। Loading চিহ্ন সরে যাওয়ার প্রতিটি অপেক্ষায় ৫ সেকেন্ড, পুরো suite-এ কয়েক মিনিট।

until(presence_of_element_located(GHOST)), poll 0.5 s
ঘড়ি
কোথায় চলছে
ফল
  1. শুরু। Session-এ implicitly_wait(3) বসানো, আর test লিখেছে WebDriverWait(d, 7, poll_frequency=0.5). Selenium Python-এ শেষ সময় ঠিক করল: এখন থেকে ৭ সেকেন্ড। লেখক ভাবছেন, সর্বোচ্চ ৭ সেকেন্ড অপেক্ষা।
  2. প্রথম ডাক আটকে থাকল ৩ সেকেন্ড। শর্তের ভেতরের find_element driver-এ গেল। Element নেই, আর implicit wait থাকায় driver নিজেই ৩ সেকেন্ড খুঁজল, তারপর NoSuchElementException. WebDriverWait এই exception উপেক্ষা করে, অর্থাৎ “এখনো নেই”।
  3. সময় দেখা, তারপর ঘুম। ঘড়ি ৩.০, শেষ সময় ৭.০ পেরোয়নি, তাই ০.৫ সেকেন্ড ঘুম। Selenium সময় দেখে শুধু প্রতিটি ডাক শেষ হওয়ার পরে; ডাক চলার মাঝখানে থামাতে পারে না।
  4. দ্বিতীয় ডাক, আবার ৩ সেকেন্ড। ৩.৫ থেকে ৬.৫. ৬.৫ এখনো ৭-এর কম, তাই আবার ঘুম।
  5. তৃতীয় ডাক শুরু হলো ৭.০-তে, শেষ ১০.০-তে। শুরুর মুহূর্তে সময় ঠিক সীমায়, তবু ডাকটি গেল, আর পুরো ৩ সেকেন্ড আটকে থাকল। শেষ হওয়ার পরে দেখা গেল ১০.০ > ৭.০.
  6. TimeoutException, প্রায় ১০.২ সেকেন্ডে। বাকি ০.২ সেকেন্ড HTTP request আর browser-এর নিজের খরচ। হিসাবের নিয়ম: মোট সময় হতে পারে প্রায় explicit + implicit পর্যন্ত। সমাধান সোজা: implicit wait শূন্য রাখুন (ডিফল্ট), আর যেখানে অপেক্ষা দরকার সেখানে explicit wait. একই কাজ implicit শূন্যে মাপলে ২ সেকেন্ডের wait ২.০ সেকেন্ডেই শেষ হয়েছিল।

এই হিসাব শুধু অনুমান নয়। নিচের Pyodide block Selenium-এর until()-এর লুপটি একটি নকল ঘড়িতে হুবহু নকল করে (প্রতিটি ডাক implicit সময় আটকে থাকে, ডাকের খরচ ০.০১ সেকেন্ড, ডাক শেষে সময় দেখা, তারপর ঘুম), তারপর pytest দিয়ে ডেস্কটপে মাপা চারটি সময়ের সাথে মিলিয়ে দেখে:

import os, sys, pytest
os.makedirs("/home/pyodide/p38", exist_ok=True)
os.chdir("/home/pyodide/p38"); sys.modules.pop("test_waitmodel", None)
open("test_waitmodel.py", "w").write('''
import pytest

def until_seconds(implicit, timeout, poll=0.5, appears=None, call=0.01):
    """WebDriverWait.until() on a fake clock; each find_element call
    blocks up to `implicit` s inside the driver before NoSuchElement."""
    t = 0.0
    while True:
        if appears is not None and appears <= t + implicit:
            return round(max(t, appears) + call, 2), "found"
        t += implicit + call                 # one call, element absent
        if t > timeout:                      # same check as Selenium
            return round(t, 2), "timeout"
        t += poll                            # time.sleep(poll)

MEASURED = [  # desktop run: Selenium 4.52 + Edge 157
    (0, 2, 0.5, None, 2.0, "timeout"),
    (5, 2, 0.5, None, 5.0, "timeout"),
    (3, 7, 0.5, None, 10.2, "timeout"),
    (0, 5, 0.1, 0.40, 0.45, "found"),
]

@pytest.mark.parametrize("imp,exp,poll,appears,real,kind", MEASURED)
def test_model_matches_desktop(imp, exp, poll, appears, real, kind):
    secs, got = until_seconds(imp, exp, poll, appears)
    print(f"implicit={imp} explicit={exp} -> {got} at {secs}s (real {real}s)")
    assert got == kind and abs(secs - real) <= 0.3
''')
pytest.main(["-q", "-s", "--no-header", "-p", "no:cacheprovider",
             "test_waitmodel.py"])

আসল আউটপুট:

implicit=0 explicit=2 -> timeout at 2.05s (real 2.0s)
.implicit=5 explicit=2 -> timeout at 5.01s (real 5.0s)
.implicit=3 explicit=7 -> timeout at 10.03s (real 10.2s)
.implicit=0 explicit=5 -> found at 0.45s (real 0.45s)
.
4 passed in 0.02s

-s দেওয়ায় প্রতিটি test-এর print দেখা যাচ্ছে, আর প্রতিটির পরে pytest-এর পাসের বিন্দু। চারটি test-ই পাস: সরল মডেলটি ডেস্কটপের মাপের ০.৩ সেকেন্ডের মধ্যে মেলে। তৃতীয় সারিতে মডেল বলছে ১০.০৩, আসল ১০.২; বাকিটা browser আর HTTP-র খরচ, যা মডেলে প্রতি ডাকে মাত্র ০.০১ ধরা। শেষ সারিটি অন্য প্রশ্নের উত্তর: badge ০.৪০ সেকেন্ডে বদলালে ০.১ poll-এ শর্ত মেলে পঞ্চম ডাকে, ০.৪৫-এ, ঠিক §৪-এর stepper-এর মতো। মডেলের MEASURED তালিকায় নিজে একটি সারি যোগ করে দেখুন, যেমন (4, 3, 0.5, None, ?, "timeout"): কত সেকেন্ড আসে?

লেখার সময় পাওয়া একটি সত্যিকারের flaky test

§৩-এর login fixture-এর প্রথম খসড়ায় শেষ লাইনটি, অর্থাৎ nav-user-এর জন্য অপেক্ষা, ছিল না। একই পাঁচটি test পরপর দুবার চালাতে প্রথমবার test_explicit_wait পাস করেছিল, দ্বিতীয়বার একই test TimeoutException দিয়ে ব্যর্থ। অর্থাৎ flaky test, যার পুরো আলোচনা পর্ব ৪০-এ। কারণ খুঁজতে একটি ছোট script login-এর ঠিক পরের অবস্থা ছাপাল (সত্যিকারের আউটপুট):

after click url: http://127.0.0.1:8794/login []
product url: http://127.0.0.1:8794/products/3 0
after add: http://127.0.0.1:8794/login?next=%2Fproducts%2F3 0

Login button-এ click-এর উত্তর ফিরেছে form জমা পড়ার আগেই: ঠিকানা তখনো /login, cookie-র তালিকা খালি []. তার পরের লাইন driver.get(".../products/3") চলমান login-কে মাঝপথে থামিয়ে নতুন পাতা খুলল; nav-user শূন্যটি, অর্থাৎ login হয়নি। তারপর add-to-cart-এর fetch পেল 401, আর app পাতাটিকে login-এ পাঠাল। কখনো form আগে জমা পড়ত, কখনো get আগে ঘটত; এই race condition-ই flaky আচরণের কারণ। সমাধান §৪-এর একই শিক্ষা: login-এর ফল যে চিহ্নে বোঝা যায় (nav-user), তার জন্য explicit wait. সমাধানের পরে suite প্রতিবার একই ফল দিয়েছে: ঠিক সেই তিনটি ব্যর্থতা, যা আমরা ইচ্ছা করে লিখেছি।

“Selenium click পাতা লোড হওয়া পর্যন্ত অপেক্ষা করে” ধারণাটি নির্ভরযোগ্য নয়। driver.get() ডিফল্টভাবে পাতার load ঘটনা পর্যন্ত অপেক্ষা করে। কিন্তু click থেকে শুরু হওয়া navigation-এর ক্ষেত্রে driver কতটা অপেক্ষা করবে, তা browser আর পরিস্থিতির ওপর নির্ভর করে; এই run-এ করেনি। তাই প্রতিটি পাতা বদলের পরে নতুন পাতার একটি নিশ্চিত চিহ্নের জন্য wait রাখুন: url_contains, বা নতুন পাতার একটি data-testid.

৬ · Alert, নতুন tab, iframe, stale element আর BiDi

বাস্তবের পাতায় শুধু button আর লেখা থাকে না। “অর্ডার বাতিল করবেন?” জাতীয় browser-এর নিজের প্রশ্ন-বাক্স (confirm), নতুন tab-এ খোলা সাহায্যের পাতা, আর পাতার ভেতরে আরেকটি পাতা, অর্থাৎ iframe, যেখানে প্রায়ই payment-এর অংশ বসে। Selenium এগুলোর প্রতিটিতে আলাদা করে “switch” করতে বলে। বাজারঘর নিজে X-Frame-Options: DENY পাঠায়, তাই তাকে frame-এ বসানো যায় না; এই তিনটি জিনিস দেখাতে lab-এ একটি ছোট স্থানীয় HTML ফাইল বানানো হয়েছিল (একটি confirm button, বাজারঘরের home খোলার একটি target="_blank" link, আর srcdoc-এ একটি নকল “Pay 961” button-সহ একটি iframe আছে)। মূল অংশ:

opts.unhandled_prompt_behavior = "ignore"     # see the note below
opts.enable_bidi = True
d = webdriver.Edge(options=opts)
wait = WebDriverWait(d, 5)
logs = []
d.script.add_console_message_handler(lambda e: logs.append(e.text))
d.get(pathlib.Path("pages/extras.html").resolve().as_uri())

d.find_element(By.ID, "cancel").click()               # 1. confirm()
alert = wait.until(EC.alert_is_present())
print("alert text:", alert.text)
alert.accept()
print("msg:", d.find_element(By.ID, "msg").text)

main = d.current_window_handle                        # 2. new tab
d.find_element(By.ID, "help").click()
wait.until(EC.number_of_windows_to_be(2))
other = [h for h in d.window_handles if h != main][0]
d.switch_to.window(other)
print("tab 2 title:", d.title)
d.close(); d.switch_to.window(main)

wait.until(EC.frame_to_be_available_and_switch_to_it((By.ID, "pay")))
d.find_element(By.ID, "paynow").click()               # 3. inside iframe
print("inside frame:", d.find_element(By.ID, "st").text)
d.switch_to.default_content()
print("back outside, has #cancel:", len(d.find_elements(By.ID, "cancel")))

d.execute_script("console.log('bazarghar: cart badge updated')")
time.sleep(0.3)                                        # let the event arrive
print("BiDi console:", logs)                           # 4. pushed by browser
$ uv run python extras.py
alert text: অর্ডার ৮ বাতিল করবেন?
msg: বাতিল হয়েছে
tab 2 title: হোম | বাজারঘর
inside frame: paid
back outside, has #cancel: 1
BiDi console: ['bazarghar: cart badge updated']

Alert: confirm খোলা থাকলে পাতার কোনো element-এ হাত দেওয়া যায় না; switch_to.alert বা alert_is_present দিয়ে ধরে accept() বা dismiss(). বাংলা প্রশ্নটি হুবহু পড়া গেছে, তাই test-এ লেখাটিও যাচাই করা যায়।

নতুন tab: Selenium নিজে থেকে নতুন tab-এ যায় না। প্রতিটি জানালার একটি “handle” থাকে; নতুনটি খুঁজে switch_to.window, কাজ শেষে close() আর মূলটিতে ফেরা। ফেরা ভুলে গেলে পরের সব command বন্ধ জানালায় যায় আর ভুতুড়ে error দেয়।

iframe: Frame-এর ভেতরের element বাইরে থেকে খোঁজা যায় না, কারণ সেটি আলাদা document. ঢুকে কাজ, তারপর switch_to.default_content() দিয়ে বাইরে। Shadow DOM-এর ক্ষেত্রেও আলাদা ধাপ লাগে (element.shadow_root), পর্ব ৩৫-এ সংক্ষেপে আছে।

BiDi আর একটি অপ্রত্যাশিত ফাঁদ: শেষ লাইনে console-এর বার্তাটি browser নিজে পাঠিয়েছে, test জিজ্ঞেস করেনি। কিন্তু প্রথম চেষ্টায় BiDi চালু করার পরে alert_is_present ৫ সেকেন্ডে TimeoutException দিয়েছিল, কারণ confirm বাক্সটি এই সেটআপে test ধরার আগেই আপনাআপনি বন্ধ হয়ে যাচ্ছিল। unhandled_prompt_behavior = "ignore" বসানোর পরে ঠিক কাজ করেছে। শিক্ষা: নতুন বৈশিষ্ট্য চালু করলে পুরোনো test-এর আচরণ বদলাতে পারে; প্রতিটি পরিবর্তনের পরে suite আবার চালান।

শেষ জিনিসটি stale element. §২-এ দেখেছেন, WebElement শুধু একটি id ধরে রাখে। পাতা নতুন করে আঁকা হলে, যেমন reload বা JavaScript পুরো তালিকা নতুন করে বানালে, পুরোনো id আর কোনো element-কে বোঝায় না। সত্যিকারের run:

before refresh: 880 টাকা
StaleElementReferenceException: stale element reference: stale element not found
found again: 880 টাকা

সমাধান হলো element জমিয়ে না রাখা, প্রয়োজনের মুহূর্তে আবার খোঁজা; এজন্যই ওপরের test-এ locator-গুলো (By, string) জোড়া হিসেবে রাখা, WebElement হিসেবে নয়। Playwright-এর locator ভেতরেই প্রতিবার নতুন করে খোঁজে, তাই সেখানে এই সমস্যা প্রায় দেখা যায় না।

৭ · Selenium Grid — অনেক মেশিনে অনেক browser

একটি suite-এ ৫০০টি UI test, প্রতিটি গড়ে ৪ সেকেন্ড: একটির পর একটি চালালে ৩৩ মিনিটের বেশি। আবার একই test Edge, Firefox আর Safari-তে চালাতে হবে, অথচ Safari চলে শুধু Apple-এর মেশিনে। Selenium Grid এই দুই সমস্যার উত্তর। Test-এর code প্রায় একই থাকে; শুধু browser নিজের কম্পিউটারে না খুলে একটি ঠিকানায় session চাওয়া হয়, আর Grid ঠিক করে কোন মেশিনের কোন browser সেটি চালাবে। ঢাকার একটি বড় বাস কাউন্টারের কথা ভাবুন: যাত্রী এক জানালায় টিকিট চান, কাউন্টার দেখে কোন বাসে কোন রুটে আসন খালি।

from selenium import webdriver

opts = webdriver.EdgeOptions()
opts.add_argument("--headless=new")
d = webdriver.Remote(command_executor="http://grid.local:4444", options=opts)
d.get("http://bazarghar-test.local/")    # the app as seen from the node
print(d.title)
d.quit()

এই অংশটি উদাহরণ, চালানো হয়নি: Grid-এর জন্য Java আর আলাদা server লাগে, যা এই পর্বের মেশিন-বাজেটের বাইরে। Grid 4-এর গঠন: Router সব request নেয়; নতুন session-এর অনুরোধ যায় New Session Queue-তে; Distributor সারি থেকে নিয়ে মানানসই Node খোঁজে (যার কাছে চাওয়া browser আর খালি জায়গা আছে); Session Map মনে রাখে কোন session কোন node-এ, যাতে পরের সব command সেখানেই যায়; আর একটি Event Bus এদের মাঝে বার্তা চালায়। ছোট পরিসরে সব এক process-এ চলে (java -jar selenium-server-<version>.jar standalone, ডিফল্ট port 4444); বড় পরিসরে আলাদা আলাদা। Selenium প্রকল্প Docker image-ও দেয়, আর বাণিজ্যিক cloud device farm-গুলোও মূলত একই protocol-এ Grid-এর মতো সেবা দেয়।

Grid suite-কে দ্রুত করে, নির্ভরযোগ্য করে না। সমান্তরাল চালালে লুকানো নির্ভরতা বেরিয়ে আসে: দুটি test একই ব্যবহারকারীর cart বদলায়, বা একটি test-এর reset অন্যটির data মুছে দেয়। বাজারঘরের reset endpoint তাই Grid-এ সমান্তরাল চালানোর সাথে মেলে না; প্রতিটি worker-এর নিজের app আর database, বা প্রতিটি test-এর নিজের নতুন ব্যবহারকারী লাগে। নেটওয়ার্কের দেরি যোগ হওয়ায় সময়ের ওপর নির্ভর করা test-ও আরও বেশি flaky হয়, যা পর্ব ৪০-এর বিষয়।

৮ · Selenium বনাম Playwright — সৎ তুলনা

“কোনটি ভালো” প্রশ্নের উত্তর নির্ভর করে দল, ভাষা, browser-এর চাহিদা আর পুরোনো code-এর ওপর। একই বাজারঘর কাজ দুই tool-এ লেখার পরে পার্থক্যগুলো এমন দাঁড়ায় (Playwright-এর দিক পর্ব ৩৬ আর ৩৭-এ, আর Full-Stack কোর্সের পর্ব ৭৬-এ):

দিকSelenium 4Playwright
Browser-এর সাথে কথাW3C WebDriver, browser-নির্মাতার নিজের driver; BiDi যুক্ত হচ্ছেনিজস্ব protocol; Chromium-এ CDP, Firefox আর WebKit-এর জন্য নিজেদের বানানো build
অপেক্ষানিজে লিখতে হয়: WebDriverWaitAction-এর আগে auto-wait আর পুনরায়-চেষ্টা করা assertion ভেতরেই
ভাষাJava, Python, C#, Ruby, JavaScript (সরকারি); আরও কিছু সম্প্রদায়েরJavaScript/TypeScript, Python, Java, .NET
Browserইনস্টল করা আসল browser, Safari-সহ (macOS-এ safaridriver)Chromium, Firefox, WebKit-এর নিজস্ব build; ইনস্টল করা Chrome বা Edge-ও
সমান্তরাল ও দূরের browserSelenium Grid, আর বহু cloud সেবাএক মেশিনে worker; দূরের browser-এর সমর্থন তুলনায় সীমিত
ব্যর্থতা পড়াscreenshot, log; বাকিটা নিজে সাজাতে হয়trace viewer, video, codegen ভেতরেই
Stale elementসম্ভব, element জমিয়ে রাখলেlocator প্রতিবার নতুন করে খোঁজে
বয়স ও প্রচলন২০০৪ থেকে; বিপুল পুরোনো suite, Appium-এর ভিত্তি২০২০ থেকে (Microsoft); নতুন প্রকল্পে দ্রুত জনপ্রিয়
লাইসেন্সApache-2.0Apache-2.0

ছকটি দেখে Playwright-কে সব দিকে এগিয়ে মনে হতে পারে, কিন্তু তিনটি জায়গায় Selenium আজও বাস্তব পছন্দ। একটি, আসল Safari: Playwright-এর WebKit build Safari-র ইঞ্জিনের কাছাকাছি, কিন্তু Apple-এর পাঠানো Safari নয়। দুই, মানদণ্ড: browser-নির্মাতারা নিজেরা WebDriver বাস্তবায়ন করেন, তাই একটি tool-এর কোম্পানির সিদ্ধান্তের ওপর নির্ভরতা কম। তিন, বিনিয়োগ: হাজার test-এর একটি Java suite নতুন tool-এ লেখার খরচ অনেক, আর ঝুঁকিও। উল্টো দিকে, নতুন web প্রকল্প, যেখানে দল TypeScript বা Python-এ কাজ করে, সেখানে Playwright-এর auto-wait আর trace অনেক সময় বাঁচায়। সবচেয়ে বড় শিক্ষা দুই tool-এই এক: অপেক্ষা করুন শর্তের জন্য, সময়ের জন্য নয়।

আরও গভীরে: WebDriver BiDi-কে অনেকে Selenium আর Playwright-এর মতো tool-এর ভবিষ্যৎ মিলনস্থল হিসেবে দেখেন: এক মানদণ্ডে দুই-মুখী যোগাযোগ, যাতে network ধরা, console পড়া আর ঘটনা শোনা সব browser-এ একভাবে চলে। Puppeteer-এর মতো CDP-নির্ভর tool-ও Firefox-এর জন্য BiDi গ্রহণ করেছে বলে প্রকাশিত হয়েছে, আর Mozilla CDP-র পুরোনো আংশিক সমর্থন সরিয়ে BiDi-কে মূল পথ করার কথা জানিয়েছে; তারিখ আর অবস্থা দ্রুত বদলায়, তাই কাজে লাগানোর আগে প্রতিটি browser-এর বর্তমান সমর্থন-তালিকা দেখুন। মানদণ্ডটি এখনো W3C-র খসড়া পর্যায়ে।

পরীক্ষা ও ইন্টারভিউতে:

  • Implicit আর explicit wait-এর পার্থক্য? Implicit: session-জুড়ে, driver-এর ভেতরে, শুধু element খুঁজে না পেলে অপেক্ষা; explicit: নির্দিষ্ট জায়গায়, নির্দিষ্ট শর্তের জন্য, client-এ polling.
  • দুটি মেশালে কী হয়? অপেক্ষার সময় অনুমান করা যায় না; implicit ৩ আর explicit ৭ সেকেন্ডে একটি মাপা run-এ ১০.২ সেকেন্ড লেগেছিল।
  • Thread.sleep বা time.sleep কেন খারাপ? হয় বেশি অপেক্ষা (ধীর suite), নয়তো কম (flaky); শর্ত যাচাই করে না।
  • StaleElementReferenceException কেন হয়? জমানো element-এর id পাতা নতুন করে আঁকার পরে অচল; প্রয়োজনের সময় আবার খুঁজুন।
  • Selenium Grid কী সমাধান করে, কী করে না? সমান্তরাল আর বহু browser-এ চালানো; test isolation আর flaky test-এর সমাধান করে না।

৯ · AI-এর যুগে Selenium test

“বাজারঘরের checkout-এর Selenium test লিখে দাও” বললে AI সহকারী দ্রুত একটি পরিচ্ছন্ন দেখতে ফাইল দেয়। Selenium-এর ক্ষেত্রে চেনা দুর্বলতাগুলোর নিজস্ব রূপ আছে। পুরোনো API: find_element_by_id বা find_element_by_css_selector, যা Selenium 4-এ সরানো হয়েছে, আর হাতে driver-এর path বসানো, যেন Selenium Manager নেই। অপেক্ষার জায়গায় time.sleep(3), নয়তো শুরুতে implicitly_wait(10) আর সাথে WebDriverWait, ঠিক §৫-এর ফাঁদ। বানানো data-testid বা ভুল লেখা, যেমন “Add to Cart”, যখন আসল button বাংলায়। শুধু happy path: শুধু ১টি পণ্য যোগ, কোনো stock-শেষ পণ্য বা login-ছাড়া চেষ্টা নেই। App এখন যা দেখায়, সেটিই expected ধরে নেওয়া, ফলে ভুল ছাড়ের সংখ্যাও assert-এ বসে যায়। quit() নেই। আর না চালিয়েই “সব test পাস করবে” বলা।

AI-কে সঠিক প্রেক্ষাপট দিন: version, locator-এর তালিকা, নিয়ম, আর wait-এর নীতি:

তুমি একজন অভিজ্ঞ SDET. Selenium 4 (Python, pytest) দিয়ে বাজারঘর নামের একটি দোকানের UI test লিখবে। Browser: Microsoft Edge, headless; driver আনবে Selenium Manager, তাই কোনো driver path লিখবে না। পাতা আর data-testid: product পাতা /products/{id}-তে add-to-cart আর qty-select; ওপরে cart-count; checkout পাতায় checkout-district, quote-total, place-order. Badge আর quote-total প্রায় ৪০০ ms দেরিতে বদলায়। নিয়ম: ১০০০ টাকার বেশি হলে ১০% ছাড় (ভগ্নাংশ বাদ, সর্বোচ্চ ৩০০); ঢাকায় delivery ৬০, বাইরে ১২০। ১. প্রথমে test case-এর ছক দাও: কী করা হবে, কোন শর্তের জন্য অপেক্ষা, প্রত্যাশিত মান আর নিয়মের কোন বাক্য থেকে এলো। অন্তত একটি negative case রাখো। ২. শুধু explicit wait (WebDriverWait + expected_conditions); implicitly_wait আর time.sleep একদম নয়। প্রতিটি পাতা বদলের পরে নতুন পাতার একটি চিহ্নের জন্য অপেক্ষা। ৩. Selenium 4-এর API ব্যবহার করো (find_element(By..., ...)); পুরোনো find_element_by_* নয়। কোনো data-testid তালিকায় না থাকলে প্রশ্ন করো, বানিও না। ৪. driver fixture-এ quit() থাকবে; কোনো আসল নাম, ফোন বা password নয়। ৫. তুমি test চালাওনি, তাই "সব পাস" লিখবে না; বরং বলো কোন test কোন ভুল ধরবে।

AI-এর লেখা Selenium test হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১প্রথম দিকের Selenium browser-এর ভেতরে JavaScript ঢুকিয়ে কাজ করত। কেন সেই পথ ছেড়ে browser-কে বাইরে থেকে চালানো WebDriver-এ যেতে হলো?

Jason Huggins-এর ২০০৪ সালের tool, পরে যার নাম Selenium Core, পরীক্ষার পাতার পাশেই একটি JavaScript program হিসেবে চলত, আর সেই JavaScript দিয়ে button চাপত, ঘর পূরণ করত। ধারণাটি চমৎকার ছিল, কারণ যেকোনো browser-এ চলত। কিন্তু browser-এর নিরাপত্তার একটি মৌলিক নিয়ম, same-origin policy, বাধা দিল: এক ঠিকানা থেকে আসা JavaScript অন্য ঠিকানার পাতায় হাত দিতে পারে না। তাই test-এর JavaScript আর পরীক্ষার পাতাকে একই ঠিকানা থেকে আসা দেখাতে Selenium Remote Control (RC) নামে একটি proxy server বানানো হলো, যা মাঝখানে বসে দুটিকে এক ঠিকানার বলে চালাত। এতে জটিলতা বাড়ল, আর ভেতরের JavaScript দিয়ে সব কিছু করা যেত না: browser-এর নিজের প্রশ্ন-বাক্স, file upload, কিছু keyboard ঘটনা, আসল mouse-এর মতো আচরণ।

Simon Stewart-এর WebDriver উল্টো দিক থেকে ভাবল: browser-এর ভেতরে না ঢুকে বাইরে থেকে, browser-এর নিজস্ব automation-এর পথ দিয়ে চালানো, যেভাবে একজন মানুষ চালান। এতে নিরাপত্তার নিয়মে আটকানো কম, আচরণ আসল ব্যবহারকারীর কাছাকাছি। দাম ছিল প্রতিটি browser-এর জন্য আলাদা বাস্তবায়ন। ২০০৯ সালের দিকে দুই প্রকল্প এক হওয়ার ঘোষণা আসে, আর ২০১১ সালে Selenium 2 প্রকাশিত হয় WebDriver-কে কেন্দ্রে রেখে।

এর পরের ধাপটিই আসল মোড়: যদি প্রতিটি browser-এর জন্য বাস্তবায়ন লাগেই, তবে browser-নির্মাতারা নিজেরাই কেন বানাবেন না? এই চিন্তা থেকে W3C-তে মানদণ্ডের কাজ শুরু হয়, আর ২০১৮ সালে সেটি Recommendation হয়। আজ Microsoft, Google, Mozilla আর Apple নিজেরাই নিজেদের driver দেয়। Tester হিসেবে এর মানে: test-এর আচরণ আর বাস্তব ব্যবহারকারীর আচরণের দূরত্ব কমেছে, আর একটি tool-এর ভাগ্যের সাথে suite বাঁধা নেই।

মূল উপলব্ধি: Test tool-এর নকশা যত ব্যবহারকারীর আসল পথের কাছে, ফলাফল তত বিশ্বাসযোগ্য; আর মানদণ্ড tool-কে দীর্ঘজীবী করে।

প্র ০২WebDriver চলে HTTP-র ওপর। প্রতিটি click, প্রতিটি লেখা পড়া একটি আলাদা request হলে test-এর গতি আর নির্ভরযোগ্যতায় এর প্রভাব কী?

§৪-এর polling stepper-এ দুই দেখার মাঝে ফাঁক ছিল ০.১১ সেকেন্ড, যেখানে ঘুম ছিল ০.১০: বাকি সময় দুটি HTTP request-এর, একটি element খোঁজা, একটি লেখা পড়া। নিজের কম্পিউটারে এটি নগণ্য। কিন্তু Grid-এ node যদি অন্য শহরের data center-এ থাকে, প্রতিটি request-এ কয়েক দশ মিলিসেকেন্ড যোগ হয়; একটি test-এ কয়েকশো command হলে কয়েক সেকেন্ড, পুরো suite-এ কয়েক মিনিট। এজন্য Selenium-এর পুরোনো পরামর্শ: অনেক ছোট command-এর বদলে কম command, যেমন বারবার find_element না করে একবার খুঁজে তালিকা নেওয়া, বা দরকারে execute_script দিয়ে একবারে কয়েকটি মান পড়া।

নির্ভরযোগ্যতার দিকটি আরও সূক্ষ্ম। প্রতিটি request একটি মুহূর্তের ছবি। find_element আর .text-এর মাঝখানে পাতা বদলে যেতে পারে, তখন stale element. প্রথম request-এ button দেখা গেল, দ্বিতীয়টিতে click করতে গিয়ে দেখা গেল একটি toast তার ওপরে এসে বসেছে, তখন element click intercepted. অর্থাৎ protocol-এর গঠন নিজেই race তৈরির সুযোগ রাখে, কারণ test আর পাতার JavaScript দুটি আলাদা সময়ে চলে, আর তাদের মাঝে নেটওয়ার্ক।

এই সমস্যাই নতুন নকশাগুলোকে প্রভাবিত করেছে। Playwright-এর মতো tool একটি স্থায়ী সংযোগে কাজ পাঠায় আর browser-এর ভেতরেই অপেক্ষা আর যাচাই একসাথে করে, যাতে “খোঁজা, যাচাই, click” প্রায় একটি ধাপ হয়। WebDriver BiDi-ও WebSocket-এ স্থায়ী সংযোগ আনে, আর browser নিজে থেকে ঘটনা জানাতে পারে, যাতে test-কে বারবার জিজ্ঞেস করতে না হয়। তবু কোনো protocol পাতার নিজের অসমাপ্ত কাজ জানে না; বাজারঘরের ৪০০ ms বিরতি যেকোনো tool-এর কাছে অদৃশ্য, যতক্ষণ না test নিজে একটি শর্ত দিয়ে জিজ্ঞেস করে।

মূল উপলব্ধি: প্রতিটি command একটি দূরের প্রশ্ন, আর উত্তর আসতে আসতে পাতা বদলাতে পারে; তাই কম প্রশ্ন, আর প্রতিটি প্রশ্ন একটি অর্থবহ শর্ত।

প্র ০৩Implicit wait তো সুবিধাজনক: একবার বসালেই সব জায়গায় একটু ধৈর্য। তাহলে অভিজ্ঞ দলগুলো একে বন্ধ রাখে কেন?

Implicit wait-এর সমস্যা তিন স্তরে। প্রথম, এটি ভুল প্রশ্নের উত্তর দেয়। এটি জানতে চায় “element আছে কি না”, অথচ আধুনিক পাতায় বেশিরভাগ element আগে থেকেই আছে, বদলায় তার লেখা, class বা অবস্থা। বাজারঘরের badge তার উদাহরণ: implicit ২ সেকেন্ড থাকা সত্ত্বেও test সাথে সাথে লেখা পড়েছে আর পেয়েছে শূন্য। ফলে দল ভাবে “wait তো আছে”, আর flaky test-এর কারণ খুঁজে পায় না।

দ্বিতীয়, এটি অদৃশ্য আর বৈশ্বিক। এক জায়গায় বসানো সেটিং পুরো session-এর প্রতিটি খোঁজায় লাগে, এমনকি সেখানে, যেখানে “নেই” হওয়াটাই প্রত্যাশিত। §৫-এর চতুর্থ মাপে loading চিহ্ন সরে যাওয়া প্রমাণ করতে ৫ সেকেন্ড লেগেছিল। একটি suite-এ “এটি দেখা যাচ্ছে না তো” ধরনের যাচাই কয়েকশো থাকলে, প্রতিটিতে পুরো implicit সময় নষ্ট। find_elements দিয়ে “খালি তালিকা” আশা করলেও একই খরচ।

তৃতীয়, explicit wait-এর সাথে মিশলে সময়ের হিসাব ভেঙে যায়, যা §৫-এ মাপা হয়েছে: ৭ সেকেন্ডের সীমা ১০.২ সেকেন্ড। CI-তে কোনো test-এর সময়সীমা ঠিক করতে গেলে, বা flaky test-এর log পড়তে গেলে, এই অনিশ্চয়তা খুব বিরক্তিকর। Selenium-এর documentation নিজেই মেশাতে নিষেধ করে, আর বেশিরভাগ অভিজ্ঞ পরামর্শ explicit-এর পক্ষে।

ইতিহাসেরও একটি দিক আছে। শুরুর দিকে implicit wait জনপ্রিয় হয় কারণ পুরোনো পাতাগুলো ছিল সার্ভারে আঁকা, পুরো পাতা একবারে আসত, আর “element আসা” মানেই “পাতা প্রস্তুত”। AJAX আর পরে React-এর মতো framework-এর যুগে পাতা অংশে অংশে বদলায়, তাই “আছে” আর “প্রস্তুত” আলাদা হয়ে গেছে। Playwright-এর auto-wait এই শিক্ষা থেকেই এসেছে: প্রতিটি action-এর আগে দৃশ্যমান, স্থির, enabled কি না দেখা, আর assertion নিজেই পুনরায় চেষ্টা করা।

মূল উপলব্ধি: ভালো অপেক্ষা স্পষ্ট, স্থানীয় আর অর্থবহ: কোন শর্ত, কোথায়, কতক্ষণ, তা test পড়েই বোঝা যায়।

প্র ০৪একটি দলের ৮০০টি Selenium (Java) test আছে, অনেকগুলোই flaky হয়ে উঠেছে। নতুন সদস্য বললেন “চলুন সব Playwright-এ নিয়ে যাই”। আপনি কীভাবে সিদ্ধান্ত নেবেন?

প্রথমে সমস্যার মূল আলাদা করুন। Flaky test-এর কারণ যদি Thread.sleep, implicit আর explicit মেশানো, জমানো element আর একে অপরের data-র ওপর নির্ভরতা হয়, তবে tool বদলালেও দলের অভ্যাস একই থাকবে, আর নতুন tool-এও একই ধরনের flaky test জন্মাবে। পর্ব ৪০-এর পদ্ধতিতে আগে মাপুন: গত কয়েক সপ্তাহে কোন test কতবার ব্যর্থ, কারণগুলোর ভাগ। প্রায়ই দেখা যায়, অল্প কয়েকটি helper (যেমন login-এর পরে নিশ্চিত wait, element না জমানো) ঠিক করলেই বেশিরভাগ flake চলে যায়।

তারপর খরচ আর লাভ। ৮০০টি test নতুন করে লেখা মানে কয়েক মাস, আর সেই সময়ে দুটি suite পাশাপাশি রক্ষণাবেক্ষণ। লাভের দিকে: auto-wait, trace viewer, দ্রুত এক মেশিনে সমান্তরাল চালানো। ঝুঁকির দিকে: দল Java-তে দক্ষ হলে Playwright-এর Java binding আছে, কিন্তু সম্প্রদায় আর উদাহরণ বেশি TypeScript-এ; আসল Safari বা পুরোনো browser চালানো দরকার হলে Selenium Grid বা cloud সেবায় যে সুবিধা আছে, তা হারাতে পারে; আর পুরোনো suite-এর লুকানো জ্ঞান, যেমন কোন test কোন পুরোনো bug ধরে, নতুন লেখায় হারিয়ে যেতে পারে।

বাস্তবে প্রচলিত একটি মাঝপথ “strangler” কৌশল: নতুন feature-এর test নতুন tool-এ, পুরোনোগুলো থাকে যতক্ষণ সেই অংশের code বড় পরিবর্তন না পায়; প্রতিটি flaky পুরোনো test হয় ঠিক হয়, নয়তো নতুন tool-এ লেখা হয়ে পুরোনোটি মোছা হয়। একই সময়ে pyramid-এর প্রশ্নও তুলুন: ৮০০টির কতগুলো আসলে API বা unit স্তরে নামানো যায় (পর্ব ৩১)? UI test-এর সংখ্যা কমানোই প্রায়ই সবচেয়ে বড় উন্নতি, tool যা-ই হোক।

মূল উপলব্ধি: Tool বদল একটি ব্যয়বহুল সিদ্ধান্ত; আগে মাপুন flaky-র কারণ tool-এ না অভ্যাসে, তারপর ধাপে ধাপে বদলান।

প্র ০৫Browser-নির্মাতারাই যখন driver বানান, তখন Selenium Manager কেন দরকার হলো? Driver-এর version-এর ঝামেলা থেকে CI-র জন্য কী শিক্ষা?

Browser এখন খুব ঘন ঘন আপডেট হয়: Chrome আর Edge প্রায় চার সপ্তাহে একটি বড় version ছাড়ে, আর browser নিজে থেকে আপডেট হয়ে যায়। Driver-কে browser-এর একই বড় version-এর হতে হয়। ফলে বহু বছর ধরে একটি চেনা দৃশ্য ছিল: সোমবার সকালে CI-র সব UI test লাল, কারণ রাতে browser আপডেট হয়েছে কিন্তু driver পুরোনো। দলগুলো এর জন্য নানা উপায় নিত: হাতে driver নামিয়ে রাখা, তৃতীয় পক্ষের “webdriver manager” library, browser-এর আপডেট বন্ধ রাখা। শেষেরটি সবচেয়ে বিপজ্জনক, কারণ ব্যবহারকারীরা নতুন browser-এ, আর test পুরোনোটিতে।

Selenium Manager এই কাজটিকে Selenium-এর নিজের অংশ বানিয়েছে: ইনস্টল করা browser-এর version পড়া, মানানসই driver নামানো, cache-এ রাখা, আর দরকারে browser-ও নামানো। আমাদের run-এ cache-এর metadata-তে driver-এর version আর মেয়াদ (TTL) লেখা ছিল, অর্থাৎ নির্দিষ্ট সময় পরে আবার দেখবে নতুন driver এসেছে কি না। এটি সুবিধা, কিন্তু CI-র জন্য দুটি প্রশ্ন তোলে। এক, পুনরুৎপাদনযোগ্যতা: আজ যে test পাস করল, কাল browser আর driver বদলে গেলে একই code-এ ভিন্ন ফল আসতে পারে; তাই CI-তে browser-এর version log-এ রাখা আর দরকারে বেঁধে দেওয়া ভালো, যেমন container image-এ নির্দিষ্ট browser. দুই, নেটওয়ার্ক আর গোপনীয়তা: build মেশিন বাইরে থেকে binary নামাচ্ছে, আর ডিফল্টভাবে usage পরিসংখ্যান পাঠায়; কিছু প্রতিষ্ঠানে এটি নীতিবিরুদ্ধ, তাই SE_AVOID_STATS আর ভেতরের mirror বা আগে থেকে রাখা driver.

এখানে একটি বড় শিক্ষা আছে, যা testing-এর বাইরেও খাটে: test-এর পরিবেশও test-এর অংশ। Browser, driver, font, জানালার মাপ, timezone: এদের যেকোনো একটি বদলালে ফল বদলাতে পারে। ভালো দল এগুলো লিখে রাখে, প্রতিটি run-এর রিপোর্টে ছাপে (যেমন pytest-এর header-এ), আর বদল হলে সচেতনভাবে বদলায়।

মূল উপলব্ধি: Selenium Manager driver খোঁজার কষ্ট দূর করেছে, কিন্তু পরিবেশ বেঁধে রাখার দায়িত্ব এখনো দলের।

অনুশীলন

প্রথমে নিজে উত্তর লিখুন, তারপর মিলিয়ে দেখুন।

  1. Test design: Spec: “Checkout পাতায় cart-এর দাম ১০০১ টাকা (সয়াবিন তেল ৮৮০ + আলু ১২১)। District বদলালে quote-delivery আর quote-total প্রায় ৪০০ ms পরে নতুন হিসাব দেখায়। ক্রেতা মিতু, Plus সদস্য নন।” Selenium-এ দুটি test case লিখুন (district, প্রত্যাশিত delivery আর total, কোন শর্তের জন্য অপেক্ষা), আর বলুন কেন শুধু quote-total পড়াই যথেষ্ট নয়।

    নিয়ম থেকে: ১০০১ > ১০০০, তাই ছাড় ১০০১-এর ১০% = ১০০.১, ভগ্নাংশ বাদে ১০০. TC1, Dhaka: delivery ৬০, total ১০০১ − ১০০ + ৬০ = ৯৬১. TC2, Rajshahi: delivery ১২০, total ১০০১ − ১০০ + ১২০ = ১০২১. App-এর /api/pricing/quote একই দুটি মান দিয়েছে (৯৬১ আর ১০২১)।

    ধাপ: Select(driver.find_element(By.CSS_SELECTOR, "[data-testid='checkout-district']")).select_by_value("Rajshahi"), তারপর WebDriverWait(driver, 5).until(EC.text_to_be_present_in_element(TOTAL, "1021")). সতর্কতা: পাতা খোলার সময়ের district যদি আগেই Rajshahi থাকে, তবে শর্ত সাথে সাথে সত্য হবে, অপেক্ষা কিছুই যাচাই করবে না; তাই আগে অন্য district থেকে শুরু করুন, বা পুরোনো মান থেকে বদলানোর শর্ত লিখুন। শুধু total পড়া যথেষ্ট নয়, কারণ ভুল ছাড় আর ভুল delivery মিলে কখনো ঠিক total দেখাতে পারে; quote-discount (১০০) আর quote-delivery-ও আলাদা assert করুন। আর মনে রাখুন, প্রথম মানটি বদলালেই বাকিগুলো একই সময়ে বদলায় এমন অনুমান নিজে যাচাই করুন, নয়তো প্রতিটির জন্য আলাদা wait রাখুন।

  2. Output অনুমান করুন: Session-এ implicitly_wait(4), তারপর WebDriverWait(d, 3, poll_frequency=0.5).until(EC.presence_of_element_located(GHOST)), যেখানে GHOST কখনো আসবে না। কত সেকেন্ড পরে কোন exception আসবে? আর app-এর UI-র দেরি ৪০০ থেকে বাড়িয়ে ১৫০০ ms করলে §৪-এর test_explicit_wait (timeout ৫) আর test_implicit_wait_toast_first (implicit ২) কী করবে?

    প্রথম অংশ: প্রথম ডাকটিই driver-এর ভেতরে ৪ সেকেন্ড আটকে থাকবে, তারপর NoSuchElementException, যা WebDriverWait উপেক্ষা করে। ডাক শেষে সময় ৪ > ৩, তাই আর কোনো ডাক নয়: প্রায় ৪ সেকেন্ডে TimeoutException. §৫-এর মডেলে until_seconds(4, 3) দেয় (4.01, 'timeout'). সীমা ৩ লেখা, অপেক্ষা ৪: মেশানোর ফাঁদ।

    দ্বিতীয় অংশ, সত্যিকারের run (BAZARGHAR_UI_DELAY_MS=1500): দুটিই পাস। test_explicit_wait badge=1 after 1.53s, অর্থাৎ explicit wait নিজে থেকে দেড় সেকেন্ড অপেক্ষা করেছে, code-এ কোনো বদল ছাড়া। Implicit test-ও পাস, কারণ toast ১.৫ সেকেন্ডে এসেছে, যা implicit ২ সেকেন্ডের মধ্যে। দেরি ২.৫ সেকেন্ড হলে implicit test ভাঙত, আর explicit test তখনো ৫ সেকেন্ডের মধ্যে পাস করত। এটাই দুই পদ্ধতির পার্থক্য: একটি শর্তের জন্য অপেক্ষা, অন্যটি ভাগ্যের ওপর।

  3. Test-এর ভুল খুঁজুন: নিচের test-এ অন্তত চারটি সমস্যা আছে। খুঁজে বের করুন আর ঠিক করুন।
    def test_add_two_items(driver):
        driver.implicitly_wait(10)
        driver.get(BASE + "/products/3")
        add = driver.find_element(By.CSS_SELECTOR, "[data-testid='add-to-cart']")
        add.click()
        time.sleep(1)
        driver.refresh()
        add.click()
        WebDriverWait(driver, 5).until(
            EC.text_to_be_present_in_element(BADGE, "2"))
    • Login নেই: login ছাড়া add-to-cart-এর fetch পায় 401, আর app পাতাটিকে login-এ পাঠায়; test কখনো আসল জিনিস যাচাই করবে না। login("mitu") fixture ব্যবহার করুন।
    • Implicit আর explicit একসাথে: implicitly_wait(10) আর WebDriverWait(…, 5): সময়ের হিসাব অনিশ্চিত। Implicit সরান।
    • time.sleep(1): হয় বাড়তি সময়, নয়তো যথেষ্ট নয়। প্রথম click-এর পরে badge “1” হওয়ার জন্য explicit wait দিন।
    • Stale element: refresh()-এর পরে পুরোনো add দিয়ে click করলে StaleElementReferenceException. আবার খুঁজুন, বা locator-জোড়া রাখুন।
    • “অংশ আছে” শর্ত: text_to_be_present_in_element(BADGE, "2") “12” বা “20”-তেও সত্য। হুবহু মেলাতে নিজের শর্ত লিখুন। আর test-এর নাম “দুটি item” বলে, কিন্তু একই পণ্য দুবার যোগ হচ্ছে; নাম আর উদ্দেশ্য মেলান।
  4. নিজে চালান: এই পর্বের প্রকল্পটি নিজের কম্পিউটারে তৈরি করুন (বাজারঘর app আর uv add selenium pytest দিয়ে)। test_naive_read_badge-কে explicit wait দিয়ে ঠিক করুন, তারপর BAZARGHAR_BUGS=coupon_ge দিয়ে app চালিয়ে একটি নতুন test লিখুন, যা তেল + আটার cart (১০০০ টাকা) checkout পাতায় নিয়ে ছাড় যাচাই করে। কোন ফল আশা করবেন?

    নিয়ম বলে ছাড় শুধু ১০০০-এর বেশি হলে, তাই ১০০০ টাকায় ছাড় ০, Dhaka-য় total ১০০০ + ৬০ = ১০৬০. coupon_ge চালু থাকলে app >= ব্যবহার করে, তাই ছাড় ১০০ আর total ৯৬০ দেখাবে। এখানে একটি লুকানো ফাঁদ: text_to_be_present_in_element(DISCOUNT, "0") লিখলে ভুল app-এও শর্ত সত্য হবে, কারণ “100”-এর ভেতরে “0” আছে, আর test সবুজ থেকে ভুলটি লুকিয়ে রাখবে। তাই হুবহু মেলানোর শর্ত লিখুন, যেমন lambda d: d.find_element(*DISCOUNT).text == "0"; ভুল app-এ তখন ব্যর্থতা আসবে TimeoutException হিসেবে। বার্তা আরও পরিষ্কার চাইলে আগে পাতা স্থির হওয়ার শর্তের জন্য অপেক্ষা করুন (যেমন total-এ “1060” বা “960”, যেকোনোটি), তারপর সাধারণ assert discount == "0", যাতে রিপোর্টে '100' == '0' দেখা যায়। শেষে quit() আর app বন্ধ করতে ভুলবেন না।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমSelenium-এ একটি button খুঁজে click করে ফল যাচাইয়ের ধাপগুলো ঘটার ক্রমে সাজান (▲▼ চেপে সরান)

  1. Selenium Manager browser-এর version দেখে মানানসই driver জোগাড় করে
  2. Client POST /session পাঠিয়ে নতুন browser session খোলে
  3. POST …/element-এর উত্তরে একটি web element id আসে
  4. POST …/element/{id}/click-এর উত্তর আসে {value: null}
  5. পাতার JavaScript দেরিতে badge বদলায়
  6. Explicit wait-এর শর্ত সত্য হয়ে until() ফেরে

Selenium-এ driver.implicitly_wait(2) বসানো। Click-এর পরে একটি badge-এর লেখা ৪০০ ms দেরিতে “0” থেকে “1” হয়, আর badge element শুরু থেকেই পাতায় আছে। Click-এর সাথে সাথে find_element(BADGE).text পড়লে কী পাওয়া যাবে?

  • ২ সেকেন্ড অপেক্ষার পরে “1”
  • সাথে সাথে “0”
  • NoSuchElementException
  • TimeoutException

Session-এ implicit wait ৩ সেকেন্ড, আর WebDriverWait(d, 7, poll_frequency=0.5) এমন একটি element-এর জন্য অপেক্ষা করছে, যা কখনো আসবে না। প্রায় কত সেকেন্ড পরে TimeoutException আসবে?

  • ৩ সেকেন্ড
  • ৭ সেকেন্ড
  • প্রায় ১০ সেকেন্ড
  • ২১ সেকেন্ড

একটি test একটি element খুঁজে variable-এ রাখল, তারপর driver.refresh() করে সেই variable দিয়ে .text পড়ল। কোন exception আসার সম্ভাবনা সবচেয়ে বেশি?

  • NoSuchElementException
  • TimeoutException
  • ElementClickInterceptedException
  • StaleElementReferenceException

W3C WebDriver protocol-এ Selenium client আর browser driver কীভাবে কথা বলে?

  • Browser-এর পাতায় JavaScript ঢুকিয়ে
  • HTTP request আর JSON body দিয়ে
  • শুধু WebSocket-এর দুই-মুখী বার্তায়
  • একই process-এর ভেতরে function call করে

একটি দলকে আসল Safari, Edge আর Firefox-এ বহু মেশিনে সমান্তরালে UI test চালাতে হবে, আর তাদের পুরোনো suite Java-তে লেখা। কোন পছন্দটি সবচেয়ে যুক্তিসঙ্গত?

  • সব test-এ implicit wait বাড়িয়ে দেওয়া
  • সব test Playwright-এর WebKit-এ নতুন করে লেখা
  • Selenium Grid (বা একই protocol-এর সেবা) দিয়ে পুরোনো suite চালানো
  • একটি মেশিনে একটির পর একটি চালানো

EC.text_to_be_present_in_element(BADGE, "1") শর্তটি নিচের কোন ক্ষেত্রে সত্য হবে, যদিও test-এর লেখক চেয়েছিলেন badge ঠিক “1” হোক?

  • Badge-এর লেখা “10” হলে
  • Badge-এর লেখা “0” হলে
  • Badge element পাতায় না থাকলে
  • Badge-এর লেখা “২” হলে

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. WebDriver: প্রতিটি command একটি HTTP request, browser-নির্মাতার driver সেটি চালায়; W3C মানদণ্ড, BiDi আসছে দুই-মুখী কথার জন্য।
  2. Selenium Manager: driver নিজে জোগাড় করে; cache-এর জায়গা SE_CACHE_PATH, পরিসংখ্যান বন্ধ SE_AVOID_STATS=true; browser-এর version log-এ রাখুন।
  3. Click অপেক্ষা করে না: পাতার JS নিজের সময়ে চলে; ফল দেখার আগে explicit wait-এ নির্দিষ্ট শর্ত, পাতা বদলের পরে নতুন পাতার চিহ্ন।
  4. Implicit wait বন্ধ রাখুন: এটি শুধু “আছে কি না” দেখে, আর explicit-এর সাথে মিশলে সময় অনিশ্চিত (৭ সেকেন্ডের wait ১০.২ সেকেন্ড)।
  5. Element জমাবেন না: locator রাখুন, দরকারের মুহূর্তে খুঁজুন; alert, tab আর iframe-এ switch করে ঢুকুন আর বেরিয়ে আসুন; Grid গতি দেয়, isolation দেয় না।

পরের পর্বে: এই পর্বের test-গুলোতে locator আর login-এর code বারবার ফিরে এসেছে। পরের পর্বে সেগুলোকে Page Object-এ সাজানো হবে: test → flow → page → driver, যাতে একটি data-testid বদলালে শুধু এক লাইন বদলাতে হয়।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান