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

Test double গভীরে — unittest.mock, patch আর mock-এর ফাঁদ

Test Doubles in Depth — unittest.mock, patch and Mocking Pitfalls

Taught in Bangla, this lesson picks among dummy, stub, spy, mock and fake for each Bazarghar payment collaborator, with the mobile wallet always mocked. In-page Python shows Mock silently accepting a wrong method while create_autospec catches it, side_effect lists producing two timeouts then success for retry logic, and where to patch. A real pytest 9.2.0 and pytest-mock 3.17.0 run includes two deliberate failures to read. It covers call assertions, controlling time and random, over-mocking, mock drift and fakes.

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

  • পাঁচ ধরনের test double চিনে বাজারঘরের প্রতিটি সহযোগীর জন্য ঠিকটি বাছাই করা
  • Mock, MagicMock, spec আর autospec-এর পার্থক্য, আর return_value ও side_effect দিয়ে timeout, decline আর retry চালানো
  • ডাক যাচাইয়ের সঠিক assertion বাছাই করা, আর patch-এর target খুঁজে বের করা
  • pytest-mock-এর mocker দিয়ে নিজের কম্পিউটারে test চালানো ও ব্যর্থতার রিপোর্ট পড়া
  • সময় আর random নিয়ন্ত্রণ করা, আর over-mocking ও mock drift চিনে fake ও contract দিয়ে ঠেকানো

১ · Test double আবার — পাঁচ নকল আর বাজারঘরের payment ধাপ

ক্রিকেট দলের নেট অনুশীলনে আসল বোলার সবসময় পাওয়া যায় না। তখন bowling machine একই গতিতে, একই লাইনে বল ছোড়ে, যতবার দরকার। ব্যাটসম্যান ইয়র্কার খেলা অনুশীলন করতে চাইলে মেশিনে পরপর তিনটি ইয়র্কার ঠিক করে দেওয়া যায়। আসল ম্যাচে এমন সুযোগ পেতে হয়তো সারা মৌসুম লাগত। Unit test-এ test double ঠিক এই মেশিন: আসল সহযোগীর জায়গায় বসা এমন নকল, যার আচরণ test নিজে ঠিক করে দেয়।

সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৯-এ Gerard Meszaros-এর xUnit Test Patterns (২০০৭) বইয়ের পাঁচ রকম double-এর সংজ্ঞা আর প্রথম উদাহরণ আছে; Python প্রোগ্রামিং কোর্সের পর্ব ৪২-এ fake বনাম mock-এর প্রাথমিক পরিচয়। এখানে সংক্ষেপে মনে করিয়ে দিয়ে অনেক গভীরে যাব: Python-এর unittest.mock-এর প্রায় সব গুরুত্বপূর্ণ অংশ, patch-এর নিয়ম, একটি সত্যিকারের pytest plugin, আর সেই ফাঁদগুলো যেখানে mock test-কে মিথ্যা আশ্বাসে ভরে দেয়।

Doubleকাজবাজারঘরে উদাহরণ
Dummyশুধু parameter-এর জায়গা পূরণ; কখনো ব্যবহার হয় নাযে logger-এর কোনো লাইন test-এর পথে চলে না
Stubআগে থেকে ঠিক করা উত্তর দেয়wallet সবসময় {"txn_id": "T-77"} দেয়
Spyআসল বা নকল কাজের সাথে প্রতিটি ডাক লিখে রাখেsleep কত সেকেন্ডে ডাকা হলো, পরে যাচাই
Mockকোন ডাক কোন argument-এ আসবে, তার প্রত্যাশা যাচাই করেwallet-এর pay ঠিক একবার, ref="BG-1002" নিয়ে
Fakeসত্যিই কাজ করে, কিন্তু সহজ পথেdict-এ রাখা order repository বা in-memory wallet

খেয়াল করুন, Python-এর Mock class একাই stub, spy আর mock তিনটির কাজ করতে পারে: return_value দিলে stub, ডাকের খাতা পড়লে spy, প্রত্যাশা assert করলে mock. তাই কথ্য ভাষায় সবকিছুকে “mock” বলা হয়। Exam আর interview-তে কিন্তু সংজ্ঞার পার্থক্য জিজ্ঞাসা করা হয়, আর নকশার সিদ্ধান্তেও পার্থক্যটি জরুরি: stub-এর ক্ষেত্রে আপনি ফল যাচাই করেন (state verification), mock-এর ক্ষেত্রে ডাকগুলো (behaviour verification).

কখন double নয়? যে সহযোগী দ্রুত, নিশ্চিত আর নিজের ঘরের, যেমন coupon বা delivery-র হিসাব, তাকে আসলই রাখুন। নকল বসানোর প্রতিটি জায়গা একটি অনুমান: “আসলটি এমনই আচরণ করবে।” অনুমান যত কম, test তত সৎ। Double-এর সঠিক জায়গা চারটি: যা ধীর (database, network), যা অনিশ্চিত (সময়, random), যা বিপজ্জনক বা খরুচে (টাকা কাটা, SMS পাঠানো), আর যা এখনো তৈরিই হয়নি (অন্য দলের service). বাজারঘরের wallet একসাথে তিনটি শর্ত পূরণ করে, তাই এই পর্বের প্রধান চরিত্র সে-ই।

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

Payment: checkout-এর শেষে mobile wallet-এ টাকা কাটা হয় (এটি সবসময় MOCK, কোনো আসল wallet নয়)। Wallet সময়মতো উত্তর না দিলে (timeout) মোট ৩ বার পর্যন্ত চেষ্টা, মাঝে ১ আর ২ সেকেন্ড অপেক্ষা; wallet টাকা কাটতে অস্বীকার করলে (decline) আর চেষ্টা নয়। প্রতিটি চেষ্টায় order id যায় ref হিসেবে, যাতে wallet একই অর্ডার দুবার না কাটে। Coupon আর delivery আগের মতো: ১০০০ টাকার বেশি অর্ডারে ১০% ছাড়, সর্বোচ্চ ৩০০, পূর্ণ টাকায়; ঢাকায় ৬০ টাকা, ২০০০ বা বেশি হলে ফ্রি (ছাড়ের আগের অঙ্কে), বাইরে ১২০, Plus সদস্যের ৬০.

বাজারঘরের charge() আর তার সহযোগীরা

Each collaborator of the system under test gets the double that fits its role

charge() আর চার সহযোগী: wallet = mock/stub, sleep = spy, repository = fake, logger = dummy charge() SUT WalletClient mock + stub timeout-এর ক্রম sleep(seconds) spy ডাক লিখে রাখে OrderRepo fake dict-এ সংরক্ষণ logger dummy শুধু জায়গা পূরণ
ছবি ২৪.১ — SUT একটাই, double চার রকম। Order repository আর logger আছে charge()-এর একটু বড় রূপে; এই পর্বের কোডে প্রথম দুটি। যে সহযোগী ধীর, অনিশ্চিত, টাকা-জড়িত বা বাইরের, তাকেই নকল করুন; সাধারণ হিসাবের function (coupon, delivery) আসলই থাকুক, §৮-এ এর কারণ দেখবেন।

২ · Mock, MagicMock, spec আর autospec — নকল কতটা আসলের মতো

unittest.mock Python 3.3 থেকে standard library-র অংশ; এর আগে এটি Michael Foord-এর আলাদা mock library ছিল। এর কেন্দ্রে চারটি জিনিস, নকলের “কড়াকড়ি” অনুযায়ী সাজানো:

Mock

যেকোনো attribute চাইলে সাথে সাথে নতুন একটি child Mock তৈরি করে; যেকোনো argument-এ ডাক মেনে নিয়ে খাতায় লেখে। সবচেয়ে নমনীয়, সবচেয়ে কম নিরাপদ।

MagicMock

MagicMock একই, সাথে len(), with, [], for-এর মতো magic method সাজানো (len(MagicMock()) দেয় 0). patch নিজে থেকে এটিই বসায়।

spec / spec_set

Mock(spec=WalletClient) শুধু আসল class-এ থাকা নাম মেনে নেয়; spec_set অজানা নামে মান বসানোও আটকায়। তবে method-এর argument যাচাই করে না।

Autospec

create_autospec(WalletClient, instance=True) বা patch(..., autospec=True): নাম আর প্রতিটি method-এর signature দুটিই আসল class থেকে নেয়।

পার্থক্যটা সবচেয়ে ভালো বোঝা যায় দুটি সাধারণ ভুলে। একজন developer refund-এর কোডে client.refund_payment(...) লিখলেন, অথচ আসল method refund. আরেকজন pay-কে শুধু টাকার অঙ্ক দিলেন, ref ভুলে গেলেন। দুটি কোডই production-এ প্রথম ডাকেই ভাঙবে। নিচে প্রতিটি ভুলের জন্য দুটি test: একটি সাধারণ Mock দিয়ে, একটি autospec দিয়ে। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

import io, sys, unittest
from unittest.mock import Mock, create_autospec

class WalletClient:                       # the real client's shape
    def pay(self, amount, ref): ...
    def refund(self, txn_id): ...

def cancel_paid_order(order, client):     # seeded typo: refund_payment
    client.refund_payment(order["txn"])
    return "refunded"

def charge(order_id, amount, client):     # seeded mistake: forgot ref
    return client.pay(amount)["txn_id"]

class DoubleKindTest(unittest.TestCase):
    def test_refund_plain_mock(self):
        self.assertEqual(cancel_paid_order({"txn": "T-7"}, Mock()), "refunded")
    def test_refund_autospec(self):
        client = create_autospec(WalletClient, instance=True)
        self.assertEqual(cancel_paid_order({"txn": "T-7"}, client), "refunded")
    def test_pay_plain_mock(self):
        client = Mock(); client.pay.return_value = {"txn_id": "T-8"}
        self.assertEqual(charge("BG-8", 700, client), "T-8")
    def test_pay_autospec(self):
        client = create_autospec(WalletClient, instance=True)
        client.pay.return_value = {"txn_id": "T-8"}
        self.assertEqual(charge("BG-8", 700, client), "T-8")

buf = io.StringIO()
suite = unittest.defaultTestLoader.loadTestsFromTestCase(DoubleKindTest)
result = unittest.TextTestRunner(stream=buf, verbosity=2).run(suite)
print("\n".join(l for l in buf.getvalue().splitlines() if l.endswith(("ok", "ERROR"))))
for test, tb in result.errors:
    print(test.id().split(".")[-1], "->", tb.strip().splitlines()[-1])

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

