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

বড় test suite — selection, sharding, flake budget আর রক্ষণাবেক্ষণ

Test Suites at Scale — Selection, Sharding, Flake Budgets and Maintenance

Taught in Bangla, this lesson scales the demo shop's suite from 150 to 1500 tests and measures what changes. A real pytest-testmon run selects 580 tests for a one-line change and catches the bug, yet runs nothing when the bug is switched on through an environment variable. Equal-count shards finish at very different times, while pytest-split's duration-based shards come out even. It also covers LPT, failed-first ordering, flake budgets, ownership and why equal coverage does not make a test redundant.

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

  • Suite বড় হলে সময়, compute আর বিশ্বাসযোগ্যতায় কী বদলায়, আর কোন সংখ্যা আগে মাপবেন
  • Test selection: file mapping, coverage map, testmon আর build graph; কোথায় নিরাপদ, কোথায় অন্ধ
  • মাপা সময় দেখে shard ভাগ করা: LPT, pytest-split আর makespan
  • Failed-first আর দ্রুত-আগে ক্রম, flake budget আর retry-এর নীতি
  • Owner, redundant test, data isolation, monorepo আর বড় প্রতিষ্ঠানের প্রকাশিত অভিজ্ঞতা

১ · Suite বড় হলে কী বদলায় — মিনিট থেকে ঘণ্টা

বোর্ড পরীক্ষার লাখো খাতার কথা ভাবুন। একজন পরীক্ষক সব খাতা দেখলে ফল বেরোতে বছর লাগত। তাই তিনটি কৌশল চলে: খাতা ভাগ করে অনেক পরীক্ষকের কাছে পাঠানো, আর ভাগ এমনভাবে যাতে সবার কাজ প্রায় একসাথে শেষ হয়; পুনর্নিরীক্ষায় শুধু যাঁরা আবেদন করেছেন তাঁদের খাতা আবার দেখা, সব নয়; আর যে খাতায় গোলমালের সম্ভাবনা বেশি, সেটি আগে। Test suite বড় হলে ঠিক এই তিনটি কাজই করতে হয়: ভাগ করা, বাছাই করা, আর ক্রম ঠিক করা।

একটি নতুন প্রকল্পে suite চলে কয়েক সেকেন্ডে। প্রতিটি নতুন feature-এর সাথে test আসে, প্রতিটি bug-এর পরে একটি regression test, আর কয়েক বছরে test-এর সংখ্যা হাজার ছাড়ায়। তখন তিনটি জিনিস বদলায়। সময়: suite duration মিনিট থেকে ঘণ্টায় যায়, আর developer-এর time to feedback বাড়ে; তিনি অপেক্ষার মধ্যে অন্য কাজে চলে যান, ফিরে এসে প্রসঙ্গ ভুলে যান। Compute: প্রতিটি PR-এ পুরো suite মানে বহু যন্ত্রের বহু মিনিট; parallel সময় কমায়, কিন্তু মোট কাজ (যন্ত্র × সময়) কমায় না, প্রায়ই বাড়ায়। বিশ্বাস: test বেশি হলে flaky test-ও বেশি, আর লাল রঙের অর্থ ঝাপসা হয়।

হাতিয়ারপ্রশ্নঝুঁকিএই পর্বে
Selectionএই পরিবর্তনে কোন test-এর ফল বদলাতে পারে?দরকারি test বাদ পড়া§৩, §৪
Sharding / parallelকয়েকটি যন্ত্রে সমান ভাগ কীভাবে?অসম ভাগ, shared অবস্থা§২, §৫
Prioritizationকোন test আগে চালালে খবর দ্রুত আসে?প্রায় নেই, কিছু বাদ যায় না§৬
সুস্থ রাখালাল রঙ কি এখনো বিশ্বাসযোগ্য?অবহেলায় suite অকেজো§৭, §৮

পর্ব ৬৪ (CI-তে test pipeline)-এ দেখেছেন, একটি stage ভাঙলে pipeline-এর critical path ছোট হয়; সেখানে ১৫০টি test দুটি সমান ভাগে ভাঙা হয়েছিল কাগজে-কলমে। এই পর্ব সেই প্রতিশ্রুতি পূরণ করে: আসল সময়ের ইতিহাস দেখে ভাগ, আর প্রথমে প্রশ্ন, আদৌ সব test চালানো দরকার কি না। নিচের ছবিটি পুরো পথটি দেখায়; সংখ্যাগুলো §২–§৬-এর সত্যিকারের run থেকে।

বড় suite-এ একটি PR-এর test — বাছাই, ক্রম, ভাগ আর রাতের জাল

Selection → ordering → sharding per pull request; full suite nightly as a safety net

একটি PR-এর test-এর পথ: impact map দিয়ে বাছাই, ক্রম, তিন shard, ফল; আর রাতে পুরো suite পরিবর্তন (PR) rules.py · normalize_phone impact map testmon / coverage context বাছাই: ৫৮০ / ১৫০০ + always-run set ক্রম আগে-ব্যর্থ · দ্রুত আগে shard ১ shard ২ shard ৩ সময় দেখে সময় দেখে সময় দেখে ≈22 s ≈23 s ≈22 s ফল আর সিদ্ধান্ত JUnit XML · flake budget · merge .py নয়? template, config, lock → সব test রাতে পুরো ১৫০০ ≈64 s একটানা ফাঁক ধরে, map-এ নিয়ম যোগ করে চারটি হাতিয়ার কম চালানো · ভাগ করে চালানো বুদ্ধিমান ক্রম · suite সুস্থ রাখা
ছবি ৬৮.১ — প্রতিটি PR-এ শুধু প্রভাবিত test, ব্যর্থ হতে পারে এমনগুলো আগে, আর মাপা সময় দেখে তিন ভাগে। Python ছাড়া অন্য ফাইল বদলালে map অন্ধ, তাই সব test; আর রাতের পুরো run selection-এর ফাঁক ধরে।

২ · সত্যিকারের ল্যাব — ১৫০ থেকে ১৫০০ test

বাজারঘরের shared app-এর একটি কপি, নিজের কম্পিউটারে। App-এর নিজের ১৫০টি test (পর্ব ২১, pytest-এর মূল-এর ধাঁচে লেখা) একটি বড় প্রকল্পের তুলনায় ছোট; তাই suite-কে দশ গুণ করা হলো তিনটি নতুন ফাইল দিয়ে, যেভাবে বাস্তবে suite বাড়ে: অনেক দ্রুত ছোট test, কিছু মাঝারি, আর অল্প কয়েকটি ভারী।

ফাইলTestকী করেমোট সময়
test_scale_rules.py900coupon, phone, delivery-র নিয়ম; শুধু function, database নয়0.24 s
test_scale_api.py300quote আর phone API, প্রতিটিতে নতুন database27.84 s
test_scale_flows.py150login, cart, অর্ডার, pay: পুরো যাত্রা20.72 s
app-এর নিজের ৭টি ফাইল150pricing, phone, order, payment, review, page13.64 s

নতুন test-গুলোর expected মান লেখা নিয়ম থেকে আলাদা করে হিসাব করা (যেমন “১০০০-এর বেশি হলে ১০%, floor, সর্বোচ্চ ৩০০”), কোড থেকে কপি করা নয়; এলোমেলো phone নম্বরের seed নির্দিষ্ট (৬৮)। সময়ের কলাম এসেছে একটানা run-এ --store-durations দিয়ে প্রতিটি test-এর মাপা সময় থেকে।

পরিবেশ: Python 3.12.13, uv 0.11.28, pytest 9.2.0 (MIT), pytest-xdist 3.8.0 (MIT), pytest-split 0.11.0 (MIT), pytest-testmon 2.3.0 (MIT), pytest-cov 7.1.0 (MIT) আর coverage 7.17.3 (Apache 2.0). সব run-এ DO_NOT_TRACK=1. এই ল্যাবে version control ছাড়া চালানো হয়েছে: কোনো version control tool ছিল না, তাই “কোন ফাইল বদলেছে” প্রশ্নের উত্তর এসেছে tool-গুলোর নিজের হিসাব থেকে (testmon-এর ফাইল-fingerprint, বা দুটি ফাইল-কপির তুলনা)। Path নিরপেক্ষ করা, যেমন ~/bazarghar-qa.

$ uv run pytest -q -p no:cacheprovider                # three times each, interleaved
serial  [64.08, 64.18, 64.57]  median 64.18 s
-n 2    [45.63, 43.50, 42.72]  median 43.50 s
-n 3    [38.52, 40.07, 38.68]  median 38.68 s     1500 passed every time

তিন worker-এ ১.৬৬ গুণ দ্রুত, তিন গুণ নয়। পর্ব ৬৪-এ ১৫০টি test-এ একই মাপে প্রায় ২ গুণ এসেছিল। পার্থক্যের সম্ভাব্য কারণ গঠনে: ৯০০টি rule test-এর প্রতিটি গড়ে ০.৩ মিলিসেকেন্ডের কাজ, অথচ xdist প্রতিটি test worker-কে পাঠায় আর ফল ফেরত আনে; এই যাতায়াতের খরচ কাজের চেয়ে বড়। তার ওপর প্রতিটি worker-কে নিজে Python চালু করে app import করে test সংগ্রহ করতে হয়, আর এই কম্পিউটারে তখন অন্য কাজও চলছিল।

সময় বনাম compute

Parallel অপেক্ষার সময় কমায়, মোট কাজ নয়। একটানা run-এ একটি core ৬৪.১৮ সেকেন্ড ব্যস্ত; -n 3-এ তিনটি core ৩৮.৬৮ সেকেন্ড ধরে আটকে থাকে, অর্থাৎ সর্বোচ্চ প্রায় ১১৬ core-সেকেন্ড (worker সবসময় পুরো ব্যস্ত থাকে না, তাই আসল খরচ এর কম)। CI-তে যন্ত্রের সময়ই suite-এর খরচ, তাই “আরও worker” সবসময় সমাধান নয়; কম test চালানো (selection) খরচও কমায়।

Durations ফাইল থেকে আরেকটি চিত্র: সবচেয়ে ধীর ১০% test (১৫০টি) মোট সময়ের ৩৪.৫% নেয়, সবচেয়ে ধীর ২০% নেয় ৬১%, আর অর্ধেক test-এই ৯৯.৭%. ৯০০টি rule test মিলে মোটের মাত্র ০.৪%. অর্থাৎ বড় suite-এর সময় অল্প কিছু ভারী test-এ জমে থাকে, আর test-এর সংখ্যা দিয়ে suite-এর খরচ বোঝা যায় না। এই অসমতাই §৫-এর sharding-এর প্রধান সমস্যা।

৩ · Test selection — শুধু যা বদলেছে তার test

