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

Page Object Model আর automation framework-এর নকশা

The Page Object Model and Designing a UI Automation Framework

Taught in Bangla, this lesson refactors raw UI tests into page objects, component objects and flows, layered as test, flow, page and driver. It argues where assertions, waits and test data belong, names anti-patterns such as god page objects and hidden assertions, and introduces the Screenplay pattern. A real Playwright 1.65.2 run in headless Edge runs three tests in raw and page-object form; renaming one data-testid breaks all six, and the page object needs one changed line where raw tests need five.

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

  • একটি raw UI test থেকে ধাপে ধাপে page object, component object আর flow বের করা
  • Test → flow → page → driver স্তর সাজানো, আর কোন কাজ কোন স্তরে যায় তা ঠিক করা
  • Assertion, অপেক্ষা (wait) আর test data কোথায় থাকবে, সেই বিতর্কে যুক্তি দিয়ে অবস্থান নেওয়া
  • God page object, ভেতরে লুকানো assertion আর sleep-এর মতো anti-pattern চেনা
  • Screenplay pattern-এর মূল ধারণা আর বাজারঘরের UI suite-এর ফোল্ডার কাঠামো

১ · সমস্যা — একই locator পঞ্চাশ জায়গায়

রেস্তোরাঁয় আপনি ওয়েটারকে বলেন, “এক প্লেট কাচ্চি আর একটা বোরহানি।” রান্নাঘরের কোন তাকে চাল, কোন হাঁড়িতে মাংস, কোন চুলায় দম, এসব আপনাকে জানতে হয় না। রান্নাঘর নতুন করে সাজানো হলেও আপনার অর্ডারের ভাষা বদলায় না; বদলায় শুধু রাঁধুনির জানা-শোনা। UI test-এও ঠিক এই ভাগটি দরকার। Test বলবে “মিতু তেল আর আলু কিনে ঢাকায় ক্যাশে অর্ডার দিলেন”; কোন বোতামের কোন test id, কোন ঘরের কোন label, তা জানবে অন্য একটি স্তর।

পর্ব ৩৫-এ ভালো locator বাছাই শিখেছেন, আর পর্ব ৩৬, ৩৭ ও ৩৮-এ Playwright ও Selenium দিয়ে বাজারঘরে test চালানো। কিন্তু ভালো locator-ও একদিন বদলায়: designer নাম বদলান, developer test id গুছিয়ে নেন। যদি সেই locator পঞ্চাশটি test-এ ছড়িয়ে থাকে, একটি বদলে পঞ্চাশটি ফাইল খুঁজতে হয়। এই রক্ষণাবেক্ষণের খরচই UI automation-এর সবচেয়ে বড় খরচ, আর page object তার প্রচলিত উত্তর।

নিচে এই পর্বের সত্যিকারের run-এর একটি “raw” test, অর্থাৎ যেখানে test নিজেই সরাসরি Playwright ডাকে। এটি কাজ করে, পাস করে, পড়াও যায়:

def test_checkout_cash_in_dhaka(page: Page):
    login(page)
    page.goto("/products/3")
    page.get_by_test_id("add-to-cart").click()
    expect(page.get_by_test_id("cart-count")).to_have_text("1")
    page.goto("/products/9")
    page.get_by_test_id("add-to-cart").click()
    expect(page.get_by_test_id("cart-count")).to_have_text("2")
    page.goto("/checkout")
    page.get_by_label("জেলা").select_option("Dhaka")
    page.get_by_label("ঠিকানা").fill("বাড়ি ১২, মিরপুর")
    page.get_by_label("মোবাইল নম্বর").fill("01712345678")
    page.get_by_test_id("pay-cash").check()
    expect(page.get_by_test_id("quote-total")).to_have_text("961")
    page.get_by_test_id("place-order").click()
    expect(page).to_have_url(re.compile(r"/orders/\d+"))
    expect(page.get_by_test_id("order-status")).to_have_attribute("data-status", "placed")
    expect(page.get_by_test_id("order-total")).to_have_text("961")

সমস্যাগুলো চোখে পড়ে একটু খুঁটিয়ে দেখলে। এক, test-এর উদ্দেশ্য (১০০১ টাকার কার্টে কুপন পেরিয়ে ঢাকায় মোট ৯৬১) আঠারো লাইনের Playwright-কলের নিচে চাপা পড়েছে। দুই, “কার্টে যোগ করে badge-এর জন্য অপেক্ষা” এই তিন লাইন একই ফাইলের আরও দুটি test-এ হুবহু আছে। তিন, cart-count শব্দটি পুরো ফাইলে ৫ বার। কাল কেউ এই test id-এর নাম বদলালে পাঁচ জায়গায় হাত দিতে হবে; পঞ্চাশটি test থাকলে আরও বেশি। এমন test-কে পর্ব ২২-এ বলা হয়েছিল fragile test: আচরণ ঠিক থাকলেও কাঠামোর ছোট বদলে ভাঙে।

মূল ধারণা

Page object হলো একটি class, যা একটি পাতা বা পাতার একটি অংশকে প্রতিনিধিত্ব করে। এর ভেতরে থাকে সেই অংশের locator আর ব্যবহারকারীর কাজগুলো method হিসেবে (add_to_cart(), place_order())। Test শুধু এই method ডাকে। পাতার HTML বদলালে বদলায় শুধু page object, test নয়। পুরো কাঠামোটিকে একসাথে বলে Page Object Model, সংক্ষেপে POM.

ধারণাটি পুরোনো। Martin Fowler ১০ সেপ্টেম্বর ২০১৩-তে তাঁর “PageObject” লেখায় জানান, তিনি এর আগে একই ধারণাকে “Window Driver” নামে বর্ণনা করেছিলেন, আর “page object” নামটি জনপ্রিয় হয় Selenium সম্প্রদায়ের মাধ্যমে; Selenium প্রকল্পের wiki আর আজকের নথিও এটি ব্যবহারের পরামর্শ দেয়। সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫১-এ JavaScript-এ এর একটি ছোট পরিচয় আছে, আর ফুল-স্ট্যাক ওয়েব ফ্রেমওয়ার্ক কোর্সের পর্ব ৭৬-এ Playwright E2E. এখানে আমরা যাব অনেক গভীরে: স্তর, বিতর্ক, anti-pattern আর সত্যিকারের মাপজোখ।

২ · Page object-এর ভেতরে কী থাকে

Page object বানানোর নিয়ম কয়েকটি, আর প্রতিটির পেছনে একটি কারণ আছে:

নিয়মকেন
Locator থাকে শুধু page object-এUI বদলালে ঠিক করার জায়গা একটি
Method-এর নাম ব্যবহারকারীর কাজে: add_to_cart(), “বোতাম ৩-এ ক্লিক” নয়Test পড়ে বোঝা যায় কী যাচাই হচ্ছে
পরের পাতায় গেলে নতুন page object ফেরত দেয়Test-এর পথ কোডেই দেখা যায়: place_order() দেয় OrderPage
নিজের কাজ শেষ হওয়া পর্যন্ত অপেক্ষা করে“ক্লিক হলো কিন্তু badge এখনো বদলায়নি” সমস্যা test-এ ছড়ায় না
সাধারণত assertion করে না; মান বা locator দেখায়রায় দেওয়া test-এর কাজ (§৪)
পুরো পাতা নয়, অর্থপূর্ণ অংশ ধরেHeader, কার্টের সারি, product card আলাদা component

শেষ নিয়মটি নিয়ে Fowler নিজেই মজা করে বলেছেন, নামটা “panel object” হলে ভালো হতো, কারণ একটি পাতায় কয়েকটি object থাকতে পারে। বাজারঘরের প্রতিটি পাতার ওপরে একই header: খোঁজার ঘর, কার্টের badge, লগইন করা নাম। একে প্রতিটি page object-এ আলাদা করে লিখলে আবার পুনরাবৃত্তি। তাই header হলো একটি component object, যা সব page object নিজের ভেতরে রাখে। Selenium-এর নথিও একই কথা বলে: component ছোট অংশ (navigation bar, product item), page object-এর ভেতরে বসে, এমনকি component-এর ভেতরেও component থাকতে পারে।

এই পর্বের lab-এ header component-টি এমন (Python class-এর মূল ধারণা লাগলে পাইথন কোর্সের পর্ব ৩১ দেখুন):

from playwright.sync_api import Page, expect


class HeaderBar:
    """Component object: the header that every page shares."""
    CART_COUNT = "cart-count"            # the only place this test id lives

    def __init__(self, page: Page):
        self.page = page
        self.cart_count = page.get_by_test_id(self.CART_COUNT)
        self.user_name = page.get_by_test_id("nav-user")

    def count(self) -> int:
        return int(self.cart_count.inner_text())

    def wait_for_count(self, n: int):
        # synchronisation for an action, not the test's verification
        expect(self.cart_count).to_have_text(str(n))

আর পণ্যের পাতা ও checkout-এর page object (মূল অংশ):

class BasePage:
    PATH = "/"
    def __init__(self, page: Page):
        self.page = page
        self.header = HeaderBar(page)        # every page has the header
    def open(self):
        self.page.goto(self.PATH)
        return self

class ProductPage(BasePage):
    def __init__(self, page: Page, product_id: int):
        super().__init__(page)
        self.PATH = f"/products/{product_id}"
        self.add_button = page.get_by_test_id("add-to-cart")

    def add_to_cart(self):
        before = self.header.count()
        self.add_button.click()
        self.header.wait_for_count(before + 1)   # the fetch + 400 ms badge
        return self

class CheckoutPage(BasePage):
    PATH = "/checkout"
    # __init__ sets self.total = page.get_by_test_id("quote-total")
    def fill_delivery(self, district: str, address: str, phone: str):
        self.page.get_by_label("জেলা").select_option(district)
        self.page.get_by_label("ঠিকানা").fill(address)
        self.page.get_by_label("মোবাইল নম্বর").fill(phone)
        return self
    def place_order(self) -> "OrderPage":
        self.page.get_by_test_id("place-order").click()
        self.page.wait_for_url("**/orders/*")
        return OrderPage(self.page)