test_pay_autospec (__main__.DoubleKindTest.test_pay_autospec) ... ERROR
test_pay_plain_mock (__main__.DoubleKindTest.test_pay_plain_mock) ... ok
test_refund_autospec (__main__.DoubleKindTest.test_refund_autospec) ... ERROR
test_refund_plain_mock (__main__.DoubleKindTest.test_refund_plain_mock) ... ok
test_pay_autospec -> TypeError: missing a required argument: 'ref'
test_refund_autospec -> AttributeError: Mock object has no attribute 'refund_payment'

সাধারণ Mock-এর দুটি test পাস, অথচ দুটি কোডই ভুল: refund_payment নামে কোনো method আসল client-এ নেই, আর pay-এর ref বাদ পড়েছে। Mock এগুলো মেনে নিয়েছে, কারণ তার কাছে কোনো নামই অচেনা নয়। Autospec দুটি ভুলই ধরল: AttributeError আর TypeError: missing a required argument: 'ref'. সাধারণ Mock-এর পাস তাই একটি false negative: defect আছে, test ধরেনি; আর autospec-এর ব্যর্থতাই সঠিক খবর। তাই নিয়ম হিসেবে মনে রাখুন: বাইরের client-এর double বানালে autospec দিয়ে শুরু করুন। (Runner-এর বিস্তারিত traceback ছোট রাখতে এখানে শুধু শেষ লাইন ছাপা হয়েছে।)

Autospec-এর সীমা। এটি নাম আর argument মেলায়, ফেরত মানের গঠন নয়। আসল pay যদি একদিন {"txn_id": …}-এর বদলে {"transaction_id": …} ফেরত দিতে শুরু করে, autospec-ওয়ালা test-ও সবুজ থাকবে। এই ফাঁকের নাম mock drift; §৮-এ এর প্রতিকার।

Autospec-এর আরেকটি খুঁটিনাটি প্রায় সবাইকে একবার আটকায়। এটি class-এর সংজ্ঞা পড়ে, চালায় না; তাই __init__-এর ভেতরে self.base_url = … লিখে তৈরি হওয়া attribute সে দেখতে পায় না। create_autospec(WalletClient, instance=True).base_url চাইলে আসে AttributeError: Mock object has no attribute 'base_url' (Python 3.14-এ চালিয়ে দেখা)। সমাধান: test-এ মানটি নিজে বসিয়ে দিন (client.base_url = "…"), অথবা class-এর স্তরে একটি ঘোষণা রাখুন। আর SUT যদি async def method ডাকে, তার জন্য আছে AsyncMock (Python 3.8 থেকে), যার ডাক await করা যায়; autospec async method চিনে নিজেই এটি বসায়।

৩ · return_value আর side_effect — উত্তর, exception আর ক্রম

Double-এর উত্তর ঠিক করার দুটি উপায়। return_value প্রতিটি ডাকে একই উত্তর দেয়: সরল stub. side_effect অনেক শক্তিশালী, তিন রূপে কাজ করে:

  • Exception: side_effect = WalletTimeout("no answer") হলে প্রতিটি ডাকে exception ছোড়া হয়। Timeout, network বিচ্ছিন্নতা, ডিস্ক ভরা: যে ভুল আসল জগতে ঘটানো কঠিন, তা এক লাইনে।
  • তালিকা (iterable): প্রতিটি ডাকে তালিকার পরের জিনিস। জিনিসটি exception (class বা object) হলে ছোড়া হয়, অন্যথায় ফেরত দেওয়া হয়। তালিকা ফুরালে পরের ডাকে StopIteration.
  • Function: একই argument পেয়ে চলে; তার ফেরত মানই উত্তর। Argument অনুযায়ী ভিন্ন উত্তর দিতে কাজে লাগে, যেমন ৫০,০০০ টাকার বেশি হলে decline.
def wallet_rule(amount, ref):                 # a tiny, rule-based stub
    if amount > 50000:
        raise WalletDeclined("limit")
    return {"txn_id": "T-" + ref}

wallet = Mock()
wallet.pay.side_effect = wallet_rule
wallet.pay(amount=700, ref="BG-7")           # {'txn_id': 'T-BG-7'}
wallet.pay(amount=60000, ref="BG-8")         # raises WalletDeclined

ওপরের ছোট উদাহরণটি scratch-এ চালিয়ে মন্তব্যের ফলগুলো মেলানো হয়েছে। Function রূপ আসলে একটি ছোট fake-এর দিকে প্রথম পদক্ষেপ: উত্তর আর argument-এর মধ্যে নিয়ম আছে। নিয়ম বড় হতে থাকলে আলাদা একটি fake class লেখাই পরিষ্কার (§৮)।

Retry-এর retry যুক্তি test করার জন্য তালিকা রূপটি আদর্শ। আসল wallet-কে দুবার timeout আর তৃতীয়বারে সফল হতে বাধ্য করা প্রায় অসম্ভব; mock দিয়ে এটি একটি লাইন। আর অপেক্ষার জন্য আসল time.sleep-এর বদলে sleep parameter-এ একটি Mock ঢুকিয়ে দেওয়া হয়েছে: test সত্যি তিন সেকেন্ড বসে থাকে না, আর spy হিসেবে লিখে রাখে কত সেকেন্ডের অপেক্ষা চাওয়া হয়েছিল (১, তারপর ২: exponential backoff).

import sys, unittest
from unittest.mock import Mock, call
class WalletTimeout(Exception): pass
class WalletDeclined(Exception): pass
def charge(order_id, amount, client, sleep, tries=3):
    for attempt in range(1, tries + 1):
        try:
            receipt = client.pay(amount=amount, ref=order_id)
            return {"status": "paid", "txn": receipt["txn_id"], "tries": attempt}
        except WalletDeclined:
            return {"status": "declined", "tries": attempt}
        except WalletTimeout:
            if attempt == tries:
                return {"status": "failed", "tries": attempt}
            sleep(2 ** (attempt - 1))

class ChargeTest(unittest.TestCase):
    def setUp(self):
        self.wallet, self.sleep = Mock(), Mock()
    def test_paid_on_third_try(self):
        self.wallet.pay.side_effect = [WalletTimeout(), WalletTimeout(), {"txn_id": "T-77"}]
        r = charge("BG-1001", 1890, self.wallet, self.sleep)
        self.assertEqual(r, {"status": "paid", "txn": "T-77", "tries": 3})
        self.assertEqual(self.sleep.call_args_list, [call(1), call(2)])
        refs = {c.kwargs["ref"] for c in self.wallet.pay.call_args_list}
        print("\n  pay calls:", self.wallet.pay.call_count, "refs:", refs)
    def test_three_timeouts_fail(self):
        self.wallet.pay.side_effect = WalletTimeout("no answer")
        self.assertEqual(charge("BG-1002", 900, self.wallet, self.sleep), {"status": "failed", "tries": 3})
    def test_decline_not_retried(self):
        self.wallet.pay.side_effect = WalletDeclined("low balance")
        self.assertEqual(charge("BG-1003", 500, self.wallet, self.sleep)["tries"], 1)
        self.sleep.assert_not_called()
suite = unittest.defaultTestLoader.loadTestsFromTestCase(ChargeTest)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)

আসল আউটপুট:

test_decline_not_retried (__main__.ChargeTest.test_decline_not_retried) ... ok
test_paid_on_third_try (__main__.ChargeTest.test_paid_on_third_try) ... 
  pay calls: 3 refs: {'BG-1001'}
ok
test_three_timeouts_fail (__main__.ChargeTest.test_three_timeouts_fail) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK

তিনটি test-ই পাস, আর তিনটি ভিন্ন পরিস্থিতি একই Mock-এ তৈরি হয়েছে। test_paid_on_third_try-এর ছাপা লাইনটি দেখায় pay তিনবার ডাকা হয়েছে, আর তিনবারই একই ref 'BG-1001' গেছে, অর্থাৎ wallet দুবার টাকা কাটার সুযোগ পায় না (§৮-এর fake এটি সত্যিই যাচাই করবে)। Decline-এর test-এ assert_not_called() নিশ্চিত করে, অস্বীকৃত payment আবার চেষ্টা হয়নি; গ্রাহকের wallet-এ বারবার অনুরোধ যাওয়া বিরক্তিকর আর ঝুঁকিপূর্ণ। এখানে sleep বাইরে থেকে দেওয়া হয়েছে (dependency injection), তাই কোনো patch লাগেনি।

নিচের stepper প্রথম test-টি লাইন ধরে চালায়: side_effect-এর তালিকা কীভাবে loop-কে চালায়, আর প্রতিটি ধাপে mock-এর খাতায় কী জমে।

1def charge(order_id, amount, client, sleep, tries=3):2    for attempt in range(1, tries + 1):3        try:4            receipt = client.pay(amount=amount, ref=order_id)5            return {"status": "paid", ...}6        except WalletDeclined:7            return {"status": "declined", ...}8        except WalletTimeout:9            if attempt == tries:10                return {"status": "failed", ...}11            sleep(2 ** (attempt - 1))
Mock-এর খাতা
attempt
pay() দিল
তালিকায় বাকি
sleep-এর ডাক
  1. প্রথম চেষ্টা। attempt = ১, client.pay(...) ডাকা হলো। Mock তালিকার প্রথম জিনিসটি নিল: একটি WalletTimeout object. এটি exception, তাই ফেরত না দিয়ে ছোড়া হলো। তালিকায় বাকি ২টি।
  2. প্রথম অপেক্ষা। except WalletTimeout ধরল; attempt (১) এখনো tries (৩)-এর সমান নয়, তাই sleep(2 ** 0), অর্থাৎ sleep(1). Spy খাতায় লিখল call(1); সত্যি কোনো অপেক্ষা হলো না।
  3. দ্বিতীয় চেষ্টা। attempt = ২, আবার pay; তালিকার দ্বিতীয় জিনিস, আবার timeout. বাকি ১টি।
  4. দ্বিতীয় অপেক্ষা। sleep(2 ** 1) = sleep(2). খাতায় এখন [call(1), call(2)]: backoff দ্বিগুণ হচ্ছে কি না, test ঠিক এটিই যাচাই করবে।
  5. তৃতীয় চেষ্টা সফল। তালিকার শেষ জিনিস একটি dict, exception নয়, তাই ফেরত দেওয়া হলো। লাইন ৫ ফল বানাল: paid, T-77, tries ৩. তালিকা এখন খালি; চতুর্থ ডাক হলে StopIteration আসত।
  6. যাচাই। ফলের dict আর sleep.call_args_list == [call(1), call(2)] দুটিই মিলল: test পাস। কেউ backoff ভুলে sleep(1) স্থির রাখলে, বা চেষ্টা ২ বারে থামালে, এই test লাল হতো।

