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

ক্যাপস্টোন — বাজারঘরের জন্য পূর্ণ test strategy আর test suite

Capstone — A Complete Test Strategy and Test Suite for Bazarghar

Taught in Bangla, this lesson joins the course into one picture: quality goals, a risk register from real defect history, a layered test strategy and a release decision. A real 38-test pytest suite across five layers, including Playwright with axe, runs from one command against a copy of the demo shop: 32 pass and 6 known defects are strict xfails. Switching on two seeded bugs fails five tests and gives NO-GO. The runner's CONDITIONAL GO still needs a human sign-off. A rubric and sample answer follow.

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

  • একটি পণ্যের প্রসঙ্গ থেকে quality goal, আর আসল defect-ইতিহাস থেকে risk register বানানো
  • প্রতিটি ঝুঁকিকে test-এর স্তর, ধরন, tool আর CI gate-এর সাথে যুক্ত করে একটি লিখিত test strategy দাঁড় করানো
  • আগের পর্বের কৌশল দিয়ে ছোট কিন্তু স্তরভিত্তিক suite লেখা, আর চেনা defect-কে xfail(strict) regression test বানানো
  • Bug switch চালু করে যাচাই করা যে suite সত্যিই ধরে, তারপর exit criteria দিয়ে go/no-go সিদ্ধান্ত নেওয়া
  • নিজের ক্যাপস্টোন করা: কাজের তালিকা, rubric, নিজে যাচাইয়ের তালিকা আর একটি নমুনা উত্তর

১ · ক্যাপস্টোনের লক্ষ্য — প্রসঙ্গ আর quality goal

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

ক্যাপস্টোন নতুন কিছু শেখায় না; শেখা জিনিস জোড়া লাগায়। পর্ব ০১-এ (QA-র মানচিত্র) যে প্রশ্ন দিয়ে কোর্স শুরু হয়েছিল, “কে, কেন, কীভাবে”, এখানে তার পূর্ণ উত্তর একটি নথি আর একটি চলমান suite হিসেবে। প্রথম ধাপ প্রসঙ্গ: বাজারঘর একটি ছোট অনলাইন মুদি দোকান। গ্রাহক খোঁজেন, কার্টে রাখেন, checkout করেন, ক্যাশ, কার্ড বা mobile wallet-এ দেন (wallet সবসময় নকল gateway), পণ্য হাতে পেয়ে রিভিউ লেখেন। দলে কয়েকজন developer, একজন tester, একজন product owner.

প্রসঙ্গ থেকে আসে quality goal: কোন গুণ এই পণ্যের জন্য সবচেয়ে জরুরি। ISO/IEC 25010-এর গুণের তালিকা থেকে বাছাই করে প্রতিটির পাশে একটি মাপ লিখুন, যাতে পরে “পূরণ হলো কি না” বলা যায়:

গুণবাজারঘরের লক্ষ্যকীভাবে মাপবেন
Functional correctnessদাম, coupon, delivery charge প্রতিটি অর্ডারে ঠিকনিয়মের সব সীমায় test পাস
Reliabilityএক অর্ডারে একবারই টাকা কাটা; অর্ডার হারায় নাtimeout-এর পর retry-তে charge ১টি
Securityঅন্যের অর্ডার দেখা যায় না; XSS নেইheader আর escape-এর test, ZAP baseline
Performanceখোঁজার উত্তর দ্রুতsmoke-এ p95 < ৩০০ ms; বড় load আলাদা run-এ
Usability ও accessibilityবাংলায়, ফোনে আর কি-বোর্ডে ব্যবহারযোগ্যaxe-এ গুরুতর লঙ্ঘন ০; ৩২০ px-এ পাশে স্ক্রল নেই

সীমানাও লিখুন: বাইরের সেবা (আসল পেমেন্ট, SMS) এই strategy-র বাইরে; সব test শুধু নিজের কম্পিউটারের 127.0.0.1-এ। Requirement-এর ভাষা যাচাইযোগ্য না হলে লক্ষ্যও মাপা যায় না, পর্ব ১৫-এর (Requirement থেকে test) শিক্ষা।

২ · Risk register — আসল defect-ইতিহাস থেকে

সময় সীমিত, তাই সব জায়গায় সমান test সম্ভব নয়। পর্ব ১৭-এ (Test plan আর strategy) risk-ভিত্তিক strategy-র পরিচয় পেয়েছেন; পর্ব ৭৩ (Risk-based testing) পুরো পদ্ধতি শেখায়। এখানে সেটি প্রয়োগ। Risk register-এর প্রতিটি সারিতে একটি product risk, তার likelihood (১–৫), impact (১–৫), আর দুটির গুণফল।

Likelihood অনুমানে নয়, প্রমাণে বসান। এই কোর্সের বড় সুবিধা: আগের পর্বগুলো বাজারঘরে কোনো bug switch ছাড়াই ১৪টি সত্যিকারের defect বা দুর্বলতা পেয়েছে (নিচের ৫ নম্বর অংশে পুরো তালিকা)। এগুলো found defect, ইচ্ছা করে বসানো seeded defect নয়। কোন এলাকায় কয়টি পড়েছে, তা likelihood-এর বড় প্রমাণ।

IDএলাকাLIস্কোরআসল defectSuite-এ test
R2পেমেন্ট, wallet4520 উঁচু32
R4Checkout-এর ডেটা, ফোনে ফর্ম4416 উঁচু56
R1দাম: coupon, delivery2510 মাঝারি014
R7নিরাপত্তা2510 মাঝারি03
R6খোঁজা, বাংলা Unicode339 মাঝারি25
R8Accessibility, layout339 মাঝারি25
R3অর্ডারের অবস্থা আর তালিকা248 মাঝারি11
R5রিভিউ224 নিচু12

সীমা: স্কোর ১৫ বা বেশি উঁচু, ৮–১৪ মাঝারি, ৭ বা কম নিচু। ১৪টি আসল defect-এর ৮টি দুই উঁচু এলাকায় (R2-তে ৩, R4-এ ৫)। শেষ কলামটি suite লেখার পরে গোনা, আর এখানেই ক্যাপস্টোনের প্রথম সৎ আবিষ্কার। ধাপে ধাপে দেখুন:

quality goal → risk → test-এর গভীরতা
ধাপ
ডেটা
ফল
  1. প্রসঙ্গ। ব্যবসার কাছে কী জরুরি, তা লিখে শুরু: দাম ঠিক, এক অর্ডারে একবারই টাকা কাটা, আর বাংলায়, ফোনে ব্যবহারযোগ্য দোকান।
  2. তালিকা। পণ্যকে আটটি এলাকায় ভাগ করে প্রতিটির জন্য প্রশ্ন: “এখানে ভুল হলে গ্রাহক বা ব্যবসার কী ক্ষতি?” এলাকাগুলো এমনভাবে ভাগ করুন যাতে প্রতিটি test একটি এলাকায় পড়ে।
  3. Likelihood. আগের পর্বের আসল defect গুনে: R4-এ ৫টি, R2-তে ৩টি, R6 আর R8-এ ২টি করে। পাশাপাশি জটিলতা আর বাইরের নির্ভরতা দেখুন: wallet gateway, timeout আর retry R2-কে স্বভাবতই ঝুঁকিপূর্ণ করে।
  4. স্কোর। R2 = ৪ × ৫ = ২০, R4 = ৪ × ৪ = ১৬, R1 আর R7 = ১০, R6 আর R8 = ৯, R3 = ৮, R5 = ২ × ২ = ৪. দুটি উঁচু, পাঁচটি মাঝারি, একটি নিচু।
  5. গভীরতা। উঁচু ঝুঁকিতে কয়েক স্তরে test, চেনা defect-এর regression test আর পর্ব ২০-এর exploratory session; মাঝারিতে unit বা API আর একটি UI পথ; নিচুতে একটি-দুটি API test.
  6. মেলানো। Suite লেখার পরে গুনে দেখা গেল R1-এ ১৪টি test (৩৮টির ৩৭%), অথচ সবচেয়ে উঁচু R2-তে মাত্র ২টি। কারণ সহজ: দামের নিয়ম pure function, test লেখা সস্তা; পেমেন্টের test-এ server, wallet mode আর browser লাগে। Test-এর সংখ্যা সহজের পিছনে ছুটেছে, ঝুঁকির পিছনে নয়। ক্যাপস্টোনের প্রথম কাজের তালিকা: R2-র জন্য chaos experiment (পর্ব ৬৩) আর ledger মেলানোর একটি স্বয়ংক্রিয় check.

উঁচু দুই ঝুঁকিতে স্বয়ংক্রিয় test-এর পাশাপাশি সময় বাঁধা exploratory session-ও পরিকল্পনায় রাখুন, পর্ব ২০-এর (Session-based exploratory testing) charter-এর ভাষায়। দুটি উদাহরণ: “৬০ মিনিট পেমেন্ট ঘুরে দেখুন, wallet-এর চারটি mode আর browser-এর back, reload আর দুবার চাপ দিয়ে, যাতে বের হয় কোথায় টাকা আর অর্ডারের অবস্থা আলাদা হয়ে যায়।” আর “৬০ মিনিট ফোনের মাপে checkout ঘুরে দেখুন, ধীর network, বাংলা অঙ্ক আর অসম্পূর্ণ ঠিকানা দিয়ে, যাতে বের হয় কোথায় গ্রাহক বিভ্রান্ত হন।” KD-57b আর KD-69a ঠিক এমন session থেকেই আসার মতো defect.

৩ · Test strategy — স্তর, ধরন, tool আর gate

Test strategy বলে কোন ঝুঁকি কোন স্তরে, কোন কৌশলে, কোন tool দিয়ে ধরা হবে, আর কখন কোন test চলবে। ISO/IEC/IEEE 29119-3 (প্রথম সংস্করণ ২০১৩, পরে হালনাগাদ) এমন নথির কাঠামো দেয়; ছোট দলে এক-দুই পাতাই যথেষ্ট। নিচের ছবিতে বাজারঘরের suite-এর আকার আর তিনটি gate:

বাজারঘরের ক্যাপস্টোন suite আর CI gate

38 tests in five layers · known defects as xfail(strict) · three gates

