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

Testable code — dependency injection, seam আর legacy code

Testable Code: Dependency Injection, Seams and Legacy Code

Taught in Bangla, this lesson shows why code with hidden clocks, randomness, network calls, globals and print is hard to test, first forcing a test with patch, then refactoring. It covers Feathers' seams, dependency injection, functional core and imperative shell, and ports and adapters with a fake adapter. In-page Python runs tests on a refactored Bazarghar checkout and characterization tests that catch a tidy-looking refactor, and a real pytest 9.2.0 run includes a patch on the wrong target.

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

  • একটি function পড়ে তার লুকানো নির্ভরতাগুলো (সময়, random, network, global, output) চিহ্নিত করা
  • প্রতিটি নির্ভরতার জন্য seam খুঁজে নেওয়া, আর patch-এর বদলে কখন dependency injection ভালো তা বোঝা
  • মিশে থাকা কোড থেকে একটি pure function বের করে নকল ছাড়াই test করা
  • Port আর adapter-এর ধারণায় test-এর জন্য নিজের fake adapter বানানো
  • Legacy code-এ characterization test লিখে নিরাপদে refactor করা, আর সন্দেহজনক আচরণ আলাদা করে চিহ্নিত করা

১ · কোন কোড test করা কঠিন — লুকানো নির্ভরতার লক্ষণ

আগের তিন পর্বে আপনি test লেখার কৌশল শিখেছেন: পর্ব ২১-এ pytest, পর্ব ২২-এ ভালো test-এর গঠন, আর পর্ব ২৪-এ unittest.mock আর patch. কিন্তু কিছু কোডের সামনে সব কৌশলই ক্লান্ত লাগে। একটি দামের নিয়ম যাচাই করতে পাঁচটি জিনিস patch করতে হয়, test কখনো রাত বারোটায় ভেঙে যায়, আর একটি ভুল patch-এ test আসল টাকা কাটার অনুরোধ পাঠিয়ে বসে। এই পর্বের মূল কথা: এমন অবস্থায় সমস্যা প্রায়ই test-এ নয়, code under test-এর নকশায়। কোড কত সহজে test করা যায়, তাকে বলে testability. এটি কোডের একটি গুণ, যা নকশা দিয়ে বাড়ানো বা কমানো যায়।

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

বাজারঘরের পুরোনো checkout কোডটি দেখুন। কয়েক বছর আগে তাড়াহুড়ায় লেখা, এখনও production-এ চলছে, আর এর কোনো test নেই। এটি দাম হিসাব করে, একটি order reference বানায়, mobile wallet-এ টাকা কাটে, order-টি একটি list-এ রাখে, আর রসিদ ছাপে:

def place_order(amount, district, phone, plus=False):
    discount = 0 if amount <= 1000 else min(amount // 10, 300)
    delivery = ((0 if amount >= 2000 else 60) if district == "Dhaka"
                else (60 if plus else 120))
    total = amount - discount + delivery
    now = datetime.now()                                   # hidden clock
    ref = f"BG-{now:%y%m%d}-{random.randint(1000, 9999)}"  # hidden dice
    txn = wallet_pay(phone, total, ref)                    # hidden network
    ORDERS.append(ref)                                     # global state
    print(f"{ref} {now:%d-%m-%Y %H:%M} total {total} txn {txn}")
    return ref

দামের নিয়ম মডিউল ২-এ ঠিক হওয়া নিয়মই: ১০০০ টাকার বেশি হলে ১০% ছাড়, পূর্ণ টাকায়, সর্বোচ্চ ৩০০; ঢাকায় delivery ৬০, তবে coupon-এর আগের দামে ২০০০ বা বেশি হলে ফ্রি; ঢাকার বাইরে ১২০, Plus সদস্যদের ৬০. হিসাবের অংশটুকু ঠিক আছে। সমস্যা হলো বাকি পাঁচ লাইন। প্রতিটি লাইন function-এর বাইরের কিছুর ওপর নির্ভর করে, আর সেই নির্ভরতা function-এর signature-এ (নাম আর parameter-এর তালিকায়) দেখা যায় না। এগুলোকে বলে লুকানো নির্ভরতা।

লক্ষণবাজারঘরের উদাহরণTest-এ কী সমস্যা
লুকানো ঘড়িdatetime.now(), time.time()ফল চালানোর সময়ের ওপর নির্ভর করে; মধ্যরাত বা বছরের শেষ দিনের আচরণ ইচ্ছামতো তৈরি করা যায় না
এলোমেলো সংখ্যাrandom.randint, uuid4()প্রত্যাশিত মান আগে থেকে লেখা যায় না; test deterministic থাকে না
Network আর বাইরের সেবাwallet_pay(...), SMS পাঠানোধীর, ইন্টারনেট লাগে, আসল টাকা বা বার্তার ঝুঁকি, বাইরের সেবা বন্ধ থাকলে test লাল
File আর databaseconfig ফাইল পড়া, open("orders.csv")যন্ত্রভেদে path আর অবস্থা আলাদা; test-এর পরে পরিষ্কার করতে হয়
Global stateORDERS.append(ref), module-এর SETTINGSএক test-এর রেখে যাওয়া অবস্থা আরেকটিকে বদলায় (পর্ব ২২-এর Independent ভাঙে)
সরাসরি outputprint(...), সরাসরি log লেখাফল ফেরত আসে না, console থেকে ধরে আনতে হয়
সরাসরি ডাকা বাইরের function বা static methodwallet_pay() module-এর নামে ডাকা; Java-য় Wallet.pay()বদলানোর জায়গা নেই; Python-এ শুধু patch, Java-য় প্রায়ই তাও না
বিশাল functionদাম, payment, SMS আর রসিদ এক জায়গায়একটি নিয়ম যাচাই করতে সবকিছু সাজাতে হয়; Arrange অংশ লম্বা হয়

লক্ষ করুন, এই তালিকার কোনোটিই “ভুল কোড” নয়। Production-এ ঘড়ি, wallet আর রসিদ সবই লাগবে। প্রশ্ন শুধু সেগুলো কোথায় আর কীভাবে আসে। একটি দোকানে বিক্রি তো হবেই, কিন্তু হিসাবের খাতা আর ক্যাশবাক্স একই ড্রয়ারে রাখলে হিসাব মেলানো কঠিন। এই পর্ব কয়েকটি ধারণা পরপর দেখাবে, যাদের সূচনা অন্য কোর্সে আছে: dependency injection-এর পুরো নকশা পাবেন সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৩৭-এ, port আর adapter পর্ব ৪০-এ, আর legacy code-এর সংজ্ঞা ও seam-এর পরিচয় পর্ব ৪৩-এ। এখানে আমরা একজন tester-এর চোখে যাব: কোন নকশা কোন test সম্ভব করে, আর পুরোনো কোড test-এর নিচে আনার হাতে-কলমে ধাপ।

২ · প্রথম চেষ্টা — patch দিয়ে জোর করে test

প্রথমে দেখি এই কোডকে না বদলে test করতে চাইলে কী হয়। নিচের block-এ place_order হুবহু আছে, আর আসল wallet-এর জায়গায় এমন একটি function আছে যা network ডাকার চেষ্টা করলেই ব্যর্থ হয় (এই পাতায় কখনো আসল network ডাকা হয় না)। দুটি test: প্রথমটি সরাসরি ডাকে, দ্বিতীয়টি mock আর patch দিয়ে ঘড়ি, random, wallet আর print সব আটকে নেয়।

import contextlib, io, random, sys, unittest
from datetime import datetime
from unittest import mock
random.seed(25)                           # same dice on every page load
ORDERS = []                               # module-level global list
def wallet_pay(phone, amount, ref):       # the real HTTPS call
    raise ConnectionError("REAL NETWORK CALL to wallet.example.invalid")

def place_order(amount, district, phone, plus=False):
    discount = 0 if amount <= 1000 else min(amount // 10, 300)
    delivery = ((0 if amount >= 2000 else 60) if district == "Dhaka"
                else (60 if plus else 120))
    total = amount - discount + delivery
    now = datetime.now()                                  # hidden clock
    ref = f"BG-{now:%y%m%d}-{random.randint(1000, 9999)}"  # hidden dice
    txn = wallet_pay(phone, total, ref)                    # hidden network
    ORDERS.append(ref)                                     # global state
    print(f"{ref} {now:%d-%m-%Y %H:%M} total {total} txn {txn}")
    return ref

class PlaceOrderTests(unittest.TestCase):
    def test_a_plain_call(self):
        place_order(2000, "Dhaka", "01712345678")
    def test_b_three_patches_and_captured_print(self):
        dt, out = mock.Mock(), io.StringIO()
        dt.now.return_value = datetime(2026, 11, 16, 21, 5)
        pay = mock.Mock(return_value="T-1")
        with mock.patch.dict(globals(), datetime=dt, wallet_pay=pay), \
             mock.patch.object(random, "randint", return_value=4321), \
             contextlib.redirect_stdout(out):
            ref = place_order(2000, "Dhaka", "01712345678")
        self.assertEqual(ref, "BG-261116-4321")
        self.assertIn("total 1800", out.getvalue())
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(
    unittest.defaultTestLoader.loadTestsFromTestCase(PlaceOrderTests))

আসল আউটপুট (ব্রাউজারের Python, traceback ছোট করা):

test_a_plain_call (__main__.PlaceOrderTests.test_a_plain_call) ... ERROR
test_b_three_patches_and_captured_print (__main__.PlaceOrderTests.test_b_three_patches_and_captured_print) ... ok

======================================================================
ERROR: test_a_plain_call (__main__.PlaceOrderTests.test_a_plain_call)
----------------------------------------------------------------------
Traceback (most recent call last):
  …
    txn = wallet_pay(phone, total, ref)                    # hidden network
  …
ConnectionError: REAL NETWORK CALL to wallet.example.invalid

----------------------------------------------------------------------
Ran 2 tests in …

FAILED (errors=1)

প্রথম test-এর ফল ERROR, FAIL নয়: কোনো assertion ভাঙেনি, test নিজেই চলতে পারেনি, কারণ function wallet-এ যেতে চেয়েছে। বাস্তব project-এ এখানে সত্যিকারের অনুরোধ যেত। দ্বিতীয় test সবুজ, কিন্তু দাম দেখুন: একটি নিয়ম (২০০০ টাকায় মোট ১৮০০) যাচাই করতে চারটি জিনিস বদলাতে হলো, ঘড়ি, random, wallet আর stdout. তার ওপর test-কে জানতে হলো function-এর ভেতরে কোন নামে কী ডাকা হয় (datetime, wallet_pay, random.randint). কাল কেউ random.randint-এর বদলে secrets.randbelow লিখলে আচরণ একই থাকবে, অথচ test ভাঙবে। Test-টি আচরণের সাথে নয়, ভেতরের বাস্তবায়নের সাথে বাঁধা; পর্ব ২২-এর ভাষায় fragile test.

এখানে patch.dict(globals(), …) লেখা হয়েছে কারণ এই পাতার block নিজের namespace-এ চলে। সাধারণ project-এ লিখতেন patch("bazarghar.checkout_legacy.datetime"): যে module-এ নামটি খোঁজা হয়, সেখানে patch. এই নিয়মের বিস্তারিত পর্ব ২৪-এর patch অংশে। §৮-এর desktop run-এ দেখবেন, নিয়মটি না মেনে সরাসরি datetime.datetime.now patch করতে গেলে কী হয়।

Patch খারাপ কিছু নয়। Legacy code-এ প্রথম test বসানোর জন্য এটি প্রায়ই একমাত্র উপায়, আর §৭-এ আমরা সেটাই করব। কিন্তু patch-এর সংখ্যা একটি মাপকাঠি: একটি সাধারণ নিয়মের test-এ তিন-চারটি patch লাগলে কোডটি আপনাকে বলছে, “আমার নির্ভরতাগুলো ভেতরে আটকানো।” তখন test-কে আরও চতুর করার বদলে কোডের নকশা বদলানোর কথা ভাবুন।

৩ · Seam — যেখানে কোড না বদলেই আচরণ বদলানো যায়

Michael Feathers তাঁর Working Effectively with Legacy Code (২০০৪) বইয়ে এই সমস্যার জন্য একটি শব্দ দেন: seam, অর্থাৎ সেলাইয়ের জোড়া। তাঁর সংজ্ঞার সারকথা: seam হলো প্রোগ্রামের এমন জায়গা, যেখানে সেই জায়গার কোড না বদলেই আচরণ বদলানো যায়। প্রতিটি seam-এর একটি enabling point থাকে: যেখানে সিদ্ধান্ত নেওয়া হয় কোন আচরণটি চলবে, আসল না নকল।

Feathers তিন রকম seam বর্ণনা করেন, মূলত C, C++ আর Java মাথায় রেখে:

Preprocessing seam

C/C++-এ #define বা #ifdef TESTING দিয়ে compile-এর আগেই কোড বদলানো। Enabling point: preprocessor-এর define. শক্তিশালী, কিন্তু কোড পড়া কঠিন করে।

compile-এর আগে

Link seam

Link বা load-এর সময় আসল library-র বদলে অন্য একটি জোড়া, যেমন test build-এ নকল .o ফাইল বা classpath-এ আলাদা class. Python-এ সবচেয়ে কাছের মিল module-এর নাম patch করা।

import/link-এর সময়

Object seam

কোড একটি object-এর method ডাকে, কিন্তু কোন object তা বাইরে থেকে আসে; test অন্য object দেয়। Enabling point: যেখানে object তৈরি হয়ে পাঠানো হয়, যেমন constructor-এর parameter.

চলার সময়

Python-এর ক্ষেত্রে একটি সতর্কতা: Python dynamic ভাষা, প্রায় যেকোনো নাম চলার সময় বদলানো যায়। তাই প্রায় সব জায়গাতেই একটি “import seam” আছে, যার enabling point হলো mock.patch-এর target. এটি সুবিধা, কারণ legacy code-এ শুরু করা সহজ; আবার ফাঁদও, কারণ এর ভরসায় কোড কখনো testable নকশায় আসে না। Feathers-এর তিন ভাগ Python-এ হুবহু খাটে না, এটি আমাদের ব্যাখ্যা। নিচের stepper-এ place_order-এর প্রতিটি নির্ভরতার জন্য seam খুঁজে দেখি।

1def place_order(...):2    total = ...   # pure3    now = datetime.now()4    n = random.randint(..)5    txn = wallet_pay(...)6    ORDERS.append(ref)7    print(f"... {txn}")
এই লাইনের নির্ভরতা
নির্ভর করে
এখন seam
ভালো seam
  1. হিসাবের লাইন। ছাড়, delivery আর মোট শুধু amount, district আর plus থেকে আসে। বাইরের কিছু পড়ে না, কিছু বদলায় না। এখানে কোনো seam লাগে না; এই অংশটুকু আলাদা করতে পারলে সরাসরি test করা যায় (§৫)।
  2. ঘড়ি। datetime.now() চালানোর মুহূর্তের সময় দেয়। এখন একমাত্র seam হলো module-এর datetime নামটি patch করা। ভালো seam: সময় দেওয়ার একটি function (clock) parameter হিসেবে নেওয়া।
  3. Random. random.randint module-এর function, তাই আবার import seam. ভালো seam: reference বানানোর কাজটিই (new_ref) বাইরে থেকে দেওয়া; test তখন একটি নির্দিষ্ট reference ফেরত দেয়।
  4. Network. wallet_pay নাম ধরে সরাসরি ডাকা, যা Java-র static call-এর মতো। Patch ভুল জায়গায় পড়লে আসল অনুরোধ চলে যায়। ভালো seam: একটি wallet object, যার pay method ডাকা হয়; test একটি নকল wallet দেয়। এটিই object seam.
  5. Global list. ORDERS-এর জন্য কোনো seam নেই; patch করতে হয়, নইলে প্রতিটি test-এর পরে list খালি করতে হয়। ভালো সমাধান seam নয়, নকশা: order হয় ফেরত মান, নয়তো একটি repository object-এ যায়, যা বাইরে থেকে আসে।
  6. Console. print সরাসরি stdout-এ লেখে; test-কে redirect_stdout বা pytest-এর capsys দিয়ে ধরতে হয়। ভালো seam: লেখার function (out) parameter হিসেবে, যার default print.
  7. সারাংশ। পাঁচটি লুকানো নির্ভরতা। চারটিতে এখন import seam আছে, আর সবগুলোরই enabling point patch বা redirect, যা ভেতরের নাম জানা দাবি করে। Object seam শূন্য। পরের ধাপ: এই নির্ভরতাগুলো signature-এ তুলে আনা।

৪ · Dependency injection — নির্ভরতা বাইরে থেকে দেওয়া

Dependency injection শব্দটি জনপ্রিয় হয় Martin Fowler-এর ২০০৪ সালের একটি লেখা থেকে। নামটি ভারী শোনালেও ধারণা সরল: একটি function বা object তার দরকারি জিনিস নিজে বানায় না বা নিজে খুঁজে আনে না; যে ডাকে, সে দিয়ে দেয়। “ঘড়ি দেখে সময় নাও” নয়, “এই ঘড়ি থেকে সময় নাও।” Python-এ এর জন্য কোনো framework লাগে না; একটি parameter-ই যথেষ্ট।

রূপবাজারঘরেকখন ভালো
Constructor injectionCheckout(wallet, clock, new_ref)যে নির্ভরতা object-এর পুরো জীবন লাগে; signature পড়েই সব নির্ভরতা দেখা যায়
Parameter injectionplace_order(..., clock=datetime.now)একটি function-এ, বিশেষত legacy কোডে: default থাকায় পুরোনো ডাকগুলো বদলাতে হয় না
Function injectionout=print, sleep=time.sleepনির্ভরতা একটিমাত্র কাজ হলে; class বানানোর দরকার নেই
Setter বা attributeshop.wallet = FakeWallet()কম পছন্দের; object কিছুক্ষণ অসম্পূর্ণ থাকে, আর ভুলে গেলে আসল wallet থেকে যায়

Parameter-এর default নিয়ে একটি জরুরি সতর্কতা, যা interview-তেও আসে। clock=datetime.now (function, বন্ধনী ছাড়া) ঠিক: প্রতিবার ডাকার সময় নতুন সময় আসে। কিন্তু now=datetime.now() (বন্ধনীসহ) লিখলে Python default মানটি function তৈরির সময় একবারই হিসাব করে। ফলে production-এ সার্ভার চালুর মুহূর্তের সময় প্রতিটি order-এ বসে যায়, আর test সবসময় নিজের now দেয় বলে ভুলটি কখনো দেখে না। অনুশীলন ৩-এ এটি ধরবেন।

আসল জিনিসগুলো কোথায় জোড়া হবে? সাধারণত প্রোগ্রামের শুরুর এক জায়গায়, যাকে বলে composition root: Checkout(HttpsWallet(KEY), clock=lambda: datetime.now(timezone.utc), new_ref=random_ref). বাকি কোড শুধু parameter পায়। কোন জিনিস inject করবেন, তার একটি ব্যবহারিক নিয়ম:

  • Inject করুন: যা test-এ নিয়ন্ত্রণ করতে হয় বা যা ধীর অথবা ঝুঁকিপূর্ণ: সময়, random, network, file, database, ইমেইল বা SMS, ঘুম (sleep), environment-এর মান।
  • Inject করবেন না: ছোট pure helper (যেমন coupon_discount), মান-বস্তু (তারিখ, টাকার অঙ্ক), standard library-র হিসাবের function. এগুলো test-এ আসলটাই চলুক; নকল বসালে test আসল আচরণ যাচাই করা বন্ধ করে।
  • সংকেত: constructor-এ সাত-আটটি parameter জমে গেলে DI-র দোষ নয়, class-টি অনেক দায়িত্ব নিয়েছে; ভাগ করার সময়।

DI-র উল্টো রূপ service locator: class নিজের ভেতর থেকে একটি global রেজিস্টারে চায়, “আমাকে একটি wallet দাও।” Test-এ রেজিস্টারে নকল বসানো যায় বটে, কিন্তু নির্ভরতা আবার signature থেকে লুকিয়ে যায়, আর রেজিস্টারটি নিজেই global state. Testability-র লক্ষ্য শুধু “নকল বসানো সম্ভব” নয়; নির্ভরতা চোখে দেখা যাওয়াও।

৫ · Functional core, imperative shell আর pure function

DI নির্ভরতাগুলো বাইরে আনে। কিন্তু আরও ভালো হয় যদি কোডের বড় অংশের কোনো নির্ভরতাই না থাকে। Gary Bernhardt ২০১২ সালের দিকে তাঁর একটি screencast আর “Boundaries” নামের বক্তৃতায় এই নকশাকে নাম দেন functional core, imperative shell: সিদ্ধান্ত আর হিসাব থাকুক একটি pure core-এ, আর বাইরের জগতের সাথে সব কাজ (সময় পড়া, টাকা কাটা, ছাপা) একটি পাতলা shell-এ।

Pure function দুটি শর্ত মানে: একই input-এ সবসময় একই output, আর কোনো side effect নেই (বাইরের কিছু পড়ে না, বদলায় না)। এমন function-এর test সবচেয়ে সহজ: ডাকুন, উত্তর পড়ুন, মিলিয়ে নিন। কোনো mock নেই, setUp নেই, cleanup নেই। পর্ব ০৮-এর সব boundary value এক টেবিলে চালানো যায়। নিচের stepper-এ place_order থেকে pure অংশটুকু ধাপে ধাপে বের করা হলো।

checkout_legacy.pyশুরু: সব মেশানো
def place_order(amount, district,
                phone, plus=False):
    discount = ...
    delivery = ...
    total = amount - discount + delivery
    now = datetime.now()
    ref = f"BG-...{random.randint(..)}"
    txn = wallet_pay(phone, total, ref)
    ORDERS.append(ref)
    print(f"{ref} ... txn {txn}")
    return ref
checkout_legacy.pyকোন লাইন pure?
def place_order(amount, district,
                phone, plus=False):
    discount = ...
    delivery = ...
    total = amount - discount + delivery
    now = datetime.now()
    ref = f"BG-...{random.randint(..)}"
    txn = wallet_pay(phone, total, ref)
    ORDERS.append(ref)
    print(f"{ref} ... txn {txn}")
    return ref
checkout.pyনতুন pure function
def price_order(amount, district,
                plus=False):
    discount = ...      # moved as is
    delivery = ...      # moved as is
    return {"discount": discount,
            "delivery": delivery,
            "total": amount - discount
                     + delivery}
checkout_legacy.pyপুরোনোটি নতুনকে ডাকে
def place_order(amount, district,
                phone, plus=False):
    bill = price_order(amount,
                       district, plus)
    now = datetime.now()
    ...
    txn = wallet_pay(phone,
                     bill["total"], ref)

characterization tests: 4 passed
test_price.pyনকল ছাড়া test
price_order(1000, "Dhaka")["total"]
→ 1060   # no coupon, 60 delivery
price_order(1001, "Dhaka")["total"]
→ 961    # 1001 - 100 + 60
price_order(1999, "Dhaka")["total"]
→ 1860   # 1999 - 199 + 60
price_order(2000, "Dhaka")["total"]
→ 1800   # free from 2000
checkout.pyবাকি থাকল পাতলা shell
class Checkout:
    def __init__(self, wallet, clock,
                 new_ref, out=print):
        ...
    def place(self, amount, district,
              phone, plus=False):
        bill = price_order(...)  # core
        now = self.clock()
        ref = self.new_ref(now)
        txn = self.wallet.pay(...)
        self.out(...)
  1. শুরু। এগারো লাইনের function, যেখানে হিসাব আর বাইরের কাজ মেশানো। দামের একটি নিয়ম test করতে হলেও পুরো function চালাতে হয়, তাই ঘড়ি, random, wallet আর print সব সাজাতে হয় (§২-এর মতো)।
  2. চিহ্নিত করা। প্রতিটি লাইনের পাশে প্রশ্ন: এই লাইন কি শুধু input পড়ে? তিনটি লাইন (ছাড়, delivery, মোট) pure; বাকি পাঁচটি বাইরের জগৎ ছোঁয়। Pure লাইনগুলো পাশাপাশি আছে, তাই বের করা সহজ।
  3. Extract function. তিনটি লাইন হুবহু একটি নতুন function price_order-এ সরানো হলো, যা একটি dict ফেরত দেয়। কোনো হিসাব বদলানো হয়নি, শুধু সরানো; এটি refactoring-এর সবচেয়ে নিরাপদ ধাপগুলোর একটি।
  4. পুরোনোটি নতুনকে ডাকে। place_order এখন price_order ডেকে মোট নেয়। বাইরে থেকে আচরণ একই, আর সেটি বিশ্বাস নয়, প্রমাণ দিয়ে জানা: আগে থেকে লেখা characterization test (§৭) এখনও সবুজ।
  5. নকল ছাড়া test. Pure function-এর boundary test এখন এক লাইনের: ১০০০-এ ১০৬০, ১০০১-এ ৯৬১, ১৯৯৯-এ ১৮৬০, ২০০০-এ ১৮০০. কোনো mock, patch বা সময় লাগেনি। দামের নিয়মের সব test এখানে থাকবে, আর সেগুলো মিলিসেকেন্ডে চলবে।
  6. পাতলা shell. বাকি থাকল চারটি বাইরের কাজ, আর সেগুলো এখন constructor দিয়ে আসা object বা function. Shell-এ কোনো if বা হিসাব নেই, তাই তার test কম লাগে: সঠিক মোট wallet-এ গেল কি না, আর রসিদ ঠিক ছাপল কি না।

নিচের block-এ নতুন নকশাটি পুরো: pure price_order আর constructor injection-সহ Checkout. শেষে core-কে সরাসরি ছয়টি input দিয়ে ডাকা হলো। পরের block এই কোড ব্যবহার করবে (data-shared).

from datetime import datetime, timedelta, timezone
DHAKA = timezone(timedelta(hours=6))

def price_order(amount, district, plus=False):     # functional core: pure
    discount = 0 if amount <= 1000 else min(amount // 10, 300)
    if district == "Dhaka":
        delivery = 0 if amount >= 2000 else 60
    else:
        delivery = 60 if plus else 120
    return {"discount": discount, "delivery": delivery,
            "total": amount - discount + delivery}

class Checkout:                                     # imperative shell
    def __init__(self, wallet, clock, new_ref, out=print):
        self.wallet, self.clock = wallet, clock      # constructor injection
        self.new_ref, self.out = new_ref, out

    def place(self, amount, district, phone, plus=False):
        bill = price_order(amount, district, plus)
        now = self.clock().astimezone(DHAKA)
        ref = self.new_ref(now)
        txn = self.wallet.pay(phone, bill["total"], ref)
        self.out(f"{ref} {now:%d-%m-%Y %H:%M} total {bill['total']} txn {txn}")
        return ref

# the pure core needs no doubles at all: call it, read the answer
for args in [(1000, "Dhaka"), (1001, "Dhaka"), (1999, "Dhaka"),
             (2000, "Dhaka"), (800, "Sylhet"), (800, "Sylhet", True)]:
    print(f"{str(args):24} -> {price_order(*args)}")

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

(1000, 'Dhaka')          -> {'discount': 0, 'delivery': 60, 'total': 1060}
(1001, 'Dhaka')          -> {'discount': 100, 'delivery': 60, 'total': 961}
(1999, 'Dhaka')          -> {'discount': 199, 'delivery': 60, 'total': 1860}
(2000, 'Dhaka')          -> {'discount': 200, 'delivery': 0, 'total': 1800}
(800, 'Sylhet')          -> {'discount': 0, 'delivery': 120, 'total': 920}
(800, 'Sylhet', True)    -> {'discount': 0, 'delivery': 60, 'total': 860}

ছয়টি ফলই মডিউল ২-এর নিয়মের সাথে মেলে: ১০০০ টাকায় ছাড় নেই (নিয়ম “বেশি হলে”), ১০০১-এ ১০০ (১০০.১-এর ভগ্নাংশ বাদ), ২০০০-এ ছাড় ২০০ আর delivery ফ্রি, কারণ সীমা মাপা হয় coupon-এর আগের দামে। ঢাকার বাইরে সাধারণ ক্রেতা ১২০, Plus সদস্য ৬০. এই প্রতিটি লাইন একটি সম্ভাব্য test, আর কোনোটিতেই ঘড়ি, wallet বা console লাগেনি। আরেকটি জিনিস: shell সময়কে astimezone(DHAKA) দিয়ে ঢাকার সময়ে আনে। সার্ভার UTC-তে চললেও reference-এর তারিখ ঢাকার দিন ধরে হবে, আর পরের block-এ সেটিই যাচাই করব।

এই নকশার একটি পুরোনো আত্মীয় আছে: Gerard Meszaros-এর xUnit Test Patterns (২০০৭) বইয়ের humble object pattern. যে অংশ test করা কঠিন (UI, hardware, network), তাকে এত “নম্র” করুন যে তাতে প্রায় কোনো logic না থাকে; logic সরিয়ে আনুন এমন জায়গায়, যা সহজে test হয়। একই ভাবনা, ভিন্ন নাম।

৬ · Port আর adapter — test-এর জন্য নিজের adapter

Shell যখন একটি wallet object চায়, তখন প্রশ্ন ওঠে: wallet বলতে ঠিক কী? উত্তরটি একটি চুক্তি: “যার একটি pay(phone, amount, ref) method আছে, যা একটি transaction id ফেরত দেয়।” Alistair Cockburn ২০০৫ সালের দিকে এই ধারণাকে hexagonal architecture বা ports and adapters নামে বর্ণনা করেন: application-এর কেন্দ্র তার নিজের ভাষায় কিছু port (চুক্তি) ঘোষণা করে, আর বাইরের প্রতিটি জিনিস একটি adapter দিয়ে সেই port-এ লাগে। Cockburn-এর একটি মূল উদ্দেশ্যই ছিল application-কে UI বা database ছাড়াই, test থেকে চালাতে পারা।

একই shell, দুই সেট adapter

ওপরে production-এর আসল adapter, নিচে test-এর নিজের adapter; মাঝে port

Ports and adapters: the same Checkout shell wired to production adapters or to test adapters Production-এ: আসল adapter সিস্টেম ঘড়িHTTPS wallet random refprint / log Checkout · shell price_order pure core, port নেই port: clock · walletnew_ref · out fixed_clockFakeWallet "BG-…-0001"lines.append Test-এ: নিজের adapter
ছবি ২৫.১ — Shell শুধু port চেনে, adapter চেনে না। Composition root ঠিক করে কোন সেট লাগবে। Pure core-এর কোনো port নেই, তাই তার test-এ কোনো adapter-ই লাগে না।

Python-এ port লেখার জন্য আলাদা ঘোষণা বাধ্যতামূলক নয়; duck typing-এ যার pay আছে, সে-ই wallet. তবে চুক্তিটি লিখে রাখলে type checker মিল যাচাই করতে পারে। এর জন্য typing.Protocol, যা Python কোর্সের পর্ব ৩৫-এ আছে। নিচের block-এ test-এর adapter হলো একটি fake object, FakeWallet: memory-তে একটি list-এ লিখে রাখে কে কত টাকা দিল। ঘড়ি একটি fake clock, যা সবসময় একই মুহূর্ত বলে। কোনো mock.patch নেই।

import sys, unittest

class FakeWallet:                         # in-memory fake: no network
    def __init__(self):
        self.paid = []
    def pay(self, phone, amount, ref):
        self.paid.append((ref, amount))
        return f"T-{len(self.paid)}"

def fixed_clock(*ymdhm):                  # a clock that always says the same
    return lambda: datetime(*ymdhm, tzinfo=timezone.utc)

class CheckoutTests(unittest.TestCase):
    def setUp(self):
        self.wallet, self.lines = FakeWallet(), []
    def shop(self, clock):
        return Checkout(self.wallet, clock, out=self.lines.append,
                        new_ref=lambda now: f"BG-{now:%y%m%d}-0001")

    def test_plus_member_outside_dhaka_is_charged_860(self):
        self.shop(fixed_clock(2026, 11, 16, 15, 5)).place(
            800, "Sylhet", "01712345678", plus=True)
        self.assertEqual(self.wallet.paid, [("BG-261116-0001", 860)])

    def test_order_after_midnight_in_dhaka_gets_the_dhaka_date(self):
        # 19:30 UTC on 16 Nov is 01:30 on 17 Nov in Dhaka (UTC+6)
        ref = self.shop(fixed_clock(2026, 11, 16, 19, 30)).place(
            800, "Sylhet", "01712345678")
        self.assertEqual(ref, "BG-261117-0001")
        self.assertEqual(self.lines,
            ["BG-261117-0001 17-11-2026 01:30 total 920 txn T-1"])

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

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

test_order_after_midnight_in_dhaka_gets_the_dhaka_date (__main__.CheckoutTests.test_order_after_midnight_in_dhaka_gets_the_dhaka_date) ... ok
test_plus_member_outside_dhaka_is_charged_860 (__main__.CheckoutTests.test_plus_member_outside_dhaka_is_charged_860) ... ok

----------------------------------------------------------------------
Ran 2 tests in …

OK

দুটি test-ই সবুজ, আর এবার সবুজের মানে আছে। প্রথম test (রিপোর্টে নামের বর্ণানুক্রমে দ্বিতীয়) যাচাই করে Plus সদস্যের ৮০০ টাকার Sylhet অর্ডারে wallet-এ ঠিক ৮৬০ টাকা গেছে: ফলের ওপর assertion, ডাকের সংখ্যার ওপর নয়। দ্বিতীয় test এমন একটি অবস্থা তৈরি করে, যা datetime.now()-এর যুগে প্রায় অসম্ভব ছিল: UTC-তে ১৬ নভেম্বর সন্ধ্যা ৭টা ৩০, অথচ ঢাকায় তখন ১৭ নভেম্বর রাত ১টা ৩০. সার্ভার UTC-তে চললে reference-এর তারিখ কোন দিনের হবে? Test বলছে ঢাকার দিন, BG-261117. পর্ব ১৪-এর error guessing-এ যে time zone-এর ফাঁদ দেখেছেন, সেটি এখন যেকোনো সময়ে, যেকোনো যন্ত্রে, এক সেকেন্ডের কম সময়ে যাচাই করা যায়।

Fake-এর একটি দায়িত্ব আছে: আসল adapter-এর মতো আচরণ করা। FakeWallet কখনো timeout দেয় না, আসল wallet দেয়। Fake যদি আসলের চেয়ে “ভালো মানুষ” হয়, test আশাবাদী হয়ে যায়; পর্ব ২৪-এ এর নাম দেখেছেন mock drift. দুটি প্রতিকার: একই চুক্তি-test (contract test) fake আর আসল adapter দুটির ওপর চালানো, যাতে দুটি একই প্রশ্নে একই উত্তর দেয়; আর adapter-এর নিজের integration test, যা পর্ব ২৮ (Integration testing — কৌশল, test database আর Testcontainers)-এ আসবে। Consumer আর provider-এর মধ্যে চুক্তি যাচাই পুরোপুরি আসবে পর্ব ৩২ (Contract testing — consumer-driven contract আর Pact)-এ।

৭ · Legacy code আর characterization test

এতক্ষণ আমরা ধরে নিয়েছি কোড বদলানো নিরাপদ। কিন্তু বাজারঘরের আসল অবস্থা: পুরোনো কোডের কোনো test নেই, যিনি লিখেছিলেন তিনি দল ছেড়েছেন, আর কোনটি নিয়ম আর কোনটি দুর্ঘটনা, কেউ নিশ্চিত নন। Feathers এমন কোডের একটি কড়া সংজ্ঞা দেন: legacy code মানে test ছাড়া কোড, বয়স যাই হোক। কারণ test না থাকলে কোনো বদল আচরণ ভাঙল কি না, তা জানার উপায় নেই।

এখানে একটি দুষ্টচক্র আছে: নিরাপদে বদলাতে test লাগে, আর test লিখতে প্রায়ই কোড বদলাতে হয় (seam বানাতে)। Feathers-এর বইয়ে এর জন্য পাঁচ ধাপের একটি পদ্ধতি আছে, যা legacy code change algorithm নামে পরিচিত: (১) বদলের জায়গা চিহ্নিত করা, (২) test-এর জায়গা খোঁজা, (৩) নির্ভরতা ভাঙা, (৪) test লেখা, (৫) বদল আর refactor. তৃতীয় ধাপে কোড বদলাতে হয় test ছাড়াই, তাই সেখানে শুধু খুব ছোট, যান্ত্রিক, প্রায় ঝুঁকিহীন বদল চলে: একটি parameter যোগ করা যার default পুরোনো আচরণ রাখে, বা IDE-র “extract method”.

চতুর্থ ধাপের test সাধারণ test নয়। আপনি জানেন না কোড কী করা উচিত; জানেন শুধু সে এখন কী করে। Characterization test ঠিক সেটাই লেখে: বর্তমান আচরণের রেকর্ড। পদ্ধতিটি প্রায় যান্ত্রিক:

  1. কোডকে একটি input দিয়ে ডাকুন, আর assertion-এ ইচ্ছা করে একটি ভুল প্রত্যাশা লিখুন (যেমন "?")।
  2. Test চালান। ব্যর্থতার বার্তা বলে দেবে কোড আসলে কী দিয়েছে।
  3. সেই আসল মানটি প্রত্যাশার জায়গায় বসান। Test সবুজ; আচরণটি এখন রেকর্ড করা।
  4. যে মান অদ্ভুত লাগে, তা সারাবেন না; একটি মন্তব্যে “সন্দেহজনক” লিখে product owner-কে জিজ্ঞেস করুন। এখনকার লক্ষ্য আচরণ রক্ষা, বিচার নয়।
  5. বদলের জায়গার চারপাশে, বিশেষত সীমার মানে (পর্ব ০৮), যথেষ্ট input রেকর্ড না হওয়া পর্যন্ত চালিয়ে যান।

বাজারঘরের একটি পুরোনো রসিদ-function legacy_bill দেখুন, যার আউটপুট “দাম−ছাড়+delivery=মোট” আকারের একটি লেখা। একজন developer এটি “পরিচ্ছন্ন” করতে চান, আচরণ না বদলে। তিনি আগে চারটি input-এর আচরণ রেকর্ড করেছেন। নিচের block-এ দুটি test: রেকর্ড কি পুরোনো কোডের সাথে মেলে, আর নতুন tidy_bill কি সেই রেকর্ড রক্ষা করে?

import sys, unittest
def legacy_bill(amount, district, plus=False):    # 2019 code, no tests
    d = 0
    if amount > 1000:
        d = min(amount // 10, 300)
    dl = 60 if plus else 120
    if district == "Dhaka":
        dl = 0 if amount >= 2000 else 60
    return f"{amount}-{d}+{dl}={amount - d + dl}"

def tidy_bill(amount, district, plus=False):      # "same behaviour, cleaner"
    d = min(amount // 10, 300) if amount > 1000 else 0
    net = amount - d
    dl = 60 if plus else 120
    if district == "Dhaka":
        dl = 0 if net >= 2000 else 60
    return f"{amount}-{d}+{dl}={net + dl}"

RECORDED = {   # pasted from legacy_bill's real output: what it DOES today
    (999, "Dhaka"): "999-0+60=1059",
    (2000, "Dhaka"): "2000-200+0=1800",
    (2000, "dhaka"): "2000-200+120=1920",       # suspicious: ask the PO
    (3010, "Sylhet", True): "3010-300+60=2770"}

class Characterization(unittest.TestCase):
    def check(self, bill):
        for args, recorded in RECORDED.items():
            with self.subTest(bill.__name__, args=args):
                self.assertEqual(bill(*args), recorded)
    def test_1_legacy_bill_matches_the_recording(self):
        self.check(legacy_bill)
    def test_2_tidy_bill_keeps_the_recorded_behaviour(self):
        self.check(tidy_bill)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(
    unittest.defaultTestLoader.loadTestsFromTestCase(Characterization))

আসল আউটপুট (ব্রাউজারের Python, traceback ছোট করা):

test_1_legacy_bill_matches_the_recording (__main__.Characterization.test_1_legacy_bill_matches_the_recording) ... ok
test_2_tidy_bill_keeps_the_recorded_behaviour (__main__.Characterization.test_2_tidy_bill_keeps_the_recorded_behaviour) ...
  test_2_tidy_bill_keeps_the_recorded_behaviour (__main__.Characterization.test_2_tidy_bill_keeps_the_recorded_behaviour) [tidy_bill] (args=(2000, 'Dhaka')) ... FAIL

======================================================================
FAIL: test_2_tidy_bill_keeps_the_recorded_behaviour (__main__.Characterization.test_2_tidy_bill_keeps_the_recorded_behaviour) [tidy_bill] (args=(2000, 'Dhaka'))
----------------------------------------------------------------------
Traceback (most recent call last):
  …
AssertionError: '2000-200+60=1860' != '2000-200+0=1800'
- 2000-200+60=1860
?          -    ^
+ 2000-200+0=1800
?              ^


----------------------------------------------------------------------
Ran 2 tests in …

FAILED (failures=1)

প্রথম test প্রমাণ করে রেকর্ডটি সৎ: পুরোনো কোড আজও ঠিক এগুলোই দেয়। দ্বিতীয় test-এ চারটি রেকর্ডের তিনটি টিকে আছে, একটি ভেঙেছে: ঢাকায় ২০০০ টাকার রসিদ এখন 2000-200+60=1860, আগে ছিল 2000-200+0=1800. Diff-এর ^ চিহ্ন দেখায় পার্থক্য delivery-র ঘরে। কারণ খুঁজলে পাওয়া যায় tidy_bill-এর if net >= 2000: পরিচ্ছন্ন করতে গিয়ে developer সীমা মাপছেন ছাড়ের পরের দামে। পর্ব ২২-এর seeded defect-টি এখানে একটি “নিরীহ” refactor থেকে জন্ম নিল, আর characterization test সেটি merge-এর আগেই ধরল। Script দিয়ে গুনে দেখা গেছে, ঢাকায় ২০০০ থেকে ২২২১ টাকার প্রতিটি অর্ডারে দুই function-এর ফল আলাদা; রেকর্ডে ২০০০ না থাকলে এই বদল নিঃশব্দে চলে যেত।

লক্ষ করুন (2000, "dhaka")-এর রেকর্ড: ছোট হাতের “dhaka” লিখলে পুরোনো কোড ঢাকাকে ঢাকার বাইরে ধরে ১২০ টাকা নেয়। এটি প্রায় নিশ্চিতভাবেই একটি bug, কিন্তু characterization test সেটিকেও পাহারা দিচ্ছে, আর এটাই নিয়ম: refactor-এর ধাপে আচরণ বদলাবেন না, এমনকি ভুল আচরণও না। Bug সারানো একটি আলাদা, ইচ্ছাকৃত বদল, নিজের test আর নিজের commit-সহ, product owner-এর সম্মতিতে। তখন রেকর্ডের মন্তব্যটি মুছে নতুন প্রত্যাশা বসবে। আচরণ-রক্ষা আর আচরণ-বদল এক commit-এ মেশালে কোনটি দুর্ঘটনা তা আর বোঝা যায় না।

test_bill.pyপ্রত্যাশা অজানা
def test_bill_2000_dhaka(self):
    self.assertEqual(
        legacy_bill(2000, "Dhaka"),
        "?")
প্রথম runFAIL, ইচ্ছা করে
FAIL: test_bill_2000_dhaka
AssertionError:
  '2000-200+0=1800' != '?'

# the failure message tells us
# what the code does today
test_bill.py৪টি রেকর্ড, সবুজ
(999, "Dhaka"):  "999-0+60=1059"
(2000, "Dhaka"): "2000-200+0=1800"
(2000, "dhaka"): "2000-200+120=1920"
                 # suspicious: ask PO
(3010, "Sylhet", True):
                 "3010-300+60=2770"
legacy_bill: 4/4 ok
bill.pyRefactor
d = min(amount // 10, 300) \
    if amount > 1000 else 0
net = amount - d
dl = 60 if plus else 120
if district == "Dhaka":
    dl = 0 if net >= 2000 else 60
return f"...={net + dl}"
দ্বিতীয় run৩ ok, ১ FAIL
(999, 'Dhaka')        ok
(2000, 'Dhaka')       FAIL
  '2000-200+60=1860'
  != '2000-200+0=1800'
(2000, 'dhaka')       ok
(3010, 'Sylhet', T)   ok
সিদ্ধান্তrefactor-এর ভুল
diff: delivery 60 vs 0
spec: 2000 threshold is checked
      BEFORE the coupon
→ the recording is right,
  the refactor is wrong
fix:  dl = 0 if amount >= 2000
run:  4/4 ok → commit refactor
next: "dhaka" bug, own commit
  1. অজানা প্রত্যাশা। legacy_bill(2000, "Dhaka") কী দেয়, কেউ নিশ্চিত নন। প্রত্যাশার জায়গায় ইচ্ছা করে "?" লেখা হলো; লক্ষ্য test-কে দিয়ে কোডের উত্তর বলিয়ে নেওয়া।
  2. ব্যর্থতা পড়া। Test লাল, আর বার্তায় আসল মান: '2000-200+0=1800'. এটি “ঠিক” কি না এখনও জানি না; জানি শুধু কোড আজ এটাই করে। মডিউল ২-এর নিয়মের সাথে মিলিয়ে দেখলে এটি ঠিকও।
  3. রেকর্ড। একই পদ্ধতিতে চারটি input রেকর্ড হলো, প্রতিটি পুরোনো কোডে সবুজ। “dhaka” (ছোট হাতের)-এর ১২০ টাকা অদ্ভুত, তাই মন্তব্যে চিহ্ন দিয়ে product owner-এর প্রশ্নের তালিকায় গেল, কিন্তু রেকর্ডে যেমন আছে তেমনই থাকল।
  4. Refactor. Developer কোড ছোট করলেন: ছাড় এক লাইনে, তারপর net হিসাব করে তা দিয়েই delivery-র সীমা মাপলেন। দেখতে পরিচ্ছন্ন, আর তাঁর ধারণা আচরণ একই।
  5. ধরা পড়ল। চারটির তিনটি সবুজ, ঢাকার ২০০০ লাল: delivery এখন ৬০, আগে ০. ছাড়ের পরে দাম ১৮০০, যা ২০০০-এর কম, তাই নতুন কোড delivery নিচ্ছে। একটি রেকর্ড ঠিক সীমায় ছিল বলেই এটি ধরা গেল।
  6. সিদ্ধান্ত। নিয়ম বলে সীমা coupon-এর আগের দামে, তাই রেকর্ড ঠিক, refactor ভুল। net-এর বদলে amount বসাতেই চারটি সবুজ, আর refactor commit হলো। “dhaka”-র bug সারানো হবে পরে, আলাদা commit-এ, product owner-এর উত্তর এলে।

অনেক input একসাথে রেকর্ড করার কৌশলকে বলে golden master: হাজারো input-এ পুরোনো কোডের পুরো আউটপুট একটি ফাইলে রেখে নতুন কোডের আউটপুট তার সাথে মেলানো। এর আধুনিক, tool-সমর্থিত রূপ snapshot আর approval testing, যার সুবিধা আর ফাঁদ নিয়ে পুরো আলোচনা পর্ব ৬১ (Snapshot আর approval testing — কখন সুবিধা, কখন ফাঁদ)-এ। একটি সাবধানবাণী এখনই: রেকর্ড ততটুকুই রক্ষা করে, যতটুকু input রেকর্ডে আছে। অনুশীলন ২-এ দেখবেন, এই চারটি রেকর্ড একটি সত্যিকারের off-by-one বদল পুরোপুরি মিস করে।

৮ · বাজারঘরের checkout — test-এর নিচে ধাপে ধাপে refactor

এবার সব টুকরো একসাথে, একজন QA engineer বা developer বাস্তবে যে ক্রমে কাজ করবেন। কাজ: product owner চান checkout-এ একটি বদল, তাই আগে পুরোনো place_order-কে test-এর নিচে আনতে হবে।

  1. বদলের জায়গা আর test-এর জায়গা। বদল হবে দামের হিসাবে আর রসিদে; সবচেয়ে কাছের test-এর জায়গা হলো place_order-এর ফেরত মান আর রসিদের লাইন।
  2. Patch দিয়ে প্রথম জাল। কোড না বদলে, import seam ব্যবহার করে কয়েকটি characterization test: ঘড়ি, random আর wallet patch করে কয়েকটি সীমার মানে রসিদ রেকর্ড (§২-এর দ্বিতীয় test-এর মতো)। এই test-গুলো ভঙ্গুর, কিন্তু অস্থায়ী; এদের কাজ পরের ধাপগুলো পাহারা দেওয়া।
  3. Pure core বের করা। হিসাবের তিন লাইন price_order-এ (§৫-এর stepper). জালটি সবুজ থাকে। এবার core-এর সরাসরি boundary test লেখা যায়।
  4. নির্ভরতা signature-এ তোলা। প্রথমে default-সহ parameter (clock=datetime.now), যাতে কোনো caller না ভাঙে; তারপর ধীরে ধীরে Checkout class আর constructor injection. প্রতিটি ছোট ধাপের পরে suite চালানো।
  5. নতুন test, পুরোনো জাল সরানো। Fake wallet আর fake clock দিয়ে shell-এর আচরণ-test (§৬)। এগুলো এখন আগের patch-ভিত্তিক test-এর কাজ আরও ভালোভাবে করে, তাই ভঙ্গুর patch-test মুছে ফেলা যায়।
  6. এখন আসল বদল। আচরণ-বদলের জন্য আগে একটি লাল test, তারপর কোড। এটিই TDD-র চক্র, যা পর্ব ২৭ (TDD হাতে-কলমে — red-green-refactor, kata আর outside-in)-এ বিস্তারিত।

Desktop-এ সত্যিকারের run — pytest 9.2.0

এই ধাপগুলোর একটি ছোট রূপ একটি আসল project-এ: uv দিয়ে বানানো ~/bazarghar-qa, যেখানে bazarghar/checkout_legacy.py (পুরোনো কোড), bazarghar/checkout.py (core আর shell) আর bazarghar/bill.py (ভুলসহ “পরিচ্ছন্ন” রসিদ)। তিনটি test ফাইল: characterization (pytest-এর parametrize দিয়ে চারটি রেকর্ড), DI-ভিত্তিক checkout test, আর legacy কোডে patch-এর দুটি চেষ্টা, যার একটি ইচ্ছা করে ভুল target-এ: mock.patch("datetime.datetime.now", ...). pytest MIT licence-এর। সত্যিকারের run, Python 3.12, pytest 9.2.0; শুরুর platform আর path-এর লাইন বাদ দেওয়া হয়েছে, আর Python-এর নিজের ফাইলের path ছোট করে …/unittest/mock.py লেখা হয়েছে:

$ uv run pytest -v --tb=short
collecting ... collected 9 items

tests/test_characterization.py::test_bill_text_matches_recorded_behaviour[999-Dhaka] PASSED [ 11%]
tests/test_characterization.py::test_bill_text_matches_recorded_behaviour[2000-Dhaka] FAILED [ 22%]
tests/test_characterization.py::test_bill_text_matches_recorded_behaviour[2000-dhaka] PASSED [ 33%]
tests/test_characterization.py::test_bill_text_matches_recorded_behaviour[3010-Sylhet-plus] PASSED [ 44%]
tests/test_checkout.py::test_dhaka_order_of_2000_totals_1800 PASSED      [ 55%]
tests/test_checkout.py::test_plus_member_outside_dhaka_is_charged_860 PASSED [ 66%]
tests/test_checkout.py::test_order_after_midnight_in_dhaka_gets_the_dhaka_date PASSED [ 77%]
tests/test_legacy_patched.py::test_patch_datetime_now_directly FAILED    [ 88%]
tests/test_legacy_patched.py::test_patch_where_the_name_is_looked_up PASSED [100%]

================================== FAILURES ===================================
____________ test_bill_text_matches_recorded_behaviour[2000-Dhaka] ____________
tests\test_characterization.py:16: in test_bill_text_matches_recorded_behaviour
    assert bill_text(*args) == recorded
E   AssertionError: assert '2000-200+60=1860' == '2000-200+0=1800'
E
E     - 2000-200+0=1800
E     ?               -
E     + 2000-200+60=1860
E     ?          +    +
______________________ test_patch_datetime_now_directly _______________________
…/unittest/mock.py:1581: in __enter__
    setattr(self.target, self.attribute, new_attr)
E   TypeError: cannot set 'now' attribute of immutable type 'datetime.datetime'

During handling of the above exception, another exception occurred:
tests\test_legacy_patched.py:8: in test_patch_datetime_now_directly
    with mock.patch("datetime.datetime.now", return_value=datetime(2026, 11, 16, 21, 5)):
…
E   TypeError: cannot set 'now' attribute of immutable type 'datetime.datetime'
=========================== short test summary info ===========================
FAILED tests/test_characterization.py::test_bill_text_matches_recorded_behaviour[2000-Dhaka]
FAILED tests/test_legacy_patched.py::test_patch_datetime_now_directly - TypeE...
========================= 2 failed, 7 passed in 0.10s =========================

তিনটি জিনিস পড়ুন। প্রথম, characterization test-এর লাল লাইনের parameterized test id [2000-Dhaka] নিজেই বলে কোন রেকর্ড ভাঙল, আর pytest-এর diff-এ - আর + দেখায় delivery ০ থেকে ৬০ হয়েছে; in-page run-এর একই ভুল। দ্বিতীয়, datetime.datetime.now সরাসরি patch করা যায় না: datetime class টি C-তে লেখা একটি built-in type, তার attribute বদলানো নিষেধ, তাই TypeError: cannot set 'now' attribute of immutable type. নতুনরা এখানে প্রায়ই আটকে যান। সমাধান দুটি: যে module-এ নামটি খোঁজা হয় সেখানে datetime নামটিই patch করা (পরের test, PASSED), বা ঘড়ি inject করা (test_checkout.py-এর তিনটি test, কোনো patch ছাড়াই PASSED). সময় নিয়ন্ত্রণের জন্য freezegun বা time-machine-এর মতো library-ও আছে, যারা ভেতরে এই কাজটিই করে; পর্ব ২৪-এ সময় আর random-এর অংশ দেখুন। তৃতীয়, পুরো ৯টি test ০.১০ সেকেন্ডে শেষ, কোনো network ছাড়া।

আরও গভীরে: Vladimir Khorikov তাঁর Unit Testing Principles, Practices, and Patterns (২০২০) বইয়ে নির্ভরতাকে দুই ভাগে দেখার প্রস্তাব দেন বলে জানা যায়: যে নির্ভরতা শুধু আপনার application ব্যবহার করে (নিজের database), আর যার প্রভাব বাইরের লোক দেখে (wallet, SMS, অন্য সেবা)। তাঁর যুক্তিতে mock-এর প্রকৃত জায়গা দ্বিতীয়টি, কারণ সেখানে ডাকটাই চুক্তি; প্রথমটিতে আসল জিনিস দিয়ে integration test বেশি নির্ভরযোগ্য। ভাবনাটি functional core-এর সাথে মেলে: core-এ কোনো double নয়, shell-এর বাইরের দিকে চুক্তি যাচাই। আরেকটি খরচ মনে রাখুন: প্রতিটি নতুন port একটি নতুন বিমূর্ততা, যা পড়তে আর বুঝতে খরচ লাগে। শুধু test-এর জন্য দশটি interface বানানো থেকে সাবধান; প্রথম প্রশ্ন সবসময়, “এটি কি pure function হতে পারত?”

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

  • Testable code কী, আর কী একে কঠিন করে? — যে কোডের আচরণ সহজে নিয়ন্ত্রণ আর পর্যবেক্ষণ করা যায়; লুকানো ঘড়ি, random, network, global state আর বিশাল function একে কঠিন করে।
  • Dependency injection কেন testability বাড়ায়? — নির্ভরতা বাইরে থেকে আসে বলে test নিজের fake বা stub দিতে পারে, patch ছাড়াই; নির্ভরতাও signature-এ দেখা যায়।
  • Seam কী? তিনটি ধরন বলুন। — যেখানে সেই জায়গার কোড না বদলেই আচরণ বদলানো যায়; Feathers-এর preprocessing, link আর object seam; প্রতিটির একটি enabling point আছে।
  • Characterization test আর সাধারণ unit test-এর পার্থক্য? — প্রথমটি কোডের বর্তমান আচরণ রেকর্ড করে (ভুল হলেও), refactor রক্ষার জন্য; দ্বিতীয়টি requirement থেকে উচিত আচরণ যাচাই করে।
  • Functional core, imperative shell কী? — সিদ্ধান্ত আর হিসাব pure core-এ, যা double ছাড়াই test হয়; বাইরের কাজ একটি পাতলা shell-এ, যেখানে inject করা adapter বসে।

৯ · AI-এর যুগে testable code

AI assistant-কে একটি legacy function দিয়ে “test লিখে দিন” বললে দুটি চেনা ফল আসে। প্রথমটি patch-এর পাহাড়: পাঁচটি @patch decorator, প্রতিটি ভেতরের নাম ধরে, প্রায়ই ভুল target-এ (যেমন datetime.datetime.now, যা §৮-এ TypeError দিল), আর শেষে শুধু “wallet_pay.assert_called_once()”, অর্থাৎ ডাক হয়েছে কি না, কত টাকা গেল তা নয়। দ্বিতীয়টি নীরব “সংশোধন”: characterization test লিখতে বললে AI প্রায়ই সন্দেহজনক আচরণ (“dhaka” → ১২০) চুপচাপ “ঠিক” মান দিয়ে লেখে, ফলে test পুরোনো কোডেই লাল হয়, বা refactor-এর মধ্যে bug fix মিশিয়ে দেয়, আর বলে “আচরণ অপরিবর্তিত।” এর বাইরে চেনা ধরন: শুধু happy path (সাফল্যের সোজা পথ), সীমার মান বাদ, অপেক্ষার জন্য sleep, অস্তিত্বহীন library option, আর চালানো ছাড়াই “সব test পাস” দাবি। আবার উল্টো দিকে, একটি ছোট script-এর জন্য AI ভারী DI framework আর দশটি interface প্রস্তাব করতে পারে।

AI-কে কাজটি ধাপে ভাগ করে দিন, আর প্রতিটি ধাপে কী বদলানো নিষেধ তা স্পষ্ট বলুন:

নিচের Python function-এ কোনো test নেই। আমি এটিকে নিরাপদে refactor করতে চাই। ধাপে ধাপে কাজ করো: [এখানে place_order-এর পুরো কোড] ১. প্রথমে শুধু তালিকা দাও: এই function-এর প্রতিটি লুকানো নির্ভরতা (সময়, random, network, global, output) আর প্রতিটির জন্য কোন seam ব্যবহার করা যায়। কোড বদলাবে না। ২. তারপর characterization test লেখো: কোড এখন যা করে তাই রেকর্ড করবে, এমনকি কোনো আচরণ ভুল মনে হলেও। সন্দেহজনক মানের পাশে "# suspicious" মন্তব্য দাও, মান বদলাবে না। সীমার মান রাখবে: 1000, 1001, 1999, 2000, 2221, 2222; ঢাকার বাইরে Plus আর সাধারণ ক্রেতা। ৩. Patch করলে লিখবে কোন module-এ নামটি খোঁজা হয়, আর কেন সেখানে। ৪. এরপর pure function বের করার আর ঘড়ি ও wallet constructor দিয়ে inject করার refactor দাও; কোনো bug fix এই ধাপে মেশাবে না। DI framework ব্যবহার করবে না। ৫. Test চালিয়েছ বলে দাবি করবে না; শুধু বলো আমি কোন command চালালে কী দেখার আশা করি।

AI-এর দেওয়া refactor বা test হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১“শুধু test-এর জন্য নকশা বদলানো নকশার ক্ষতি করে” — ২০১৪ সালের “test-induced design damage” বিতর্কটি কী ছিল, আর আপনার অবস্থান কী হওয়া উচিত?

২০১৪ সালের এপ্রিলে Ruby on Rails-এর স্রষ্টা David Heinemeier Hansson একটি লেখায় “test-induced design damage” কথাটি ব্যবহার করেন। তাঁর অভিযোগ ছিল, শুধু unit test দ্রুত আর বিচ্ছিন্ন করার জন্য কিছু দল এত স্তর, interface আর inject করা object যোগ করে যে কোড পড়া কঠিন হয়ে যায়; সহজ একটি Rails controller ছয়টি ফাইলে ছড়িয়ে পড়ে। এর পরে Kent Beck, Martin Fowler আর তিনি “Is TDD Dead?” নামে কয়েকটি আলোচনায় (২০১৪ সালের মে–জুন) বিষয়টি নিয়ে প্রকাশ্যে কথা বলেন।

আলোচনার সারকথা, আমাদের পড়া অনুযায়ী, একটি ভারসাম্য। Beck আর Fowler স্বীকার করেন যে mock-এর অতিরিক্ত ব্যবহার আর অপ্রয়োজনীয় স্তর সত্যিই ক্ষতি করে। আবার তাঁরা দেখান, যে নকশা test করা কঠিন, তা প্রায়ই অন্য কারণেও কঠিন: বদলানো, পুনর্ব্যবহার আর বোঝা। Test এখানে একজন প্রথম ব্যবহারকারী, যিনি নকশার ব্যথা আগে টের পান।

এই পর্বের উদাহরণ দিয়ে বিচার করুন। price_order বের করা কোনো ক্ষতি নয়: function টি ছোট হলো, নাম পেল, আর এখন checkout ছাড়া অন্য জায়গাতেও (cart-এর পাতায় আগাম মোট দেখাতে) ব্যবহার করা যায়। ঘড়ি inject করাও ক্ষতি নয়: time zone-এর সিদ্ধান্তটি চোখে দেখা যায়। কিন্তু যদি কেউ coupon_discount-এর জন্য একটি DiscountPolicyInterface, একটি factory আর একটি DI container বানান, যাতে test-এ একটি নকল ছাড় বসানো যায়, তাহলে লাভ শূন্য, কারণ pure function-এর নকল দরকারই ছিল না, আর পাঠক তিনটি ফাইল ঘুরে একটি গুণফল খুঁজবেন।

ব্যবহারিক মানদণ্ড: যে বদল নির্ভরতাকে চোখে আনে বা pure অংশকে আলাদা করে, তা সাধারণত নকশাকে ভালো করে। যে বদল শুধু একটি mock বসানোর জায়গা বানায়, আর কোনো আসল বিকল্প adapter কখনো আসবে না, তা নিয়ে দ্বিতীয়বার ভাবুন। আর মনে রাখুন, সব test-কেই বিচ্ছিন্ন unit test হতে হবে না; কিছু জিনিস integration test-এ আসলটা দিয়ে যাচাই করাই সৎ।

মূল উপলব্ধি: Test-এর ব্যথা প্রায়ই নকশার ব্যথার আগাম সংকেত, কিন্তু প্রতিকার যেন নির্ভরতা সরল করে, শুধু নকল বসানোর জায়গা না বানায়।

প্র ০২Feathers কেন legacy code-কে “test ছাড়া কোড” বললেন? বয়স বা পুরোনো ভাষার বদলে এই সংজ্ঞার সুবিধা আর সমালোচনা কী?

সাধারণ কথায় legacy code মানে উত্তরাধিকারসূত্রে পাওয়া পুরোনো কোড, প্রায়ই পুরোনো ভাষা বা framework-এ। Michael Feathers ২০০৪ সালে Working Effectively with Legacy Code বইয়ে ইচ্ছা করে একটি উসকানিমূলক সংজ্ঞা দেন: test ছাড়া কোডই legacy code. তাঁর যুক্তি, test থাকলে কোডের আচরণ দ্রুত আর যাচাই করে বদলানো যায়; না থাকলে প্রতিটি বদল একটি অনুমান, কোড যত সুন্দর বা নতুনই হোক। এই সংজ্ঞায় গতকাল লেখা কোডও legacy, যদি তার test না থাকে।

সংজ্ঞার সুবিধা হলো এটি কাজের দিকে ঠেলে দেয়। “পুরোনো” বললে উপায় একটাই মনে হয়: নতুন করে লেখা, যা বড় system-এ কুখ্যাতভাবে ঝুঁকিপূর্ণ। “Test ছাড়া” বললে উপায় স্পষ্ট: আগে test-এর নিচে আনা, তারপর ধীরে বদলানো। বইটির বড় অংশ তাই ব্যবহারিক কৌশলের ক্যাটালগ: dependency ভাঙার কয়েক ডজন কৌশল, যেমন parameterize constructor, extract interface, sprout method (নতুন কাজ আলাদা, test-সহ ছোট method-এ লিখে পুরোনো থেকে এক লাইনে ডাকা) আর wrap method. Seam আর characterization test শব্দ দুটিও এই বইয়ের মাধ্যমে ছড়ায়।

সমালোচনাও আছে। কেউ বলেন সংজ্ঞাটি বেশি সরল: অনেক test থাকা কোডও বোঝা অসম্ভব হতে পারে, বিশেষত test যদি ভঙ্গুর বা অর্থহীন হয়; আবার ছোট, স্থির, কখনো না বদলানো script-এ test না থাকলেও তা “বোঝা” নয়। অন্যরা যোগ করেন, legacy-র আসল সমস্যা প্রায়ই জ্ঞানের অভাব: কেউ জানে না কেন নিয়মটি এমন। Characterization test এই জ্ঞানের একটি অংশ ফিরিয়ে আনে, কিন্তু “কেন” প্রশ্নের উত্তর দেয় না; সেজন্য মানুষের সাথে কথা বলতে হয়, যেমন আমাদের “dhaka” প্রশ্নটি।

একজন tester-এর জন্য সংজ্ঞাটির একটি বিশেষ অর্থ আছে: আপনার দলের কোন অংশ legacy, তা মাপা যায়। Release-এর ঝুঁকি বিচারে (পর্ব ৭৩-এর risk-based testing) test-হীন, ঘনঘন বদলানো অংশগুলোই সবচেয়ে বড় লাল পতাকা।

মূল উপলব্ধি: Legacy-কে বয়সে নয়, নিরাপদে বদলানোর ক্ষমতায় মাপুন; আর সেই ক্ষমতা ফেরানোর প্রথম ধাপ characterization test.

প্র ০৩Hexagonal architecture, functional core আর humble object — তিনটি ধারণা কোথা থেকে এল, আর একজন tester-এর কাছে এদের অভিন্ন বার্তা কী?

তিনটি ধারণা তিন সময়ে, তিন প্রেক্ষাপটে এসেছে। Alistair Cockburn ২০০৫ সালের দিকে hexagonal architecture বর্ণনা করেন; তাঁর লেখায় প্রেরণা হিসেবে ছিল একটি পুরোনো সমস্যা: business logic UI আর database-এর কোডে মিশে যায়, ফলে application-কে স্বয়ংক্রিয় test থেকে চালানো যায় না। তাঁর সমাধান, application নিজের ভাষায় port ঘোষণা করবে, আর UI, test script, database বা নকল database সবাই adapter হয়ে সেই port-এ লাগবে। ষড়ভুজ আকারটি শুধু ছবির সুবিধা, ছয় সংখ্যার কোনো অর্থ নেই।

Gerard Meszaros ২০০৭ সালের xUnit Test Patterns বইয়ে humble object pattern দেন একেবারে test-এর দিক থেকে: যে অংশ test-এ চালানো কঠিন (একটি GUI, একটি thread, একটি hardware driver), তাকে প্রায় logic-শূন্য করুন, আর logic এমন object-এ সরান যা সহজে test হয়। ২০১২ সালের দিকে Gary Bernhardt functional programming-এর দিক থেকে একই কথা বলেন: সিদ্ধান্তগুলো immutable data-র ওপর pure function-এ, আর বাইরের জগতের সাথে যোগাযোগ একটি পাতলা imperative shell-এ। Robert C. Martin-এর Clean Architecture (২০১২-র লেখা, পরে ২০১৭-র বই) একই ধারার আরেকটি রূপ, যা সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪০-এ দেখবেন।

অভিন্ন বার্তাটি tester-এর জন্য সোজা: যেখানে সিদ্ধান্ত, সেখানে নির্ভরতা নয়। বাজারঘরের সব জটিলতা (ছাড়ের সীমা, delivery-র নিয়ম, order-এর অবস্থা, রিভিউর শর্ত) সিদ্ধান্ত; এগুলো pure core-এ থাকলে মডিউল ২-এর প্রতিটি technique (partition, boundary, decision table, state transition) সরাসরি, দ্রুত, শত শত case-এ চালানো যায়। Shell-এ বাকি থাকে কম সংখ্যক, কিন্তু ভিন্ন ধরনের প্রশ্ন: সঠিক টাকা কি wallet-এ গেল, timeout হলে কী হয়। এই প্রশ্নগুলো integration আর contract test-এর বিষয়।

ফলে test pyramid-এর আকারও নকশা থেকে আসে। যে দলের logic UI-তে বা SQL-এর ভেতরে, তারা বাধ্য হয়ে ধীর end-to-end test-এ ভর করে; যার pure core বড়, তার pyramid-এর নিচের স্তর চওড়া আর দ্রুত।

মূল উপলব্ধি: তিন নাম, এক নীতি: logic-কে বাইরের জগৎ থেকে আলাদা করুন, তাহলে সবচেয়ে বেশি test সবচেয়ে সস্তা জায়গায় বসবে।

প্র ০৪সময়কে কেন সবচেয়ে বিপজ্জনক লুকানো নির্ভরতা বলা হয়? বাস্তবের কোন ধরনের সময়-সম্পর্কিত ব্যর্থতা inject করা ঘড়ি দিয়ে আগেই ধরা যায়?

সময় এমন একটি input, যা প্রতিটি run-এ নিজে থেকে বদলায়, আর যার সবচেয়ে বিপজ্জনক মানগুলো (মধ্যরাত, মাসের শেষ, অধিবর্ষের ২৯ ফেব্রুয়ারি, বছরের শেষ সেকেন্ড, ঘড়ি এগোনো-পেছানোর দিন) খুব কম আসে। datetime.now()-নির্ভর কোডের test তাই দুই রকম ভুল করে: হয় আজকের তারিখে সবুজ থেকে বিপজ্জনক দিনটি কখনো দেখে না, নয়তো ঠিক সেই দিনে হঠাৎ লাল হয়ে flaky বলে বদনাম পায় (flaky test, পর্ব ৪০)।

ইতিহাসে এর উদাহরণ অনেক। Y2K সমস্যা ছিল বছরকে দুই অঙ্কে রাখার ফল, যা ২০০০ সালে পৌঁছে তুলনা আর হিসাব উল্টে দিতে পারত। ৩২-বিটের Unix সময় ২০৩৮ সালের জানুয়ারিতে ভরে যাবে, যার প্রস্তুতি এখনও চলছে। অধিবর্ষের হিসাবে ভুলের কারণে বিভিন্ন যন্ত্র বছরের শেষ দিনে আটকে যাওয়ার ঘটনা প্রকাশ্যে আলোচিত হয়েছে। বাংলাদেশের কাছের একটি উদাহরণও আছে: আমাদের জানামতে ২০০৯ সালের জুনে দেশে daylight saving time চালু করে ঘড়ি এক ঘণ্টা এগোনো হয়, আর সেই বছরের শেষে আবার আগের সময়ে ফেরানো হয়। Time zone-এর তথ্যভান্ডার এমন বদল ধরে রাখে, কিন্তু যে কোড নিজের মতো “UTC+6” ধরে নেয়, তার হিসাব সেই মাসগুলোর পুরোনো তারিখে ভুল হতে পারে।

Inject করা ঘড়ি এই প্রতিটি দিনকে একটি সাধারণ test case বানায়: fixed_clock(2026, 12, 31, 18, 0) দিলে ঢাকায় নতুন বছর শুরু, reference হয় BG-270101; অনুশীলন ১-এ এর সীমার মানগুলো নিজে বের করবেন। পর্ব ০৮-এর boundary value analysis সময়ের ওপরও খাটে: ২৩:৫৯:৫৯ আর ০০:০০:০০ একটি সীমার দুই পাশ। Sleep আর timeout-এর বেলায়ও একই কৌশল: sleep inject করলে তিন দফা retry-র test সত্যিকারের তিন সেকেন্ড অপেক্ষা না করে মুহূর্তে চলে।

আরেকটি সূক্ষ্ম বিষয়: ঘড়ি inject করলেও “কোন time zone-এ” সিদ্ধান্তটি কোডে স্পষ্ট লিখতে হয়। আমাদের shell সময়কে ঢাকায় আনে; কিন্তু database-এ রাখার সময় UTC রাখাই সাধারণ চর্চা। এই দুই সিদ্ধান্ত আলাদা test-এ যাচাই হলে ভালো।

মূল উপলব্ধি: সময় একটি input; তাকে input-এর মতো বাইরে থেকে দিন, তাহলে সবচেয়ে বিরল দিনটিও প্রতিটি run-এ test হবে।

প্র ০৫Characterization test bug-কেও পাহারা দেয়। তাহলে এটি কি নিরাপত্তা, না ফাঁদ? কখন এগুলো রাখবেন, কখন সাধারণ test দিয়ে বদলাবেন?

Characterization test-এর শক্তি আর দুর্বলতা একই জায়গায়: এটি requirement জানে না। Refactor-এর সময় এটাই চাই, কারণ refactor-এর সংজ্ঞাই হলো বাইরের আচরণ না বদলানো; আচরণ ঠিক কি ভুল, সেই বিচার তখন অপ্রাসঙ্গিক। আমাদের উদাহরণে এটি ঠিক কাজটিই করল: একটি নিরীহ-দেখতে বদল delivery-র নিয়ম ভাঙল, আর রেকর্ড সেটি ধরল।

ফাঁদ শুরু হয় যখন এই test-গুলো স্থায়ী হয়ে যায় আর দল ভুলে যায় এগুলো কী। ছয় মাস পরে কেউ “dhaka”-র bug সারালেন, একটি test লাল হলো, আর নতুন সদস্য ভাবলেন তিনি কিছু ভেঙেছেন; বা উল্টো, কেউ লাল দেখে অভ্যাসবশত রেকর্ড “হালনাগাদ” করে দিলেন, আর একটি আসল regression চুপচাপ নতুন রেকর্ড হয়ে গেল। Snapshot আর approval testing-এর পরিচিত সমস্যাও এটাই, যা পর্ব ৬১-এ বিস্তারিত: “approve” বোতাম চাপা সহজ, পার্থক্য পড়া কঠিন। Llewellyn Falco-র ApprovalTests ধরনের tool এই কাজকে সহজ করে, কিন্তু পার্থক্য বিচারের দায় মানুষেরই থাকে।

একটি স্বাস্থ্যকর জীবনচক্র এমন হতে পারে। প্রথমে, স্পষ্ট নাম আর জায়গা: tests/characterization/ ফোল্ডারে, নামে “recorded”. দ্বিতীয়, প্রতিটি সন্দেহজনক রেকর্ডের পাশে মন্তব্য আর একটি খোলা প্রশ্ন বা ticket. তৃতীয়, refactor শেষ হলে যে আচরণ requirement দিয়ে নিশ্চিত হলো, তার জন্য সাধারণ, আচরণ-নামের unit test লেখা (pure core-এর ওপর), আর সংশ্লিষ্ট রেকর্ড মুছে ফেলা। চতুর্থ, যে আচরণ নিয়ে কেউ নিশ্চিত নন, তার রেকর্ড রেখে দেওয়া, কারণ অন্তত বদল হলে কেউ জানবেন।

AI-এর যুগে এর গুরুত্ব বেড়েছে। AI দিয়ে বড় পরিমাণ পুরোনো কোড দ্রুত refactor করানো লোভনীয়, আর characterization test তার সবচেয়ে সস্তা নিরাপত্তা জাল; কিন্তু শর্ত হলো রেকর্ডটি পুরোনো কোড চালিয়ে আসা, AI-এর অনুমান থেকে নয়।

মূল উপলব্ধি: Characterization test একটি অস্থায়ী ভারা: refactor-এর সময় অপরিহার্য, শেষে requirement-ভিত্তিক test দিয়ে ধীরে ধীরে বদলানোর মতো।

অনুশীলন

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

  1. Spec থেকে test (test design): বাজারঘরের order reference-এর নিয়ম: BG-YYMMDD-NNNN, যেখানে তারিখ হলো order-এর মুহূর্তে ঢাকার (UTC+6) তারিখ। Checkout-এর ঘড়ি UTC সময় দেয়। (ক) Boundary value analysis দিয়ে চারটি test case লিখুন: ঘড়ির UTC মান আর প্রত্যাশিত reference-এর তারিখ অংশ। (খ) পুরোনো datetime.now()-নির্ভর কোডে এই test-গুলো কেন কার্যত অসম্ভব?

    (ক) ঢাকার মধ্যরাত মানে UTC-র ১৮:০০. সীমার দুই পাশ, আর বছর বদলের দুই পাশ (script দিয়ে মেলানো):

    ঘড়ি (UTC)ঢাকায়প্রত্যাশিত
    2026-11-16 17:59:5916-11 23:59:59BG-261116
    2026-11-16 18:00:0017-11 00:00:00BG-261117
    2026-12-31 17:59:0031-12 23:59BG-261231
    2026-12-31 18:00:002027-01-01 00:00BG-270101

    (খ) datetime.now() চালানোর মুহূর্তের সময় দেয়; ঢাকার মধ্যরাতের ঠিক আগের সেকেন্ডটি পেতে test-কে ঠিক সেই সময়ে চালাতে হতো। তা ছাড়া now() যন্ত্রের local time দেয়, তাই UTC সার্ভার আর ঢাকার ল্যাপটপে একই test ভিন্ন ফল দিত। Patch দিয়ে সম্ভব, কিন্তু inject করা ঘড়িতে এটি একটি সাধারণ parameter.

  2. আউটপুট অনুমান করুন (read the result): §৭-এর চারটি রেকর্ড (৯৯৯ ঢাকা, ২০০০ ঢাকা, ২০০০ “dhaka”, ৩০১০ Sylhet Plus) অপরিবর্তিত। এবার আরেকজন developer legacy_bill-এর if amount > 1000: বদলে লিখলেন if amount >= 1000:. Characterization test চালালে কয়টি subTest লাল হবে? এ থেকে কী শেখা যায়, আর কোন রেকর্ড যোগ করবেন?

    একটিও না; চারটিই সবুজ থাকবে (script-এ চালিয়ে মেলানো)। বদলটি শুধু ঠিক ১০০০ টাকার অর্ডারে প্রভাব ফেলে: আগে ছাড় ০, এখন ১০০. রেকর্ডের কোনো input ১০০০ নয়; ৯৯৯ দুই নিয়মেই ছাড় পায় না, আর বাকিগুলো ১০০০-এর অনেক ওপরে। শিক্ষা: characterization test শুধু রেকর্ড করা input-এর আচরণ রক্ষা করে; সবুজ মানে “রেকর্ডের বাইরে কিছু বদলায়নি” নয়। পর্ব ০৮-এর মতো প্রতিটি সীমার দুই পাশ রেকর্ড করুন: ১০০০, ১০০১, ১৯৯৯, ২০০০, ৩০০০, ৩০১০, আর ঢাকার বাইরে সাধারণ ক্রেতা। ১০০০ যোগ করলে এই বদলে রেকর্ড "1000-0+60=1060" আর নতুন ফল "1000-100+60=960", তাই লাল।

  3. Test-এর ভুল খুঁজুন (find the bug): একজন সহকর্মী ঘড়ি inject করেছেন এভাবে, আর test সবুজ:
    def place_order(amount, district, phone, now=datetime.now()):
        ref = f"BG-{now:%y%m%d}-{next_number()}"
        ...
    
    def test_ref_uses_the_given_date(self):
        ref = place_order(800, "Sylhet", "01712345678",
                          now=datetime(2026, 11, 16, 21, 5))
        self.assertTrue(ref.startswith("BG-2611"))
    Production-এ কী ভুল হবে, test কেন ধরে না, আর test-এ আরেকটি দুর্বলতা কী?

    Production-এর ভুল: now=datetime.now()-এর default মান Python একবারই হিসাব করে, function তৈরির সময়, অর্থাৎ module import-এর মুহূর্তে। তাই সার্ভার যতদিন চালু থাকে, যে order-এ now দেওয়া হয় না তার প্রতিটি সেই প্রথম মুহূর্তের তারিখ পায়; তিন দিন পরের order-এও পুরোনো তারিখ। Test কেন ধরে না: test সবসময় নিজের now দেয়, তাই default পথটি কখনো চলে না। Test-এর দুর্বলতা: startswith("BG-2611") শুধু বছর আর মাস দেখে, দিন নয়; ভুল দিনের reference-ও পাস করবে। এটি পর্ব ২২-এর দুর্বল assertion. সমাধান: মান নয়, function inject করুন: clock=datetime.now আর ভেতরে now = clock(); test-এ clock=lambda: datetime(2026, 11, 16, 21, 5) আর পুরো reference-এর assertion. চাইলে default পথের জন্য একটি ছোট test রাখুন যা দুবার ডেকে দেখে ঘড়ি সত্যিই প্রতিবার ডাকা হয়।

  4. কোন seam, কোন কৌশল (ভেবে দেখুন): বাজারঘরের পুরোনো কোডে চারটি অবস্থা। প্রতিটিতে test-এর নিচে আনার প্রথম ধাপটি কী হবে? (ক) ৬০০ লাইনের process_order-এ Plus সদস্যের নতুন নিয়ম যোগ করতে হবে, function-টির কোনো test নেই। (খ) ReviewService-এর constructor নিজেই database-এ সংযোগ খোলে। (গ) Payment-এর retry কোড প্রতি দফায় time.sleep(2) ডাকে। (ঘ) একটি function সরাসরি os.environ["WALLET_KEY"] পড়ে।

    (ক) Sprout method: নতুন নিয়মটি একটি আলাদা, ছোট pure function-এ লিখুন (যেমন plus_delivery(district, plus)) আর তার test আগে লিখুন; পুরোনো function থেকে শুধু এক লাইনে ডাকুন। পুরো ৬০০ লাইন test-এর নিচে আনার আগেই নতুন কোড test-সহ থাকে। সময় পেলে চারপাশে characterization test. (খ) Parameterize constructor: সংযোগ বা repository একটি parameter হিসেবে নিন, default আগের মতো আসল সংযোগ; test একটি in-memory fake দেয়। এটি object seam. (গ) Function injection: sleep=time.sleep parameter; test-এ sleep=calls.append দিলে অপেক্ষা ছাড়াই দেখা যায় কতবার, কত সেকেন্ড ঘুমাতে চেয়েছিল। (ঘ) Config inject করা: চাবিটি parameter বা config object হিসেবে নিন, environment পড়া composition root-এ সরান। দ্রুত শুরুর জন্য pytest-এর monkeypatch-এর setenv দিয়ে একটি নকল মান দেওয়া যায়, কিন্তু চাবিটি অবশ্যই বানানো, আসল নয়।

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

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

ক্রমFeathers-এর পদ্ধতিতে test-হীন কোডে একটি বদল আনার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. কোডের কোথায় বদল আনতে হবে, তা চিহ্নিত করা
  2. কোথায় test বসালে বদলটি যাচাই করা যাবে, তা খোঁজা
  3. ছোট, নিরাপদ ধাপে নির্ভরতা ভেঙে seam তৈরি করা
  4. Characterization test লিখে বর্তমান আচরণ রেকর্ড করা
  5. বদল আনা আর refactor করা, প্রতিটি ধাপের পরে test চালিয়ে

Michael Feathers-এর সংজ্ঞায় “seam” কোনটি?

  • কোডের এমন জায়গা, যেখানে বেশিরভাগ bug থাকে
  • দুটি module-এর মাঝের যেকোনো সীমানা
  • যেখানে সেই জায়গার কোড না বদলেই প্রোগ্রামের আচরণ বদলানো যায়
  • Test ফাইল আর production ফাইলের মধ্যে যোগসূত্র

নিচের কোনটি pure function?

  • def ref(): return f"BG-{datetime.now():%y%m%d}"
  • def discount(a): return 0 if a <= 1000 else min(a // 10, 300)
  • def save(r): ORDERS.append(r); return len(ORDERS)
  • def show(t): print("total", t)

একটি test-হীন পুরোনো function-এর জন্য characterization test লেখার সময় একটি ফল স্পষ্ট ভুল মনে হলো (ছোট হাতের “dhaka” লিখলে ১২০ টাকা delivery). এখন কী করা উচিত?

  • বর্তমান মানটিই রেকর্ড করা, “সন্দেহজনক” চিহ্ন দিয়ে product owner-কে জিজ্ঞেস করা
  • Test-এ সঠিক মান (৬০) লেখা, যাতে bug-টি ধরা থাকে
  • এই input-টি রেকর্ড থেকে বাদ দেওয়া
  • একই commit-এ bug সারিয়ে refactor শুরু করা

pytest-এ mock.patch("datetime.datetime.now", return_value=...) চালাতেই TypeError: cannot set 'now' attribute of immutable type 'datetime.datetime' এল। সবচেয়ে ভালো ব্যাখ্যা আর সমাধান কোনটি?

  • return_value-এ datetime object দেওয়া যায় না, string দিতে হবে
  • pytest-এ unittest.mock চলে না, pytest-mock লাগবে
  • Python-এর version পুরোনো, নতুন version-এ চলবে
  • Built-in type-এর attribute বদলানো যায় না; ব্যবহারের module-এ datetime নামটি patch করা বা ঘড়ি inject করা

“Functional core, imperative shell” নকশায় কোন অংশে সবচেয়ে বেশি unit test থাকা উচিত, আর কেন?

  • Shell-এ, কারণ সেখানে network আর database আছে
  • Core-এ, কারণ সিদ্ধান্তগুলো সেখানে আর সেটি double ছাড়াই test করা যায়
  • দুই অংশে সমান, যাতে coverage সমান থাকে
  • Composition root-এ, কারণ সব object সেখানে তৈরি হয়

একটি পুরোনো function send_receipt(order) শত জায়গা থেকে ডাকা হয়, আর ভেতরে datetime.now() পড়ে। কোনো caller না বদলে ঘড়ি test-যোগ্য করার সবচেয়ে কম ঝুঁকির উপায় কোনটি?

  • একটি বাধ্যতামূলক now parameter যোগ করা
  • একটি global CURRENT_TIME variable রাখা, যা test বদলায়
  • clock=datetime.now default-সহ একটি parameter যোগ করা, ভেতরে clock()
  • now=datetime.now() default-সহ একটি parameter যোগ করা

শব্দকোষ

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

মনে রাখুন

  1. Test কঠিন হলে আগে নকশা দেখুন: লুকানো ঘড়ি, random, network, global আর print testability কমায়; patch-এর সংখ্যা একটি মাপকাঠি।
  2. Dependency injection: নির্ভরতা constructor বা parameter দিয়ে আসুক; default-এ function দিন (clock=datetime.now), মান নয়।
  3. Seam হলো যেখানে কোড না বদলেই আচরণ বদলানো যায়; object seam সবচেয়ে পরিচ্ছন্ন, import seam legacy-তে শুরুর উপায়।
  4. Pure core, পাতলা shell: সিদ্ধান্ত pure function-এ, double ছাড়াই অনেক test; বাইরের কাজ shell-এ, port আর adapter দিয়ে।
  5. Legacy code-এ আগে characterization test: বর্তমান আচরণ রেকর্ড, সন্দেহজনক মান চিহ্নিত, সীমার input রেকর্ডে; refactor আর bug fix আলাদা commit-এ।

পরের পর্বে: একই বাজারঘরের coupon test pytest, JUnit 5, Vitest আর Go-র testing-এ পাশাপাশি: xUnit পরিবারের ধারণা, parametrization আর mocking library-র তুলনা, আর JUnit XML. পর্ব ২৬ (বিভিন্ন ভাষায় unit test — JUnit, Jest/Vitest আর Go-র testing তুলনা).

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

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