Developer normalize_phone-এর একটি লাইন বদলালেন। Review-এর রেটিং গড় করার test কি আবার চালানো দরকার? সম্ভবত না। Regression test selection-এর মূল প্রশ্ন এটিই: এই পরিবর্তনে কোন test-এর ফল বদলাতে পারে? উত্তরের জন্য দরকার test থেকে code-এর একটি মানচিত্র। পর্ব ০৫-এ impact analysis-এর যে ধারণা দেখেছেন, এটি তারই যন্ত্রে করা রূপ। মানচিত্র বানানোর চারটি প্রচলিত উপায়:

উপায়মানচিত্র আসেশক্তিদুর্বলতা
নামের নিয়মrules.py → test_rules.pyসহজ, কোনো tool লাগে নাপরোক্ষ ব্যবহার (order যা phone ডাকে) ধরা পড়ে না
Coverage mapপ্রতিটি test চলার সময় কোন code চললনির্ভুল, পরোক্ষ ব্যবহারও ধরেmap বানাতে coverage-সহ run লাগে; code-এর বাইরের input দেখে না
Build graphঘোষিত নির্ভরতা (Bazel-এর মতো)test না চালিয়েই জানা যায়, ভাষা পেরোয়ঘোষণা লেখা আর বজায় রাখার পরিশ্রম; সাধারণত মোটা দাগে (target-স্তরে)
ইতিহাস-ভিত্তিক মডেলঅতীতে কোন পরিবর্তনে কোন test ব্যর্থ হয়েছেকোনো map ছাড়াই চলেনিরাপদ নয়, সম্ভাবনাভিত্তিক (§৮)

একটি selection-কে safe বলা হয়, যদি তার অনুমানের ভেতরে প্রভাবিত কোনো test বাদ না যায়। খেয়াল করুন “অনুমানের ভেতরে”: coverage map ধরে নেয়, test-এর ফল শুধু সেই code-এর ওপর নির্ভর করে যা চলার সময় চলেছিল। এই অনুমান কোথায় ভাঙে, তা নিচের run-এ দেখবেন।

সত্যিকারের run: pytest-testmon

pytest --testmon প্রথমবার পুরো suite চালায় আর coverage দিয়ে প্রতিটি test কোন code block চালাল তা .testmondata নামের একটি SQLite ফাইলে রাখে। পরের run-এ প্রতিটি ফাইলের fingerprint মিলিয়ে দেখে কোন block বদলেছে, আর শুধু সেই block-এর সাথে যুক্ত test চালায়। ধাপে ধাপে, সত্যিকারের ফল (প্রতিটির শেষ লাইন):

--- 0 first run, builds .testmondata:   wall 89.31 s
    1500 passed in 87.67s
--- 1 nothing changed:                  wall 1.56 s
    no tests ran in 0.01s
--- 2 normalize_phone: strip() -> lstrip():   wall 52.02 s
    FAILED tests/test_phone.py::test_order_stores_trimmed_phone - assert 422 == 201
    141 failed, 439 passed, 863 deselected in 50.40s
--- 4 coupon_discount: cap 300 -> 299:        wall 93.82 s
    180 failed, 1014 passed, 306 deselected in 92.14s
--- 5 templates/base.html: label for= changed:  wall 3.55 s
    FAILED tests/test_pages_and_meta.py::test_search_box_has_label - assert '<lab...
    1 failed, 8 passed, 5 deselected in 1.87s

প্রতিটি সংখ্যা একটি শিক্ষা। প্রথম run ৮৯.৩১ সেকেন্ড, সাধারণ একটানা run-এর (৬৪.১৮) চেয়ে প্রায় ৩৯% বেশি: প্রতিটি test-এর coverage মাপার খরচ। কিছু না বদলালে ১.৫৬ সেকেন্ড, একটিও test নয়। phone-এর এক লাইনে ১৫০০-এর ৫৮০টি চলল: ৪৩৯টি পাস, ১৪১টি ব্যর্থ, যেগুলো দুই প্রান্তে space রেখে phone পাঠায়। বাদ পড়ল ৯২০টি: ৮৬৩টি “deselected”, আর review ও auth-এর দুটি ফাইলের ৫৭টি test collectই হয়নি, কারণ তাদের কোনো test phone-এর code চালায় না। Order-এর যাত্রাগুলো (১৫০টি) বাছাইয়ে এসেছে, কারণ অর্ডার দেওয়ার সময় phone যাচাই হয়: নামের নিয়মে এটি ধরা পড়ত না।

Coupon-এর এক লাইনে চিত্র উল্টো: ১১৯৪টি test বাছাই, আর সময় ৯৩.৮২ সেকেন্ড, coverage ছাড়া পুরো suite-এর চেয়েও বেশি। Coupon প্রায় সব হিসাবে ঢোকে, আর বাছাই করা run-ও coverage মাপে বলে প্রতিটি test ধীর। Selection-এর লাভ নির্ভর করে পরিবর্তনটি code-এর কত কেন্দ্রে, তার ওপর। Template-এর পরিবর্তন testmon ধরেছে: Jinja template-কে Python code-এ রূপান্তর করে চালায় আর সেই code-এ template-এর path রাখে, তাই coverage সেটিকেও একটি ফাইল হিসেবে দেখে। ৯টি test, একটি ব্যর্থ, ৩.৫৫ সেকেন্ডে; পুরো suite-ও ঠিক এই একটিই ধরেছে।

যেখানে selection অন্ধ — একটি environment variable

এবার কোনো ফাইল না বদলে শুধু একটি environment variable: BAZARGHAR_BUGS=coupon_ge, যা app-কে ১০০০ টাকাতেই ছাড় দিতে বাধ্য করে। সত্যিকারের ফল:

$ BAZARGHAR_BUGS=coupon_ge uv run pytest -q --testmon
no tests ran in 0.01s                                   exit 0   (green!)
$ BAZARGHAR_BUGS=coupon_ge uv run pytest -q -x
FAILED tests/test_pricing.py::test_coupon_rule[coupon-1000] - AssertionError:...
1 failed, 85 passed in 9.26s                            exit 1

Selection সবুজ দিল, অথচ app ভাঙা। Testmon ফাইলের পরিবর্তন দেখে, আর এখানে কোনো ফাইল বদলায়নি। একই অন্ধ জায়গা তৈরি করে Python-এর বাইরে পড়া config (JSON, YAML), database-এর data, বাইরের service, ঘড়ি আর CI যন্ত্রের পরিবেশ। (Installed package বদলালে testmon নিজেই সব test আবার চালায়; তার source code-এ এই নিয়ম আছে।) তাই selection-এর পাশে তিনটি নিরাপত্তা: Python ছাড়া অন্য কিছু (config, lockfile, CI ফাইল) বদলালে পুরো suite; প্রতিটি PR-এ একটি ছোট always-run set, যেমন smoke test; আর রাতে পুরো suite (nightly build).

rules.py · normalize_phone · s = raw.lstrip()
ধাপ
বদলানো
বাছাই
বাদ
ফল
  1. এক লাইনের পরিবর্তন। raw.strip() হয়ে গেল raw.lstrip(): শুরুর space কাটে, শেষেরটা রেখে দেয়। দেখতে নিরীহ, কিন্তু নিয়ম বলে দুই প্রান্তের space-ই কাটতে হবে।
  2. Fingerprint মেলানো। Testmon প্রতিটি ফাইলের প্রতিটি code block-এর checksum রেখেছিল। এবার মিলিয়ে দেখল: শুধু rules.py-এর normalize_phone block বদলেছে; বাকি ফাইল আর block আগের মতো।
  3. Map-এ খোঁজা। কোন test-এর রেকর্ডে এই block আছে? ৫৮০টি, আটটি ফাইলে: phone-এর নিয়মের ৩০০, phone API-র ১০০, order-এর যাত্রা ১৫০, আর app-এর নিজের কিছু test. Review আর auth-এর দুটি ফাইল collectই হলো না।
  4. চালানো, দ্রুত আগে। Testmon বাছাই করা test-গুলো আগের গড় সময় দেখে সাজায়, দ্রুতগুলো আগে, যাতে ব্যর্থতার খবর তাড়াতাড়ি আসে (§৬-এর prioritization).
  5. ফল। ১৪১টি ব্যর্থ, সবই দুই প্রান্তে space-ওয়ালা phone; ৫২.০২ সেকেন্ডে। পুরো suite-এর ৬৪.১৮-এর তুলনায় সাশ্রয় মাঝারি, কারণ বাছাই করা run-ও coverage মাপে। কিন্তু test-এর সংখ্যা প্রায় দুই-তৃতীয়াংশ কম, আর বড় suite-এ এই অনুপাতই ঘণ্টা বাঁচায়।

Selection-এর যুক্তি নিজে হাতে চালিয়ে দেখুন। নিচের প্রোগ্রামে একটি ছোট coverage map (নাম সরল করা, ধাঁচ আসল map-এর মতো) আর তিনটি নিয়ম: map-এর test, map-এ নেই এমন নতুন test সবসময়, আর Python ছাড়া অন্য ফাইল বদলালে সব:

# A small coverage map: which functions each test executed (from a per-test coverage run)
COVERAGE = {
    "test_coupon_rule[1000]":  {"rules.coupon_discount"},
    "test_phone_spec[0]":      {"rules.normalize_phone"},
    "test_quote_api[1001]":    {"api.quote", "rules.quote", "rules.coupon_discount", "rules.delivery_charge"},
    "test_order_and_pay[3-1]": {"api.login", "services.add_to_cart", "services.place_order",
                                "rules.normalize_phone", "rules.quote", "rules.coupon_discount",
                                "rules.delivery_charge", "services.pay", "wallet.charge"},
    "test_search_box_label":   {"web.home", "services.search"},
    "test_review_average":     {"rules.average_stars", "services.reviews"},
}
ALL_TESTS = list(COVERAGE) + ["test_new_refund_rule"]      # new test: no coverage data yet

def select(changed_functions, changed_files):
    code_only = all(f.endswith(".py") for f in changed_files)
    if not code_only:                 # templates, config, lockfile: the map cannot see them
        return ALL_TESTS, "non-Python file changed -> run everything"
    picked = [t for t, funcs in COVERAGE.items() if funcs & changed_functions]
    unknown = [t for t in ALL_TESTS if t not in COVERAGE]  # never measured: always run
    return picked + unknown, f"{len(picked)} mapped + {len(unknown)} new"

CHANGES = {
    "phone trim":      ({"rules.normalize_phone"}, ["rules.py"]),
    "coupon cap":      ({"rules.coupon_discount"}, ["rules.py"]),
    "wallet retry":    ({"wallet.charge"}, ["wallet.py"]),
    "search label":    (set(), ["templates/base.html"]),
}
for name, (funcs, files) in CHANGES.items():
    tests, why = select(funcs, files)
    print(f"{name:13} -> {len(tests)}/{len(ALL_TESTS)} tests ({why})")
    print("              ", ", ".join(t.split("[")[0] for t in tests))

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

phone trim    -> 3/7 tests (2 mapped + 1 new)
               test_phone_spec, test_order_and_pay, test_new_refund_rule
coupon cap    -> 4/7 tests (3 mapped + 1 new)
               test_coupon_rule, test_quote_api, test_order_and_pay, test_new_refund_rule