খেয়াল করুন তিনটি ব্যাপার। add_to_cart() নিজেই badge বাড়া পর্যন্ত অপেক্ষা করে: বাজারঘরে badge বদলায় fetch শেষ হওয়ার ৪০০ মিলিসেকেন্ড পরে, আর এই খুঁটিনাটি জানার দায় পাতার, test-এর নয়। Method-গুলো self বা পরের পাতা ফেরত দেয়, তাই কলগুলো শিকলের মতো জোড়া যায়: CheckoutPage(page).open().fill_delivery(…).place_order(). একে বলে fluent interface. আর BasePage ছোট রাখা হয়েছে; তাতে শুধু যা সত্যিই সব পাতার সাধারণ, অর্থাৎ header আর open().

1def test_checkout(page):2  login(page)3  page.goto("/products/3")4  …test_id("add-to-cart").click()5  …test_id("cart-count") … "1"6  (৯ নম্বর পণ্যে একই ৩ লাইন)7  …label("জেলা").select_option8  …label("ঠিকানা").fill(…)9  …test_id("pay-cash").check()10 …test_id("place-order").click()11 expect(…"order-total")…"961"
কী কোথায় গেল
নতুন class
cart-count লেখা
  1. Locator চিহ্নিত করা। ছোট করা কোডে লাইন ৪, ৫ আর ৭–১০ সরাসরি পাতার ঘর বা বোতাম ছোঁয়; আসল ১৮ লাইনের test-এ প্রায় প্রতিটি লাইনই এমন। এগুলোই পাতার “জানা-শোনা”; test-এর উদ্দেশ্য নয়। প্রথম কাজ এদের আলাদা করে চেনা।
  2. সবার সাধারণ অংশ: header. Cart badge প্রতিটি পাতায় থাকে, তাই লাইন ৫ যায় HeaderBar component-এ। ফাইলে ৫ বার লেখা cart-count এখন ১ বার, header.py-তে।
  3. পুনরাবৃত্ত কাজ: কার্টে যোগ। “পাতায় যাওয়া, বোতাম চাপা, badge-এর অপেক্ষা” তিন লাইন দুবার এসেছে (৩–৬)। এগুলো মিলে হলো ProductPage.add_to_cart(), যা আগের সংখ্যা পড়ে, ক্লিক করে, এক বাড়া পর্যন্ত অপেক্ষা করে।
  4. লগইন আর checkout-এর পাতা। লাইন ২ যায় LoginPage.login_as()-এ; লাইন ৭–১০ ভাগ হয় fill_delivery(), choose_payment() আর place_order()-এ, যার শেষটি OrderPage ফেরত দেয়।
  5. Test-এ যা রইল। একটি flow (Shopper) page object-গুলো জোড়া দেয়, আর test হলো চার লাইনের: কে, কী কিনলেন, কীভাবে অর্ডার দিলেন, আর রায় (অবস্থা placed, মোট ৯৬১)। Assertion test-এই থাকল।

৩ · স্তর সাজানো — test → flow → page → driver

বড় suite-এ page object একা যথেষ্ট নয়। “লগইন করে তিনটি পণ্য কার্টে দেওয়া” কাজটি দশটি test-এ লাগে; প্রতিটি test-এ page object-এর একই চার-পাঁচটি কল আবার পুনরাবৃত্তি। তাই আরও একটি স্তর: flow (কেউ বলেন workflow, action বা step). Flow হলো ব্যবহারকারীর একটি যাত্রা, যা কয়েকটি page object জোড়া দেয়। ফলে কাঠামো দাঁড়ায় চার স্তরে, আর নিয়ম একটাই: প্রতিটি স্তর শুধু ঠিক নিচের স্তরকে চেনে।

বাজারঘরের UI suite-এর স্তর

Each layer talks only to the one below it; a UI change is fixed in the page layer

Tests → Flows → Pages ও components → Driver → Browser → App Tests · উদ্দেশ্য + রায় test_pom.py · expect(…) Flows · ব্যবহারকারীর যাত্রা Shopper.log_in().checkout() Pages + components LoginPage · ProductPage CheckoutPage · HeaderBar সব locator শুধু এখানে Driver · Playwright Page · Locator Browser · headless Edge App · বাজারঘর 127.0.0.1 UI বদল → এখানে ঠিক
ছবি ৩৯.১ — ওপরের স্তর ব্যবহারকারীর ভাষায়, নিচের স্তর যন্ত্রের ভাষায়। App-এর HTML বদলালে মেরামত হয় page স্তরে; test আর flow অক্ষত থাকে।
স্তরকী জানেকী জানে না
Testউদ্দেশ্য, test data, প্রত্যাশিত ফল (নিয়ম থেকে)কোনো locator বা URL
Flowকোন পাতার পরে কোন পাতা; একটি যাত্রার ধাপlocator; রায়
Page / componentlocator, action, নিজের অপেক্ষাব্যবসার নিয়ম (কুপন কত হবে)
Driverbrowser চালানোবাজারঘর কী জিনিস

কাঠামোটি কতটা সরল, তা দেখতে browser ছাড়াই একটি ছোট মডেল চালান। এখানে FakeDriver Playwright-এর জায়গায় বসেছে: আসল কিছু চালায় না, শুধু কোন কল এলো তা লিখে রাখে আর একটি খুদে কার্ট রাখে, যাতে কুপনের হিসাব (১০০০-এর বেশি হলে ১০%, ভগ্নাংশ বাদ, সর্বোচ্চ ৩০০) সত্যি হয়। প্রতিটি লাইনের শুরুতে কোন স্তর থেকে কল এসেছে, সেটি ছাপা হয়:

class FakeDriver:                       # stands in for Playwright's page
    PRICE = {3: 880, 9: 121}
    def __init__(self): self.url, self.cart, self.log = "/", [], []
    def act(self, layer, what): self.log.append(f"{layer:<6}| {what}")
    def goto(self, path): self.act("driver", "goto " + path); self.url = path
    def click(self, tid):
        self.act("driver", f"click [{tid}]")
        if tid == "add-to-cart": self.cart.append(int(self.url[10:]))
    def text(self, tid):
        self.act("driver", f"read  [{tid}]")
        sub = sum(self.PRICE[p] for p in self.cart)
        disc = min(300, sub // 10) if sub > 1000 else 0
        return {"cart-count": str(len(self.cart)),
                "cart-discount": f"{disc} টাকা"}[tid]
class HeaderBar:                        # component object (on every page)
    CART = "cart-count"
    def __init__(self, d): self.d = d
    def count(self): return self.d.text(self.CART)
class ProductPage:                      # page object: locators + actions
    def __init__(self, d, pid): self.d, self.pid = d, pid
    def add_to_cart(self):
        self.d.act("page", f"ProductPage({self.pid}).add_to_cart()")
        self.d.goto(f"/products/{self.pid}"); self.d.click("add-to-cart")
        return self
class CartPage:
    def __init__(self, d): self.d = d
    def discount(self): self.d.goto("/cart"); return self.d.text("cart-discount")
def add_products(d, *ids):              # flow layer: a user journey
    d.act("flow", f"add_products{ids}")
    for pid in ids: ProductPage(d, pid).add_to_cart()
d = FakeDriver()                        # test layer: intent + assertion
add_products(d, 3, 9)
ok = CartPage(d).discount() == "100 টাকা"
print("count:", HeaderBar(d).count(), "| discount ok:", ok)
print(*d.log, sep="\n")

আসল আউটপুট:

count: 2 | discount ok: True
flow  | add_products(3, 9)
page  | ProductPage(3).add_to_cart()
driver| goto /products/3
driver| click [add-to-cart]
page  | ProductPage(9).add_to_cart()
driver| goto /products/9
driver| click [add-to-cart]
driver| goto /cart
driver| read  [cart-discount]
driver| read  [cart-count]

Test-এর অংশ মাত্র চার লাইন, তাতে কোনো locator নেই। Flow স্তর একবার ডাকা হলো, page স্তর দুবার (দুটি পণ্য), আর driver স্তরে গেল সাতটি আসল কাজ। ৮৮০ + ১২১ = ১০০১ টাকা, তাই ছাড় ১০০, আর discount ok: True; এটি FakeDriver-এর ছোট কার্ট থেকে সত্যিই হিসাব করা। এখন একটি পরীক্ষা করুন: HeaderBar.CART-এর মান বদলে "cart-badge" লিখে চালান। KeyError আসবে, আর traceback দেখাবে কলটি এসেছে HeaderBar.count() থেকে: ভাঙার জায়গা একটি, মেরামতের জায়গাও একটি। আসল browser-এ এই একই পরীক্ষা §৬-এ।

Flow কতটা মোটা হবে

Flow যত সুবিধার, তত বিপদেরও। buy_and_pay_and_review(user, items, method, stars) ধাঁচের একটি “সব-পারি” flow দশটি parameter আর ভেতরে if-এর জঙ্গল নিয়ে আসে; test পড়ে আর বোঝা যায় না কী ঘটছে। কাজের নিয়ম: flow ছোট আর নামেই বোঝা যায় এমন (log_in, add_products, checkout), ভেতরে শাখা-প্রশাখা নেই, আর যেকোনো test চাইলে flow বাদ দিয়ে সরাসরি page object ডাকতে পারে। Test-এ এক চিমটি পুনরাবৃত্তি থাকুক, যদি তাতে পড়া সহজ হয়; এটাই DAMP আর DRY-এর ভারসাম্য, যা পর্ব ২২-এ এসেছিল।

৪ · Assertion কোথায় থাকবে — একটি পুরোনো বিতর্ক

Page object-এর ভেতরে assertion থাকবে কি না, এ নিয়ে দলগুলোর মধ্যে বহু বছরের মতভেদ। Fowler তাঁর ২০১৩-এর লেখায় সরাসরি বলেছেন, তিনি page object-এ কোনো assertion না রাখার পক্ষে; ব্যতিক্রম শুধু পাতার নিজস্ব “invariant” যাচাই। Selenium-এর আজকের নথি আরও কড়া: page object কখনো যাচাই বা assertion করবে না; একমাত্র গ্রহণযোগ্য ব্যতিক্রম হলো object তৈরির সময় পাতাটি ঠিকমতো খুলেছে কি না দেখা। অন্য দিকে কিছু দল checkout.verify_total(961) ধাঁচের method পছন্দ করে, কারণ test আরও ছোট দেখায়।

মূল যুক্তিটি একটি ছোট উদাহরণে পরিষ্কার হয়। ধরুন login_as()-এর ভেতরে লেখা আছে “লগইন সফল কি না, assert করে দেখা”। এখন ভুল পাসওয়ার্ডের test লিখুন, যার প্রত্যাশা হলো লগইন ব্যর্থ হবে আর error দেখাবে। নিচের কোডে দুই ধরনের page object আর তিনটি সত্যিকারের unittest test আছে:

import sys, unittest

class FakeLogin:                        # tiny stand-in for the /login page
    USERS = {"mitu@bazarghar.test": "mitu1234"}
    def submit(self, email, pw):
        ok = self.USERS.get(email) == pw
        if ok:
            return {"nav-user": "মিতু রহমান"}
        return {"login-error": "ইমেইল বা পাসওয়ার্ড ভুল"}

class LoginPageWithAssert:              # anti-pattern: verification inside
    def login_as(self, email, pw):
        shown = FakeLogin().submit(email, pw)
        assert "nav-user" in shown, "login failed"
        return shown
class LoginPage:                        # better: report what the page shows
    def login_as(self, email, pw):
        return FakeLogin().submit(email, pw)

MITU = "mitu@bazarghar.test"
class LoginTests(unittest.TestCase):
    def test_bad_pw_assert_in_page(self):
        shown = LoginPageWithAssert().login_as(MITU, "wrong")
        self.assertIn("login-error", shown)
    def test_bad_pw_plain_page(self):
        shown = LoginPage().login_as(MITU, "wrong")
        self.assertEqual(shown.get("login-error"), "ইমেইল বা পাসওয়ার্ড ভুল")
    def test_good_pw_shows_name(self):
        shown = LoginPage().login_as(MITU, "mitu1234")
        self.assertEqual(shown.get("nav-user"), "মিতু রহমান")

suite = unittest.defaultTestLoader.loadTestsFromTestCase(LoginTests)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)