Capstone suite: 16 unit, 7 API, 5 non-functional, 4 UI tests, 6 known-defect tests, and three CI gates UI + axe · 4 sec·perf·l10n · 5 API + contract · 7 unit + property · 16 চেনা defect · ৬টি xfail(strict) প্রতিটি PR রাতের run release KD-37 · 42 · 54 · 56a · 60 · 69b unit + API UI · axe · perf summary · সই ধীর দ্রুত সবুজ: প্রতিটি পরিবর্তনে, সেকেন্ডে লাল: defect ঠিক হলে suite লাল হয়
ছবি ৭৭.১ — ৩৮টি test-এর ৪২% unit স্তরে, কারণ সেখানে test দ্রুত আর স্থির। চেনা defect-এর ৬টি test আলাদা বাক্সে: আজ তারা “প্রত্যাশিত ব্যর্থতা”। Gate তিনটি: প্রতিটি PR-এ দ্রুত অংশ, রাতে ধীর অংশ, release-এর আগে পুরো run আর মানুষের সই।

প্রতিটি স্তরের পিছনে একটি কারণ আর একটি আগের পর্ব। Tool বাছার নিয়ম: খোলা লাইসেন্স, দলের ভাষা (Python), আর আগে এই app-এ প্রমাণিত:

স্তর / ধরনTool (লাইসেন্স)কেনপর্ব
Unit + propertypytest 9.2.0 (MIT), Hypothesis 6.170.15 (MPL-2.0)দামের নিয়মের সব সীমা, মিলিসেকেন্ডে২১, ৫৮
APIhttpx 0.28.1 (BSD-3-Clause)ব্যবসার পথ HTTP-তে: retry, 409, 422৩১
Contractjsonschema 4.26.0 (MIT)UI যে আকারের JSON-এর ওপর নির্ভর করে৩২
UI smokePlaywright 1.65.2 (Apache-2.0), ইনস্টল করা Edgeএকটি সোনালি পথ, auto-wait সহ৩৬
Accessibilityaxe-core 4.14.1 (MPL-2.0)WCAG-এর স্বয়ংক্রিয় অংশ; বাকিটা হিসাব করে৫৪
নিরাপত্তাhttpxsecurity header, search-এর escape৫২, ৫৩
Performance smokehttpx, ৩টি threadবড় ধীরগতি দ্রুত ধরা; আসল load আলাদা৪৬–৪৮
Localizationhttpxবাংলা খোঁজা, Unicode৫৬
Reliabilityএই suite-এ নয়chaos আর recovery আলাদা সূচিতে৫৭, ৬৩

Strategy-র বাকি অংশ, এক লাইনে করে, প্রতিটির বিস্তারিত আগের পর্বে:

  • পরিবেশ আর ডেটা: প্রতিটি run-এর নিজস্ব SQLite ফাইল, প্রতিটি test-এর আগে seed ফেরত (POST /api/test/reset), নকল wallet, সব ডেটা বানানো (পর্ব ৬৫)।
  • CI gate: PR-এ unit, API, contract; রাতে UI, axe, perf smoke, নিরাপত্তা; সপ্তাহে Locust বা k6-এর load, ZAP baseline আর chaos (পর্ব ৬৪)।
  • Entry criteria: build ওঠে, /api/health 200 দেয়, reset কাজ করে।
  • Exit criteria: E1 কোনো অপ্রত্যাশিত ব্যর্থতা নেই; E2 প্রতিটি খোলা চেনা defect-এর id আর severity আছে; E3 search smoke-এ p95 < ৩০০ ms; E4 axe-এ critical বা serious লঙ্ঘন ০; E5 প্রতিটি খোলা উঁচু severity-র defect-এ দায়িত্বপ্রাপ্ত মানুষের সই।
  • সময় আর অগ্রগতি: কাজের অনুমান আর দৈনিক অগ্রগতির হিসাব পর্ব ৭৪-এর (Test management আর estimation) পদ্ধতিতে।
  • Defect ব্যবস্থাপনা আর রিপোর্ট: প্রতিটি defect-এর id, severity আর regression test (পর্ব ১৮); JUnit XML থেকে স্তরভিত্তিক summary (পর্ব ৬৭)।

যা ইচ্ছা করে বাদ, তা-ও strategy-তে লিখুন, কারণসহ। Visual regression (পর্ব ৪১) বাদ, কারণ বাজারঘরের পাতা ঘন ঘন বদলায় আর baseline রাখার খরচ এখন লাভের চেয়ে বেশি। Selenium (পর্ব ৩৮) বাদ, কারণ একই কাজ Playwright-এ চলছে, দুটি framework-এর রক্ষণাবেক্ষণ অপচয়। Gherkin-এর BDD স্তর (পর্ব ৪৩) বাদ, কারণ product owner এখন feature file পড়েন না; acceptance criteria থাকছে requirement-এর নথিতে (পর্ব ৪৪)। প্রসঙ্গ বদলালে এই সিদ্ধান্তও বদলাবে, আর লেখা থাকলে কেউ জানবেন কেন আগে বাদ ছিল।

৪ · Suite জোড়া লাগানো — চেনা কৌশল, নতুন করে লেখা

নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো, বাজারঘর app-এর একটি কপির বিরুদ্ধে (শুধু 127.0.0.1, কোনো বাইরের যোগাযোগ নেই)। Python 3.12, uv দিয়ে বানানো environment; tool-এর version আর লাইসেন্স ওপরের টেবিলে। Playwright-এর ভেতরের কোডে কোনো usage-তথ্য পাঠানোর ব্যবস্থা খুঁজে পাওয়া যায়নি (শুধু Firefox-এর telemetry বন্ধ রাখার setting), তবু সব run-এ DO_NOT_TRACK=1 রাখা ছিল, আর npm-এ update-notifier=false. Path নিরপেক্ষ করা।

Suite-এর মেরুদণ্ড একটি conftest. দুটি বিষয় লক্ষ করুন: suite নিজেও জানে কোন build পরীক্ষা হচ্ছে (BAZARGHAR_BUGS), আর browser-এ login হয় API-র token-কে cookie বানিয়ে, প্রতিবার ফর্ম পূরণ করে নয় (পর্ব ৩৭-এর storage state-এর মতো ধারণা):

BASE = os.environ.get("BAZARGHAR_URL", "http://127.0.0.1:8895")
BUGS = parse_bugs(os.environ.get("BAZARGHAR_BUGS"))      # the build under test

@pytest.fixture
def fresh(api):
    """Seed data back, sessions dropped, wallet mode success."""
    assert api.post("/api/test/reset").status_code == 200

@pytest.fixture(scope="session")
def browser():
    with sync_playwright() as p:
        b = p.chromium.launch(channel="msedge", headless=True)
        yield b
        b.close()

@pytest.fixture
def page_as(browser, login):
    """A page logged in as `user` via the bg_session cookie; closed after."""
    made = []
    def _page(user, width=1280, csp=False):
        ctx = browser.new_context(base_url=BASE, bypass_csp=csp,
                                  viewport={"width": width, "height": 800})
        if user:
            ctx.add_cookies([{"name": "bg_session", "value": login(user),
                              "url": BASE}])
        made.append(ctx)
        return ctx.new_page()
    yield _page
    for ctx in made:
        ctx.close()

প্রতিটি test একটি ঝুঁকির সাথে বাঁধা, একটি নিজস্ব marker দিয়ে: @pytest.mark.risk("R2-payment"). এতে ওপরের register-এর শেষ কলামটি একটি ছোট script দিয়ে গোনা গেছে, হাতে নয়। স্তর অনুযায়ী কয়েকটি উদাহরণ, প্রতিটি আগের কোনো পর্বের কৌশল:

  • Unit: coupon-এর সীমা আর সীমার কাছের ছয়টি মান (১০০০, ১০০১, ২৯৯৯, ৩০০০, ৩০০৯, ৫০০০; পর্ব ০৮), delivery-র decision table-এর পাঁচটি সারি (পর্ব ০৯), ফোনের চারটি partition (পর্ব ০৭), আর একটি Hypothesis property: ছাড় কখনো ৩০০ বা মোটের দশ ভাগের বেশি নয়, ১০০০ পর্যন্ত শূন্য। @example(1000) নিশ্চিত করে সীমাটি প্রতিবার পরীক্ষা হয়।
  • API: timeout-এর পর একই Idempotency-Key দিয়ে retry করলে ledger-এ charge ঠিক একটি; shipped অর্ডার cancel করলে 409; "stars": "5" পাঠালে 422; গড় "4.3" (half up).
  • Contract: /api/products-এর প্রতিটি পণ্যে id, price, stock integer আর in_stock boolean, একটি JSON Schema দিয়ে।
  • UI: তেল কার্টে, badge “1” হওয়া পর্যন্ত Playwright-এর auto-wait (পর্ব ৩৬; badge ৪০০ ms পরে বদলায়), তারপর checkout-এ Rajshahi বাছলে delivery ১২০ আর মোট ১০০০.

দুটি ছোট সিদ্ধান্ত suite-কে বিশ্বাসযোগ্য রাখে। Hypothesis চলে derandomize=True আর database=None দিয়ে: প্রতিটি run-এ একই উদাহরণ, তাই CI-তে আজ পাস কাল ফেল হয় না (এলোমেলো খোঁজার জন্য আলাদা রাতের run রাখা যায়)। আর state বদলানো প্রতিটি test নিজের আগে seed ফেরত আনে, তাই test-এর ক্রম বদলালেও ফল একই (পর্ব ৪০-এর order-dependent test-এর শিক্ষা)। লেখার সময় পরিষ্কার build পাঁচবার চালানো হয়েছে; পাঁচবারই একই ফল, ৩২টি পাস আর ৬টি xfail.

৫ · চেনা defect-কে test বানানো — xfail(strict)

আগের পর্বগুলোয় পাওয়া ১৪টি defect এখন কী করবেন? তিনটি ভুল পথ চেনা: test না লেখা (ঠিক হলো কি না কেউ জানবে না), skip করা (test চলেই না), বা বর্তমান ভুল আচরণকেই assert করা (suite ভুলকে পাহারা দেয়)। সঠিক পথ: requirement অনুযায়ী test লিখুন, আর তাকে xfail চিহ্ন দিন, strict=True সহ, কারণে defect-এর id. তখন test চলে, ব্যর্থ হয়, রিপোর্টে “প্রত্যাশিত ব্যর্থতা” দেখায়; আর যেদিন কেউ defect ঠিক করেন, test পাস করে, ফলে XPASS, আর strict থাকায় suite লাল হয়ে মনে করিয়ে দেয়, “marker সরান”। চারটি আচরণ পাশাপাশি এই পাতাতেই চালিয়ে দেখুন:

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

