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

Fixture আর test data — scope, factory আর builder

Fixtures and Test Data — Scope, Factories and Builders

Taught in Bangla, this lesson traces the real order of unittest setUpClass, setUp, tearDown and addCleanup, then covers pytest fixtures: yield teardown, dependencies, conftest.py levels and function, class, module and session scope. A real pytest 9.2.0 --setup-show run shows session, module and function fixtures built and torn down, and a ScopeMismatch error. It covers autouse, parametrized and factory fixtures, tmp_path, monkeypatch, capsys and caplog, test data builders, seeded fake data and a shared-state leak.

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

  • unittest-এর setUpClass, setUp, tearDown, addCleanup-এর আসল ক্রম, আর setUp ব্যর্থ হলে কী চলে
  • pytest fixture-এর scope, নির্ভরতা, conftest.py-এর স্তর আর --setup-show পড়ে setup-teardown-এর ক্রম বোঝা
  • autouse, parametrized আর factory fixture কখন সাহায্য করে আর কখন বিপদ ডাকে
  • tmp_path, monkeypatch, capsys, caplog দিয়ে ফাইল, পরিবেশ, print আর log-এর test
  • Test data builder, object mother আর seed দেওয়া ডেটা বানানো, আর shared state-এর leak খুঁজে সারানো

১ · Fixture কী — test-এর আগে মঞ্চ সাজানো

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

Test-এর জগতে এই আগে-পরের ব্যবস্থার নাম test fixture: test চালানোর আগে যে নির্দিষ্ট, জানা শুরুর অবস্থা তৈরি করা হয় (একটি cart, test database-এ কয়েকটি পণ্য, একটি অস্থায়ী ফোল্ডার), আর test শেষে যা গুছিয়ে ফেলা হয়। Gerard Meszaros তাঁর xUnit Test Patterns (২০০৭) বইয়ে প্রতিটি test-কে চার ধাপে ভাগ করে দেখিয়েছেন, যাকে বলা হয় four-phase test: setup (মঞ্চ সাজানো), exercise (আসল কাজটি করা), verify (ফল যাচাই) আর teardown (গোছানো)। পর্ব ২২ (ভালো unit test-এর গঠন — AAA, নামকরণ আর একটি আচরণ)-এর Arrange-Act-Assert হলো প্রথম তিন ধাপ; এই পর্ব প্রথম আর শেষ ধাপের গভীরে যায়: মঞ্চ কে সাজাবে, কতবার, কতজনের জন্য, আর গোছাবে কে।

প্রাথমিক পরিচয় আগেই হয়েছে: Python প্রোগ্রামিং কোর্সের পর্ব ৪২-এ একটি fixture, yield আর tmp_path; সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৬-এ fixture-এর ধারণা; ফুল-স্ট্যাক কোর্সের পর্ব ৭৭-এ JavaScript-এ factory আর builder. এখানে নতুন যা: scope আর setup-teardown-এর নিখুঁত ক্রম (সত্যিকারের run দেখে), fixture-এর নির্ভরতা আর conftest.py-এর স্তর, factory fixture, তৈরি fixture-গুলো, test data-র নকশা, আর shared state কীভাবে test-কে একে অপরের ওপর নির্ভরশীল করে ফেলে। pytest-এর মৌলিক ব্যবহার এই কোর্সের পর্ব ২১-এ।

বাজারঘরের নিয়ম (এই পর্বে)

Coupon: অর্ডার ১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০ টাকা, পূর্ণ টাকায়। Delivery: ঢাকার ভেতরে ৬০ টাকা, ২০০০ টাকা বা বেশি হলে ফ্রি (ছাড়ের আগের টাকায় বিচার); বাইরে ১২০ টাকা, Plus সদস্যের ৬০ টাকা। অর্ডারের অবস্থা: placed → paid → packed → shipped → delivered; shipped-এর আগে cancel করা যায়, টাকা দেওয়া অর্ডার cancel হলে refund. ফোন: ১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3–9, শুধু ASCII অঙ্ক।

unittest-এর পাঁচটি hook — কোনটি কখন চলে

pytest-এ যাওয়ার আগে Python-এর standard library-র unittest দেখি, কারণ xUnit পরিবারের সব framework (JUnit, NUnit, pytest-এর unittest-সমর্থন) একই ছাঁচে চলে। প্রতিটি test method-এর আগে setUp, পরে tearDown; পুরো class-এর জন্য একবার setUpClass আর tearDownClass; আর addCleanup, যা একটি পরিষ্কারের কাজ তালিকায় তোলে। Class-স্তরের সমতুল্য addClassCleanup এসেছে Python 3.8-এ। প্রশ্ন হলো ক্রম, আর কিছু ব্যর্থ হলে কী চলে, কী চলে না। অনুমান না করে চালিয়ে দেখি। নিচের class-এ তিনটি test: একটি পাস করে, একটি assertion-এ ব্যর্থ হয়, আর একটির setUp-ই মাঝপথে ভেঙে পড়ে (stock service বন্ধ)। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

import unittest

class CheckoutTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setUpClass     open test db (once)")
        cls.addClassCleanup(print, "class cleanup  close test db")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass  drop tables")

    def setUp(self):
        print(f"  setUp        new cart [{self._testMethodName[5:]}]")
        self.addCleanup(print, "  cleanup 1    delete cart")
        self.addCleanup(print, "  cleanup 2    release coupon")
        if self._testMethodName == "test_c_broken_setup":
            raise RuntimeError("stock service down")
    def tearDown(self):
        print("  tearDown")
    def test_a_pay(self):
        print("    test       pay 1190 taka")
    def test_b_wrong_total(self):
        print("    test       check total")
        self.assertEqual(1190, 1000)
    def test_c_broken_setup(self):
        print("    test       (never runs)")

result = unittest.TestResult()
unittest.defaultTestLoader.loadTestsFromTestCase(CheckoutTest).run(result)
print("ran", result.testsRun, "| failures", len(result.failures),
      "| errors", len(result.errors))

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

setUpClass     open test db (once)
  setUp        new cart [a_pay]
    test       pay 1190 taka
  tearDown
  cleanup 2    release coupon
  cleanup 1    delete cart
  setUp        new cart [b_wrong_total]
    test       check total
  tearDown
  cleanup 2    release coupon
  cleanup 1    delete cart
  setUp        new cart [c_broken_setup]
  cleanup 2    release coupon
  cleanup 1    delete cart
tearDownClass  drop tables
class cleanup  close test db
ran 3 | failures 1 | errors 1

পাঁচটি নিয়ম এখানে চোখে দেখা গেল। (১) setUpClass একবার, সবার আগে; tearDownClass একবার, সবার শেষে, তারপর class cleanup. (২) প্রতিটি test-এর আগে নতুন setUp, তাই প্রতিটি test নতুন cart পায়। (৩) Cleanup-গুলো উল্টো ক্রমে চলে: যোগ হয়েছিল ১, ২; চলল ২, ১। যা পরে খোলা হয়েছে, তা আগে বন্ধ, যেমন আলমারির ভেতরের বাক্স আগে বন্ধ করে তারপর আলমারি। (৪) test_b-এর assertion ব্যর্থ হলেও tearDown আর cleanup চলেছে। (৫) সবচেয়ে গুরুত্বপূর্ণ: test_c-এ setUp ভেঙে পড়ায় test-এর মূল অংশ চলেনি, tearDown-ও চলেনি, কিন্তু ভাঙার আগে নথিভুক্ত দুটি cleanup ঠিকই চলেছে। ফল: assertion-এর ব্যর্থতা “failure”, অপ্রত্যাশিত exception “error”. তাই অভিজ্ঞরা resource খোলার সাথে সাথেই addCleanup লেখেন, tearDown-এর ভরসায় থাকেন না।

২ · pytest fixture গভীরে — yield, নির্ভরতা আর conftest-এর স্তর

unittest-এ সব test একই setUp পায়, দরকার থাকুক বা না থাকুক। pytest উল্টো পথে হাঁটে: প্রতিটি test parameter-এর নাম লিখে বলে দেয় তার কী দরকার, আর pytest সেই নামের fixture খুঁজে, চালিয়ে, মানটি পৌঁছে দেয়। এটি এক ধরনের dependency injection: test নিজে কিছু বানায় না, বাইরে থেকে পায়। রেস্তোরাঁয় ভাতের সাথে ডাল চাইলে রান্নাঘর জানে ডালের আগে পেঁয়াজ ভাজতে হবে; আপনাকে পেঁয়াজের কথা বলতে হয় না। Fixture-ও তাই: একটি fixture অন্য fixture চাইতে পারে, আর pytest নির্ভরতার পুরো শিকল নিজে সাজায়।

নিচে বাজারঘরের test-এর tests/conftest.py, যা পরের অংশগুলোর সত্যিকারের run-এ ব্যবহার হয়েছে। এখানে একটি test SQLite database (session-জুড়ে একটি), তাতে পণ্যের তালিকা ভরা (প্রতি ফাইলে নতুন করে), আর একটি অর্ডার-কারখানা:

import sqlite3
import pytest
from bazarghar.orders import Order

STEPS = ["placed", "paid", "packed", "shipped", "delivered"]

@pytest.fixture(scope="session")
def db(tmp_path_factory):
    path = tmp_path_factory.mktemp("data") / "bazarghar.db"
    conn = sqlite3.connect(path)
    conn.execute("CREATE TABLE product (name TEXT, price INT, stock INT)")
    yield conn
    conn.close()

@pytest.fixture(scope="module")
def catalogue(db):
    db.executemany("INSERT INTO product VALUES (?, ?, ?)",
                   [("chal", 80, 50), ("dal", 140, 20), ("tel", 190, 10)])
    db.commit()
    yield db
    db.execute("DELETE FROM product")
    db.commit()

@pytest.fixture
def make_order():
    created = []
    def _make(status="placed", items=((500, 2),), district="Dhaka"):
        order = Order(list(items), district)
        for _ in range(STEPS.index(status)):
            order.advance()            # reach the state the real way
        created.append(order)
        return order
    yield _make
    print()
    print(f"[make_order teardown: {len(created)} order(s)]", end="")

তিনটি জিনিস খেয়াল করুন। এক, yield: এর আগের অংশ setup, পরের অংশ teardown; এমন fixture-কে বলে yield fixture. Test ব্যর্থ হলেও yield-এর পরের অংশ চলে; তবে yield-এর আগেই exception হলে সেই fixture-এর teardown চলে না, যেমন unittest-এর ভাঙা setUp. দুই, নির্ভরতা: catalogue চায় db, db চায় pytest-এর তৈরি tmp_path_factory. কোনো test শুধু catalogue চাইলেও pytest আগে বাকি দুটি বানাবে। তিন, make_order কোনো অর্ডার দেয় না, অর্ডার বানানোর একটি function দেয়; §৪-এ এর নাম factory fixture. অর্ডারটি নির্দিষ্ট অবস্থায় পৌঁছায় advance() ডেকে, অর্থাৎ আসল state machine-এর পথ ধরে (পর্ব ১০); order.status = "shipped" সরাসরি বসিয়ে দিলে অবৈধ অবস্থাও বানানো যেত, যা বাস্তবে কখনো ঘটে না।

conftest.py-এর স্তর আর একই নামের fixture

