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

Flaky test — কারণ, খোঁজা, quarantine আর স্থায়ী সমাধান

Flaky Tests — Causes, Detection, Quarantine and Lasting Fixes

Taught in Bangla, this lesson defines flaky tests and maps their causes. In a real lab three Playwright tests on the Bazarghar demo shop run 20 times in shuffled order and 10 runs go red from a sleep race and an order dependency. Condition waits and fresh data bring failures to zero, while pytest-rerunfailures leaves 10 red runs, nearly doubles the time and once passes for the wrong reason. It computes suite pass probability from flake rates, sets a quarantine policy, and uses in-page pytest to control the clock.

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

  • Flaky test-এর সংজ্ঞা, intermittent defect থেকে তার পার্থক্য, আর গবেষণায় পাওয়া কারণের মানচিত্র
  • একটি flaky suite বারবার চালিয়ে মাপা, seed দিয়ে test-এর ক্রম ধরে রাখা, আর ব্যর্থতার বার্তা থেকে কারণ চেনা
  • সারানোর স্থায়ী কৌশল: শর্তের অপেক্ষা, isolation, নির্ধারিত data, নিয়ন্ত্রিত ঘড়ি
  • Flake rate, suite পাসের সম্ভাবনা আর “কতবার চালালে যথেষ্ট” হিসাব
  • Retry কখন বিপদ, quarantine কীভাবে চালাতে হয়, আর flaky test আবার মূল suite-এ ফেরানোর শর্ত

১ · Flaky test কী — একই কোড, ভিন্ন ফল

রাখাল বালক আর বাঘের গল্পটি মনে করুন। বালক মিছিমিছি “বাঘ এসেছে” বলে চিৎকার করত। দুবার গ্রামবাসী দৌড়ে এলো, বাঘ নেই। তৃতীয়বার সত্যিই বাঘ এলো, কিন্তু কেউ আর এলো না। Flaky test হলো সেই রাখাল বালক। CI-তে লাল দাগ মানে হওয়ার কথা “কিছু ভেঙেছে”। কিন্তু একটি test যদি কোড না বদলেও মাঝে মাঝে লাল হয়, দলের সবাই শেখেন: “ও কিছু না, আবার চালিয়ে দিই।” তারপর একদিন সত্যিকারের bug লাল দেখায়, আর সেটিও আবার চালানো হয়।

সংজ্ঞাটি সরল: একই কোড, একই test, একই পরিবেশ, তবু কখনো পাস, কখনো ফেল। ফলটি নির্ভর করে এমন কিছুর ওপর যা test নিয়ন্ত্রণ করে না: সময়, ক্রম, অন্য test-এর রেখে যাওয়া data, network, কম্পিউটারের ব্যস্ততা। পর্ব ২২-এ এর একটি রূপ দেখেছেন, sleepy test; পর্ব ২৩-এ shared state-এর চুইয়ে পড়া; পর্ব ২৪-এ নিয়ন্ত্রিত ঘড়ি। আর পর্ব ৩৬-এ বাজারঘরের cart badge-এর ৪০০ ms দেরি মেপে দেখেছেন, click-এর পরপর পড়লে মান তখনো পুরোনো। এই পর্ব সেই টুকরোগুলো এক জায়গায় আনে, আর তিনটি প্রশ্নের উত্তর দেয়: flake কীভাবে মাপবেন, কীভাবে কারণ খুঁজবেন, আর সারানোর আগ পর্যন্ত দলকে কীভাবে রক্ষা করবেন।

Full-Stack কোর্সের পর্ব ৭৭-এ developer-এর দৃষ্টিতে Vitest দিয়ে সাতটি কারণ নিজের হাতে ঘটানো হয়েছে। এখানে আমরা tester-এর দৃষ্টিতে আরও গভীরে যাব: একটি আসল browser suite বারবার চালিয়ে পরিসংখ্যান, ব্যর্থতার বার্তা পড়ে কারণ আলাদা করা, retry plugin-এর সত্যিকারের আচরণ, আর quarantine-এর একটি পূর্ণ নীতি।

Flaky test বনাম intermittent defect

দুটি শব্দ গুলিয়ে যায়, কিন্তু পার্থক্যটি জরুরি। পর্ব ১৮-এর intermittent defect হলো product-এর ভুল যা মাঝে মাঝে দেখা দেয়: ব্যবহারকারীও কখনো কখনো তা দেখবেন। Flaky test হলো এমন একটি test, যার ফল অনির্ধারিত। দুটি একসাথেও থাকতে পারে: কোডে race থাকলে test মাঝে মাঝে লাল হয়, আর সেটি “test-এর মেজাজ” নয়, আসল bug. তাই প্রতিটি flake-এর প্রথম প্রশ্ন: অনির্ধারণ কোথায়, test-এ নাকি product-এ? উত্তর না জেনে test “ঠিক” করা মানে হয়তো bug-এর একমাত্র সাক্ষীকে চুপ করানো।

মূল কথা

একটি test-এর মূল্য তার ফলের ওপর আস্থায়। Flaky test শুধু নিজের ফল নষ্ট করে না, পুরো suite-এর লাল রঙের অর্থ হালকা করে দেয়। তাই flake-কে bug-এর মতোই গুরুত্ব দিন: মাপুন, কারণ খুঁজুন, সারান।

২ · কারণের মানচিত্র — গবেষণা কী বলে

Flaky test নিয়ে সবচেয়ে উদ্ধৃত প্রথম বড় গবেষণা Qingzhou Luo, Farah Hariri, Lamyaa Eloussi আর Darko Marinov-এর “An Empirical Analysis of Flaky Tests” (FSE ২০১৪)। তাঁরা Apache-এর open-source প্রকল্পগুলোর commit ইতিহাসে “intermit” আর “flak” শব্দ খুঁজে flaky test সারানোর commit বের করেন, তার থেকে ২০১টি খুঁটিয়ে দেখেন, আর ১৬১টির মূল কারণ নিশ্চিতভাবে শ্রেণিবদ্ধ করতে পারেন। প্রবন্ধের সারণি অনুযায়ী তিনটি কারণ মিলে প্রায় ৭৭%: async wait ৭৪টি (প্রায় ৪৫%), concurrency ৩২টি (প্রায় ২০%), আর test order dependency ১৯টি (প্রায় ১২%). প্রবন্ধের প্রথম উদাহরণটিও চেনা লাগবে: একটি test server চালু করে Thread.sleep(2000) দিয়ে ধরে নিত সে তৈরি; সারানো হয় শর্তের অপেক্ষা দিয়ে।

Python-এর ছবি কিছুটা আলাদা। Martin Gruber ও সহলেখকদের “An Empirical Study of Flaky Tests in Python” (ICST ২০২১) PyPI-র ২২ হাজারের বেশি প্রকল্পের test বারবার চালিয়ে ৭,৫৭১টি flaky test পায়, যার প্রায় ৫৯% ছিল order-dependent; বাকিগুলোর বড় অংশ test পরিকাঠামোর সমস্যা, আর অল্প অংশ network ও randomness. দুটি গবেষণার পদ্ধতি আলাদা (একটি সারানোর commit পড়ে, অন্যটি বারবার চালিয়ে), তাই শতাংশ সরাসরি তুলনীয় নয়। শিক্ষাটি তুলনীয়: অপেক্ষা আর ক্রম, এই দুটিই সবচেয়ে বড় দুই চোর।

কারণবাজারঘরে কেমন দেখায়স্থায়ী সমাধান
Async waitclick-এর পরে sleep(0.42), তারপর badge পড়াযা দেখার কথা তার শর্তে অপেক্ষা (expect)
Concurrencyদুটি thread একই stock কমায়কোডের race সারানো; lock, transaction (পর্ব ৬২)
Order dependencyএক test cart-এ তেল রেখে যায়, পরের test খালি cart আশা করেপ্রতিটি test-এর আগে নতুন data, নিজের ব্যবহারকারী
Shared state, resource leakখোলা browser context, ভরা temp folder, ধরা portteardown-এ বন্ধ করা; fixture-এর yield
সময় ও time zoneUTC-তে চলা CI-তে ঢাকার তারিখ ভুলfake clock, ঘড়ি parameter হিসেবে
Randomnessseed ছাড়া এলোমেলো পণ্য বা কুপনrandom seed নির্দিষ্ট ও লগে লেখা
Network ও বাইরের serviceআসল wallet gateway মাঝে মাঝে ধীরstub বা service virtualization (পর্ব ৩৪)
সমান্তরাল run-এ data সংঘর্ষদুই worker একই মিতুর cart বদলায়প্রতি worker আলাদা ব্যবহারকারী বা database
অক্রমিক সংগ্রহ, floating pointset-এর ক্রম ধরে নেওয়া, 0.1 + 0.2ক্রম নিরপেক্ষ তুলনা, approx

আরেকটি সূত্র বড় প্রতিষ্ঠানের অভিজ্ঞতা। ২০১৬ সালে Google Testing Blog-এ John Micco-র লেখা “Flaky Tests at Google and How We Mitigate Them” বহুল উদ্ধৃত; সেখানে বলা হয়েছিল তাঁদের test run-গুলোর প্রায় ১.৫% flaky ফল দেয়, আর মোট test-এর একটি উল্লেখযোগ্য অংশে (প্রায় ১৬%, আমাদের পড়া অনুযায়ী) কোনো না কোনো মাত্রার flakiness আছে। পরের বছর একই ব্লগে Jeff Listfield-এর একটি লেখায় বলা হয়েছিল, বড় test (বেশি binary, বেশি memory) flaky হওয়ার প্রবণতা বেশি। সংখ্যাগুলো সেই সময়ের, সেই পরিবেশের; শিক্ষাটি স্থায়ী: বড়, ধীর, বহু অংশ ছোঁয়া test সবচেয়ে বেশি flaky, আর UI test ঠিক এই দলে।

৩ · সত্যিকারের ল্যাব — একটি flaky suite, ২০ বার

অনুমান নয়, মাপা। নিচের সব কিছু এই কোর্স লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো হয়েছে। App: কোর্সের বাজারঘর, শুধু 127.0.0.1:8796-এ, test mode-এ। Test প্রকল্প: Python 3.12.13, pytest 9.2.0 (MIT), playwright 1.65.2 আর pytest-playwright 0.10.0 (দুটিই Apache-2.0), pytest-randomly 5.1.0 (MIT) আর pytest-rerunfailures 16.7 (MPL-2.0). Browser: কম্পিউটারে থাকা Microsoft Edge 157, headless. সতর্কতা হিসেবে run-এর আগে DO_NOT_TRACK=1 রাখা হয়েছিল। Path নিরপেক্ষ করা।