৪ · ডাক যাচাই — কোন assertion কী বলে, আর কী বলে না

Mock-এর খাতা পড়ার অনেক উপায়, আর ভুলটি বাছলে test দুর্বল হয়ে যায়। একটি গ্রাহককে দুবার SMS বা দুবার টাকা কাটা, এমন bug ধরা পড়বে কি না, তা নির্ভর করে কোন assertion লিখলেন তার ওপর:

যাচাইকী নিশ্চিত করেসতর্কতা
assert_called_with(...)শুধু শেষ ডাকের argumentআগে কতবার, কী দিয়ে ডাকা হলো দেখে না
assert_called_once_with(...)ঠিক একবার, এই argument-এদ্বিগুণ চার্জ ধরে; সবচেয়ে কড়া একক যাচাই
assert_any_call(...)অন্তত একবার এমন ডাকসংখ্যা আর ক্রম দেখে না
assert_has_calls([...])এই ডাকগুলো এই ক্রমে আছেমাঝে বাড়তি ডাক থাকলেও পাস করতে পারে
call_args_list == [...]পুরো ইতিহাস, হুবহুসবচেয়ে নির্দিষ্ট; implementation বদলালে ভাঙতে পারে
assert_not_called()একবারও ডাকা হয়নি“decline-এ retry নয়”-এর মতো নিয়মে দরকারি

Argument-এর কিছু অংশ অপ্রাসঙ্গিক হলে unittest.mock.ANY ব্যবহার করুন, যেমন pay.assert_called_once_with(amount=1890, ref=ANY). আর mock_calls একটি parent mock-এর সব child-এর ডাক এক তালিকায় রাখে, তাই “আগে pay, পরে SMS” ধরনের ক্রম যাচাই করা যায়। কৌশলটি হলো দুটি double-কে একই parent-এর child বানানো:

shop = Mock()
shop.wallet.pay.return_value = {"txn_id": "T-1"}
checkout(wallet=shop.wallet, sms=shop.sms)      # SUT pays, then texts
assert shop.mock_calls == [
    call.wallet.pay(amount=1890, ref="BG-1"),
    call.sms.send("01700000000", "paid T-1"),
]

কেউ ভুল করে টাকা কাটার আগে “paid” SMS পাঠানোর কোড লিখলে তালিকার ক্রম মিলবে না, test লাল হবে (একটি ছোট checkout লিখে scratch-এ যাচাই করা)। ফোন নম্বরটি বানানো, বাজারঘরের নিয়ম মানে: ১১ অঙ্ক, শুরু 01, তৃতীয় অঙ্ক 3–9.

বানান ভুলের ফাঁদ। Mock যেকোনো নাম মেনে নেয়, তাই একসময় m.asert_called_once() লিখলে সেটি নীরবে একটি নতুন Mock ডেকে পাস করত, কিছুই যাচাই না করে। Python 3.5 থেকে assert বা assret দিয়ে শুরু নামে AttributeError আসে, পরে আরও কিছু ভুল বানান এই তালিকায় যোগ হয়েছে; Python 3.14-এ asert_called বা called_once_with লিখে চালালে দুটিতেই error আসে। তবু নিরাপদ অভ্যাস: double-এ spec বা autospec দিন, আর প্রতিটি নতুন test একবার ইচ্ছা করে লাল করে দেখুন।

আরেকটি সূক্ষ্ম বিষয়: কতটা যাচাই করবেন। Payment-এ “ঠিক একবার, এই অঙ্কে, এই ref-এ” যাচাই ব্যবসার নিয়ম, তাই কড়া assertion সঠিক। কিন্তু ভেতরের সাহায্যকারী function কোন ক্রমে ডাকা হলো, এমন খুঁটিনাটি assert করলে test implementation-এর প্রতিলিপি হয়ে যায়; আচরণ না বদলে কোড সাজালেও test ভাঙে। নিয়মটি সহজ: বাইরের জগতে যা যায় (টাকা, SMS, email, অন্য service-এ অনুরোধ) তার ডাক যাচাই করুন; ভেতরের হিসাবের জন্য ফল যাচাই করুন। পর্ব ২২-এ assertion-এর মান নিয়ে আরও আছে।

৫ · patch — “যেখানে খোঁজা হয়, সেখানে”

§৩-এ sleep আর client parameter হিসেবে দেওয়া যেত। কিন্তু অনেক কোড সহযোগীকে নিজেই বানায়: বাজারঘরের আসল payment.py-তে client না দিলে WalletClient() তৈরি হয়। তখন test চলাকালে নামটিকে সাময়িক বদলাতে হয়: patch. এটি monkey patching-এর নিয়ন্ত্রিত রূপ: শুরুতে আসল object মনে রাখে, শেষে ঠিক ফিরিয়ে দেয়, test ব্যর্থ হলেও।

Python-এর অফিসিয়াল নথির “Where to patch” অংশের মূল কথা: patch করুন যেখানে object-টি খোঁজা হয়, যেখানে সংজ্ঞায়িত সেখানে নয়। কেন, তা import-এর আচরণে। from shop.wallet import WalletClient চললে payment module-এর ভেতরে একটি নতুন নাম তৈরি হয়, যা সেই মুহূর্তের class-কে দেখায়। (Module আর import-এর মূল বিষয় Python প্রোগ্রামিং কোর্সের পর্ব ২২-এ।)

shop.wallet · shop.payment · charge()
wallet.WalletClient
payment.WalletClient
charge() পায়
ফল
  1. Import-এর মুহূর্ত। payment.py-র প্রথম লাইন from shop.wallet import WalletClient. এখন দুটি নাম, একটি object: wallet.WalletClient আর payment.WalletClient.
  2. ভুল target. patch("shop.wallet.WalletClient") শুধু wallet module-এর নামটিকে MagicMock দিয়ে বদলায়। payment-এর নামটির কথা কেউ জানে না; সেটি আগের মতোই আসল class দেখায়।
  3. charge() চলল। Function-এর ভেতরে WalletClient খোঁজা হয় payment-এর global namespace-এ। পাওয়া গেল আসল class, তার pay ডাকা হলো, আর এসে পড়ল RuntimeError: REAL NETWORK CALL. বাস্তবে এখানে সত্যিকারের network অনুরোধ চলে যেত।
  4. Patch শেষ। with block থেকে বের হতেই wallet-এর নাম আবার আসল class-এ ফিরল। Patch সবসময় সাময়িক।
  5. সঠিক target. patch("shop.payment.WalletClient"): ঠিক যে নাম charge() খোঁজে। WalletClient() এখন MagicMock-এর return_value ফেরত দেয়, যা “instance”; তার pay.return_value ঠিক করা ছিল, তাই ফল 'T-2'.
  6. patch.object. patch.object(payment, "WalletClient") একই নাম বদলায়, তবে string-এর বদলে module object দিয়ে। Module-এর নামে বানান ভুল হলে test লোড হওয়ার সময়েই error আসে। শেষে দুটি নামই আবার একই আসল class দেখায়।

এবার এই তিনটি ঘটনাই আসল কোডে। Block-টি ব্রাউজারের ফাইল সিস্টেমে সত্যিকারের দুটি module (shop/wallet.py, shop/payment.py) লিখে import করে, তারপর তিনভাবে patch করে:

import os, sys, unittest
from unittest.mock import patch
os.makedirs("/tmp/p24/shop", exist_ok=True)
files = {"__init__.py": "",
  "wallet.py": "class WalletClient:\n    def pay(self, amount, ref):\n"
               "        raise RuntimeError('REAL NETWORK CALL')\n",
  "payment.py": "from shop.wallet import WalletClient\n"
                "def charge(order_id, amount):\n"
                "    return WalletClient().pay(amount=amount, ref=order_id)['txn_id']\n"}
for name, text in files.items():
    with open("/tmp/p24/shop/" + name, "w") as f: f.write(text)
sys.path.insert(0, "/tmp/p24")
from shop import payment, wallet

class PatchTargetTest(unittest.TestCase):
    def test_1_where_defined(self):                 # wrong target
        with patch("shop.wallet.WalletClient") as FakeClient:
            FakeClient.return_value.pay.return_value = {"txn_id": "T-1"}
            self.assertEqual(payment.charge("BG-1", 700), "T-1")

    def test_2_where_looked_up(self):               # right target
        with patch("shop.payment.WalletClient") as FakeClient:
            FakeClient.return_value.pay.return_value = {"txn_id": "T-2"}
            self.assertEqual(payment.charge("BG-2", 700), "T-2")
            FakeClient.return_value.pay.assert_called_once_with(amount=700, ref="BG-2")

    @patch.object(payment, "WalletClient")           # same name, as an object
    def test_3_patch_object(self, FakeClient):
        FakeClient.return_value.pay.return_value = {"txn_id": "T-3"}
        self.assertEqual(payment.charge("BG-3", 700), "T-3")

suite = unittest.defaultTestLoader.loadTestsFromTestCase(PatchTargetTest)
unittest.TextTestRunner(stream=sys.stdout, verbosity=1).run(suite)
print("after the tests:", payment.WalletClient is wallet.WalletClient)

আসল আউটপুট:

E..
======================================================================
ERROR: test_1_where_defined (__main__.PatchTargetTest.test_1_where_defined)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 19, in test_1_where_defined
    self.assertEqual(payment.charge("BG-1", 700), "T-1")
                     ~~~~~~~~~~~~~~^^^^^^^^^^^^^
  File "/tmp/p24/shop/payment.py", line 3, in charge
    return WalletClient().pay(amount=amount, ref=order_id)['txn_id']
           ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/tmp/p24/shop/wallet.py", line 3, in pay
    raise RuntimeError('REAL NETWORK CALL')
RuntimeError: REAL NETWORK CALL

----------------------------------------------------------------------
Ran 3 tests in 0.004s

FAILED (errors=1)
after the tests: True