আসল আউটপুট:

test_bad_pw_assert_in_page (__main__.LoginTests.test_bad_pw_assert_in_page) ... FAIL
test_bad_pw_plain_page (__main__.LoginTests.test_bad_pw_plain_page) ... ok
test_good_pw_shows_name (__main__.LoginTests.test_good_pw_shows_name) ... ok

======================================================================
FAIL: test_bad_pw_assert_in_page (__main__.LoginTests.test_bad_pw_assert_in_page)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 23, in test_bad_pw_assert_in_page
    shown = LoginPageWithAssert().login_as(MITU, "wrong")
  File "main.py", line 14, in login_as
    assert "nav-user" in shown, "login failed"
           ^^^^^^^^^^^^^^^^^^^
AssertionError: login failed

----------------------------------------------------------------------
Ran 3 tests in 0.001s

FAILED (failures=1)

প্রথম test ব্যর্থ হলো, কিন্তু app-এর কোনো দোষে নয়: ভুল পাসওয়ার্ডে error দেখানো ঠিক আচরণ। ব্যর্থ করেছে page object নিজে, তার ভেতরের assert, আর বার্তা “login failed” পড়ে মনে হয় app ভেঙেছে। দ্বিতীয় রূপে page object শুধু জানায় পাতায় কী দেখা গেল, আর রায় দেয় test; ফলে একই page object দিয়ে positive আর negative দুই রকম test লেখা গেল। এটাই মূল কারণ: assertion page-এ বসালে page object একটিমাত্র “প্রত্যাশিত” পথে বাঁধা পড়ে।

অপেক্ষা আর assertion আলাদা জিনিস

তাহলে HeaderBar.wait_for_count()-এর ভেতরে expect কেন? কারণ সেটি রায় নয়, synchronisation: “আমার ক্লিকের কাজ শেষ হোক, তারপর ফেরত দিই।” প্রশ্নটি হলো উদ্দেশ্যের। Page object নিজের action শেষ হওয়ার শর্তের জন্য অপেক্ষা করতে পারে, যেমন URL বদলানো বা badge এক বাড়া। কিন্তু “কুপন ১০০ হওয়া উচিত” ধাঁচের ব্যবসায়িক প্রত্যাশা থাকে test-এ, যেখানে এর উৎস, অর্থাৎ requirement, স্পষ্ট দেখা যায়। Playwright-এ একটি সুন্দর মাঝামাঝি পথ আছে: page object locator দেখায় (cart.discount), আর test তার ওপর web-first assertion চালায় (expect(cart.discount).to_have_text("100 টাকা")), যা নিজে থেকেই বারবার চেষ্টা করে। ফলে page object-এ assertion লাগে না, আবার test-এ অপেক্ষার কোডও লাগে না। এই পর্বের lab-এর test এমন:

from playwright.sync_api import Page, expect
from flows.shopper import Shopper, MITU
from pages.shop_pages import CartPage
from pages.components.header import HeaderBar

OIL, POTATO = 3, 9          # 880 + 121 = 1001 taka


def test_add_one_product_updates_badge(page: Page):
    Shopper(page, MITU).log_in().add_products(OIL)
    expect(HeaderBar(page).cart_count).to_have_text("1")


def test_coupon_applies_just_above_1000(page: Page):
    Shopper(page, MITU).log_in().add_products(OIL, POTATO)
    cart = CartPage(page).open()
    expect(cart.subtotal).to_have_text("1001 টাকা")
    expect(cart.discount).to_have_text("100 টাকা")


def test_checkout_cash_in_dhaka(page: Page):
    order = Shopper(page, MITU).log_in().add_products(OIL, POTATO).checkout()
    expect(order.status).to_have_attribute("data-status", "placed")
    expect(order.total).to_have_text("961")

৯৬১ সংখ্যাটি নিয়ম থেকে: পণ্যের দাম ১০০১, কুপন ছাড় ১০০ (১০০০-এর বেশি, তাই ছাড় আছে), ঢাকায় ডেলিভারি ৬০ (২০০০-এর কম), মোট ১০০১ − ১০০ + ৬০ = ৯৬১। Test-এ সংখ্যাটি দেখেই একজন reviewer নিয়মের সাথে মেলাতে পারেন; page object-এর ভেতরে লুকানো থাকলে পারতেন না।

৫ · সত্যিকারের run — raw আর page-object, একই ফল

এই পর্বের সব browser run একটি Windows ডেস্কটপে, আলাদা scratch ফোল্ডারে: Python 3.12, pytest 9.2.0 (MIT লাইসেন্স), Playwright for Python 1.65.2 আর pytest-playwright 0.10.0 (দুটোই Apache-2.0), আর কম্পিউটারে আগে থেকে থাকা Microsoft Edge 157, headless. Playwright-এর নিজস্ব browser নামানো হয়নি। বাজারঘরের app (MIT) চলেছে নিজের কপি থেকে 127.0.0.1:8795-এ, test mode-এ, নিজের database ফাইলে; প্রতিটি test-এর আগে /api/test/reset seed data ফিরিয়ে আনে। Path নিরপেক্ষ করা হয়েছে, কোনো বাইরের website ছোঁয়া হয়নি।

suite/
  pyproject.toml          # pytest options: msedge, base URL
  conftest.py             # reset fixture, 5 s action timeout
  pages/
    components/header.py  # HeaderBar
    shop_pages.py         # Base, Login, Product, Cart,
                          #   Checkout, Order pages
  flows/shopper.py        # Customer data + Shopper flow
  tests/
    raw/test_raw.py       # 3 tests, Playwright calls inline
    pom/test_pom.py       # the same 3 tests via flows/pages
cd ~/bazarghar-qa/suite
uv add pytest pytest-playwright      # browser download not needed
# pyproject: addopts = "--browser-channel=msedge --base-url=http://127.0.0.1:8795"
uv run pytest tests -v

সত্যিকারের আউটপুট (মাথার কয়েকটি লাইন বাদ):

collecting ... collected 6 items

tests/pom/test_pom.py::test_add_one_product_updates_badge[chromium] PASSED [ 16%]
tests/pom/test_pom.py::test_coupon_applies_just_above_1000[chromium] PASSED [ 33%]
tests/pom/test_pom.py::test_checkout_cash_in_dhaka[chromium] PASSED      [ 50%]
tests/raw/test_raw.py::test_add_one_product_updates_badge[chromium] PASSED [ 66%]
tests/raw/test_raw.py::test_coupon_applies_just_above_1000[chromium] PASSED [ 83%]
tests/raw/test_raw.py::test_checkout_cash_in_dhaka[chromium] PASSED      [100%]

============================= 6 passed in 11.81s ==============================

দুটি suite একই আচরণ যাচাই করে, তাই ফলও এক; সময়ও প্রায় সমান, কারণ page object কোনো বাড়তি browser-কাজ করে না, শুধু কোড সাজায়। Test-এর নামের পাশে [chromium] দেখে বিভ্রান্ত হবেন না: Edge-ও Chromium-ভিত্তিক, তাই pytest-playwright তাকে এই নামেই দেখায়।

এবার সৎ হিসাবটা। লাইন গুনলে (wc -l): test_raw.py ৫০ লাইন, test_pom.py ২৪ লাইন। কিন্তু page-object সংস্করণের পেছনে আছে আরও ১৩০ লাইন (shop_pages.py ৭৭, header.py ১৮, shopper.py ৩৫)। অর্থাৎ তিনটি test-এর জন্য POM মোট কোড বাড়িয়েছে, ৫০ থেকে ১৫৪। লাভ আসে test-এর সংখ্যা বাড়লে: নতুন test আর নতুন locator লেখে না, আগের page object ব্যবহার করে। দুটি-তিনটি test-এর ছোট প্রকল্পে POM বানানো অনেক সময় বাড়তি নকশা; পঞ্চাশটি test-এ এটি রক্ষাকবচ।

  1. TestShopper(page, MITU)উদ্দেশ্য
  2. log_in()LoginPageflow → page
  3. add_products(3, 9)ProductPage ×2flow → page
  4. checkout()CheckoutPage → OrderPageflow → page
  5. রায়expect(order.total)test