wallet retry  -> 2/7 tests (1 mapped + 1 new)
               test_order_and_pay, test_new_refund_rule
search label  -> 7/7 tests (non-Python file changed -> run everything)
               test_coupon_rule, test_phone_spec, test_quote_api, test_order_and_pay, test_search_box_label, test_review_average, test_new_refund_rule

phone আর coupon-এর পরিবর্তনে map ঠিক সেই test-গুলো দিল যারা ওই function চালায়, আর order-এর যাত্রা দুটিতেই এল, কারণ তা phone আর coupon দুটিই ছোঁয়। wallet.charge-এর পরিবর্তনে শুধু order-এর test: test_coupon_rule বা test_review_average চালানোর কোনো কারণ নেই। test_new_refund_rule প্রতিবার চলেছে, কারণ এর কোনো coverage এখনো মাপা হয়নি; নতুন test-কে বাদ দেওয়া selection-এর সবচেয়ে সাধারণ ভুলগুলোর একটি। আর template-এর পরিবর্তনে সব ৭টি: এই সরল map Python ছাড়া কিছু দেখে না, তাই নিরাপদ পথ পুরো suite. Testmon template-এর ক্ষেত্রে এর চেয়ে সূক্ষ্ম, কিন্তু environment variable-এ সে-ও অন্ধ (§৩)।

৪ · Coverage map নিজে বানানো — আর redundant test-এর প্রশ্ন

Testmon-এর ভেতরের ধারণাটি coverage.py দিয়ে নিজেও করা যায়। Coverage context চালু করলে (--cov-context=test) প্রতিটি চালানো লাইনের সাথে লেখা থাকে কোন test সেটি চালিয়েছে (পর্ব ১৩, White-box testing-এ coverage-এর মূল)। একটি ছোট script সেই data পড়ে প্রতিটি লাইনকে তার function-এর সাথে মেলায়, আর পুরোনো ও নতুন ফাইলের কপি তুলনা করে বদলানো function বের করে। সত্যিকারের ফল:

$ uv run pytest -q --cov=bazarghar --cov-context=test --cov-report=
1500 passed in 91.00s
$ uv run python covmap.py rules_old.py rules_new.py rules.py
tests with coverage data: 1500
changed: ['rules.py:normalize_phone'] -> selected 580 of 1500
  {test_orders: 3, test_pages_and_meta: 1, test_payment: 7, test_phone: 17,
   test_pricing: 2, test_scale_api: 100, test_scale_flows: 150, test_scale_rules: 300}
changed: ['rules.py:coupon_discount'] -> selected 1194 of 1500
distinct coverage signatures: 66
   358 tests share one signature, e.g. test_coupon_spec[1490] .. test_coupon_spec[2860]
   300 tests share one signature, e.g. test_phone_spec[ 01513269590 ] ..
test_coupon_spec: 450 tests -> 2 signatures

দুটি স্বাধীন পদ্ধতি একই সংখ্যা দিল: phone-এ ৫৮০, coupon-এ ১১৯৪. এটি একটি ভালো অভ্যাসও: কোনো selection tool-এ ভরসা করার আগে একটি দ্বিতীয় পদ্ধতিতে মিলিয়ে নিন।

৬৬টি signature, ১৫০০টি test — তাহলে কি ১৪৩৪টি অপ্রয়োজনীয়?

একই লাইনগুলো চালায় এমন test-গুলোর একই “coverage signature”. ১৫০০টি test-এ মাত্র ৬৬টি আলাদা signature; coupon-এর ৪৫০টি test মাত্র দুটিতে পড়ে (১০০০ পর্যন্ত, আর তার ওপরে)। একটি সহজ কিন্তু বিপজ্জনক সিদ্ধান্ত হতো: প্রতিটি signature থেকে একটি রেখে বাকি মুছে ফেলা। নিচের প্রোগ্রাম ছোট আকারে প্রশ্নটি যাচাই করে: coupon-এর আটটি test, তাদের coverage signature, আর তিনটি mutant (পর্ব ৫৯):

import sys
SRC = """def coupon(s):
    if s <= LIMIT:
        return 0
    return min(s * 10 // 100, CAP)"""
def build(limit=1000, cap=300):              # the real rule, or a mutant of it
    ns = {"LIMIT": limit, "CAP": cap}; exec(SRC, ns); return ns["coupon"]
EXPECTED = {500: 0, 1000: 0, 1001: 100, 2000: 200, 2999: 299, 3000: 300, 3010: 300, 4500: 300}

def lines_run(f, arg):                      # which lines of coupon() one test executes
    seen = set()
    def tracer(frame, event, _):
        if frame.f_code is f.__code__ and event == "line": seen.add(frame.f_lineno)
        return tracer
    sys.settrace(tracer); f(arg); sys.settrace(None)
    return frozenset(seen)

real = build()
groups = {}
for s in EXPECTED:
    groups.setdefault(lines_run(real, s), []).append(s)
print("coverage signatures:", list(groups.values()))
MUTANTS = {"<= became <": build(limit=999), "cap 300 -> 301": build(cap=301),
           "cap 300 -> 299": build(cap=299)}
for name, m in MUTANTS.items():
    killers = [s for s, exp in EXPECTED.items() if m(s) != exp]
    print(f"{name:15} killed by {killers}")
keep = [g[0] for g in groups.values()]       # "one test per signature" pruning
print("pruned suite", keep, "kills:",
      [n for n, m in MUTANTS.items() if any(m(s) != EXPECTED[s] for s in keep)])

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

coverage signatures: [[500, 1000], [1001, 2000, 2999, 3000, 3010, 4500]]
<= became <     killed by [1000]
cap 300 -> 301  killed by [3010, 4500]
cap 300 -> 299  killed by [3000, 3010, 4500]
pruned suite [500, 1001] kills: []

আটটি test মাত্র দুটি coverage signature-এ: ৫০০ আর ১০০০ একই লাইন চালায়, বাকি ছয়টিও নিজেদের মধ্যে একই। কিন্তু mutant-গুলো ভিন্ন গল্প বলে। <= থেকে < মারে শুধু ১০০০; cap-এর দুটি ভুল মারে ৩০০০, ৩০১০ আর ৪৫০০. “প্রতি signature-এ একটি” রেখে suite ছোট করলে (৫০০ আর ১০০১) coverage একই থাকে, কিন্তু তিনটি mutant-এর একটিও আর ধরা পড়ে না। ১০০০ আর ৩০০০ হলো boundary value (পর্ব ০৮, Boundary value analysis): এদের মূল্য লাইনে নয়, মানে।

শিক্ষাটি স্পষ্ট: coverage overlap একটি redundant test-এর প্রার্থী-তালিকা দেয়, রায় নয়। বড় suite ছাঁটাইয়ের সৎ পথ: overlap দিয়ে প্রার্থী, mutation দিয়ে যাচাই, requirement-এর traceability দিয়ে শেষ সিদ্ধান্ত। আর অনেক সময় মুছে ফেলার চেয়ে ভালো হলো মেলানো: একই রকম দশটি test-কে একটি parametrize-করা test-এ আনা, বা একটি ধীর UI test-এর হিসাবের অংশ unit-এ নামানো।

৫ · Sharding — মাপা সময় দেখে কয়েকটি যন্ত্রে ভাগ

-n 3 এক যন্ত্রের ভেতরে তিনটি process; এর সীমা যন্ত্রের core আর memory. আরও বড় suite-এ test ভাগ করা হয় কয়েকটি আলাদা CI যন্ত্রে, প্রতিটি নিজের অংশ চালায়: এটিই sharding. প্রতিটি shard-এর ভেতরে আবার xdist চলতে পারে। প্রশ্ন একটাই: ভাগটি কেমন হবে? মোট সময় ঠিক করে সবচেয়ে ধীর shard, যার নাম makespan; তিনটি shard-এর দুটি ৫ সেকেন্ডে শেষ হলেও তৃতীয়টি ৫০ সেকেন্ড নিলে developer ৫০ সেকেন্ডই অপেক্ষা করেন।

সত্যিকারের run: তিনটি ভাগ-নীতি

pytest-split 0.11.0 (MIT) আগের একটানা run-এ --store-durations দিয়ে প্রতিটি test-এর সময় .test_durations নামের JSON ফাইলে রেখেছিল (§২)। তারপর তিনটি নীতিতে --splits 3 --group 1, 2, 3: তিনটি process একসাথে চালু, যেন তিনটি CI যন্ত্র। সত্যিকারের আউটপুট, ছাঁটা:

== no durations (count): wall 51.81 s
  [pytest-split] No test durations found. Pytest-split will split tests evenly …
  group 1: done after 51.81 s | 500 passed, 1000 deselected in 50.12s
  group 2: done after 18.36 s | 500 passed, 1000 deselected in 16.69s
  group 3: done after  2.04 s | 500 passed, 1000 deselected in 0.37s
== duration_based_chunks: wall 32.10 s
  group 1: done after 31.51 s | 225 passed  (estimated duration: 20.84s)
  group 2: done after 32.10 s | 227 passed  (estimated duration: 20.89s)
  group 3: done after 31.51 s | 1048 passed (estimated duration: 20.71s)
== least_duration: wall 32.08 s
  group 1: done after 31.99 s | 315 passed  (estimated duration: 20.81s)
  group 2: done after 31.95 s | 592 passed  (estimated duration: 20.81s)
  group 3: done after 32.08 s | 593 passed  (estimated duration: 20.81s)

সমান সংখ্যা: durations ফাইল না থাকলে pytest-split প্রতিটি test-কে সমান ধরে ৫০০ করে ভাগ করে। ফাইলগুলো নাম অনুযায়ী সাজানো, তাই প্রথম ভাগে পড়ল পুরোনো API test আর test_scale_api-এর বড় অংশ, তৃতীয় ভাগে শুধু দ্রুত rule test. ফল ৫১.৮১, ১৮.৩৬ আর ২.০৪ সেকেন্ড: একটি যন্ত্র প্রায় সারাক্ষণ বসে থাকল, আর মোট সময় একটানা run-এর কাছাকাছি।

সময় দেখে: দুটি algorithm-ই অনুমিত সময় প্রায় সমান করেছে (২০.৭১ থেকে ২০.৮৯), আর তিনটি shard ০.৬ সেকেন্ডের মধ্যে শেষ হয়েছে। duration_based_chunks ক্রম না ভেঙে পরপর টুকরো কাটে (তাই একটি ভাগে ১০৪৮টি দ্রুত test); least_duration প্রতিটি test-কে সবচেয়ে কম ভারের ভাগে দেয় (৩১৫, ৫৯২, ৫৯৩টি)।

অনুমান ২০.৮, আসল প্রায় ৩২ সেকেন্ড কেন? তিনটি shard একই কম্পিউটারে একসাথে চলেছে, CPU আর disk ভাগ করে। প্রতিটি least_duration shard একা চালালে লাগল ২২.৫৯, ২৩.৪০ আর ২২.৩৯ সেকেন্ড, অনুমানের কাছাকাছি; বাড়তিটুকু Python চালু হওয়া আর test সংগ্রহ। আলাদা CI যন্ত্রে এই চিত্রই আশা করা যায়।

