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

Integration testing — কৌশল, test database আর Testcontainers

Integration Testing: Strategies, Test Databases and Testcontainers

Taught in Bangla, this lesson covers interface defects that only integration tests catch, big-bang, top-down, bottom-up and sandwich strategies with stubs and drivers, and deciding what to keep real or fake. In-page Python and SQL show per-test transaction rollback and savepoints, and the page explains Testcontainers. A real pytest 9.2.0 and httpx 0.28.1 run tests the local Bazarghar FastAPI app from checkout to delivered status, and skipping the reset makes one then two tests fail.

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

  • Interface-এর কোন ধরনের ভুল শুধু integration test-এ ধরা পড়ে, তা চিনে নেওয়া
  • Big-bang, top-down, bottom-up আর sandwich কৌশলের ক্রম, stub আর driver-এর হিসাব করা
  • প্রতিটি নির্ভরতার জন্য আসল না নকল, সেই সিদ্ধান্ত যুক্তি দিয়ে নেওয়া
  • Test database আলাদা রাখার কৌশল বেছে নেওয়া: নতুন ফাইল, per-test rollback, savepoint, reset endpoint আর Testcontainers
  • pytest আর httpx দিয়ে একটি চালু app-এর checkout থেকে order-এর অবস্থা পর্যন্ত integration test লেখা, আর flaky হওয়ার কারণ খুঁজে বের করা

১ · Integration test কীসের জন্য — জোড়ের ভুল

মডিউল ৪-এ আপনি বাজারঘরের প্রতিটি অংশ আলাদা করে test করেছেন: coupon-এর নিয়ম, order-এর অবস্থা, review-এর শর্ত। পর্ব ২৪-এ wallet-এর জায়গায় mock বসিয়েছেন, পর্ব ২৫-এ শিখেছেন কীভাবে নির্ভরতাগুলো বাইরে থেকে দিতে হয়। এখন প্রশ্ন বদলায়: প্রতিটি অংশ নিজে ঠিক, কিন্তু জোড়া লাগালে কি ঠিক থাকে?

মোবাইল রিচার্জের দোকানের কথা ভাবুন। দোকানের app ক্রেতার কাছ থেকে টাকা নিল, রসিদ ছাপল: নিজের দিক থেকে নিখুঁত। অপারেটরের system-ও নিখুঁত: সঠিক নম্বর পেলে সঙ্গে সঙ্গে রিচার্জ দেয়। কিন্তু দোকানের app নম্বর পাঠায় +8801712… আকারে, আর অপারেটর চায় 01712…. দুই পক্ষই নিজের test-এ সবুজ, অথচ ক্রেতার ফোনে টাকা ঢোকে না। ভুলটি কোনো এক অংশে নয়, দুই অংশের মাঝখানে। Integration test ঠিক সেই মাঝখানটি দেখে।

পর্ব ০৫-এ integration-কে একটি test level হিসেবে দেখেছেন, দুই রূপে: নিজের system-এর ভেতরের অংশগুলোর জোড় (component integration testing), আর নিজের system আর বাইরের system-এর জোড় (system integration testing). এই পর্বের বেশিরভাগ কাজ প্রথমটি নিয়ে: বাজারঘরের API, service, দামের নিয়ম আর database একসাথে। বাইরের wallet আর courier-এর জোড় আসবে পর্ব ৩২ (Contract testing — consumer-driven contract আর Pact) আর পর্ব ৩৪ (Service virtualization — mock server আর নির্ভরতা আলাদা করা)-এ। Test pyramid-এ integration-এর জায়গা আর চারটি কৌশলের সংক্ষিপ্ত পরিচয় পাবেন সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৫১-এ; এখানে আমরা হাতে-কলমে, অনেক গভীরে যাব।

জোড়ের ভুলের (interface defect) চেনা কয়েকটি ধরন, বাজারঘরের উদাহরণে:

ধরনবাজারঘরে কেমনMock-ভিত্তিক unit test কেন মিস করে
Field-এর নাম বা আকারService পাঠায় delivery_charge, repository পড়ে deliveryMock যেকোনো নামের dict সানন্দে নেয়
এককএক অংশ টাকায়, আরেক অংশ পয়সায় (১৮০০ বনাম ১৮০০০০)দুই পাশের test নিজের এককে সবুজ
মানের বানানService লেখে "PLACED", database মানে শুধু 'placed'Mock-এর কোনো CHECK নেই
Constraintএকই ক্রেতার দ্বিতীয় review-তে UNIQUE, স্টক শূন্যের নিচে নামলে CHECKনিয়মটি থাকে database-এ, কোডে নয়
Transaction-এর সীমাOrder-এর সারি জমা হলো, কিন্তু স্টক কমার আগেই ভুল: অর্ধেক কাজ থেকে গেলMock-এ “অর্ধেক জমা” বলে কিছু নেই
Encoding আর ধরনবাংলা ঠিকানা, "5" বনাম 5, তারিখের time zonePython-এর ভেতরে সব ঠিক থাকে; ভুল হয় JSON বা SQL-এ যাওয়ার পথে
Wiring আর configভুল port, ভুল database ফাইল, test mode বন্ধUnit test কখনো আসল জোড়া-লাগানো কোড চালায় না

একটি উদাহরণ নিজে চালিয়ে দেখুন। নিচের block-এ দুটি সত্যিকারের module: OrderRepo, যা একটি আসল SQLite database-এ order লেখে, আর Checkout, যা দাম হিসাব করে repository-কে order দেয়। প্রথম test Checkout-কে একটি mock repository দিয়ে চালায়; দ্বিতীয়টি দুটি module জোড়া দিয়ে memory-তে থাকা SQLite-এ (:memory:) চালায়:

import os, sys, pytest
d = "/home/pyodide/p28a"; os.makedirs(d, exist_ok=True); os.chdir(d)
sys.path.insert(0, d)
for m in ("orders_repo", "checkout28", "test_wiring"): sys.modules.pop(m, None)
open("orders_repo.py", "w").write('''
SCHEMA = """CREATE TABLE orders (id INTEGER PRIMARY KEY, customer TEXT,
  total INTEGER, status TEXT CHECK (status IN
  ('placed','paid','packed','shipped','delivered','cancelled','refunded')));"""
class OrderRepo:                         # talks to a real SQLite connection
    def __init__(self, conn): self.conn = conn
    def save(self, o):
        sql = "INSERT INTO orders (customer, total, status) VALUES (?, ?, ?)"
        return self.conn.execute(sql, (o["customer"], o["total"], o["status"])).lastrowid''')
open("checkout28.py", "w").write('''
class Checkout:
    def __init__(self, repo): self.repo = repo
    def place(self, customer, subtotal):     # Dhaka rule only, for brevity
        total = subtotal - (0 if subtotal <= 1000 else min(subtotal // 10, 300))
        total += 0 if subtotal >= 2000 else 60
        return self.repo.save({"customer": customer, "status": "PLACED",
                               "total": total})''')
open("test_wiring.py", "w").write('''
import sqlite3; from unittest import mock
from checkout28 import Checkout; from orders_repo import OrderRepo, SCHEMA
def test_unit_with_mock_repo():
    repo = mock.Mock(); repo.save.return_value = 8
    assert Checkout(repo).place("mitu", 2000) == 8
    assert repo.save.call_args.args[0]["total"] == 1800
def test_integration_with_real_sqlite():
    conn = sqlite3.connect(":memory:"); conn.executescript(SCHEMA)
    Checkout(OrderRepo(conn)).place("mitu", 2000)
    row = conn.execute("SELECT total, status FROM orders").fetchone()
    assert row == (1800, "placed")''')
pytest.main(["-v", "--no-header", "--tb=short", "-p", "no:cacheprovider",
             "test_wiring.py"])

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

============================= test session starts ==============================
collecting ... collected 2 items

test_wiring.py::test_unit_with_mock_repo PASSED                          [ 50%]
test_wiring.py::test_integration_with_real_sqlite FAILED                 [100%]

=================================== FAILURES ===================================
______________________ test_integration_with_real_sqlite _______________________
test_wiring.py:10: in test_integration_with_real_sqlite
    Checkout(OrderRepo(conn)).place("mitu", 2000)