conftest.py pytest নিজেই খুঁজে পড়ে; এর fixture সেই ফোল্ডার আর তার নিচের সব ফোল্ডারের test-এ import ছাড়াই পাওয়া যায়। একাধিক স্তরে conftest থাকতে পারে, আর খোঁজার নিয়ম কাছ থেকে দূরে: আগে test ফাইল নিজে, তারপর তার ফোল্ডারের conftest, তারপর ওপরের ফোল্ডারের conftest, শেষে plugin আর pytest-এর তৈরি fixture. ফলে ভেতরের ফোল্ডার একই নামের fixture লিখে ওপরেরটি বদলে দিতে পারে।

ফাইলযা রাখবেনকারা পায়
tests/conftest.pydb, catalogue, make_orderসব test
tests/checkout/conftest.pyনিজের catalogue (শুধু Plus-সদস্যের পণ্য)শুধু checkout-এর test; ওপরেরটি এখানে ঢাকা পড়ে
test ফাইলের ভেতরেশুধু এই ফাইলের plus_memberশুধু এই ফাইল

সাবধান: একই নামের fixture বদলে দেওয়া শক্তিশালী, কিন্তু test পড়ে বোঝা যায় না কোন catalogue এলো। এক নামের তিনটি সংস্করণ থাকলে নতুন সহকর্মী ঘণ্টা ধরে খুঁজবেন। pytest --fixtures সব fixture আর তাদের ফাইল দেখায়, আর pytest --fixtures-per-test দেখায় কোন test কোন ফাইলের fixture পেল। ভিন্ন আচরণ হলে ভিন্ন নাম দিন: plus_catalogue.

৩ · Scope — function, class, module, session আর setup-এর ক্রম

Fixture scope ঠিক করে একটি fixture কতবার তৈরি হবে আর কতক্ষণ বাঁচবে। ঢাকার মেট্রো রেলের কথা ভাবুন: পুরো লাইন (session) সকালে একবার চালু হয়, রাতে বন্ধ; প্রতিটি স্টেশন (module) নিজের সময়ে খোলে-বন্ধ হয়; প্রতিটি কামরা (class) এক যাত্রায় একবার পরিষ্কার হয়; আর প্রতিটি যাত্রীর টিকিট (function) নতুন। পাঁচটি scope:

scopeকতবার তৈরিবাজারঘরে উদাহরণ
function (ডিফল্ট)প্রতিটি test-এ নতুনcart, order, যা test বদলায়
classপ্রতিটি test class-এ একবারএকজন Plus সদস্যের প্রোফাইল (শুধু পড়া হয়)
moduleপ্রতিটি test ফাইলে একবারপণ্যের তালিকা ভরা catalogue
packageপ্রতিটি package-এ (ফোল্ডারে) একবারএক ফোল্ডারের সব test-এর জন্য একটি fake server
sessionপুরো pytest-চলায় একবারdatabase সংযোগ, ধীর-তৈরি জিনিস

Scope-এর বাসা — কে কার ভেতরে, কতবার

Nested fixture scopes in the real run below

Fixture scope-এর বাসা: session ⊃ module ⊃ class ⊃ function session db — ১ বার module · test_catalogue.py catalogue — ১ম বার test: ৩টি পণ্য test: চালের দাম module · test_member.py catalogue — ২য় বার class · TestPlusMember plus_member — ১ বার function order — নতুন delivery = 60 function order — নতুন total = 420
ছবি ২৩.১ — বড় scope-এর fixture বাইরের বাক্সে, একবার তৈরি হয়ে ভেতরের সবাই ভাগ করে নেয়; ভেতরের বাক্স যতবার আসে, ছোট scope-এর fixture ততবার নতুন।

ডেস্কটপে সত্যিকারের run — --setup-show

নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো হয়েছে: Python 3.12.13, pytest 9.2.0 (MIT লাইসেন্স), uv দিয়ে বানানো ছোট প্রকল্পে; path নিরপেক্ষ করা। প্রকল্পে বাজারঘরের bazarghar/ package (pricing, orders, checkout), ওপরের conftest আর দুটি test ফাইল:

cd ~/bazarghar-qa
uv init --vcs none --author-from none
uv add pytest
def test_three_products_seeded(catalogue):
    count = catalogue.execute("SELECT COUNT(*) FROM product").fetchone()[0]
    assert count == 3


def test_rice_price(catalogue):
    sql = "SELECT price FROM product WHERE name = 'chal'"
    assert catalogue.execute(sql).fetchone()[0] == 80
import pytest
from bazarghar.orders import Order
from bazarghar.pricing import delivery_charge

@pytest.fixture(scope="class")
def plus_member():
    return {"district": "Sylhet", "member": True}

@pytest.fixture
def order(catalogue, plus_member):
    sql = "SELECT price FROM product WHERE name = 'dal'"
    price = catalogue.execute(sql).fetchone()[0]
    return Order([(price, 3)], **plus_member)

class TestPlusMember:
    def test_outside_delivery_is_60(self, order):
        assert delivery_charge(order.district, order.total(),
                               order.member) == 60

    def test_order_total(self, order):
        assert order.total() == 420

--setup-show flag প্রতিটি fixture-এর SETUP আর TEARDOWN ছাপে; অক্ষর S, M, C, F মানে session, module, class, function; ঢুকে-থাকা ফাঁকা জায়গা দেখায় কে কার ভেতরে:

$ uv run pytest --setup-show tests/test_catalogue.py tests/test_member.py
==================== test session starts ====================
platform win32 -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0
rootdir: ~/bazarghar-qa
configfile: pyproject.toml
collected 4 items

tests\test_catalogue.py
SETUP    S tmp_path_factory
SETUP    S db (fixtures used: tmp_path_factory)
    SETUP    M catalogue (fixtures used: db)
        tests/test_catalogue.py::test_three_products_seeded (fixtures used: catalogue, db, request, tmp_path_factory) .
        tests/test_catalogue.py::test_rice_price (fixtures used: catalogue, db, request, tmp_path_factory) .
    TEARDOWN M catalogue
tests\test_member.py
    SETUP    M catalogue (fixtures used: db)
      SETUP    C plus_member
        SETUP    F order (fixtures used: catalogue, plus_member)
        tests/test_member.py::TestPlusMember::test_outside_delivery_is_60 (fixtures used: catalogue, db, order, plus_member, request, tmp_path_factory) .
        TEARDOWN F order
        SETUP    F order (fixtures used: catalogue, plus_member)
        tests/test_member.py::TestPlusMember::test_order_total (fixtures used: catalogue, db, order, plus_member, request, tmp_path_factory) .
        TEARDOWN F order
      TEARDOWN C plus_member
    TEARDOWN M catalogue
TEARDOWN S db
TEARDOWN S tmp_path_factory

===================== 4 passed in 0.04s =====================

লম্বা আউটপুট এক নজরে পড়া কঠিন। নিচের stepper-এ একই run ছোট করে, ধাপে ধাপে; ডানে দেখবেন কোন fixture এই মুহূর্তে বেঁচে আছে, আর কোনটি এ পর্যন্ত কতবার তৈরি হলো।

1SETUP S tmp_path_factory2SETUP S db3  SETUP M catalogue4    test_three_products .5    test_rice_price .6  TEARDOWN M catalogue7  SETUP M catalogue8   SETUP C plus_member9    SETUP F order10    test_outside_60 .11    TEARDOWN F order12    SETUP F order13    test_order_total .14    TEARDOWN F order15   TEARDOWN C plus_member16  TEARDOWN M catalogue17TEARDOWN S db18TEARDOWN S tmp_path_factory
এই মুহূর্তে
জীবিত
তৈরি হলো
  1. Session আগে। প্রথম test catalogue চায়, যে চায় db, যে চায় tmp_path_factory. সবচেয়ে বড় scope-এর fixture সবার আগে তৈরি হয়, নির্ভরতার ক্রমে: আগে tmp_path_factory, তারপর db.
  2. Module-এর catalogue. প্রথম ফাইলের জন্য তিনটি পণ্য ভরা হলো। চার ফাঁকা ঘরের ঢোকানো লেখা বলছে এটি session-এর ভেতরে।
  3. দুটি test, একটি catalogue. দ্বিতীয় test-এর আগে কোনো নতুন SETUP নেই; দুটি test একই catalogue ভাগ করে নিল। কেউ এখানে একটি পণ্য মুছে ফেললে পরের test সেটি টের পেত; §৭-এ সেই বিপদ।
  4. ফাইল বদল। প্রথম ফাইল শেষ, তাই catalogue ভাঙা হলো (DELETE FROM product), আর দ্বিতীয় ফাইলের জন্য নতুন করে ভরা হলো: catalogue এখন ২ বার। db কিন্তু একই, session শেষ হয়নি।
  5. Class আর function. TestPlusMember-এর জন্য plus_member একবার; তার ভেতরে প্রথম test-এর জন্য নতুন order (ডালের দাম ১৪০ × ৩ = ৪২০ টাকা, সিলেট, Plus সদস্য)। ঢোকানো ফাঁক বাড়ছে: S, M, C, F.
  6. প্রতি test-এ নতুন order. প্রথম test শেষে order ভাঙা হলো, দ্বিতীয় test-এর আগে আবার তৈরি: order এখন ২ বার। Function scope-এর মূল্য এটাই: প্রতিটি test অক্ষত অর্ডার পায়।
  7. ভেতর থেকে বাইরে ভাঙা। class শেষ, তাই plus_member; ফাইল শেষ, তাই catalogue. Teardown সবসময় setup-এর উল্টো ক্রমে।
  8. Session শেষে। db আগে, তারপর tmp_path_factory: তৈরি হয়েছিল উল্টো ক্রমে। মোট হিসাব: db ১ বার, catalogue ২ বার, plus_member ১ বার, order ২ বার; ৪টি test, ৪টিই পাস।

বড় scope ছোট scope চাইতে পারে না

উল্টো নির্ভরতা চেষ্টা করলে কী হয়? একটি session fixture যদি function fixture cart চায়, তাহলে কোন test-এর cart? প্রশ্নটির উত্তর নেই, তাই pytest থামিয়ে দেয়। সত্যিকারের run:

$ uv run pytest -q mism/
E                                                       [100%]
========================== ERRORS ==========================
________________ ERROR at setup of test_report ________________
ScopeMismatch: You tried to access the function scoped fixture cart with a session scoped request object. Requesting fixture stack:
mism\test_mismatch.py:9:  def shared_report(cart)
Requested fixture:
mism\test_mismatch.py:4:  def cart()
1 error in 0.01s

লক্ষ করুন অক্ষরটি E, F নয়: test-এর কোড চলেইনি, ভেঙেছে প্রস্তুতিতে। ScopeMismatch-এর নিয়ম মনে রাখার সহজ উপায়: ছোট scope বড়টির ওপর নির্ভর করতে পারে (order চায় catalogue), বড়টি ছোটর ওপর নয়।

কোন scope বাছবেন — তিন প্রশ্ন

(১) Test কি জিনিসটি বদলায়? বদলালে function scope, কোনো ব্যতিক্রম নয়। (২) তৈরি কি সত্যিই ধীর? মাপুন (--durations, পর্ব ২১)। দ্রুত হলে function scope-ই রাখুন। (৩) বড় scope দরকার হলে বদলানো অংশ আলাদা করা যায় কি? যেমন session-এ database সংযোগ, কিন্তু প্রতিটি test-এর ডেটা function scope-এ, test শেষে rollback করে মুছে ফেলা। Integration test-এ এই কৌশল বিস্তারিত আসবে পর্ব ২৮ (Integration testing — কৌশল, test database আর Testcontainers)-এ।

৪ · autouse, parametrized fixture আর factory fixture

autouse — না চাইলেও চলে