LPT — সবচেয়ে লম্বা কাজ আগে

least_duration-এর পেছনের নিয়মটি পুরোনো: LPT (Longest Processing Time first). কাজগুলো বড় থেকে ছোট সাজিয়ে প্রতিবার সবচেয়ে হালকা যন্ত্রে দেওয়া। নিচের প্রোগ্রাম §২-এর আসল ফাইলভিত্তিক সময় নিয়ে তিনটি নীতি তুলনা করে: সমান সংখ্যা, পুরো ফাইল ধরে LPT, আর বড় ফাইলকে প্রায় ৪ সেকেন্ডের টুকরো করে LPT:

# Real per-file numbers from the stored durations of the 1500-test suite
FILES = {  # file: (tests, seconds, serial)
    "scale_api": (300, 27.84), "scale_flows": (150, 20.72), "reviews": (36, 3.26),
    "orders": (23, 2.69), "auth_admin_search": (21, 2.21), "pages_and_meta": (14, 1.70),
    "phone": (17, 1.64), "pricing": (32, 1.11), "payment": (7, 1.03), "scale_rules": (900, 0.24),
}

def by_count(k):                  # equal number of tests per shard, files in name order
    cut, loads, done = sum(n for n, _ in FILES.values()) / k, [0.0] * k, 0
    for f in sorted(FILES):
        n, s = FILES[f]
        for _ in range(n):        # assume each test of a file costs the file's average
            loads[min(int(done // cut), k - 1)] += s / n; done += 1
    return loads

def lpt(jobs, k):                 # longest job first, onto the least-loaded shard
    loads, plan = [0.0] * k, [[] for _ in range(k)]
    for name, s in sorted(jobs, key=lambda j: -j[1]):
        i = loads.index(min(loads)); loads[i] += s; plan[i].append(name)
    return loads, plan

def show(name, loads):
    ideal = sum(loads) / len(loads)
    print(f"{name:16} {' / '.join(f'{x:5.2f}' for x in loads)}  wall {max(loads):5.2f} s"
          f"  ({max(loads) / ideal - 1:+.0%} over ideal {ideal:.2f})")

show("equal count", by_count(3))
loads, plan = lpt([(f, s) for f, (n, s) in FILES.items()], 3)
show("LPT, whole file", loads)
print("   shard 1 =", plan[0], "| shard 2 =", plan[1])
chunks = [(f"{f}#{i + 1}", s / max(1, round(s / 4)))      # cut files into ~4 s pieces
          for f, (n, s) in FILES.items() for i in range(max(1, round(s / 4)))]
show(f"LPT, {len(chunks)} chunks", lpt(chunks, 3)[0])

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

equal count      48.39 / 13.92 /  0.13  wall 48.39 s  (+132% over ideal 20.81)
LPT, whole file  27.84 / 20.72 / 13.88  wall 27.84 s  (+34% over ideal 20.81)
   shard 1 = ['scale_api'] | shard 2 = ['scale_flows']
LPT, 20 chunks   20.57 / 21.18 / 20.69  wall 21.18 s  (+2% over ideal 20.81)

সমান সংখ্যা ৪৮.৩৯ / ১৩.৯২ / ০.১৩: সত্যিকারের run-এর ৫১.৮১ / ১৮.৩৬ / ২.০৪-এর সাথে ছবিটি মেলে (আসল run-এ প্রতিটি shard-এর Python চালু হওয়ার সময়ও আছে, আর একসাথে চলায় যন্ত্র ভাগাভাগি)। পুরো ফাইল ধরে LPT ২৭.৮৪: একটি ফাইল (scale_api) একাই আদর্শ ২০.৮১-এর চেয়ে বড়, তাই তাকে না ভাঙলে কোনো ভাগই এর নিচে নামতে পারে না। টুকরো করে LPT ২১.১৮, আদর্শের মাত্র ২% ওপরে। নিজে বদলে দেখুন: lpt(chunks, 3)-এর জায়গায় 4 দিন, বা টুকরোর মাপ 4 থেকে 2 করুন। টুকরো যত ছোট, ভাগ তত সমান; কিন্তু বাস্তবে প্রতিটি টুকরোর নিজের শুরুর খরচ আছে।

প্রতিটি shard-এর ভার (সেকেন্ড)
এই ধাপে
shard ১
shard ২
shard ৩
makespan
  1. সবচেয়ে বড় টুকরো আগে। scale_flows (২০.৭২ সেকেন্ড) ৫টি টুকরো, প্রতিটি ৪.১৪; এরাই সবচেয়ে বড়। প্রতিটি যায় তখনকার সবচেয়ে হালকা shard-এ: ১, ২, ৩, ১, ২. ভার ৮.২৯ / ৮.২৯ / ৪.১৪.
  2. তারপর api. scale_api (২৭.৮৪) ৭টি টুকরো, প্রতিটি ৩.৯৮; প্রথম দুটি হালকা shard ৩-এ, তারপর পালা করে। ভার ১৬.২৪ / ১৬.২৪ / ১৬.০৮: প্রায় সমান।
  3. মাঝারি ফাইল। reviews (৩.২৬) যায় সবচেয়ে হালকা shard ৩-এ: ১৯.৩৪. তারপর orders (২.৬৯) shard ১-এ: ১৮.৯৩.
  4. ছোট ফাইল ফাঁক ভরায়। বাকি ছয়টি (২.২১ থেকে ০.২৪) একে একে সবচেয়ে হালকা shard-এ। শেষে ২০.৫৭ / ২১.১৮ / ২০.৬৯. ছোট কাজ শেষে রাখাই LPT-এর কৌশল: এরা বালির মতো ফাঁক ভরে।
  5. ফল। Makespan ২১.১৮, আদর্শ সমান ভাগ ২০.৮১-এর মাত্র ২% ওপরে। পুরো ফাইল না ভাঙলে ২৭.৮৪, কারণ একটি ফাইলই আদর্শের চেয়ে বড়। Test-স্তরে ভাঙলে pytest-split-এর মতো প্রায় নিখুঁত ভাগ সম্ভব।

Durations ফাইলও পুরোনো হয়। নতুন test-এর কোনো মাপা সময় থাকে না; pytest-split তাদের গড় সময় ধরে নেয়। নতুন একটি ধীর E2E ফাইল যোগ হলে ভাগ আবার অসম হতে পারে। নিয়মিত (যেমন রাতের run-এ) durations হালনাগাদ করুন, আর CI-তে ফাইলটি কোডের পাশে রাখুন। আর shard-এ ভাগ মানে test-গুলো আলাদা process-এ, আলাদা ক্রমে চলবে: যে test আগের test-এর রেখে যাওয়া অবস্থায় নির্ভর করে, সে এখানেই ভাঙবে (অনুশীলন ৩)।

৬ · ক্রম — আগে-ব্যর্থ আর দ্রুত test আগে

Selection test বাদ দেয়, sharding ভাগ করে; তৃতীয় হাতিয়ারটি কিছুই বাদ দেয় না, শুধু ক্রম বদলায়: test case prioritization. লক্ষ্য, ভুল থাকলে তার খবর যত আগে সম্ভব। সবচেয়ে সস্তা দুটি নিয়ম: যে test আগের run-এ ব্যর্থ হয়েছিল সেটি আগে (কারণ ভুলটি সম্ভবত এখনো আছে), আর দ্রুত test আগে (একই সময়ে বেশি যাচাই)। pytest-এর cache প্রথমটি নিজেই রাখে (পর্ব ২১-এ --lf আর --ff দেখেছেন); testmon দ্বিতীয়টি করে, §৩-এর মতো।

১৫০০টি test-এ coupon_ge bug চালু রেখে চারটি run, সত্যিকারের ফল:

$ BAZARGHAR_BUGS=coupon_ge uv run pytest -q -x              # default order
FAILED tests/test_pricing.py::test_coupon_rule[coupon-1000] - AssertionError:...
1 failed, 85 passed in 9.22s                  wall 10.80 s
$ BAZARGHAR_BUGS=coupon_ge uv run pytest -q                 # full, cache records failures
7 failed, 1493 passed in 61.84s               wall 63.40 s
$ BAZARGHAR_BUGS=coupon_ge uv run pytest -q --ff -x         # failed first
1 failed in 0.20s                             wall 1.73 s
$ BAZARGHAR_BUGS=coupon_ge uv run pytest -q --lf            # only last failed
7 failed in 0.71s                             wall 2.25 s

প্রথম ব্যর্থতার খবর ১০.৮০ থেকে নেমে এল ১.৭৩ সেকেন্ডে, যার বেশিরভাগ Python চালু হওয়া। পুরো run-এ ৭টি ব্যর্থতা ছড়িয়ে ছিল তিনটি ফাইলে; ডিফল্ট ক্রমে প্রথমটি আসে ৮৬তম test-এ, কারণ ফাইলগুলো নাম অনুযায়ী চলে আর test_pricing.py ষষ্ঠ। --ff শুধু ক্রম বদলায়, কিছু বাদ দেয় না, তাই নিরাপদ; --lf বাকিগুলো চালায় না, তাই শুধু ঠিক করার পরের দ্রুত যাচাইয়ে।

CI-তে pytest-এর cache সাধারণত থাকে না, কারণ প্রতিটি job খালি যন্ত্রে শুরু হয়। তখন “আগে-ব্যর্থ” তথ্য আসে test-এর ইতিহাস থেকে (পর্ব ৬৭-এর JUnit XML), cache হিসেবে সংরক্ষণ করে, বা একটি ছোট নিজস্ব তালিকা থেকে। গবেষণায় কোনো ক্রম কত ভালো তার একটি প্রচলিত মাপ APFD; Rothermel ও সহলেখকেরা (IEEE TSE, ২০০১) এটি ব্যবহার করে বিভিন্ন prioritization কৌশল তুলনা করেছিলেন। মাপটির মূল ভাব সহজ: ভুলগুলো ক্রমের কত শুরুর দিকে ধরা পড়ে।

Sharding-এর সাথে ক্রম: shard-এর ভেতরেও failed-first কাজে লাগে, কিন্তু খেয়াল রাখুন, ক্রম বদলালে ক্রম-নির্ভর test ভাঙে। এটি আসলে লাভ: যে test শুধু একটি নির্দিষ্ট ক্রমে পাস করে, তার ভুল এখনই জানা ভালো (পর্ব ৪০-এর pytest-randomly). আর -x শুধু স্থানীয় কাজে; CI-তে পুরো ছবি দরকার, তাই সেখানে সাধারণত --maxfail-এর মতো একটি বড় সীমা।

৭ · Flake budget, retry আর quarantine — বড় পরিসরে সিদ্ধান্ত

পর্ব ৪০ (Flaky test)-এ দেখেছেন, প্রতিটি test আলাদাভাবে “প্রায় নির্ভরযোগ্য” হলেও হাজার test-এর suite প্রায় কখনো সবুজ হয় না, আর retry আসল bug-কেও ঢেকে দেয়। ছোট দলে প্রতিটি flaky test আলাদা করে ধরা যায়। বড় suite-এ দরকার একটি নিয়ম, যা আগে থেকে লেখা থাকে আর সংখ্যা দেখে সিদ্ধান্ত দেয়: flake budget.

লোডশেডিংয়ের সময় একটি কারখানার কথা ভাবুন। মালিক ঠিক করেছেন, মাসে দুই ঘণ্টার বেশি বিদ্যুৎ গেলে জেনারেটর কিনবেন। প্রতিদিন তর্ক করতে হয় না; খাতা দেখে সিদ্ধান্ত হয়ে যায়। Flake budget-ও তাই: “অপরিবর্তিত কোডে ১০০টি run-এর মধ্যে বড়জোর ৫টি অকারণে লাল হতে পারে।” সীমা ছাড়ালে নতুন feature-এর আগে flaky test সারানো।

লক্ষ্য যদি হয় অপরিবর্তিত কোডে অন্তত ৯৫% run সবুজ, তাহলে প্রতি run-এ flaky ব্যর্থতার গড় সংখ্যা বড়জোর −ln(০.৯৫) ≈ ০.০৫১৩ হতে পারে। ১৫০০টি test সমানভাবে ভাগ করে নিলে প্রতিটির flake rate হতে হবে প্রায় ০.০০০০৩৪-এর নিচে, অর্থাৎ ত্রিশ হাজার run-এ একবারের কম। কোনো দলই প্রতিটি test এভাবে মাপে না; বাস্তবে budget-টি দেখা হয় পুরো suite-এর ইতিহাস থেকে (পর্ব ৬৭, Test report আর metric-এর JUnit XML ইতিহাস), আর সবচেয়ে বড় অপরাধীদের আগে ধরা হয়। নিচের stepper একটি কাল্পনিক কিন্তু হিসাব-যাচাই করা ইতিহাস দিয়ে সিদ্ধান্তটি দেখায়:

লক্ষ্য: অপরিবর্তিত কোডে ≥ ৯৫% সবুজ
flaky test
flaky ভার
সবুজ run
সিদ্ধান্ত
  1. নিয়ম আগে। দল লিখে রাখল: অপরিবর্তিত কোডে অন্তত ৯৫% run সবুজ। স্বাধীন flake ধরে নিলে সবুজের সম্ভাবনা মোটামুটি e−λ, যেখানে λ প্রতি run-এ flaky ব্যর্থতার গড়। তাই λ ≤ −ln(০.৯৫) ≈ ৫.১৩%. এটিই budget.
  2. ইতিহাস গোনা। main branch-এর শেষ ৫০০টি run, যেখানে কোড বদলায়নি অথচ ফল বদলেছে (একই commit-এ পাস আর ফেল)। চারটি test ধরা পড়ল: A ২০ বার, B ৬, C ৩, D ১ বার।
  3. Budget পার। হার: A ৪.০%, B ১.২%, C ০.৬%, D ০.২%; মোট ভার ৬.০%, সীমার ওপরে। চারটির প্রতিটি পাস করার সম্ভাবনা গুণ করলে সবুজ run ৯৪.১%: প্রতি ১০০টি PR-এ প্রায় ৬টি অকারণে লাল।
  4. সবচেয়ে বড়টিকে quarantine. A (৪%) মূল সিদ্ধান্ত থেকে সরল। বাকি ভার ২.০%, সবুজ ৯৮.০%: budget-এর ভেতরে, হাতে কিছু জায়গাও রইল। B পরের সপ্তাহের কাজের তালিকায়, কারণ নতুন কোনো flake এলেই সীমা আবার কাছে চলে আসবে।
  5. Quarantine-এর শর্ত। A মুছে ফেলা হয়নি: একটি owner, একটি ticket, একটি সময়সীমা, আর রাতের আলাদা job-এ বারবার চলা। ৪% flake অন্তত একবার দেখতে ৯৫% নিশ্চয়তায় প্রায় ৭৪ বার চালাতে হয় (ln ০.০৫ ÷ ln ০.৯৬); তাই রাতের job-এ সংখ্যাটি সেভাবে রাখা। সময়সীমা পেরোলে সিদ্ধান্ত: সারানো, নতুন করে লেখা, নয়তো মুছে ফেলা।

বড় suite-এ retry-এর নীতি

Retry পুরোপুরি নিষেধ করা বাস্তবসম্মত নয়; নিয়ন্ত্রণের বাইরের ক্ষণিক সমস্যা (যেমন CI যন্ত্রের network-এ মুহূর্তের বাধা) থাকবেই। কিন্তু বড় দলে কয়েকটি নিয়ম কাজে লাগে:

  • Retry শুধু চিহ্নিত test-এ, ঢালাও নয়; আর সেই চিহ্নেরও owner আর সময়সীমা থাকে।
  • “Retry-তে পাস” আলাদা ফল, সবুজ নয়। JUnit XML-এ rerun সংখ্যা রাখা হয় আর flake budget-এর হিসাবে যোগ হয়। না হলে retry budget-কে লুকিয়ে ফেলে।
  • নতুন বা বদলানো test-এ retry নয়। নতুন test merge-এর আগে বারবার চালিয়ে দেখা হয় (পর্ব ৪০), যাতে flake suite-এ ঢোকার আগেই থামে।
  • State বদলানো test-এ retry বিপজ্জনক: অর্ডার, payment বা stock বদলায় এমন test আবার চালালে app-এ জঞ্জাল জমে, আর ভুল কারণে সবুজ আসতে পারে।

৮ · রক্ষণাবেক্ষণ — owner, data, repository আর বড় প্রতিষ্ঠানের অভিজ্ঞতা

বড় suite শুধু দ্রুত চালানোর প্রশ্ন নয়; বছরের পর বছর বিশ্বাসযোগ্য রাখার প্রশ্ন। চারটি অভ্যাস সবচেয়ে বেশি কাজে লাগে।

প্রতিটি test-এর owner

Test ownership: লাল বা flaky হলে কার কাছে খবর যাবে, তা লেখা থাকে। অনেক দল CODEOWNERS ফাইলেই test ফোল্ডারের দায়িত্ব লেখে (সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৪)। মালিকহীন test-ই সবচেয়ে বেশি দিন quarantine-এ পড়ে থাকে।

প্রতি test-এর নিজের data

Shard আর worker বাড়লে shared অবস্থা বিষ। বাজারঘরের suite নিরাপদে ভাগ হলো কারণ প্রতিটি test নিজের database ফাইল পায়। চলন্ত app-এ প্রতিটি worker-এর নিজের ব্যবহারকারী বা নিজের app কপি লাগে (পর্ব ৩৭ Playwright গভীরে, পর্ব ৬৫ Test environment আর test data).

নিয়মিত ছাঁটাই

প্রতি কয়েক মাসে: সবচেয়ে ধীর ২০টি test, সবচেয়ে বেশি flaky ১০টি, আর বছরে একবারও কিছু না ধরা পুরোনো E2E. প্রতিটির জন্য একটি সিদ্ধান্ত: দ্রুত করা, নিচের স্তরে নামানো (UI থেকে API বা unit), মেলানো, নয়তো mutation দেখে মুছে ফেলা।

সময়ের বাজেটও

Flake-এর মতো suite duration-এরও সীমা রাখুন, যেমন “PR-এর test ১০ মিনিটের মধ্যে”। সীমা ছুঁলে নতুন test যোগের আগে পুরোনোগুলোর খরচ কমানোর কাজ। সংখ্যাটি দলের নিজের অভিজ্ঞতা থেকে আসা উচিত; সর্বজনীন কোনো সঠিক মান নেই।

Monorepo না অনেক repository — test-এর চোখে

Monorepo-তে সব service এক জায়গায়, তাই একটি পরিবর্তনের প্রভাব পুরো কোডে দেখা যায়: এক commit-এ library আর তার সব ব্যবহারকারী একসাথে test হয়। দাম হলো, selection ছাড়া প্রতিটি পরিবর্তনে বিশাল suite চলত; তাই monorepo প্রায় সবসময় একটি build graph নির্ভর tool-এর সাথে আসে, যেমন Bazel, যেখানে প্রতিটি target-এর নির্ভরতা ঘোষণা করা থাকে। Polyrepo-তে প্রতিটি repository-র suite ছোট আর দ্রুত, কিন্তু এক service-এর পরিবর্তন অন্যটিকে ভাঙল কি না তা ধরা পড়ে দেরিতে, অন্য repository যখন নতুন version নেয়; সেই ফাঁক ভরাতে লাগে contract test (পর্ব ৩২, Contract testing). দুই পদ্ধতির গঠন সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ১৯-এ আছে।

বড় প্রতিষ্ঠান কী করেছে — নাম আর সাবধানতা

  • Google-এর TAP: Google-এর continuous testing ব্যবস্থার নাম TAP (Test Automation Platform). Memon ও সহলেখকদের প্রবন্ধ “Taming Google-Scale Continuous Testing” (ICSE SEIP ২০১৭) বর্ণনা করে, পরিবর্তনে প্রভাবিত test build-নির্ভরতা দিয়ে বের করা হয়, আর দিনের কাজ কয়েকটি ধাপে (milestone) ভাগ করে কোডের একেকটি snapshot test করা হয়। প্রবন্ধের বিস্তারিত সংখ্যা আমরা এখানে দিচ্ছি না।
  • Facebook-এর predictive test selection: Machalica ও সহলেখক (ICSE SEIP ২০১৯) ইতিহাস থেকে শেখা মডেল দিয়ে বাছাই করেছিলেন। তাঁদের দাবি, test-এর অবকাঠামো খরচ প্রায় অর্ধেক কমিয়েও ৯৫%-এর বেশি আলাদা test ব্যর্থতা আর ৯৯.৯%-এর বেশি ভুল পরিবর্তন ধরা পড়েছে। এটি তাঁদের পরিবেশের প্রকাশিত ফল, আমরা যাচাই করিনি।
  • Sapienz: Mao, Harman ও Jia-র (ISSTA ২০১৬) একটি search-based tool, যা Android app-এর জন্য নিজে test sequence বানায়; পরে Facebook-এ ব্যবহারের কথা প্রকাশিত হয়েছে। এটি selection নয়, বড় পরিসরে test তৈরির উদাহরণ; উল্লেখ করা হলো কারণ ইন্টারভিউতে নামটি আসে।

আরও গভীরে: Regression test selection-এর গবেষণা পুরোনো। Rothermel ও Harrold (ACM TOSEM, ১৯৯৭) control-flow graph তুলনা করে একটি “safe” পদ্ধতি দেন; Gligoric, Eloussi ও Marinov-এর Ekstazi (ISSTA ২০১৫) দেখান, method নয়, ফাইল-স্তরের নির্ভরতা ধরলেও বাস্তবে ভালো ফল আসে আর খরচ কম। Yoo ও Harman-এর সমীক্ষা (STVR, ২০১২) minimization, selection আর prioritization তিনটিকে এক কাঠামোয় আনে। Sharding-এর গণিত আসে scheduling থেকে: Graham (১৯৬৯) দেখান, LPT-এর makespan কখনো সেরা সম্ভাব্য সময়ের (৪/৩ − ১/(৩m)) গুণের বেশি নয়, যেখানে m যন্ত্রের সংখ্যা।

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

  • Test selection আর prioritization-এর পার্থক্য? Selection কিছু test বাদ দেয়; prioritization সব রাখে, শুধু ক্রম বদলায়।
  • Selection কখন বিপজ্জনক? যখন পরিবর্তন code-এর বাইরে (template, config, data, lockfile) বা map পুরোনো; তাই রাতে পুরো suite আর ছোট always-run set.
  • Count দিয়ে shard ভাগ করলে সমস্যা? Test-গুলোর সময় অসমান; সবচেয়ে ধীর shard-ই মোট সময় ঠিক করে। মাপা সময় দিয়ে ভাগ করুন।
  • একই coverage মানেই redundant test? না; সীমার মান আলাদা ভুল ধরে। মুছে ফেলার আগে mutation দিয়ে যাচাই।
  • Flake budget কী? অকারণ লাল run-এর আগে থেকে লেখা সীমা; ছাড়ালে flaky test সারানো বা owner আর সময়সীমাসহ quarantine.

৯ · AI-এর যুগে বড় test suite

AI assistant দিয়ে test লেখা খুব দ্রুত, তাই suite আগের চেয়েও দ্রুত বড় হয়। বড় suite-এ AI-এর সাধারণ ভুলগুলোর দাম গুণে বাড়ে: হাজার test-এ একটি sleep মানে হাজারবার অপেক্ষা; একটি অচেনা plugin option মানে CI-এর সব shard লাল।

AI যা প্রায়ই করেবড় suite-এ দামযাচাই
শুধু happy path, একই রকম শত testসময় বাড়ে, নতুন ভুল ধরে না; coverage একইMutation-এ নতুন mutant মারে কি না
Code এখন যা করে তাই assertBug-ওয়ালা কোডেও সবুজ; selection-ও ভুল আস্থা দেয়প্রতিটি assert লিখিত requirement-এর সাথে মেলানো
time.sleep দিয়ে অপেক্ষাধীর আর flaky; budget খায়--durations, শর্তের অপেক্ষা
অস্তিত্বহীন option (যেমন ভুল নামের shard flag)সব shard একসাথে ব্যর্থ, বা চুপচাপ পুরো suite চলেPlugin-এর অফিসিয়াল ডকুমেন্টেশন, --help
Global reset, স্থির id (যেমন “অর্ডার ৮”)Parallel আর shard-এ ভাঙেএলোমেলো ক্রম আর -n 3-এ চালানো
সব mock করে ফেলাদ্রুত কিন্তু কিছুই আসল test হয় নাএকটি আসল bug বসিয়ে দেখা ধরে কি না
না চালিয়েই “সব test পাস” বলাভুল আস্থানিজে চালানো, আউটপুট পড়া

AI-কে বিশ্লেষণে ব্যবহার করুন, সিদ্ধান্তে নয়। মাপা তথ্য দিন, আর উত্তর যাচাইযোগ্য রূপে চান:

তুমি একজন অভিজ্ঞ SDET. নিচে আমাদের pytest suite-এর .test_durations ফাইলের সারাংশ (ফাইল, test সংখ্যা, মোট সেকেন্ড) আর শেষ ৩০০টি CI run-এর flaky তালিকা (test, কতবার একই commit-এ পাস ও ফেল দুটোই) দিলাম। [এখানে সারাংশ পেস্ট করুন] ১. তিনটি shard-এর জন্য ভারসাম্যপূর্ণ ভাগ প্রস্তাব করো, প্রতিটির আনুমানিক সময়সহ, আর হিসাবটি দেখাও। ২. আমাদের লক্ষ্য অপরিবর্তিত কোডে ৯৫% সবুজ; কোন test-গুলো quarantine-এ যাওয়া উচিত, হিসাবসহ। ৩. শুধু pytest-split আর pytest-xdist-এর এমন option ব্যবহার করো যা তাদের অফিসিয়াল ডকুমেন্টেশনে আছে, আর প্রতিটির জন্য ডকুমেন্টেশনের অংশের নাম বলো। ৪. কোনো test মুছে ফেলার পরামর্শ দিও না; শুধু “যাচাই করার মতো প্রার্থী” তালিকা দাও।

AI-এর পরামর্শ হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১Test selection এত সময় বাঁচায়, তবু বড় প্রতিষ্ঠানগুলো কেন একসময় পুরো suite চালায়?

কারণ প্রতিটি selection পদ্ধতি একটি অনুমানের ওপর দাঁড়িয়ে, আর অনুমান কখনো না কখনো ভাঙে। Coverage-ভিত্তিক selection ধরে নেয়, test-এর আচরণ শুধু সেই code-এর ওপর নির্ভর করে যা test চলার সময় চলেছিল। এই পর্বের ল্যাবেই দেখেছেন অনুমানটি কোথায় ভাঙে: একটি Jinja template বদলালে pytest-testmon একটিও test বাছেনি, অথচ পুরো suite চালাতে একটি test লাল হলো। একই রকম অন্ধ জায়গা আছে configuration ফাইলে, database migration-এ, lockfile-এ নতুন library version-এ, পরিবেশে (Python-এর নতুন version), আর সময় বা তারিখে নির্ভর কোডে।

Rothermel ও Harrold-এর ১৯৯৭ সালের কাজ “safe” selection-এর ধারণা স্পষ্ট করে: নির্দিষ্ট অনুমানের ভেতরে প্রভাবিত কোনো test বাদ যাবে না। শব্দটি গুরুত্বপূর্ণ: “অনুমানের ভেতরে”। বাস্তব সিস্টেমে সব অনুমান কেউ নিশ্চিত করতে পারেন না। Google-এর TAP নিয়ে ২০১৭ সালের প্রবন্ধে বর্ণিত ব্যবস্থায় build-নির্ভরতা দিয়ে প্রভাবিত test বের করা হয়, কিন্তু নিয়মিত বিরতিতে কোডের snapshot-ও test করা হয়; বিস্তারিত সংখ্যা প্রবন্ধে আছে।

তাই পরিপক্ব নকশা তিন স্তরের: প্রতিটি PR-এ বাছাই করা test আর একটি ছোট always-run set; merge-এর সময় বা কিছুক্ষণ পরপর বড় অংশ; রাতে পুরো suite. রাতের run-এ এমন ব্যর্থতা এলে যা দিনের selection ধরেনি, সেটি নিজেই একটি তথ্য: map-এর কোন ফাঁক দিয়ে এটি গলল, তা খুঁজে selection-এর নিয়মে যোগ করা হয়। অর্থাৎ পুরো run শুধু নিরাপত্তা জাল নয়, selection-কে শেখানোর উপায়ও।

আরেকটি দিক হলো সময়ের সাথে ভুলের দাম। দিনের বেলায় ধরা পড়া ভুল যে developer করেছেন তিনিই মনে রেখে সারান; রাতে ধরা পড়লে কোন commit দায়ী তা খুঁজতে হয় (culprit finding), যা অনেক পরিবর্তন একসাথে থাকলে কঠিন। তাই রাতের run যত বিরল হয়, selection তত নিখুঁত হওয়া দরকার।

মূল উপলব্ধি: Selection একটি ঝুঁকিপূর্ণ ছাড়, নিরাপত্তার নিশ্চয়তা নয়। ছাড় নিন, কিন্তু নিয়মিত পুরো suite দিয়ে যাচাই করে নিন ছাড়টি কোথায় ফাঁকি দিচ্ছে।

প্র ০২একই coverage দেখে test মুছে দিলে কী হারায়? Suite ছোট করার সৎ উপায় কী?

Test suite minimization-এর পুরোনো গবেষণার মূল চিন্তা ছিল: একই coverage-লক্ষ্য পূরণ করে এমন সবচেয়ে ছোট test-এর সেট খোঁজা। সমস্যা হলো, coverage মাপে কোন লাইন চলল, কী যাচাই হলো তা নয়। এই পর্বের ব্রাউজারের প্রোগ্রামে আটটি coupon test মাত্র দুটি coverage signature-এ পড়ল; “প্রতি signature-এ একটি” রাখলে বাকি থাকে ৫০০ আর ১০০১, আর তিনটি mutant-এর একটিও আর মরে না। ১০০০ সীমা, ৩০০০-এর cap, ৩০১০-এ floor-এর প্রভাব: এই মানগুলো test design technique (পর্ব ০৮, boundary value analysis) দিয়ে ইচ্ছা করে বাছা হয়েছিল, আর coverage তাদের পার্থক্য দেখে না।

গবেষণাতেও এর মিশ্র ফল এসেছে: কিছু পরীক্ষায় coverage ধরে রেখে minimize করা suite-এর ভুল ধরার ক্ষমতা উল্লেখযোগ্যভাবে কমেছে, কিছুতে কম কমেছে; ফল নির্ভর করেছে প্রোগ্রাম আর test-এর ধরনের ওপর। সাধারণ শিক্ষা: শুধু coverage-কে মানদণ্ড ধরে মুছে ফেলা ঝুঁকিপূর্ণ।

সৎ উপায়টি ধাপে ধাপে। প্রথমে প্রার্থী খুঁজুন: একই signature, খুব ধীর, বছরে কিছু না ধরা, বা একই কথা বারবার বলা E2E. তারপর প্রতিটি প্রার্থীর জন্য প্রশ্ন: এটি সরালে কোন mutant আর মরে না (পর্ব ৫৯, Mutation testing)? কোন requirement-এর একমাত্র test এটি (traceability, পর্ব ১৯)? তৃতীয়ত, মুছে ফেলার চেয়ে প্রায়ই ভালো হলো মেলানো বা নামানো: দশটি আলাদা E2E-কে একটি parametrize-করা API test-এ আনা, বা UI-তে করা হিসাবের যাচাই unit-এ নামানো। এতে suite দ্রুত হয়, কিন্তু যাচাই থাকে।

শেষে মনে রাখুন pesticide paradox (পর্ব ০৩): একই test বছরের পর বছর চালালে নতুন ভুল কম ধরে। তাই ছাঁটাই আর নতুন test নকশা দুটোই রক্ষণাবেক্ষণের অংশ; শুধু সংখ্যা কমানো লক্ষ্য নয়।

মূল উপলব্ধি: Coverage overlap বলে “কোথায় তাকাবেন”; mutation আর requirement বলে “কী মুছতে পারবেন”। সিদ্ধান্ত দ্বিতীয়টির ওপর দাঁড়ায়।

প্র ০৩Flake budget কি flaky test-কে “বৈধতা” দেয় না? সীমা রাখা আর শূন্য-সহনশীলতার মধ্যে কোনটি ভালো?

প্রশ্নটি ন্যায্য। শূন্য-সহনশীলতা শুনতে কঠোর আর পরিষ্কার: কোনো flaky test সহ্য করা হবে না। কিন্তু বড় suite-এ এর বাস্তব ফল প্রায়ই উল্টো। পর্ব ৪০-এর হিসাব মনে করুন: হাজার test-এর suite-এ প্রতিটি হাজারে একবার flaky হলেও মাত্র ৩৬.৮% run সবুজ। Flake শূন্যে নামানো সম্ভব না হলে “শূন্য” নিয়ম দুটি খারাপ পথ খোলে: হয় নিয়মটি নীরবে উপেক্ষিত হয় আর দল “re-run” বোতাম চাপতে শেখে, নয়তো সন্দেহজনক test ঢালাওভাবে মুছে ফেলা হয়, যার সাথে আসল সংকেতও হারায়।

Budget এই দুইয়ের মাঝখানে একটি পরিমাপযোগ্য চুক্তি। এটি বলে: এই পরিমাণ অকারণ লাল পর্যন্ত আমরা নতুন কাজ চালিয়ে যাব, তার বেশি হলে flake সারানো অগ্রাধিকার পাবে। ধারণাটি SRE-এর error budget থেকে এসেছে (পর্ব ৫০, SLO আর capacity testing): নির্ভরযোগ্যতা শতভাগ নয়, একটি লক্ষ্যমাত্রা, আর বাজেট শেষ হলে গতির বদলে স্থিতি।

বৈধতা দেওয়ার ঝুঁকি কমাতে তিনটি শর্ত দরকার। এক, budget-এর ভেতরেও প্রতিটি flaky test-এর ticket আর owner থাকে; budget শুধু ঠিক করে কখন সবকিছু থামাতে হবে। দুই, quarantine-এর সময়সীমা থাকে, যাতে সেটি পরিত্যক্ত test-এর গুদাম না হয়ে যায়; Martin Fowler-এর ২০১১ সালের প্রবন্ধ ঠিক এই সতর্কতা দিয়েছিল। তিন, flake-এর হিসাব আলাদাভাবে রিপোর্ট হয়, retry-তে পাসও গোনা হয়; না হলে retry budget-কে লুকিয়ে ফেলে আর সংখ্যা মিথ্যা হয়ে যায়।

আরেকটি দিক মনে রাখা দরকার: কিছু “flaky” test আসলে product-এর intermittent bug ধরছে, যেমন race condition (পর্ব ৬২)। Budget-এর হিসাবে সেটিকে শব্দ ধরলে আসল ভুল চাপা পড়ে। তাই quarantine-এর আগে অন্তত একবার জিজ্ঞাসা: ভুলটা কি test-এর, না product-এর?

মূল উপলব্ধি: সীমাহীন সহনশীলতা আর অবাস্তব শূন্য, দুটোই সংকেত নষ্ট করে। লেখা budget, owner আর সময়সীমা মিলে flake-কে একটি পরিচালনাযোগ্য ঝুঁকি বানায়।

প্র ০৪Monorepo-তে test চালানো কেন একটি build system-এর সমস্যা হয়ে দাঁড়ায়?

Monorepo-র বড় সুবিধা হলো, একটি library বদলালে তার সব ব্যবহারকারীকে একই পরিবর্তনে test করা যায়; পুরোনো version-এ আটকে থাকা ব্যবহারকারী নেই। Potvin ও Levenberg-এর ২০১৬ সালের প্রবন্ধ (Communications of the ACM) Google-এর এই পদ্ধতির সুবিধা আর খরচ দুটোই বর্ণনা করে। কিন্তু সুবিধাটির দাম: যদি প্রতিটি পরিবর্তনে পুরো repository-র সব test চলত, তাহলে কোড যত বাড়ত, প্রতিটি PR-এর অপেক্ষা তত বাড়ত, আর কোনো এক কোণের flaky test সবার PR আটকাত।

তাই monorepo-তে প্রশ্নটি হয়ে যায়: “এই পরিবর্তন কোন কোন target-কে ছোঁয়?” Coverage দিয়ে এর উত্তর দেওয়া যায়, কিন্তু coverage মাপতে আগে test চালাতে হয়, আর ভাষা বা প্রক্রিয়া পেরোলে (যেমন Python service একটি C++ library ডাকে) তা কঠিন। Bazel-এর মতো build system অন্য পথ নেয়: প্রতিটি target নিজের নির্ভরতা ঘোষণা করে, তাই নির্ভরতার গ্রাফ থেকে কোনো test না চালিয়েই বলা যায় কোনগুলো প্রভাবিত। ঘোষণা ভুল হলে build-ই ব্যর্থ হয়, তাই map সৎ থাকে। দামটি হলো, ঘোষণা লেখা আর বজায় রাখার পরিশ্রম, আর সব tool-কে এই কাঠামোয় আনা।

Build graph আরেকটি সুবিধা দেয়: hermetic build আর cache. একই input-এ একই ফল ধরে নিয়ে আগে চালানো test-এর ফল আবার ব্যবহার করা যায়, শুধু input বদলালে আবার চালানো হয়। এটি selection-এরই আরেক রূপ। কিন্তু সেটি নিরাপদ শুধু তখন, যখন test সত্যিই hermetic: network, ঘড়ি বা এলোমেলো seed-এ নির্ভর test cache-এ ভুল সবুজ রেখে যেতে পারে।

Polyrepo-তে এই সমস্যা ছোট দেখায়, কারণ প্রতিটি repository-র suite আলাদা। কিন্তু সমস্যাটি চলে যায় integration-এর মুহূর্তে: library-র নতুন version কে কখন নেবে, আর তখন কী ভাঙবে। Contract test আর semantic versioning সেই ফাঁক কমায়, দূর করে না।

মূল উপলব্ধি: Repository-র গঠন ঠিক করে দেয় কোথায় test-এর খরচ পড়বে: monorepo-তে প্রতিটি পরিবর্তনে, তাই নির্ভরতার গ্রাফ লাগে; polyrepo-তে integration-এর সময়, তাই চুক্তি লাগে।

প্র ০৫মেশিন লার্নিং দিয়ে test বাছাই করলে কী লাভ, আর কোথায় বিপদ?

Predictive test selection প্রশ্নটি উল্টো দিক থেকে দেখে। “কোন test এই code ছোঁয়” না জিজ্ঞেস করে জিজ্ঞাসা করে: “ইতিহাস বলে, এমন পরিবর্তনে কোন test সাধারণত ব্যর্থ হয়?” বৈশিষ্ট্য হতে পারে বদলানো ফাইল আর test-এর মধ্যে দূরত্ব, পরিবর্তনের আকার, test-এর সাম্প্রতিক ব্যর্থতার হার, কোন দল বা কোন ধরনের ফাইল। Machalica ও সহলেখকেরা (Facebook, ICSE SEIP ২০১৯) এমন একটি মডেলের কথা লিখেছিলেন, যার দাবি ছিল খরচ প্রায় অর্ধেক করেও ৯৯.৯%-এর বেশি ভুল পরিবর্তন ধরা। Flaky test ছিল তাঁদের বড় বাধা, কারণ শেখার data-তেই শব্দ থাকে।

লাভ স্পষ্ট: build graph বা coverage না থাকলেও কাজ করে, ভাষা আর প্রক্রিয়ার সীমা মানে না, আর খরচ ও ঝুঁকির মধ্যে একটি নব (knob) দেয়: সম্ভাবনার সীমা কমালে বেশি test, বাড়ালে কম।

বিপদগুলোও গুরুত্বপূর্ণ। এক, এটি নিরাপদ নয় সংজ্ঞাতেই; কিছু ব্যর্থতা ইচ্ছা করেই বাদ পড়ে, তাই পরে পুরো run দরকার। দুই, ফিডব্যাক লুপ: যে test কম বাছাই হয়, তার ইতিহাসে ব্যর্থতাও কম জমে, ফলে মডেল তাকে আরও কম বাছে। নতুন ধরনের ভুল, যা অতীতে ঘটেনি, মডেল চেনে না। তিন, ব্যাখ্যা: “এই test কেন চলেনি?” প্রশ্নের উত্তর “মডেল বলেছে” হলে দলের আস্থা কমে। চার, data-র মান: flaky ফল দিয়ে শেখা মডেল flake-কেই “গুরুত্বপূর্ণ” ভাবতে পারে।

তাই ব্যবহারিক পথ হলো মিশ্র: নিশ্চিত নির্ভরতা (build graph বা coverage) থেকে আসা test সবসময়, মডেল শুধু বাকিগুলোর মধ্যে অগ্রাধিকার দেয়, ছোট একটি এলোমেলো নমুনা প্রতিবার যোগ হয় যাতে ইতিহাস একপেশে না হয়, আর রাতে পুরো suite. এই পর্বের মূল কৌশলগুলো সেই ভিত্তি; মডেল তার ওপরে একটি স্তর।

মূল উপলব্ধি: ML selection একটি সম্ভাবনার বাজি, প্রমাণ নয়। নিশ্চিত নির্ভরতা, এলোমেলো নমুনা আর পুরো run দিয়ে বাজিটি ঘিরে রাখলে লাভ পাবেন, অন্ধ জায়গাও চোখে থাকবে।

অনুশীলন

চারটি কাজ: একটি selection tool-এর জন্য test নকশা, একটি sharding-এর ফল আগে থেকে বলা, একটি ভাঙা test খোঁজা, আর একটি flake budget-এর সিদ্ধান্ত।

  1. Selection tool-এর test নকশা। বাজারঘরের দল একটি ছোট select_tests tool লিখছে। Spec: (ক) শুধু .py ফাইল বদলালে coverage map থেকে যেসব test বদলানো function চালায়, সেগুলো; (খ) templates/-এর কোনো ফাইল বদলালে সব page test (test_pages_*) যোগ; (গ) pyproject.toml বা uv.lock বদলালে পুরো suite; (ঘ) map-এ নেই এমন (নতুন) test সবসময় চলে; (ঙ) কিছুই না বদলালে শুধু smoke set. Equivalence partitioning আর boundary-র চিন্তা দিয়ে অন্তত ছয়টি test case লিখুন: input (বদলানো ফাইলের তালিকা) আর expected ফল।

    Partition হলো পরিবর্তনের ধরন; প্রতিটি থেকে অন্তত একটি, আর মিশ্র ও প্রান্তের ক্ষেত্র:

    IDবদলানো ফাইলExpectedকোন নিয়ম
    T1(কিছু না)শুধু smoke setঙ, খালি তালিকার প্রান্ত
    T2rules.py (normalize_phone)map-এ phone চালানো test + নতুন testক, ঘ
    T3templates/base.htmlসব page test + map-এর কোনো test নয় + নতুন testখ
    T4uv.lockপুরো suiteগ
    T5rules.py + templates/cart.htmlদুটির মিলন: map-এর test ∪ সব page testক + খ মিশ্র
    T6rules.py + pyproject.tomlপুরো suite (গ সবকিছুকে ছাপিয়ে যায়)অগ্রাধিকারের নিয়ম
    T7.py ফাইল যার কোনো function কোনো test চালায়নিশুধু নতুন test আর smoke; সাথে সতর্কবার্তা “untested code বদলেছে”ক-এর ফাঁকা ফল

    T6 আর T7 spec-এর ফাঁক দেখায়: দুই নিয়ম একসাথে খাটলে কোনটি জিতবে, আর map-এ যার কোনো test নেই এমন code বদলালে কী হবে, spec তা বলে না। Test নকশা করতে গিয়ে requirement-এর প্রশ্ন বের হওয়াই এই কাজের আসল ফল (পর্ব ১৫)।

  2. ফল আগে বলুন। সাতটি test-এর মাপা সময় (সেকেন্ড): 9, 7, 6, 5, 4, 3, 3. তিনটি shard-এ LPT নিয়মে ভাগ করুন (সবচেয়ে লম্বা আগে, প্রতিবার সবচেয়ে কম ভারের shard-এ)। প্রতিটি shard-এর মোট আর makespan কত? এর চেয়ে ভালো ভাগ কি সম্ভব?

    ধাপে ধাপে: 9 → ১, 7 → ২, 6 → ৩; তখন ভার 9/7/6. 5 → ৩ (6 সবচেয়ে কম) = 11; 4 → ২ (7) = 11; 3 → ১ (9) = 12; শেষ 3 → ২ বা ৩ (দুটিই 11; প্রথমটি বেছে) = 14. ফল: shard ১ = 9 + 3 = 12, shard ২ = 7 + 4 + 3 = 14, shard ৩ = 6 + 5 = 11; makespan ১৪ সেকেন্ড। মোট ৩৭, আদর্শ ১২.৩৩.

    ভালো ভাগ আছে: {9, 4} = 13, {7, 6} = 13, {5, 3, 3} = 11; makespan ১৩. সব ৩৭ = ২১৮৭টি ভাগ script দিয়ে যাচাই করে দেখা গেছে ১৩-ই সেরা। LPT দ্রুত আর প্রায় সবসময় ভালো, কিন্তু নিখুঁত নয়; Graham-এর সীমা অনুযায়ী তিন shard-এ এটি সেরার ১১/৯ গুণের বেশি খারাপ হতে পারে না (এখানে ১৪/১৩ ≈ ১.০৮)।

  3. Bug খুঁজুন। নিচের দুটি test একা একা আর পরপর চালালে সবসময় পাস করে। Suite-কে pytest-split দিয়ে তিন shard-এ ভাগ করার পর থেকে মাঝে মাঝে দ্বিতীয়টি ব্যর্থ হয়: assert 404 == 200. সমস্যা কোথায়, আর ঠিক করবেন কীভাবে?
    ORDER = {}
    
    def test_place_order(client, place_order):
        r = place_order("mitu", items=[(3, 1)])
        ORDER["id"] = r.json()["id"]
        assert r.status_code == 201
    
    def test_cancel_order(client, auth):
        oid = ORDER.get("id", 8)
        r = client.post(f"/api/orders/{oid}/transition",
                        json={"action": "cancel"}, headers=auth("mitu"))
        assert r.status_code == 200

    দ্বিতীয় test প্রথমটির রেখে যাওয়া অবস্থার ওপর নির্ভর করে: module-স্তরের ORDER আর প্রথম test-এ তৈরি অর্ডার। একই process-এ পরপর চললে মিলে যায়। Shard-এ ভাগ হলে দুটি আলাদা process-এ যেতে পারে; তখন ORDER খালি, default 8 ধরা হয়, কিন্তু প্রতিটি test নিজের নতুন database পায়, যেখানে অর্ডার ৮ নেই, তাই 404. এটি order-dependent test (পর্ব ৪০), আর স্থির id-এর ভুল (পর্ব ৩৭)।

    সমাধান: দ্বিতীয় test নিজের অর্ডার নিজে বানাবে, server যে id দেয় সেটিই ব্যবহার করবে: oid = place_order("mitu", items=[(3, 1)]).json()["id"], আর module-স্তরের অবস্থা মুছে ফেলা। যাচাই: pytest -p randomly বা দুই test-কে আলাদা shard-এ জোর করে চালানো। বড় suite-এ নিয়ম: প্রতিটি test যেকোনো shard-এ, যেকোনো ক্রমে, একা চলতে পারবে।

  4. Budget-এর সিদ্ধান্ত। একটি দলের লক্ষ্য অপরিবর্তিত কোডে ৯০% run সবুজ। শেষ ২০০টি run-এ তিনটি test একই commit-এ পাস আর ফেল দুটোই করেছে: X ১০ বার, Y ৪ বার, Z ২ বার। Budget কত, বর্তমান অবস্থা কী, আর ন্যূনতম কোনটি quarantine করলে লক্ষ্য পূরণ হয়?

    Budget: −ln(০.৯০) ≈ ০.১০৫৪, অর্থাৎ প্রতি run-এ গড়ে ১০.৫৪% flaky ব্যর্থতা। হার: X ৫%, Y ২%, Z ১%; মোট ৮%, budget-এর ভেতরে। সবুজের সম্ভাবনা ০.৯৫ × ০.৯৮ × ০.৯৯ ≈ ৯২.২%, লক্ষ্যের ওপরে। তাই এই মুহূর্তে কিছু quarantine জরুরি নয়।

    কিন্তু “জরুরি নয়” মানে “ঠিক আছে” নয়: প্রতি ১০০টি PR-এ প্রায় ৮টি অকারণে লাল, আর X একাই তার বেশিরভাগ। সঠিক কাজ হলো তিনটির ticket আর owner রাখা, X-কে সবার আগে সারানো, আর লক্ষ্যটিকে সময়ের সাথে কঠোর করার কথা ভাবা (যেমন ৯৫%). তখন budget ৫.১৩% হবে, আর X quarantine না করলে লক্ষ্য পূরণ হবে না।

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

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

ক্রমবড় suite-এ একটি pull request-এর test কীভাবে চলে, ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. বদলানো ফাইল আর function বের করা
  2. Impact map দিয়ে প্রভাবিত test বাছাই, সাথে always-run set
  3. ক্রম ঠিক করা: আগে-ব্যর্থ আর দ্রুত test আগে
  4. মাপা সময় দেখে test-গুলো কয়েকটি shard-এ ভাগ করা
  5. ফল মিলিয়ে flake budget আর merge-এর সিদ্ধান্ত
  6. রাতে পুরো suite চালিয়ে selection-এর ফাঁক খোঁজা

Test selection আর test prioritization-এর মূল পার্থক্য কোনটি?

  • Selection শুধু নতুন test চালায়, prioritization শুধু পুরোনো
  • Selection কিছু test বাদ দেয়; prioritization সব test রাখে, শুধু ক্রম বদলায়
  • Selection test parallel চালায়, prioritization serial
  • Selection রাতে চলে, prioritization শুধু PR-এ

একটি coverage-ভিত্তিক selection tool একটি HTML template-এর পরিবর্তনে ০টি test বাছল, অথচ পুরো suite চালালে একটি page test ব্যর্থ হয়। সবচেয়ে সম্ভাব্য কারণ কী?

  • Tool-টি ভুলভাবে install হয়েছে
  • Page test-টি flaky
  • Coverage map শুধু Python code দেখে, template ফাইলের পরিবর্তন তার কাছে অদৃশ্য
  • Test-গুলো ভুল ক্রমে চলেছে

১৫০০টি test-কে সমান সংখ্যায় (৫০০ করে) তিন shard-এ ভাগ করা হলো; shard-গুলো শেষ হলো 51.8, 18.4 আর 2.0 সেকেন্ডে। এখান থেকে কী বোঝা যায়?

  • Test-এর সংখ্যা নয়, মাপা সময় দেখে ভাগ করা দরকার
  • আরও বেশি shard দরকার
  • দ্বিতীয় আর তৃতীয় shard-এর test ব্যর্থ হয়েছে
  • Parallel কাজ করেনি, সব serial চলেছে

pytest-এ --ff (failed first) কী করে?

  • শুধু আগের run-এ ব্যর্থ test চালায়
  • প্রথম ব্যর্থতায় run থামিয়ে দেয়
  • সবচেয়ে দ্রুত test আগে চালায়
  • আগের run-এর ব্যর্থ test আগে চালায়, তারপর বাকি সব

লক্ষ্য: অপরিবর্তিত কোডে ৯৫% run সবুজ। চারটি flaky test-এর হার 4.0%, 1.2%, 0.6%, 0.2% (মোট 6.0%). Flake budget প্রায় 5.13%. প্রথম পদক্ষেপ কোনটি সবচেয়ে যুক্তিসঙ্গত?

  • সব test-এ ২ বার retry চালু করা
  • সবচেয়ে বড়টিকে (4%) owner আর সময়সীমাসহ quarantine করা
  • চারটি test-ই মুছে ফেলা
  • কিছু না করা, কারণ সব test আলাদাভাবে ৯৫%-এর বেশি পাস করে

দুটি test একই লাইনগুলো চালায় (একই coverage): coupon-এর subtotal 1001 আর 3010. এদের একটি কি নিরাপদে মুছে ফেলা যায়?

  • হ্যাঁ, একই coverage মানে একই test
  • হ্যাঁ, কারণ coverage শতাংশ কমবে না
  • না; দুটি আলাদা ভুল ধরতে পারে, mutation দিয়ে যাচাই না করে মুছবেন না
  • না, কারণ 3010-এর test বেশি ধীর

শব্দকোষ

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

মনে রাখুন

  1. বড় suite-এর চারটি হাতিয়ার: কম চালানো (selection), ভাগ করে চালানো (sharding), বুদ্ধিমান ক্রম (prioritization), আর সুস্থ রাখা (flake budget, owner, ছাঁটাই)।
  2. Selection একটি ঝুঁকিপূর্ণ ছাড়: code-এর বাইরের পরিবর্তন map দেখে না; তাই always-run set আর রাতে পুরো suite.
  3. Shard ভাগ করুন মাপা সময় দেখে, সংখ্যা দেখে নয়; সবচেয়ে ধীর shard-ই মোট সময়। Parallel সময় কমায়, কিন্তু মোট compute বাড়াতে পারে।
  4. Flake budget লিখে রাখুন; সীমা ছাড়ালে সবচেয়ে বড় অপরাধীকে owner আর সময়সীমাসহ quarantine; retry-তে পাসও গুনুন।
  5. একই coverage মানে redundant নয়; মুছে ফেলার আগে mutation আর requirement দিয়ে যাচাই।

পরের পর্বে: মডিউল ১২ শুরু: বিশেষ ধরনের system. প্রথমে mobile app — device আর emulator, Appium, আর দুর্বল network-এ app কেমন আচরণ করে।

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

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