checkout28.py:7: in place
    return self.repo.save({"customer": customer, "status": "PLACED",
orders_repo.py:9: in save
    return self.conn.execute(sql, (o["customer"], o["total"], o["status"])).lastrowid
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E   sqlite3.IntegrityError: CHECK constraint failed: status IN
E     ('placed','paid','packed','shipped','delivered','cancelled','refunded')
=========================== short test summary info ============================
FAILED test_wiring.py::test_integration_with_real_sqlite - sqlite3.IntegrityE...
========================= 1 failed, 1 passed in 0.08s ==========================

Mock-এর test সবুজ: Checkout ঠিক ১৮০০ টাকা হিসাব করেছে আর save ডেকেছে, mock-এর কাছে এর বেশি জানার কিছু নেই। একই কোড আসল SQLite-এর সাথে জোড়া দিতেই sqlite3.IntegrityError: CHECK constraint failed. Database-এর schema বলছে order-এর অবস্থা ছোট হাতের সাতটি শব্দের একটি (পর্ব ১০-এর state machine), আর service পাঠাচ্ছে "PLACED". দুই module-ই নিজের দিক থেকে “ঠিক”; ভুলটি দুজনের চুক্তিতে। Traceback-এর তিনটি লাইন জোড়ের পথটিও দেখায়: test থেকে checkout28.py, সেখান থেকে orders_repo.py, তারপর SQLite. লক্ষ করুন, এই test-এর কোনো network বা server লাগেনি। Integration test মানেই ধীর, ভারী test নয়; মানে আসল জোড়।

দুটি শব্দ মনে রাখুন। Narrow integration test নিজের কোডের শুধু সেই অংশ যাচাই করে, যা একটি বাইরের জিনিসের (এখানে database) সাথে কথা বলে: ছোট, দ্রুত, ভাঙলে কারণ স্পষ্ট। Broad integration test অনেক অংশ চালু অবস্থায় জোড়া দিয়ে পুরো পথ চালায়: আস্থা বেশি, কিন্তু ধীর, আর কারণ খুঁজতে সময় লাগে। §৬-এর run দ্বিতীয় ধরনের। ভালো suite-এ দুটিই থাকে, প্রথমটি বেশি।

২ · জোড়া লাগানোর কৌশল — big-bang থেকে sandwich

একটি system-এ অনেক module থাকলে প্রশ্ন ওঠে, কোন ক্রমে জোড়া লাগাবেন আর test করবেন। নিচের ছবিতে বাজারঘরের checkout-এর module-গুলো স্তরে স্তরে সাজানো। ওপরে API-র route, যা HTTP request নেয়; মাঝে Shop service, যা কাজের ক্রম ঠিক করে; নিচে তিনটি অংশ: দামের pure নিয়ম, SQLite-এর database স্তর আর নকল payment gateway.

বাজারঘরের checkout — module-এর স্তর

ওপর থেকে নিচে ডাক যায়; প্রতিটি তীর একটি জোড়, আর প্রতিটি জোড় একটি integration-এর প্রশ্ন

Module layers of the বাজারঘর checkout: API route, Shop service, and rules, db and wallet below API route POST /api/orders Shop service place_order() rules দামের নিয়ম pure db SQLite আসল ফাইল wallet নকল gateway তৃতীয় পক্ষ top-down: ওপর থেকে নিচে stub bottom-up: নিচ থেকে ওপরে driver
ছবি ২৮.১ — চারটি তীর মানে চারটি জোড়: API→Shop, Shop→rules, Shop→db, Shop→wallet. Top-down কৌশল ওপর থেকে নামে, নিচের না-জোড়া অংশে stub বসায়; bottom-up নিচ থেকে ওঠে, ওপরের ডাকার অংশের জায়গায় driver লেখে।

চারটি পরিচিত কৌশল:

কৌশলকীভাবেকী লাগেসুবিধাঅসুবিধা
Big-bangসব module তৈরি হলে একবারে সব জোড়াকোনো stub বা driver নয়ছোট system-এ সহজ, পরিকল্পনা কমব্যর্থ হলে কোন জোড়ে ভুল, বলা কঠিন; শেষ মুহূর্তে সব ভুল একসাথে
Top-downওপরের নিয়ন্ত্রক module থেকে শুরু, ধাপে ধাপে নিচেনিচের না-জোড়া module-এর stubমূল প্রবাহ আর নকশার ভুল আগে দেখা যায়; একটি চলমান কঙ্কাল আগে পাওয়া যায়অনেক stub লিখতে হয়; নিচের আসল আচরণ (database) দেরিতে আসে
Bottom-upসবচেয়ে নিচের module থেকে শুরু, ধাপে ধাপে ওপরেওপরের ডাকার অংশের জায়গায় driverDatabase আর হিসাবের মতো ভিতের অংশ আগে পাকা হয়; stub কমপুরো প্রবাহ শেষে দেখা যায়; ব্যবহারকারীর চোখে দেখা দেরিতে
Sandwich (hybrid)ওপর থেকে আর নিচ থেকে একসাথে, মাঝের স্তরে মিলনকিছু stub, কিছু driverবড় system-এ দুই দল সমান্তরালে কাজ করতে পারেমাঝের স্তরটি সবচেয়ে দেরিতে পূর্ণ test পায়

Stub আর driver দুটিই test double-এর আত্মীয়। Stub ডাক গ্রহণ করে আর আগে থেকে ঠিক করা উত্তর দেয় (পর্ব ২৪-এ দেখেছেন)। Driver ডাক পাঠায়: ওপরের যে অংশ এখনো জোড়া হয়নি, তার হয়ে নিচের module-কে ডাকে আর ফল মেলায়। আজকের pytest test function নিজেই সবচেয়ে সাধারণ driver. নিচের stepper-এ একই ছবিতে দুই কৌশলের ক্রম দেখুন।

Top-down · ধাপ ১শুধু API আসল
API route : আসল
└ Shop    : stub
  (ঠিক করা order দেয়)

test → POST /api/orders
→ 201 আসে কি?
Top-down · ধাপ ২Shop যোগ হলো
API route : আসল
└ Shop    : আসল
  ├ rules  : stub → 1800
  ├ db     : stub → id 8
  └ wallet : stub → "T-1"
Top-down · ধাপ ৩নিচের আসল অংশ
API route : আসল
└ Shop    : আসল
  ├ rules  : আসল
  ├ db     : আসল SQLite
  └ wallet : নকল gateway
             (সবসময় নকল)
Bottom-up · ধাপ ১নিচের স্তর আগে
driver → rules.quote
         (2000, "Dhaka")
driver → db: INSERT, SELECT
driver → wallet adapter
         → নকল gateway

ওপরের কিছু এখনো নেই
Bottom-up · ধাপ ২Shop যোগ হলো
driver → Shop.place_order
  ├ rules  : আসল
  ├ db     : আসল SQLite
  └ wallet : নকল gateway

API route এখনো নেই
Bottom-up · ধাপ ৩সব জোড়া
test → API route : আসল
└ Shop    : আসল
  ├ rules  : আসল
  ├ db     : আসল SQLite
  └ wallet : নকল gateway
একই শেষ ছবি, ভিন্ন পথ
  1. Top-down, প্রথম ধাপ। শুধু API-র route আসল। Shop-এর জায়গায় একটি stub, যা সবসময় একই order ফেরত দেয়। এই ধাপের প্রশ্ন: request-এর আকার, login আর উত্তরের status code ঠিক আছে কি? Stub: ১টি।
  2. Top-down, দ্বিতীয় ধাপ। আসল Shop জোড়া হলো; তার নিচের তিনটি অংশ এখন stub: দাম সবসময় ১৮০০, database সবসময় id ৮, wallet সবসময় "T-1". প্রশ্ন: Shop কাজগুলো সঠিক ক্রমে ডাকে কি? Stub: ৩টি।
  3. Top-down, তৃতীয় ধাপ। দামের নিয়ম আর SQLite আসল হলো। এখন প্রথমবার আসল schema, constraint আর transaction দেখা যায়; §১-এর "PLACED"-এর মতো ভুল এখানে ধরা পড়ে। Wallet তৃতীয় পক্ষ, তাই এখানেও নকল gateway থাকে।
  4. Bottom-up, প্রথম ধাপ। উল্টো দিক থেকে শুরু। নিচের তিনটি অংশ আগে, প্রতিটিকে একটি driver (একটি pytest function) সরাসরি ডাকে: দামের নিয়ম, database-এর লেখা-পড়া আর wallet-এর adapter. Driver: ৩টি, stub: ০টি।
  5. Bottom-up, দ্বিতীয় ধাপ। আসল Shop তার আসল নিচের অংশসহ। ওপরের API এখনো নেই, তাই একটি driver সরাসরি place_order ডাকে। বাজারঘরের নিজের suite-এর বড় অংশ এই স্তরে চলে।
  6. Bottom-up, তৃতীয় ধাপ। API যোগ হলো; এখন test HTTP দিয়ে ঢোকে। শেষ ছবি top-down-এর তৃতীয় ধাপের মতোই, কিন্তু পথ আলাদা: top-down-এ মোট ৪টি stub লিখতে হলো, bottom-up-এ ৪টি driver আর কোনো stub নয়।

আজকের বেশিরভাগ দল কৌশলের নাম নিয়ে কথা বলে না, কারণ continuous integration সবাইকে ছোট ছোট ধাপে, প্রায়ই দিনে কয়েকবার, জোড়া লাগাতে বাধ্য করে। তবু আলাদা দলের তৈরি অংশ জোড়ার সময় (যেমন courier-এর API আসবে তিন সপ্তাহ পরে) ক্রমের সিদ্ধান্ত সত্যিই নিতে হয়, আর stub বনাম driver পরীক্ষার প্রায় নিশ্চিত প্রশ্ন।

৩ · কোনটা আসল, কোনটা নকল — একটি request-এর পথ

Integration test লেখার সবচেয়ে গুরুত্বপূর্ণ সিদ্ধান্ত: প্রতিটি নির্ভরতা আসল থাকবে, না নকল? সব আসল রাখলে test ধীর আর অস্থির হয়, তৃতীয় পক্ষের sandbox বন্ধ থাকলেই লাল। সব নকল করলে সেটি আর integration test থাকে না, আর §১-এর মতো ভুল চুপচাপ পার হয়ে যায়। একটি ব্যবহারিক নিয়ম: যে জোড়টি যাচাই করছেন, তার দুই পাশ আসল রাখুন; বাকিগুলো যত সস্তায় সম্ভব।

নির্ভরতাIntegration test-একারণ
দামের pure নিয়মআসলদ্রুত, deterministic; নকল করলে আসল নিয়মটিই আর যাচাই হয় না
নিজের databaseআসল engine, আলাদা test database-এSchema, constraint আর transaction এখানেই থাকে; জোড়ের ভুলের বড় অংশ এখানে
Mobile wallet, courier, SMSনকল gateway বা প্রদানকারীর sandboxআসল টাকা বা বার্তার ঝুঁকি, ধীরগতি, আপনার নিয়ন্ত্রণের বাইরে; চুক্তি যাচাই হবে contract test-এ (পর্ব ৩২)
ঘড়ি আর randomনিয়ন্ত্রিত (inject করা)পর্ব ২৫-এর মতো; প্রত্যাশিত মান আগে থেকে লেখা যায়
অন্য দলের নিজস্ব serviceঅবস্থাভেদে আসল (একটি test পরিবেশে) বা virtualize করাপ্রতিটি run-এ আসলটি চালু রাখা ব্যয়বহুল; পর্ব ৩৪ দেখুন
Network আর HTTP serverদুইভাবেই চলেIn-process client (FastAPI-এর TestClient) দ্রুত; সত্যিকারের port-এ চলা server-এ uvicorn আর config-ও যাচাই হয়

শেষ সারিটি নিয়ে একটি কথা। বাজারঘরের নিজের suite-এর ১৫০টি test চলে in-process, প্রতিটি test নিজের নতুন SQLite ফাইল পায়; desktop-এ পুরো suite ১৩.১২ সেকেন্ডে শেষ হয়েছে। §৬-এর test-গুলো উল্টো পথে যায়: আসল port-এ চলা app-এ httpx দিয়ে HTTP request পাঠায়। দুটিই integration test; দ্বিতীয়টি আরেকটু চওড়া, কারণ server চালু করা, port, environment-এর মান আর test mode-ও তার আওতায়। একটি request কোন কোন স্তর পার হয়, ধাপে ধাপে দেখুন:

  1. Testhttpxrequest পাঠায়
  2. RouteFastAPIlogin, যাচাই
  3. ServiceShopকাজের ক্রম
  4. নিয়মquoteছাড়, delivery
  5. DatabaseSQLiteএক transaction
  6. উত্তর201JSON
Testmitu-র কার্টে ২০০০ টাকা
POST /api/orders
Authorization: Bearer …
{"district": "Dhaka",
 "address": "বাড়ি ১২, মিরপুর",
 "phone": "01712345678",
 "payment_method": "cash",
 "delivery_slot": "evening"}
Routeদরজায় যাচাই
token নেই     → 401
"phone": 1712 → 422
সব ঠিক       →
  shop.place_order(
      user, **body)
Serviceব্যবসার যাচাই
district চেনা?   না → 422
phone নিয়মে?     না → 422
কার্ট খালি?       হ্যাঁ → 400
স্টক যথেষ্ট?      না → 409
তারপর দাম চাওয়া
নিয়মpure হিসাব
quote(2000, "Dhaka",
      plus=False)
subtotal  2000
discount   200   # 10%, max 300
delivery     0   # 2000 BEFORE coupon
total     1800
Databaseসব, নয়তো কিছুই না
BEGIN
INSERT orders        → id 8
INSERT order_items   ×2
UPDATE products      stock − qty
INSERT order_history placed
DELETE cart_items
COMMIT
উত্তরtest যা মেলায়
201 {"id": 8,
     "status": "placed",
     "pricing": {
       "subtotal": 2000,
       "discount": 200,
       "delivery": 0,
       "total": 1800}, …}
GET /api/products/3
→ stock 28
  1. Test. Test একজন সত্যিকারের ক্লায়েন্টের মতো HTTP request পাঠায়: login করে পাওয়া token, আর বাংলা ঠিকানাসহ JSON body. Request-এর আগে mitu-র কার্টে দুটি সয়াবিন তেল আর দুটি আটা, মোট ২০০০ টাকা।
  2. Route. FastAPI-র route প্রথমে দরজায় যাচাই করে: token না থাকলে 401, JSON-এর ধরন ভুল হলে (যেমন phone একটি সংখ্যা) 422. এই স্তরের ভুল unit test-এ প্রায় কখনো ধরা পড়ে না, কারণ unit test route-এ ঢোকেই না।
  3. Service. Shop.place_order ব্যবসার শর্ত দেখে: district, phone-এর নিয়ম, খালি কার্টে 400, স্টক না থাকলে 409. এগুলো ঠিক হলে তবেই দাম চাওয়া হয়।
  4. নিয়ম। Pure হিসাব: ২০০০ টাকায় ছাড় ২০০, আর delivery ০, কারণ ২০০০ টাকার সীমা coupon-এর আগের দামে মাপা হয়। delivery_after_discount bug চালু থাকলে ঠিক এই লাইনে delivery হয় ৬০; §৬-এর run সেটিই ধরবে।
  5. Database. পাঁচটি লেখা একটি transaction-এ: order-এর সারি, দুটি item, স্টক কমানো, ইতিহাসে placed, আর কার্ট খালি করা। মাঝপথে ভুল হলে একটিও থাকে না। এই “সব, নয়তো কিছুই না” আচরণ mock দিয়ে যাচাই করা যায় না।
  6. উত্তর। 201 আর JSON-এ id ৮, অবস্থা placed আর মোট ১৮০০. ভালো integration test শুধু উত্তর নয়, পার্শ্বফলও মেলায়: সয়াবিন তেলের স্টক ৩০ থেকে ২৮, আর কার্ট খালি।

৪ · Test database — আলাদা, পরিষ্কার আর পুনরাবৃত্তিযোগ্য

Integration test-এ আসল database মানে একটি নতুন দায়িত্ব: প্রতিটি test যেন একটি জানা, পরিষ্কার অবস্থা থেকে শুরু হয়, আর শেষে কোনো চিহ্ন না রেখে যায়। এর জন্য সবসময় একটি আলাদা test database, যেখানে আসল গ্রাহকের ডেটা কখনো থাকে না, আর শুরুর ডেটা আসে একটি জানা seed থেকে। (Fixture আর test data-র সাধারণ নিয়ম পর্ব ২৩-এ।) পরিষ্কার রাখার চারটি প্রচলিত কৌশল:

কৌশলকীভাবেভালো দিকসাবধান
প্রতি test-এ নতুন databaseপ্রতিটি test-এর জন্য নতুন ফাইল বা নতুন schema, seed-সহপূর্ণ বিচ্ছিন্নতা; বাজারঘরের নিজের suite এভাবে চলেবড় schema-য় ধীর; ১৫০টি test-এ ১৩.১২ সেকেন্ড
Per-test transaction আর rollbackTest শুরুতে BEGIN, শেষে ROLLBACKখুব দ্রুত; seed একবারই বসেCode under test নিজে commit করলে বা আলাদা connection খুললে ভাঙে (নিচে)
Truncate বা reset endpointপ্রতি test-এর আগে টেবিল খালি করে seed আবার বসানো, যেমন বাজারঘরের POST /api/test/resetচালু server-এর ক্ষেত্রেও কাজ করে, যেখানে test-এর হাতে connection নেইReset নিজেই সময় নেয়; production-এ endpoint-টি কখনো থাকা চলবে না
Template database থেকে কপিSeed-সহ একটি database একবার বানিয়ে প্রতি worker বা test-এ তার কপিParallel run-এ প্রতিটি worker আলাদা database পায়Engine-এর সমর্থন লাগে (যেমন PostgreSQL-এর template), বা ফাইল কপি

বাজারঘরের reset endpoint থাকে শুধু BAZARGHAR_TEST_MODE=1 চালু থাকলে, নইলে 404. এক ডাকে database মোছার API production-এ থাকলে তা নিজেই গুরুতর ঝুঁকি; এর অনুপস্থিতি যাচাই করাও একটি test.

SQLite in-memory, না আসল engine?

Python-এর SQLite-এ :memory: দিলে পুরো database থাকে শুধু memory-তে (in-memory database), প্রতিটি connection-এর নিজের আলাদা database. খুব দ্রুত আর কিছু install করতে হয় না। বাজারঘর production-এও SQLite চালায়, তাই তার জন্য এটি আসল engine-ই। কিন্তু অনেক দল production-এ PostgreSQL বা MySQL চালিয়ে test-এ SQLite ব্যবহার করে, আর সেখানে পার্থক্যগুলো ফাঁদ হয়ে দাঁড়ায়:

  • ধরনের কড়াকড়ি: SQLite সাধারণ টেবিলে INTEGER কলামেও 'abc' রেখে দেয়; ৩.৩৭ সংস্করণ (২০২১) থেকে STRICT টেবিল আছে। PostgreSQL সাথে সাথে ভুল দেয়।
  • SQL-এর রূপ: তারিখের function, ILIKE, JSON-এর operator, RETURNING-এর খুঁটিনাটি engine-ভেদে আলাদা।
  • Sequence: PostgreSQL-এর sequence (database sequence) rollback-এ পেছায় না; rollback-এর পরে পরের id ৮ নয়, ৯ হতে পারে। SQLite-এর সাধারণ INTEGER PRIMARY KEY rollback-এর পরে আবার ৮ দেয় (নিচের block দেখুন)।
  • একসাথে লেখা: Lock, isolation level আর deadlock-এর আচরণ বড় engine-এ ভিন্ন; race-এর bug SQLite-এ প্রায়ই দেখা যায় না।

তাই নিয়ম: যে test-এর লক্ষ্য database-এর সাথে জোড়, সেটি production-এর একই engine আর একই সংস্করণে চালান (§৫-এর Testcontainers এর একটি উপায়)। SQLite in-memory তখনই নিরাপদ, যখন production-ও SQLite, বা test-এর লক্ষ্য database নয়। Transaction আর ACID-এর মূল ধারণা DBMS ও SQL কোর্সের পর্ব ৪৪-এ।

Per-test transaction আর rollback, হাতে-কলমে

নিচের block-এ একটি session-scope fixture একবার database বানায়, সাতটি seed order-সহ (বাজারঘরের সাতটি order-এর মোট দাম)। তারপর প্রতিটি test-এর জন্য একটি function-scope fixture BEGIN করে, test শেষে ROLLBACK. --setup-show দিয়ে চালানো, যাতে fixture-এর ক্রম দেখা যায়:

import os, sys, pytest
d = "/home/pyodide/p28b"; os.makedirs(d, exist_ok=True); os.chdir(d)
for m in ("conftest", "test_rollback"): sys.modules.pop(m, None)
open("conftest.py", "w").write('''
import sqlite3, pytest
@pytest.fixture(scope="session")
def engine():                            # built ONCE: schema + 7 seed orders
    conn = sqlite3.connect(":memory:", isolation_level=None)
    conn.execute("CREATE TABLE orders (id INTEGER PRIMARY KEY, total INT)")
    conn.executemany("INSERT INTO orders (total) VALUES (?)",
                     [(t,) for t in (750, 635, 1115, 480, 1060, 1021, 1800)])
    yield conn
    conn.close()
@pytest.fixture
def db(engine):                          # every test inside its own transaction
    engine.execute("BEGIN")
    yield engine
    engine.execute("ROLLBACK")''')
open("test_rollback.py", "w").write('''
def place(db, total):
    return db.execute("INSERT INTO orders (total) VALUES (?)", (total,)).lastrowid
def count(db):
    return db.execute("SELECT COUNT(*) FROM orders").fetchone()[0]
def test_a_new_order_gets_id_8(db):
    assert place(db, 1800) == 8 and count(db) == 8
def test_b_two_orders_still_start_at_8(db):
    assert [place(db, 961), place(db, 920)] == [8, 9] and count(db) == 9
def test_c_seed_is_untouched(db):
    assert count(db) == 7''')
pytest.main(["-v", "--no-header", "--setup-show", "-p", "no:cacheprovider",
             "test_rollback.py"])

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

============================= test session starts ==============================
collecting ... collected 3 items

test_rollback.py::test_a_new_order_gets_id_8 
SETUP    S engine
        SETUP    F db (fixtures used: engine)
        test_rollback.py::test_a_new_order_gets_id_8 (fixtures used: db, engine)PASSED
        TEARDOWN F db
test_rollback.py::test_b_two_orders_still_start_at_8 
        SETUP    F db (fixtures used: engine)
        test_rollback.py::test_b_two_orders_still_start_at_8 (fixtures used: db, engine)PASSED
        TEARDOWN F db
test_rollback.py::test_c_seed_is_untouched 
        SETUP    F db (fixtures used: engine)
        test_rollback.py::test_c_seed_is_untouched (fixtures used: db, engine)PASSED
        TEARDOWN F db
TEARDOWN S engine

============================== 3 passed in 0.02s ===============================

SETUP S engine একবারই, প্রথম test-এর আগে (S মানে session scope); TEARDOWN S engine একবারই, সবার শেষে। মাঝে প্রতিটি test-এর জন্য SETUP F db আর TEARDOWN F db (F মানে function scope). তিনটি test-ই সবুজ, আর এর মানে আছে। প্রথম test একটি order যোগ করে id ৮ পেল; দ্বিতীয় test আবার ৮ থেকে শুরু করল, কারণ প্রথমটির order rollback-এ মুছে গেছে; তৃতীয় test দেখল seed-এর ঠিক ৭টি সারি। কোনো test আরেকটির চিহ্ন দেখেনি: এটিই test isolation. ক্রম উল্টে দিলেও ফল একই থাকবে।

1engine: CREATE + 7 seed2db: BEGIN3test: INSERT, assert4db: ROLLBACK5test_c: COUNT(*) == 76engine: close
Database-এর অবস্থা
চলমান test
transaction
COUNT(*)
নতুন id
  1. Session শুরু। engine fixture একবার চলে: টেবিল বানায় আর সাতটি seed order বসায়। isolation_level=None মানে Python নিজে থেকে transaction খুলবে না; কখন খুলবে, তা fixture ঠিক করবে। সারি: ৭টি।
  2. test_a-র আগে BEGIN. db fixture একটি transaction খোলে। এখন থেকে যা লেখা হবে, তা এই transaction-এর ভেতরে থাকবে, স্থায়ী নয়।
  3. test_a চলে। একটি order যোগ হলো, id ৮; সারি এখন ৮টি। Test-এর ভেতর থেকে সবকিছু সাধারণ database-এর মতোই দেখায়, assertion পাস করে।
  4. ROLLBACK. Test শেষ হতেই fixture-এর yield-এর পরের অংশ চলে: rollback. id ৮-এর order মুছে গেল, সারি আবার ৭টি। Database ঠিক seed-এর অবস্থায়।
  5. test_b. নতুন BEGIN, দুটি order, id ৮ আর ৯; সারি ৯টি; তারপর আবার rollback. লক্ষ করুন id আবার ৮ থেকে শুরু, কারণ SQLite সবচেয়ে বড় id দেখে পরেরটি দেয়। PostgreSQL-এর sequence হলে এখানে ৯ আর ১০ আসতে পারত; তাই test-এ পরম id-এর ওপর ভরসা ঝুঁকিপূর্ণ।
  6. test_c. শুধু গোনে: ৭টি। আগের দুই test-এর কোনো চিহ্ন নেই।
  7. Session শেষ। engine-এর teardown connection বন্ধ করে। তিনটি test, একবার seed, তিনবার rollback: “3 passed”.

যখন code under test নিজেই transaction চালায়

Per-test rollback-এর একটি পরিচিত ফাঁদ আছে। বাস্তবের service নিজেই BEGIN আর COMMIT করে, কারণ order আর স্টক একসাথে জমা হওয়া দরকার। Test-এর খোলা transaction-এর ভেতরে service COMMIT করলে test-এর transaction-ই শেষ হয়ে যায়, ডেটা স্থায়ী হয়, আর test-এর শেষের ROLLBACK হয় ভুল দেয়, নয়তো কিছুই মোছে না। সমাধান হলো nested transaction-এর জন্য savepoint: test-এর বাইরের transaction খোলা থাকে, আর app-এর নিজের “transaction” হয় একটি savepoint. অনেক framework ঠিক এটিই করে। SQL-এ দেখুন:

-- fixture: schema + seed (runs once)
CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT,
  stock INTEGER NOT NULL CHECK (stock >= 0));
INSERT INTO products VALUES (3, 'Soybean Oil 5 L', 30), (7, 'Atta 2 kg', 40);

BEGIN;                   -- fixture: the test's outer transaction
SAVEPOINT order_8;       -- app's own "BEGIN" becomes a savepoint
UPDATE products SET stock = stock - 2 WHERE id = 3;
RELEASE order_8;         -- app's "COMMIT": kept, but only inside the test
SAVEPOINT order_9;
UPDATE products SET stock = stock - 5 WHERE id = 7;
ROLLBACK TO order_9;     -- app's "ROLLBACK" after a payment error
SELECT 'inside test' AS seen_by, id, stock FROM products;

ROLLBACK;                -- fixture teardown
SELECT 'next test' AS seen_by, id, stock FROM products;

আসল আউটপুট: প্রতিটি লেখার পাশে একটি “✓”, তারপর দুটি ফলের টেবিল। Test-এর ভেতরে inside test | 3 | 28 আর inside test | 7 | 40: order ৮-এর ২টি তেল কাটা থেকে গেছে, কারণ RELEASE savepoint-টিকে বাইরের transaction-এ মিশিয়ে দেয়; আর order ৯-এর ৫টি আটা ROLLBACK TO-তে ফিরে এসেছে। Fixture-এর শেষ ROLLBACK-এর পরে next test | 3 | 30 আর next test | 7 | 40: পুরো seed অবস্থা। App ভেবেছে সে commit করেছে, test দেখেছে ফল, আর পরের test পেয়েছে পরিষ্কার database. App যদি সত্যিই COMMIT লিখত, বাইরের transaction শেষ হয়ে যেত আর ২৮ স্থায়ী হতো; অনুশীলন ৩-এ এই ভুলটি খুঁজবেন।

বাস্তবের framework-এ এই কৌশলের নাম আলাদা, ধারণা একই। Django-র TestCase প্রতিটি test-কে একটি transaction-এ মোড়ায় আর কোডের atomic ব্লকগুলো savepoint হয়ে যায়; SQLAlchemy-র নথিতে “join an external transaction” নামে একটি recipe আছে। তবু তিনটি জিনিস এভাবে যাচাই করা যায় না: commit-এর মুহূর্তে যাচাই হওয়া নিয়ম (যেমন PostgreSQL-এর deferred constraint), commit হওয়ার পরে চলা কাজ (ইমেইল পাঠানো, event ছাড়া), আর আলাদা connection থেকে পড়া কোড, যে test-এর না-commit-করা ডেটা দেখতেই পায় না। এগুলোর জন্য আসল commit আর পরে reset বা truncate লাগে।

৫ · Testcontainers — প্রতিটি run-এ আসল database, container-এ

ধরুন বাজারঘর বড় হয়ে PostgreSQL-এ গেল। Test-এ SQLite চালালে §৪-এর পার্থক্যগুলো ফাঁদ হয়ে যাবে; আবার প্রতিটি developer-এর যন্ত্রে আর CI-তে একটি স্থায়ী PostgreSQL সার্ভার রাখা ঝামেলার: সংস্করণ মেলে না, পুরোনো ডেটা থেকে যায়, দুটি run একই database-এ ধাক্কা খায়। Testcontainers এর একটি জনপ্রিয় সমাধান: একটি open-source library, যা test চলার সময় Docker-এ একটি container চালু করে, তাতে নির্দিষ্ট সংস্করণের আসল database, আর run শেষে container মুছে ফেলে। Java দিয়ে শুরু, এখন Python, Go, .NET, Node.js-সহ অনেক ভাষায় আছে; Python-এর package-টি Apache 2.0 licence-এর।

একটি run-এর ধাপ:

  1. Test session শুরুতে library Docker-কে বলে নির্দিষ্ট image থেকে container চালাতে, যেমন postgres:17-alpine. Image না থাকলে প্রথমবার নামায়।
  2. Container-এর database প্রস্তুত না হওয়া পর্যন্ত অপেক্ষা (wait strategy): log-এ একটি লাইন, বা একটি query সফল হওয়া। এখানে অন্ধ sleep নয়।
  3. Library একটি এলোমেলো খালি port-এ container-টি খোলে আর connection URL দেয়, তাই একই যন্ত্রে দুটি run ধাক্কা খায় না।
  4. Test-গুলো চলে, migration দিয়ে schema বানিয়ে, প্রতিটি test-এর পরে rollback বা truncate করে।
  5. Session শেষে container থামানো আর মোছা হয়। Test process হঠাৎ মরে গেলেও যাতে container পড়ে না থাকে, বেশিরভাগ ভাষার রূপে একটি ছোট সহকারী container (Ryuk নামে পরিচিত) নজর রাখে।

এই যন্ত্রে Docker চালু ছিল না, তাই নিচের কোডটি উদাহরণ, চালানো হয়নি। Import-এর পথ আর driver=None parameter testcontainers-python 4.15.0-এর source থেকে মেলানো (এই সংস্করণে পুরোনো testcontainers.postgres পথ deprecated). Database driver হিসেবে psycopg ধরা হয়েছে:

# উদাহরণ, চালানো হয়নি: tests/conftest.py
# uv add "testcontainers[postgres]" psycopg pytest
import psycopg, pytest
from testcontainers.community.postgres import PostgresContainer

@pytest.fixture(scope="session")
def pg_url():
    with PostgresContainer("postgres:17-alpine", driver=None) as pg:
        url = pg.get_connection_url()      # postgresql://test:test@localhost:PORT/test
        with psycopg.connect(url) as conn:
            conn.execute(open("schema.sql").read())   # or run migrations
        yield url                          # container removed after the session

@pytest.fixture
def db(pg_url):
    with psycopg.connect(pg_url) as conn:  # one transaction per test
        yield conn
        conn.rollback()

খরচও আছে: প্রথম run-এ image নামানো, container চালু হতে কয়েক সেকেন্ড (তাই প্রতি session-এ একবার), আর CI-তে Docker. বিকল্প হিসেবে অনেক দল CI-র service container বা Docker Compose দিয়ে একটি database চালায় (Docker Compose-এর পরিচয় ক্লাউড ও DevOps কোর্সের পর্ব ৪০-এ); পার্থক্য হলো, Testcontainers-এ জীবনচক্র test-এর কোডের ভেতরে, আলাদা script-এ নয়। পুরো test পরিবেশ আর data নিয়ে আলোচনা পর্ব ৬৫ (Test environment আর test data — Docker Compose, seed আর masking)-এ।

৬ · বাজারঘরে সত্যিকারের run — pytest আর httpx

এবার একটি চালু app-এর broad integration test. কোর্সের বাজারঘর app (FastAPI আর SQLite, শুধু 127.0.0.1-এ চলে) নিজের lab-এ চালানো হলো, test mode চালু করে আর database ফাইল lab-এর ভেতরে রেখে:

$ BAZARGHAR_TEST_MODE=1 BAZARGHAR_DB=~/bazarghar-qa/lab.db \
    uv run bazarghar --port 8781 --test-mode --reset

আলাদা একটি uv project-এ (~/bazarghar-qa/itests) pytest 9.2.0 (MIT) আর httpx 0.28.1 (BSD-3-Clause). conftest.py-তে তিনটি fixture: পুরো session-এ একটি HTTP client, প্রতিটি test-এর আগে reset, আর login-এর একটি factory:

# tests/conftest.py
BASE = os.environ.get("BAZARGHAR_URL", "http://127.0.0.1:8781")

@pytest.fixture(scope="session")
def api():
    with httpx.Client(base_url=BASE, timeout=5.0) as client:
        try:
            client.get("/api/health").raise_for_status()
        except httpx.HTTPError as exc:
            pytest.exit(f"app not reachable at {BASE}: {exc}", returncode=2)
        yield client

@pytest.fixture(autouse=True)
def fresh_seed(api):
    if os.environ.get("SKIP_RESET"):         # demo only: show the leak
        return
    r = api.post("/api/test/reset")          # 404 if the app is not in test mode
    assert r.status_code == 200, r.text

@pytest.fixture
def login(api):
    def _login(name):
        r = api.post("/api/auth/login",
                     json={"email": f"{name}@bazarghar.test", "password": f"{name}1234"})
        assert r.status_code == 200, r.text
        return {"Authorization": f"Bearer {r.json()['access_token']}"}
    return _login

পাঁচটি test, প্রতিটি একটি পূর্ণ পথ: কার্ট থেকে order আর ঢাকায় ২০০০ টাকায় ফ্রি delivery; রাজশাহীর Plus সদস্যের ৬০ টাকা delivery; placed থেকে delivered পর্যন্ত পুরো state machine; shipped order বাতিলে 409; বাতিলে স্টক ফেরত। প্রথমটি দেখুন:

# tests/test_checkout_flow.py (অংশ)
def test_dhaka_2000_cart_becomes_order_with_free_delivery(api, login):
    mitu = login("mitu")
    fill_cart(api, mitu, [(OIL, 2), (ATTA, 2)])            # 2*880 + 2*120 = 2000
    r = place(api, mitu, "Dhaka")
    assert r.status_code == 201
    order = r.json()
    assert (order["id"], order["status"]) == (8, "placed")
    assert order["pricing"] == {"subtotal": 2000, "discount": 200,
                                "delivery": 0, "total": 1800}
    assert stock(api, OIL) == 28                           # 30 in the seed
    assert api.get("/api/cart", headers=mitu).json()["count"] == 0

def test_order_walks_placed_to_delivered(api, login):
    mitu, admin = login("mitu"), login("admin")
    fill_cart(api, mitu, [(OIL, 1)])
    oid = place(api, mitu, "Dhaka").json()["id"]
    assert api.post(f"/api/orders/{oid}/pay", headers=mitu).json()["status"] == "paid"
    for action, expected in [("pack", "packed"), ("ship", "shipped"),
                             ("deliver", "delivered")]:
        r = api.post(f"/api/orders/{oid}/transition", json={"action": action},
                     headers=admin)
        assert (r.status_code, r.json()["status"]) == (200, expected)
    history = [h["status"] for h in r.json()["history"]]
    assert history == ["placed", "paid", "packed", "shipped", "delivered"]

সত্যিকারের run, Python 3.12, pytest 9.2.0, httpx 0.28.1; platform, path আর config-এর শুরুর লাইনগুলো বাদ দেওয়া হয়েছে:

$ uv run pytest -v
collecting ... collected 5 items

tests/test_checkout_flow.py::test_dhaka_2000_cart_becomes_order_with_free_delivery PASSED [ 20%]
tests/test_checkout_flow.py::test_plus_member_outside_dhaka_pays_60_delivery PASSED [ 40%]
tests/test_checkout_flow.py::test_order_walks_placed_to_delivered PASSED [ 60%]
tests/test_checkout_flow.py::test_shipped_order_cannot_be_cancelled PASSED [ 80%]
tests/test_checkout_flow.py::test_cancel_puts_stock_back PASSED          [100%]

============================== 5 passed in 0.60s ==============================

এবার server থামিয়ে একটি seeded defect চালু করে আবার চালানো হলো: BAZARGHAR_BUGS=delivery_after_discount, যেখানে ফ্রি delivery-র সীমা coupon-এর পরের দামে মাপা হয়। Test-এর কোড একটুও বদলায়নি:

$ uv run pytest -v --tb=short -p no:cacheprovider
collecting ... collected 5 items

tests/test_checkout_flow.py::test_dhaka_2000_cart_becomes_order_with_free_delivery FAILED [ 20%]
tests/test_checkout_flow.py::test_plus_member_outside_dhaka_pays_60_delivery PASSED [ 40%]
tests/test_checkout_flow.py::test_order_walks_placed_to_delivered PASSED [ 60%]
tests/test_checkout_flow.py::test_shipped_order_cannot_be_cancelled PASSED [ 80%]
tests/test_checkout_flow.py::test_cancel_puts_stock_back PASSED          [100%]

================================== FAILURES ===================================
____________ test_dhaka_2000_cart_becomes_order_with_free_delivery ____________
tests\test_checkout_flow.py:28: in test_dhaka_2000_cart_becomes_order_with_free_delivery
    assert order["pricing"] == {"subtotal": 2000, "discount": 200,
E   AssertionError: assert {'subtotal': ...'total': 1860} == {'subtotal': ...'total': 1800}
E
E     Omitting 2 identical items, use -vv to show
E     Differing items:
E     {'delivery': 60} != {'delivery': 0}
E     {'total': 1860} != {'total': 1800}
E
E     Full diff: (-: missing in left side, +: extra in left side)...
E
E     ...Full output truncated, use '-vv' to show
=========================== short test summary info ===========================
FAILED tests/test_checkout_flow.py::test_dhaka_2000_cart_becomes_order_with_free_delivery
========================= 1 failed, 4 passed in 0.58s =========================

pytest-এর dict তুলনা ঠিক দুটি ঘর দেখাচ্ছে: delivery ৬০ (প্রত্যাশা ০) আর মোট ১৮৬০ (প্রত্যাশা ১৮০০); subtotal আর discount মিলেছে (“Omitting 2 identical items”). ব্যবহারকারীর ভাষায়: ঢাকার ক্রেতা ২০০০ টাকার বাজার করে ৬০ টাকা বেশি দিচ্ছেন। লক্ষ করুন বাকি চারটি test সবুজ; রাজশাহীর test-এর কার্ট ১০০১ টাকার, সেখানে ফ্রি delivery-র প্রশ্নই নেই। একটি bug ধরতে ঠিক সীমার মানটি লাগে, integration test-এও। বাস্তবে এই ভুলটি pure নিয়মের unit test-এই আগে ধরা পড়ার কথা (পর্ব ২১); integration test নিশ্চিত করে যে সেই নিয়মটিই সত্যিই checkout-এর পথে বসানো আছে, আর database-এ ঠিক সেই মোটই জমা হচ্ছে। Bug report লেখার নিয়মে (পর্ব ১৮) এই ব্যর্থতাই একটি ভালো report-এর প্রমাণ: ধাপ, প্রত্যাশা আর আসল ফল।

Reset বাদ দিলে কী হয়

এবার bug ছাড়া, কিন্তু SKIP_RESET=1 দিয়ে reset বন্ধ করে, পরপর দুবার (server শুরুতে একবার --reset হয়েছিল):

$ SKIP_RESET=1 uv run pytest -q --tb=no -rf -p no:cacheprovider
....F                                                                    [100%]
=========================== short test summary info ===========================
FAILED tests/test_checkout_flow.py::test_cancel_puts_stock_back - assert 23 =...
1 failed, 4 passed in 0.27s

$ SKIP_RESET=1 uv run pytest -q --tb=no -rf -p no:cacheprovider
F...F                                                                    [100%]
=========================== short test summary info ===========================
FAILED tests/test_checkout_flow.py::test_dhaka_2000_cart_becomes_order_with_free_delivery
FAILED tests/test_checkout_flow.py::test_cancel_puts_stock_back - assert 16 =...
2 failed, 3 passed in 0.27s

$ uv run pytest -q --tb=no -rf -p no:cacheprovider
.....                                                                    [100%]
5 passed in 0.52s

প্রথম run-এই একটি test লাল, কোনো bug ছাড়াই। test_cancel_puts_stock_back ধরে নিয়েছে সয়াবিন তেলের স্টক ৩০ থেকে শুরু, তাই তিনটি কেনার পরে ২৭ হবে। কিন্তু আগের তিনটি test একই run-এ মোট ৪টি তেল কিনেছে (২+১+১), তাই স্টক ছিল ২৬, আর তিনটি কেনার পরে ২৩. Test-টি একা চালালে সবুজ, suite-এ লাল: এটি একটি order-dependent test. আর ব্যর্থ হওয়ায় বাতিলের ধাপ চলেনি, ৩টি তেল ফেরত আসেনি। দ্বিতীয় run-এ আরও খারাপ: নতুন order-এর id ৮ নয়, ১২ (আগের run-এ ৮ থেকে ১১ হয়ে গেছে), আর স্টক ২৩ থেকে নেমে ১৬. Reset ফিরিয়ে আনতেই আবার পাঁচটি সবুজ। সংখ্যাগুলো যোগ করে মিলিয়ে দেখুন; এমন হিসাবই flaky test-এর রহস্য খোলে।

৭ · Integration test কেন অস্থির হয়

Unit test-এর চেয়ে integration test-এ flaky test বেশি দেখা যায়, কারণ চলমান অংশ বেশি। পুরো আলোচনা পর্ব ৪০ (Flaky test — কারণ, খোঁজা, quarantine আর স্থায়ী সমাধান)-এ; এখানে integration-এর নিজস্ব উৎসগুলো আর তাদের প্রতিকার:

উৎসবাজারঘরে উদাহরণপ্রতিকার
ভাগ করা অবস্থা§৬-এর স্টক আর id, reset ছাড়াপ্রতি test-এর আগে reset বা rollback; প্রতিটি test নিজের ডেটা নিজে বানায়
পরম মানে ভরসাid == 8, stock == 27আগে-পরে তুলনা (before - 3), বা ফেরত আসা id ব্যবহার
Parallel run-এ ধাক্কাদুটি worker একই কার্ট বা একই database-এWorker-প্রতি আলাদা database বা আলাদা ব্যবহারকারী
সময় আর ক্রম“আজকের order” মধ্যরাতে ভাঙে; list-এর ক্রম ধরে নেওয়াঘড়ি inject করা (পর্ব ২৫); ORDER BY ছাড়া ক্রম ধরে না নেওয়া
অপেক্ষাServer চালু হওয়ার আগেই test শুরু; পেছনের কাজ শেষ হয়নিHealth check-এ অপেক্ষা (conftest-এর /api/health), অন্ধ sleep নয়
বাইরের নির্ভরতাWallet-এর sandbox ধীর বা বন্ধনকল gateway (পর্ব ৩৪), আর আলাদা কয়েকটি sandbox test
Port আর পরিবেশআরেকটি app একই port-এ; test mode বন্ধনিজের port, environment-এর মান যাচাই; reset-এর 404-এ সাথে সাথে থামা

§৬-এর conftest-এর দুটি সিদ্ধান্ত এই টেবিল থেকেই: /api/health না পেলে pytest.exit (পাঁচটি অর্থহীন connection error-এর বদলে একটি পরিষ্কার বার্তা), আর reset-এর উত্তর 200 না হলে assertion, যাতে test mode বন্ধ থাকলে test ভুল অবস্থার ওপর না চলে।

আরও গভীরে: Parallel run-এ প্রতিটি worker-এর আলাদা database দরকার, আর প্রতিবার schema আর seed নতুন করে বানানো ধীর। PostgreSQL-এ CREATE DATABASE … TEMPLATE একটি প্রস্তুত database-এর কপি দ্রুত বানায়; SQLite-এ একটি seed-করা ফাইল কপি করাই যথেষ্ট। বড় suite-এ দলগুলো প্রায়ই দুই স্তর রাখে: বেশিরভাগ test per-test rollback-এ, আর commit-এর আচরণ যাচাইয়ের অল্প কয়েকটি test আলাদা, পরিষ্কার database-এ। কোন test কোন দলে যাবে, তার মানদণ্ড একটিই: code under test নিজে transaction চালায় কি না।

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

  • Stub আর driver-এর পার্থক্য কী? — Stub ডাকা অংশের নকল, ঠিক করা উত্তর দেয় (top-down-এ লাগে); driver ডাকার অংশের নকল, নিচের module-কে ডাকে (bottom-up-এ লাগে)।
  • Big-bang integration-এর প্রধান অসুবিধা? — সব একসাথে জোড়া হয় বলে ব্যর্থতার জায়গা খুঁজে পাওয়া কঠিন, আর জোড়ের ভুল দেরিতে ধরা পড়ে।
  • Integration test-এ database কীভাবে পরিষ্কার রাখবেন? — প্রতি test-এ নতুন database, per-test transaction আর rollback, truncate বা reset, বা template থেকে কপি; code নিজে commit করলে savepoint বা আসল reset.
  • Test-এ SQLite in-memory, production-এ PostgreSQL: ঝুঁকি কী? — ধরনের কড়াকড়ি, SQL-এর রূপ, sequence আর concurrency-র আচরণ আলাদা; database-এর জোড় যাচাইয়ে একই engine (যেমন Testcontainers দিয়ে)।
  • Component integration আর system integration testing-এর পার্থক্য? — প্রথমটি নিজের system-এর ভেতরের অংশগুলোর জোড়, দ্বিতীয়টি বাইরের system-এর (wallet, courier) সাথে জোড়।

৮ · AI-এর যুগে integration test

AI assistant-কে “এই API-র integration test লিখে দিন” বললে কয়েকটি চেনা ভুল আসে। প্রথম, নাম integration, কিন্তু ভেতরে সব mock: database, service, এমনকি দামের নিয়মও patch করা, ফলে §১-এর "PLACED"-এর মতো ভুল চুপচাপ পার হয়ে যায়। দ্বিতীয়, শুধু happy path: 201 এলেই খুশি, 409, 422 বা স্টক ফেরতের মতো পার্শ্বফল দেখা হয় না। তৃতীয়, test-এর মধ্যে পরিষ্কারের কোনো ব্যবস্থা নেই, বা উল্টো, একটি ঢালাও “সব টেবিল DROP” fixture, যা ভুল database URL পেলে বিপজ্জনক। চতুর্থ, server বা container-এর জন্য time.sleep(5). পঞ্চম, অস্তিত্বহীন option: পুরোনো import-এর পথ, ভুল parameter, বানানো endpoint. আর শেষে, test না চালিয়েই “সব test পাস” দাবি।

AI-কে কাজ দিন সীমা আর প্রমাণ চেয়ে:

বাজারঘর app-এর জন্য pytest + httpx দিয়ে integration test লেখো। App চলে http://127.0.0.1:8781-এ, test mode-এ; POST /api/test/reset seed ফিরিয়ে আনে। নিয়ম: ১. Database, service আর দামের নিয়ম কোনোটাই mock করবে না; এটি চালু app-এর ওপর HTTP test. ২. প্রতিটি test-এর আগে reset-এর একটি autouse fixture; session-এর শুরুতে /api/health না পেলে pytest.exit, sleep নয়। ৩. শুধু 201 নয়: প্রতিটি test অন্তত একটি পার্শ্বফল মেলাবে (স্টক, কার্ট খালি, order-এর history). ৪. এই case-গুলো রাখবে: ঢাকায় ঠিক 2000 টাকার কার্টে delivery 0; shipped order বাতিলে 409 invalid_transition; বাতিলে স্টক ফেরত; অন্য ক্রেতার order-এ 404. ৫. যে endpoint বা field আমার দেওয়া তালিকায় নেই, তা বানাবে না; সন্দেহ হলে প্রশ্ন করো। ৬. Test চালিয়েছ বলে দাবি করবে না; শুধু বলো কোন command চালালে কী আশা করি।

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

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

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

প্র ০১“Integration hell” কথাটি কোথা থেকে এল, আর continuous integration কীভাবে big-bang কৌশলের সমস্যার উত্তর হয়ে উঠল?

বড় software project-এ বহু বছর একটি চেনা ছবি ছিল: কয়েকটি দল মাসের পর মাস আলাদা আলাদা অংশ বানায়, আর পরিকল্পনার শেষ দিকে একটি “integration phase” থাকে, যখন সব জোড়া লাগানো হবে। সেই phase প্রায় কখনো পরিকল্পনামতো চলত না। প্রতিটি দলের অংশ নিজের test-এ সবুজ, কিন্তু জোড়া দিতেই শত শত ভুল একসাথে বেরোত: interface-এর বোঝাপড়ায় অমিল, একই নামের দুই অর্থ, ভিন্ন সংস্করণের library. ভুলগুলো একে অপরকে ঢেকে রাখত, তাই কোনটির কারণ কোথায়, তা খুঁজতে সপ্তাহ চলে যেত। Developer-রা এই অবস্থার নাম দেন “integration hell”. এটি আসলে big-bang integration-এর স্বাভাবিক পরিণতি।

উত্তরটি এসেছিল একটি সহজ পর্যবেক্ষণ থেকে: জোড়া লাগানো যদি কষ্টের হয়, তবে আরও ঘন ঘন করুন, যাতে প্রতিবার জোড়ার পরিমাণ ছোট থাকে। “Continuous integration” কথাটি Grady Booch-এর ১৯৯১ সালের object-oriented design-এর বইয়ে পাওয়া যায় বলে সাধারণত উল্লেখ করা হয়; ১৯৯০-এর দশকের শেষে Kent Beck-এর Extreme Programming এটিকে একটি মূল চর্চা বানায়, যেখানে দিনে কয়েকবার জোড়া আর প্রতিবার সব test চলে। Martin Fowler-এর “Continuous Integration” লেখাটি (প্রথম সংস্করণ ২০০০ সালে) ধারণাটিকে ব্যাপকভাবে ছড়িয়ে দেয়।

Testing-এর ভাষায় CI হলো incremental integration-কে চরমে নেওয়া: প্রতিটি ছোট বদল একটি নতুন “ধাপ”, আর প্রতিটি ধাপের পরে integration test. ভুল ধরা পড়লে সন্দেহের তালিকা ছোট: শেষ কয়েক ঘণ্টার বদল। তবে CI একা যথেষ্ট নয়। Integration test যদি সব mock করে, তাহলে প্রতিদিন জোড়া লাগালেও আসল জোড় কখনো যাচাই হয় না; “integration hell” তখন production-এ গিয়ে দেখা দেয়। আবার integration test যদি ধীর আর অস্থির হয়, দল সেগুলো এড়াতে শুরু করে। তাই এই পর্বের কৌশলগুলো, দ্রুত rollback, নিয়ন্ত্রিত নকল আর পরিষ্কার reset, CI-কে কার্যকর রাখার উপকরণ।

বাজারঘরের মতো ছোট দলেও প্রশ্নটি প্রাসঙ্গিক: courier-এর API তিন সপ্তাহ পরে এলে আপনি কি তিন সপ্তাহ অপেক্ষা করে একবারে জুড়বেন, নাকি আজই একটি stub-এর বিপরীতে নিজের adapter বানিয়ে প্রতিদিন জুড়বেন?

মূল উপলব্ধি: জোড়া লাগানোর কষ্ট কমানোর উপায় এড়িয়ে যাওয়া নয়, ঘন ঘন করা; আর প্রতিবার আসল জোড় যাচাই করা।

প্র ০২“যে type আপনার নিজের নয়, তার mock বানাবেন না” — এই পরামর্শ কোথা থেকে এল, আর integration test-এর সাথে এর সম্পর্ক কী?

Steve Freeman আর Nat Pryce তাঁদের Growing Object-Oriented Software, Guided by Tests (২০০৯) বইয়ে একটি নীতি দেন, যা সাধারণত “only mock types that you own” বা “don't mock what you don't own” নামে পরিচিত। তাঁরা mock-ভিত্তিক TDD-র অন্যতম প্রবক্তা, তাই পরামর্শটি mock-বিরোধীদের নয়, mock-এর পক্ষের মানুষদের সতর্কবাণী। যুক্তিটি এমন: বাইরের library বা service-এর mock বানালে আপনি সেই জিনিসটি কীভাবে আচরণ করে, সে সম্পর্কে নিজের ধারণা লিখে রাখেন। ধারণাটি ভুল হলে, বা library-র পরের সংস্করণে আচরণ বদলালে, mock-ভিত্তিক test সবুজই থাকে, অথচ আসল কোড ভাঙে।

তাঁদের প্রস্তাবিত সমাধান দুই স্তরের। প্রথম স্তরে নিজের ভাষায় একটি ছোট interface বা adapter বানান, যেমন বাজারঘরের OrderRepo বা wallet adapter; বাকি কোড শুধু এটিকে চেনে, আর unit test-এ এটির mock চলতে পারে, কারণ এটি আপনার নিজের type. দ্বিতীয় স্তরে adapter-টির নিজের integration test লিখুন, আসল library আর আসল database বা sandbox-এর বিপরীতে। এই test-টিই বাইরের জগৎ সম্পর্কে আপনার ধারণা যাচাই করে। এটিই narrow integration test-এর মূল উদ্দেশ্য।

§১-এর block এই নীতির একটি ছোট রূপ। Checkout-এর unit test-এ OrderRepo-এর mock বৈধ, কারণ repository আমাদের নিজের। কিন্তু repository আর database-এর জোড়টি, যেখানে CHECK constraint থাকে, শুধু আসল SQLite-এর সাথেই যাচাই হতে পারে। কেউ যদি sqlite3 module-এর connect-ই mock করতেন, তাহলে তিনি SQLite-এর আচরণ সম্পর্কে নিজের ধারণা লিখতেন, আর CHECK-এর অস্তিত্ব ভুলে যাওয়াই স্বাভাবিক।

নীতিটির সীমাও আছে। কিছু বাইরের জিনিস test-এ আসলরূপে চালানো যায় না, যেমন আসল টাকার wallet. সেখানে প্রদানকারীর sandbox, contract test (পর্ব ৩২) আর service virtualization (পর্ব ৩৪) মিলে কাজটি করে। পর্ব ২৪-এর mock drift এই নীতি না মানারই ফল।

মূল উপলব্ধি: নিজের adapter-এর mock চলে; বাইরের জিনিসের আচরণ যাচাই হয় শুধু আসলটির সাথে একটি integration test-এ।

প্র ০৩Testcontainers কীভাবে জনপ্রিয় হলো, আর in-memory database-এর যুগ থেকে আসল engine-এর দিকে এই সরে আসার পেছনে কী যুক্তি?

২০০০-এর দশকে Java জগতে একটি প্রচলিত চর্চা ছিল: production-এ Oracle বা PostgreSQL, আর test-এ HSQLDB বা H2-এর মতো in-memory database, অনেক সময় ORM-এর সাহায্যে, যাতে একই কোড দুই জায়গায় চলে। কারণ ছিল ব্যবহারিক: আসল database সার্ভার প্রতিটি developer-এর যন্ত্রে বসানো ঝামেলার, আর in-memory database এক সেকেন্ডে তৈরি হয়। দামটা দিতে হতো পরে: SQL-এর রূপ, ধরনের কড়াকড়ি আর lock-এর আচরণের পার্থক্যে কিছু bug test-এ সবুজ থেকে production-এ ধরা পড়ত।

Docker (২০১৩) সমীকরণটি বদলে দেয়: আসল PostgreSQL-এর একটি নির্দিষ্ট সংস্করণ এখন একটি command-এ, কয়েক সেকেন্ডে, যেকোনো যন্ত্রে চলে। আমাদের জানামতে Testcontainers-এর Java library ২০১৫ সালের দিকে Richard North-এর হাতে শুরু হয়, ঠিক এই সুযোগ test-এর কোডের ভেতরে আনতে। পরে এর রক্ষণাবেক্ষণকারীরা AtomicJar নামে একটি প্রতিষ্ঠান গড়েন, আর ২০২৩ সালের ডিসেম্বরে Docker, Inc. প্রতিষ্ঠানটি কিনে নেয় বলে প্রকাশিত হয়েছে। ততদিনে library-টির রূপ অনেক ভাষায় ছড়িয়েছে।

যুক্তিটি সহজ: test-এর আস্থা নির্ভর করে test-এর পরিবেশ production-এর কতটা কাছে, তার ওপর। যে test একটি database-এর সাথে জোড় যাচাইয়ের দাবি করে, সে যদি অন্য engine-এ চলে, তাহলে সে শুধু “আমাদের কোড কোনো এক SQL database-এ চলে” যাচাই করে। আবার container প্রতিটি run-এ নতুন হয়, তাই পুরোনো ডেটার ভূত থাকে না, আর এলোমেলো port-এর কারণে একই যন্ত্রে কয়েকটি run একসাথে চলতে পারে।

তবু এটি সব সমস্যার সমাধান নয়। Container চালু হতে সময় লাগে, তাই প্রতি session-এ একবার চালানোই নিয়ম; CI-তে Docker চাই; বড় image নামানো ধীর নেটওয়ার্কে কষ্টের। আর যে test-এর লক্ষ্য database নয় (যেমন দামের নিয়ম), তার জন্য container চালানো অপচয়। বাজারঘরের মতো যেখানে production-ও SQLite, সেখানে in-memory বা ফাইল-ভিত্তিক SQLite-ই আসল engine.

মূল উপলব্ধি: Database-এর সাথে জোড় যাচাইয়ের test production-এর একই engine-এ চলুক; container সেটিকে সস্তা করেছে, কিন্তু প্রতিটি test-এর জন্য নয়।

প্র ০৪Per-test rollback খুব দ্রুত আর পরিষ্কার। তাহলে কোন ধরনের bug এটি লুকিয়ে ফেলতে পারে, আর বড় framework-গুলো এই সমস্যা কীভাবে সামলায়?

Per-test rollback-এর মূল কৌশল: test কখনো commit করে না। এখানেই এর দুর্বলতা, কারণ বাস্তবের system-এ অনেক কিছু ঘটে ঠিক commit-এর মুহূর্তে বা তার পরে। প্রথমত, কিছু constraint commit-এ যাচাই হয়। PostgreSQL-এ একটি foreign key-কে DEFERRABLE INITIALLY DEFERRED করা যায়, যার যাচাই হয় transaction শেষে। Test commit না করলে ভাঙা সম্পর্কের ডেটাও সবুজ থেকে যায়। দ্বিতীয়ত, commit-এর পরের কাজ: order জমা হলে ক্রেতাকে SMS পাঠানো বা একটি event ছাড়া। অনেক framework এমন কাজকে “commit সফল হলে চালাও” তালিকায় রাখে; test কখনো commit না করলে কাজটিও কখনো চলে না।

Django এই পার্থক্যটি নথিতেই স্পষ্ট রাখে। তার TestCase প্রতিটি test-কে একটি transaction-এ মোড়ায় আর শেষে rollback করে, আর কোডের ভেতরের atomic ব্লকগুলো savepoint হয়ে যায়। তাই transaction.on_commit-এ রাখা কাজ সাধারণত চলে না; Django ৩.২ থেকে এগুলো ধরার জন্য captureOnCommitCallbacks আছে। যেখানে আসল commit-এর আচরণ যাচাই দরকার, সেখানে TransactionTestCase, যা আসলেই commit করে আর test-এর পরে টেবিল খালি করে, অনেক ধীরে।

তৃতীয় ফাঁদ connection. Code under test যদি নিজে আলাদা connection খোলে (একটি background worker, বা আলাদা connection pool), সে test-এর না-commit-করা ডেটা দেখতেই পায় না; test তখন অদ্ভুতভাবে ব্যর্থ হয়, বা আরও খারাপ, ভুলভাবে সবুজ থাকে। চতুর্থত, sequence: PostgreSQL-এ rollback-এর পরে id পেছায় না, তাই id-নির্ভর assertion run-ভেদে বদলায়। আর পঞ্চমত, concurrency: দুটি অনুরোধ একই স্টক কমালে কী হয়, তা একটি transaction-এর ভেতরে বসে দেখা যায় না, কারণ সেখানে দ্বিতীয় অনুরোধ নেই।

ব্যবহারিক সমাধান হলো স্তর ভাগ করা: বেশিরভাগ test দ্রুত rollback-এ, আর অল্প কয়েকটি চিহ্নিত test আসল commit-সহ, প্রতিটির পরে truncate বা reset. বাজারঘরের HTTP test-গুলো দ্বিতীয় দলে পড়ে: server নিজের transaction commit করে, আর test reset endpoint দিয়ে পরিষ্কার করে।

মূল উপলব্ধি: Rollback test-কে দ্রুত করে, কিন্তু commit-এর মুহূর্ত আর তার পরের জগৎ দেখায় না; সেগুলোর জন্য আলাদা, আসল commit-এর test রাখুন।

প্র ০৫বড় প্রতিষ্ঠানের অভিজ্ঞতা বলে বড় test বেশি flaky হয়। কেন, আর integration test-এর আকার নিয়ে এ থেকে কী সিদ্ধান্ত নেওয়া যায়?

২০১৬ সালে Google-এর testing blog-এ John Micco-র একটি লেখায় বলা হয়, তাঁদের test run-গুলোর প্রায় ১.৫ শতাংশে flaky ফল আসে, আর প্রায় ১৬ শতাংশ test-এ কোনো না কোনো মাত্রায় অস্থিরতা দেখা গেছে; সংখ্যাগুলো সেই প্রতিষ্ঠানের নিজের পরিবেশের, সব জায়গার জন্য নয়। ২০১৭ সালে একই blog-এ Jeff Listfield-এর একটি বিশ্লেষণ দেখায় যে বড় test (বেশি memory বা বেশি কোড-নির্ভর) flaky হওয়ার সম্ভাবনা বেশি, আর test কোন tool-এ লেখা, তার চেয়ে আকারই বড় ভূমিকা রাখে। Luo ও সহকর্মীদের ২০১৪ সালের গবেষণা open-source project-এ একই ধরনের কারণ পায়: async অপেক্ষা, concurrency আর test-এর ক্রম।

কারণটি গাণিতিকভাবে সহজ। একটি test যত বেশি চলমান অংশের ওপর নির্ভর করে (server, database, network, ঘড়ি, আরেকটি service), তার প্রতিটির ছোট অনিশ্চয়তা যোগ হয়। প্রতিটি অংশ যদি হাজারে একবার গোলমাল করে, দশটি অংশের test প্রায় একশোয় একবার গোলমাল করবে। আর broad test ভাঙলে কারণ খোঁজা কঠিন, তাই দল প্রায়ই “আবার চালাও” বোতাম চাপে; এতে আসল ভুলও “flaky” বলে উপেক্ষিত হয়।

এ থেকে integration test-এর আকার নিয়ে তিনটি সিদ্ধান্ত। প্রথম, যতটা সম্ভব narrow: একটি জোড় যাচাইয়ে শুধু সেই জোড়ের দুই পাশ আসল, বাকিটা নিয়ন্ত্রিত (§৩)। দ্বিতীয়, broad test অল্প, আর প্রতিটির পেছনে স্পষ্ট ঝুঁকি: যেমন বাজারঘরের checkout থেকে delivered পর্যন্ত একটি পথ। তৃতীয়, অস্থিরতার উৎসগুলো নকশা থেকেই বাদ: প্রতি test-এ reset, health check-এ অপেক্ষা, inject করা ঘড়ি, নিজের port. §৬-এর reset ছাড়া run দেখিয়েছে, একটি মাত্র ভাগ করা অবস্থা কত দ্রুত পাঁচটির মধ্যে দুটিকে লাল করতে পারে।

Flaky test-এর সংখ্যা মাপা, quarantine আর স্থায়ী সমাধানের পদ্ধতি পর্ব ৪০-এ আর বড় suite-এর flake budget পর্ব ৬৮ (বড় test suite — selection, sharding, flake budget আর রক্ষণাবেক্ষণ)-এ আসবে।

মূল উপলব্ধি: প্রতিটি নতুন চলমান অংশ অস্থিরতা যোগ করে; integration test-কে যতটা সম্ভব narrow রাখুন, আর broad test-গুলো অল্প ও উদ্দেশ্যমূলক।

অনুশীলন

কাগজ-কলমে করুন, তারপর উত্তর মিলিয়ে নিন। চাইলে উপরের program-গুলো বদলে নিজের উত্তর যাচাই করতে পারেন।

  1. Spec থেকে test (test design): বাজারঘরের নিয়ম: order বাতিল (cancel) করা যায় placed, paid বা packed অবস্থা থেকে, order-এর মালিক বা admin; বাতিলে স্টক ফেরত আসে। refund শুধু cancelled থেকে, আর শুধু যদি টাকা দেওয়া হয়ে থাকে। অন্য সব transition-এ 409 invalid_transition. pack, ship, deliver শুধু admin; অন্য ক্রেতার order-এ 404. Seed: order ৬ (sumi, placed, টাকা দেওয়া হয়নি, তেল ১ আর আলু ১), order ৭ (joy, paid, card), order ৫ (rafi, shipped). Seed-এ তেলের স্টক ৩০, আলুর ৯০. এই seed থেকে HTTP integration test-এর ছয়টি case লিখুন: কে, কোন order-এ, কোন action, প্রত্যাশিত status code আর পার্শ্বফল।

    প্রতিটি সারি চালু app-এ একটি scratch script দিয়ে মেলানো হয়েছে (প্রথম সারির আগে reset, তারপর ক্রমানুসারে):

    কেOrderActionপ্রত্যাশা
    sumi৬pack403 forbidden (শুধু admin)
    joy৬cancel404 order_not_found (অন্যের order, id ফাঁস হয় না)
    sumi৬cancel200 cancelled; তেল ৩০ → ৩১, আলু ৯০ → ৯১
    sumi৬refund409 invalid_transition (টাকা দেওয়া হয়নি)
    joy৭cancel, তারপর refund200 cancelled, তারপর 200 refunded; wallet-এর ledger-এ order ৭-এর charge-এর অবস্থা refunded
    rafi৫cancel409 invalid_transition (shipped)

    লক্ষ করুন, প্রতিটি সারিতে শুধু status code নয়, অন্তত একটি পার্শ্বফলও মেলানো যায়: স্টক, ledger, বা ভুলের code. চতুর্থ সারি তৃতীয়টির ওপর নির্ভর করে; আলাদা test হলে order ৬-কে আগে বাতিল করে নেওয়া সেই test-এর Arrange অংশ।

  2. ব্যর্থতা পড়ুন (read the failure): একজন সহকর্মী বলছেন, “test_cancel_puts_stock_back আমার যন্ত্রে একা চালালে সবুজ, CI-তে পুরো suite-এ লাল: assert 23 == 27. CI নিশ্চয়ই খারাপ।” Suite-এ আগের তিনটি test একই ক্রেতার কার্ট থেকে তেল কেনে: ২টি, ১টি, ১টি। Seed-এ তেল ৩০. CI-তে reset-এর fixture বন্ধ ছিল। ২৩ সংখ্যাটি কোথা থেকে এল, আর দুটি আলাদা প্রতিকার কী?

    ৩০ − ২ − ১ − ১ = ২৬; তারপর এই test নিজে ৩টি কেনে: ২৬ − ৩ = ২৩. Test ধরে নিয়েছিল শুরু ৩০, তাই ৩০ − ৩ = ২৭. CI খারাপ নয়; test-টি order-dependent, আর একা চালালে আগের তিনটির প্রভাব থাকে না বলে সবুজ। এই পাতার সত্যিকারের run-এ ঠিক এই সংখ্যাগুলোই এসেছিল। প্রতিকার (ক): প্রতিটি test-এর আগে reset বা rollback, যাতে প্রতিটি test seed থেকে শুরু করে। প্রতিকার (খ): assertion আপেক্ষিক করা: before = stock(api, OIL), তারপর কেনা, তারপর assert stock(api, OIL) == before - 3, আর বাতিলের পরে == before. দুটি একসাথে রাখাই সবচেয়ে মজবুত; দ্বিতীয়টি parallel run-এও টেকে।

  3. Test-এর ভুল খুঁজুন (find the bug): নিচের fixture আর repository-তে দুটি সমস্যা আছে। Test-গুলো আলাদা আলাদা চালালে সবুজ, একসাথে চালালে দ্বিতীয় test লাল আর teardown-এ একটি ERROR. সমস্যা দুটি কী, আর কীভাবে সারাবেন?
    @pytest.fixture
    def db(engine):
        engine.execute("BEGIN")
        yield engine
        engine.execute("ROLLBACK")
    
    class OrderRepo:
        def save(self, total):
            oid = self.conn.execute("INSERT INTO orders (total) VALUES (?)",
                                    (total,)).lastrowid
            self.conn.commit()
            return oid
    
    def test_new_order_gets_id_8(db):
        assert OrderRepo(db).save(1800) == 8
    
    def test_seed_has_7_orders(db):
        assert db.execute("SELECT COUNT(*) FROM orders").fetchone()[0] == 7

    সমস্যা ১, repository নিজে commit করে: self.conn.commit() fixture-এর খোলা transaction-টিই commit করে দেয়। ফলে order স্থায়ী হয়ে যায়, আর teardown-এর ROLLBACK-এ ভুল আসে: Python-এর sqlite3-এ এটি OperationalError: cannot rollback - no transaction is active (scratch-এ চালিয়ে মেলানো), যা pytest-এ teardown-এর ERROR হিসেবে দেখায়। পরের test তখন ৭ নয়, ৮টি সারি দেখে। সমাধান: transaction-এর সীমা repository নয়, ডাকার অংশ ঠিক করুক (service বা একটি unit of work, যা inject করা যায়); বা app-এর নিজের transaction-কে savepoint বানানো (§৪-এর SQL block). সমস্যা ২, পরম id: == 8 শুধু তখনই টেকে, যখন আগে কেউ ৮ নেয়নি আর engine rollback-এর পরে id পুনরায় দেয়। PostgreSQL-এর sequence-এ এটি rollback-এর পরেও ভাঙবে। ভালো assertion: ফেরত আসা id দিয়ে সারিটি পড়ে মান মেলানো, আর সংখ্যা গোনা আগে-পরে তুলনা করে।

  4. কৌশল বেছে নিন (ভেবে দেখুন): বাজারঘরে একটি নতুন feature আসছে: order delivered হলে courier কোম্পানির API থেকে delivery-র প্রমাণ (ছবির লিংক) এনে database-এ রাখা আর ক্রেতাকে SMS পাঠানো। Courier-এর API তিন সপ্তাহ পরে পাওয়া যাবে; SMS gateway-র একটি sandbox আছে। Database production-এ PostgreSQL. (ক) কোন integration কৌশলে এগোবেন, আর কোথায় stub লাগবে? (খ) প্রতিটি নির্ভরতা integration test-এ আসল না নকল? (গ) কোন test per-test rollback-এ চলবে না, আর কেন?

    (ক) Top-down বা sandwich: নিজের service আর API এখনই বানিয়ে জোড়া যায়, আর courier-এর জায়গায় একটি stub (বা তাদের প্রকাশিত নথি থেকে বানানো একটি নকল server, পর্ব ৩৪) বসবে, যা ঠিক করা উত্তর দেয়, ধীর উত্তর আর ভুলও দিতে পারে। নিজের courier adapter-টি আজই লিখে stub-এর বিপরীতে প্রতিদিন জোড়া লাগানো: তিন সপ্তাহ পরে একবারে জোড়ার চেয়ে কম ঝুঁকি। (খ) নিজের service আর delivery-র নিয়ম আসল; database আসল PostgreSQL, একই সংস্করণ, যেমন Testcontainers-এ; courier এখন stub, পরে তাদের sandbox-এর বিপরীতে অল্প কয়েকটি আলাদা test আর একটি contract test (পর্ব ৩২); SMS-এর বেশিরভাগ test-এ নকল gateway, আর sandbox-এর বিপরীতে অল্প কয়েকটি। (গ) “SMS শুধু order delivered হওয়ার transaction commit হলে যায়” এই আচরণ per-test rollback-এ যাচাই হবে না, কারণ commit-ই হয় না; এর জন্য আসল commit আর পরে truncate বা reset-এর আলাদা test লাগবে। একইভাবে, যদি delivery-র প্রমাণ আনার কাজ একটি background worker নিজের connection-এ করে, সেটিও rollback-এর test-এ test-এর ডেটা দেখবে না।

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

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

ক্রমPer-test transaction আর rollback ব্যবহার করা একটি pytest suite-এ ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Session fixture একবার schema বানায় আর seed ডেটা বসায়
  2. Function fixture প্রথম test-এর আগে BEGIN করে
  3. Test ডেটা লেখে আর assertion চালায়
  4. Function fixture-এর teardown ROLLBACK করে, database seed-এর অবস্থায় ফেরে
  5. পরের test আবার BEGIN থেকে শুরু করে
  6. সব test শেষে session fixture connection বন্ধ করে

Bottom-up integration testing-এ ওপরের, এখনো জোড়া না হওয়া module-এর জায়গায় কী ব্যবহার করা হয়?

  • Stub, যা ঠিক করা উত্তর ফেরত দেয়
  • Driver, যা নিচের module-কে ডাকে আর ফল মেলায়
  • Fake object, যা memory-তে ডেটা রাখে
  • কিছুই না, কারণ ওপরের module লাগে না

একটি service-এর unit test-এ repository-র mock দিয়ে সব test সবুজ, কিন্তু আসল SQLite-এর সাথে জোড়া দিতেই IntegrityError: CHECK constraint failed. এর সবচেয়ে সম্ভাব্য ব্যাখ্যা কী?

  • pytest-এর একটি bug, যা mock-কে ভুলভাবে সবুজ দেখায়
  • SQLite CHECK constraint ঠিকভাবে প্রয়োগ করে না
  • Service database-এর নিয়মের বাইরের মান পাঠাচ্ছে, যা mock জানতে পারে না
  • In-memory database-এ constraint কাজ করে না, ফাইলে করে

একটি integration test একা চালালে সবুজ, পুরো suite-এ লাল: assert (12, 'placed') == (8, 'placed'). প্রথম কোন সন্দেহটি যাচাই করবেন?

  • আগের test-এর ডেটা থেকে যাচ্ছে; reset বা rollback চলছে না, আর test পরম id ধরে নিয়েছে
  • Server ধীর, তাই timeout বাড়ানো দরকার
  • pytest-এর version পুরোনো
  • Test-টিকে retry দিয়ে তিনবার চালানো

Production-এ PostgreSQL, আর test-এ SQLite in-memory. নিচের কোন ঝুঁকিটি এই ব্যবস্থায় সবচেয়ে কম প্রাসঙ্গিক?

  • ভুল ধরনের মান SQLite-এ জমা হয়, PostgreSQL-এ ভুল দেয়
  • Rollback-এর পরে id-এর আচরণ আলাদা
  • একসাথে চলা লেখার lock-এর আচরণ আলাদা
  • Coupon-এর ১০% ছাড়ের pure হিসাব ভুল আসা

Per-test transaction আর rollback-এর suite-এ code under test নিজেই conn.commit() ডাকে। কী ঘটার সম্ভাবনা সবচেয়ে বেশি?

  • Commit উপেক্ষিত হয়, কারণ test-এর transaction খোলা
  • শুধু code-এর নিজের লেখাটুকু স্থায়ী হয়, বাকিটা rollback হয়
  • Test-এর transaction commit হয়ে ডেটা থেকে যায়, পরের test তা দেখে
  • SQLite commit নিষেধ করে, তাই test সাথে সাথে ব্যর্থ হয়

বাজারঘরের একটি দলের integration test-এর জন্য নির্ভরতা বেছে নেওয়ার কোন সিদ্ধান্তটি সবচেয়ে যুক্তিসঙ্গত?

  • নিজের database আর দামের নিয়ম আসল, mobile wallet নকল gateway
  • Database mock, wallet আসল, যাতে টাকার পথ যাচাই হয়
  • সব আসল, wallet-এ প্রতিবার আসল টাকা কেটে পরে ফেরত
  • দামের নিয়ম mock, যাতে test দ্রুত হয়

শব্দকোষ

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

মনে রাখুন

  1. Integration test জোড় দেখে: field-এর নাম, একক, মানের বানান, constraint আর transaction-এর সীমা; mock-ভিত্তিক unit test এগুলো দেখে না।
  2. Top-down-এ stub, bottom-up-এ driver; big-bang-এ ভুলের জায়গা খোঁজা কঠিন; continuous integration জোড়াকে ছোট আর ঘন ঘন করে।
  3. যে জোড় যাচাই করছেন, তার দুই পাশ আসল; নিজের database আর pure নিয়ম আসল, তৃতীয় পক্ষ নকল বা sandbox.
  4. Test database পরিষ্কার রাখুন: নতুন database, per-test rollback (code নিজে commit করলে savepoint), reset বা truncate; database-এর জোড় production-এর একই engine-এ, প্রয়োজনে Testcontainers.
  5. অস্থিরতার উৎস নকশাতেই বাদ দিন: প্রতি test-এ reset, আপেক্ষিক assertion, health check-এ অপেক্ষা, inject করা ঘড়ি; broad test অল্প আর উদ্দেশ্যমূলক।

পরের পর্বে: Tester-এর চোখে HTTP: request আর response-এর গঠন, method-এর অর্থ, কোন status code কখন, JSON-এর চেনা ডেটা-ভুল, আর curl ও DevTools দিয়ে বাজারঘরের API পরীক্ষা। পর্ব ২৯ (Tester-এর জন্য HTTP আর REST — method, status code আর JSON).

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

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