test_pom.pyএক লাইনে পুরো যাত্রা
order = Shopper(page, MITU).log_in()
          .add_products(OIL, POTATO)
          .checkout()
# MITU: email, password, name
# (flows/shopper.py-তে test data)
LoginPage.login_as()driver-এ যা যায়
goto /login
get_by_label("ইমেইল").fill(…)
get_by_label("পাসওয়ার্ড").fill(…)
get_by_role("button", name="লগইন করুন")
  .click()
nav-user দেখা পর্যন্ত অপেক্ষা
ProductPage.add_to_cart()দুবার
পণ্য 3: count() → 0, click,
        wait_for_count(1)
পণ্য 9: count() → 1, click,
        wait_for_count(2)
# badge বদলায় fetch-এর 400 ms পরে
CheckoutPagefluent শিকল
.open()                 goto /checkout
.fill_delivery("Dhaka", …)
.choose_payment("cash") pay-cash
.place_order()          place-order
  → wait_for_url(**/orders/*)
  → return OrderPage(page)
test_pom.pyরায় test-এ
expect(order.status)
  .to_have_attribute("data-status",
                     "placed")
expect(order.total).to_have_text("961")
PASSED
  1. Test শুরু। Test শুধু বলে কে (মিতু), কী কিনবেন (তেল আর আলু) আর কী করবেন (checkout). কোনো URL, label বা test id নেই। মিতুর ইমেইল-পাসওয়ার্ড একটি ছোট dataclass-এ, একবার লেখা।
  2. লগইন। log_in() flow LoginPage খোলে আর login_as() ডাকে। Page object ফর্ম পূরণ করে, বোতাম চাপে, তারপর header-এ মিতুর নাম আসা পর্যন্ত অপেক্ষা করে; এটি নিজের action শেষ হওয়ার শর্ত, রায় নয়।
  3. দুটি পণ্য। add_products(3, 9) প্রতিটি পণ্যের জন্য একটি ProductPage বানায়। প্রতিবার আগের সংখ্যা পড়ে (০, তারপর ১), ক্লিক করে, আর এক বাড়া পর্যন্ত অপেক্ষা করে। ৪০০ মিলিসেকেন্ডের দেরির খবর শুধু এখানে।
  4. Checkout. CheckoutPage-এর method-গুলো শিকলে চলে, কারণ প্রতিটি self ফেরত দেয়। place_order() নতুন URL-এর জন্য অপেক্ষা করে OrderPage ফেরত দেয়; test পরের পাতার object হাতে পায়।
  5. রায়। Test OrderPage-এর দুটি locator-এ web-first assertion চালায়: অবস্থা placed, মোট ৯৬১। সত্যিকারের run-এ PASSED. ব্যর্থ হলে বার্তা আসবে test-এর লাইন থেকে, যেখানে প্রত্যাশা লেখা।

৬ · UI বদলাল — একটি data-testid-এর নাম

এবার আসল পরীক্ষা। ধরুন একজন developer header গুছাতে গিয়ে cart badge-এর test id cart-count থেকে cart-badge করলেন, আর নিজের দিকে ঠিকঠাক কাজ করলেন: template আর যে JavaScript badge বদলায়, দুটোই। App ব্যবহারকারীর কাছে হুবহু আগের মতো। এই বদলটি lab-এর app-এর কপিতে করা হলো (শেয়ার করা মূল app ছোঁয়া হয়নি):

--- templates/base.html
-  <span class="badge" data-testid="cart-count">{{ cart_count }}</span>
+  <span class="badge" data-testid="cart-badge">{{ cart_count }}</span>
--- static/app.js
-  document.querySelector('[data-testid="cart-count"]').textContent = …
+  document.querySelector('[data-testid="cart-badge"]').textContent = …

Server আবার চালু করে একই ৬টি test (সত্যিকারের আউটপুট, ছোট করে):

tests\pom\test_pom.py FFF                                                [ 50%]
tests\raw\test_raw.py FFF                                                [100%]
________________ test_add_one_product_updates_badge[chromium] _________________
tests\pom\test_pom.py:10: in test_add_one_product_updates_badge
    Shopper(page, MITU).log_in().add_products(OIL)
flows\shopper.py:28: in add_products
    ProductPage(self.page, pid).open().add_to_cart()
pages\shop_pages.py:35: in add_to_cart
    before = self.header.count()
pages\components\header.py:14: in count
    return int(self.cart_count.inner_text())
…
E   playwright._impl._errors.TimeoutError: Locator.inner_text: Timeout 5000ms exceeded.
E   Call log:
E     - waiting for get_by_test_id("cart-count")
…
tests\raw\test_raw.py:17: in test_add_one_product_updates_badge
E   AssertionError: Locator expected to have text '1'
E   Actual value: None
E   Error: element(s) not found
…
============================= 6 failed in 33.26s ==============================

দুই suite-ই লাল, যা প্রত্যাশিত: test id নেই, তাই কোনো test badge খুঁজে পায় না। কিন্তু traceback দুটির চেহারা আলাদা। Page-object সংস্করণের traceback স্তর ধরে নামে: test → shopper.py → shop_pages.py → header.py:14, আর সব তিনটি ব্যর্থতার শেষ বিন্দু একই লাইন। Raw সংস্করণের তিনটি ব্যর্থতা তিনটি আলাদা লাইনে (test_raw.py-এর ১৭, ২৪ আর ৩৭)। মেরামত:

@@ -3,7 +3,7 @@
 class HeaderBar:
     """Component object: the header that every page shares."""
-    CART_COUNT = "cart-count"            # the only place this test id lives
+    CART_COUNT = "cart-badge"            # the only place this test id lives
tests/pom/test_pom.py::test_add_one_product_updates_badge[chromium] PASSED [ 16%]
tests/pom/test_pom.py::test_coupon_applies_just_above_1000[chromium] PASSED [ 33%]
tests/pom/test_pom.py::test_checkout_cash_in_dhaka[chromium] PASSED      [ 50%]
tests/raw/test_raw.py::test_add_one_product_updates_badge[chromium] FAILED [ 66%]
tests/raw/test_raw.py::test_coupon_applies_just_above_1000[chromium] FAILED [ 83%]
tests/raw/test_raw.py::test_checkout_cash_in_dhaka[chromium] FAILED      [100%]
======================== 3 failed, 3 passed in 22.49s =========================

এক লাইনে page-object suite সবুজ। Raw suite-কে সবুজ করতে test_raw.py-এর ৫টি লাইন বদলাতে হলো (diff গুনে), তারপর 6 passed in 11.79s. পঞ্চাশটি raw test-এ badge থাকলে সংখ্যাটি পঞ্চাশের কাছাকাছি হতো, আর একটি বাদ পড়লে সেই test পরের run পর্যন্ত লাল থাকত। Page-object-এ সংখ্যাটি তখনও ১।

1base.html: data-testid=2  "cart-count" → "cart-badge"3app.js: [data-testid=4  "cart-count" → "cart-badge"5header.py: CART_COUNT =6  "cart-badge"   (১ লাইন)7test_raw.py: get_by_test_id(8  "cart-badge")  (৫ লাইন)
suite → ফল
raw (৩টি)
POM (৩টি)
test-কোডে বদল
  1. আগে। App অপরিবর্তিত; দুই suite মিলে ৬টি test, সব পাস, ১১.৮১ সেকেন্ডে।
  2. Developer-এর commit. Template আর JavaScript দুই জায়গায় test id বদলাল; ব্যবহারকারীর চোখে কিছুই বদলায়নি। ৬টি test-ই লাল। POM-এর তিনটির traceback শেষ হয় header.py:14-এ, raw-এর তিনটি তিন আলাদা লাইনে।
  3. Page object মেরামত। HeaderBar.CART_COUNT-এ এক লাইন বদল। POM-এর ৩টি সবুজ, raw-এর ৩টি এখনো লাল: ২২.৪৯ সেকেন্ডে 3 failed, 3 passed.
  4. Raw মেরামত। test_raw.py-তে ৫টি লাইন বদলে ৬টিই সবুজ। মোট মেরামত: POM-এ ১, raw-এ ৫; test বাড়লে raw-এর সংখ্যা বাড়ে, POM-এর বাড়ে না।

প্রথম চেষ্টায় একটি শিক্ষা: এই run প্রথমবার চালানোর সময় conftest.py-এ action timeout কমানো ছিল না। header.count()-এর inner_text() Playwright-এর ডিফল্ট ৩০ সেকেন্ড অপেক্ষা করেছিল, তাই POM-এর প্রতিটি ব্যর্থতায় ৩০ সেকেন্ড, আর পুরো run লাগল 6 failed in 108.10s. Page object-এর ভেতরের এমন “পড়া” (web-first assertion ছাড়া) ব্যর্থতাকে ধীর করে। তাই lab-এ একটি fixture সব পাতায় page.set_default_timeout(5000) বসিয়েছে, আর ওপরের ফল সেই সেটিং-এ। Timeout-এর মান নিজের app-এর গতি দেখে ঠিক করুন; খুব কম দিলে ধীর CI-তে মিথ্যা লাল আসবে (পর্ব ৪০-এর flaky test).

আরেকটি কথা: এই বদল test ধরে ফেলল, এটাও মূল্যবান। Test id একটি চুক্তি (পর্ব ৩৫); developer যদি suite-এর সাথে একই pull request-এ page object-এর লাইনটিও বদলান, তাহলে কেউ লাল দেখবেনই না। POM সেটা সহজ করে, কারণ developer-কে খুঁজতে হয় একটি ফাইল।

৭ · Anti-pattern — page object যেভাবে নষ্ট হয়

POM নিজে সমাধান নয়, একটি কাঠামো; ভুলভাবে বানালে raw test-এর চেয়েও খারাপ হতে পারে, কারণ সমস্যা লুকিয়ে থাকে আরও একটি স্তরের নিচে। সবচেয়ে চেনা ভুলগুলো:

Anti-patternলক্ষণপ্রতিকার
God page objectShopPage নামে একটি class-এ ৮০টি method, সব পাতারপাতা আর component ধরে ভাগ; একটি class-এর বদলের একটি কারণ
লুকানো assertionlogin_as() নিজেই সফলতা assert করে; negative test অসম্ভবমান বা locator ফেরত দিন, রায় test-এ
sleep ভেতরেtime.sleep(2) “badge-এর জন্য”; ধীর আর flakyশর্তে অপেক্ষা: expect, wait_for_url
Locator ফাঁসtest-এ page.get_by_test_id(…) আবার ফিরে এসেছেদরকারি locator page object-এর attribute হিসেবে দিন
গভীর inheritanceBasePage → ShopBase → CartBase → CartPage; কোন method কোথা থেকে, বোঝা যায় নাছোট base, বাকিটা component (composition)
Page-এ ব্যবসার নিয়মexpected_discount() page object-এ কুপন হিসাব করেপ্রত্যাশা নিয়ম থেকে, test-এ; নইলে app-এর ভুল test-এও কপি হয়
অবস্থা ভাগাভাগিpage object-এ class-level cart list, test-এর মাঝে টিকে থাকেপ্রতিটি test নতুন object আর নতুন browser context

প্রথম সারির নাম এসেছে সাধারণ সফটওয়্যার নকশার god class থেকে, আর প্রতিকারটি single responsibility principle; সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সে SOLID আর design pattern এসেছে, আর page object দেখতে অনেকটা সেখানকার পর্ব ৩৪-এর Facade-এর মতো: জটিল একটি subsystem-এর সামনে সরল একটি দরজা। ষষ্ঠ সারিটি সবচেয়ে সূক্ষ্ম। Page object-এ কুপনের হিসাব লিখলে সেটি app-এর কোডের আরেকটি কপি; app-এ >= আর >-এর ভুল থাকলে আপনার কপিতেও সেই ভুল ঢুকতে পারে, আর test খুশিমনে পাস করবে। প্রত্যাশিত মান আসবে requirement থেকে, লেখা থাকবে test-এ (পর্ব ১৫)।

৮ · Screenplay pattern — actor, task আর question

Page object প্রশ্ন করে “কোন পাতা?”; Screenplay pattern প্রশ্ন করে “কে, কী লক্ষ্যে?” এখানে test লেখা হয় নাটকের পাণ্ডুলিপির মতো: একজন actor (মিতু), তাঁর ability (browser চালানো, API ডাকা), তিনি task করেন (কার্টে পণ্য যোগ), task গড়া ছোট interaction দিয়ে (ক্লিক, টাইপ), আর শেষে তিনি question করেন (কার্টে কয়টি পণ্য দেখছি?)। Page বা locator তখন interaction-এর ভেতরের খুঁটিনাটি।

Serenity/JS-এর নথির ইতিহাস অনুযায়ী এর শুরু ২০০৭-এর দিকে: Kevin Lawrence interaction designer-দের ভাষায় test সাজানোর ধারণা দেন, আর Antony Marcano দেখান “Roles, Goals, Tasks, Actions” মডেল। পরে Andy Palmer, Jan Molak আর John Ferguson Smart-সহ কয়েকজন বিভিন্ন implementation বানান, আর ২০১৫-এ Java-র Serenity BDD-তে এটি সরাসরি সমর্থন পায়; ২০১৬-এ শুরু হয় JavaScript-এর Serenity/JS. Python-এ কয়েকটি ছোট লাইব্রেরি আছে, কিন্তু Java আর JavaScript-এর মতো প্রচলিত নয় (লেখার সময়ের অবস্থা)। নিচে browser ছাড়া ধারণাটির একটি ক্ষুদ্র মডেল:

class BrowseTheWeb:                     # ability: wraps the driver
    def __init__(self): self.cart, self.log = [], []
    def click_add(self, pid):
        self.cart.append(pid); self.log.append(f"click add-to-cart /products/{pid}")
    def read(self, tid):
        self.log.append(f"read [{tid}]"); return len(self.cart)

class Actor:
    def __init__(self, name): self.name, self.abilities = name, {}
    def can(self, ability): self.abilities[type(ability)] = ability; return self
    def ability(self, kind): return self.abilities[kind]
    def attempts_to(self, *tasks):
        for t in tasks: print(f"{self.name} attempts to {t}"); t.perform_as(self)
        return self
    def asks_for(self, question): return question.answered_by(self)

class AddToCart:                        # task: one business step
    def __init__(self, *ids): self.ids = ids
    def __str__(self): return f"add products {self.ids} to the cart"
    def perform_as(self, actor):
        for pid in self.ids: actor.ability(BrowseTheWeb).click_add(pid)

class CartCount:                        # question: what the actor can see
    def answered_by(self, actor): return actor.ability(BrowseTheWeb).read("cart-count")

mitu = Actor("Mitu").can(BrowseTheWeb())
mitu.attempts_to(AddToCart(3, 9))
seen = mitu.asks_for(CartCount())
print("Mitu sees", seen, "items | check == 2:", seen == 2)
print(*mitu.ability(BrowseTheWeb).log, sep="\n")

আসল আউটপুট:

Mitu attempts to add products (3, 9) to the cart
Mitu sees 2 items | check == 2: True
click add-to-cart /products/3
click add-to-cart /products/9
read [cart-count]

Test-এর ভাষা এখন প্রায় বাক্য: “Mitu attempts to add products (3, 9) to the cart”, তারপর তিনি যা দেখেন তা জিজ্ঞেস। Task ছোট, আলাদা class, একটি কাজ; নতুন কাজ লাগলে নতুন task যোগ হয়, পুরোনো class বড় হয় না। এটাই Screenplay-এর সমর্থকদের প্রধান যুক্তি: বড় page object যেমন ফুলে ওঠে, task তেমন ফোলে না। আর একই actor-কে API-এর ability দিলে UI আর API ধাপ এক test-এ মেশানো সহজ।

খরচও আছে। একটি সরল ক্লিকের জন্য actor, ability, task আর interaction মিলে অনেক class; নতুন সহকর্মীর শিখতে সময় লাগে, আর ছোট suite-এ এটি বাড়তি আনুষ্ঠানিকতা। বাস্তবে অনেক দল মাঝামাঝি পথে থাকে: page আর component object, ওপরে পাতলা flow, যা Screenplay-এর task-এর কাছাকাছি কাজ করে। কোনটি “সঠিক”, তার সাধারণ উত্তর নেই; suite-এর আকার, দলের অভিজ্ঞতা আর ভাষার tool দেখে বাছাই।

৯ · বাজারঘরের UI suite-এর কাঠামো

Page object একটি framework-এর একটি অংশমাত্র। বাজারঘরের UI suite পুরোপুরি দাঁড় করালে আরও কয়েকটি অংশ লাগে, আর প্রতিটির নিজস্ব জায়গা থাকা দরকার:

⚙️ কনফিগারেশন

Base URL, browser channel, timeout আর পরিবেশ (local, staging) pyproject.toml বা environment variable-এ; কোডে কোনো URL বা পাসওয়ার্ড নয়।

pyproject · env

🧰 Fixture

conftest.py-তে reset, লগইন করা context, timeout; scope আর পরিষ্কার করার নিয়ম পর্ব ২৩-এর মতো।

conftest.py

👤 Test data

Customer আর পণ্য dataclass বা builder-এ, seed data-র সাথে মিলিয়ে; নকল ফোন নম্বর, কোনো আসল তথ্য নয়।

data/ · builder

📊 রিপোর্ট ও CI

ব্যর্থতায় screenshot আর trace (পর্ব ৩৭), JUnit XML, আর CI-তে প্রতিটি pull request-এ smoke অংশ।

trace · junit.xml

ফোল্ডার ভাগের একটি সাধারণ নিয়ম: যা একসাথে বদলায়, তা একসাথে থাকে। পাতার নকশা বদলালে pages/; ব্যবহারকারীর যাত্রা বদলালে flows/; ব্যবসার নিয়ম বদলালে tests/ আর test data. Data-driven আর keyword-driven framework, আর একাধিক ধরন মেলানো hybrid framework, পর্ব ৪৫-এ; সেখানে এই কাঠামোর ওপরেই নতুন স্তর বসবে। Given-When-Then ভাষায় test (পর্ব ৪৩) লিখলেও নিচে এই page object আর flow-ই কাজ করবে।

আরও গভীরে: UI test-এর রক্ষণাবেক্ষণ নিয়ে একাডেমিক গবেষণাও হয়েছে; যেমন Leotta ও সহকর্মীদের ২০১৩ সালের দিকের একটি শিল্প-কেসভিত্তিক গবেষণা page object-সহ আর ছাড়া web test suite-এর বিবর্তন তুলনা করে রক্ষণাবেক্ষণের সময় কমার কথা জানায়। নির্দিষ্ট শতাংশ প্রকল্প আর প্রেক্ষাপটভেদে আলাদা, তাই প্রবণতাটি নিন, সংখ্যাটি নয়। আরেকটি আধুনিক প্রশ্ন: component-ভিত্তিক frontend (React, Vue) আর component testing-এর যুগে অনেক কিছু পাতার বদলে component স্তরেই যাচাই হয়, তাই E2E suite ছোট হয়, আর page object হয় component object-এর পাতলা মালা। “কত E2E” প্রশ্নটি test pyramid-এর (পর্ব ০৫); POM শুধু যেটুকু E2E থাকে তাকে টেকসই রাখে।

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

  • Page Object Model কী, আর লাভ কী? প্রতিটি পাতা বা অংশের locator আর action একটি class-এ; UI বদলালে এক জায়গায় মেরামত, test পড়া সহজ, পুনরাবৃত্তি কম।
  • Page object-এ assertion রাখা উচিত? সাধারণ নিয়মে না (Fowler, Selenium-এর নথি); ব্যতিক্রম পাতা ঠিকমতো খুলেছে কি না সেই যাচাই। রায় test-এ, যাতে negative test লেখা যায়।
  • Component object কেন? Header বা product card-এর মতো যে অংশ অনেক পাতায় আসে, তাকে একবার লিখে সব page object-এ ব্যবহার।
  • Page object-এর method কী ফেরত দেয়? একই পাতায় থাকলে self, অন্য পাতায় গেলে সেই পাতার object; এতে fluent শিকল আর স্পষ্ট পথ।
  • POM বনাম Screenplay? POM পাতা ধরে ভাগ করে, Screenplay actor-এর task আর question ধরে; Screenplay বড় suite-এ ভালো ভাগ দেয়, কিন্তু বেশি class আর শেখার খরচ।

১০ · AI-এর যুগে — AI দিয়ে page object লেখানো

AI সহকারীকে “এই test-গুলো POM-এ সাজিয়ে দিন” বললে কয়েক সেকেন্ডে পরিপাটি class আসে, আর পরিপাটি দেখেই ভুল চোখ এড়ায়। চেনা ভুলগুলো: পাতা না দেখে কল্পিত locator বা method (page.wait_for_badge() নামে কিছু Playwright-এ নেই); প্রতিটি method-এ assert বা time.sleep; সব পাতা এক বিশাল class-এ; app-এর কুপন হিসাব page object-এ কপি করে “expected” বানানো, ফলে বর্তমান কোড যা করে তা-ই যাচাই হয়, requirement নয়; শুধু সুখী পথের (happy path) test; refactor-এর পরে test-এর অর্থ নীরবে বদলে যাওয়া (একটি assertion বাদ পড়া); আর না চালিয়েই “সব test পাস করবে” দাবি।

AI-কে আসল কোড আর স্পষ্ট সীমা দিন:

তুমি একজন অভিজ্ঞ test automation engineer. নিচে বাজারঘরের ৩টি raw Playwright for Python test আর পাতাগুলোর আসল HTML-এর অংশ দিলাম। এগুলো page object, component object আর একটি পাতলা flow স্তরে সাজাবে। নিয়ম: ১. শুধু HTML-এ সত্যিই থাকা data-testid, label আর role ব্যবহার করবে; কোনো locator অনুমান করবে না। ২. Page object-এ কোনো assert নয়; locator বা মান ফেরত দেবে, রায় test-এ expect দিয়ে। ৩. time.sleep নয়; অপেক্ষা শুধু শর্তে (expect, wait_for_url), আর শুধু নিজের action শেষ হওয়ার জন্য। ৪. প্রত্যাশিত সংখ্যা (যেমন 961) test-এ যেমন আছে তেমন থাকবে; কোনো হিসাব page object-এ সরাবে না। ৫. প্রতিটি পুরোনো assertion নতুন test-এ কোথায় গেল, একটি তালিকায় দেখাবে। ৬. তুমি কোড চালাওনি, তাই "পাস করবে" দাবি করবে না; Playwright-এর যে method ব্যবহার করবে, তার নাম official নথির সাথে মিলিয়ে দেখতে বলবে। [এখানে test আর HTML]

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

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

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

প্র ০১Fowler বলেছিলেন নামটা “panel object” হলে ভালো হতো। পাতা না অংশ, page object কীসের প্রতিনিধি হওয়া উচিত?

“Page object” নামটি এসেছে এমন এক যুগ থেকে, যখন web app মানে ছিল আলাদা আলাদা পাতা: প্রতিটি ক্লিকে server নতুন HTML পাঠাত, আর একটি URL মানে একটি পর্দা। Selenium-এর প্রথম দিকের বছরগুলোতে (২০০০-এর দশকের মাঝামাঝি থেকে) “প্রতিটি পাতার জন্য একটি class” নিয়মটি স্বাভাবিক ছিল। Martin Fowler ২০১৩-এর লেখায় সতর্ক করেন যে নামটি বিভ্রান্তিকর: object বানানো উচিত পাতার অর্থপূর্ণ অংশ ধরে, যেমন একটি album তালিকা, তার ভেতরে প্রতিটি album, আর header-footer; সেজন্যই তাঁর মতে “panel object” ভালো নাম হতো।

আজকের single-page app-এ এই কথা আরও সত্য। বাজারঘর server-rendered হলেও তার checkout পাতায় জেলা বদলালে মোট দাম JavaScript-এ বদলায়, header সব পাতায় একই, আর product card প্রথম পাতা আর খোঁজার ফল দুই জায়গায় আসে। “প্রতিটি URL-এর জন্য একটি class” নিয়ম মানলে card আর header-এর locator অন্তত দুই-তিন জায়গায় কপি হতো, যা POM-এর মূল উদ্দেশ্যেরই বিপরীত।

একটি কাজের মাপকাঠি: একটি object-এর বদলের কারণ একটি হওয়া উচিত। Header-এর নকশা বদলানো এক দলের কাজ, checkout ফর্ম আরেক দলের; দুটো এক class-এ থাকলে দুই দলের বদল একই ফাইলে সংঘাত বাধায়। Frontend যেভাবে component-এ ভাগ করা, test-এর object-গুলোও সেভাবে ভাগ করলে মিল সহজ হয়: HeaderBar, ProductCard, CartRow, আর পাতা হলো এদের একটি সাজানো রূপ। Selenium-এর আজকের নথিও এই component ধারণাকে স্পষ্ট সমর্থন করে।

তবে উল্টো দিকের বাড়াবাড়িও আছে: প্রতিটি বোতামের জন্য একটি class বানালে কোড খুঁজতে খুঁজতেই দিন যায়। সীমা টানুন পুনর্ব্যবহারে: যে অংশ একাধিক পাতায় আসে বা একটি পাতায় বারবার আসে (তালিকার সারি), সেটি component; বাকিটা পাতার object-এর attribute.

মূল উপলব্ধি: Page object আসলে UI-এর অর্থপূর্ণ অংশের object; পাতা একটি সুবিধাজনক মোড়ক মাত্র, ভাগের আসল একক হলো component.

প্র ০২“Page object-এ কখনো assertion নয়” — এই নিয়মের পক্ষে-বিপক্ষে যুক্তি কী, আর Playwright-এর web-first assertion বিতর্কটিকে কীভাবে বদলেছে?

নিয়মটির পক্ষে দুটি শক্ত যুক্তি। প্রথমটি নমনীয়তা: assertion page-এ বসালে page object একটিমাত্র “প্রত্যাশিত” ফলে বাঁধা পড়ে। এই পর্বের Pyodide উদাহরণে login_as()-এর ভেতরের assert ভুল পাসওয়ার্ডের test-কে ব্যর্থ করেছে, অথচ app ঠিক আচরণ করছিল। দ্বিতীয়টি স্পষ্টতা: test পড়ে বোঝা উচিত কী যাচাই হচ্ছে। checkout()-এর ভেতরে লুকানো “মোট ৯৬১ কি না” পরীক্ষা reviewer দেখেন না, আর নিয়ম বদলালে কোন test কোন সংখ্যা ধরে আছে তা খুঁজে পাওয়া কঠিন। Fowler ২০১৩-এ এই কারণেই page object-এ assertion না রাখার পক্ষে বলেন, আর Selenium-এর নথি একে প্রায় আইন বানিয়েছে।

বিপক্ষের যুক্তিও উড়িয়ে দেওয়ার মতো নয়। কিছু যাচাই পাতার পরিচয়ের অংশ: “checkout পাতা খুলেছি তো?” এটি না দেখে এগোলে পরের ব্যর্থতার বার্তা বিভ্রান্তিকর হয়। তাই দুই সূত্রই ব্যতিক্রম রাখে: Fowler পাতার invariant-এর জন্য, Selenium object তৈরির সময় পাতা লোড যাচাইয়ের জন্য। আরেকটি বাস্তব চাপ: একই চার লাইনের assertion বিশটি test-এ; তখন দলগুলো assert_order_summary(...) ধাঁচের helper বানায়। সমাধান হলো সেই helper-কে test-স্তরের helper হিসেবে রাখা, page object-এর ভেতরে নয়।

Playwright-এর web-first assertion এই বিতর্কে একটি পুরোনো প্রযুক্তিগত চাপ সরিয়েছে। Selenium-যুগে অনেক দল page-এ assertion বসাত কারণ “অপেক্ষা করে তারপর যাচাই” কোড জটিল ছিল, আর সেটি একবার লিখে লুকিয়ে রাখা সুবিধাজনক। Playwright-এ expect(locator).to_have_text(...) নিজেই বারবার চেষ্টা করে; ফলে page object শুধু locator দেয়, test এক লাইনে অপেক্ষাসহ যাচাই করে। এই পর্বের test_pom.py ঠিক তা-ই করেছে।

তবে সূক্ষ্ম রেখাটি মনে রাখুন: page-এর ভেতরের wait_for_count()-এ expect আছে, কিন্তু তার উদ্দেশ্য action-এর শেষ চিহ্ন। উদ্দেশ্যই ঠিক করে কোনটি synchronisation আর কোনটি রায়।

মূল উপলব্ধি: Page object জানায় পাতায় কী আছে, test ঠিক করে সেটা ঠিক কি না; ব্যতিক্রম শুধু “ঠিক পাতায় আছি তো” যাচাই।

প্র ০৩Screenplay pattern-এর সমর্থকেরা বলেন page object বড় হতে হতে “god object” হয়। এই সমালোচনা কতটা ন্যায্য, আর কখন Screenplay বাছবেন?

Screenplay-এর ইতিহাস দেখায় এটি page object-এর প্রতিক্রিয়া থেকেই এসেছে। Serenity/JS-এর নথি অনুযায়ী ২০০৭-এর দিকে Kevin Lawrence আর Antony Marcano “Roles, Goals, Tasks, Actions” ভাষায় test সাজানোর ধারণা দেন; ২০০৮-এ Marcano আর Andy Palmer প্রথম পরীক্ষামূলক Java implementation বানান, আর ২০১৫-এ Serenity BDD-তে John Ferguson Smart আর Jan Molak-এর নেতৃত্বে এটি সরাসরি সমর্থন পায়। সমর্থকদের যুক্তি ছিল design-নীতির: বড় page object open-closed নীতি ভাঙে, কারণ নতুন কাজ মানে পুরোনো class-এ নতুন method; আর একটি পাতার class-এ অনেক ভিন্ন দায়িত্ব জমে।

সমালোচনা আংশিক ন্যায্য। বাস্তবে বহু প্রকল্পে CheckoutPage শত শত লাইনের হয়ে যায়: ফর্ম পূরণের দশ রকম রূপ, error পড়া, coupon, ঠিকানা বই। কিন্তু এর একটি বড় অংশ POM-এর দোষ নয়, ভুল ভাগের দোষ: component object আর পাতলা flow স্তর ব্যবহার করলে page object ছোট থাকে। এই পর্বের lab-এ Shopper flow প্রায় Screenplay-এর task-এর কাজই করছে, শুধু আলাদা নাম আর কম আনুষ্ঠানিকতায়।

Screenplay-এর সত্যিকারের বাড়তি লাভ তিনটি। এক, actor-ভিত্তিক ভাষা BDD-র Given-When-Then-এর সাথে ভালো মেলে (পর্ব ৪৩)। দুই, ability-র ধারণা UI, API আর database ধাপ একই ভাষায় মেশায়: একজন actor API দিয়ে অর্ডার বানিয়ে UI-তে যাচাই করতে পারেন। তিন, একাধিক actor-এর test (ক্রেতা অর্ডার দিলেন, admin ship করলেন) স্বাভাবিকভাবে লেখা যায়। খরচ হলো অনেক ছোট class, শেখার সময়, আর Python-এ তুলনামূলক কম প্রচলিত tool.

কখন বাছবেন: বড়, দীর্ঘজীবী suite, একাধিক দল, অনেক actor আর মিশ্র UI-API যাত্রা, এবং দলে কেউ আগে থেকে এই pattern জানেন। ছোট বা মাঝারি suite-এ page আর component object আর পাতলা flow সাধারণত যথেষ্ট, পরে দরকার হলে ধাপে ধাপে task-এর দিকে যাওয়া যায়।

মূল উপলব্ধি: God page object-এর মূল সমস্যা ভাগের অভাব; Screenplay একটি কড়া ভাগের ব্যাকরণ দেয়, কিন্তু সেই শৃঙ্খলা POM-এর ভেতরেও অনেকটা আনা যায়।

প্র ০৪Abstraction বাড়ালে test পড়া সহজ হয়, কিন্তু ব্যর্থতা খোঁজা কঠিনও হতে পারে। DRY আর DAMP-এর মধ্যে UI test-এ রেখা কোথায় টানবেন?

Production কোডে DRY (Don't Repeat Yourself) প্রায় সর্বজনীন নীতি; একই যুক্তি দুই জায়গায় থাকলে একদিন একটি বদলাবে, অন্যটি নয়। Test-এর জগতে একটি পাল্টা নীতি জনপ্রিয় হয়েছে: DAMP, “Descriptive And Meaningful Phrases”. এর মূল কথা, test-এর প্রথম কাজ নিজেকে ব্যাখ্যা করা; একটু পুনরাবৃত্তি থাকুক, যদি তাতে test একা পড়েই বোঝা যায়। দুটি নীতি আসলে বিরোধী নয়; তারা প্রশ্ন করে কোন জিনিস পুনরাবৃত্ত হচ্ছে।

UI test-এ একটি ব্যবহারিক রেখা: কীভাবে (locator, অপেক্ষা, ক্লিকের ক্রম) DRY, কী (উদ্দেশ্য, data, প্রত্যাশিত ফল) DAMP. এই পর্বের test_pom.py-তে Shopper(page, MITU).log_in() তিনটি test-এ আছে; এটিকে একটি fixture-এ লুকানো যেত, কিন্তু তাহলে test পড়ে বোঝা যেত না কে লগইন করেছেন আর কার্ট খালি থেকে শুরু কি না। অন্য দিকে cart-count locator পাঁচবার লেখা ছিল raw ফাইলে, যা স্পষ্টতা বাড়ায়নি, শুধু ঝুঁকি বাড়িয়েছে।

Debugging-এর দিকটিও গুরুত্বপূর্ণ। এই পর্বের ব্যর্থ run-এ POM-এর traceback চার স্তর পার হয়ে header.py:14-এ পৌঁছেছে। স্তর ভালো নামে ভাগ থাকলে এই পথ পড়া সহজ: কোন যাত্রা, কোন পাতা, কোন ঘর। কিন্তু flow-এর ভেতরে flow, তার ভেতরে generic “do_action(name)” ধাঁচের dispatcher থাকলে traceback একটি গোলকধাঁধা হয়, আর নতুন সহকর্মী ভয় পান। কিছু keyword-driven framework-এ (পর্ব ৪৫) ঠিক এই সমস্যা দেখা যায়।

রেখা টানার কয়েকটি প্রশ্ন: test একা পড়ে কি একজন নতুন tester বলতে পারেন কী যাচাই হচ্ছে? ব্যর্থতার বার্তা কি দুই ক্লিকে আসল কারণে পৌঁছায়? একটি UI বদলে কয়টি ফাইল খুলতে হয়? প্রথম দুটির উত্তর “হ্যাঁ” আর তৃতীয়টির “একটি” হলে abstraction ঠিক মাপের।

মূল উপলব্ধি: যন্ত্রের খুঁটিনাটি একবার লিখুন, ব্যবসার উদ্দেশ্য প্রতিটি test-এ স্পষ্ট রাখুন; abstraction-এর মাপ ঠিক করে পড়া আর debugging, সৌন্দর্য নয়।

প্র ০৫Page object কার সম্পত্তি — QA দলের, না developer-দের? Test id-এর চুক্তি আর code review-এর দিক থেকে ভাবুন।

পুরোনো অনেক প্রতিষ্ঠানে UI automation ছিল আলাদা QA দলের কাজ, আলাদা repository-তে, প্রায়ই আলাদা ভাষায়। Developer একটি template বদলাতেন, রাতের run লাল হতো, পরদিন QA দল খুঁজে বের করত কী বদলেছে। এই “ছুড়ে দেওয়া” মডেলে page object-ও একটি দেয়ালের ওপারে থাকত, আর প্রতিটি UI বদল ছিল একটি ছোট দুর্ঘটনা। এই পর্বের run ঠিক সেই দুর্ঘটনার একটি ছোট রূপ: developer নিজের দিকে সব ঠিক করেছিলেন, তবু ৬টি test লাল।

Shift-left আর DevOps-এর যুগে (পর্ব ০৪) অনেক দল UI test-কে app-এর একই repository-তে রাখে। তখন page object আর test id একটি চুক্তি: developer যে pull request-এ cart-count বদলান, সেই PR-এ header.py-ও বদলান, আর CI-তে UI suite সবুজ না হলে merge হয় না। POM এখানে বড় সাহায্য, কারণ developer-কে পঞ্চাশটি test নয়, একটি ফাইল খুঁজতে হয়। কোনো কোনো দল code owner নিয়মে pages/ ফোল্ডারের বদলে QA-র একজনের review বাধ্যতামূলক রাখে, যাতে locator-এর মান ঠিক থাকে।

দায়িত্ব ভাগের একটি যুক্তিসঙ্গত রূপ: test id আর accessible name app-এর অংশ, তাই developer-এর দায়িত্ব; page object আর flow যৌথ সম্পত্তি; test-এর উদ্দেশ্য, প্রত্যাশিত ফল আর ঝুঁকি বাছাই tester-এর দক্ষতার জায়গা। একজন tester page object review করেন locator-এর স্থিরতা আর অপেক্ষার নিয়ম দেখতে; একজন developer test review করেন ব্যবসার নিয়ম ঠিক বোঝা হয়েছে কি না দেখতে। এই পারস্পরিক review অনেক সময় দুই দলের চেয়ে বেশি bug ধরে।

ঝুঁকিও আছে: সবার সম্পত্তি মানে কখনো কারও সম্পত্তি নয়। পুরোনো, অব্যবহৃত method জমে, একই কাজের তিনটি রূপ তৈরি হয়। নিয়মিত পরিষ্কার, একজন নির্দিষ্ট রক্ষণাবেক্ষণকারী আর লেখা নির্দেশিকা তাই দরকার।

মূল উপলব্ধি: Page object সবচেয়ে ভালো কাজ করে যখন app-এর কোডের পাশে থাকে আর একই PR-এ বদলায়; test id আর page object মিলে developer ও tester-এর মধ্যে একটি লিখিত চুক্তি।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন।

  1. Spec থেকে page object আর test-এর নকশা: বাজারঘরের রিভিউ ফর্মে আছে পাঁচটি তারার radio (review-star-1 … review-star-5), লেখার ঘর (review-text-input), জমা দেওয়ার বোতাম (review-submit) আর ভুল হলে বার্তা (review-error). নিয়ম: তারা ১–৫ বাধ্যতামূলক; লেখা দুই প্রান্তের ফাঁকা বাদে ১০–৫০০ অক্ষর। একটি ReviewPage নকশা করুন (attribute আর method), আর এই page object দিয়ে কয়েকটি test-এর নাম ও data লিখুন।

    ReviewPage(page, product_id): PATH = /products/{id}/review; attribute text_box, error, submit_button; method choose_stars(n) (review-star-{n} check করে, self ফেরত), write(text) (self), submit() (সফল হলে পণ্যের পাতায় যায়, তাই সেই পাতার ProductPage; ব্যর্থ হলে একই পাতা থাকে, তাই অনেকে দুটি method রাখেন: submit() → ProductPage আর submit_expecting_error() → self). কোনো assertion নয়।

    Test (BVA আর EP, পর্ব ০৮): ৯ অক্ষর → error; ১০ অক্ষর → সফল; ৫০০ → সফল; ৫০১ → error; দুই প্রান্তে ফাঁকাসহ ১০ অক্ষর (মোট ১২) → সফল; তারা না বেছে → error; ৫টি emoji-সহ ১০ code point → সফল (review_utf16_length ভুল চালু থাকলে এখানে পার্থক্য দেখা যায়)। লগইন হবেন মিতু, পণ্য ডাল (২), কারণ seed data-য় শুধু এটিই তিনি এখনো রিভিউ করেননি আর পেয়েছেন; প্রতিটি test-এর আগে reset. প্রত্যাশিত ফল test-এ, নিয়ম থেকে।

  2. Failure পড়ুন আর ফল অনুমান করুন: একটি suite-এ ৩টি raw আর ৩টি POM test. App-এ cart badge-এর test id বদলানোর পরে POM-এর তিনটি ব্যর্থতার traceback শেষ হয় pages\components\header.py:14: in count লাইনে, বার্তা Locator.inner_text: Timeout 5000ms exceeded … waiting for get_by_test_id("cart-count"). (ক) কোন ফাইলে কী বদলাবেন? (খ) শুধু সেটি বদলালে pytest-এর শেষ লাইন কী হবে? (গ) কেন এখানে AssertionError নয়, TimeoutError?

    (ক) header.py-তে CART_COUNT-এর মান নতুন test id-তে। কিন্তু তার আগে app-এর diff দেখে নিশ্চিত হোন এটি ইচ্ছাকৃত নামবদল, badge উধাও হওয়ার bug নয়; হাতে পাতা খুলে badge দেখুন। (খ) এই পর্বের সত্যিকারের run-এ ঠিক এটাই হয়েছে: 3 failed, 3 passed; POM সবুজ, raw-এর locator এখনো পুরোনো। (গ) ব্যর্থতা ঘটেছে test-এর রায়ের আগে, page object-এর ভেতরের একটি পড়ায় (inner_text()), যা element-এর জন্য action timeout পর্যন্ত অপেক্ষা করে; raw test-এ প্রথম ব্যর্থ লাইন ছিল expect(...), তাই সেখানে AssertionError. বার্তার ধরন দেখেই বোঝা যায় কোন স্তরে আটকেছে।

  3. Page object-এ ভুল খুঁজুন: একজন সহকর্মীর লেখা; অন্তত পাঁচটি সমস্যা খুঁজুন।
    class ShopPage:                         # used by every test
        items = []
        def login(self):
            self.page.fill("#email", "mitu@bazarghar.test")
            self.page.fill("#password", "mitu1234")
            self.page.click("text=লগইন করুন")
            assert "মিতু" in self.page.content()
        def add_rice(self):
            self.page.click("ul li:nth-child(1) button")
            time.sleep(2)
            self.items.append("rice")
        def expected_total(self, subtotal):
            return subtotal - (subtotal // 10 if subtotal >= 1000 else 0) + 60

    (১) God page object: login, পণ্য, হিসাব সব এক ShopPage-এ; ভাগ করুন LoginPage, ProductPage/HomePage-এ। (২) items = [] class-level: সব object-এ একই list, এক test-এর অবস্থা পরের test-এ ঢোকে। (৩) login()-এর ভেতরে assert: ভুল পাসওয়ার্ডের test লেখা যাবে না, আর মিতু hard-code করা; ব্যবহারকারী parameter হোক। (৪) nth-child(1): অবস্থাভিত্তিক locator, ওপরে একটি card বসলেই অন্য পণ্য (পর্ব ৩৫); card-এর data-product-id দিয়ে সরু করুন। (৫) time.sleep(2): ধীর আর flaky; badge-এর শর্তে অপেক্ষা। (৬) expected_total: ব্যবসার নিয়ম page object-এ, আর তাতে কয়েকটি ভুল: >= (নিয়ম “১০০০-এর বেশি”), সর্বোচ্চ ৩০০-এর সীমা নেই, আর ডেলিভারি সবসময় ৬০ ধরা (ঢাকার বাইরে ১২০, ঢাকায় ২০০০ বা বেশি হলে ফ্রি)। প্রত্যাশা test-এ, requirement থেকে। (৭) #email আর text=… চলে, কিন্তু বাজারঘরে label ও test id আছে, সেগুলো বেশি স্থির।

  4. Bug report-এ ভুল খুঁজুন: একটি release-এর পরে রাতের run দেখে লেখা হলো: “শিরোনাম: কার্ট সম্পূর্ণ ভেঙে গেছে। Severity: Critical. বিবরণ: ৪৭টি UI test ব্যর্থ, সবগুলোতে cart-count পাওয়া যায়নি। Assign: frontend দল।” আগের release-এর সাথে diff-এ দেখা যায় badge-এর test id cart-badge হয়েছে। রিপোর্টে কী ভুল, আর আপনি কী করবেন?

    প্রথমে যাচাই: হাতে বা একটি ছোট script-এ কার্টে পণ্য যোগ করে badge বাড়ে কি না দেখুন। বাড়লে কার্ট ভাঙেনি; ভেঙেছে test-এর সাথে app-এর test id-চুক্তি। তাহলে “কার্ট সম্পূর্ণ ভেঙে গেছে” শিরোনাম আর Critical severity দুটোই ভুল পথে নেয়; ব্যবহারকারীর কোনো ক্ষতি নেই (পর্ব ১৮)। ৪৭টি ব্যর্থতা একটি কারণের ৪৭টি লক্ষণ, ৪৭টি bug নয়। সঠিক কাজ: test-রক্ষণাবেক্ষণের একটি task (“release X-এ cart badge-এর test id cart-count → cart-badge; page object আপডেট দরকার”), commit-এর লিংকসহ; POM থাকলে এক লাইনের মেরামত। আর process-এর একটি প্রস্তাব: test id বদলালে একই PR-এ page object বদলানো আর CI-তে UI smoke চালানো বাধ্যতামূলক। যদি হাতে চেষ্টায় সত্যিই badge না বাড়ত, তখন রিপোর্টে লাগত ধাপ, browser, প্রত্যাশা আর evidence, “৪৭টি test ব্যর্থ” নয়।

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

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

ক্রমএকটি raw UI test suite-কে page object-এ সাজানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. পুরো suite চালিয়ে বর্তমান ফল লিখে রাখা (কোনটি পাস, কোনটি ফেল)
  2. Test-গুলোতে পুনরাবৃত্ত locator আর action চিহ্নিত করা
  3. Component আর page object বানিয়ে locator ও action সেখানে সরানো
  4. ব্যবহারকারীর যাত্রাগুলো পাতলা flow-এ জোড়া দেওয়া
  5. Test-গুলো নতুন স্তরে লেখা, assertion test-এই রেখে
  6. আবার পুরো suite চালিয়ে আগের ফলের সাথে মেলানো, আর একটি বসানো bug দিয়ে যাচাই

একটি UI suite-এ ৪০টি test সরাসরি get_by_test_id("cart-count") লেখে। App-এ test id বদলে cart-badge হলো। Page Object Model-এ সাজানো থাকলে সাধারণত কয়টি জায়গায় বদল লাগত?

  • ৪০টি, প্রতিটি test-এ একবার
  • ১টি, header-এর component বা page object-এ
  • যতগুলো flow আছে, ততটি
  • ০টি, Playwright নিজে নতুন নাম খুঁজে নেয়

একটি LoginPage.login_as() method-এর শেষে লেখা আছে assert "nav-user" in shown. এই নকশার প্রধান সমস্যা কোনটি?

  • test ধীর হয়ে যায়
  • Python-এ method-এর ভেতরে assert লেখা যায় না
  • ভুল পাসওয়ার্ডের মতো negative test এই page object দিয়ে লেখা যায় না
  • locator আরও ভঙ্গুর হয়ে যায়

Playwright-এ CheckoutPage.place_order() অর্ডার দেওয়ার পরে order পাতায় চলে যায়। Page Object Model-এর প্রচলিত নিয়মে এই method কী ফেরত দেওয়া উচিত?

  • একটি OrderPage object
  • একই CheckoutPage (self)
  • True, যদি মোট দাম ঠিক হয়
  • কিছুই না (None)

একটি page object-এর method: def add_to_cart(self): self.button.click(); time.sleep(2). Cart badge ক্লিকের প্রায় ৪০০ মিলিসেকেন্ড পরে বদলায়, কিন্তু ধীর CI-তে কখনো ২ সেকেন্ডেরও বেশি লাগে। সবচেয়ে ভালো মেরামত কোনটি?

  • time.sleep(5) করা
  • sleep সরিয়ে প্রতিটি test-এ বসানো
  • ব্যর্থ test স্বয়ংক্রিয়ভাবে তিনবার আবার চালানো
  • ক্লিকের আগে সংখ্যা পড়ে, ক্লিকের পরে badge এক বাড়া পর্যন্ত শর্তে অপেক্ষা

Screenplay pattern-এ “কার্টে কয়টি পণ্য দেখা যাচ্ছে” এই তথ্যটি সাধারণত কোন অংশ হিসেবে লেখা হয়?

  • Task
  • Question
  • Ability
  • Actor

একটি দল তিনটি UI test-এর জন্য page object আর flow বানাল; test ফাইল ৫০ লাইন থেকে ২৪ লাইনে নামল, কিন্তু নতুন page object আর flow মিলে ১৩০ লাইন। কোন সিদ্ধান্তটি সবচেয়ে যুক্তিসঙ্গত?

  • POM সবসময় ক্ষতিকর, কারণ মোট কোড বেড়েছে
  • POM মোট কোড কমিয়েছে, তাই সবসময় লাভজনক
  • Suite বড় হবে আর অনেকদিন চলবে এমন হলে লাভ, নইলে বাড়তি নকশা হতে পারে
  • Test-এর সংখ্যার সাথে এই সিদ্ধান্তের সম্পর্ক নেই

শব্দকোষ

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

মনে রাখুন

  1. এক জায়গায় জানা-শোনা: locator আর action page বা component object-এ; test ব্যবহারকারীর কাজের ভাষায়।
  2. চার স্তর: test → flow → page/component → driver; প্রতিটি স্তর শুধু নিচেরটিকে চেনে, flow পাতলা।
  3. রায় test-এ: page object মান বা locator দেখায়, নিজের action-এর শর্তে অপেক্ষা করে, কিন্তু assert করে না।
  4. সত্যিকারের মাপ: test id বদলে raw-এ ৫ লাইন, POM-এ ১ লাইন; তবে ছোট suite-এ POM মোট কোড বাড়ায়।
  5. Anti-pattern: god page object, লুকানো assertion, sleep, page-এ ব্যবসার নিয়ম; Screenplay বড় suite-এর জন্য আরও কড়া ভাগ।

পরের পর্বে: Flaky test — যে test কোনো বদল ছাড়াই কখনো পাস, কখনো ফেল। কারণ, খোঁজার উপায়, quarantine নীতি, retry-এর বিপদ, আর ৪০০ মিলিসেকেন্ডের badge-এ একটি ইচ্ছাকৃত race কুড়িবার চালিয়ে গোনা।

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

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