Suite-এ তিনটি test, প্রতিটি দেখতে নিরীহ। এগুলো এমনভাবে লেখা, যেমন একজন ব্যস্ত লেখক সত্যিই লিখতে পারেন:

import time

from playwright.sync_api import Page, expect


def test_badge_after_sleep(page: Page, login):        # race
    login("joy")
    page.goto("/products/3")
    page.get_by_role("button", name="কার্টে যোগ করুন").click()
    time.sleep(0.42)        # "badge takes ~400 ms, +20 ms margin"
    assert page.get_by_test_id("cart-count").inner_text() == "1"


def test_add_oil(page: Page, login):                  # polluter
    login("mitu")
    page.goto("/products/3")
    page.get_by_role("button", name="কার্টে যোগ করুন").click()
    expect(page.get_by_test_id("cart-count")).to_have_text("1")


def test_new_cart_is_empty(page: Page, login):        # victim
    login("mitu")
    page.goto("/")
    expect(page.get_by_test_id("cart-count")).to_have_text("0")

আর conftest.py-এ seed data ফেরানো হয় পুরো run-এ একবার (scope="session"), কারণ “প্রতিটি test-এ reset ধীর”। প্রথম test-এর লেখক পর্ব ৩৬-এর মাপ জানেন: badge বদলায় প্রায় ৪০০ ms-এ। তাই ২০ ms বাড়তি দিয়ে ৪২০ ms ঘুম। কাগজে যুক্তিটি ঠিক শোনায়। এই কম্পিউটারে একটি আলাদা script দিয়ে ঘুমের দৈর্ঘ্য বদলে প্রতিটি ১০ বার চালানো হয়েছিল: ০.৩৬, ০.৩৮ আর ০.৪০ সেকেন্ডে ১০-এ ০ বার পাস, ০.৪২-এ ১০-এ ৭ বার, ০.৪৪-এ ১০-এ ১০ বার। অর্থাৎ ৪২০ ms ঠিক সীমার ওপর দাঁড়িয়ে: কম্পিউটার একটু ব্যস্ত হলেই হার।

২০ বার, প্রতিবার আলাদা ক্রমে

pytest-randomly প্রতিটি run-এ test-এর ক্রম এলোমেলো করে; --randomly-seed=N দিলে ক্রমটি নির্দিষ্ট আর পুনরাবৃত্তিযোগ্য হয়। একটি ছোট Python script (run20.py) seed ১ থেকে ২০ দিয়ে ২০টি আলাদা pytest process চালাল, ঠিক যেমন ২০টি আলাদা CI run. সত্যিকারের আউটপুট (মাঝের সারি ছাঁটা; প্রতিটি সারির “1 warning” হলো pytest-playwright-এর একটি deprecation সতর্কবার্তা, ছাঁটা হয়েছে):

$ uv run python run20.py flaky
seed  1: empty > race > add_oil     fail=-            | 3 passed in 2.93s
seed  2: race > empty > add_oil     fail=-            | 3 passed in 2.88s
seed  3: add_oil > race > empty     fail=empty        | 1 failed, 2 passed in 7.92s
seed  4: empty > race > add_oil     fail=-            | 3 passed in 2.91s
seed  5: empty > race > add_oil     fail=race         | 1 failed, 2 passed in 2.97s
seed  6: add_oil > race > empty     fail=empty        | 1 failed, 2 passed in 7.93s
…
seed 10: add_oil > race > empty     fail=race,empty   | 2 failed, 1 passed in 7.96s
…
seed 13: add_oil > empty > race     fail=empty,race   | 2 failed, 1 passed in 7.91s
…
seed 17: add_oil > empty > race     fail=empty,race   | 2 failed, 1 passed in 7.97s
seed 18: race > empty > add_oil     fail=-            | 3 passed in 2.96s
seed 19: add_oil > race > empty     fail=empty        | 1 failed, 2 passed in 7.90s
seed 20: race > empty > add_oil     fail=-            | 3 passed in 2.86s
red runs: 10/20; failures per test: {'empty': 8, 'race': 5}; total 105 s

একটি আপাত-সাধারণ suite: ২০টি CI run-এর অর্ধেক লাল, কোড একটুও না বদলে। কিন্তু ছবিটি খেয়াল করে দেখুন, দুটি flake দুই রকম:

  • empty ফেল করেছে ৮ বার, আর প্রতিবারই তালিকায় add_oil তার আগে। ২০টি ক্রমের মধ্যে ঠিক ৮টিতে add_oil আগে চলেছে (seed ৩, ৬, ৮, ১০, ১২, ১৩, ১৭, ১৯), আর সেই ৮টিতেই ফেল; বাকি ১২টিতে একবারও নয়। এটি এলোমেলো নয়, ক্রমের নিখুঁত ফল।
  • race ফেল করেছে ৫ বার (seed ৫, ৯, ১০, ১৩, ১৭), আর ক্রমের সাথে কোনো মিল নেই: কখনো প্রথমে চলে ফেল, কখনো প্রথমে চলে পাস।
  • সময়ও সংকেত দেয়: empty ফেল করা run প্রায় ৭.৯ সেকেন্ড, বাকিগুলো প্রায় ২.৯. কারণ web-first assertion হাল ছাড়ার আগে ৫ সেকেন্ড ধরে বারবার দেখে (polling); race-এর assert একবার দেখেই থামে, তাই তার ফেলে সময় বাড়ে না।

এবার ক্রম এলোমেলো করার আসল সুবিধা দেখুন। একই seed দিয়ে আবার চালানো হলো, তিনবার করে, সত্যিকারের ফল:

seed 3: FAILED test_new_cart_is_empty                          (7.92s)
seed 3: FAILED test_badge_after_sleep, test_new_cart_is_empty  (7.94s)
seed 3: FAILED test_badge_after_sleep, test_new_cart_is_empty  (7.94s)
seed 5: FAILED test_badge_after_sleep                          (2.94s)
seed 5: 3 passed                                               (2.89s)
seed 5: FAILED test_badge_after_sleep                          (2.91s)

Seed ৩-এ empty তিনে তিন বার ফেল: ক্রম ধরে রাখলে order flake পুরোপুরি পুনরাবৃত্তিযোগ্য, তাই debug করা সহজ। race একই seed-এও কখনো পাস, কখনো ফেল: timing flake seed দিয়ে ধরা যায় না, কারণ seed শুধু ক্রম ঠিক করে, কম্পিউটারের ঘড়ি নয়। এই পার্থক্যটিই নির্ণয়ের প্রথম ধাপ।

test_new_cart_is_empty · seed 3
প্রমাণ
অনুমান
পরের কাজ
  1. লাল run, আর seed. pytest-randomly প্রতিটি run-এর শুরুতে Using --randomly-seed=3 লেখে। CI লগে এই লাইনটিই প্রথম সূত্র: একই ক্রম যেকোনো সময় আবার আনা যায়।
  2. বার্তা পড়া। সত্যিকারের বার্তা: Locator expected to have text '0', Actual value: 1. Badge-এ “1” মানে মিতুর cart-এ একটি জিনিস আছে, অথচ এই test নিজে কিছু যোগ করেনি।
  3. Call log: timing নয়। 14 × locator resolved to … 1 মানে ৫ সেকেন্ডে ১৪ বার দেখা, প্রতিবার একই “1”. দেরিতে আসা মান হলে কোনো একবার “0” দেখা যেত। মান স্থির কিন্তু ভুল, তাই সন্দেহ state-এর ওপর।
  4. একা চালানো। pytest -k empty: সত্যিকারের run-এ তিনবারে তিনবার পাস, প্রতিবার প্রায় ১ সেকেন্ডে। একা পাস, দলে ফেল: এটি order-dependent test-এর চিহ্ন।
  5. জোড়ায় চালানো। -k "add_oil or empty" --randomly-seed=3: add_oil PASSED, empty FAILED. দোষী পাওয়া গেল: add_oil হলো polluter, empty হলো victim. অনেক test থাকলে এই খোঁজা অর্ধেক অর্ধেক করে (bisect) চালানো যায়।
  6. মূল কারণ ও সমাধান। Reset ছিল session-এ একবার, তাই এক test-এর cart পরের test পায়। প্রতিটি test-এর আগে seed ফেরালে (পরের অংশ) সব ক্রমে ২০ বারে ০ বার ফেল। Polluter-কে “পরিষ্কার করে যাওয়া” শেখানোও এক পথ, কিন্তু victim-কে নিজের শুরুর অবস্থা নিশ্চিত করতে দেওয়া বেশি নিরাপদ।

race-এর বার্তা তুলনায় অনেক কম কথা বলে: AssertionError: assert '0' == '1', কোনো call log নেই, কারণ inner_text() একবারই পড়েছে। “0” মানে পড়ার মুহূর্তে badge তখনো বদলায়নি। কোডে time.sleep চোখে পড়লেই এটি async wait-এর প্রধান সন্দেহভাজন, Luo ও সহলেখকদের সারণির সবচেয়ে বড় ঘর।

৪ · স্থায়ী সমাধান — শর্তের অপেক্ষা, isolation, নির্ধারিত ঘড়ি

Playwright-এর auto-waiting click-এর মতো action-কে রক্ষা করে, কিন্তু inner_text() দিয়ে পড়া মানকে নয়; এই ফাঁকেই race ঢুকেছিল। তাই দুটি পরিবর্তন: ঘুমের বদলে web-first assertion, আর প্রতিটি test-এর আগে seed data ফেরানো (fresh fixture). Test-এর নাম আর কাজ একই রইল:

# fixed/conftest.py
@pytest.fixture(autouse=True)
def fresh_data(base_url):                 # FIX: every test gets the seed
    req = urllib.request.Request(base_url + "/api/test/reset", method="POST")
    urllib.request.urlopen(req, timeout=5).close()
    yield

# fixed/test_cart_fixed.py
def test_badge_after_add(page: Page, login):
    login("joy")
    page.goto("/products/3")
    page.get_by_role("button", name="কার্টে যোগ করুন").click()
    expect(page.get_by_test_id("cart-count")).to_have_text("1")

একই ২০টি seed-এ, সত্যিকারের আউটপুট (ছাঁটা):