প্রথম লাইনের E.. মানে প্রথম test-এ ERROR, বাকি দুটি পাস। Traceback-এর শেষ তিন ধাপ পড়ুন: test থেকে payment.py-র charge, সেখান থেকে wallet.py-র আসল pay. Mock তৈরি হয়েছিল ঠিকই, কিন্তু কেউ তাকে ডাকেনি। এই উদাহরণে আসল client জোরে ব্যর্থ হয় বলে ভুলটি চোখে পড়ল; বাস্তবের client হয়তো sandbox-এ সফলও হতো, আর test ধীর, অস্থির (flaky) অথবা খরুচে হয়ে যেত, কেউ টেরও পেত না। শেষ লাইনের True দেখায় সব patch শেষে নামগুলো আসল object-এ ফিরেছে।

কাজের ধারা — target খুঁজে বের করা

  1. SUT-এর ফাইল খুলুন (test-এর নয়)। যে নাম বদলাতে চান, সেটি কীভাবে এসেছে দেখুন: from X import Name, নাকি import X.
  2. from X import Name হলে target = SUT-এর module.Name. import X আর কোডে X.Name(...) হলে target = X.Name, কারণ তখন খোঁজা হয় X-এর ভেতরে।
  3. Patch বসিয়ে প্রথমে নিশ্চিত হোন mock সত্যিই ডাক পেয়েছে (assert_called_once_with বা call_count). এই এক লাইন “ভুল target, আসল জিনিস চলল” ধরনের নীরব ভুলের পাহারাদার।

Patch লেখার চার রূপ

  • Context manager (with patch(...) as m:): patch-এর সীমা চোখে দেখা যায়; test-এর একটি অংশেই নকল দরকার হলে ভালো। (with-এর ভেতরের কথা Python প্রোগ্রামিং কোর্সের পর্ব ৩৯-এ।)
  • Decorator (@patch(...)): পুরো test জুড়ে। একাধিক decorator থাকলে নিচের decorator-এর mock আসে প্রথম argument-এ, কারণ decorator নিচ থেকে ওপরে প্রয়োগ হয়। এই উল্টো ক্রম নিয়ে interview-তে প্রায়ই প্রশ্ন আসে।
  • patch.object(obj, "name"): string-এর বদলে আসল object; class-এর একটি method বদলাতেও কাজে লাগে।
  • patch.dict(d, {...}): একটি dict-এ সাময়িক মান, যেমন os.environ বা বাজারঘরের SETTINGS; শেষে dict আগের অবস্থায় ফেরে, নতুন key মুছেও যায়।

সব রূপেই autospec=True দেওয়া যায়; তখন §২-এর সুরক্ষা patch-এর ভেতরেও পাওয়া যায়। Class patch করলে মনে রাখুন: FakeClient.pay আর FakeClient.return_value.pay আলাদা mock. কোড WalletClient().pay(...) ডাকলে দ্বিতীয়টিতেই উত্তর বসাতে হয় আর যাচাই করতে হয়।

আরেকটি রূপ প্রায়ই কাজে লাগে: নিজের বানানো নকল সরাসরি বসানো, patch("shop.payment.WalletClient", new=FakeWallet). তখন patch নিজে কোনো MagicMock বানায় না, আর decorator হিসেবে ব্যবহার করলে test function-এ বাড়তি argument-ও আসে না; কারণ নকলটি আপনার হাতেই আছে। §৮-এর fake এভাবে বসানো যায়। একটি সীমা মনে রাখুন: new আর autospec=True একসাথে দেওয়া যায় না; দুটি দিলে TypeError আসে (scratch-এ চালিয়ে যাচাই করা), কারণ autospec নিজেই নকল বানায়। তাই নিজের fake বসালে তার method আর argument আসল class-এর সাথে মেলে কি না, সেই দায়িত্ব আপনার; §৮-এর contract test সেখানেই সাহায্য করে।

৬ · ডেস্কটপে সত্যিকারের run — pytest-mock-এর mocker

pytest দিয়ে লেখা test-এ unittest.mock সরাসরি চলে, তবে decorator-এর উল্টো ক্রম আর with-এর গভীর nesting বিরক্তিকর হয়। pytest-mock plugin একটি mocker fixture দেয়: mocker.patch(...) সাধারণ একটি লাইন, আর test শেষ হলেই সব patch নিজে থেকে ফিরে যায়। pytest-এর fixture আর মূল ব্যবহার পর্ব ২১-এ; fixture-এর scope নিয়ে পর্ব ২৩-এ।

নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো: Python 3.12.13, pytest 9.2.0 (MIT লাইসেন্স), pytest-mock 3.17.0 (MIT লাইসেন্স, রক্ষণাবেক্ষণ করেন pytest-এর অন্যতম maintainer Bruno Oliveira), uv দিয়ে বানানো ছোট প্রকল্পে; path নিরপেক্ষ করা। কোড বাজারঘরের bazarghar package: wallet.py (আসল client, ডাকলেই RuntimeError), payment.py (§৩-এর charge, তবে client না দিলে নিজে WalletClient() বানায়, আর চেষ্টার সংখ্যা SETTINGS["max_tries"] থেকে নেয়), pricing.py আর checkout.py.

cd ~/bazarghar-qa
uv init --vcs none --author-from none
uv add pytest pytest-mock
from bazarghar import checkout, pricing
from bazarghar.payment import charge
from bazarghar.wallet import WalletClient, WalletTimeout


def test_paid_after_two_timeouts(mocker):
    client = mocker.create_autospec(WalletClient, instance=True)
    client.pay.side_effect = [WalletTimeout(), WalletTimeout(),
                              {"txn_id": "T-77"}]
    sleep = mocker.Mock()
    result = charge("BG-1001", 1890, client=client, sleep=sleep)
    assert result == {"status": "paid", "txn": "T-77", "tries": 3}
    assert sleep.call_args_list == [mocker.call(1), mocker.call(2)]


def test_default_client(mocker):
    Client = mocker.patch("bazarghar.wallet.WalletClient")
    Client.return_value.pay.return_value = {"txn_id": "T-9"}
    assert charge("BG-1004", 700)["txn"] == "T-9"


def test_max_tries_from_settings(mocker):
    mocker.patch.dict("bazarghar.payment.SETTINGS", {"max_tries": 2})
    client = mocker.create_autospec(WalletClient, instance=True)
    client.pay.side_effect = WalletTimeout()
    sleep = mocker.Mock()
    result = charge("BG-1005", 900, client=client, sleep=sleep)
    assert result == {"status": "failed", "tries": 2}
    sleep.assert_called_once_with(2)


def test_checkout_spies_on_real_coupon(mocker):
    spy = mocker.spy(pricing, "coupon_discount")
    assert checkout.payable("Dhaka", 2100) == 1890
    spy.assert_called_once_with(2100)
    assert spy.spy_return == 210

দ্বিতীয় test-এ ইচ্ছা করে ভুল target, তৃতীয়টিতে ইচ্ছা করে ভুল প্রত্যাশা রাখা হয়েছে। Run:

$ uv run pytest -v
============================= test session starts =============================
platform win32 -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0
rootdir: ~/bazarghar-qa
configfile: pyproject.toml
testpaths: tests
plugins: mock-3.17.0
collecting ... collected 4 items

tests/test_payment.py::test_paid_after_two_timeouts PASSED               [ 25%]
tests/test_payment.py::test_default_client FAILED                        [ 50%]
tests/test_payment.py::test_max_tries_from_settings FAILED               [ 75%]
tests/test_payment.py::test_checkout_spies_on_real_coupon PASSED         [100%]

================================== FAILURES ===================================
_____________________________ test_default_client _____________________________
…
    def test_default_client(mocker):
        Client = mocker.patch("bazarghar.wallet.WalletClient")
        Client.return_value.pay.return_value = {"txn_id": "T-9"}
>       assert charge("BG-1004", 700)["txn"] == "T-9"
…
bazarghar\payment.py:14: in charge
    receipt = client.pay(amount=amount, ref=order_id)
…
    def pay(self, amount, ref):
        """Charge `amount` taka; `ref` is the idempotency reference."""
>       raise RuntimeError("REAL NETWORK CALL from a test!")
E       RuntimeError: REAL NETWORK CALL from a test!

bazarghar\wallet.py:18: RuntimeError
________________________ test_max_tries_from_settings _________________________
…
        assert result == {"status": "failed", "tries": 2}
>       sleep.assert_called_once_with(2)
E       AssertionError: expected call not found.
E       Expected: mock(2)
E         Actual: mock(1)
E
E       pytest introspection follows:
E
E       Args:
E       assert (1,) == (2,)
E
E         At index 0 diff: 1 != 2
…
tests\test_payment.py:29: AssertionError
=========================== short test summary info ===========================
FAILED tests/test_payment.py::test_default_client - RuntimeError: REAL NETWOR...
FAILED tests/test_payment.py::test_max_tries_from_settings - AssertionError: ...
========================= 2 failed, 2 passed in 0.06s =========================

রিপোর্টটি পড়া

  • plugins: mock-3.17.0: pytest plugin খুঁজে পেয়েছে; mocker fixture-এর জন্য আর কোনো import লাগেনি।
  • test_default_client: §৫-এর ভুল, এবার আসল tool-এ। Traceback আবার payment.py:14 হয়ে wallet.py:18-এর আসল pay-এ পৌঁছেছে। ঠিক রূপ: mocker.patch("bazarghar.payment.WalletClient", autospec=True).
  • test_max_tries_from_settings: patch.dict চেষ্টার সংখ্যা ২ করেছে; দুবার timeout হয়ে ফল failed, এই assertion পাস। কিন্তু অপেক্ষা হয়েছে একবারই, দুই চেষ্টার মাঝে, আর সেটি ১ সেকেন্ড: Expected mock(2), Actual mock(1). এখানে ভুল কোডে নয়, test-এর প্রত্যাশায়। ভুল প্রত্যাশা চেনার উপায়: নিয়মটি আবার পড়া, যেখানে প্রথম অপেক্ষা ১ সেকেন্ড।
  • pytest introspection follows: এটি pytest-mock-এর যোগ। সাধারণ unittest.mock শুধু Expected/Actual দেয়; plugin-টি pytest-এর assertion rewriting দিয়ে argument-এর tuple তুলনা করে দেখায় কোন index-এ পার্থক্য (At index 0 diff: 1 != 2). অনেক argument থাকলে এটি সময় বাঁচায়।
  • mocker.spy: চতুর্থ test আসল coupon_discount চালিয়েছে (ছাড় সত্যিই ২১০), আর spy শুধু লিখে রেখেছে কী argument এল, কী ফেরত গেল (spy_return). আসল আচরণ বদলায় না: spy-এর সংজ্ঞা ঠিক এটাই।