@pytest.fixture(autouse=True) দিলে fixture-টি তার নাগালের (একই ফাইল, বা conftest-এর ফোল্ডার আর নিচে) প্রতিটি test-এ নিজে থেকে চলে, কেউ নাম না লিখলেও। একে বলে autouse fixture. ঠিক জায়গায় এটি খুব কাজের: প্রতিটি test-এর আগে একটি global cache খালি করা, বা নিশ্চিত করা যে কোনো test ভুল করে আসল mobile-wallet-এ অনুরোধ পাঠাবে না। কিন্তু দাম আছে: test পড়ে বোঝা যায় না যে কিছু একটা চলছে। Meszaros এমন লুকানো নির্ভরতাকে বলেছেন “mystery guest”: test-এর ফল এমন কিছুর ওপর নির্ভর করে যা test-এ লেখা নেই।

এই কোর্সের lab-এ এর একটি সত্যিকারের উদাহরণ পাওয়া গেল। Test data-র জন্য Faker library (§৬) install করার পরে একই --setup-show run-এ নতুন একটি লাইন এলো, যা কেউ লেখেননি:

plugins: Faker-40.54.0
collected 4 items

tests\test_catalogue.py
SETUP    S _session_faker
SETUP    S tmp_path_factory
…

Faker নিজের pytest plugin সাথে আনে, আর সেই plugin-এর _session_faker একটি session-scope autouse fixture; install করলেই প্রতিটি test-এর তালিকায় ঢুকে যায়। এখানে ক্ষতিকর নয়, কিন্তু শিক্ষাটি পরিষ্কার: autouse fixture আপনার না-জানা জায়গা থেকেও আসতে পারে। --setup-show আর --fixtures-per-test এগুলো খুঁজে বের করার হাতিয়ার; আর কোনো plugin সাময়িক বন্ধ করতে -p no:faker. (এই পর্বের বাকি run-গুলো -p no:faker দিয়ে, যাতে আউটপুট ছোট থাকে।)

Parametrized fixture — এক fixture, কয়েক রূপ

পর্ব ২১-এ দেখেছেন @pytest.mark.parametrize একটি test-কে কয়েকটি input-এ চালায়। একই কাজ fixture-এর স্তরেও হয়: params দিলে যে test-ই fixture-টি চায়, প্রতিটি মানের জন্য আলাদা করে চলে। এমন fixture-কে বলে parametrized fixture; মানটি আসে request.param থেকে। পার্থক্যটি দায়িত্বের: parametrize-এর তালিকা থাকে test-এর মাথায়, আর parametrized fixture-এর তালিকা থাকে fixture-এ, তাই অনেক test একসাথে সব রূপ পায়। যেমন delivery-র প্রতিটি test ঢাকার ভেতরে আর বাইরে, দুই জায়গায় চালাতে:

@pytest.fixture(params=["Dhaka", "Khulna"], ids=["inside", "outside"])
def district(request):
    return request.param


def test_delivery_at_most_120(make_order, district):
    order = make_order(items=[(300, 1)], district=district)
    assert delivery_charge(order.district, order.total()) <= 120

Factory fixture — জিনিস নয়, জিনিস বানানোর যন্ত্র

সাধারণ fixture প্রতিটি test-কে একটি জিনিস দেয়, একই রূপে। কিন্তু কোনো test-এর লাগে shipped অর্ডার, কোনোটির paid, কোনোটির একসাথে দুটি। প্রতিটি রূপের জন্য আলাদা fixture (paid_order, shipped_order…) লিখলে সংখ্যা দ্রুত বাড়ে। সমাধান factory fixture: fixture একটি function দেয়, আর test সেটি দরকারমতো ডাকে। ওপরের conftest-এর make_order ঠিক এমন। বাড়তি সুবিধা: fixture নিজে বানানো সব অর্ডারের হিসাব রাখে (created), তাই শেষে একসাথে পরিষ্কার করতে পারে; আসল প্রকল্পে সেখানে test database থেকে মুছে ফেলার কোড থাকত।

def test_paid_order_refunded_after_cancel(make_order):
    order = make_order("paid")
    order.cancel()
    order.refund()
    assert order.status == "refunded"


def test_shipped_order_cannot_be_cancelled(make_order):
    order = make_order("shipped")
    with pytest.raises(ValueError, match="cannot cancel"):
        order.cancel()


def test_unpaid_cancel_has_no_refund(make_order):
    order = make_order("placed")
    order.cancel()
    with pytest.raises(ValueError, match="refund needs"):
        order.refund()
$ uv run pytest -v tests/test_factory.py
collecting ... collected 5 items

tests/test_factory.py::test_paid_order_refunded_after_cancel PASSED   [ 20%]
tests/test_factory.py::test_shipped_order_cannot_be_cancelled PASSED  [ 40%]
tests/test_factory.py::test_unpaid_cancel_has_no_refund PASSED        [ 60%]
tests/test_factory.py::test_delivery_at_most_120[inside] PASSED       [ 80%]
tests/test_factory.py::test_delivery_at_most_120[outside] PASSED      [100%]

===================== 5 passed in 0.01s =====================

তিনটি অর্ডার-test তিনটি ভিন্ন অবস্থা চাইল, একটি fixture থেকেই। শেষ test দুবার চলেছে, আর ids-এর জন্য নামে [inside] আর [outside], যা -k outside দিয়ে আলাদা চালানো যায়। Factory-র teardown কখন চলে, দেখতে -s (print দেখানোর flag) আর --setup-show একসাথে:

$ uv run pytest -s --setup-show "tests/test_factory.py::test_delivery_at_most_120"
collected 2 items

tests\test_factory.py
        SETUP    F make_order
        SETUP    F district['inside']
        tests/test_factory.py::test_delivery_at_most_120[inside] (fixtures used: district, make_order, request) .
        TEARDOWN F district['inside']
[make_order teardown: 1 order(s)]
        TEARDOWN F make_order
        SETUP    F make_order
        SETUP    F district['outside']
        tests/test_factory.py::test_delivery_at_most_120[outside] (fixtures used: district, make_order, request) .
        TEARDOWN F district['outside']
[make_order teardown: 1 order(s)]
        TEARDOWN F make_order

===================== 2 passed in 0.01s =====================

একই scope-এর মধ্যে fixture তৈরি হয়েছে test-এর parameter-এর ক্রমে (make_order, তারপর district), ভেঙেছে উল্টো ক্রমে। আমাদের print-টি TEARDOWN F make_order-এর আগে এসেছে, কারণ pytest TEARDOWN লাইনটি লেখে পরিষ্কারের কাজ শেষ হওয়ার পরে। আর প্রতিটি parametrized রূপ নতুন make_order পেয়েছে, তাই প্রতিবার গণনা ১ থেকে শুরু।

৫ · তৈরি fixture — tmp_path, monkeypatch, capsys আর caplog

pytest নিজেই কয়েকটি fixture দেয়, যেগুলো এমন জিনিসের test সহজ করে যা সাধারণ assert-এ ধরা কঠিন: ফাইল, environment variable, পর্দায় ছাপা লেখা আর log. বাজারঘরের checkout.py-তে তিনটি ছোট কাজ আছে: ছাড় সর্বোচ্চ ৩০০-তে আটকালে একটি warning log, রসিদ ছাপা, আর invoice ফাইল লেখা এমন ফোল্ডারে যা environment variable BAZARGHAR_INVOICE_DIR ঠিক করে।

import logging
import os
from pathlib import Path
from bazarghar.pricing import breakdown

log = logging.getLogger("bazarghar.checkout")

def checkout(order):
    bill = breakdown(order.district, order.total(), order.member)
    if bill["discount"] == 300:
        log.warning("coupon cap reached, total %s", bill["subtotal"])
    return bill

def print_receipt(bill):
    for key in ("subtotal", "discount", "delivery", "payable"):
        print(f"{key:<9}{bill[key]:>6}")

def save_invoice(order_id, bill):
    folder = Path(os.environ.get("BAZARGHAR_INVOICE_DIR", "invoices"))
    folder.mkdir(exist_ok=True)
    path = folder / f"{order_id}.csv"
    rows = [f"{k},{v}" for k, v in bill.items()]
    path.write_text("\n".join(rows) + "\n", encoding="utf-8")
    return path
import logging
from bazarghar.checkout import checkout, print_receipt, save_invoice
from builders import an_order

def test_cap_logs_warning(caplog):
    order = an_order().with_items((1500, 2)).build()      # 3000 taka
    with caplog.at_level(logging.WARNING, logger="bazarghar.checkout"):
        bill = checkout(order)
    assert bill["discount"] == 300
    assert "coupon cap reached" in caplog.text

def test_receipt_for_plus_member_outside(capsys):
    order = (an_order().with_items((1200, 1))
             .outside_dhaka().plus_member().build())
    print_receipt(checkout(order))
    out = capsys.readouterr().out
    assert out.splitlines()[-1] == "payable    1140"

def test_invoice_goes_to_tmp(tmp_path, monkeypatch):
    monkeypatch.setenv("BAZARGHAR_INVOICE_DIR", str(tmp_path))
    path = save_invoice("BG-1001", {"payable": 1140})
    assert path.parent == tmp_path
    assert path.read_text(encoding="utf-8") == "payable,1140\n"
$ uv run pytest -v tests/test_checkout.py
collecting ... collected 3 items

tests/test_checkout.py::test_cap_logs_warning PASSED                  [ 33%]
tests/test_checkout.py::test_receipt_for_plus_member_outside PASSED   [ 66%]
tests/test_checkout.py::test_invoice_goes_to_tmp PASSED               [100%]

===================== 3 passed in 0.01s =====================
Fixtureযা দেয়ওপরের test-এ
tmp_pathপ্রতিটি test-এ নতুন খালি ফোল্ডার (pathlib.Path)invoice আসল invoices/ ফোল্ডারে না গিয়ে সেখানে গেল
monkeypatchsetenv, setattr, setitem, delenv; test শেষে নিজে আগের অবস্থায় ফেরায়env variable সাময়িক বদলানো
capsysstdout/stderr ধরে রাখে; readouterr()রসিদের শেষ লাইন: ১২০০ − ১২০ + ৬০ = ১১৪০
caploglog record ধরে রাখে; at_level, text, records৩০০০ টাকায় ছাড় ৩০০, তাই warning
tmp_path_factorysession scope-এ অস্থায়ী ফোল্ডার বানানোর যন্ত্রconftest-এর test database

খেয়াল করুন monkeypatch নিজেও একটি function-scope fixture, তাই এর বদল test শেষে নিজে উল্টে যায়। হাতে os.environ["BAZARGHAR_INVOICE_DIR"] = … লিখলে বদলটি থেকে যেত, আর পরের সব test চুপচাপ সেই ফোল্ডারে লিখত: §৭-এর shared state-এর আরেক রূপ। একটি ছোট সীমা: function-scope monkeypatch module বা session fixture-এর ভেতরে ব্যবহার করা যায় না (ScopeMismatch); সেখানে pytest.MonkeyPatch.context() context manager লাগে। monkeypatch.setattr দিয়ে কোনো function বদলে দেওয়ার কৌশল, আর কোথায় বদলাতে হয়, তা পর্ব ২৪ (Test double গভীরে — unittest.mock, patch আর mock-এর ফাঁদ)-এর বিষয়।

৬ · Test data — builder, object mother আর seed দেওয়া এলোমেলো data