$ uv run python run20.py fixed
seed  1: add_oil > badge > empty    fail=-   | 3 passed in 3.42s
seed  2: empty > add_oil > badge    fail=-   | 3 passed in 3.47s
seed  3: add_oil > empty > badge    fail=-   | 3 passed in 3.53s
…
seed 19: add_oil > empty > badge    fail=-   | 3 passed in 3.65s
seed 20: add_oil > empty > badge    fail=-   | 3 passed in 3.37s
red runs: 0/20; failures per test: {}; total 76 s

২০ বারে ০ বার ফেল, add_oil আগে থাকা ক্রমেও। প্রতিটি run একটু ধীর (প্রায় ২.৯ থেকে ৩.৪ সেকেন্ড), কারণ এখন প্রতিটি test-এর আগে reset হয়। কিন্তু মোট সময় কম: ১০৫ থেকে ৭৬ সেকেন্ড, কারণ ফেল করা web-first assertion আর ৫ সেকেন্ড বসে থাকে না। Isolation-এর দাম সামান্য, আর flake-এর দাম লুকানো কিন্তু বড়।

২০ বারে ০ মানে “কখনো ফেল করবে না” নয়। পরের অংশের হিসাবে দেখবেন, ২০ বার পাস থেকে বলা যায় ফেলের হার সম্ভবত ১৫%-এর নিচে, তার বেশি কিছু নয়। আমাদের আত্মবিশ্বাস আসে মূলত কারণ বোঝা থেকে: ঘুম নেই, ভাগাভাগি করা state নেই। পরিসংখ্যান শুধু সেই বোঝাকে সমর্থন করে।

সারানোর কৌশলের তালিকা

কৌশলমানেভুল বিকল্প
শর্তের অপেক্ষাযে দৃশ্যমান পরিবর্তন প্রমাণ করে কাজ শেষ, সেটির অপেক্ষাঘুম বাড়ানো, timeout বাড়ানো
Isolationপ্রতিটি test নিজের শুরুর অবস্থা নিজে বানায়test-এর ক্রম নির্দিষ্ট করে দেওয়া
নির্ধারিত dataseed লেখা, নির্দিষ্ট ব্যবহারকারী, নির্দিষ্ট id“এলোমেলো, তাই বেশি কভার করে”
নিয়ন্ত্রিত ঘড়িঘড়ি parameter বা fake, সীমার মুহূর্তগুলো ইচ্ছা করেdatetime.now() দিয়ে test
বাইরের নির্ভরতা নকলwallet gateway-এর stub, recorded উত্তরআসল service-এর ওপর retry
সম্পদ বন্ধ করাfixture-এর yield-এর পরে বন্ধ, প্রতি worker আলাদা port“CI বড় যন্ত্র, সমস্যা নেই”

সময়ের flake, ব্রাউজারেই

সময়-নির্ভর flake সবচেয়ে ধূর্ত, কারণ এটি দিনের নির্দিষ্ট ঘণ্টায় শুধু দেখা দেয়। ধরুন বাজারঘরের নিয়ম: “আজ অর্ডার করলে আগামীকাল delivery”, আর “আজ” মানে ঢাকার তারিখ। Developer লিখলেন now.date(), যেখানে now UTC-তে। দুপুরে test পাস। কিন্তু ঢাকার রাত ১২টা থেকে সকাল ৬টা (UTC-তে আগের দিনের সন্ধ্যা ৬টা থেকে রাত ১২টা) দিনের এই ৬ ঘণ্টায় UTC-র তারিখ ঢাকার চেয়ে একদিন পিছিয়ে। আসল ঘড়িতে চলা test তাই দিনের ২৫% সময় ফেল করত; যে দল রাত ২টায় nightly CI চালায়, তার কাছে test “সবসময় ভাঙা”, আর দিনের দলের কাছে “কখনো ভাঙে না”। নিচের pytest (ব্রাউজারে, Pyodide) আসল ঘড়ির বদলে দুটি নির্দিষ্ট মুহূর্ত দেয়:

import os, sys, pytest
os.makedirs("/home/pyodide/p40", exist_ok=True)
os.chdir("/home/pyodide/p40"); sys.path.insert(0, os.getcwd())
for m in ("slots40", "test_slots40"):
    sys.modules.pop(m, None)             # re-run after you edit the code

open("slots40.py", "w").write('''
from datetime import timedelta, timezone
DHAKA = timezone(timedelta(hours=6))

def delivery_date_v1(now):          # BUG: UTC calendar date
    return now.date() + timedelta(days=1)

def delivery_date_v2(now):          # fix: Dhaka calendar date
    return now.astimezone(DHAKA).date() + timedelta(days=1)
''')
open("test_slots40.py", "w").write('''
from datetime import date, datetime, timezone
import pytest
from slots40 import delivery_date_v1, delivery_date_v2

NOON = datetime(2026, 11, 16, 6, 0, tzinfo=timezone.utc)     # 12:00 Dhaka
NIGHT = datetime(2026, 11, 16, 19, 30, tzinfo=timezone.utc)  # 01:30 Dhaka, 17th

@pytest.mark.parametrize("impl", [delivery_date_v1, delivery_date_v2],
                         ids=["v1", "v2"])
@pytest.mark.parametrize(("now", "want"),
    [(NOON, date(2026, 11, 17)), (NIGHT, date(2026, 11, 18))],
    ids=["noon", "night"])
def test_next_day_delivery(impl, now, want):
    assert impl(now) == want
''')
pytest.main(["-v", "--no-header", "-p", "no:cacheprovider", "--tb=line",
             "test_slots40.py"])

আসল আউটপুট (ব্রাউজারের Python):

collecting ... collected 4 items

test_slots40.py::test_next_day_delivery[noon-v1] PASSED                  [ 25%]
test_slots40.py::test_next_day_delivery[noon-v2] PASSED                  [ 50%]
test_slots40.py::test_next_day_delivery[night-v1] FAILED                 [ 75%]
test_slots40.py::test_next_day_delivery[night-v2] PASSED                 [100%]

=================================== FAILURES ===================================
E   assert datetime.date(2026, 11, 17) == datetime.date(2026, 11, 18)
     +  where datetime.date(2026, 11, 17) = <function delivery_date_v1 at …>(datetime.datetime(2026, 11, 16, 19, 30, tzinfo=datetime.timezone.utc))
…
========================= 1 failed, 3 passed in 0.01s =========================

দুপুরের মুহূর্তে (noon) দুটি সংস্করণই পাস: UTC আর ঢাকা দুই জায়গাতেই ১৬ তারিখ। রাতের মুহূর্তে (night, UTC ১৯:৩০ = ঢাকার ১৭ তারিখ রাত ১:৩০) v1 দিয়েছে ১৭ নভেম্বর, অথচ ঢাকার “আগামীকাল” ১৮; v2 আগে ঢাকার সময়ে রূপান্তর করে, তাই পাস। আসল ঘড়িতে এই ভুল দিনে মাত্র ৬ ঘণ্টা দেখা দিত; নিয়ন্ত্রিত ঘড়িতে এটি প্রতিটি run-এ, ০.০১ সেকেন্ডে ধরা পড়ে। এটিই deterministic test-এর শক্তি: সীমার মুহূর্তটি ভাগ্যের ওপর না ছেড়ে নিজে তৈরি করা। ঘড়িকে parameter হিসেবে দেওয়ার নকশা পর্ব ২৫-এর বিষয়।

৫ · Flake-এর গণিত — suite কেন এত সহজে লাল

একটি test প্রতিটি run-এ, অন্যদের থেকে স্বাধীনভাবে, p সম্ভাবনায় ফেল করে ধরা যাক; এই p-কে বলে flake rate. তাহলে সেটি পাস করে (১ − p) সম্ভাবনায়, আর nটি এমন test-এর suite পুরো সবুজ হয় (১ − p)n সম্ভাবনায়। গুণফল দ্রুত ছোট হয়। Full-Stack কোর্সের পর্ব ৭৭-এ একটি হিসাব দেখেছেন; এখানে পুরো টেবিল, সাথে উল্টো প্রশ্ন: একটি flake ধরতে কতবার চালাতে হবে, আর আমাদের ল্যাবের সংখ্যা থেকে আসল হার সম্পর্কে কতটুকু বলা যায়।

import math

# 1) P(whole suite green) when each of n tests flakes independently with p
print("suite green = (1 - p) ** n")
for p in (0.001, 0.005, 0.01):
    row = [f"n={n}: {(1 - p) ** n:6.1%}" for n in (50, 200, 1000)]
    print(f"  p={p:<5}", " | ".join(row))

# 2) how many reruns to see at least one failure with 95 % chance?
print("runs for 95% chance of >= 1 failure: ln(0.05) / ln(1 - p)")
for p in (0.25, 0.05, 0.01, 0.001):
    k = math.ceil(math.log(0.05) / math.log(1 - p))
    print(f"  p={p:<5} -> {k} runs")