def product_status(pid, fixed):        # stand-in for GET /api/products/{id}
    if pid >= 2**63:
        return 404 if fixed else 500   # KD-60: SQLite overflow -> 500
    return 200

KD60 = pytest.mark.xfail(strict=True, reason="KD-60: id 2**63 gives 500")

@KD60
def test_kd60_open():
    assert product_status(2**63, fixed=False) in (404, 422)

@KD60
def test_kd60_fixed():
    assert product_status(2**63, fixed=True) in (404, 422)

@pytest.mark.xfail(reason="KD-60, not strict")
def test_kd60_fixed_lenient():
    assert product_status(2**63, fixed=True) in (404, 422)

@pytest.mark.skip(reason="KD-60")
def test_kd60_skipped():
    assert product_status(2**63, fixed=False) in (404, 422)

def test_normal_id():
    assert product_status(1, fixed=False) == 200
''')
pytest.main(["-q", "-rxXs", "--no-header", "-p", "no:cacheprovider", "test_kd.py"])

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

xFXs.                                                                    [100%]
=================================== FAILURES ===================================
_______________________________ test_kd60_fixed ________________________________
[XPASS(strict)] KD-60: id 2**63 gives 500
=================================== XPASSES ====================================
=========================== short test summary info ============================
XFAIL test_kd.py::test_kd60_open - KD-60: id 2**63 gives 500
XPASS test_kd.py::test_kd60_fixed_lenient - KD-60, not strict
SKIPPED [1] test_kd.py:23: KD-60
1 failed, 1 passed, 1 skipped, 1 xfailed, 1 xpassed in 0.02s

পাঁচটি অক্ষর, পাঁচটি গল্প: x মানে defect এখনো আছে, যেমনটা প্রত্যাশিত। F হলো strict test-টি, যার কোড “ঠিক করা” হয়েছে: [XPASS(strict)], suite লাল। X একই অবস্থা কিন্তু strict নয়: শুধু তালিকায় একটি লাইন, run সবুজ, আর marker বছরের পর বছর থেকে যেতে পারে। s হলো skip: কিছুই চলেনি, তাই কিছুই জানা যায়নি। শেষ . সাধারণ পাস।

pytest-এ পুরো project-এর জন্য xfail_strict = true ini option-ও আছে; ক্যাপস্টোনে প্রতিটি marker-এ আলাদা করে লেখা হয়েছে, যাতে পড়েই বোঝা যায়।

বাজারঘরের ১৪টি found defect আর suite-এ তাদের অবস্থান। Id-র সংখ্যা সেই পর্বের নম্বর, যেখানে defect-টি ধরা পড়েছিল:

IdDefectRSeveritySuite-এ
KD-37পাতা থেকে timeout-এর পর আবার pay: দুবার chargeR2উঁচুxfail
KD-63aWallet call write lock-এর ভেতরে: ধীর wallet-এ ক্যাশ অর্ডারও ব্যর্থR2উঁচুনা
KD-63bTimeout-এ টাকা কাটা, অর্ডার unpaid; মেলানোর কাজ নেইR2উঁচুনা
KD-42৩২০ px-এ কার্ট পাশে স্ক্রল করেR8মাঝারিxfail
KD-49/api/orders N+1, index নেইR3মাঝারিনা
KD-54হেডারে focus ring-এর contrast ১.০৭:১R8মাঝারিxfail
KD-56aখোঁজায় Unicode normalise হয় নাR6মাঝারিxfail
KD-57aOffline-এ পুরোনো delivery charge থেকে যায়R4মাঝারিনা
KD-57bদুবার চাপলে “কার্ট খালি” পাতায় পৌঁছায়R4মাঝারিনা
KD-69aReload-এ checkout-এর লেখা ঠিকানা হারায়R4মাঝারিনা
KD-69bপেমেন্টের radio ১৩ px উঁচুR4মাঝারিxfail
KD-56bবাংলা পাতায় রিভিউর ভুলের বার্তা ইংরেজিতেR5নিচুনা
KD-60product_id 2**63 দিলে 500R6নিচুxfail
KD-69cফোনের ভুলের বার্তায় ইংরেজি অঙ্কR4নিচুনা

৬টি xfail হিসেবে আছে, ৮টি নেই। যেগুলো নেই, তাদের বেশিরভাগের জন্য বিশেষ ব্যবস্থা লাগে: volume ডেটা (KD-49), network বন্ধ করা (KD-57a), বা chaos (KD-63a). সেগুলো লুকানো যাবে না; release summary-তে আলাদা লাইনে আসবে। একই ১৪টি defect পর্ব ৭৫-এ D1–D14 নামে আছে (D1 = KD-37, D10 = KD-63a, D11 = KD-63b); সেখানে severity-র মাপ critical, major আর minor, RCA-র বিচারে, আর এখানে release-এর সিদ্ধান্তের জন্য উঁচু, মাঝারি আর নিচু। তাই কয়েকটির মাত্রা হুবহু মেলে না: KD-42, KD-69a আর KD-69b এখানে মাঝারি, সেখানে minor ধরা হয়েছে। এই defect-গুলো কেন জন্মাল আর কোন ধাপে ধরা যেত, সেই root cause বিশ্লেষণ পর্ব ৭৫-এর (Quality metric আর process improvement) বিষয়; ক্যাপস্টোন তাদের নিয়ে release-এর সিদ্ধান্ত নেয়। KD-37-এর test-এর মূল অংশ:

def kd(defect, why):
    return pytest.mark.xfail(strict=True, reason=f"{defect}: {why}")

@pytest.mark.risk("R2-payment")
@kd("KD-37", "UI pay retry after timeout charges twice")
def test_ui_retry_after_timeout_charges_once(api, page_as, login):
    order = place_order(api, login("rafi"))
    page = page_as("rafi")
    api.put("/api/test/wallet", json={"mode": "timeout_once"})
    page.goto(f"/orders/{order['id']}")
    page.get_by_test_id("pay-button").click()
    expect(page.get_by_test_id("flash")).to_be_visible()
    page.get_by_test_id("pay-button").click()                 # customer retries
    expect(page.get_by_test_id("order-status")).to_have_attribute("data-status", "paid")
    ledger = api.get("/api/test/wallet").json()["charges"]
    assert len([c for c in ledger if c["order_id"] == order["id"]]) == 1

একটি সতর্কতা: xfail test ভুল কারণেও ব্যর্থ হতে পারে, যেমন locator-এর বানান ভুল। তাই প্রথমবার --runxfail দিয়ে চালিয়ে আসল ব্যর্থতার বার্তা পড়া হয়েছে। ছয়টিই সঠিক কারণে ব্যর্থ: assert 500 in (404, 422), খোঁজায় 0 == 1, কার্টে 37 <= 0 (এই কার্টে ৩৭ px পাশে স্ক্রল; পর্ব ৪২-এর কার্টে ৪৬ px ছিল, ভিন্ন পণ্যের লাইনে), contrast 1.069… >= 3, radio 13 >= 24, আর ledger-এ 2 == 1, অর্থাৎ দুটি charge.

৬ · এক command-এ পুরো run — runner আর release summary

পুরো suite একটি script চালায়, run_capstone.py: নিজের server চালু করে, /api/health-এর জন্য সর্বোচ্চ ৫০ বার অপেক্ষা করে, pytest চালিয়ে JUnit XML লেখে, তারপর নিজের চালু করা server-টিকেই বন্ধ করে, এবং XML পড়ে summary আর সিদ্ধান্ত লেখে। সিদ্ধান্তের অংশটি:

for tc in ET.parse(xml).getroot().iter("testcase"):
    layer = LAYER[tc.get("classname").split(".")[-1]]
    f, s = tc.find("failure"), tc.find("skipped")
    kind = "fail" if f is not None or tc.find("error") is not None else (
        "xfail" if s is not None and s.get("type") == "pytest.xfail" else "pass")
    rows.setdefault(layer, {"pass": 0, "fail": 0, "xfail": 0})[kind] += 1
    if kind == "fail":
        fails.append(f"{layer}: {tc.get('name')}")
    if kind == "xfail":
        open_kd.append(s.get("message").split(":")[0].strip())
# … print the table, then:
if fails:
    decision = "NO-GO: exit criterion E1 (no unexpected failure) not met"
elif any(SEV[k] == "high" for k in open_kd):
    decision = "CONDITIONAL GO: needs a named owner's sign-off for " + ", ".join(
        k for k in open_kd if SEV[k] == "high")
else:
    decision = "GO"

লক্ষ করুন s.get("type") == "pytest.xfail": pytest-এর JUnit XML-এ xfail আলাদা কোনো ট্যাগ পায় না, <skipped type="pytest.xfail"> হিসেবে লেখা হয়, আর মাথায় লেখা থাকে skipped="6". সাধারণ dashboard তাই ছয়টি “skip” দেখাবে, ছয়টি চেনা defect নয়। সত্যিকারের run, bug ছাড়া:

cd ~/bazarghar-qa
uv run python run_capstone.py
.......xxxxxx.........................                                   [100%]
XFAIL …test_known_defects.py::test_huge_product_id_is_not_500 - KD-60: product_id 2**63 gives 500
… (আরও ৫টি XFAIL)
32 passed, 6 xfailed in 7.65s

=== RELEASE SUMMARY  build=clean  exit=0  wall=8.1s
unit            pass 16  fail 0  xfail 0
api+contract    pass  7  fail 0  xfail 0
sec+perf+l10n   pass  5  fail 0  xfail 0
ui+a11y         pass  4  fail 0  xfail 0
known-defects   pass  0  fail 0  xfail 6
search smoke: n=60 p50=2.4ms p95=12.5ms
unexpected failures: 0
open known defects (xfail strict): KD-60(low), KD-56a(medium), KD-42(medium), KD-54(medium), KD-69b(medium), KD-37(high)
not automated, residual risk: 8
DECISION: CONDITIONAL GO: needs a named owner's sign-off for KD-37
run_capstone.py · build=clean · port 8895
ধাপ
দেখা
মানে
  1. Server. Runner নিজে app চালায়, test mode চালু, নিজস্ব SQLite ফাইল, port ৮৮৯৫. বন্ধ করে শুধু নিজের চালু করা process-টি; অন্য কারও process ছোঁয় না।
  2. সংগ্রহ। pytest পাঁচটি ফাইল থেকে ৩৮টি test পায়: unit ১৬, API ও contract ৭, নিরাপত্তা-perf-বাংলা ৫, UI ও axe ৪, চেনা defect ৬. ফাইল চলে বর্ণানুক্রমে।
  3. API. প্রথম সাতটি বিন্দু test_api.py: quote-এর দুটি সীমা, timeout-এর পর একটিই charge, 409, 422, গড় 4.3, contract.
  4. চেনা defect. ছয়টি x: প্রতিটি ব্যর্থ, যেমনটা প্রত্যাশিত। --runxfail-এর আগের run দেখিয়েছে, ব্যর্থতাগুলো সঠিক কারণে।
  5. নিরাপত্তা, perf. পাঁচটি পাস: দুটি পথে security header, search-এর escape, বাংলা খোঁজা, আর ৩ জন × ২০টি অনুরোধে p95 ১২.৫ ms, সীমা ৩০০ ms.
  6. UI, unit. Edge-এ চারটি পাস (একটি smoke, তিন পাতায় axe), তারপর ১৬টি unit, Hypothesis-এর ৩০০টি উদাহরণসহ। পুরো pytest ৭.৬৫ সেকেন্ড।
  7. সিদ্ধান্ত। XML-এ tests="38", skipped="6". Runner xfail-কে আলাদা করে, অপ্রত্যাশিত ব্যর্থতা ০ পায়, আর খোলা defect-এর মধ্যে একটি উঁচু: KD-37. তাই CONDITIONAL GO. পরের অংশে দেখবেন, এই সিদ্ধান্তও পুরো সত্য নয়।

রিপোর্টে কম্পিউটারের নাম: pytest-এর JUnit XML-এর hostname attribute-এ আসল কম্পিউটারের নাম থাকে। এই পাতার উদ্ধৃতি থেকে তা সরানো হয়েছে; ক্যাপস্টোন জমা দেওয়ার আগে আপনিও সরান।

৭ · Suite কি সত্যিই ধরে? — bug switch আর একটি “ঠিক করা” defect

সবুজ suite দুটি জিনিস বোঝাতে পারে: app ঠিক, অথবা suite অন্ধ। পার্থক্য করতে ইচ্ছা করে ভুল ঢোকান, পর্ব ৫৯-এর (Mutation testing) ধারণায়। বাজারঘরের দুটি seeded bug একসাথে চালু: coupon_ge (coupon-এ >-এর জায়গায় >=) আর reflected_search (search-এর শব্দ escape ছাড়া, আর /-এ CSP নেই)।

uv run python run_capstone.py coupon_ge,reflected_search
E       assert (100, 960) == (0, 1060)
…
E       KeyError: 'content-security-policy'
…
E       assert '<script>alert(1)</script>' not in '<!doctype h...dy>\n</html>'
…
E       AssertionError: assert 100 == 0
…
E           Failing explicit example: test_coupon_properties(
E               subtotal=1000,
E           )
…
5 failed, 27 passed, 6 xfailed in 7.34s
=== RELEASE SUMMARY  build=coupon_ge+reflected_search  exit=1  wall=7.8s
unit            pass 14  fail 2  xfail 0
api+contract    pass  6  fail 1  xfail 0
sec+perf+l10n   pass  3  fail 2  xfail 0
ui+a11y         pass  4  fail 0  xfail 0
known-defects   pass  0  fail 0  xfail 6
…
DECISION: NO-GO: exit criterion E1 (no unexpected failure) not met

একটি coupon-ভুল তিন স্তরে ধরা পড়ল: unit-এর সীমা, Hypothesis-এর property (@example(1000)-এর কারণে), আর API-র quote. XSS ধরা পড়ল দুটি test-এ। কিন্তু একটি ব্যর্থতার বার্তা দুর্বল: KeyError. Header না থাকলে test assert-এর আগেই ভেঙেছে; পাঠক বুঝবেন না এটি test-এর নিজের bug নাকি app-এর। এটি অনুশীলন ২-এর বিষয়।

তৃতীয় run: slow_search (প্রতিটি খোঁজা ১৫০০ ms ঘুমায়)। শুধু perf smoke ফেল: assert 1507.7262999984669 < 300, p50 ১৫০৫.৩ ms, আর পুরো run ৪৮ সেকেন্ড, কারণ UI-এর পাতাগুলোও খোঁজার পথ দিয়ে যায়। চতুর্থ run উল্টো দিক থেকে: app-এর কপিতে KD-60 ঠিক করা হলো (Path(ge=1, le=2**63 - 1), পর্ব ৬০-এর সমাধান):

[XPASS(strict)] KD-60: product_id 2**63 gives 500
FAILED capstone_tests/test_known_defects.py::test_huge_product_id_is_not_500
1 failed, 32 passed, 5 xfailed in 7.45s
…
known-defects   pass  0  fail 1  xfail 5
…
DECISION: NO-GO: exit criterion E1 (no unexpected failure) not met

strict marker ঠিক কাজটি করল: defect ঠিক হতেই suite লাল। কিন্তু runner একে “অপ্রত্যাশিত ব্যর্থতা” ধরে NO-GO বলল, অথচ খবরটি ভালো। নিয়মে একটি ফাঁক: XPASS(strict) মানে “marker সরান”, release আটকানোর কারণ নয়। পরের অংশের calculator এই পার্থক্য করে।

৮ · Go/no-go — exit criteria, residual risk আর সই

Go/no-go সিদ্ধান্তের দুটি অংশ। প্রথমটি যান্ত্রিক: exit criteria পূরণ হলো কি না। দ্বিতীয়টি মানবিক: যা বাকি থাকল, সেই residual risk কে মেনে নিচ্ছেন। Runner দুটি জিনিস ভুল করেছিল: automate না হওয়া ৮টি defect সিদ্ধান্তে ধরেনি (তার মধ্যে KD-63a আর KD-63b উঁচু), আর XPASS-কে ব্যর্থতা ভেবেছিল। নিচের calculator চারটি আসল run-এর ফলের ওপর দুটিই ঠিক করে। SIGNED_OFF বদলে দেখুন:

SEV = {"high": 3, "medium": 2, "low": 1}
# 14 real defects from earlier lessons: id -> (severity, automated?)
KD = {"KD-37": ("high", 1), "KD-63a": ("high", 0), "KD-63b": ("high", 0),
      "KD-42": ("medium", 1), "KD-49": ("medium", 0), "KD-54": ("medium", 1),
      "KD-56a": ("medium", 1), "KD-57a": ("medium", 0), "KD-57b": ("medium", 0),
      "KD-69a": ("medium", 0), "KD-69b": ("medium", 1),
      "KD-56b": ("low", 0), "KD-60": ("low", 1), "KD-69c": ("low", 0)}
# real results of four desktop runs (functional failures, search p95 ms, axe)
RUNS = {"clean":       dict(fail=0, p95=12.5, axe=0, fixed=[]),
        "coupon+xss":  dict(fail=5, p95=13.7, axe=0, fixed=[]),
        "slow_search": dict(fail=0, p95=1507.7, axe=0, fixed=[]),
        "kd60_fixed":  dict(fail=0, p95=14.0, axe=0, fixed=["KD-60"])}
SIGNED_OFF = {"KD-37", "KD-63a", "KD-63b"}      # try: set()

def decide(r):
    why = []
    if r["fail"]: why.append(f"E1 {r['fail']} unexpected failure(s)")
    if r["p95"] >= 300: why.append(f"E3 search p95 {r['p95']} ms >= 300")
    if r["axe"]: why.append(f"E4 {r['axe']} serious axe violation(s)")
    if why: return "NO-GO", why
    still = {k: v for k, v in KD.items() if k not in r["fixed"]}
    high = [k for k, (s, _) in still.items() if s == "high"]
    unsigned = [k for k in high if k not in SIGNED_OFF]
    hidden = sum(1 for s, auto in still.values() if not auto)
    note = [f"residual points {sum(SEV[s] for s, _ in still.values())}",
            f"{hidden} of {len(still)} open not automated"]
    if r["fixed"]: note.append("remove xfail: " + ", ".join(r["fixed"]))
    if unsigned: return "NO-GO", note + ["E5 no sign-off: " + ", ".join(unsigned)]
    return ("CONDITIONAL GO" if high else "GO"), note + ["signed: " + ", ".join(high)]

for name, r in RUNS.items():
    verdict, why = decide(r)
    print(f"{name:12} {verdict:14} | " + "; ".join(why))

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

clean        CONDITIONAL GO | residual points 28; 8 of 14 open not automated; signed: KD-37, KD-63a, KD-63b
coupon+xss   NO-GO          | E1 5 unexpected failure(s)
slow_search  NO-GO          | E3 search p95 1507.7 ms >= 300
kd60_fixed   CONDITIONAL GO | residual points 27; 8 of 13 open not automated; remove xfail: KD-60; signed: KD-37, KD-63a, KD-63b

দুটি NO-GO, দুটি কারণ। bug-এর build আটকায় E1-এ, ধীর build E3-এ; calculator শুধু “NO-GO” নয়, কোন criterion ভাঙল তা-ও বলে। এখানে perf test-এর ব্যর্থতাকে E1 থেকে আলাদা রাখা হয়েছে, যাতে কারণটি পরিষ্কার থাকে।

সবুজ build-এও residual risk. ১৪টি খোলা defect-এর ভার (উঁচু ৩, মাঝারি ২, নিচু ১ ধরে) ২৮, আর তার ৮টি কোনো test পাহারা দেয় না। KD-60 ঠিক হওয়ার পর ভার ২৭, আর পরামর্শ “marker সরান”: এবার NO-GO নয়। SIGNED_OFF = set() করে আবার চালান: সবুজ build-ও NO-GO হয়ে যাবে, কারণ তিনটি উঁচু ঝুঁকি কেউ মেনে নেননি।

exit criteria E1–E5 · build=clean
Criterion
মান
অবস্থা
  1. E1. অপ্রত্যাশিত ব্যর্থতা ০. একটি থাকলেও আলোচনা শেষ: NO-GO, যেমন bug-এর build-এ ৫টি ছিল।
  2. E3, E4. Search smoke-এ p95 ১২.৫ ms, সীমা ৩০০; axe-এ critical বা serious লঙ্ঘন ০. মনে রাখুন, smoke মানে বড় ধীরগতি ধরা; ৫০ জনের load-এর প্রমাণ এটি নয়।
  3. E2. ছয়টি চেনা defect test-এ পাহারায়, প্রতিটির id আর severity আছে। একটি উঁচু: KD-37, পাতা থেকে retry-তে দুবার charge.
  4. বাকি আটটি। Automate হয়নি ৮টি, তার দুটি উঁচু: KD-63a (ধীর wallet-এ সব checkout ব্যর্থ হতে পারে) আর KD-63b (টাকা কাটা, অর্ডার unpaid). Runner এগুলো দেখেনি; summary-তে আলাদা লাইনে লিখতেই হবে।
  5. E5. তিনটি উঁচু ঝুঁকির প্রতিটিতে পেমেন্টের দায়িত্বপ্রাপ্ত মানুষ, অর্থাৎ risk owner, সই করবেন, প্রতিকারসহ: প্রতিদিন হাতে wallet ledger আর অর্ডার মেলানো, দুবার charge হলে ফেরতের নিয়ম, আর wallet ধীর হলে সতর্কবার্তা।
  6. সিদ্ধান্ত। CONDITIONAL GO, তিনটি সই আর তিনটি প্রতিকারসহ, লিখিত। সই না পেলে NO-GO. Tester-এর কাজ তথ্যটি স্পষ্ট করা; risk acceptance-এর সিদ্ধান্ত ব্যবসার।

এই সিদ্ধান্ত এক পাতার test completion report-এ যায় (গঠন পর্ব ১৯-এ, Test execution আর summary report): কী test হলো, কী হলো না, খোলা defect, residual risk, আর কে কোন ঝুঁকি মেনে নিলেন।

আরও গভীরে: Release-এর সিদ্ধান্তকে কেউ কেউ শুধু সংখ্যার নিয়ম বানাতে চান, যেমন “pass rate ৯৮%-এর বেশি হলে যাবে”। কিন্তু এক সংখ্যায় ভিন্ন ঝুঁকি মেশে, আর পর্ব ৬৭-এর Goodhart's law-এর ফাঁদ খুলে যায়। পরিণত দলে যান্ত্রিক gate “না” বলতে পারে, কিন্তু “হ্যাঁ” বলেন মানুষ, লিখিত ঝুঁকিসহ। Production-এর পরেও canary আর feature flag (পর্ব ৬৬) ঝুঁকি কমায়: সিদ্ধান্ত তখন “সবার জন্য যাবে কি না” থেকে “কতজনের জন্য আগে যাবে” হয়ে যায়।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন চেনা:

  • Test strategy আর test plan-এর পার্থক্য? — Strategy বলে কীভাবে (স্তর, কৌশল, tool, gate); plan বলে এই release-এ কী, কে, কবে।
  • Exit criteria-র উদাহরণ দিন। — অপ্রত্যাশিত ব্যর্থতা ০, উঁচু severity-র খোলা defect-এ সই, p95 সীমার নিচে, accessibility-র গুরুতর লঙ্ঘন ০.
  • চেনা bug-এর test কী করবেন? — Requirement অনুযায়ী লিখে defect id-সহ xfail(strict=True); skip বা মুছে ফেলা নয়।
  • Release-এর সিদ্ধান্ত কে নেন? — ব্যবসার দায়িত্বপ্রাপ্ত মানুষ; QA দেয় ঝুঁকির স্পষ্ট তথ্য আর সুপারিশ।
  • Suite সবুজ, তবু ভরসা নেই কেন? — ইচ্ছা করে ভুল ঢুকিয়ে দেখুন suite ধরে কি না; যা automate হয়নি তা-ও গুনুন।

৯ · আপনার ক্যাপস্টোন — কাজ, rubric আর নমুনা উত্তর

এবার আপনার পালা। App-এর README অনুযায়ী বাজারঘর নিজের কম্পিউটারে চালান (শুধু localhost), নিজের একটি কপিতে। কাজ সাতটি:

  1. প্রসঙ্গ আর quality goal এক পাতায়: অন্তত চারটি গুণ, প্রতিটির মাপ।
  2. Risk register: অন্তত ছয়টি এলাকা, L আর I-এর পাশে প্রমাণ (আসল defect, জটিলতা, নির্ভরতা)।
  3. Strategy: প্রতিটি ঝুঁকির জন্য স্তর, কৌশল আর tool, লাইসেন্সসহ; entry ও exit criteria; তিনটি CI gate.
  4. Suite: এক command-এ চলে, অন্তত ২০টি test, অন্তত চারটি স্তর; প্রতিটি test একটি ঝুঁকির marker-এ।
  5. চেনা defect: অন্তত তিনটি found defect-এর xfail(strict) test; একবার --runxfail দিয়ে ব্যর্থতার কারণ যাচাই।
  6. প্রমাণ: অন্তত দুটি bug switch চালু করে suite লাল হয়, তা দেখান; আর একটি switch যা আপনার suite ধরে না, তা খুঁজে বের করুন।
  7. Release summary: স্তরভিত্তিক ফল, খোলা আর automate না হওয়া defect, সিদ্ধান্ত আর কার সই লাগবে।

কাজটি এক বসায় নয়, ধাপে ধাপে করুন, আর প্রতিটি ধাপের শেষে জমা দেওয়ার মতো একটি জিনিস রাখুন:

  1. প্রথম ধাপ, কাগজে: quality goal আর register. App চালানোর আগেই README আর আগের পর্বগুলোর নোট থেকে প্রতিটি এলাকার জন্য একটি প্রশ্ন লিখুন: “এখানে ভুল হলে কার, কী ক্ষতি?” Likelihood-এর পাশে অন্তত একটি প্রমাণ লিখুন; প্রমাণ না থাকলে লিখুন “অনুমান”, যাতে পরে যাচাই করা যায়।
  2. দ্বিতীয় ধাপ, strategy-র খসড়া: register-এর প্রতিটি সারির পাশে স্তর আর tool. যে ঝুঁকির জন্য কোনো স্বয়ংক্রিয় test লিখবেন না, তার পাশেও লিখুন কীভাবে দেখবেন: exploratory session, আলাদা সূচির chaos, অথবা “এবার বাদ” আর তার কারণ।
  3. তৃতীয় ধাপ, suite-এর কাঠামো: আগে conftest, seed ফেরত আনা আর প্রতিটি স্তরে একটি করে test; সেগুলো সবুজ হলে তবেই বাকিগুলো। প্রথম দিন থেকেই এক command-এ পুরো run চালু রাখলে শেষে জোড়া লাগানোর ঝামেলা থাকে না।
  4. চতুর্থ ধাপ, চেনা defect আর প্রমাণ-run: xfail(strict) test, --runxfail দিয়ে কারণ যাচাই, তারপর bug switch চালু করে suite লাল হয় কি না দেখা। যে switch আপনার suite ধরে না, সেটি লুকাবেন না: সেটিই আপনার পরের test-এর ঠিকানা।
  5. শেষ ধাপ, সিদ্ধান্ত: register-এর শেষ কলাম, অর্থাৎ প্রতিটি ঝুঁকিতে কয়টি test, marker থেকে script দিয়ে গুনুন; তারপর release summary. Summary লেখার পরে register-এ ফিরে যান, আর যে এলাকায় test ঝুঁকির তুলনায় কম পড়েছে, তা পরের কাজের তালিকায় তুলুন।

নিজের কাজের স্কোর দেখুন। নিচের rubric-এ নয়টি মাপকাঠি, ওজনের যোগফল ১০০; যেগুলো পূরণ করেছেন সেগুলোয় টিক দিন:

// Capstone rubric: 9 criteria, weights sum to 100
const R = [
  ["প্রসঙ্গ আর quality goal", 5],
  ["Risk register, প্রমাণসহ L × I", 15],
  ["Strategy: ঝুঁকি → স্তর, কৌশল, tool", 15],
  ["এক command, ≥২০ test, ≥৪ স্তর", 15],
  ["চেনা defect = xfail(strict) + id", 10],
  ["≥২টি bug switch ধরা পড়ে", 10],
  ["CI gate, entry/exit criteria", 10],
  ["Summary: সিদ্ধান্ত + residual risk + সই", 15],
  ["শুধু localhost; secret বা hostname নেই", 5]];
const total = R.reduce((s, [, w]) => s + w, 0);
const band = p => p >= 80 ? "জমা দেওয়ার মতো" : p >= 60 ? "আরেকবার ঘষামাজা" : "মূল অংশ বাকি";
console.log("weights sum:", total);
const first = [3, 5];                 // a typical first attempt: tests only
const s1 = first.reduce((s, i) => s + R[i][1], 0);
console.log("first attempt (tests only):", s1, "->", band(s1));
const ui = document.getElementById("ui");
ui.innerHTML = R.map(([t, w], i) =>
  `<label><input type="checkbox" data-i="${i}"> ${t} (${w})</label>`).join("") + `<p id="out"></p>`;
function score() {
  const s = [...ui.querySelectorAll("input:checked")].reduce((a, c) => a + R[+c.dataset.i][1], 0);
  document.getElementById("out").textContent = `আপনার স্কোর ${s}/100 → ${band(s)}`;
}
ui.addEventListener("change", score); score();

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

weights sum: 100
first attempt (tests only): 25 -> মূল অংশ বাকি

শুধু test লিখে (মাপকাঠি ৪ আর ৬) স্কোর ২৫: অনেক code, কিন্তু ক্যাপস্টোনের তিন-চতুর্থাংশ বাকি। ওজনের বেশিরভাগ ভাবনায়: ঝুঁকি, strategy আর সিদ্ধান্ত। এটিই একজন QA engineer আর একজন test-লেখকের পার্থক্য।

নিজে যাচাইয়ের তালিকা

নমুনা উত্তর: এই পর্বের ১ থেকে ৮ নম্বর অংশই একটি পূর্ণ নমুনা: quality goal-এর টেবিল, ৮টি সারির register, স্তর-tool-কারণের টেবিল আর পাঁচটি exit criteria, ৩৮টি test-এর suite, ৬টি xfail, চারটি প্রমাণ-run আর একটি লিখিত সিদ্ধান্ত। নমুনার দুর্বলতাও সৎভাবে লিখুন: R2-তে test কম, reliability-র test আলাদা সূচিতে, আর perf smoke কোনো load test নয়। ভালো ক্যাপস্টোন নিজের সীমা জানে।

Register-এর একটি সারি পূর্ণভাবে লিখলে কেমন দেখায়, তার নমুনা (ওপরের R4; নিজের ভাষায় লিখুন):

  • ঝুঁকি: ফোনে checkout করার সময় গ্রাহকের লেখা ডেটা হারায় বা পর্দায় ভুল তথ্য থাকে, ফলে অর্ডার হাতছাড়া হয় বা গ্রাহক ভুল সিদ্ধান্ত নেন।
  • Likelihood ৪, প্রমাণ: আগের পর্বগুলোয় এই এলাকায় পাঁচটি আসল defect (KD-57a, KD-57b, KD-69a, KD-69b, KD-69c); ফর্মে অনেক field, আর ফল network-এর অবস্থার ওপর নির্ভর করে।
  • Impact ৪, কারণ: টাকা সরাসরি হারায় না, কিন্তু অর্ডার হারাতে পারে আর গ্রাহকের আস্থা কমে।
  • Test-এর পরিকল্পনা: ফোনের মাপে checkout-এর একটি UI পথ, payment radio-র মাপের xfail test (KD-69b), ফোন নম্বরের partition-এর unit test, আর ধীর network ও reload নিয়ে ৬০ মিনিটের একটি exploratory session.
  • যা বাকি: offline অবস্থা আর খসড়া হারানোর স্বয়ংক্রিয় test নেই (KD-57a, KD-69a); release summary-তে আলাদা লাইনে আসবে।

লক্ষ করুন, প্রতিটি দাবির পাশে একটি প্রমাণ বা একটি id আছে। Rubric-এর “প্রমাণসহ L × I” মানে ঠিক এটুকু: পরের মানুষ register পড়ে জানবেন সংখ্যাটি কোথা থেকে এল, আর নতুন defect এলে কোন সারি বদলাতে হবে।

নমুনার release summary, manager-এর পড়ার মতো করে (সব তথ্য ওপরের সত্যিকারের run থেকে):

Release summary · বাজারঘর · পরিষ্কার build

সুপারিশ: শর্তসাপেক্ষে যাবে। ৩৮টি test-এর ৩২টি পাস, অপ্রত্যাশিত ব্যর্থতা নেই; search-এর p95 ১২.৫ ms; axe-এ গুরুতর লঙ্ঘন নেই। খোলা চেনা defect ১৪টি: ৬টি test-এ পাহারায়, ৮টি নয়। তিনটি উঁচু ঝুঁকি পেমেন্টে: retry-তে দুবার charge (KD-37), ধীর wallet-এ checkout ব্যর্থ (KD-63a), টাকা কাটা কিন্তু অর্ডার unpaid (KD-63b). শর্ত: পেমেন্টের risk owner-এর সই, আর প্রতিদিন ledger মেলানো। যা test হয়নি: ৫০ জনের load, offline অবস্থা, chaos; পরের সপ্তাহের সূচিতে।

১০ · AI-এর যুগে ক্যাপস্টোন

AI সহকারী কয়েক মিনিটে strategy-র খসড়া আর বিশটি test লিখে দিতে পারে। কিন্তু ক্যাপস্টোনে তার চেনা ভুলগুলো একসাথে ক্ষতিকর: শুধু happy path-এর test; app এখন যা করে তা-ই assert করা, ফলে ভুল কোডেও test পাস; বানানো API field বা tool option; sleep দিয়ে অপেক্ষা; এত mock যে আসল কিছুই পরীক্ষা হয় না; সীমা বাদ; আর না চালিয়েই “সব test পাস” দাবি। Strategy-তেও একই কাজ: ঝুঁকির স্কোর বানানো, প্রমাণ ছাড়া।

নিজের ক্যাপস্টোনের পর্যালোচনা চাইতে পারেন এভাবে:

তুমি একজন অভিজ্ঞ QA lead, আমার ক্যাপস্টোনের পর্যালোচক। নিচে আমার risk register, test strategy, release summary আর test-এর নামের তালিকা দিলাম (hostname, path আর token মুছে)। [register পেস্ট করুন] [strategy পেস্ট করুন] [pytest --collect-only -q-এর আউটপুট আর release summary পেস্ট করুন] ১. প্রতিটি উঁচু ঝুঁকির জন্য কয়টি test আছে গুনে দেখাও; কোথায় সংখ্যা ঝুঁকির সাথে মেলে না, বলো। ২. কোন test-এর নাম দেখে মনে হয় সেটি শুধু happy path, বা বর্তমান আচরণকে assert করছে, তা চিহ্নিত করো; নিশ্চিত না হলে "অনিশ্চিত" লেখো। ৩. আমার exit criteria-তে কোনো ফাঁক থাকলে বলো (যেমন automate না হওয়া ঝুঁকি)। ৪. কোনো tool-এর option প্রস্তাব করলে আলাদা তালিকায় লেখো; আমি official docs-এ মিলিয়ে নেব। ৫. কোনো সংখ্যা নিজে বানাবে না; আমার দেওয়া লাইন থেকে উদ্ধৃত করবে।

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

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

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

প্র ০১পুরো suite সবুজ, সব exit criteria পূরণ। তবু কি বলা যায় “বাজারঘরে আর কোনো গুরুতর bug নেই”?

না, আর এই উত্তরটি testing-এর সবচেয়ে পুরোনো সত্যগুলোর একটি। Edsger Dijkstra ১৯৬৯–৭০ সালের দিকে লিখেছিলেন, প্রোগ্রাম testing bug-এর উপস্থিতি দেখাতে পারে, অনুপস্থিতি কখনো নয়। পর্ব ০৩-এর সাতটি নীতির প্রথমটিও এটাই। ক্যাপস্টোনের ৩৮টি test কয়েকশো অবস্থার একটি ক্ষুদ্র নমুনা; Hypothesis-এর ৩০০টি উদাহরণও একটি function-এর সব input-এর তুলনায় সামান্য।

এই পর্বের নিজের ইতিহাসই প্রমাণ। বাজারঘরের নিজস্ব suite-এ ১৫০টি test ছিল, প্রথম থেকেই সবুজ। তবু পরের পর্বগুলো ১৪টি আসল defect পেয়েছে: browser-এ retry-তে দুবার charge, ৩২০ px-এ পাশে স্ক্রল, Unicode-এর খোঁজা, অনেক অর্ডারে ধীর তালিকা। কোনোটিই পুরোনো test-এর ভুল নয়; সেগুলো ওই প্রশ্নই করেনি। নতুন প্রশ্ন এসেছে নতুন কৌশল থেকে: UI automation, responsive check, localization, fuzzing, chaos.

তাই release summary-তে “bug নেই” কখনো লিখবেন না। লিখুন কী পরীক্ষা হয়েছে, কোন ঝুঁকিতে কতটা গভীরে, কী পরীক্ষা হয়নি, আর কোন চেনা defect খোলা। এই ক্যাপস্টোনের summary বলে: ৮টি চেনা defect কোনো test পাহারা দেয় না, reliability-র test আলাদা সূচিতে, আর perf smoke ৫০ জনের load-এর প্রমাণ নয়। এগুলো দুর্বলতা স্বীকার নয়, তথ্য। সিদ্ধান্ত যিনি নেবেন, তাঁর দরকার ঠিক এই তথ্য।

সবুজ suite-এর আসল অর্থ: “যে প্রশ্নগুলো আমরা করেছি, তার উত্তর এখন ঠিক।” প্রশ্নগুলো কতটা ভালো, তা যাচাই করে mutation বা bug switch, আর exploratory session নতুন প্রশ্ন খোঁজে।

মূল উপলব্ধি: Testing আস্থা বাড়ায়, নিশ্চয়তা দেয় না। ভালো রিপোর্ট আস্থার সাথে তার সীমাও জানায়।

প্র ০২চেনা defect-এর test xfail করে রাখলে দল কি সেগুলোর সাথে বাস করতে অভ্যস্ত হয়ে যায় না? এই বিপদ কীভাবে সামলাবেন?

বিপদটি বাস্তব, আর এর একটি বিখ্যাত নাম আছে। ১৯৮৬ সালে Challenger মহাকাশযান দুর্ঘটনার পর সমাজবিজ্ঞানী Diane Vaughan তাঁর বইয়ে (১৯৯৬) normalization of deviance-এর ধারণা দেন: booster-এর O-ring-এ ক্ষয় আগের উড্ডয়নেও দেখা গিয়েছিল, প্রতিবার কিছু না ঘটায় অস্বাভাবিকটা ধীরে ধীরে “গ্রহণযোগ্য” হয়ে গিয়েছিল। ঘটনাটির পূর্ণ ব্যাখ্যা জটিল, কিন্তু শিক্ষাটি সফটওয়্যারেও খাটে: লাল দাগ যদি স্থায়ী হয়, চোখ তা দেখা বন্ধ করে।

xfail-এর তালিকাও এমন হতে পারে। ছয়টি x প্রতিদিন দেখা দলের কাছে এক সময় আর খবর থাকে না। কয়েকটি অভ্যাস একে ঠেকায়। প্রথম, প্রতিটি xfail-এর কারণে defect-এর id, আর tracker-এ সেই defect-এর মালিক ও লক্ষ্য-তারিখ। দ্বিতীয়, সংখ্যাটি release summary-তে আলাদা লাইনে আর প্রবণতাসহ: “চেনা defect ৬, গত release-এ ৫”। সংখ্যা বাড়তে থাকলে সেটি নিজেই সতর্কবার্তা। তৃতীয়, severity অনুযায়ী সীমা: উঁচু severity-র কোনো xfail সই ছাড়া release পার হবে না, এই পর্বের E5. চতুর্থ, strict marker, যাতে ঠিক হলে চুপচাপ পাস না করে।

বিকল্পটি আরও খারাপ। Test মুছে ফেললে বা skip করলে defect চোখের আড়ালে চলে যায়, আর ঠিক হলো কি না কেউ জানে না। Test লাল রেখে দিলে পুরো build সারাক্ষণ লাল থাকে, আর নতুন ব্যর্থতা পুরোনোর ভিড়ে হারায়, যা পর্ব ৪০-এর flaky test-এর সমস্যার মতোই। xfail(strict) মাঝের পথ: দৃশ্যমান, আলাদা, আর পরিবর্তনে সজাগ।

মূল উপলব্ধি: চেনা defect-কে test-এ রাখা দায়িত্ব নেওয়া; তাকে প্রতিদিনের দৃশ্য বানিয়ে ফেলা দায়িত্ব এড়ানো। মালিক, তারিখ আর প্রবণতা দুটিকে আলাদা রাখে।

প্র ০৩বাজারঘর একটি নতুন দেশে চালু হবে: ভিন্ন মুদ্রা, ভিন্ন delivery-র নিয়ম। পুরোনো সবুজ suite আর risk register কতটা কাজে লাগবে?

Ariane 5-এর প্রথম উড্ডয়ন (৪ জুন ১৯৯৬) এই প্রশ্নের সবচেয়ে চেনা উত্তর। তদন্ত বোর্ডের প্রতিবেদন অনুযায়ী, inertial reference system-এর একটি software অংশ Ariane 4 থেকে প্রায় অপরিবর্তিত নেওয়া হয়েছিল। নতুন রকেটের গতিপথে একটি মান অনেক বড় হলো, ৬৪-bit দশমিক সংখ্যা থেকে ১৬-bit পূর্ণসংখ্যায় রূপান্তরে overflow হলো, আর উড্ডয়নের প্রায় ৪০ সেকেন্ডের মধ্যে রকেট ধ্বংস হলো। পুরোনো রকেটে কোডটি বহুবার সফল ছিল; সমস্যা ছিল প্রসঙ্গ বদলে যাওয়া, আর নতুন গতিপথের বাস্তব ডেটা দিয়ে পূর্ণ পরীক্ষা না হওয়া।

বাজারঘরের ক্ষেত্রেও সবুজ suite মানে শুধু “পুরোনো প্রসঙ্গে পুরোনো প্রশ্নের উত্তর ঠিক”। নতুন দেশে quality goal আর ঝুঁকি দুই-ই বদলায়। দাম পূর্ণ টাকায় floor করা হয়; নতুন মুদ্রায় দশমিক থাকলে coupon-এর সীমা, rounding আর ৩০০-র cap নতুন করে ভাবতে হবে (পর্ব ০৮-এর floating point boundary). Delivery-র decision table-এ “Dhaka” নামের শর্তটি অর্থহীন হয়ে নতুন শর্ত আসবে। ফোন নম্বরের regular expression বাংলাদেশের নিয়মে বাঁধা। Unicode-এর ঝুঁকি নতুন লিপিতে নতুন রূপ নেবে।

তাই প্রথম কাজ register নতুন করে খোলা: প্রতিটি এলাকার impact আর likelihood নতুন প্রসঙ্গে, আর “পুনর্ব্যবহৃত কোড, নতুন অনুমান” একটি আলাদা ঝুঁকি হিসেবে। Suite-এর যে test-গুলো স্থির ধ্রুবক (১০০০, ৬০, ১২০) assert করে, সেগুলোকে নিয়মের table থেকে চালানো parametrize-এ বদলানো ভালো, যাতে প্রতিটি দেশের নিয়ম আলাদা ডেটা হয়। আর পরিবেশে নতুন দেশের মতো বাস্তব ডেটা: পর্ব ৬৫-এর শিক্ষা।

মূল উপলব্ধি: Test-এর ফল একটি প্রসঙ্গের সাথে বাঁধা। প্রসঙ্গ বদলালে register আগে, suite পরে।

প্র ০৪অনেক প্রতিষ্ঠানে QA-কে “gatekeeper” বলা হয়: QA না বললে release যাবে না। এই ভূমিকা কেন সমস্যাজনক, আর ক্যাপস্টোনের সিদ্ধান্ত-প্রক্রিয়া কীভাবে আলাদা?

Therac-25-এর ঘটনা (১৯৮৫–৮৭) দায়িত্বের প্রশ্নে বারবার পড়া হয়। এই radiation therapy যন্ত্রে আগের মডেলের hardware নিরাপত্তা-তালা সরিয়ে software-এর ওপর ভরসা করা হয়েছিল; software-এর race condition-সহ কয়েকটি ত্রুটিতে কয়েকজন রোগী মারাত্মক মাত্রার radiation পান। Nancy Leveson আর Clark Turner-এর বিশ্লেষণ (১৯৯৩) দেখায়, সমস্যা একটি bug-এর চেয়ে বড়: অতিরিক্ত আস্থা, স্বাধীন নিরাপত্তা-বিশ্লেষণের অভাব, আর অভিযোগ এলে “যন্ত্র ঠিক আছে” ধরে নেওয়া। কেউ পুরো ঝুঁকির মালিক ছিলেন না।

Gatekeeper মডেল দায়িত্বকে ভুল জায়গায় রাখে। QA “হ্যাঁ” বললে বাকিরা ভাবেন quality তাঁদের কাজ নয় (পর্ব ৭৬-এর whole-team quality-র উল্টো)। QA “না” বললে QA হয়ে যায় দেরির কারণ, আর চাপের মুখে “না” একসময় “ঠিক আছে, এবারের মতো” হয়ে যায়। দুটিই খারাপ: সিদ্ধান্তের দায় তাঁর কাছে নেই, যাঁর হাতে ব্যবসার তথ্য আর ক্ষমতা।

ক্যাপস্টোনের প্রক্রিয়া দায়িত্ব ভাগ করে। যান্ত্রিক gate (E1, E3, E4) নিরপেক্ষভাবে “না” বলে, কোনো মানুষের মেজাজ নয়। E5 বলে, প্রতিটি উঁচু ঝুঁকিতে নাম ধরে একজন risk owner সই করবেন, প্রতিকারসহ। Tester-এর কাজ তিনটি: ঝুঁকিটি স্পষ্ট ভাষায় বোঝানো (“এক অর্ডারে দুবার টাকা কাটা যেতে পারে, retry করলে”), প্রমাণ দেওয়া (সত্যিকারের run, ledger-এ ২টি charge), আর সুপারিশ। সিদ্ধান্ত লিখিত থাকে, তাই পরে প্রশ্ন উঠলে বোঝা যায় কে কী জেনে কী মেনেছিলেন।

মূল উপলব্ধি: QA তথ্যের মালিক, সিদ্ধান্তের নয়। ভালো প্রক্রিয়া সিদ্ধান্তকে দৃশ্যমান আর দায়বদ্ধ করে।

প্র ০৫ক্যাপস্টোনে contract test শুধু একটি JSON Schema. বাজারঘর যদি কয়েকটি দলে ভাগ হয় (app, payment, delivery), তখন কী বদলাতে হবে?

NASA-র Mars Climate Orbiter ১৯৯৯ সালে হারিয়ে যায়। তদন্তে দেখা যায়, মাটির একটি software একটি মান pound-force·second এককে দিচ্ছিল, আর navigation-এর দিক ধরে নিয়েছিল সেটি newton·second, অর্থাৎ SI একক। প্রতিটি অংশ নিজের ভেতরে হয়তো ঠিক ছিল; ভুল ছিল দুই দলের মাঝের চুক্তিতে, যা কেউ যন্ত্র দিয়ে যাচাই করেনি।

এক দলের ছোট app-এ একটি schema যথেষ্ট, কারণ provider আর consumer একই কোডে, একই suite-এ। দল ভাগ হলে তিনটি জিনিস বদলায়। প্রথম, contract আর একজনের অনুমান নয়: প্রতিটি consumer নিজের প্রত্যাশা লেখে, provider সেগুলো যাচাই করে, পর্ব ৩২-এর consumer-driven contract আর Pact-এর ধারণা। একক আর অর্থও contract-এর অংশ: price integer টাকায়, পয়সায় নয়। দ্বিতীয়, CI gate বদলায়: provider-এর build-এ সব consumer-এর contract চলে, আর “এই version কি deploy করা যায়” প্রশ্নটি একটি যন্ত্রের উত্তর পায়। তৃতীয়, risk register-এ নতুন এলাকা: দলের সীমানা। পর্ব ৭০-এর microservice-এর ঝুঁকি, যেমন event দুবার আসা আর eventual consistency, register-এ আসে।

End-to-end test দিয়ে এই সব ধরার লোভ হয়, কিন্তু কয়েকটি দলের service একসাথে চালানো ধীর আর ভঙ্গুর। ক্যাপস্টোনের পিরামিড তাই আরও প্রশস্ত হয় মাঝখানে: প্রতিটি দলের নিজের unit আর API test, তাদের মাঝে contract, আর ওপরে খুব অল্প কয়েকটি সোনালি পথ।

মূল উপলব্ধি: বড় ব্যর্থতা প্রায়ই দুই ঠিক অংশের মাঝখানে জন্মায়। দল যত ভাগ হয়, চুক্তিকে তত যন্ত্রে যাচাইযোগ্য করতে হয়।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। উদ্ধৃত আউটপুট এই পর্বের সত্যিকারের run থেকে।

  1. Test নকশা (spec থেকে): নতুন নিয়ম: “একটি কার্টে সর্বোচ্চ ২০টি ভিন্ন পণ্যের লাইন থাকতে পারে। নতুন পণ্য যোগ করলে লাইন ২০-এর বেশি হলে API 422 cart_full দেয় আর কার্ট বদলায় না; আগে থেকে থাকা লাইনের পরিমাণ বদলানো চলবে। পাতায় বাংলায় বার্তা।” এটি কোন ঝুঁকিতে পড়ে, কোন কোন স্তরে কোন test লিখবেন? একটি ফাঁদও খুঁজুন।

    ঝুঁকি R4 (checkout-এর ডেটা), মাঝারি। একটি সম্ভাব্য সেট:

    স্তরঅবস্থা → কাজপ্রত্যাশা
    Unit19 লাইন → নতুন পণ্যগ্রহণ, 20 লাইন (সর্বোচ্চ বৈধ সীমা)
    Unit20 লাইন → নতুন পণ্যপ্রত্যাখ্যান, 21 অবৈধের প্রথম মান
    Unit20 লাইন → পুরোনো লাইনের qty বদলগ্রহণ, লাইন 20
    Unit0 লাইন → নতুন পণ্যগ্রহণ, 1 লাইন
    API20 লাইন → POST /api/cart/items422, cart_full, কার্টে এখনো 20 লাইন
    API21তম ব্যর্থ → একটি লাইন মুছে আবার যোগগ্রহণ
    UIপাতায় 21তম যোগবাংলায় বার্তা, ইংরেজি নয় (KD-56b-এর শিক্ষা)

    ফাঁদ: seed-এ মাত্র ১২টি পণ্য। API আর UI স্তরে ২১টি ভিন্ন পণ্য লাগবে, তাই আগে test data বানাতে হবে, যেমন admin API দিয়ে পণ্য তৈরির একটি factory (পর্ব ২৩, ৬৫)। নইলে কেউ ১২টি দিয়ে test লিখে “সীমা পরীক্ষা হয়েছে” ভাববেন।

  2. ব্যর্থতা পড়া: একটি build-এ নিচের ব্যর্থতা এলো। কোন test, কী ভেঙেছে, আর এই বার্তা কেন দুর্বল? Test কীভাবে উন্নত করবেন?
    FAILED capstone_tests/test_nonfunctional.py::test_security_headers[/] - KeyError: 'content-security-policy'
        h = api.get(path).headers
        ...
    >   assert "default-src" in h["content-security-policy"]
    E   KeyError: 'content-security-policy'

    Test হলো / পথের security header-এর test. Response-এ Content-Security-Policy header নেই। বাজারঘরে এটি reflected_search switch-এর লক্ষণ, যা /-এ CSP সরিয়ে দেয়; একই run-এ escape-এর test-ও ফেল করেছিল, যা ধারণাটিকে পোক্ত করে।

    বার্তাটি দুর্বল, কারণ এটি assertion-এর ব্যর্থতা নয়, Python-এর KeyError: পড়লে মনে হয় test-এর কোডে bug. উন্নত রূপ: csp = h.get("content-security-policy"), তারপর assert csp, f"{path}: CSP header missing", তারপর assert "default-src" in csp. এখন ব্যর্থতা নিজেই বলে কী নেই, কোন পথে। ভালো test শুধু ধরে না, কারণও বলে।

  3. Test-এর bug খুঁজুন: একজন KD-60-এর জন্য এই test লিখে বললেন, “চেনা defect, xfail দিয়ে রাখলাম।” তিনটি সমস্যা খুঁজুন।
    @pytest.mark.xfail(reason="bug")
    def test_huge_id(api):
        r = api.get(f"/api/products/{2**63}")
        assert r.status_code == 500

    ১. ভুল আচরণকে assert করছে। Requirement বলে অজানা পণ্যে 404 (বা অবৈধ id-তে 422); test assert করে 500, অর্থাৎ বর্তমান bug. ফলে আজ test পাস করে।

    ২. strict নেই। পাস করায় ফল XPASS, কিন্তু strict না থাকায় run সবুজ; কেউ খেয়াল করবেন না। আরও খারাপ, KD-60 ঠিক হলে 404 আসবে, test ফেল করবে, আর xfail-এর কারণে সেটি “প্রত্যাশিত ব্যর্থতা” দেখাবে: সমাধানটিই লুকিয়ে যাবে।

    ৩. কারণ অস্পষ্ট। “bug” কোনো id নয়; tracker-এ খোঁজা যায় না। ঠিক রূপ: @pytest.mark.xfail(strict=True, reason="KD-60: product_id 2**63 gives 500") আর assert r.status_code in (404, 422).

  4. সিদ্ধান্ত নিন: একটি release-এর summary: অপ্রত্যাশিত ব্যর্থতা ০; search smoke-এ p95 ৪১০ ms (সীমা ৩০০); axe-এ serious লঙ্ঘন ০; খোলা উঁচু defect দুটি: KD-63a (risk owner সই করেছেন) আর KD-37 (সই হয়নি)। E1–E5 ধরে সিদ্ধান্ত কী, কেন? p95 ঠিক হয়ে গেলে কী হবে?

    সিদ্ধান্ত NO-GO, E3-এর কারণে: ৪১০ ≥ ৩০০. যান্ত্রিক gate ভাঙলে সই-এর প্রশ্নই ওঠে না। এই পর্বের calculator-ও প্রথমে E1, E3, E4 দেখে, তারপর সই।

    p95 ঠিক হলে (ধরুন ১২০ ms) E1, E3, E4 পূরণ। তখন E5: KD-63a-র সই আছে, KD-37-এর নেই, তাই তবু NO-GO. KD-37-এর risk owner প্রতিকারসহ (যেমন প্রতিদিন ledger মেলানো আর দুবার কাটা টাকা ফেরতের নিয়ম) সই করলে CONDITIONAL GO. খেয়াল করুন, “সব test পাস” কোনো ধাপেই একা যথেষ্ট ছিল না।

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

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

ক্রমএকটি পূর্ণ test strategy আর suite-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. প্রসঙ্গ আর quality goal লেখা
  2. প্রমাণসহ risk register বানানো
  3. ঝুঁকি অনুযায়ী স্তর, কৌশল, tool আর exit criteria ঠিক করা
  4. Suite লেখা, চেনা defect xfail(strict) হিসেবে
  5. Bug switch চালু করে suite ধরে কি না যাচাই
  6. Release summary, সিদ্ধান্ত আর risk owner-এর সই

pytest-এ একটি test-এ @pytest.mark.xfail(strict=True, reason="KD-60") আছে। Developer defect-টি ঠিক করলেন, আর test-এর assertion এখন সত্য। পরের run-এ কী হবে?

  • Test পাস হিসেবে গোনা হবে, run সবুজ
  • Test ব্যর্থ হবে, বার্তা [XPASS(strict)]
  • Test skip হবে, কারণ marker আছে
  • pytest marker-টি নিজে সরিয়ে দেবে

একটি smoke test-এ ২০টি response time (ms): 110, 95, 120, 130, 105, 98, 140, 160, 115, 125, 101, 99, 135, 180, 118, 122, 450, 129, 133, 97. Nearest-rank পদ্ধতিতে p95 কত?

  • 180
  • 450
  • 138.1
  • 160

একটি risk register-এ ১–৫ মাপে পেমেন্টের likelihood ৪, impact ৫; সীমা: ১৫ বা বেশি উঁচু। এই এলাকার জন্য কোন পরিকল্পনা সবচেয়ে যুক্তিসঙ্গত?

  • একটি UI end-to-end test যথেষ্ট
  • যত বেশি সম্ভব unit test, কারণ সেগুলো সস্তা
  • কয়েক স্তরে test, চেনা defect-এর regression test, exploratory আর chaos যাচাই
  • পরের release পর্যন্ত test পিছিয়ে দেওয়া

একটি দোকানের app-এ ইচ্ছা করে একটি bug বসানো হলো: coupon-এর শর্ত > 1000 থেকে >= 1000. পুরো suite তবু সবুজ। এর সবচেয়ে যুক্তিসঙ্গত অর্থ কী?

  • Bug-টি ক্ষতিকর নয়, তাই ধরা পড়েনি
  • Suite flaky
  • Coverage ১০০% হলে এমন হতে পারে না
  • Suite-এ ১০০০ টাকার সীমার test নেই বা assertion দুর্বল

একটি release-এর আগে কে সাধারণত শেষ go/no-go সিদ্ধান্ত নেন, আর tester-এর ভূমিকা কী?

  • Tester একাই, কারণ তিনি test চালিয়েছেন
  • দায়িত্বপ্রাপ্ত ব্যবসার মানুষ; tester দেন ঝুঁকির তথ্য, প্রমাণ আর সুপারিশ
  • যে developer শেষ পরিবর্তন করেছেন
  • CI pipeline, সবুজ হলেই release

pytest-এর একটি JUnit XML-এর মাথায় লেখা: tests="38" failures="0" skipped="6". ছয়টিই <skipped type="pytest.xfail">. Dashboard কী দেখানো উচিত?

  • ৩২টি পাস আর ৬টি চেনা defect (xfail), skip ০
  • ৩২টি পাস আর ৬টি skip
  • ৩২টি পাস আর ৬টি ব্যর্থ
  • ৩৮টি পাস

শব্দকোষ

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

মনে রাখুন

  1. ক্যাপস্টোনের ক্রম: প্রসঙ্গ আর quality goal → প্রমাণসহ risk register → স্তর, কৌশল, tool, gate আর exit criteria → suite → ভুল ঢুকিয়ে যাচাই → সিদ্ধান্ত আর সই।
  2. Likelihood বসান প্রমাণে: বাজারঘরের ১৪টি found defect-এর ৮টি দুই উঁচু এলাকায়। পরে মিলিয়ে দেখুন test-এর সংখ্যা ঝুঁকির পিছনে গেছে, না সহজের পিছনে।
  3. চেনা defect: requirement অনুযায়ী test, xfail(strict=True), কারণে id. ঠিক হলে XPASS(strict) suite লাল করে বলে “marker সরান”। JUnit XML-এ xfail “skipped” হিসেবে আসে।
  4. সবুজ suite প্রমাণ নয়; bug switch দেখিয়েছে suite ধরে (৫টি ব্যর্থ, NO-GO), আর একটি ব্যর্থতার বার্তা (KeyError) দুর্বল।
  5. যান্ত্রিক gate “না” বলে; “হ্যাঁ” বলেন risk owner, লিখিত residual risk আর প্রতিকারসহ। Automate না হওয়া ঝুঁকিও summary-তে আসে।

পরের পর্বে: নতুন মডিউল ১৪, পরীক্ষা আর ইন্টারভিউর প্রস্তুতি। শুরু test design-এর হিসাবের অনুশীলন দিয়ে: partition, boundary, decision table আর coverage-এর সংখ্যা, ধাপে ধাপে সমাধানসহ।

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

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