Fixture বলে কখন আর কতবার; test data বলে কী। বাজারঘরের একটি অর্ডারে পণ্যের লাইন, জেলা, সদস্যপদ, অবস্থা, টাকা দেওয়া হয়েছে কি না। প্রতিটি test-এ সবকিছু হাতে লিখলে দুটি সমস্যা। এক, test-এর আসল কথাটি হারিয়ে যায়: দশটি মানের মধ্যে কোনটি এই test-এর জন্য গুরুত্বপূর্ণ? দুই, Order-এ একটি নতুন বাধ্যতামূলক field যোগ হলে দুইশো test ভাঙে। কোন মান বাছবেন, সেটি এসেছে technique থেকে (পর্ব ১৬-এর test data নকশা, পর্ব ০৮-এর সীমা); এখানে প্রশ্ন হলো সেই মান কোডে কীভাবে সুন্দর করে বসাবেন।

Test data builder

Builder নিরাপদ, সাদামাটা default দিয়ে শুরু করে; test শুধু যা প্রাসঙ্গিক তা বদলায়, method-এর শিকলে, পড়তে বাক্যের মতো। Nat Pryce ২০০০-এর দশকে এটি জনপ্রিয় করেন; পরে Freeman ও Pryce-এর Growing Object-Oriented Software, Guided by Tests (২০০৯) বইয়ে বিস্তারিত।

Object mother

Object mother নাম দেওয়া তৈরি object-এর সংগ্রহ: delivered_order(), plus_member_outside(). পড়তে চমৎকার, কিন্তু প্রতিটি নতুন রূপে নতুন function লাগে। নামটি ২০০১ সালের দিকে ThoughtWorks-এর একটি XP সম্মেলনের প্রবন্ধ থেকে প্রচলিত বলে উদ্ধৃত হয়।

বাস্তবে দুটি মেশে: object mother-এর function ভেতরে builder ব্যবহার করে, আর নতুন রূপ লাগলে test সরাসরি builder ডাকে। নিচের stepper-এ বাজারঘরের OrderBuilder (lab-এর tests/builders.py) দিয়ে একটি অর্ডার ধাপে ধাপে তৈরি হচ্ছে; ডানে builder-এর ভেতরের অবস্থা:

1order = (an_order()2  .with_items((1200, 1))3  .outside_dhaka()4  .plus_member()5  .build())6bill = checkout(order)
builder-এর ভেতরে
items
district
member
ফল
  1. Default দিয়ে শুরু। an_order() একটি builder দেয়: ৫০০ টাকার একটি পণ্য, ঢাকা, সদস্য নন। Default ইচ্ছা করে “বিরক্তিকর”: কোনো ছাড় নেই, কোনো বিশেষ নিয়ম খাটে না, যাতে test যা বদলায় শুধু তার প্রভাব দেখা যায়।
  2. with_items. এই test-এর জন্য ১২০০ টাকার একটি পণ্য; coupon-এর সীমা ১০০০-এর ওপরে, তাই ছাড় খাটবে। প্রতিটি method self ফেরত দেয় বলে শিকলটি চলে।
  3. outside_dhaka. জেলা বদলে রাজশাহী। কোন জেলা, তা এখানে গুরুত্বপূর্ণ নয়, শুধু “ঢাকার বাইরে”; তাই method-এর নাম আচরণ বলে, জেলার নাম ঐচ্ছিক।
  4. plus_member. সদস্যপদ True. এখন test পড়লেই বোঝা যায় কী যাচাই হচ্ছে: ঢাকার বাইরের Plus সদস্য।
  5. build. এতক্ষণ শুধু নকশা জমা হচ্ছিল; এখন আসল Order তৈরি, মোট ১২০০ টাকা, অবস্থা placed. Builder ভেতরে list(self._items) দিয়ে নতুন copy দেয়, যাতে দুটি অর্ডার একই list ভাগ না করে (§৭ দেখুন কেন)।
  6. বিল। ছাড় ১২০০ ÷ ১০ = ১২০, delivery Plus সদস্যের ৬০, পরিশোধ ১২০০ − ১২০ + ৬০ = ১১৪০ টাকা; §৫-এর রসিদ-test ঠিক এই সংখ্যাটি দেখেছে।

এবার builder-কে কাজে দেখি, একটি বসানো ভুলসহ। নিচের breakdown-এ developer ভুল করে delivery-র ২০০০ টাকার সীমা বিচার করেছেন ছাড়ের পরের টাকায়; নিয়ম বলে ছাড়ের আগের টাকায়। ২১০০ টাকার ঢাকার অর্ডারে ছাড় ২১০, বাকি ১৮৯০, তাই ভুল কোড ৬০ টাকা delivery নেবে। দুটি test, দুটিই builder দিয়ে:

import sys, unittest