# 3) our real race test: 5 failures in 20 runs. Wilson 95 % interval
def wilson(fail, n, z=1.96):
    ph = fail / n
    centre = (ph + z * z / (2 * n)) / (1 + z * z / n)
    half = z * math.sqrt(ph * (1 - ph) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return centre - half, centre + half

lo, hi = wilson(5, 20)
print(f"race: 5/20 = {5 / 20:.0%}, 95% interval {lo:.0%} .. {hi:.0%}")
lo, hi = wilson(0, 20)
print(f"fixed: 0/20, 95% interval {max(lo, 0):.0%} .. {hi:.0%}"
      f"  (rule of three: {3 / 20:.0%})")

আসল আউটপুট (Pyodide):

suite green = (1 - p) ** n
  p=0.001 n=50:  95.1% | n=200:  81.9% | n=1000:  36.8%
  p=0.005 n=50:  77.8% | n=200:  36.7% | n=1000:   0.7%
  p=0.01  n=50:  60.5% | n=200:  13.4% | n=1000:   0.0%
runs for 95% chance of >= 1 failure: ln(0.05) / ln(1 - p)
  p=0.25  -> 11 runs
  p=0.05  -> 59 runs
  p=0.01  -> 299 runs
  p=0.001 -> 2995 runs
race: 5/20 = 25%, 95% interval 11% .. 47%
fixed: 0/20, 95% interval 0% .. 16%  (rule of three: 15%)

প্রথম টেবিল: হাজার test-এর suite-এ প্রতিটি test হাজারে একবার flaky হলেও পুরো run সবুজ মাত্র ৩৬.৮% সময়। প্রতিটি ০.৫% হলে আর ১০০০টি test হলে সবুজ run প্রায় অসম্ভব (০.৭%). এজন্যই বড় দলে “আলাদা করে প্রায় নির্ভরযোগ্য” test-ও মিলে suite-কে অকেজো করে।

দ্বিতীয় টেবিল: অন্তত একবার ফেল দেখতে যত বার চালাতে হয়, তা হলো ln(0.05) / ln(1 − p)-এর ওপরের পূর্ণসংখ্যা। আমাদের race-এর মতো ২৫% flake ১১ বারেই প্রায় নিশ্চিত ধরা পড়ে; ১% flake-এর জন্য ২৯৯ বার। Gruber ও সহলেখকেরা Python test-এর জন্য একই ধরনের যুক্তিতে বলেছিলেন, একটি পাস করা test flaky নয় বলে ৯৫% নিশ্চিত হতে প্রায় ১৭০ বার চালানো লাগে, তাঁদের দেখা flake rate-এর ভিত্তিতে।

তৃতীয় অংশ: ২০ বারে ৫ বার ফেল থেকে race-এর আসল হার “২৫%” বলা যায়, কিন্তু ৯৫% confidence interval (Wilson পদ্ধতি) ১১% থেকে ৪৭%: অল্প data, চওড়া সীমা। আর সারানো suite-এর ২০ বারে ০ ফেল মানে হার ০ থেকে ১৬%-এর মধ্যে; সহজ মাথার হিসাব rule of three (৩/n) দেয় ১৫%.

p = 0.005 · suite green = (1 − p)^n
test সংখ্যা n
হিসাব
সবুজ run
১০০ run-এ লাল
  1. একটি test. ২০০ বারে একবার ফেল। আলাদা করে দেখলে কেউ খেয়ালই করবেন না: ১০০টি run-এ লাল প্রায় শূন্য।
  2. দশটি এমন test. 0.99510 ≈ ৯৫.১%. প্রতি ২০টি run-এ মোটামুটি একটি লাল, কোনো কোড না বদলে।
  3. পঞ্চাশটি। সবুজ ৭৭.৮%: প্রায় প্রতি পাঁচটি pull request-এর একটি লাল দেখে, অকারণে।
  4. দুইশোটি। সবুজ ৩৬.৭%: এখন লাল-ই স্বাভাবিক। Developer-রা “re-run” বোতাম চাপতে শেখেন, আর লাল রঙ সংকেত হারায়।
  5. এক হাজারটি। সবুজ ০.৭%: প্রায় কোনো run-ই সবুজ নয়। বড় suite-এ তাই প্রতি test-এর flake rate হাজারে একের অনেক নিচে রাখতে হয়, অথবা flaky test-গুলোকে মূল সিদ্ধান্ত থেকে সরাতে হয়, যা পরের অংশের বিষয়। হিসাবটি ধরে নেয় flake-গুলো স্বাধীন; বাস্তবে একটি ধীর CI যন্ত্র অনেক test-কে একসাথে ফেলতে পারে।

৬ · খোঁজা — rerun, ইতিহাস আর এলোমেলো ক্রম

Flaky test খোঁজার উপায়গুলো তিন রকম তথ্য ব্যবহার করে:

উপায়কীভাবেকী ধরে, কী ছাড়ে
বারবার চালানোএকই commit-এ N বার; ফল ভিন্ন হলেই flakytiming ধরে; order flake ধরতে ক্রমও বদলাতে হয়
ক্রম এলোমেলোpytest-randomly, seed লগেorder dependency ধরে, seed দিয়ে পুনরাবৃত্তি
Test-এর ইতিহাসএকই commit-এ পাস আর ফেল দুটোই আছে কি নাবাড়তি run লাগে না; তথ্য জমতে সময় লাগে
পরিবেশে চাপCPU ব্যস্ত রেখে, সমান্তরাল worker বাড়িয়েসীমার কাছের timing দ্রুত প্রকাশ পায়
নতুন test-এর পরীক্ষাmerge-এর আগে নতুন বা বদলানো test-কে ২০–৫০ বারflake suite-এ ঢোকার আগেই থামে

সহজতম শুরু হলো শেষ সারিটি। নতুন UI test merge-এর আগে একটি আলাদা CI ধাপে বারবার চালান; আমাদের race ১১ বারের মধ্যেই ৯৫% সম্ভাবনায় ধরা পড়ত। ইতিহাসভিত্তিক পদ্ধতি বড় দলে জনপ্রিয়: প্রতিটি run-এর ফল (test, commit, পরিবেশ, সময়) একটি database-এ জমা থাকে, আর একই commit-এ পাস ও ফেল দেখলে test-টি নিজে থেকেই “flaky” চিহ্ন পায়। এর জন্য কাঠামোবদ্ধ রিপোর্ট লাগে, যেমন JUnit XML (পর্ব ৬৭)।

গবেষণাতেও খোঁজার যন্ত্র এসেছে। DeFlaker (Bell ও সহলেখক, ICSE ২০১৮) বারবার না চালিয়ে flake চেনার চেষ্টা করে: একটি test ফেল করলে দেখে, সর্বশেষ কোড পরিবর্তনের কোনো অংশ সেই test আদৌ চালিয়েছে কি না; না চালালে ফেলটি সম্ভবত flaky. iDFlakies (Lam ও সহলেখক, ICST ২০১৯) ক্রম বদলে বদলে order-dependent test খোঁজে, আর polluter ও victim শব্দ দুটি এই ধারার গবেষণাতেই প্রচলিত। Parry ও সহলেখকদের একটি সমীক্ষা (ACM TOSEM, ২০২১-২২) পুরো ক্ষেত্রটির ভালো মানচিত্র দেয়। যন্ত্রগুলোর বিস্তারিত দাবি আমরা নিজে যাচাই করিনি; ধারণাগুলো আপনার দলের সাধারণ কৌশলে কাজে লাগে।

৭ · Retry আর quarantine — শব্দ কমানো, সত্য না লুকিয়ে

দলের সামনে লাল CI, আর release কাল। সবচেয়ে সহজ উত্তর retry: ফেল হলে আবার চালানো, একবার পাস করলেই পাস ধরা। pytest-এ এর জনপ্রিয় plugin pytest-rerunfailures; --reruns 2 মানে প্রতিটি ফেল করা test আরও সর্বোচ্চ ২ বার। আমাদের flaky suite-এ একই ২০টি seed দিয়ে চালানো হলো, সত্যিকারের আউটপুট (ছাঁটা):

$ uv run python run20.py flaky --reruns 2
seed  3: add_oil > race > empty   fail=race,empty  rerun=race,race,empty,empty | 2 failed, 1 passed, 4 rerun in 19.97s
seed  5: empty > race > add_oil   fail=race        rerun=race,race  | 1 failed, 2 passed, 2 rerun in 4.45s
seed  6: add_oil > race > empty   fail=empty       rerun=empty,empty | 1 failed, 2 passed, 2 rerun in 18.51s
…
seed 11: race > empty > add_oil   fail=-           rerun=race       | 3 passed, 1 rerun in 3.74s
…
seed 16: empty > race > add_oil   fail=-           rerun=race       | 3 passed, 1 rerun in 3.70s
…
red runs: 10/20; failures per test: {'race': 6, 'empty': 8}; reruns per test: {'race': 14, 'empty': 16}; total 201 s

ফল প্রথম দেখায় অবাক করে। লাল run তবুও ২০-এ ১০, মোট সময় ১০৫ থেকে ২০১ সেকেন্ড। empty-এর ১৬টি rerun-এর একটিও পাস করেনি: rerun-এর সময় মিতুর cart-এ তেল তখনো আছে, তাই একই ফল। Order flake-এ retry কাজই করে না। একটি seed-এর পুরো বিবরণ, সত্যিকারের আউটপুট:

$ uv run pytest flaky -v --randomly-seed=6 --reruns 2 --tb=no
flaky/test_cart_flaky.py::test_add_oil[chromium] PASSED                  [ 33%]
flaky/test_cart_flaky.py::test_badge_after_sleep[chromium] RERUN         [ 66%]
flaky/test_cart_flaky.py::test_badge_after_sleep[chromium] RERUN         [ 66%]
flaky/test_cart_flaky.py::test_badge_after_sleep[chromium] FAILED        [ 66%]
flaky/test_cart_flaky.py::test_new_cart_is_empty[chromium] RERUN         [100%]
flaky/test_cart_flaky.py::test_new_cart_is_empty[chromium] RERUN         [100%]
flaky/test_cart_flaky.py::test_new_cart_is_empty[chromium] FAILED        [100%]
==================== 2 failed, 1 passed, 4 rerun in 19.94s ====================

আর race? Seed ১১ আর ১৬-তে প্রথমবার ফেল, rerun-এ পাস। মনে হতে পারে retry কাজ করেছে। কিন্তু ভাবুন, প্রথম চেষ্টার click-এ joy-র cart-এ একটি তেল ঢুকে গেছে; rerun-এ পাতা খোলে badge “1” নিয়ে, click-এর পরে হওয়ার কথা “2”. Test আশা করে “1”. তাহলে rerun পাস করল কীভাবে? যাচাই করতে শুধু race test, --reruns 2 দিয়ে ১০ বার চালানো হলো, আর প্রতিবার শেষে API থেকে joy-র cart গোনা হলো, সত্যিকারের আউটপুট:

$ uv run python rerun_truth.py
run  1: 1 passed in 1.46s                      joy's cart qty after run = 1
run  2: 1 passed in 1.45s                      joy's cart qty after run = 1
run  3: 1 passed in 1.45s                      joy's cart qty after run = 1
run  4: 1 failed, 2 rerun in 2.99s             joy's cart qty after run = 3
run  5: 1 passed in 1.45s                      joy's cart qty after run = 1
run  6: 1 failed, 2 rerun in 3.02s             joy's cart qty after run = 3
run  7: 1 passed in 1.48s                      joy's cart qty after run = 1
run  8: 1 passed in 1.51s                      joy's cart qty after run = 1
run  9: 1 passed in 1.46s                      joy's cart qty after run = 1
run 10: 1 passed, 1 rerun in 2.20s             joy's cart qty after run = 2

Run ১০ সবুজ, অথচ cart-এ ২টি তেল। Rerun-এ test badge পড়েছে দেরি হওয়ার আগে, পুরোনো “1” দেখেছে, আর পাস করেছে। ঠিক যেটি প্রথম চেষ্টায় ফেলের কারণ ছিল (পুরোনো মান পড়া), সেটিই rerun-এ পাসের কারণ। Run ৪ আর ৬-এ উল্টো: rerun-এ মান সময়মতো “2” আর “3” হয়েছে, তাই ফেল। Retry এখানে সবুজ রঙ দিয়েছে ভুল কারণে, আর প্রতিটি চেষ্টা app-এ নতুন অবস্থা রেখে গেছে। আসল checkout test হলে প্রতিটি rerun একটি করে নতুন অর্ডার বা নতুন charge বানাতে পারত।

pytest-rerunfailures-এর সমালোচনা, এক জায়গায়। (১) Order flake-এ অকেজো, কারণ rerun-এ পরিবেশ একই থাকে। (২) Timing flake-এ রঙ বদলায়, কারণ নয়; উপরের মতো ভুল কারণেও পাস হয়। (৩) পরিবেশে প্রভাব ফেলা test (cart, অর্ডার, payment) বারবার চালালে app-এ জঞ্জাল জমে। (৪) Product-এর আসল intermittent bug ঢাকা পড়ে: নিচের simulation দেখাবে কতটা। (৫) সময় বাড়ে: এখানে প্রায় দ্বিগুণ। Plugin-টির নিজের ভালো দিকও আছে: রিপোর্টে RERUN আর “4 rerun” আলাদা দেখায়, --only-rerun দিয়ে নির্দিষ্ট error-এ সীমিত করা যায়, আর @pytest.mark.flaky(reruns=…) দিয়ে সব test-এ নয়, শুধু চিহ্নিত test-এ। সৎ ব্যবহার একটিই: নিয়ন্ত্রণের বাইরের ক্ষণিক সমস্যায়, সীমিতভাবে, আর “rerun-এ পাস” সংখ্যাটি প্রতিদিন গুনে দেখা।

Retry বনাম quarantine — একটি simulation

বড় suite-এ নীতির প্রভাব দেখতে নিচের Python ২০০টি test-এর suite ২০০০ বার “চালায়”: ৬টি test ৩% flaky, আর একটি test product-এর একটি আসল race-এ ২০% run-এ ফেল করে (একটি সত্যিকারের intermittent bug). তিনটি নীতি: retry নেই; প্রতিটি ফেলে ২ বার retry; আর flaky ৬টিকে quarantine করে আলাদা job-এ সরানো। Seed নির্দিষ্ট, তাই ফল প্রতিবার একই:

import random

random.seed(40)
N_TESTS, FLAKY, P_FLAKE = 200, 6, 0.03    # 6 flaky tests, 3 % each
P_BUG = 0.20      # one test hits a REAL race in the shop code 20 % of runs
RUNS = 2000


def one_run(retries, quarantine):
    red, bug_seen = False, False
    for t in range(N_TESTS):
        if quarantine and t < FLAKY:
            continue                        # runs in a separate job
        p = P_FLAKE if t < FLAKY else P_BUG if t == FLAKY else 0.0
        for attempt in range(1 + retries):
            if random.random() >= p:        # this attempt passed
                break
        else:                               # every attempt failed
            red = True
            bug_seen |= t == FLAKY
    return red, bug_seen


print(f"{'policy':24} {'red runs':>9} {'bug caught':>11}")
for name, retries, quar in [("no retry", 0, False),
                            ("retry up to 2", 2, False),
                            ("quarantine, no retry", 0, True)]:
    reds = bugs = 0
    for _ in range(RUNS):
        r, b = one_run(retries, quar)
        reds += r
        bugs += b
    print(f"{name:24} {reds / RUNS:9.1%} {bugs / RUNS:11.1%}")

আসল আউটপুট (Pyodide):

policy                    red runs  bug caught
no retry                     34.1%       20.3%
retry up to 2                 0.8%        0.8%
quarantine, no retry         21.1%       21.1%

Retry নেই: ৩৪.১% run লাল, যার বড় অংশ flake-এর শব্দ; আসল bug ধরা পড়ে প্রায় ২০% run-এ, তার প্রকৃত হারের সমান। Retry ২ বার: CI প্রায় সবসময় সবুজ (লাল মাত্র ০.৮%), দল খুশি। কিন্তু আসল bug-ও ধরা পড়ে মাত্র ০.৮% run-এ, কারণ পরপর তিনবার ফেলের সম্ভাবনা 0.23 = ০.০০৮. ব্যবহারকারী তবুও প্রতি পাঁচবারে একবার ভুল দেখবেন। Quarantine: লাল ২১.১%, আর প্রতিটি লাল run-ই আসল bug-এর জন্য; শব্দ নেই, সংকেত পুরো। Flaky ৬টি আলাদা job-এ চলে, তাদের তথ্য হারায় না। Model-টি সরল (প্রতিটি চেষ্টা স্বাধীন), কিন্তু দিকটি স্পষ্ট: retry শব্দ আর সংকেত দুটোই কমায়; quarantine শুধু শব্দ।

Quarantine-এর একটি পূর্ণ নীতি

Quarantine মানে flaky test-কে মুছে ফেলা নয়, মূল পাস-ফেল সিদ্ধান্ত থেকে সাময়িকভাবে সরানো। Martin Fowler-এর ২০১১ সালের প্রবন্ধ “Eradicating Non-Determinism in Tests” এই ধারণাটিকে জনপ্রিয় করে, সাথে সতর্কতা: quarantine-এর আকার আর সময়ের সীমা না থাকলে তা পরিত্যক্ত test-এর গুদাম হয়ে যায়। pytest-এ একটি সহজ বাস্তবায়ন: একটি marker, মূল job-এ বাদ, আলাদা job-এ বারবার:

# pyproject.toml
[tool.pytest.ini_options]
markers = ["quarantine(issue, owner, until): flaky, kept out of the gate"]

# the test
@pytest.mark.quarantine(issue="QA-412", owner="sumi", until="2026-11-30")
def test_badge_after_sleep(page, login): ...

# main CI job (decides merge)      nightly job (measures the flake)
#   pytest -m "not quarantine"       pytest -m quarantine  (50 runs, seed logged)

Marker-এর issue, owner আর until নিজে কিছু করে না, শুধু তথ্য রাখে; সময়সীমা পেরোলে CI ভাঙানোর জন্য conftest.py-এ একটি ছোট hook লাগে, যা marker পড়ে তারিখ মেলায়। Nightly job-এর ৫০ বার চালানো এই পর্বের run20.py-এর মতো একটি loop দিয়েই হয়।

একটি flaky test-এর জীবনচক্র

ধরা → মাপা → quarantine → কারণ সারানো → আবার মাপা → মূল suite-এ ফেরা; ভুল পথ: retry দিয়ে ঢাকা

Flaky test-এর জীবনচক্র: ধরা, মাপা, quarantine, সারানো, আবার মাপা, ফেরা মূল suite (gate) লাল মানেই সংকেত ধরা পড়া একই commit-এ পাস আর ফেল মাপা ২০–৫০ বার, seed লেখা Quarantine issue, মালিক, সময়সীমা gate-এর বাইরে, nightly চলে মূল কারণ সারানো অপেক্ষা, isolation, নির্ধারিত data বা ঘড়ি আবার মাপা যেমন ৩০০ বারে ০ ফেল পাস → gate-এ ফেরত ভুল পথ retry দিয়ে সবুজ করা লুকানো আসল bug সময় শেষ? মুছুন বা নতুন লিখুন
ছবি ৪০.১ — Quarantine একটি অস্থায়ী ঘর, স্থায়ী ঠিকানা নয়। প্রতিটি flaky test-এর পথ শেষ হয় হয় মূল suite-এ ফেরায়, নয় সচেতন সিদ্ধান্তে মুছে ফেলায়।
  1. ধরাপাস + ফেলএকই commit
  2. মাপা৫/২০flake rate
  3. QuarantineQA-412gate-এর বাইরে
  4. সারানোexpectsleep বাদ
  5. ফেরাgateমার্কার বাদ
একটি flaky test-এর অবস্থা
মূল gate-এ?
তথ্য
দায়িত্ব
  1. ধরা পড়া। Test-এর ইতিহাসে একই commit-এ একবার পাস, একবার ফেল: সংজ্ঞা অনুযায়ীই flaky. এখনো কারণ জানা নেই, শুধু লক্ষণ।
  2. মাপা। ২০ বার, seed লিখে: ৫ বার ফেল, আনুমানিক ২৫%, ৯৫% interval ১১–৪৭%. ক্রম বদলালেও হার একই রকম, তাই সম্ভবত timing, order নয়।
  3. Quarantine. Marker বসল issue QA-412, মালিক সুমি আর দুই সপ্তাহের সময়সীমাসহ। মূল job -m "not quarantine" চালায়, তাই merge আর আটকায় না। Nightly job test-টি ৫০ বার চালিয়ে হার লিখে রাখে, তথ্য হারায় না।
  4. সারানো। কারণ async wait: sleep(0.42)-এর বদলে expect(...).to_have_text("1"), আর প্রতি test-এ reset. Product কোডে কোনো race আছে কি না তাও দেখা হলো: নেই, দেরিটি নকশা অনুযায়ী।
  5. ফেরা। শুধু “কয়েকবার পাস” যথেষ্ট নয়। Rule of three অনুযায়ী ৩০০ বারে ০ ফেল দেখালে হারের ৯৫% ঊর্ধ্বসীমা প্রায় ১%. সেই প্রমাণ আর কারণের ব্যাখ্যাসহ review-এর পরে marker সরে, test আবার gate-এ। সময়সীমা পেরিয়ে গেলে বিকল্প সিদ্ধান্ত: test মুছে নতুন করে লেখা।

আরও গভীরে: বড় প্রতিষ্ঠানে quarantine-এর সাথে “flake budget” রাখা হয়: পুরো suite-এর মোট flake কত পর্যন্ত সহনীয়, আর তা ছাড়ালে নতুন feature-এর আগে test সারানো। উল্টো দিকে একটি বিতর্কও আছে: কেউ কেউ বলেন quarantine product-এর আসল bug-কে দলের চোখের আড়ালে পাঠায়, তাই quarantine-এর প্রতিটি test-এর ব্যর্থতার বার্তা মালিকের কাছে নিয়মিত যাওয়া জরুরি। Flake-এর হার মডেল করতে স্বাধীন Bernoulli চেষ্টা ধরা হয়, কিন্তু বাস্তবে ফেলগুলো একসাথে আসে (একটি ধীর যন্ত্র, একটি ব্যস্ত সময়)। তাই পরিবেশসহ ইতিহাস রাখাই শ্রেয়। Suite-এর আকার বাড়লে selection, sharding আর flake budget-এর পূর্ণ আলোচনা পর্ব ৬৮ (বড় test suite)-এ।

৮ · AI-এর যুগে — AI-এর লেখা test আর flake

AI সহকারী flake তৈরিতেও দ্রুত, সারাতেও দ্রুত, কিন্তু প্রায়ই ভুল পথে। তার সাধারণ ভুলগুলো এমন: অপেক্ষার জন্য sleep বা wait_for_timeout; “flaky test সারাও” বললে timeout বাড়ানো বা @pytest.mark.flaky(reruns=3) বসানো; একই ব্যবহারকারী আর data সব test-এ; datetime.now() আর seed ছাড়া random; আর চালানো ছাড়াই “২০ বার চালালাম, সব পাস” দাবি। মাঝে মাঝে plugin-এর option বানিয়েও লেখে, যেমন অস্তিত্বহীন কোনো flag.

Flaky test নিয়ে AI-এর সাহায্য চাইলে লক্ষণ নয়, প্রমাণ দিন, আর সমাধানের সীমা বলে দিন:

তুমি একজন অভিজ্ঞ SDET. নিচের pytest-playwright test মাঝে মাঝে ফেল করে। প্রমাণ: ২০টি run-এ ৫ বার ফেল; ক্রম (pytest-randomly seed) বদলালেও হার একই; বার্তা: assert '0' == '1'. Test-এর code: [এখানে test] App-এর আচরণ: click-এর পরে cart badge প্রায় ৪০০ ms পরে বদলায়। নিয়ম: ১. প্রথমে সম্ভাব্য মূল কারণ বলো, আর কেন অন্য কারণ (order, data, network) কম সম্ভব। ২. সমাধানে sleep, wait_for_timeout, timeout বাড়ানো বা retry/rerun নয়। ৩. শুধু Playwright-এর অফিসিয়াল API; প্রতিটি method-এর নাম আলাদা তালিকায় দাও, আমি docs-এ মিলিয়ে নেব। ৪. Product কোডে কোনো race থাকতে পারে কি না, সেটিও আলাদা করে ভাবো। ৫. Test চালানোর ফল দাবি করবে না; সারানোর পরে কতবার, কোন command-এ চালিয়ে আমি নিশ্চিত হব, তা লিখে দাও।

AI-এর “সারানো” flaky test হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১একটি flaky test সারানোর আগে কেন জানতে হবে অনির্ধারণটি test-এ নাকি product-এ? দুটির পার্থক্য করবেন কীভাবে?

Flaky test-এর ফল দুই উৎস থেকে অনির্ধারিত হতে পারে। প্রথমটি test নিজে: ঘুম দিয়ে অপেক্ষা, ভাগাভাগি করা data, আসল ঘড়ি, seed ছাড়া এলোমেলো মান। এখানে product ঠিক আছে, test ভুল প্রশ্ন করছে বা ভুল মুহূর্তে করছে। দ্বিতীয়টি product: কোডে race, দুটি request একসাথে এলে stock ভুল হওয়া, cache-এর পুরোনো মান। এখানে test সৎ সাক্ষী; সে মাঝে মাঝে লাল হয় কারণ product মাঝে মাঝে ভুল করে, আর ব্যবহারকারীও সেই ভুল দেখবেন।

দুটি গুলিয়ে ফেলার দাম অসম। Product-এর race-কে “test flaky” ভেবে retry বা quarantine করলে একমাত্র সাক্ষী চুপ হয়; এই পর্বের simulation-এ দেখেছেন, ২ বার retry দিলে ২০% হারের একটি আসল bug ধরা পড়ার হার ০.৮%-এ নামে। Luo ও সহলেখকদের ২০১৪ সালের গবেষণাতেও লেখকেরা খেয়াল করেছিলেন, async wait-এর ধরনের সমস্যা product কোডেও আসল concurrency bug হিসেবে থাকতে পারে, শুধু test-এ নয়।

পার্থক্য করার কয়েকটি ব্যবহারিক উপায় আছে। (১) ব্যর্থতার বার্তা পড়ুন: মান কি “পুরোনো” (test আগে পড়েছে) নাকি “অসম্ভব” (যেমন stock ঋণাত্মক, একই অর্ডার দুবার)? অসম্ভব মান product-এর দিকে ইঙ্গিত করে। (২) Product-এর অবস্থা আলাদা পথে দেখুন: আমাদের ল্যাবে API থেকে cart গোনা হয়েছিল, সেখানে ২টি তেল দেখে বোঝা গেল rerun ভুল কারণে পাস। (৩) Test-এর অপেক্ষা সঠিক করে আবার চালান: শর্তের অপেক্ষার পরেও ফেল হলে, আর মান অসম্ভব হলে, সমস্যা product-এ। (৪) Product-এ চাপ দিন: একই কাজ সমান্তরালে চালালে race হার বাড়ে কি না।

দলের সংস্কৃতিতেও এর প্রভাব আছে। “Flaky” শব্দটি প্রায়ই দায় এড়ানোর লেবেল হয়ে যায়: test-এর দোষ, কোডের নয়। ভালো নীতি হলো flake-এর প্রতিটি issue-তে একটি ঘর রাখা: “product-এর ভুল বাদ দেওয়া হয়েছে কীভাবে?”

মূল উপলব্ধি: Flake একটি লক্ষণ, রোগ নয়। লক্ষণ চুপ করানোর আগে রোগ কোথায়, test-এ নাকি product-এ, তা প্রমাণ দিয়ে ঠিক করুন।

প্র ০২প্রতিটি test-এর আগে reset করলে suite ধীর হয়। Isolation আর গতির মধ্যে বাস্তব সমঝোতা কী?

এই পর্বের ল্যাবে প্রতিটি run প্রায় ২.৯ থেকে ৩.৪ সেকেন্ড হয়েছিল, প্রতিটি test-এর আগে একটি reset যোগ করায়। তিনটি test-এ এটি তুচ্ছ, তিন হাজারে নয়। তাই বাস্তব প্রশ্ন: isolation কীভাবে সস্তা করা যায়, isolation ছাড়া কীভাবে চলা যায় নয়। xUnit ঘরানার ভাষায় (Gerard Meszaros-এর xUnit Test Patterns, ২০০৭) fresh fixture আর shared fixture-এর টানাপোড়েন পুরোনো; shared fixture দ্রুত, কিন্তু “interacting tests” আর “test run war”-এর মতো smell তৈরি করে, যা ঠিক আমাদের polluter আর victim.

সস্তা isolation-এর কয়েকটি কৌশল আছে। প্রথম, পুরো database reset-এর বদলে প্রতিটি test-কে নিজের ব্যবহারকারী দিন: test A মিতু, test B নতুন একজন। তখন reset না করেও cart আলাদা থাকে। দ্বিতীয়, database-এ transaction খুলে test শেষে rollback (পর্ব ২৮), যা পুরো reset-এর চেয়ে দ্রুত। তৃতীয়, browser-এর দিকে নতুন context প্রতি test-এ সস্তা (পর্ব ৩৬); login state বারবার UI দিয়ে না করে একবার বানিয়ে আবার ব্যবহার (পর্ব ৩৭)। চতুর্থ, সমান্তরাল worker-এ প্রতিটির নিজের database বা নিজের ডেটার উপসর্গ।

আরেকটি দিক প্রায়ই বাদ পড়ে: flake-এর নিজের খরচ। আমাদের flaky suite-এ ১০৫ সেকেন্ড লেগেছিল, সারানোটিতে ৭৬, কারণ ফেল করা web-first assertion পুরো ৫ সেকেন্ড অপেক্ষা করে। তার ওপর মানুষের সময়: লাল run দেখা, আবার চালানো, তদন্ত। Isolation-এর কয়েক শতাংশ বাড়তি সময় প্রায়ই flake-এর লুকানো খরচের চেয়ে কম।

তবু কিছু ক্ষেত্রে ইচ্ছাকৃতভাবে shared state রাখা হয়, যেমন বিশাল read-only reference data (জেলার তালিকা, পণ্যের catalogue). শর্ত হলো কোনো test সেটি বদলাবে না, আর সেটি নিশ্চিত করার পাহারা থাকবে, যেমন read-only connection বা test শেষে checksum মেলানো।

মূল উপলব্ধি: প্রশ্নটি “isolation নাকি গতি” নয়, “কোন isolation সবচেয়ে সস্তা”। নিজের data, rollback আর নতুন context প্রায়ই পুরো reset-এর চেয়ে দ্রুত, আর flake-এর খরচের চেয়ে অনেক সস্তা।

প্র ০৩Test-এর ক্রম প্রতিবার এলোমেলো করা কি ভালো অভ্যাস? এর বিপক্ষে কী যুক্তি আছে?

পক্ষের যুক্তি এই পর্বেই দেখেছেন। নির্দিষ্ট ক্রমে চললে add_oil হয়তো সবসময় empty-এর পরে চলত, আর order dependency বছরের পর বছর লুকিয়ে থাকত, যতদিন না কেউ নতুন test যোগ করে বা সমান্তরাল worker চালু করে। এলোমেলো ক্রম লুকানো নির্ভরতাকে আগেভাগে প্রকাশ করে। Gruber ও সহলেখকদের Python গবেষণায় flaky test-এর প্রায় ৫৯% order-dependent ছিল; অর্থাৎ Python-এ এটি সম্ভবত সবচেয়ে বড় উৎস। RSpec আর Minitest-এর মতো কয়েকটি framework ঐতিহাসিকভাবেই ক্রম এলোমেলো করার ব্যবস্থা রাখে।

বিপক্ষের যুক্তিও শক্ত। প্রথম, এলোমেলো ক্রম নিজেই অনির্ধারণ যোগ করে: আজকের লাল run কালকে আবার আনা কঠিন, যদি seed লগে না থাকে। pytest-randomly এজন্যই শুরুতে seed ছাপে, আর --randomly-seed দিয়ে তা ফেরানো যায়; seed না রাখলে এলোমেলো ক্রম সাহায্যের বদলে বিভ্রান্তি। দ্বিতীয়, merge-এর gate-এ এলোমেলো ক্রম হঠাৎ একটি পুরোনো order dependency প্রকাশ করে এমন একজনের pull request আটকাতে পারে, যিনি ওই test ছোঁননি। তৃতীয়, কিছু suite ইচ্ছা করে ধাপে ধাপে চলে (যেমন একটি দীর্ঘ end-to-end যাত্রা), যদিও সেটি নিজেই একটি নকশার দুর্বলতা।

বাস্তব সমঝোতা হলো স্তরভেদ: nightly বা আলাদা job-এ এলোমেলো ক্রম, seed সহ; মূল gate-এ হয় নির্দিষ্ট ক্রম, নয় এলোমেলো কিন্তু order flake পাওয়া গেলে দ্রুত quarantine. আর নতুন test-কে merge-এর আগে কয়েকটি আলাদা seed-এ চালানো, যাতে নতুন নির্ভরতা ঢুকতেই না পারে।

একটি সূক্ষ্মতা: ক্রম বদলালেই সব order flake ধরা পড়ে না। তিনটির বেশি test-এর মধ্যে নির্দিষ্ট একটি জোড়ার ক্রম ধরতে অনেক বিন্যাস লাগতে পারে; গবেষণার যন্ত্রগুলো (যেমন iDFlakies) তাই কৌশলে ক্রম বেছে নেয়।

মূল উপলব্ধি: এলোমেলো ক্রম তখনই বন্ধু, যখন তা পুনরাবৃত্তিযোগ্য। Seed লেখা আর order flake পাওয়া গেলে তা ধরে রাখার নিয়ম ছাড়া এটি নতুন flake-এর উৎস মাত্র।

প্র ০৪CI-তে স্বয়ংক্রিয় retry চালু রাখা কি কখনো যুক্তিসঙ্গত? থাকলে কোন শর্তে?

বাস্তবে অনেক দল retry চালু রাখে, আর কিছু টুল (যেমন Playwright Test, JavaScript-এ) retry-তে পাস করা test-কে আলাদা করে “flaky” হিসেবে দেখায়। তাই প্রশ্নটি নীতির, “retry ভালো না খারাপ” নয়। Google-এর ২০১৬ সালের ব্লগ লেখার মন্তব্যে একটি উত্তরে বলা হয়েছিল, তাঁদের rerun ব্যবস্থা শুধু flaky হিসেবে চিহ্নিত test-এ বা ব্যবহারকারী চাইলে চলে; অর্থাৎ সব test-এ স্বয়ংক্রিয় নয়।

Retry যুক্তিসঙ্গত হতে পারে যখন ব্যর্থতার উৎস নিয়ন্ত্রণের সত্যিই বাইরে: CI যন্ত্রের হঠাৎ network বিচ্ছিন্নতা, browser download-এ timeout, শেয়ার করা পরিবেশের ক্ষণিক সমস্যা। শর্তগুলো: (১) retry নির্দিষ্ট error-এ সীমিত (pytest-rerunfailures-এর --only-rerun), assertion-এর ভুলে নয়; (২) “retry-তে পাস” আলাদা গোনা আর dashboard-এ দেখানো; (৩) একটি test বারবার retry-তে পাস করলে স্বয়ংক্রিয়ভাবে issue খোলা; (৪) পরিবেশ বদলানো test (অর্ডার, payment) retry-র বাইরে, কারণ এই পর্বে দেখেছেন প্রতিটি চেষ্টা app-এ নতুন অবস্থা রেখে যায়।

Retry অযৌক্তিক যখন এটি সমস্যার বদলে ব্যবহৃত হয়। এই পর্বের ল্যাবে দুটি স্পষ্ট প্রমাণ: order flake-এ ১৬টি rerun-এর একটিও কাজে আসেনি, আর timing flake-এ একবার পাস এসেছিল ভুল কারণে, কার্টে ২টি তেল নিয়ে। Simulation দেখিয়েছে, retry আসল intermittent bug-এর সংকেত প্রায় মুছে দেয়।

একটি মধ্যপথও প্রচলিত: retry-তে পাস করলে CI সবুজ, কিন্তু pull request-এ একটি হলুদ সতর্কতা আর flaky test-এর তালিকা। এতে কাজ থামে না, আবার তথ্যও হারায় না।

মূল উপলব্ধি: Retry একটি ছাঁকনি, ওষুধ নয়। সীমিত error-এ, গোনা অবস্থায় আর সময়সীমাসহ ব্যবহার করুন; নইলে এটি flake-এর সাথে আসল bug-ও ছেঁকে ফেলে।

প্র ০৫“২০ বার চালিয়ে সব পাস, তাই flake সারানো হয়েছে” — এই দাবি কতটা শক্ত? আত্মবিশ্বাস কোথা থেকে আসা উচিত?

পরিসংখ্যানের দিক থেকে দাবিটি দুর্বল। n বার চালিয়ে একবারও ফেল না দেখলে আসল ফেলের হারের ৯৫% ঊর্ধ্বসীমা মোটামুটি ৩/n, যা “rule of three” নামে পরিচিত; চিকিৎসা গবেষণায় বিরল পার্শ্বপ্রতিক্রিয়ার হার অনুমানে এটি দীর্ঘদিন ব্যবহৃত। ২০ বারে ০ ফেল মানে হার ১৫% পর্যন্ত হতে পারে, এই পর্বের Wilson হিসাবও ১৬% দিয়েছে। ১%-এর নিচে নিশ্চিত হতে প্রায় ৩০০ বার চালাতে হয়। Gruber ও সহলেখকেরা তাঁদের Python গবেষণায় একই ধরনের যুক্তিতে প্রায় ১৭০ বারের কথা বলেছিলেন।

আরও সূক্ষ্ম সমস্যা আছে। প্রথম, সব run একই কম্পিউটারে, একই ব্যস্ততায় হলে সেগুলো স্বাধীন নমুনা নয়; CI-র ধীর যন্ত্রে হার ভিন্ন হতে পারে। দ্বিতীয়, order flake বারবার একই ক্রমে চালালে কখনো ধরা পড়ে না। এই পর্বের প্রথম ল্যাবে add_oil আগে না চললে empty ২০ বারেও পাস করত। তৃতীয়, সময়ের flake দিনের নির্দিষ্ট ঘণ্টায় দেখা দেয়; দুপুরে ২০০০ বার চালালেও রাত ১টার bug ধরা পড়বে না।

তাই আত্মবিশ্বাসের মূল উৎস হওয়া উচিত কারণ বোঝা: ঘুম কেন ভুল ছিল, কোন শর্তের অপেক্ষা এখন হচ্ছে, কোন state আর ভাগ হচ্ছে না, ঘড়ি কোথা থেকে আসছে। পরিসংখ্যান তারপর সেই ব্যাখ্যার সমর্থন: আলাদা seed-এ, আলাদা চাপে, যথেষ্ট বার। আর যেখানে সম্ভব, নির্ধারিত test দিয়ে সীমার অবস্থা নিজে তৈরি করুন: Pyodide block-এ আসল ঘড়ির বদলে রাত ১:৩০-এর মুহূর্ত দেওয়া হয়েছিল, তাই সময়ের bug প্রতিবার, দিনের যেকোনো সময় ধরা পড়ে।

Karl Popper-এর বিজ্ঞানদর্শনের একটি পরিচিত কথা এখানে মানায়: পর্যবেক্ষণ একটি তত্ত্বকে মিথ্যা প্রমাণ করতে পারে, কিন্তু অল্প পর্যবেক্ষণ দিয়ে সত্য প্রমাণ করা যায় না। ২০টি সবুজ run একটি অনুমানকে টিকিয়ে রাখে, প্রমাণ করে না।

মূল উপলব্ধি: “কয়েকবার পাস” একটি দুর্বল প্রমাণ। মূল কারণের ব্যাখ্যা, সীমার অবস্থা ইচ্ছা করে তৈরি করা test, আর যথেষ্ট সংখ্যক বৈচিত্র্যময় run: তিনটি মিলে তবে “সারানো হয়েছে” বলা যায়।

অনুশীলন

চারটিই কাগজ-কলমে করা যায়; চাইলে ব্রাউজারের Python block-এ নিজের হিসাব মিলিয়ে নিন।

  1. Spec থেকে নির্ধারিত test case: বাজারঘরের নতুন নিয়ম: “ঢাকার সময় রাত ১০টার আগে অর্ডার হলে পরদিন delivery; রাত ১০টা বা তার পরে হলে পরশু।” Code-এর function delivery_date(now), now UTC-তে আসে। আসল ঘড়ি ছাড়া এমন test case লিখুন (UTC মুহূর্ত আর প্রত্যাশিত তারিখ), যা সীমা আর তারিখ-বদলের ফাঁদ দুটোই ধরে।

    ঢাকা = UTC+6, তাই ঢাকার রাত ১০টা = UTC ১৬:০০. সীমার দুই পাশ আর UTC-তারিখ বদলের অংশ:

    IDnow (UTC)ঢাকার সময়প্রত্যাশা
    T12026-11-16 15:59:5916 নভেম্বর 21:59:592026-11-17
    T22026-11-16 16:00:0016 নভেম্বর 22:00:002026-11-18
    T32026-11-16 19:30:0017 নভেম্বর 01:302026-11-18
    T42026-11-16 06:00:0016 নভেম্বর 12:002026-11-17

    T1–T2 হলো পর্ব ০৮-এর দুই-মানের সীমা (এক সেকেন্ডের ব্যবধান)। T3 সবচেয়ে গুরুত্বপূর্ণ: ঢাকায় ১৭ তারিখ রাত ১টা ৩০, অর্থাৎ ১০টার আগে, তাই পরদিন ১৮; কিন্তু UTC-তে তখনো ১৬ তারিখ, তাই UTC-র তারিখ ধরা কোড ১৭ দেবে, বা “১০টার পরে” ভেবে ১৮ দিলেও ভুল কারণে। T4 সাধারণ ক্ষেত্র। আসল ঘড়িতে T2 বা T3-এর মুহূর্ত দিনে একবারই আসে; নিয়ন্ত্রিত ঘড়িতে প্রতিটি run-এ।

  2. ব্যর্থতা পড়ে কারণ বলুন: দুটি ব্যর্থতার বার্তা। (ক) AssertionError: assert '0' == '1', call log নেই, run-এর সময় ৩ সেকেন্ড। (খ) Locator expected to have text '0', Actual value: 1, 14 × locator resolved to … 1, run-এর সময় ৮ সেকেন্ড; test একা চালালে পাস। কোনটি সম্ভবত timing flake, কোনটি order flake? প্রতিটির পরের পরীক্ষা কী?

    (ক) timing flake (async wait): একবার পড়ে থেমেছে (Python-এর assert, অপেক্ষা নেই), আর মান “0” মানে পুরোনো মান। পরের পরীক্ষা: test-এ sleep বা inner_text()/is_visible() খুঁজুন; একই seed-এ কয়েকবার চালান, ফল বদলালে timing. সমাধান web-first expect.

    (খ) order flake: ৫ সেকেন্ডে ১৪ বার দেখেও একই “1”, অর্থাৎ মান স্থির কিন্তু ভুল; একা পাস। পরের পরীক্ষা: লগ থেকে seed নিয়ে একই ক্রমে চালান (পুনরাবৃত্তি হলে নিশ্চিত), তারপর জোড়ায় জোড়ায় বা অর্ধেক অর্ধেক করে polluter খুঁজুন। সমাধান প্রতি test-এ নিজের data বা reset. ৮ সেকেন্ডও সংকেত: ব্যর্থ web-first assertion পুরো timeout অপেক্ষা করে।

  3. এই test-এর ভুল খুঁজুন:
    ORDERS = []
    
    def test_new_order_gets_coupon(page, login):
        login("mitu")
        product = random.choice([3, 4, 7])
        page.goto(f"/products/{product}")
        page.get_by_role("button", name="কার্টে যোগ করুন").click()
        time.sleep(1)
        page.goto("/checkout")
        ORDERS.append(datetime.now())
        assert len(ORDERS) == 1
        assert page.get_by_test_id("quote-discount").inner_text() != "0"

    অন্তত ছয়টি flake বা ভুলের উৎস। (১) Seed ছাড়া random.choice: প্রতিবার ভিন্ন পণ্য; ব্যর্থ হলে আবার আনা কঠিন। নির্দিষ্ট পণ্য দিন, বা seed লগে লিখুন। (২) উদ্দেশ্য আর data মেলে না: তেল (৮৮০), সরিষার তেল (২৯০), আটা (১২০) কোনোটিই একা ১০০০ টাকার বেশি নয়, তাই coupon হওয়ার কথাই নয়; test সবসময় ফেল করবে, অথবা ভুল কারণে পাস করবে যদি আগের test-এর জিনিস cart-এ থাকে। (৩) time.sleep(1): ধীর CI-তে কম, দ্রুত যন্ত্রে অপচয়; badge-এর expect দিন। (৪) Module-level ORDERS: একই process-এ দ্বিতীয় test বা parametrize হলে len == 1 ভাঙে: order dependency. (৫) datetime.now(): কোনো কাজে আসে না, কিন্তু সময়-নির্ভরতার বীজ। (৬) অপেক্ষাহীন, দুর্বল assertion: inner_text() != "0" পাতা লোডের আগের মুহূর্ত পড়ে, আর “0 নয়” মানে যেকোনো ভুল মানও পাস; requirement থেকে হিসাব করা নির্দিষ্ট মান expect(...).to_have_text("100")-এর মতো লিখুন। সাথে reset বা নিজের ব্যবহারকারী না থাকায় মিতুর পুরোনো cart-ও ফল বদলায়।

  4. Flake-এর হিসাব: একটি suite-এ ৩০০টি test, প্রতিটি স্বাধীনভাবে ০.২% flaky. (ক) পুরো suite সবুজ হওয়ার সম্ভাবনা কত? (খ) একটি test-কে quarantine থেকে ফেরাতে নীতি বলে “আসল হার ১%-এর নিচে, ৯৫% নিশ্চয়তায়”। শূন্য ফেল ধরে নিলে কতবার চালাতে হবে? (গ) ২% flaky একটি test-এ ২ বার retry দিলে ফেলের সম্ভাবনা কত, আর এটি কেন বিপজ্জনক তথ্য হতে পারে?

    (ক) 0.998300 ≈ ০.৫৪৮, অর্থাৎ প্রায় ৫৪.৮% run সবুজ, ৪৫.২% লাল, কোনো কোড না বদলে। (খ) Rule of three: ৩/n ≤ ০.০১ ⇒ n ≥ ৩০০; আরও নিখুঁত হিসাবে ln(0.05)/ln(0.99) ≈ ২৯৮.১, তাই ২৯৯ বা মোটামুটি ৩০০ বার, ০ ফেলসহ। (গ) তিনটি চেষ্টাই ফেল: 0.023 = ০.০০০০০৮, প্রায় কখনোই না। বিপদ হলো, এই একই হিসাব আসল bug-এর ক্ষেত্রেও খাটে: product-এ ২% হারের একটি race থাকলে retry-সহ CI প্রায় কখনো লাল হবে না, অথচ প্রতি ৫০টি অর্ডারে একটি ভুল ব্যবহারকারীর কাছে যাবে। ব্রাউজারের Python block-এ P_BUG বদলে নিজে দেখে নিন।

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

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

ক্রমএকটি flaky test ধরা পড়ার পর থেকে কাজের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. একই commit-এ পাস আর ফেল দেখে test-টিকে flaky হিসেবে চিহ্নিত করা
  2. Seed লিখে কয়েক ডজন বার চালিয়ে flake rate মাপা
  3. Issue, মালিক আর সময়সীমাসহ test-টিকে quarantine-এ সরানো
  4. মূল কারণ খুঁজে সারানো (শর্তের অপেক্ষা, isolation, নির্ধারিত data বা ঘড়ি)
  5. যথেষ্ট বার আবার চালিয়ে নিশ্চিত হয়ে মূল suite-এ ফেরানো

একটি test একা চালালে সবসময় পাস করে, কিন্তু পুরো suite-এর মধ্যে কখনো কখনো ফেল করে। ব্যর্থতার বার্তায় মান ৫ সেকেন্ড ধরে একই আর ভুল। সবচেয়ে সম্ভাব্য কারণ কী?

  • Badge দেরিতে বদলায়, assertion যথেষ্ট অপেক্ষা করেনি
  • বাইরের network ধীর
  • অন্য কোনো test আগে চলে shared state রেখে যায় (order dependency)
  • Browser-এর version-এর পার্থক্য

২০০টি test-এর একটি suite-এ প্রতিটি test স্বাধীনভাবে ০.৫% flaky. পুরো suite সবুজ হওয়ার সম্ভাবনা প্রায় কত?

  • ৯৯.৫%
  • ৩৬.৭%
  • ০%
  • ৯০%

একটি test-এ time.sleep(0.42)-এর পরে inner_text() দিয়ে cart badge পড়া হয়; badge প্রায় ৪০০ ms পরে বদলায়। Test মাঝে মাঝে ফেল করে। সবচেয়ে ভালো স্থায়ী সমাধান কোনটি?

  • ঘুম বাড়িয়ে ২ সেকেন্ড করা
  • pytest-rerunfailures দিয়ে --reruns 3
  • Test-টি স্থায়ীভাবে quarantine-এ রাখা
  • expect(badge).to_have_text("1") দিয়ে শর্তের অপেক্ষা

একটি suite-এ ৬টি flaky test আছে, আর একটি test product-এর একটি আসল race-এ ২০% run-এ ফেল করে। সব ফেল করা test-এ ২ বার retry চালু করলে কী হয়?

  • CI প্রায় সবসময় সবুজ হয়, কিন্তু আসল bug-ও প্রায় আর ধরা পড়ে না
  • শুধু flaky test-এর শব্দ কমে, আসল bug আগের মতোই ধরা পড়ে
  • লাল run-এর সংখ্যা বাড়ে
  • Product-এর race নিজে থেকে সেরে যায়

pytest-randomly দিয়ে চালানো একটি run-এ একটি test ফেল করল। লগে লেখা Using --randomly-seed=3. এই তথ্য সবচেয়ে বেশি কাজে আসে কোন ক্ষেত্রে?

  • Click-এর পরে দেরিতে বদলানো badge-এর timing flake আবার আনতে
  • একই ক্রমে আবার চালিয়ে order-dependent ব্যর্থতা নিশ্চিতভাবে ফিরিয়ে আনতে
  • বাইরের service-এর ধীর উত্তর আবার ঘটাতে
  • ফেল করা test-কে পরের run-এ পাস করাতে

একটি সারানো test ২০ বার চালিয়ে একবারও ফেল করেনি। Rule of three অনুযায়ী এর আসল ফেলের হার সম্পর্কে ৯৫% নিশ্চয়তায় কী বলা যায়?

  • হার ঠিক ০%
  • হার ১%-এর নিচে
  • হার মোটামুটি ১৫%-এর নিচে, এর বেশি কিছু নয়
  • কিছুই বলা যায় না

একটি delivery-তারিখের test UTC-তে চলা CI-তে শুধু ঢাকার রাত ১২টা থেকে সকাল ৬টার মধ্যে ফেল করে। এমন সময়-নির্ভর flake-এর সবচেয়ে ভালো স্থায়ী সমাধান কোনটি?

  • CI-এর সময়সূচি বদলে শুধু দিনে চালানো
  • ফেল হলে retry চালু করা
  • CI যন্ত্রের time zone ঢাকা করে দেওয়া
  • Code-এ ঘড়ি parameter হিসেবে দেওয়া, আর test-এ নির্দিষ্ট মুহূর্ত (যেমন UTC ১৯:৩০) ব্যবহার করা

শব্দকোষ

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

মনে রাখুন

  1. Flake একটি লক্ষণ: অনির্ধারণ test-এ নাকি product-এ, তা প্রমাণ দিয়ে ঠিক করুন; product-এর race হলে test সৎ সাক্ষী।
  2. মাপুন, seed লিখে: বারবার চালান আর ক্রম এলোমেলো করুন; seed ধরে রাখলে order flake পুনরাবৃত্তিযোগ্য, timing flake নয়।
  3. স্থায়ী সমাধান: শর্তের অপেক্ষা, প্রতি test-এ নিজের data, নির্ধারিত seed আর নিয়ন্ত্রিত ঘড়ি; ঘুম বা timeout বাড়ানো নয়।
  4. গণিত নির্মম: suite সবুজ = (১ − p)n; ২০ বার পাস মানে হার ১৫% পর্যন্তও হতে পারে, ১%-এর জন্য প্রায় ৩০০ বার।
  5. Retry নয়, quarantine: retry শব্দ আর সংকেত দুটোই কমায়; quarantine issue, মালিক আর সময়সীমাসহ শুধু শব্দ সরায়।

পরের পর্বে: পাতার চেহারা ভাঙলে কোনো assertion তা ধরে না। Visual regression testing-এ বাজারঘরের পণ্যের কার্ডের baseline screenshot, CSS বদলে pixel diff, threshold বাছাই, আর দেরিতে বদলানো badge-এর মতো চলমান অংশ ঢেকে (mask) ছবিকে স্থির রাখা।

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

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