দুটি লাইন ঠিক করার পর (target bazarghar.payment.WalletClient, প্রত্যাশা assert_called_once_with(1)) একই কমান্ড:

$ uv run pytest -v
…
tests/test_payment.py::test_paid_after_two_timeouts PASSED               [ 25%]
tests/test_payment.py::test_default_client PASSED                        [ 50%]
tests/test_payment.py::test_max_tries_from_settings PASSED               [ 75%]
tests/test_payment.py::test_checkout_spies_on_real_coupon PASSED         [100%]

============================== 4 passed in 0.02s ==============================

লক্ষ্য করুন, চতুর্থ test শুরু হওয়ার আগেই তৃতীয় test-এর patch.dict ফিরে গেছে; নইলে পরের test-এ max_tries ২ থেকে যেত আর test-গুলো একে অপরের ওপর নির্ভর করত। pytest-এর নিজস্ব monkeypatch fixture-ও নাম, attribute আর environment variable সাময়িক বদলায়; তবে তার কাছে mock বানানো বা ডাক যাচাইয়ের সুবিধা নেই, তাই দুটি প্রায়ই একসাথে ব্যবহার হয়।

কাজunittest.mockpytest-mock
নাম বদলানোwith patch(...) বা @patchmocker.patch(...)
একাধিক patchdecorator-এর উল্টো ক্রম, বা nested withপরপর লাইন, ক্রমের ঝামেলা নেই
আসল আচরণ রেখে লেখাMock(wraps=func)mocker.spy(obj, "name")
শুধু ডাক নেওয়ার নকলMock()mocker.stub(), mocker.Mock()
ফেরত আনাwith বা decorator শেষেtest শেষে নিজে; চাইলে mocker.stopall()

দুটি একই unittest.mock-এর ওপর দাঁড়ানো, তাই side_effect, autospec, call যাচাই সব হুবহু একই। দলে যেটি চলছে, সেটিই রাখুন; একই ফাইলে দুই রীতি মেশানো পড়তে কষ্টকর।

৭ · সময় আর random — ঘড়ি নিজের হাতে রাখা

সময় আর random সংখ্যা test-এর সবচেয়ে চুপচাপ শত্রু। “আজ শুক্রবার হলে delivery slot বন্ধ” ধরনের নিয়মের test বৃহস্পতিবার পাস করে, শুক্রবার ফেল করে; OTP-র random অঙ্কের test কখনো কখনো ফেল করে। সমাধানের তিনটি স্তর, পছন্দের ক্রমে:

  1. ঘড়ি বাইরে থেকে দিন। Function-এ now=datetime.now বা sleep=time.sleep parameter রাখুন, test-এ একটি স্থির ঘড়ি দিন। §৩-এর sleep এভাবেই নকল হয়েছে। এই নকশার পূর্ণ আলোচনা পর্ব ২৫ (Testable code — dependency injection, seam আর legacy code)-এ।
  2. যেখানে খোঁজা হয় সেখানে patch. কোড import time লিখে time.sleep(1) ডাকলে patch("bazarghar.payment.time.sleep") কাজ করে; কিন্তু সাবধান, payment.time আসলে পুরো time module, তাই এটি test চলাকালে সব জায়গার time.sleep বদলায়। কোড from time import sleep লিখলে target bazarghar.payment.sleep.
  3. ঘড়ি জমানোর library. freezegun (Apache 2.0) আর time-machine (MIT) datetime.now()-কে একটি নির্দিষ্ট মুহূর্তে আটকে রাখে বা এগিয়ে দেয়; পুরোনো কোড, যেখানে parameter যোগ করা যায় না, সেখানে কাজে লাগে। এই পর্বে এগুলো চালানো হয়নি; ব্যবহারের আগে প্রতিটির নথিতে option মিলিয়ে নিন।
from datetime import datetime, timedelta, timezone

DHAKA = timezone(timedelta(hours=6))          # Bangladesh: UTC+6

def slot_open(now=lambda: datetime.now(DHAKA)):
    return now().weekday() != 4                # 4 = Friday

friday = lambda: datetime(2026, 11, 20, 10, 0, tzinfo=DHAKA)
assert slot_open(now=friday) is False          # same answer every day

ওপরের ছোট উদাহরণে test কোন দিনে চলছে, তাতে কিছু আসে যায় না; ২০২৬ সালের ২০ নভেম্বর শুক্রবার, তাই উত্তর সবসময় False. এমন স্থির ঘড়িকে বলে fake clock. Random-এর ক্ষেত্রেও একই কৌশল: random.Random(42)-এর মতো seed দেওয়া generator বাইরে থেকে দিন, বা OTP-র ক্ষেত্রে patch("bazarghar.otp.random.randint", return_value=4821); এখানেও ওপরের সতর্কতা খাটে, কারণ otp.random পুরো random module, তাই test চলাকালে সব জায়গার randint বদলায়। সবচেয়ে পরিষ্কার পথ তাই প্রথমটি: make_otp(rng=random.Random(42)); test একই seed দিলে প্রতিবার একই OTP পায়, আর production-এ secrets module-এর মতো নিরাপদ উৎস ঢোকানো যায়। Timezone মনে রাখুন: বাজারঘরের সার্ভার UTC-তে চললে বাংলাদেশের রাত ১২টা থেকে সকাল ৬টা পর্যন্ত সময় সার্ভারের হিসাবে আগের দিন।

৮ · Mock-এর ফাঁদ — over-mocking, mock drift আর fake

Mock শক্তিশালী, আর ঠিক সে কারণেই বিপজ্জনক: mock সেই উত্তরই দেয়, যা test-লেখক বিশ্বাস করেন আসল জিনিস দেবে। বিশ্বাস ভুল হলে test সবুজ, production লাল। দুটি রূপ সবচেয়ে প্রচলিত।

Over-mocking — সব নকল, কিছুই যাচাই নয়

বাজারঘরের payable() coupon আর delivery-র নিয়ম ডেকে মোট টাকা বের করে। একজন developer ভুল করে delivery-র হিসাব করলেন ছাড়ের পরের অঙ্কে, অথচ নিয়ম বলে ছাড়ের আগের অঙ্কে। দুটি test: একটিতে দুটি নিয়মই mock, অন্যটিতে আসল নিয়ম।

import sys, types, unittest
from unittest.mock import patch