def breakdown(district, total, member=False):        # seeded defect inside
    discount = min(total // 10, 300) if total > 1000 else 0
    after = total - discount
    if district == "Dhaka":
        delivery = 0 if after >= 2000 else 60
    else:
        delivery = 60 if member else 120
    return {"discount": discount, "delivery": delivery, "payable": after + delivery}

class OrderBuilder:
    def __init__(self):                 # safe, boring defaults
        self.lines, self.district, self.member = [(500, 1)], "Dhaka", False
    def with_items(self, *lines): self.lines = list(lines); return self
    def outside_dhaka(self, d="Rajshahi"): self.district = d; return self
    def plus_member(self): self.member = True; return self
    def build(self):
        total = sum(price * qty for price, qty in self.lines)
        return breakdown(self.district, total, self.member)

def an_order(): return OrderBuilder()

class BillTest(unittest.TestCase):
    def test_plus_outside_1140(self):
        bill = an_order().with_items((1200, 1)).outside_dhaka().plus_member().build()
        self.assertEqual(bill["payable"], 1140)
    def test_free_from_2000_before_coupon(self):
        bill = an_order().with_items((700, 3)).build()          # 2100, Dhaka
        self.assertEqual(bill["delivery"], 0, "rule: 2000+ before coupon")

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

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

test_free_from_2000_before_coupon (__main__.BillTest.test_free_from_2000_before_coupon) ... FAIL
test_plus_outside_1140 (__main__.BillTest.test_plus_outside_1140) ... ok

======================================================================
FAIL: test_free_from_2000_before_coupon (__main__.BillTest.test_free_from_2000_before_coupon)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 30, in test_free_from_2000_before_coupon
    self.assertEqual(bill["delivery"], 0, "rule: 2000+ before coupon")
    ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: 60 != 0 : rule: 2000+ before coupon

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

দ্বিতীয় test ভুলটি ধরেছে: কোড দিল ৬০, নিয়ম চায় ০. দুটি জিনিস লক্ষ করুন। প্রথমত, test-এ শুধু সেই মানগুলো লেখা যা নিয়মটির জন্য জরুরি: ৭০০ × ৩ = ২১০০ (২০০০-এর ওপরে, কিন্তু ছাড়ের পরে নিচে নামে), আর ঢাকা এসেছে default থেকে। এই মানটি বাছাই করা হয়েছে ইচ্ছা করে: ২০০০ থেকে ২২২১ টাকার মধ্যে যেকোনো অর্ডার ছাড়ের পরে ২০০০-এর নিচে নামে, তাই দুই নিয়মের পার্থক্য ঠিক এখানে ধরা পড়ে। দ্বিতীয়ত, assertion-এর বার্তায় নিয়মটি লেখা, তাই ব্যর্থতার রিপোর্ট পড়েই developer বোঝেন কোন requirement ভেঙেছে। Builder-হীন test-এ এই ২১০০ চাপা পড়ত জেলা, সদস্যপদ আর অবস্থার মানের ভিড়ে।

এলোমেলো test data — seed বাঁধুন, আর আসল মানুষ নয়

হাতে বাছা মান নিয়মের সীমা যাচাই করে, কিন্তু কল্পনার বাইরের ঘটনা ধরে না: একটু ভিন্ন নাম, ভিন্ন জেলা, অনেক বেশি অর্ডার। তাই অনেক দল এলোমেলো ডেটাও ব্যবহার করে। একটি শর্ত অটল: seed বেঁধে দিন। Seed একই থাকলে “এলোমেলো” ডেটা প্রতিবার হুবহু একই, তাই কোনো test ব্যর্থ হলে আবার একই ডেটায় চালিয়ে ভুল খোঁজা যায়। Seed ছাড়া এলোমেলো ডেটা থেকে জন্মায় flaky test: আজ পাস, কাল ফেল, কেউ জানে না কেন (পর্ব ৪০ (Flaky test — কারণ, খোঁজা, quarantine আর স্থায়ী সমাধান)-এ বিস্তারিত)।

প্রথমে সত্যিকারের একটি জনপ্রিয় tool: Faker 40.54.0 (MIT লাইসেন্স), একই uv প্রকল্পে uv add faker. Faker-এর pytest plugin একটি faker fixture দেয়, যা প্রতিটি test-এর শুরুতে seed 0 দিয়ে নতুন করে বাঁধা হয়; ভাষা বদলাতে faker_locale fixture, যা plugin-এর নিয়মে autouse হতে হয়। বাংলাদেশি ধাঁচের ডেটার জন্য locale bn_BD. তিনটি test: দুটি নাম আর ফোন ছাপে, তৃতীয়টি ২০০টি ফোন নম্বর বাজারঘরের ফোন-নিয়মে মেলায়।

import re
import pytest

PHONE = re.compile(r"01[3-9]\d{8}")

@pytest.fixture(autouse=True)
def faker_locale():
    return ["bn_BD"]

def test_first_customer(faker):
    print("\n", faker.name(), faker.phone_number(), end="")

def test_same_seed_again(faker):
    print("\n", faker.name(), faker.phone_number(), end="")

def test_phones_follow_bazarghar_rule(faker):
    phones = [faker.phone_number() for _ in range(200)]
    bad = [p for p in phones if not PHONE.fullmatch(p)]
    assert bad == [], f"{len(bad)} of 200 break the rule, e.g. {bad[:3]}"
$ uv run pytest -s -q fk/
 মুশফিক উদ্দিন ০১ ৪৮৭ ××××××.
 মুশফিক উদ্দিন ০১ ৪৮৭ ××××××.F
========================= FAILURES =========================
____________ test_phones_follow_bazarghar_rule ____________
…
E   AssertionError: 200 of 200 break the rule, e.g. ['+৮৮০-২-৬-××××-××××', '+৮৮০ ১৮২৪ ××××××', '০১৪১১××××××']
…
FAILED fk/test_fake_customers.py::test_phones_follow_bazarghar_rule - Asserti...
1 failed, 2 passed in 0.16s

(নম্বরের শেষ অঙ্কগুলো আমরা × দিয়ে ঢেকেছি: generator-এর বানানো নম্বরও কোনো আসল মানুষের নম্বরের সাথে মিলে যেতে পারে, তাই প্রকাশ্য লেখায় পুরো নম্বর নয়।) দুটি শিক্ষা। এক, দুটি test একই নাম আর নম্বর পেয়েছে, কারণ plugin প্রতিটি test-এ seed 0 থেকে শুরু করে: পুনরাবৃত্তিযোগ্য, যা ভালো। দুই, ২০০টির মধ্যে ২০০টিই বাজারঘরের নিয়ম ভাঙে: বাংলা অঙ্ক, ফাঁকা জায়গা, +৮৮০, ল্যান্ডফোনের ধাঁচ। Faker-এর ডেটা “বাস্তবের মতো দেখতে”, কিন্তু আপনার validation নিয়ম জানে না। তাই এগুলো খারাপ input-এর test-এ চমৎকার (পর্ব ১৪-এর error guessing), কিন্তু “বৈধ গ্রাহক” দরকার হলে নিজের নিয়মে বানাতে হবে। নিচের block ঠিক তাই করে, standard library-র random.Random দিয়ে, নিজের seed-এ:

import random, re

PHONE_RULE = re.compile(r"01[3-9]\d{8}")       # 11 digits, 01, third 3-9
DISTRICTS = ["Dhaka", "Chattogram", "Rajshahi", "Sylhet", "Khulna"]

def fake_customer(rng, n):
    phone = "01" + str(rng.randint(3, 9)) + "".join(str(rng.randint(0, 9)) for _ in range(8))
    return {"id": f"TEST-{n:03}", "phone": phone,
            "district": rng.choice(DISTRICTS), "total": rng.choice([999, 1000, 1001, 2000, 3010])}

def batch(seed, size=3):
    rng = random.Random(seed)                    # own generator, own seed
    return [fake_customer(rng, n) for n in range(1, size + 1)]

first, again, other = batch(2026), batch(2026), batch(7)
for c in first:                              # never print full phone numbers
    print(c["id"], f'{c["district"]:<10}', f'{c["total"]:>4}', c["phone"][:3] + "*" * 8)
print("same seed, same data :", first == again)
print("other seed, same data:", first == other)
many = batch(2026, size=500)
print("valid phones:", sum(bool(PHONE_RULE.fullmatch(c["phone"])) for c in many), "of 500")

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

TEST-001 Sylhet     3010 013********
TEST-002 Rajshahi    999 017********
TEST-003 Sylhet     3010 016********
same seed, same data : True
other seed, same data: False
valid phones: 500 of 500

একই seed (2026) দুবার একই ডেটা দিয়েছে, ভিন্ন seed ভিন্ন ডেটা; ৫০০টি নম্বরের ৫০০টিই নিয়ম মানে, কারণ generator নিয়ম থেকেই লেখা। তিনটি অভ্যাস লক্ষ করুন। (১) random.Random(seed) নিজের আলাদা generator; global random.seed() বদলালে অন্য test-এর এলোমেলোতাও বদলে যায়, যা আরেক রকম shared state. (২) টাকার মান পুরোপুরি এলোমেলো নয়, সীমার মান থেকে বাছা (৯৯৯, ১০০০, ১০০১, ২০০০, ৩০১০); এলোমেলোতা ছড়ায়, কৌশল নিশানা ঠিক করে। (৩) id-তে TEST- উপসর্গ, যাতে test environment-এর ডেটা কখনো আসল বলে ভুল না হয়, আর ছাপায় পুরো ফোন নম্বর নেই। হাজার রকম এলোমেলো input দিয়ে নিয়ম যাচাইয়ের পূর্ণ কৌশল আসবে পর্ব ৫৮ (Property-based testing — Hypothesis আর shrinking)-এ।

Production-এর আসল ডেটা test-এ নয়। “আসল গ্রাহকের ডেটা কপি করলেই তো সবচেয়ে বাস্তব test” — এই সহজ পথ ব্যক্তিগত তথ্য ফাঁসের পুরোনো উৎস: test environment-এ নিরাপত্তা দুর্বল থাকে, log আর screenshot এদিক-ওদিক যায়। নিরাপদ পথ synthetic data (নিয়ম দিয়ে বানানো), আর একান্ত দরকারে data masking: নাম, ফোন, ঠিকানা বদলে বা ঢেকে দেওয়া। Test environment আর ডেটা ব্যবস্থাপনার পূর্ণ আলোচনা পর্ব ৬৫ (Test environment আর test data — Docker Compose, seed আর masking)-এ।

৭ · Shared mutable state — এক test-এর ময়লা আরেক test-এ

মেসের রান্নাঘরে একটি হাঁড়ি। প্রথমজন তাতে ঝাল তরকারি রেঁধে না ধুয়ে রেখে গেলেন; দ্বিতীয়জনের পায়েস ঝাল হলো। দ্বিতীয়জন একা রাঁধলে পায়েস ঠিকই হতো। Test-এ এই হাঁড়ি হলো shared mutable state: কয়েকটি test একই বদলযোগ্য জিনিস (list, dict, database-এর সারি, global variable, ফাইল, environment variable) ভাগ করে, আর একটি test সেটি বদলে ফেলে রাখে। ফল order-dependent test: একা চালালে পাস, পুরো suite-এ ফেল, বা উল্টো। Test isolation মানে ঠিক এর উল্টো: প্রতিটি test যেকোনো ক্রমে, একা বা সবার সাথে, একই ফল দেয়।

Meszaros-এর ভাষায় প্রতিটি test-এর জন্য নতুন fixture হলো fresh fixture, আর কয়েকজনের ভাগের fixture shared fixture; দ্বিতীয়টি দ্রুত, কিন্তু “interacting tests” নামের smell-এর উৎস। একটি সত্যিকারের উদাহরণ, ইচ্ছা করে ভুল করে লেখা:

import pytest
from bazarghar.orders import Order

DEFAULT_ITEMS = [(500, 2)]                 # one shared, mutable list

@pytest.fixture(scope="module")
def basket():
    return Order(DEFAULT_ITEMS)

def test_add_oil(basket):
    basket.items.append((190, 1))
    assert basket.total() == 1190

def test_default_basket_is_1000(basket):
    assert basket.total() == 1000
$ uv run pytest -v leak/test_leak.py
leak/test_leak.py::test_add_oil PASSED                        [ 50%]
leak/test_leak.py::test_default_basket_is_1000 FAILED         [100%]

========================= FAILURES =========================
______________ test_default_basket_is_1000 ______________

basket = <bazarghar.orders.Order object at 0x…>

    def test_default_basket_is_1000(basket):
>       assert basket.total() == 1000
E       assert 1190 == 1000
E        +  where 1190 = total()
…
FAILED leak/test_leak.py::test_default_basket_is_1000 - assert 1190 == 1000
1 failed, 1 passed in 0.04s

$ uv run pytest -q "leak/test_leak.py::test_default_basket_is_1000"
.                                                       [100%]
1 passed in 0.01s

একই test, একা চালালে পাস। এই অবস্থায় সবচেয়ে সাধারণ ভুল ধারণা হলো “scope বদলে function করলেই সারবে”. lab-এ সেটিও সত্যিকারভাবে চালানো হয়েছে; নিচের stepper-এ পুরো গল্প:

শুরু: DEFAULT_ITEMS = [(500, 2)]
চলছে
DEFAULT
basket
ফল
  1. Basket তৈরি। Module scope, তাই ফাইলের দুটি test একই Order পাবে। আরও সূক্ষ্ম: Order.__init__ list-টি কপি না করে সরাসরি রাখে, তাই basket.items আর DEFAULT_ITEMS একই list-এর দুটি নাম।
  2. test_add_oil. ১৯০ টাকার তেল যোগ: ৫০০ × ২ + ১৯০ = ১১৯০, পাস। কিন্তু append সেই ভাগের list-টিকেই বদলাল; test শেষে কেউ তা ফেরাল না।
  3. দ্বিতীয় test. একই basket পেল, যাতে তেল এখনো আছে: assert 1190 == 1000. Failure-এর রিপোর্ট দ্বিতীয় test-কে দোষ দিচ্ছে, অথচ দোষী প্রথমটি; leak-এর সবচেয়ে বিভ্রান্তিকর দিক এটাই।
  4. একা চালানো। নতুন process, নতুন list, কোনো তেল নেই: পাস। “আমার কম্পিউটারে চলে” ধাঁচের রহস্যের এক বড় উৎস। একা পাস আর সবার সাথে ফেল হলে প্রথম সন্দেহ: shared state.
  5. শুধু scope বদল। @pytest.fixture (function scope) করে চালানো হলো: প্রতিটি test এখন নতুন Order পায়, তবু ফল একই, 1 failed, 1 passed, assert 1190 == 1000. কারণ নতুন Order-ও একই module-স্তরের list ধরে রাখে, আর প্রথম test সেটিই বদলেছে। Fixture নতুন, ডেটা পুরোনো।
  6. আসল সমাধান। Order(list(DEFAULT_ITEMS)): প্রতিবার নতুন copy, সাথে function scope. এখন 2 passed, আর DEFAULT_ITEMS কখনো বদলায় না। আরও ভালো: module-স্তরে বদলযোগ্য list না রেখে tuple রাখা, বা builder-এর মতো প্রতিবার নতুন বানানো। Production কোডের Order-ও নিজে copy রাখলে এই শ্রেণির ভুল সেখানেও কমত।

ধাপ ৫ আর ৬-এর সত্যিকারের আউটপুট, ফাইল দুটি শুধু fixture-এর লাইনে আলাদা:

$ uv run pytest -q leak/test_leak2.py        # scope=function only
.F                                                      [100%]
…
E       assert 1190 == 1000
…
1 failed, 1 passed in 0.04s
$ uv run pytest -q leak/test_leak3.py        # function scope + list(...) copy
..                                                      [100%]
2 passed in 0.01s

Leak খোঁজার যন্ত্র — test-এর ক্রম বদলে চালানো

বাস্তবে leak এত সহজে চোখে পড়ে না; suite-এ শত শত test, আর ডিফল্ট ক্রমে হয়তো দোষী test নির্দোষটির পরে চলে, তাই সব সবুজ। কৌশল হলো ক্রম বদলে চালানো। pytest-এর জন্য pytest-randomly-র মতো plugin প্রতিবার ক্রম এলোমেলো করে (আর seed ছাপে, যাতে একই ক্রম আবার চালানো যায়)। নিচের block একই কাজ ছোট করে করে: তিনটি test-এর ৬টি সম্ভাব্য ক্রম সবগুলো চালায়, ভাঙা আর সারানো দুই সংস্করণে।

import unittest
from itertools import permutations

DEFAULT_ITEMS = [(500, 2)]                      # module-level, mutable

class Order:
    def __init__(self, items): self.items = items
    def total(self): return sum(p * q for p, q in self.items)

class LeakyTest(unittest.TestCase):
    def setUp(self): self.basket = Order(DEFAULT_ITEMS)        # same list!
    def test_add_oil(self):
        self.basket.items.append((190, 1))
        self.assertEqual(self.basket.total(), 1190)
    def test_default_is_1000(self): self.assertEqual(self.basket.total(), 1000)
    def test_first_is_rice(self): self.assertEqual(self.basket.items[0], (500, 2))

class FixedTest(LeakyTest):
    def setUp(self): self.basket = Order(list(DEFAULT_ITEMS))  # fresh copy

names = ["test_add_oil", "test_default_is_1000", "test_first_is_rice"]
for case in (LeakyTest, FixedTest):
    print(case.__name__)
    for order in permutations(names):
        DEFAULT_ITEMS[:] = [(500, 2)]             # reset between runs
        result = unittest.TestResult()
        unittest.TestSuite(case(n) for n in order).run(result)
        failed = [t._testMethodName[5:] for t, _ in result.failures]
        print("  ", " > ".join(n[5:] for n in order), "| failed:", failed or "none")

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

LeakyTest
   add_oil > default_is_1000 > first_is_rice | failed: ['default_is_1000']
   add_oil > first_is_rice > default_is_1000 | failed: ['default_is_1000']
   default_is_1000 > add_oil > first_is_rice | failed: none
   default_is_1000 > first_is_rice > add_oil | failed: none
   first_is_rice > add_oil > default_is_1000 | failed: ['default_is_1000']
   first_is_rice > default_is_1000 > add_oil | failed: none
FixedTest
   add_oil > default_is_1000 > first_is_rice | failed: none
   add_oil > first_is_rice > default_is_1000 | failed: none
   default_is_1000 > add_oil > first_is_rice | failed: none
   default_is_1000 > first_is_rice > add_oil | failed: none
   first_is_rice > add_oil > default_is_1000 | failed: none
   first_is_rice > default_is_1000 > add_oil | failed: none

এখানে unittest-এর setUp প্রতিটি test-এ নতুন Order বানায় (pytest-এর function scope-এর সমতুল্য), তবু ভাঙা সংস্করণে ৬টির মধ্যে ৩টি ক্রমে ফেল: ঠিক যেসব ক্রমে add_oil চলে default_is_1000-এর আগে। first_is_rice কোনো ক্রমেই ভাঙেনি, কারণ সে শুধু প্রথম লাইন দেখে, যা append বদলায় না; অর্থাৎ leak সব test-কে ছোঁয় না, তাই সহজে লুকিয়ে থাকে। ডিফল্ট ক্রম (নাম অনুযায়ী বর্ণানুক্রম) এখানে ঘটনাচক্রে ভাঙা ক্রমগুলোর একটি; অন্য নামে হলে suite সবুজ থাকত। সারানো সংস্করণ ৬টি ক্রমেই পাস। দুটি ক্রম থেকে test-কে বিচার করা যায় না; সব বা অনেক ক্রমে চালালে তবেই isolation-এর প্রমাণ মেলে।

লুকানো ভাগের জিনিসলক্ষণপ্রতিকার
Module-স্তরের list/dict, class attributeএকা পাস, suite-এ ফেলপ্রতিবার নতুন copy; tuple বা frozen ডেটা
Mutable default argument (def f(items=[]))দ্বিতীয় ডাকে আগের মান থেকে যায়items=None, ভেতরে নতুন list
Module/session scope-এর database সারিসারির সংখ্যা ক্রম অনুযায়ী বদলায়প্রতি test transaction rollback বা মুছে ফেলা
Environment variable, global random.seed, cacheঅন্য ফাইলের test হঠাৎ অন্যরকম আচরণ করেmonkeypatch, নিজের random.Random, autouse reset
ফাইল আর ফোল্ডারআগের run-এর ফাইল পরের run-এ পাওয়া যায়tmp_path

আরও গভীরে: Luo ও সহকর্মীদের FSE ২০১৪-র গবেষণা (“An Empirical Analysis of Flaky Tests”) open-source প্রকল্পের flaky test-এর কারণ ভাগ করে দেখায় যে async অপেক্ষা আর concurrency-র পরেই test-এর ক্রমের ওপর নির্ভরতা বড় একটি শ্রেণি। একই বছর Zhang ও সহকর্মীরা (ISSTA ২০১৪) দেখান, “test-গুলো স্বাধীন” এই ধারণা বাস্তব প্রকল্পে প্রায়ই সত্য নয়, আর তা খোঁজার স্বয়ংক্রিয় উপায় প্রস্তাব করেন। Parallel run (pytest-xdist) isolation-কে আরও কঠিন পরীক্ষায় ফেলে: প্রতিটি worker আলাদা process, তাই session fixture প্রতি worker-এ একবার করে চলে, আর একই database বা ফাইলে দুই worker একসাথে লিখলে নতুন ধরনের সংঘাত হয়; প্রতিকার হলো প্রতি worker-এর আলাদা নাম বা আলাদা database. বড় suite-এ এর ব্যবস্থাপনা আসবে পর্ব ৬৮ (বড় test suite — selection, sharding, flake budget আর রক্ষণাবেক্ষণ)-এ।

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

  • pytest fixture-এর scope কয়টি, ডিফল্ট কোনটি? পাঁচটি: function, class, module, package, session; ডিফল্ট function.
  • Session fixture কি function fixture চাইতে পারে? না, ScopeMismatch; ছোট scope বড়টি চাইতে পারে, উল্টো নয়।
  • setUp মাঝপথে exception দিলে tearDown চলে? না; কিন্তু তার আগে নথিভুক্ত addCleanup চলে, উল্টো ক্রমে।
  • Test একা পাস, suite-এ ফেল — প্রথম সন্দেহ? Shared mutable state বা ক্রমের ওপর নির্ভরতা; ক্রম বদলে চালিয়ে নিশ্চিত হোন।
  • Builder আর object mother-এর পার্থক্য? Builder default দিয়ে শুরু করে প্রাসঙ্গিক অংশ বদলায়; object mother নাম দেওয়া তৈরি object দেয়, রূপ বাড়লে function বাড়ে।

৮ · AI-এর যুগে fixture আর test data

AI সহকারী fixture আর test data লিখতে খুব দ্রুত, আর ঠিক এখানে তার ভুলগুলোও খুব চেনা। সময় বাঁচাতে সব কিছু scope="session" করে দেয়, ফলে test একে অপরের ডেটা বদলায়; conftest-এ autouse fixture ছড়িয়ে দেয়, যা কেউ টের পায় না; এমন pytest option বা fixture বানিয়ে বলে যা নেই (যেমন Faker-এর locale বদলানোর “সহজ” কোনো flag); seed ছাড়া এলোমেলো ডেটা দেয়; test data-য় আসল মানুষের মতো নাম, ঠিকানা আর ফোন নম্বর বসায়; expected মান লেখে কোড পড়ে, requirement পড়ে নয়, ফলে ছাড়ের পরের টাকায় delivery বিচারের ভুলটি “সঠিক” বলে test-এ ঢুকে যায়; শুধু happy path; আর না চালিয়েই বলে “সব test পাস”.

AI-কে fixture নকশা করতে বললে scope-এর কারণ আর isolation-এর প্রমাণ চেয়ে নিন:

তুমি একজন অভিজ্ঞ SDET. নিচে বাজারঘরের orders.py, pricing.py আর ব্যবসার নিয়ম দিলাম। pytest-এর জন্য conftest.py আর একটি test data builder লিখে দাও। [নিয়ম পেস্ট করুন] [orders.py আর pricing.py পেস্ট করুন] শর্ত: ১. প্রতিটি fixture-এর scope লেখো আর এক লাইনে কারণ বলো; যে fixture test বদলাতে পারে, সেটি function scope হবে। ২. কোনো autouse fixture দিও না, যদি না আলাদা করে কারণ বলো। ৩. Builder-এর default এমন হবে যাতে কোনো ছাড় বা বিশেষ delivery নিয়ম না খাটে। ৪. প্রতিটি test-এর expected মান নিয়মের কোন বাক্য থেকে এলো, পাশে comment-এ লেখো। ৫. এলোমেলো ডেটা লাগলে random.Random(seed) ব্যবহার করো; আসল মানুষের মতো নাম বা ফোন নম্বর দিও না, id-তে TEST- উপসর্গ দাও। ৬. যেকোনো pytest option বা plugin-এর নাম দিলে docs-এর লিংক দাও; নিজে test চালানোর দাবি করো না।

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

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

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

প্র ০১দলের suite চলতে ২০ মিনিট লাগে। একজন প্রস্তাব দিলেন সব fixture session scope করে দিতে। কী বলবেন?

প্রস্তাবটির পেছনের সমস্যা সত্যি: ধীর suite মানে developer test চালানো কমিয়ে দেন, feedback দেরিতে আসে, আর শেষে কেউ লাল test-কে গুরুত্ব দেয় না। কিন্তু সমাধানটি ভুল জায়গায় হাত দিচ্ছে। Meszaros-এর xUnit Test Patterns (২০০৭) এই টানাপোড়েনকে দুই নামে বর্ণনা করে: fresh fixture (প্রতিটি test নতুন) আর shared fixture (অনেকে ভাগ করে)। Shared fixture দ্রুত, কিন্তু তার পরিচিত পরিণতি “interacting tests”: একটি test-এর পরিবর্তন অন্য test-এর ফল বদলায়, আর ভুল রিপোর্ট আসে নির্দোষ test-এর নামে। সব fixture session করলে suite হয়তো পাঁচ মিনিটে নামবে, কিন্তু সপ্তাহে কয়েকবার এমন ব্যর্থতা আসবে যা কেউ পুনরুৎপাদন করতে পারে না; সেগুলো খুঁজতে যে সময় যাবে, তা বাঁচানো সময়ের চেয়ে বেশি হতে পারে।

ভালো পথ মাপা দিয়ে শুরু: pytest --durations=10 দেখায় কোন test বা setup সবচেয়ে ধীর। প্রায়ই দেখা যায় সময় খায় অল্প কয়েকটি জিনিস: database তৈরি, migration চালানো, বড় ফাইল পড়া, network. তখন শুধু সেই ব্যয়বহুল আর অপরিবর্তনীয় অংশ বড় scope-এ নিন: session-এ database তৈরি আর schema, কিন্তু প্রতিটি test-এর ডেটা function scope-এ, test শেষে transaction rollback. যা test বদলায়, তা কখনো ভাগ নয়। এরপর parallel চালানো (pytest-xdist) বিবেচনা করুন, যা isolation ঠিক থাকলেই নিরাপদ।

আরেকটি প্রশ্ন জিজ্ঞেস করার মতো: এই test-গুলো কি আদৌ unit test? Unit test-এর setup সাধারণত মিলিসেকেন্ডের; ২০ মিনিট প্রায়ই বলে দেয় যে অনেক test আসলে integration test, যা database বা বাইরের service ছোঁয়। তাদের আলাদা করে আলাদা ধাপে চালানো, আর ব্যবসার নিয়ম (ছাড়, delivery) বিশুদ্ধ function-এ এনে দ্রুত unit test-এ ঢাকা, দীর্ঘমেয়াদি সমাধান; পর্ব ২৫-এ testable নকশা এই দিকেই যায়।

মূল উপলব্ধি: Scope গতি আর isolation-এর মধ্যে দর-কষাকষি। ব্যয়বহুল আর অপরিবর্তনীয় জিনিস ভাগ করুন, বদলযোগ্য জিনিস কখনো নয়; আর সিদ্ধান্তের আগে মাপুন।

প্র ০২xUnit-এর setUp/tearDown থাকতে pytest কেন নাম-ধরে-চাওয়া fixture বেছে নিল? এর লাভ আর দাম কী?

setUp/tearDown-এর ছাঁচ এসেছে Kent Beck-এর Smalltalk-এর test framework (SUnit, ১৯৯০-এর দশকের শুরুর দিকে) থেকে, তারপর ১৯৯৭ সালের দিকে Beck আর Erich Gamma-র JUnit হয়ে প্রায় প্রতিটি ভাষায়: Python-এর unittest-ও এই পরিবারের। মূল ভাবনা সরল: একটি class-এর সব test একই প্রস্তুতি পায়। সমস্যা দেখা দেয় বড় হলে। একটি class-এর দশটি test-এর তিনটির database লাগে, পাঁচটির নকল wallet, দুটির কিছুই না; তবু সবাই পুরো setUp চালায়। প্রস্তুতি ভাগ করতে উত্তরাধিকার (inheritance) লাগে, আর কয়েক স্তরের base class-এর পরে কেউ জানে না কোন test আসলে কী পাচ্ছে।

pytest (Holger Krekel-এর py.test থেকে বড় হওয়া) ভিন্ন পথ নেয়: প্রতিটি test parameter-এর নামে নিজের প্রয়োজন ঘোষণা করে। আগের সংস্করণে “funcarg” নামে এর শুরু; ২০১২ সালের অক্টোবরে pytest 2.3-এ আজকের @pytest.fixture এলো, scope, parametrization আর fixture-এর ভেতরে অন্য fixture চাওয়ার সুবিধাসহ। লাভ তিনটি। প্রথমত, যা লাগে শুধু তাই তৈরি হয়। দ্বিতীয়ত, ছোট fixture জুড়ে বড় প্রস্তুতি বানানো যায় (catalogue চায় db), উত্তরাধিকার ছাড়াই। তৃতীয়ত, test-এর signature নিজেই তার নির্ভরতার তালিকা, পড়লেই বোঝা যায়।

দাম কিন্তু আছে। নাম দেখে fixture কোথা থেকে এলো, বোঝা যায় না: একই ফাইলে, পাশের conftest-এ, ওপরের conftest-এ, নাকি কোনো plugin-এ? Autouse fixture থাকলে signature-ও আর পুরো সত্য বলে না, যা এই পর্বের Faker plugin-এর উদাহরণে দেখেছেন। তাই pytest নিজেই খোঁজার হাতিয়ার দেয়: --fixtures, --fixtures-per-test, --setup-show. দলগত নিয়ম যেমন “fixture-এর নামে আচরণ বলুন”, “এক নামের fixture একটিই” আর “autouse শুধু conftest-এর মাথায় comment-সহ” এই দাম কমায়।

মূল উপলব্ধি: কোনো ছাঁচ সব দিকে ভালো নয়; setUp স্পষ্ট কিন্তু অনমনীয়, fixture নমনীয় কিন্তু লুকানো। দলের নিয়ম আর tool দিয়ে দুর্বল দিকটি পুষিয়ে দিন।

প্র ০৩“Production-এর ডেটার একটি কপি staging-এ দিলেই সবচেয়ে বাস্তব test হয়” — এই যুক্তির সমস্যা কোথায়?

যুক্তিটির একটি সত্য দিক আছে: বাস্তব ডেটায় এমন অদ্ভুত জিনিস থাকে যা কেউ কল্পনা করে না: বাংলা আর ইংরেজি মেশানো ঠিকানা, তিন লাইনের নাম, বছর পুরোনো অর্ডার যার অবস্থা এখনকার নিয়মে নেই। এগুলো test-কে সত্যিকারের পরীক্ষায় ফেলে। কিন্তু দাম অনেক বড়। Test environment সাধারণত production-এর মতো সুরক্ষিত থাকে না: অনেক বেশি মানুষের প্রবেশাধিকার, log-এ পুরো request ছাপা, screenshot আর bug report-এ গ্রাহকের নাম আর ফোন নম্বর। বিশ্বজুড়ে অনেক ডেটা ফাঁসের ঘটনা ঘটেছে ঠিক এমন অরক্ষিত কপি থেকে। আইনের দিক থেকেও প্রশ্ন ওঠে: ইউরোপের GDPR (২০১৮ থেকে কার্যকর) ব্যক্তিগত তথ্যের ব্যবহারকে নির্দিষ্ট উদ্দেশ্য আর ন্যূনতম প্রয়োজনে সীমিত করার নীতি নেয়; গ্রাহক তাঁর তথ্য দিয়েছিলেন অর্ডারের জন্য, আপনার test-এর জন্য নয়। আপনার দেশের আর প্রতিষ্ঠানের নিয়ম আলাদা হতে পারে, কিন্তু নীতিটি সব জায়গায় প্রাসঙ্গিক।

বিকল্পগুলোর একটি স্তরবিন্যাস আছে। সবচেয়ে নিরাপদ synthetic data: নিয়ম থেকে বানানো, যেমন এই পর্বের seed দেওয়া generator, যা কারও তথ্য নয়। বাস্তবের বৈচিত্র্য দরকার হলে বাস্তব ডেটার বৈশিষ্ট্য মাপুন (নামের দৈর্ঘ্যের বণ্টন, কোন অক্ষর থাকে, অর্ডারের টাকার পরিসর) আর সেই অনুযায়ী generator বানান। একান্তই কপি লাগলে masking: নাম, ফোন, ঠিকানা, ইমেইল বদলে দেওয়া, এমনভাবে যাতে সম্পর্ক ঠিক থাকে (একই গ্রাহকের সব অর্ডারে একই নকল নাম), আর অল্প অংশ (subset) নেওয়া। এখানেও সতর্কতা আছে: গবেষকেরা বহুবার দেখিয়েছেন, কয়েকটি “নিরীহ” field মিলিয়ে মানুষকে আবার চেনা যায়, তাই masking-এর পরেও প্রবেশাধিকার সীমিত রাখা দরকার।

Faker-এর উদাহরণটি আরেকটি সূক্ষ্ম বিষয় দেখায়: “বাস্তবের মতো” মানেই “আপনার নিয়মে বৈধ” নয়। ২০০টি নকল ফোনের ২০০টিই বাজারঘরের নিয়ম ভেঙেছিল। Test data-র নকশা তাই সবসময় দুই ভাগ: নিয়ম মানা বৈধ ডেটা, আর ইচ্ছা করে নিয়ম-ভাঙা অবৈধ ডেটা।

মূল উপলব্ধি: Test data-ও ব্যক্তিগত তথ্যের দায়িত্বের অংশ। আগে synthetic, তারপর masking, আসল কপি শেষ বিকল্প, আর সব ক্ষেত্রে প্রবেশাধিকার সীমিত।

প্র ০৪একটি test একা চালালে পাস, CI-তে মাঝে মাঝে ফেল। কোড বদলায়নি। কীভাবে খুঁজবেন?

এটি flaky test-এর সবচেয়ে পরিচিত রূপগুলোর একটি, আর গবেষণা বলে এর পেছনে প্রায়ই test-এর ক্রম। Qingzhou Luo, Darko Marinov ও সহকর্মীদের FSE ২০১৪-র “An Empirical Analysis of Flaky Tests” কয়েকটি বড় open-source প্রকল্পের flaky test-এর সংশোধন বিশ্লেষণ করে কারণগুলো শ্রেণিতে ভাগ করে; সবচেয়ে সাধারণ শ্রেণিগুলোর মধ্যে ছিল async অপেক্ষা, concurrency আর test-এর ক্রমের ওপর নির্ভরতা। একই বছর Sai Zhang ও সহকর্মীদের ISSTA ২০১৪-র কাজ দেখায় “test-গুলো একে অপরের থেকে স্বাধীন” ধারণাটি বাস্তবে প্রায়ই ভাঙে, আর ক্রম বদলে চালিয়ে এমন নির্ভরতা স্বয়ংক্রিয়ভাবে খোঁজা যায়।

খোঁজার ধাপ। এক, ক্রম ধরুন: CI-তে test কোন ক্রমে চলেছিল? Parallel চললে কোন worker-এ, তার আগে কোন test? দুই, ক্রম বদলে স্থানীয়ভাবে চালান: পুরো ফাইল, উল্টো ক্রম, বা pytest-randomly-র মতো plugin দিয়ে এলোমেলো ক্রম, আর ব্যর্থ ক্রমের seed লিখে রাখুন। তিন, ব্যর্থ ক্রম পেলে অর্ধেক অর্ধেক করে ছাঁটুন (bisect): আগের test-গুলোর কোন অর্ধেক থাকলে ফেল হয়? কয়েক ধাপেই দোষী test বেরিয়ে আসে, এই পর্বের add_oil-এর মতো। চার, দোষীর ভেতরে খুঁজুন কী ভাগের জিনিস বদলাচ্ছে: module-স্তরের list, class attribute, environment variable, global seed, database-এর সারি, ফাইল, cache, এমনকি ঘড়ি।

ক্রম ছাড়া অন্য সন্দেহও আছে: সময়-নির্ভর কোড (রাত ১২টার আশেপাশে তারিখ বদলায়, UTC আর বাংলাদেশ সময়ের ৬ ঘণ্টার পার্থক্য), seed-হীন এলোমেলো ডেটা, নেটওয়ার্ক, আর parallel worker-দের একই ফাইলে লেখা। সংশোধনের পরে প্রমাণ চাই: এলোমেলো ক্রমে অনেকবার চালিয়ে একবারও ফেল না হওয়া। “retry দিয়ে সবুজ করা” সমাধান নয়, লক্ষণ ঢাকা।

মূল উপলব্ধি: “একা পাস, সবার সাথে ফেল” প্রায় সবসময় ভাগের অবস্থার সংকেত। ক্রম বদলে পুনরুৎপাদন, bisect দিয়ে দোষী খোঁজা, আর fresh fixture দিয়ে সারানো।

প্র ০৫Autouse fixture কি “জাদু”, যা এড়ানো উচিত? কখন এটি সঠিক হাতিয়ার?

Python-এর দর্শনের পরিচিত বাক্য “Explicit is better than implicit” (Tim Peters-এর “The Zen of Python”, PEP 20) autouse-এর বিরুদ্ধে সবচেয়ে সহজ যুক্তি: যা চলছে তা test-এ লেখা থাকা উচিত। Meszaros-এর “mystery guest” smell একই কথা বলে: test-এর ফল এমন কিছুর ওপর নির্ভর করলে যা test-এ দেখা যায় না, ব্যর্থতার কারণ খুঁজতে পাঠককে অন্য ফাইলে গোয়েন্দাগিরি করতে হয়। এই পর্বের lab-এ আমরা নিজে কোনো autouse লিখিনি, তবু Faker install করতেই একটি autouse fixture প্রতিটি test-এ ঢুকে গেল: নিজের অজান্তে।

তবে autouse-এর ন্যায্য জায়গাও আছে, আর সেগুলোর একটি মিল আছে: কাজটি প্রতিটি test-এর জন্য সত্যিই দরকারি, আর test-এর আচরণের অংশ নয়, বরং নিরাপত্তা বা পরিচ্ছন্নতার বেড়া। উদাহরণ: প্রতিটি test-এর আগে একটি in-memory cache খালি করা; নিশ্চিত করা যে কোনো test ভুলেও আসল mobile-wallet বা ইমেইল সার্ভারে অনুরোধ পাঠাবে না (network বন্ধ করে দেওয়া); global random-এর seed প্রতি test-এ নির্দিষ্ট করা; timezone একটি নির্দিষ্ট মানে বেঁধে রাখা। এগুলো ভুলে যাওয়ার খরচ বড়, আর প্রতিটি test-এ নাম লেখার কোনো তথ্যগত মূল্য নেই।

উল্টো দিকে, test-এর ডেটা বা অবস্থা তৈরি (একটি অর্ডার, একজন গ্রাহক, পণ্যের তালিকা) কখনো autouse হওয়া উচিত নয়, কারণ সেটিই test-এর গল্প। দলগত অভ্যাস যা সাহায্য করে: autouse fixture শুধু conftest-এর ওপরে, প্রত্যেকটির পাশে comment-এ কারণ; নিয়মিত --setup-show দেখে অপ্রত্যাশিত নাম খোঁজা; আর plugin যোগ করলে সে কী fixture আনে, --fixtures দিয়ে দেখা। Parallel চালালে সতর্কতা আরও বেশি: session-scope autouse প্রতি worker-এ আলাদা চলে, তাই “একবার” মানে আসলে “worker-প্রতি একবার”।

মূল উপলব্ধি: Autouse বেড়ার জন্য, গল্পের জন্য নয়। যা প্রতিটি test-কে রক্ষা করে তা autouse হতে পারে; যা একটি test-এর অর্থ তৈরি করে তা অবশ্যই test-এ নাম ধরে লেখা থাকবে।

অনুশীলন

উত্তর দেখার আগে খাতায় নিজের উত্তর লিখুন।

  1. Spec থেকে fixture আর test data নকশা: বাজারঘরের “রিভিউ আর রেটিং” feature-এর নিয়ম: AC1 শুধু delivered অর্ডারের পণ্যে রিভিউ; AC2 তারা ১–৫, পূর্ণসংখ্যা; AC3 লেখা ছাঁটার পরে ১০–৫০০ অক্ষর; AC4 একজন গ্রাহক এক পণ্যে একটিই রিভিউ; AC5 গড় এক দশমিকে, half up. এই test-গুলোর জন্য কোন কোন fixture বানাবেন, প্রতিটির scope কী, আর builder-এর default কী হবে? অন্তত ছয়টি test-এর তালিকা দিন, কোনটি কোন fixture ব্যবহার করে তাসহ।

    একটি যুক্তিসঙ্গত নকশা (একমাত্র সঠিক উত্তর নয়):

    • review_store — function scope: রিভিউ জমা হয় আর AC4 যাচাইয়ে আগের রিভিউ লাগে, তাই প্রতিটি test-এ খালি store. Session scope হলে AC4-এর test অন্য test-এর রিভিউ দেখে ভুল ফল দিত।
    • make_order — factory fixture, function scope: AC1-এর জন্য delivered আর shipped দুই অবস্থার অর্ডার লাগে, আসল advance() দিয়ে।
    • a_review() builder — default: তারা ৪, লেখা ঠিক ২০ অক্ষরের সাধারণ বাক্য, delivered অর্ডার, নতুন গ্রাহক; কোনো সীমার কাছাকাছি নয়।
    • product_catalogue — module scope হতে পারে, কারণ test-গুলো শুধু পড়ে।

    Test-এর তালিকা: (১) delivered অর্ডারে রিভিউ গৃহীত — make_order("delivered"), review_store; (২) shipped অর্ডারে প্রত্যাখ্যাত — make_order("shipped"); (৩) তারা ০ আর ৬ প্রত্যাখ্যাত, ১ আর ৫ গৃহীত — builder-এ শুধু তারা বদল, parametrize; (৪) লেখা ৯ আর ৫০১ অক্ষর প্রত্যাখ্যাত, ১০ আর ৫০০ গৃহীত, দুই প্রান্তে ফাঁকা জায়গা দিয়ে ছাঁটা যাচাই — builder-এ শুধু লেখা বদল (পর্ব ০৮-এর সীমা); (৫) একই গ্রাহকের দ্বিতীয় রিভিউ প্রত্যাখ্যাত — একই review_store-এ দুবার জমা; (৬) গড় 4.25 থেকে 4.3 (half up) — review_store-এ ৪টি তারা-মান, যেমন 4, 4, 4, 5 (গড় ৪.২৫)। প্রতিটি test-এ builder-এর ঠিক একটি অংশ বদলায়, তাই নাম আর উদ্দেশ্য মেলে।

  2. আউটপুট অনুমান করুন: নিচের ফাইলটি pytest -q -s দিয়ে চালালে কী ছাপা হবে, ক্রমসহ লিখুন।
    @pytest.fixture(scope="module")
    def stock():
        print("\n+stock", end="")
        yield {"chal": 50}
        print("\n-stock", end="")
    
    @pytest.fixture
    def cart(stock):
        print("\n+cart", end="")
        yield []
        print("\n-cart", end="")
    
    def test_one(cart):
        print("\n test_one", end="")
    
    def test_two(stock, cart):
        print("\n test_two", end="")

    সত্যিকারের run (pytest 9.2.0):

    +stock
    +cart
     test_one.
    -cart
    +cart
     test_two.
    -cart
    -stock
    2 passed in 0.01s

    stock module scope, তাই একবার তৈরি, ফাইলের শেষে একবার ভাঙা। cart function scope, তাই প্রতিটি test-এর আগে-পরে। test_two নিজে stock চাইলেও নতুন stock হয় না, আগেরটিই পায়। শেষে ভাঙার ক্রম উল্টো: -cart আগে, -stock পরে। বিন্দু (.) এসেছে test পাস করার চিহ্ন হিসেবে, test-এর print-এর ঠিক পরে।

  3. Test-এ বাগ খুঁজুন: নিচের builder দিয়ে লেখা দুটি test. দ্বিতীয়টি একা চালালে পাস, ফাইলসহ চালালে assert 590 == 190. দোষ কোথায়, আর কীভাবে সারাবেন?
    class CartBuilder:
        def __init__(self, items=[]):
            self.items = items
        def add(self, price, qty=1):
            self.items.append((price, qty))
            return self
        def total(self):
            return sum(p * q for p, q in self.items)
    
    def test_rice_only():
        assert CartBuilder().add(80, 5).total() == 400
    
    def test_oil_only():
        assert CartBuilder().add(190).total() == 190

    দোষ items=[]: Python-এ default argument একবারই তৈরি হয়, function সংজ্ঞায়িত হওয়ার সময়; তাই প্রতিটি CartBuilder() একই list পায়। প্রথম test সেখানে ৮০ × ৫ যোগ করে রেখে গেছে, দ্বিতীয় test ১৯০ যোগ করে পায় ৪০০ + ১৯০ = ৫৯০. সত্যিকারের run-এ ঠিক এই বার্তা: E assert 590 == 190, 1 failed, 1 passed. এটি §৭-এর shared mutable state, শুধু fixture-এর বদলে Python-এর ভাষার নিয়ম থেকে।

    সংশোধন: def __init__(self, items=None): আর self.items = list(items) if items else []. লক্ষ করুন বাগটি production কোডে নয়, test-এর helper-এ; তাই test-এর helper-ও কোড, তারও review লাগে।

  4. ব্যর্থতার রিপোর্ট পড়ুন: সহকর্মী test database-এর রিপোর্ট বানাতে session fixture লিখেছেন, আর suite চালাতেই এলো: ScopeMismatch: You tried to access the function scoped fixture cart with a session scoped request object. Fixture-টি def shared_report(cart). এর মানে কী, test-এর ফলাফলে কোন অক্ষর দেখাবে, আর দুটি সম্ভাব্য সমাধান কী?

    Session scope-এর shared_report পুরো run-এ একবার তৈরি হবে, কিন্তু সে চাইছে function scope-এর cart, যা প্রতি test-এ আলাদা। কোন test-এর cart নেবে? উত্তর নেই, তাই pytest প্রস্তুতিতেই থামায়। Test-এর কোড চলেনি, তাই ফলাফলে E (error), F নয়; সত্যিকারের run-এ 1 error আর “ERROR at setup of test_report”.

    সমাধান: (ক) রিপোর্ট সত্যিই প্রতি test-এর cart-নির্ভর হলে shared_report-কেও function scope করুন। (খ) রিপোর্ট যদি সবার জন্য একটি হওয়ার কথা হয়, তাহলে তার cart-নির্ভরতা সরান: session-এ শুধু খালি রিপোর্ট-কাঠামো, আর প্রতিটি test নিজের cart থেকে তাতে লিখবে, কিংবা cart-কেও session স্তরের কোনো অপরিবর্তনীয় জিনিস দিয়ে বদলান। cart-কে session scope বানিয়ে দেওয়া সবচেয়ে খারাপ সমাধান: সব test একই বদলযোগ্য cart ভাগ করবে।

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

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

ক্রমএকটি unittest class-এ একটিমাত্র test পাস করলে hook-গুলো কোন ক্রমে চলে? সাজান (▲▼ চেপে সরান)

  1. setUpClass
  2. setUp (ভেতরে addCleanup নথিভুক্ত)
  3. test method
  4. tearDown
  5. addCleanup-এর কাজ
  6. tearDownClass

একটি pytest ফাইলে তিনটি test, প্রতিটি একটি module-scope fixture catalogue আর একটি function-scope fixture order চায়। ফাইলটি চালালে fixture দুটি কতবার তৈরি হবে?

  • catalogue ৩ বার, order ৩ বার
  • catalogue ১ বার, order ৩ বার
  • catalogue ১ বার, order ১ বার
  • catalogue ৩ বার, order ১ বার

unittest-এ একটি test-এর setUp দুটি addCleanup নথিভুক্ত করার পরে exception দিল। কোনটি সত্য?

  • test method চলে না, কিন্তু tearDown চলে
  • কিছুই চলে না, পুরো class থেমে যায়
  • test method আর tearDown চলে না, দুটি cleanup উল্টো ক্রমে চলে
  • test method চলে, তারপর cleanup

একটি session-scope fixture একটি function-scope fixture-কে parameter হিসেবে চাইলে pytest কী করে?

  • ScopeMismatch error দেয়, test-এর ফল E
  • function fixture-কে চুপচাপ session scope বানিয়ে নেয়
  • প্রথম test-এর মান নিয়ে বাকি সবাইকে দেয়
  • শুধু warning দিয়ে চালিয়ে যায়

একটি test একা চালালে পাস করে, কিন্তু পুরো suite-এর সাথে চালালে ফেল করে; কোড বদলায়নি। সবচেয়ে সম্ভাব্য কারণ কোনটি?

  • Test-এর assertion-এ ভুল expected মান
  • Fixture-এর scope function হওয়া
  • pytest-এর version পুরোনো হওয়া
  • আগে চলা কোনো test-এর রেখে যাওয়া shared mutable state

Test data builder-এর default মান কেমন হওয়া উচিত?

  • যতটা সম্ভব সীমার কাছাকাছি, যাতে বেশি ভুল ধরা পড়ে
  • বৈধ আর সাদামাটা, যাতে কোনো বিশেষ নিয়ম না খাটে
  • প্রতিবার এলোমেলো, seed ছাড়া
  • Production-এর একজন আসল গ্রাহকের তথ্য

একটি test-কে invoice ফাইল লেখার কোড যাচাই করতে হবে, যা ফোল্ডার পায় environment variable INVOICE_DIR থেকে। আসল ফোল্ডার না ছুঁয়ে আর পরের test-এ কোনো প্রভাব না রেখে করতে কোন pytest fixture দুটি সবচেয়ে উপযুক্ত?

  • capsys আর caplog
  • tmp_path_factory আর হাতে os.environ বদলানো
  • tmp_path আর monkeypatch
  • request আর caplog

শব্দকোষ

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

মনে রাখুন

  1. Fixture = শুরুর অবস্থা + পরিষ্কার। unittest-এ setUp/tearDown/addCleanup, pytest-এ নাম ধরে চাওয়া fixture, yield-এর পরে teardown.
  2. Scope: function (ডিফল্ট) < class < module < package < session. বড় scope আগে তৈরি, পরে ভাঙে; ছোট scope বড়টি চাইতে পারে, উল্টো নয়।
  3. Teardown উল্টো ক্রমে, আর addCleanup setUp ভাঙলেও চলে; --setup-show দিয়ে নিজের চোখে ক্রম দেখুন।
  4. Test data: সাদামাটা default-এর builder, দরকারমতো object mother আর factory fixture; এলোমেলো হলে seed বাঁধা, আসল মানুষের তথ্য কখনো নয়।
  5. Isolation: যা test বদলায় তা কখনো ভাগ নয়; scope বদলানো যথেষ্ট নয়, নতুন copy লাগে; ক্রম বদলে চালিয়ে প্রমাণ নিন।

পরের পর্বে: এতক্ষণ test-এর জন্য আসল জিনিস বানিয়েছেন। কিন্তু mobile-wallet-এর মতো বাইরের service-এ test থেকে আসল অনুরোধ পাঠানো যায় না। পর্ব ২৪-এ unittest.mock দিয়ে নকল সহযোগী, patch কোথায় বসাতে হয়, আর এত mock যে আসল কিছুই test হয় না, সেই ফাঁদ।

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

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