pricing = types.ModuleType("pricing")             # the real rules
pricing.coupon_discount = lambda total: min(total // 10, 300) if total > 1000 else 0
pricing.delivery_charge = lambda district, total, member=False: (
    (0 if total >= 2000 else 60) if district == "Dhaka" else (60 if member else 120))

def payable(district, total, member=False):       # seeded bug: threshold
    discount = pricing.coupon_discount(total)     # uses the total AFTER
    delivery = pricing.delivery_charge(district, total - discount, member)
    return total - discount + delivery            # the discount

class PayableTest(unittest.TestCase):
    @patch.object(pricing, "delivery_charge", return_value=0)
    @patch.object(pricing, "coupon_discount", return_value=210)
    def test_over_mocked(self, coupon, delivery):  # bottom decorator = 1st arg
        self.assertEqual(payable("Dhaka", 2100), 1890)
        coupon.assert_called_once_with(2100)
        delivery.assert_called_once()
        print("\n  delivery got:", delivery.call_args, end=" ")

    def test_real_rules(self):
        self.assertEqual(payable("Dhaka", 2100), 1890)   # 2100 - 210 + 0

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

আসল আউটপুট:

test_over_mocked (__main__.PayableTest.test_over_mocked) ... 
  delivery got: call('Dhaka', 1890, False) ok
test_real_rules (__main__.PayableTest.test_real_rules) ... FAIL

======================================================================
FAIL: test_real_rules (__main__.PayableTest.test_real_rules)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 24, in test_real_rules
    self.assertEqual(payable("Dhaka", 2100), 1890)   # 2100 - 210 + 0
    ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: 1950 != 1890

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

FAILED (failures=1)

Over-mocked test পাস করল একটি ভুল কোডে, অথচ প্রমাণ তার হাতেই ছিল: ছাপা লাইনে দেখা যাচ্ছে delivery-র নিয়ম পেয়েছে ১৮৯০, ২১০০ নয়। assert_called_once() শুধু “ডাকা হয়েছে” দেখে, কী দিয়ে তা দেখে না; আর mock যেকোনো অঙ্কে ০ ফেরত দেয়, তাই ফলও “ঠিক” এল। আসল নিয়মের test ভুলটি ধরল: ১৮৯০ টাকা ২০০০-এর কম, তাই delivery ৬০, মোট ১৯৫০.

payable("Dhaka", 2100) · নিয়মে উত্তর 1890
coupon
delivery
payable
test
  1. নকল ছাড়। coupon_discount mock, সবসময় ২১০. এটি আসল উত্তরের সাথে মেলে, তাই এখানে সমস্যা নেই।
  2. ভুল argument, নকল উত্তর। ভুল কোড delivery-কে দিল ছাড়ের পরের অঙ্ক ১৮৯০. আসল নিয়ম এতে ৬০ দিত; কিন্তু mock-এর return_value=0, argument যা-ই হোক।
  3. ফল মিলে গেল। ২১০০ − ২১০ + ০ = ১৮৯০, প্রত্যাশার সাথে হুবহু। Test-লেখক উত্তরটি নিজেই mock-এ বসিয়েছিলেন, তাই এটি আসলে নিজের বিশ্বাসের প্রতিধ্বনি।
  4. দুর্বল ডাক-যাচাই। Coupon-এর argument যাচাই হয়েছে, delivery-র হয়নি; assert_called_once() শুধু সংখ্যা দেখে। Test পাস, অথচ ভুলের প্রমাণ call_args-এ পড়ে ছিল।
  5. আসল নিয়ম। একই input, mock ছাড়া: delivery পেল ১৮৯০, ২০০০-এর কম, তাই ৬০. মোট ১৯৫০, প্রত্যাশা ১৮৯০: FAIL. বিশুদ্ধ, দ্রুত function mock করার কোনো কারণই ছিল না।
  6. সংশোধন। Delivery-কে total দিলে ২১০০ ≥ ২০০০, ফ্রি; মোট ১৮৯০. এখন দুটি test-ই পাস, কিন্তু শুধু দ্বিতীয়টি ভবিষ্যতে এই ভুল আবার ধরতে পারবে।

Mock drift আর fake

দ্বিতীয় ফাঁদ সময়ের সাথে আসে। Wallet সরবরাহকারী নতুন সংস্করণে উত্তরের key txn_id বদলে transaction_id করলেন। বাজারঘরের সব test-এর mock এখনো পুরোনো key ফেরত দেয়; সব সবুজ, আর প্রথম আসল payment-এ KeyError. §২-এ দেখেছেন autospec-ও এটি ধরে না। প্রতিকার তিনটি:

  • যা আপনার নয়, তা সরাসরি mock না করা। বাইরের SDK-কে নিজের ছোট একটি adapter-এর পেছনে রাখুন (WalletClient ঠিক এটাই), আর unit test-এ adapter-এর double ব্যবহার করুন। Adapter নিজে sandbox-এর সাথে কয়েকটি integration test পায়।
  • Fake. নিচের in-memory wallet সত্যিই নিয়ম মানে: একই ref-এ দ্বিতীয়বার টাকা কাটে না, আর “টাকা কাটা হলো কিন্তু উত্তর হারাল” ধরনের timeout তৈরি করতে পারে। Mock এমন অবস্থা মনে রাখে না, fake রাখে।
  • Contract test. একই test-এর সেট fake আর আসল (বা sandbox) দুটির ওপর চালান; দুটির উত্তরের গঠন মিললে fake সৎ থাকে। Consumer-driven contract আর Pact আসবে পর্ব ৩২ (Contract testing — consumer-driven contract আর Pact)-এ, আর পুরো service নকল করা পর্ব ৩৪ (Service virtualization — mock server আর নির্ভরতা আলাদা করা)-এ।

এই আলোচনার পেছনে একটি প্রচলিত শব্দজোড়া আছে: solitary আর sociable unit test (Jay Fields-এর দেওয়া নাম বলে উদ্ধৃত হয়, Martin Fowler-এর লেখায় জনপ্রিয়)। Solitary test SUT-কে সব সহযোগী থেকে আলাদা করে, সবকিছুর double দিয়ে; sociable test আসল সহযোগীদের সাথে চলে, শুধু সীমানার বাইরেরটি নকল। ওপরের over-mocked test ছিল solitary, আসল নিয়মের test sociable, আর ভুল ধরল দ্বিতীয়টিই। “Unit” মানে তাই একটি class বা function নয়, একটি আচরণ, যা দ্রুত আর আলাদাভাবে চালানো যায়।

import itertools

class FakeWallet:
    """In-memory wallet: same ref -> same transaction, no double charge."""
    def __init__(self, timeouts=0):
        self.timeouts, self.charges = timeouts, {}
        self._ids = itertools.count(1)

    def pay(self, amount, ref):
        if ref not in self.charges:
            self.charges[ref] = {"txn_id": f"T-{next(self._ids)}", "amount": amount}
        if self.timeouts:                 # money taken, answer lost
            self.timeouts -= 1
            raise WalletTimeout()
        return self.charges[ref]

def test_retry_does_not_charge_twice():
    wallet = FakeWallet(timeouts=2)
    result = charge("BG-1001", 1890, wallet, sleep=lambda s: None)
    assert result == {"status": "paid", "txn": "T-1", "tries": 3}
    assert sum(c["amount"] for c in wallet.charges.values()) == 1890

এই test (§৩-এর charge আর WalletTimeout-এর সাথে scratch-এ চালিয়ে মেলানো) প্রমাণ করে: দুবার উত্তর হারালেও গ্রাহকের কাছ থেকে মোট ১৮৯০ টাকাই কাটা হয়েছে, কারণ তিনবারই একই ref গেছে। কেউ ref-এ attempt নম্বর জুড়ে দিলে (BG-1001-2) fake তিনটি আলাদা charge রাখবে, যোগফল ৫৬৭০, আর test লাল। Mock-ভিত্তিক test এই ভুল ধরতে পারত না, কারণ mock-এর কাছে “আগে কাটা হয়েছিল কি না” বলে কিছু নেই। এই ধারণার নাম idempotency key.

আরও গভীরে। Mock object-এর ধারণা প্রথম প্রকাশিত হয় Tim Mackinnon, Steve Freeman ও Philip Craig-এর “Endo-Testing: Unit Testing with Mock Objects” প্রবন্ধে (XP2000 সম্মেলন)। পরে Freeman ও Nat Pryce-এর Growing Object-Oriented Software, Guided by Tests (২০০৯) mock-কে নকশার হাতিয়ার হিসেবে দেখায়: object-গুলো একে অপরকে কী বার্তা পাঠায়, তা আবিষ্কারের উপায়। এই ধারাকে বলা হয় mockist (London), আর আসল object ও fake পছন্দ করা ধারাকে classicist (Detroit); Martin Fowler-এর “Mocks Aren't Stubs” প্রবন্ধ (প্রথম রূপ ২০০৪-এর দিকে, বড় সংশোধন ২০০৭) দুটির তুলনার প্রচলিত সূত্র। বড় প্রকল্পে প্রায়ই মাঝামাঝি পথ: সীমানায় (network, টাকা, ঘড়ি) double, ভেতরে আসল object.

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

  • Stub আর mock-এর পার্থক্য? Stub উত্তর দেয়, ফল যাচাই হয় (state); mock-এর ডাকগুলো যাচাই হয় (behaviour).
  • from a import X থাকা module b-এর test-এ কোথায় patch? b.X, কারণ নামটি সেখানেই খোঁজা হয়।
  • দুটি @patch decorator-এর mock কোন ক্রমে argument-এ আসে? নিচেরটি প্রথমে।
  • Retry test-এ পরপর ভিন্ন উত্তর কীভাবে? side_effect-এ তালিকা; exception-গুলো ছোড়া হয়, বাকিগুলো ফেরত।
  • Fake কখন mock-এর চেয়ে ভালো? যখন সহযোগীর অবস্থা আছে (repository, wallet-এর ledger) আর অনেক test একই আচরণ চায়।

৯ · AI-এর যুগে test double

AI সহকারী mock-ভরা test খুব দ্রুত লেখে, আর ঠিক এখানেই সবচেয়ে বেশি সতর্কতা লাগে। প্রচলিত ভুলগুলো: কোডের প্রতিটি সহযোগী mock করে শুধু “ডাকা হয়েছে” যাচাই করা (over-mocking), যাতে ভুল কোডেও test সবুজ; কোড এখন যা করে সেটিই প্রত্যাশা হিসেবে লেখা, requirement যা বলে তা নয়; ভুল patch target, বিশেষ করে from … import-এর ক্ষেত্রে; autospec ছাড়া mock, ফলে অস্তিত্বহীন method-ও পাস; retry test-এ আসল time.sleep রেখে দেওয়া, ফলে ধীর আর sleep-নির্ভর test; বানানো mock API, যেমন এমন method বা pytest-mock option যা নেই; শুধু happy path, timeout আর decline বাদ; আর না চালিয়েই “সব test পাস” দাবি।

AI-কে requirement দিয়ে, double বাছাইয়ের যুক্তিসহ test চাইতে পারেন:

তুমি একজন অভিজ্ঞ Python QA engineer. নিচে বাজারঘরের payment.py, wallet.py আর payment-এর নিয়ম দিলাম। [নিয়ম পেস্ট করুন: timeout-এ মোট ৩ বার চেষ্টা, মাঝে ১ আর ২ সেকেন্ড; decline-এ আর চেষ্টা নয়; ref = order id] [payment.py আর wallet.py পেস্ট করুন] ১. প্রতিটি সহযোগীর জন্য কোন test double (dummy, stub, spy, mock, fake) নেবে, এক লাইনে কারণসহ টেবিল দাও। ২. pytest আর pytest-mock দিয়ে test লেখো: timeout-এর সংখ্যা ০, ১, ২ আর ৩; decline; timeout-এর পরে decline. প্রতিটি expected মানের পাশে নিয়মের কোন বাক্য থেকে এলো লেখো। ৩. WalletClient-এর double সবসময় autospec দিয়ে বানাও। Patch লাগলে target কেন ওই নাম, ব্যাখ্যা করো। ৪. আসল time.sleep কোথাও চলবে না; কীভাবে নিশ্চিত করলে, বলো। ৫. pure হিসাবের function (coupon, delivery) mock করবে না। ৬. কোনো mock method বা pytest-mock option ব্যবহার করলে তার নাম আলাদা তালিকায় দাও, আমি docs-এ মিলিয়ে নেব। নিজে test চালানোর দাবি করবে না।

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

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

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

প্র ০১Mockist আর classicist ধারার বিতর্ক থেকে একজন tester কী শিখবেন?

বিতর্কটির শুরু ২০০০ সালের দিকে, লন্ডনের Extreme Programming চর্চাকারীদের মধ্যে। Mackinnon, Freeman ও Craig XP2000 সম্মেলনে mock object-এর ধারণা প্রকাশ করেন; তাঁদের যুক্তি ছিল, প্রতিটি object-কে তার সহযোগী থেকে আলাদা করে test করলে নকশা ছোট, স্পষ্ট interface-এর দিকে যায়। Freeman ও Pryce পরে ২০০৯ সালের বইয়ে দেখান, mock আসলে নকশা আবিষ্কারের হাতিয়ার: বাইরের আচরণের test থেকে শুরু করে ভেতরের object-গুলো কী বার্তা পাঠাবে, তা ধাপে ধাপে বের করা।

অন্য পক্ষ, যাদের বলা হয় classicist বা Detroit ধারা (Kent Beck-এর প্রথম দিকের TDD চর্চার সাথে যুক্ত বলে ধরা হয়), আসল object যতটা সম্ভব ব্যবহার করে আর ফল যাচাই করে। Martin Fowler তাঁর “Mocks Aren't Stubs” প্রবন্ধে দুটির তুলনা করেছেন: mockist test ভেতরের নকশার সাথে বেশি জড়ানো, তাই refactoring-এ বেশি ভাঙে; কিন্তু ব্যর্থ হলে ভুলটি ঠিক কোন object-এ, তা সাথে সাথে বোঝা যায়। Classicist test refactoring সহ্য করে, কিন্তু একটি ভুলে অনেক test একসাথে লাল হতে পারে।

Tester-এর জন্য এখান থেকে তিনটি ব্যবহারিক শিক্ষা। প্রথমত, mock-এর assertion আসলে নকশার সিদ্ধান্তকে স্থির করে দেয়; প্রতিটি ভেতরের ডাক যাচাই করলে developer কোড পুনর্গঠন করতে ভয় পান। দ্বিতীয়ত, কোন ধারা ভালো তা প্রসঙ্গের ওপর নির্ভর করে: বাইরের system-এর সাথে কথোপকথন (payment, SMS) behaviour verification চায়, হিসাবের নিয়ম state verification চায়। তৃতীয়ত, review-এ প্রশ্নটি করুন: “এই mock-টি সরালে test কি আরও বিশ্বাসযোগ্য হতো?” §৮-এর over-mocked test-এ উত্তর স্পষ্ট হ্যাঁ।

মূল উপলব্ধি: দুই ধারাই একমত যে সীমানার বাইরের জিনিস নকল করতে হয়। বিতর্ক শুধু সীমানা কোথায় টানবেন তা নিয়ে; সীমানা যত ভেতরে, test তত ভঙ্গুর।

প্র ০২“যা আপনার নয়, তা mock করবেন না” পরামর্শটির পেছনের যুক্তি কী?

পরামর্শটি সাধারণত Freeman ও Pryce-এর বইয়ের সাথে যুক্ত করা হয় (ইংরেজিতে “Only mock types that you own”). যুক্তি সরল: বাইরের library বা SDK-র আচরণ আপনি নিয়ন্ত্রণ করেন না, আর তার নথি প্রায়ই অসম্পূর্ণ। আপনি যখন সেই SDK-র একটি method mock করেন, তখন test-এ বসান আপনার ধারণা: কোন exception আসে, উত্তরের গঠন কী, কোন argument বাধ্যতামূলক। ধারণা ভুল হলে test ভুলটিকে স্থায়ী করে দেয়, আর SDK-র নতুন সংস্করণে আচরণ বদলালে mock বদলায় না।

প্রতিকার হলো নিজের একটি পাতলা স্তর, adapter: বাজারঘরের WalletClient-এর মতো, যার method-গুলো বাজারঘরের ভাষায় (pay(amount, ref), refund(txn_id)). SDK-র সব জটিলতা, যেমন token, retry header, বিচিত্র error code, ওই স্তরের ভেতরে। এরপর ব্যবসার কোডের unit test-এ adapter-এর double, যা আপনার নিজের interface, তাই তার চুক্তি আপনিই জানেন। Adapter-কে test করুন কম সংখ্যক integration test দিয়ে, সরবরাহকারীর sandbox বা একটি রেকর্ড করা উত্তরের বিরুদ্ধে।

এতে আরেকটি লাভ: সরবরাহকারী বদলালে শুধু adapter বদলায়। বাংলাদেশে একাধিক mobile wallet আর card gateway থাকায় একটি shop প্রায়ই কয়েকটি সরবরাহকারী একসাথে ব্যবহার করে; প্রত্যেকের জন্য আলাদা adapter আর একটি সাধারণ interface থাকলে ব্যবসার test একবারই লিখতে হয়। এই নকশার নাম ports and adapters, যা পর্ব ২৫-এ আরও আসবে।

পরামর্শটি কিন্তু অন্ধ নিয়ম নয়। ছোট প্রকল্পে adapter বাড়তি বোঝা হতে পারে, আর time.sleep-এর মতো standard library-র function patch করা প্রায় সবাই গ্রহণযোগ্য মনে করেন, কারণ তার আচরণ স্থির ও সুপরিচিত।

মূল উপলব্ধি: Mock সবসময় একটি চুক্তির নকল। চুক্তিটি আপনার নিজের হলে নকল বিশ্বাসযোগ্য; অন্যের হলে আগে নিজের ভাষায় একটি চুক্তি বানান।

প্র ০৩Timeout-এর পরে payment আবার চেষ্টা করা কেন বিপজ্জনক, আর test-এ এটি কীভাবে ধরবেন?

Timeout মানে “উত্তর আসেনি”, “কাজ হয়নি” নয়। হতে পারে wallet টাকা কেটে নিয়েছে, কিন্তু উত্তর ফেরার পথে network ভেঙেছে। তখন আবার চেষ্টা করলে গ্রাহকের wallet থেকে দ্বিতীয়বার টাকা যায়। Distributed system-এ এটি সুপরিচিত সমস্যা: বার্তা ঠিক একবার পৌঁছানো নিশ্চিত করা কঠিন, তাই বাস্তবে “অন্তত একবার” পাঠানো হয়, আর গ্রহণকারী নকল চিনে ফেলে।

চেনার উপায় হলো idempotency key: প্রতিটি অনুরোধের সাথে একটি স্থির পরিচয়, যেমন order id. গ্রহণকারী আগে দেখেছে এমন key পেলে নতুন কাজ না করে আগের ফল ফেরত দেয়। HTTP API-র জন্য IETF-এ Idempotency-Key header-এর একটি খসড়া মানও আলোচনায় আছে বলে জানা যায়; অনেক payment সরবরাহকারী নিজেদের মতো করে একই ধারণা ব্যবহার করে। বাজারঘরের নিয়মে ref এই কাজটি করে।

Test-এর দিক থেকে মজার ব্যাপার হলো, সাধারণ mock এই ঝুঁকি ধরতে পারে না। Mock-এর কাছে প্রতিটি ডাক আলাদা; আগে টাকা কাটা হয়েছিল কি না, সে মনে রাখে না। call_args_list দিয়ে আপনি যাচাই করতে পারেন যে তিনবারই একই ref গেছে, এবং §৩-এর stepper সেটি দেখিয়েছে। কিন্তু “একই ref-এ দ্বিতীয়বার কাটা হয় না” নিয়মটি wallet-এর দিকের, আর সেটি মডেল করে fake: §৮-এর FakeWallet সত্যিই ledger রাখে, “টাকা কাটা কিন্তু উত্তর হারানো” পরিস্থিতি বানায়, আর মোট কাটা অঙ্ক যাচাই করতে দেয়।

আরেকটি স্তর হলো decline বনাম timeout-এর পার্থক্য। Decline নিশ্চিত উত্তর, তাই retry অর্থহীন আর বিরক্তিকর; timeout অনিশ্চিত, তাই সাবধানে retry. দুটি আলাদা exception আর আলাদা test রাখা এই পার্থক্যকে কোডে স্থায়ী করে।

মূল উপলব্ধি: যে ঝুঁকি সহযোগীর অবস্থার ওপর নির্ভর করে, তা অবস্থাহীন mock দিয়ে test হয় না; সেখানে অবস্থা রাখা fake লাগে।

প্র ০৪সময়-নির্ভর কোড test করা কেন এত কঠিন, আর বাংলাদেশের প্রেক্ষাপটে কী বাড়তি সতর্কতা লাগে?

সময় এমন একটি input যা কোডে লেখা থাকে না: function নিজে datetime.now() ডাকে। ফলে একই test আজ পাস করে, কাল ফেল করে; রাত ১১টা ৫৯-এ পাস করে, ১২টা ০১-এ নয়। Flaky test-এর তালিকায় সময় সবসময় ওপরের দিকে থাকে। এর ওপর আছে ক্যালেন্ডারের বিচিত্রতা: অধিবর্ষের ২৯ ফেব্রুয়ারি, মাসের শেষ দিন, বছর বদল, আর timezone.

বাংলাদেশের সময় UTC+6, আর বর্তমানে daylight saving নেই। তবে ইতিহাস মনে রাখার মতো: ২০০৯ সালের মাঝামাঝি বিদ্যুৎ সাশ্রয়ের জন্য দেশে কয়েক মাস ঘড়ি এক ঘণ্টা এগিয়ে রাখা হয়েছিল, আর বছরের শেষে তা তুলে নেওয়া হয়। Timezone database-এ এমন ঐতিহাসিক বদল লেখা থাকে, তাই পুরোনো তারিখের হিসাবে library ঠিক উত্তর দেয়; কিন্তু নিজের হাতে “UTC + ৬ ঘণ্টা” যোগ করা কোড সেই সময়ের জন্য ভুল। এ ছাড়া সার্ভার প্রায়ই UTC-তে চলে: বাংলাদেশের রাত ১২টা থেকে সকাল ৬টা পর্যন্ত সার্ভারের হিসাবে আগের দিন, ফলে “আজকের অর্ডার” বা “শুক্রবারের slot” ভুল দিনে পড়তে পারে।

Test-এর কৌশল তিনটি, §৭-এর ক্রমে। ঘড়ি parameter হিসেবে দিন, যাতে test একটি নির্দিষ্ট মুহূর্ত বেছে নেয়: শুক্রবার সকাল, বৃহস্পতিবার রাত ১১টা ৫৯, ২৯ ফেব্রুয়ারি। পুরোনো কোডে freezegun বা time-machine-এর মতো library দিয়ে ঘড়ি জমিয়ে দিন। আর অপেক্ষা (sleep) কখনো আসল রাখবেন না: retry-এর মোট অপেক্ষা ৩ সেকেন্ড হলে একশো test-এ পাঁচ মিনিট নষ্ট।

সীমার মানের ধারণা (পর্ব ০৮) এখানে সময়ের ওপর খাটে: দিন বদলের ঠিক আগে আর পরে, slot খোলার ঠিক মুহূর্তে।

মূল উপলব্ধি: সময়কে অন্য যেকোনো input-এর মতো আচরণ করুন: বাইরে থেকে দিন, সীমার মান বাছুন, আর timezone স্পষ্ট লিখুন।

প্র ০৫একটি test-এ সাতটি patch লাগলে সেটি কী নির্দেশ করে?

প্রায় সবসময় এটি test-এর নয়, কোডের নকশার সমস্যা। যে function নিজে database খোলে, wallet client বানায়, ঘড়ি পড়ে, SMS পাঠায়, log লেখে আর config ফাইল পড়ে, তাকে আলাদা করে test করতে হলে প্রতিটি নামই patch করতে হয়। Test তখন কোডের import-এর তালিকার প্রতিলিপি: কেউ একটি import-এর ধরন বদলালে (import time থেকে from time import sleep) patch target ভুল হয়ে যায়, আর test হয় ভাঙে, নয়তো নীরবে আসল জিনিস চালায়।

Michael Feathers তাঁর Working Effectively with Legacy Code (২০০৪) বইয়ে এমন জায়গাকে “seam”-এর ভাষায় ব্যাখ্যা করেছেন: কোডের এমন বিন্দু, যেখানে কোড না বদলেই আচরণ বদলানো যায়। Patch একধরনের seam, Python-এর গতিশীল প্রকৃতির জন্য সহজলভ্য। কিন্তু সহজলভ্য বলেই অপব্যবহার সহজ; Java বা C#-এর মতো ভাষায় এমন কোড test করতে হলে নকশা বদলাতেই হতো।

ভালো পথ হলো নকশা বদলানো: হিসাবের অংশ (কত টাকা, কোন ছাড়, কোন অবস্থা) একটি বিশুদ্ধ function-এ, যার কোনো double লাগে না; আর বাইরের কাজ (wallet, SMS, database) একটি পাতলা স্তরে, যা constructor বা parameter দিয়ে পায়। একে বলে functional core, imperative shell. তখন বেশিরভাগ test-এ double লাগেই না, আর বাকিগুলোতে একটি-দুটি।

Tester-এর কাজ এখানে সংকেতটি তুলে ধরা: review-এ “এই test-এ এতগুলো patch কেন?” প্রশ্নটি developer-কে নকশা ভাবতে বাধ্য করে। এই রূপান্তরের ধাপগুলো, characterization test সহ, পর্ব ২৫-এ হাতে-কলমে দেখবেন।

মূল উপলব্ধি: Patch-এর সংখ্যা নকশার জ্বর মাপার থার্মোমিটার। জ্বর বেশি হলে আরও patch নয়, কোডের চিকিৎসা দরকার।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। সব ফল scratch-এ চালিয়ে মেলানো।

  1. Test নকশা: নিয়ম: “Wallet timeout দিলে মোট ৩ বার পর্যন্ত চেষ্টা, মাঝে ১ আর ২ সেকেন্ড অপেক্ষা; decline হলে সাথে সাথে থামা; প্রতিটি চেষ্টায় একই ref.” side_effect-এর তালিকা দিয়ে test case-এর টেবিল বানান: wallet-এর উত্তরের ক্রম, প্রত্যাশিত ফল, প্রত্যাশিত sleep-এর ডাক। কোন দুটি case সীমার মান?
    IDside_effectফলsleep
    PAY-1[ok]paid, tries 1[]
    PAY-2[T, ok]paid, tries 2[call(1)]
    PAY-3[T, T, ok]paid, tries 3[call(1), call(2)]
    PAY-4T (সবসময়)failed, tries 3[call(1), call(2)]
    PAY-5[D]declined, tries 1[]
    PAY-6[T, D]declined, tries 2[call(1)]

    T = WalletTimeout(), D = WalletDeclined(), ok = {"txn_id": ...}. প্রতিটিতে pay.call_args_list-এর সব ডাকে একই ref যাচাই করুন। সীমার মান PAY-3 আর PAY-4: timeout-এর সংখ্যা ২ (শেষ সুযোগে সফল) আর ৩ (সীমা পার)। Retry-এর সংখ্যায় off-by-one ভুল (range(1, tries)) ঠিক PAY-3-এ ধরা পড়ে।

  2. আউটপুট অনুমান করুন: §৩-এর charge (tries = 3) একটি Mock wallet দিয়ে ডাকা হলো, যেখানে wallet.pay.side_effect = [WalletTimeout(), WalletTimeout()]. কী ঘটবে? sleep.call_args_list আর wallet.pay.call_count কত? এটি কি কোডের bug, নাকি test-এর?

    দুটি timeout-এর পরে sleep(1) আর sleep(2) হয়, তৃতীয় চেষ্টায় তালিকা খালি, তাই Mock ছোড়ে StopIteration. Scratch-এ চালানো ফল: StopIteration, sleep.call_args_list == [call(1), call(2)], pay.call_count == 3. unittest-এ test-টি FAIL নয়, ERROR দেখাবে। এটি test-এর ভুল: test-লেখক তৃতীয় উত্তর দিতে ভুলে গেছেন। “সব চেষ্টায় timeout” বোঝাতে তালিকার বদলে একটি exception দিন: side_effect = WalletTimeout(), তখন ফল {"status": "failed", "tries": 3}.

  3. Test-এ ভুল খুঁজুন: orders.py-তে আছে from bazarghar.wallet import WalletClient, আর cancel_paid_order(order) ডাকে WalletClient().refund(order["txn"]). নিচের test-এ কয়টি সমস্যা, আর ঠিক রূপ কী?
    @patch("bazarghar.wallet.WalletClient")
    def test_refund(self, Client):
        Client.refund.return_value = "ok"
        cancel_paid_order({"txn": "T-7"})
        Client.refund.assert_called_with("T-7")

    চারটি। (১) ভুল target: নাম খোঁজা হয় bazarghar.orders-এ, তাই আসল client চলবে। (২) Class আর instance গুলিয়ে ফেলা: কোড WalletClient().refund ডাকে, অর্থাৎ Client.return_value.refund; Client.refund একটি ভিন্ন mock, যা কখনো ডাক পায় না। (৩) assert_called_with শুধু শেষ ডাক দেখে; দুবার refund-এর bug ধরতে assert_called_once_with. (৪) Autospec নেই, তাই refund-এর বানান বা argument ভুলও ধরা পড়বে না। ঠিক রূপ: @patch("bazarghar.orders.WalletClient", autospec=True), তারপর Client.return_value.refund.assert_called_once_with("T-7").

  4. Double বাছাই: বাজারঘরের place_order(cart, repo, sms, clock, logger) function-এর জন্য প্রতিটি সহযোগীর double বাছুন, এক লাইনে কারণসহ: repo (order সংরক্ষণ ও পড়া), sms (গ্রাহককে একবার নিশ্চিতকরণ বার্তা), clock (অর্ডারের সময়), logger (এই test-এর পথে ব্যবহার হয় না)। আর cart-এর মোট হিসাবের জন্য pricing কি নকল করবেন?

    repo: fake (dict-এ রাখা), কারণ সংরক্ষণের পরে পড়া যায় এমন অবস্থা লাগে, আর অনেক test একে ব্যবহার করবে। sms: mock বা spy, autospec সহ, আর assert_called_once_with(phone, message); এটি বাইরের জগতে যাওয়া কাজ, ডাকই আসল ফল। clock: stub বা fake clock, একটি স্থির মুহূর্ত দেয়। logger: dummy, শুধু parameter পূরণ (যেমন None বা একটি খালি object). pricing: নকল নয়; এটি দ্রুত, বিশুদ্ধ, আর নিয়মটিই test-এর বিষয়। Mock করলে §৮-এর over-mocking ফাঁদ।

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

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

ক্রমwith patch("shop.payment.WalletClient") as Fake: চলার সময় ঘটনাগুলো ক্রমে সাজান (▲▼ চেপে সরান)

  1. patch নামটির আসল object মনে রাখে
  2. নামটির জায়গায় একটি MagicMock বসায়
  3. SUT চলে, নামটি খুঁজে MagicMock পায়
  4. Test mock-এর ডাক আর ফল যাচাই করে
  5. with শেষে আসল object ফিরে আসে

Module shop/payment.py-তে লেখা from shop.wallet import WalletClient, আর charge() ভেতরে WalletClient() বানায়। charge()-এর test-এ কোন target patch করবেন?

  • shop.wallet.WalletClient
  • shop.wallet.WalletClient.pay
  • shop.payment.WalletClient
  • builtins.WalletClient

Retry function (সর্বোচ্চ ৩ চেষ্টা, timeout-এর পরে অপেক্ষা ১ সেকেন্ড, তারপর ২) একটি Mock wallet পায়, যার pay.side_effect = [WalletTimeout(), {"txn_id": "T-5"}]. ফল কী?

  • paid, tries 1; sleep ডাকা হয়নি
  • paid, tries 2; sleep একবার, ১ সেকেন্ড
  • StopIteration
  • failed, tries 3

কোডে ভুল করে client.refund_payment(txn) লেখা, অথচ আসল class-এ method-এর নাম refund. কোন double এই ভুলে সাথে সাথে error দেয়?

  • Mock()
  • MagicMock()
  • Mock(return_value="ok")
  • create_autospec(WalletClient, instance=True)

একটি SMS mock-কে দুবার ডাকা হলো: send("017", "paid") আর send("017", "paid"). কোন assertion এই “দুবার SMS” bug ধরে?

  • send.assert_called_once_with("017", "paid")
  • send.assert_called_with("017", "paid")
  • send.assert_any_call("017", "paid")
  • send.assert_called()

Test-এর ওপরে পরপর দুটি decorator: প্রথম লাইনে @patch("shop.a"), তার নিচে @patch("shop.b"), আর function def test(self, m1, m2). m1 কোনটির mock?

  • shop.a
  • shop.b
  • দুটি একই mock
  • ক্রম এলোমেলো, প্রতিবার ভিন্ন

Wallet সরবরাহকারী উত্তরের key txn_id বদলে transaction_id করলেন। বাজারঘরের সব unit test-এর mock এখনো {"txn_id": "T-1"} ফেরত দেয়, আর সব পাস। কোনটি এই সমস্যা ধরার সবচেয়ে উপযুক্ত উপায়?

  • Mock-এ autospec যোগ করা
  • একই ধরনের আরও unit test লেখা
  • Adapter বা fake আর আসল sandbox-এর ওপর একই contract test চালানো
  • Retry-এর সংখ্যা বাড়ানো

শব্দকোষ

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

মনে রাখুন

  1. পাঁচ double: dummy জায়গা পূরণ করে, stub উত্তর দেয়, spy ডাক লেখে, mock ডাক যাচাই করে, fake সহজ পথে সত্যিই কাজ করে।
  2. return_value একই উত্তর; side_effect exception, ক্রমের তালিকা (শেষে StopIteration) বা function. Retry test-এর মূল হাতিয়ার।
  3. বাইরের client-এর double-এ autospec দিন; ডাক-যাচাইয়ে argument আর সংখ্যা দুটিই দেখুন (assert_called_once_with).
  4. Patch করুন যেখানে নাম খোঁজা হয়; একাধিক decorator-এ নিচেরটির mock প্রথম argument. pytest-mock-এর mocker test শেষে সব নিজেই ফেরায়।
  5. Pure function mock করবেন না; অবস্থা-নির্ভর সহযোগীর জন্য fake, আর mock drift ঠেকাতে contract test. সময় আর random বাইরে থেকে দিন।

পরের পর্বে: এত patch কেন লাগে? যে কোড নিজে ঘড়ি পড়ে, client বানায় আর ছাপে, তাকে ধাপে ধাপে testable বানানো: dependency injection, seam আর legacy কোডের characterization test.

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

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