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

ভালো unit test-এর গঠন — AAA, নামকরণ আর একটি আচরণ

Structuring Good Unit Tests: AAA, Naming and One Behaviour per Test

Taught in Bangla, this lesson structures unit tests with Arrange-Act-Assert and Given-When-Then, splits an eager test into one test per behavior, and names tests by behavior. In-page Python shows a test built with loops and production formulas passing on a seeded Bazarghar defect while a plain literal test catches it, and a real pytest 9.2.0 run repeats the comparison. It covers specific assertions, DAMP versus DRY, smells such as mystery guest and assertion roulette, and the FIRST properties.

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

  • যেকোনো unit test-কে Arrange, Act আর Assert-এ ভাগ করে পড়া ও লেখা, আর Given-When-Then-এর সাথে মেলানো
  • একটি eager test-কে আলাদা আচরণের কয়েকটি test-এ ভেঙে নেওয়া
  • আচরণ বোঝায় এমন test-এর নাম দেওয়া, আর একটি দলে একটি নামের ধরন মানা
  • নির্দিষ্ট assertion বেছে নেওয়া, যাতে ব্যর্থতার বার্তা পড়েই কারণ বোঝা যায়
  • Test smell চিনে সারানো, আর buggy কোডেও পাস করে এমন test ধরার কৌশল

১ · Test নিজেই একটি দলিল — গঠন কেন জরুরি

পর্ব ২১ (pytest-এর মূল — assert, fixture, parametrize আর marker)-এ আপনি দেখেছেন test কীভাবে চালাতে হয়: কোন ফাইল খোঁজা হয়, কীভাবে একটি অংশ বেছে চালানো যায়, ব্যর্থতার রিপোর্ট কেমন দেখায়। এই পর্বের প্রশ্ন আলাদা: একটি test-এর ভেতরটা কেমন হলে তাকে বিশ্বাস করা যায়? একটি unit test শুধু “চলল কি না” দেখার যন্ত্র নয়। এটি একটি ছোট লিখিত উদাহরণ: “এই অবস্থায়, এই কাজ করলে, এই ফল হওয়া উচিত।” ছয় মাস পরে নতুন একজন developer যখন বাজারঘরের delivery-র নিয়ম বদলাতে আসবেন, requirement-এর নথি হয়তো পুরোনো হয়ে গেছে, কিন্তু test-গুলো প্রতিদিন চলছে। তাই সেগুলোই হয়ে যায় নিয়মের সবচেয়ে হালনাগাদ বিবরণ।

বোর্ড পরীক্ষার খাতা দেখার কথা ভাবুন। একজন পরীক্ষক যদি শুধু শেষ পাতায় “৬২” লিখে দেন, প্রধান পরীক্ষক পুনর্নিরীক্ষার সময় কিছুই বুঝবেন না: কোন প্রশ্নে নম্বর কাটা গেল, কেন? কিন্তু প্রতিটি প্রশ্নের পাশে আলাদা নম্বর আর কোথায় ভুল তার ছোট চিহ্ন থাকলে যে কেউ মিলিয়ে দেখতে পারেন। ভালো unit test সেই আলাদা আলাদা নম্বরের মতো: প্রতিটি test একটি প্রশ্ন, তার নাম বলে প্রশ্নটি কী, আর ব্যর্থ হলে বার্তা বলে ঠিক কোথায় কাটা গেল।

পর্ব ২২ থেকে ২৭ পর্যন্ত আমরা বাজারঘরের একটি ছোট Python package নিয়ে কাজ করব। এই পর্বের code under test (code under test) হলো bazarghar/pricing.py, যেখানে পর্ব ০৭–০৯-এ ঠিক হওয়া নিয়মগুলোই আছে:

বাজারঘরের দামের নিয়ম (মডিউল ২-এ চূড়ান্ত)

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

Package-এর লেখক একটি ভুল করে ফেলেছেন, যা আমরা ইচ্ছা করেই রেখেছি (seeded defect): delivery-র ২০০০ টাকার সীমা তিনি ছাড়ের পরের দামে মেপেছেন। ফলে ঢাকায় ঠিক ২০০০ টাকার অর্ডারে ২০০ টাকা ছাড়ের পরে ১৮০০ থাকে, আর কোড ৬০ টাকা delivery বসায়: মোট ১৮৬০, যেখানে নিয়ম বলে ১৮০০. Script দিয়ে গুনে দেখা গেছে, ২০০০ থেকে ২২২১ টাকার প্রতিটি ঢাকার অর্ডারে মোট ভুল আসে; ২২২২ থেকে ছাড়ের পরেও ২০০০ থাকে বলে ভুলটি আর দেখা যায় না। এই পর্বের মূল নাটক এটাই: একই কোডের ওপর দুই ধরনের test চালাব। একটি দেখতে পরিশ্রমী, কিন্তু সবুজ থেকে যায়; আরেকটি সরল, আর ভুলটি ধরে।

কয়েকটি বিষয় অন্য কোর্সে পরিচিতি হিসেবে আছে; এখানে আমরা সেগুলো অনেক গভীরে যাব। AAA, FIRST আর কয়েকটি test smell-এর প্রথম পরিচয় পাবেন সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৬-এ, আর pytest-এর একদম শুরু Python প্রোগ্রামিং কোর্সের পর্ব ৪২-এ। Python-এর class আর self অচেনা লাগলে Python কোর্সের পর্ব ৩১ একবার দেখে নিন; unittest-এর প্রতিটি test একটি class-এর method.

২ · Arrange-Act-Assert আর Given-When-Then — তিন ভাগের গঠন

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

BDD-ধাঁচের দলগুলো একই তিন অংশকে ব্যবসার ভাষায় বলে Given-When-Then: Given ঢাকার একটি ২০০০ টাকার অর্ডার, When checkout-এর মোট হিসাব হয়, Then মোট ১৮০০ টাকা। Given = Arrange, When = Act, Then = Assert. পর্ব ১৫-এ acceptance criteria লেখার সময় আপনি এই ছাঁচ দেখেছেন; Gherkin আর pytest-bdd দিয়ে এটি পুরো রূপে আসবে পর্ব ৪৩ (BDD আর Gherkin — Given-When-Then আর pytest-bdd)-এ।

একটি test-এর তিন অংশ, তিন নামে

বাঁয়ে test-এর লাইন, ডানে একই অংশের তিনটি প্রচলিত নাম

Arrange, Act, Assert mapped to Given, When, Then and the four-phase test ১ · Arrange২ · Act৩ · Assert৪ · Teardown Given · setupWhen · exerciseThen · verifyদরকার হলে amount = 2000district = "Dhaka" total = checkout_total( amount, district) assertEqual(total, 1800)# 2000 - 200 + 0 ফাইল বা সংযোগ বন্ধ, অবস্থা আগের মতো Act একবার · Assert ফলের ওপর
ছবি ২২.১ — একই test-কে AAA, Given-When-Then আর four-phase test তিন নামে ডাকা যায়। Unit test-এ teardown প্রায়ই লাগে না, কারণ সব কিছু memory-তে তৈরি হয় আর test শেষে মুছে যায়।

নিয়মটি সহজ শোনায়, কিন্তু প্রতিটি অংশে কিছু সূক্ষ্ম সিদ্ধান্ত আছে:

  • Act একবারই। Act অংশে দুটি আলাদা কাজ ডাকা (প্রথমে checkout_total, তারপর cancel_order) মানে প্রায় সবসময় দুটি আচরণ, তাই দুটি test. ব্যতিক্রম: একটি অবস্থা-পরিবর্তনের ক্রমই যখন আচরণ, যেমন পর্ব ১০-এর order state machine-এর একটি পথ। তখনও শেষের কাজটিই Act; আগের ধাপগুলো Arrange-এর অংশ।
  • Arrange লম্বা হলে সংকেত। একটি দাম যাচাই করতে কুড়ি লাইনের প্রস্তুতি লাগলে হয় code under test-এর নকশা জটিল (অনেক লুকানো নির্ভরতা, যা পর্ব ২৫-এর বিষয়), নয়তো test এমন জিনিস তৈরি করছে যা আচরণের সাথে সম্পর্কহীন। এর সমাধান test data builder, যার ঝলক §৫-এ।
  • Assert ফলের ওপর, পথের ওপর নয়। “মোট ১৮০০” যাচাই করুন; “coupon_discount একবার ডাকা হয়েছে” নয়, যদি না ডাকাটাই চুক্তির অংশ। ভেতরের পথ যাচাই করা test-কে ভঙ্গুর করে; mock দিয়ে কখন সত্যিই পথ যাচাই করতে হয়, তা পর্ব ২৪-এর বিষয়।
  • অংশগুলো চোখে আলাদা। তিন অংশের মাঝে একটি ফাঁকা লাইন, বা নতুনদের জন্য # Arrange, # Act, # Assert মন্তব্য। অভিজ্ঞ দলে মন্তব্যগুলো প্রায়ই বাদ যায়, ফাঁকা লাইন থেকে যায়।

ছোট test-এ তিন অংশ একটি লাইনে মিশে যেতে পারে: self.assertEqual(coupon_discount(5000), 300). এখানে Arrange হলো ৫০০০ মানটি, Act হলো ডাকাটি, Assert চারপাশের বাক্য। এটি ভুল নয়। AAA কোনো যান্ত্রিক নিয়ম নয়; প্রশ্ন একটাই, পাঠক কি এক নজরে বলতে পারেন কী তৈরি হলো, কী করা হলো আর কী আশা করা হলো?

৩ · এক test, এক আচরণ — eager test ভাঙা

“এক test-এ একটিই assertion” কথাটি অনেকে শুনেছেন। আক্ষরিকভাবে মানলে অকারণ কষ্ট: একটি রসিদের মোট আর ছাড় একই আচরণের দুটি দিক হতে পারে। আসল নিয়ম হলো এক test-এ একটি আচরণ, অর্থাৎ test-এর ব্যর্থ হওয়ার কারণ একটিই হওয়া উচিত। এর উল্টোটিকে van Deursen ও সহকর্মীরা ২০০১ সালের “Refactoring Test Code” প্রবন্ধে eager test নাম দেন: যে test একসাথে অনেক কিছু যাচাই করতে “আগ্রহী”।

Eager test-এর দুটি ক্ষতি। প্রথম, প্রথম ব্যর্থ assertion-এ test থেমে যায়, পরের যাচাইগুলো আর চলেই না; ফলে একটি ভুল আরেকটি ভুলকে আড়াল করে। দ্বিতীয়, নাম আর বার্তা থেকে বোঝা যায় না কোন নিয়ম ভাঙল, কারণ নামটি তিন আচরণের কোনোটিরই নয়। নিচের stepper-এ একটি eager test-কে তিনটি test-এ ভাঙা হলো, আর buggy কোডে আগে-পরের ফল দেখানো হলো।

test_pricing.pyশুরু: একটি test
def test_checkout(self):
    self.assertEqual(
        coupon_discount(5000), 300)
    self.assertEqual(
        checkout_total(2000, "Dhaka"),
        1800)
    self.assertEqual(
        delivery_charge(800, "Sylhet",
                        plus=True), 60)
test_pricing.pyকয়টি আচরণ?
def test_checkout(self):
    # 1 coupon cap
    self.assertEqual(
        coupon_discount(5000), 300)
    # 2 Dhaka free-delivery threshold
    self.assertEqual(
        checkout_total(2000, "Dhaka"),
        1800)
    # 3 Plus member outside Dhaka
    self.assertEqual(
        delivery_charge(800, "Sylhet",
                        plus=True), 60)
Buggy কোডে চালানো১টি test, FAIL
test_checkout ... FAIL
AssertionError: 1860 != 1800

# assertion 1: passed
# assertion 2: failed here
# assertion 3: never ran
test_pricing.pyপ্রথম দুটি আলাদা
def test_coupon_is_capped_at_300_taka(self):
    self.assertEqual(
        coupon_discount(5000), 300)

def test_plus_member_outside_dhaka_pays_60(self):
    self.assertEqual(
        delivery_charge(800, "Sylhet",
                        plus=True), 60)
test_pricing.pyতৃতীয়টি AAA-তে
def test_dhaka_order_of_2000_gets_free_delivery(self):
    amount, district = 2000, "Dhaka"

    total = checkout_total(amount, district)

    # 2000 - 200 coupon + 0 delivery
    self.assertEqual(total, 1800)
Buggy কোডে আবার৩টি test, ১টি FAIL
test_coupon_is_capped_at_300_taka ... ok
test_dhaka_order_of_2000_gets_free_delivery
  ... FAIL
test_plus_member_outside_dhaka_pays_60 ... ok

AssertionError: 1860 != 1800
  1. শুরু। একটি test, নাম test_checkout, ভেতরে তিনটি assertion. দেখতে গোছানো, প্রত্যাশিত মানগুলোও আক্ষরিক সংখ্যা। সমস্যা গঠনে।
  2. আচরণ গোনা। প্রতিটি assertion-এর পাশে লিখুন সে কোন নিয়ম যাচাই করে। তিনটি আলাদা নিয়ম: coupon-এর সর্বোচ্চ সীমা, ঢাকায় ফ্রি delivery-র সীমা, আর ঢাকার বাইরে Plus সদস্যের delivery. তিন নিয়ম মানে তিনটি ব্যর্থ হওয়ার কারণ।
  3. Buggy কোডে চালানো। প্রথম assertion পাস, দ্বিতীয়টিতে 1860 != 1800, আর test সেখানেই থামে। তৃতীয় assertion কখনো চলেনি; Plus-এর নিয়মেও ভুল থাকলে আজ তা জানা যেত না। নাম test_checkout বলে না তিনটির কোনটি ভাঙল।
  4. প্রথম দুটি আলাদা করা। Coupon আর Plus-এর assertion নিজের নিজের test-এ গেল, প্রতিটির নাম তার আচরণ। কোনো assertion বদলানো হয়নি, শুধু সরানো; refactoring-এর মতোই আচরণ এক রেখে গঠন বদলানো।
  5. তৃতীয়টি AAA-তে। ঢাকার ২০০০ টাকার test-এ তিন অংশ ফাঁকা লাইনে আলাদা, আর প্রত্যাশিত মানের পাশে ছোট মন্তব্য কেন ১৮০০: ২০০০ − ২০০ ছাড় + ০ delivery. মন্তব্যটি হিসাব নয়, পাঠকের জন্য ব্যাখ্যা।
  6. আবার চালানো। এখন তিনটি test: দুটি ok, একটি FAIL. লাল লাইনের নাম পড়েই বোঝা যায় কোন নিয়ম ভেঙেছে, আর Plus-এর নিয়ম যে ঠিক আছে, সেই তথ্যও পাওয়া গেল। Test-এর সংখ্যা বেড়েছে, কিন্তু প্রতিটি লাল এখন একটি নির্দিষ্ট প্রশ্নের উত্তর।

এক আচরণের সীমা কোথায়? একটি কাজের কয়েকটি ফল যদি একসাথে একটিই প্রতিশ্রুতি হয়, যেমন checkout-এর রসিদে ছাড়, delivery আর মোট, তাহলে সেগুলো এক test-এ থাকতে পারে, বিশেষত যদি পুরো রসিদ একটি তুলনায় যাচাই হয় (§৭-এ দেখবেন)। একটি সহজ পরীক্ষা: test-এর জন্য একটি সৎ নাম লিখতে গিয়ে যদি “আর” শব্দ লাগে (“coupon-এর সীমা আর Plus-এর delivery”), তাহলে সম্ভবত দুটি test.

একই কাঠামোয় অনেক মানের জন্য (১৯৯৯, ২০০০, ২১০০) আলাদা আলাদা method লেখার দরকার নেই। সেটি parameterized test: একটি test-এর কাঠামো, মানের একটি টেবিল, আর প্রতিটি সারি আলাদা case হিসেবে রিপোর্ট হয়। unittest-এ এটি subTest দিয়ে, pytest-এ parametrize দিয়ে, যা পর্ব ২১-এ এসেছে। লক্ষ করুন, এটি eager test নয়: প্রতিটি সারি একই আচরণ যাচাই করে, আর একটি সারি ব্যর্থ হলেও বাকিগুলো চলে।

৪ · নাম দিয়ে আচরণ বলা

CI-র লাল পাতায় আপনি প্রথমে শুধু নামের তালিকা দেখেন। সেখানে test_2 বা test_delivery_charge পড়ে কিছু বোঝা যায় না; কোড খুলে পড়তে হয়। ভালো নাম পড়ে তিনটি প্রশ্নের উত্তর পাওয়া যায়: কোন অবস্থায়, কী করলে, কী হওয়া উচিত। সবচেয়ে জরুরি নিয়ম: নামে আচরণ লিখুন, method-এর নাম নয়। test_checkout_total বলে কোন function-কে test করা হচ্ছে; test_dhaka_order_of_2000_gets_free_delivery বলে কোন নিয়ম। Function-এর নাম বদলালে প্রথমটি মিথ্যা হয়ে যায়, দ্বিতীয়টি নয়।

প্রচলিত কয়েকটি ধরন, প্রতিটির নিজের সুবিধা আছে:

ধরনবাজারঘরের উদাহরণকোথায় বেশি
আচরণের বাক্য (snake_case)test_plus_member_outside_dhaka_pays_60_takaPython, pytest আর unittest
অবস্থা_কাজ_ফলtest_order_2000_dhaka__total__is_1800.NET আর Java দলে, Roy Osherove-এর বইয়ে প্রচলিত বলে জানা যায়
“should” বাক্যit("should give free delivery at 2000 in Dhaka")Jest, Vitest, Mocha (পর্ব ২৬)
Given-When-Thentest_given_plus_member_when_outside_dhaka_then_60BDD-ধাঁচের দল

কোন ধরন বেছে নেবেন, তার চেয়ে জরুরি পুরো project-এ একটি ধরন মানা (naming convention). “should” শব্দ নিয়ে একটি বিতর্কও জেনে রাখুন: কেউ বলেন “should” নামকে প্রত্যাশা হিসেবে পড়ায় (“উচিত”), যা ব্যর্থ হলে “হলো না” বোঝায়; আবার কেউ বলেন এটি কোনো তথ্য যোগ না করে নাম লম্বা করে, তাই সরাসরি বর্তমান কালে লেখা ভালো (“pays 60 taka”). দুটিই গ্রহণযোগ্য, একসাথে মেশানো নয়।

একই test, পাঁচটি নাম
নাম
বলে
ভাঙলে বোঝা যায়?
  1. test2. কোড খোলা ছাড়া কিছুই জানা যায় না। এমন নাম সাধারণত আসে যখন test পরে, তাড়াহুড়ায় লেখা হয়। দলে কেউ test-টি মুছলেও কেউ বুঝবেন না কী হারাল।
  2. test_delivery. এলাকাটি জানা গেল, কিন্তু delivery-র নিয়মে অন্তত চারটি আচরণ আছে: ঢাকায় ৬০, ঢাকায় ফ্রি, বাইরে ১২০, বাইরে Plus-এ ৬০. কোনটি ভাঙল?
  3. test_delivery_charge_sylhet. এবার function-এর নাম আর একটি input. কিন্তু Sylhet-এ কী হওয়া উচিত তা বলা নেই, আর function-এর নাম বদলালে নামটি পুরোনো হয়ে যাবে।
  4. test_delivery_sylhet_plus_60. অবস্থা (Sylhet, Plus) আর ফল (৬০) এসেছে। কাজ চলে, তবে “sylhet” নিয়মের অংশ নয়, শুধু উদাহরণ; নিয়মটি “ঢাকার বাইরে”। নতুন পাঠক ভাবতে পারেন Sylhet-এর জন্য আলাদা নিয়ম আছে।
  5. আচরণের নাম। test_plus_member_outside_dhaka_pays_60_taka নিয়মটি হুবহু বলে। লাল হলে product owner-ও পড়ে বুঝবেন কী ভেঙেছে। Sylhet রইল test-এর ভেতরে, Arrange অংশে, উদাহরণ হিসেবে।

লম্বা নাম নিয়ে চিন্তার কিছু নেই; test-এর নাম কেউ হাতে ডাকে না, শুধু পড়ে। তবে নাম যদি এত লম্বা হয় যে তিনটি “and” লাগে, তাহলে সমস্যা নামের নয়, test-টি একাধিক আচরণ যাচাই করছে (§৩). Test class বা ফাইলের নামও একটি স্তর যোগ করে: class CheckoutTotalInDhaka-এর ভেতরে method-এর নাম ছোট রাখা যায়, যেমন test_order_of_2000_gets_free_delivery.

ভালো নামের একটি পুরস্কার আছে: pytest -v বা unittest-এর verbose রিপোর্ট পড়লে নামগুলো মিলে একটি নিয়মের তালিকা হয়ে যায়, অনেকটা হালনাগাদ থাকা একটি স্পেসিফিকেশনের মতো। ২০০৩ সালের দিকে Chris Stevenson “agiledox” নামে একটি ছোট tool বানান, যা JUnit test-এর method নাম থেকে বাক্য তৈরি করত; Dan North তাঁর “Introducing BDD” (২০০৬) লেখায় বলেছেন এই ধারণা থেকেই BDD-র একটি সূত্র এসেছে (আমাদের জানামতে). §৬-এর সত্যিকারের pytest run-এ এমন একটি তালিকা দেখবেন।

৫ · পড়ার মতো test — DAMP বনাম DRY, magic number আর builder

Production কোডে পুনরাবৃত্তি কমানো একটি গুণ: DRY (Don't Repeat Yourself) নীতি বলে প্রতিটি জ্ঞানের একটি জায়গা থাকুক। Test-এ এই নীতি অন্ধভাবে চালালে উল্টো ফল হয়। ধরুন কেউ বারোটি test-কে এক লাইনে নামিয়ে এনেছেন:

def test_case_7(self):
    self.check(2000, "Dhaka", False, 1800)

চমৎকার সংক্ষিপ্ত, কিন্তু পড়ে কিছুই বোঝা যায় না: False কী? ১৮০০ কী, delivery না মোট? check ভেতরে কী করে, কোন assertion? জানতে অন্য ফাইলে যেতে হয়। এই কারণে অনেক দল test-এর জন্য DAMP কথাটি ব্যবহার করে: Descriptive And Meaningful Phrases. অর্থাৎ test-এ একটু পুনরাবৃত্তি থাকুক, কিন্তু প্রতিটি test একা পড়ে বোঝা যাক। শব্দটি সাধারণত Jay Fields-এর নামে উল্লেখ করা হয়, আর Google-এর testing blog-এর একটি পরিচিত লেখায় (২০১৯) এটি জনপ্রিয় হয় বলে জানা যায়।

DAMP মানে সব কিছু বারবার লেখা নয়। একটি ব্যবহারিক ভাগ:

Test-এর ভেতরে, চোখের সামনে

যে মানগুলো এই আচরণের জন্য গুরুত্বপূর্ণ (২০০০, "Dhaka"), যে কাজ ডাকা হচ্ছে, আর প্রত্যাশিত ফল (১৮০০)। পাঠক এগুলো খুঁজতে অন্য জায়গায় যাবেন না।

DAMP

Helper-এ সরানো যায়

একঘেয়ে প্রস্তুতি যা আচরণের সাথে সম্পর্কহীন: একটি বৈধ ক্রেতা, একটি বৈধ ঠিকানা, database সংযোগ। এগুলো builder বা test fixture-এ।

DRY

Magic number: test-এ ব্যাখ্যাহীন সংখ্যা (magic number) পাঠককে থামিয়ে দেয়: assertEqual(checkout_total(2100, "Dhaka"), 1890)-এ ১৮৯০ কোথা থেকে? Production কোডে উত্তর হতো নাম দেওয়া constant. Test-এ সবসময় তা নয়, কারণ FREE_DELIVERY_LIMIT constant production কোড থেকে import করলে test আর কোড একই ভুল সংখ্যা ভাগ করে নিতে পারে; constant ভুল হলে test-ও চুপ থাকবে। Test-এ ভালো উপায় হলো আক্ষরিক মান রাখা, আর পাশে ছোট মন্তব্যে কোথা থেকে এল: # 2100 - 210 coupon + 0 delivery. প্রত্যাশিত মান আসে requirement থেকে, কোড থেকে নয়; পর্ব ০২-এর ভাষায় এটিই test oracle.

Test data builder-এর ঝলক: রিভিউ বা অর্ডারের মতো বড় object-এ প্রতিটি test-এ দশটি field লিখলে আসল মানগুলো ভিড়ে হারিয়ে যায়। Test data builder যুক্তিসংগত default দিয়ে একটি বৈধ object বানায়, আর test শুধু প্রাসঙ্গিক field বদলায়: an_order().in_district("Dhaka").with_amount(2000).build(). পাঠক দেখেন শুধু যা এই আচরণের জন্য জরুরি। Builder, object mother, factory fixture আর fixture-এর scope পুরোটা আসবে পর্ব ২৩ (Fixture আর test data — scope, factory আর builder)-এ।

Helper-এর ভেতরে assertion লুকানো সবচেয়ে বিপজ্জনক DRY. self.check(...) ভেতরে যদি একটি শর্তে assertion এড়িয়ে যায়, বারোটি test একসাথে কিছু না যাচাই করেও সবুজ থাকবে, আর কেউ টের পাবেন না। Helper বানাতে হলে নাম দিয়ে বলুন সে কী যাচাই করে (assert_total_is(...)), আর ভেতরে কোনো if রাখবেন না।

৬ · Test-এ logic নয় — buggy কোডেও পাস করা test

এখন এই পর্বের কেন্দ্রীয় পরীক্ষা। নিচের প্রথম block-এ বাজারঘরের দামের কোড (seeded defect সহ) আর একজন পরিশ্রমী developer-এর লেখা একটি test. Test-টি তিনটি অর্ডারের মান loop-এ চালায়, প্রত্যাশিত মান নিজেই হিসাব করে, আর আরও দুটি যাচাই যোগ করে। চালিয়ে দেখুন।

import sys, unittest

def coupon_discount(amount):          # >1000: 10%, floor, max 300
    return 0 if amount <= 1000 else min(amount // 10, 300)

def delivery_charge(amount, district, plus=False):
    if district == "Dhaka":
        return 0 if amount >= 2000 else 60
    return 60 if plus else 120

def checkout_total(amount, district, plus=False):
    net = amount - coupon_discount(amount)
    return net + delivery_charge(net, district, plus)  # seeded defect

class TestCheckout(unittest.TestCase):           # the smelly version
    def test_checkout(self):
        for amount in [500, 1500, 2500]:
            total = checkout_total(amount, "Dhaka")
            net = amount - coupon_discount(amount)
            if net >= 2000:
                self.assertEqual(total, net)
            else:
                self.assertEqual(total, net + delivery_charge(net, "Dhaka"))
        self.assertTrue(coupon_discount(5000) <= 300)
        self.assertTrue(delivery_charge(800, "Sylhet") > 0)

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

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

test_checkout (__main__.TestCheckout.test_checkout) ... ok

----------------------------------------------------------------------
Ran 1 test in …

OK

সবুজ। অথচ কোডে ভুল আছে। কেন ধরা পড়ল না? এই test-এ একসাথে পাঁচটি smell কাজ করছে, আর প্রতিটি ভুলটিকে আড়াল করতে সাহায্য করেছে:

  1. প্রত্যাশা কোডের সূত্র থেকে। net + delivery_charge(net, …) লাইনটি production কোডের ভুল সূত্রটিই আবার লিখেছে: ছাড়ের পরের দামে delivery. Test আর কোড একই ভুল দুবার বলছে, তাই মিলে যাচ্ছে। এটিই সবচেয়ে মারাত্মক।
  2. Conditional test logic. if net >= 2000 দিয়ে test নিজে সিদ্ধান্ত নিচ্ছে কোন প্রত্যাশা খাটবে। Test-এর if-ও ভুল হতে পারে, আর test-এর test কেউ লেখে না।
  3. ভুল জায়গার মান। ৫০০, ১৫০০ আর ২৫০০ নিয়মের সীমা থেকে দূরে। ভুলটি থাকে শুধু ২০০০ থেকে ২২২১-এর মধ্যে; পর্ব ০৮-এর boundary value analysis এখানে ১৯৯৯ আর ২০০০ বেছে নিত।
  4. দুর্বল assertion. <= 300 আর > 0 প্রায় কিছুই যাচাই করে না: coupon ০ দিলেও প্রথমটি পাস, ঢাকার বাইরে ১ টাকা নিলেও দ্বিতীয়টি।
  5. Eager আর নামহীন। তিন নিয়ম এক test-এ, নাম test_checkout.

এবার একই কোডের জন্য পুনর্লিখিত test. প্রতিটি test একটি আচরণ, নাম সেই আচরণ, প্রত্যাশিত মান requirement থেকে হাতে হিসাব করা আক্ষরিক সংখ্যা, আর কোনো loop বা if নেই। এই block আগের block-এর function ব্যবহার করে (data-shared).

class CheckoutRules(unittest.TestCase):          # refactored: one behaviour each
    def test_coupon_is_capped_at_300_taka(self):
        self.assertEqual(coupon_discount(5000), 300)

    def test_plus_member_outside_dhaka_pays_60_taka(self):
        self.assertEqual(delivery_charge(800, "Sylhet", plus=True), 60)

    def test_dhaka_order_of_1999_pays_60_taka_delivery(self):
        self.assertEqual(checkout_total(1999, "Dhaka"), 1860)  # 1999-199+60

    def test_dhaka_order_of_2000_gets_free_delivery(self):
        # Arrange: exactly on the threshold, coupon makes it 1800
        amount, district = 2000, "Dhaka"
        # Act
        total = checkout_total(amount, district)
        # Assert: 2000 - 200 coupon + 0 delivery (threshold before coupon)
        self.assertEqual(total, 1800)

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

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

test_coupon_is_capped_at_300_taka (__main__.CheckoutRules.test_coupon_is_capped_at_300_taka) ... ok
test_dhaka_order_of_1999_pays_60_taka_delivery (__main__.CheckoutRules.test_dhaka_order_of_1999_pays_60_taka_delivery) ... ok
test_dhaka_order_of_2000_gets_free_delivery (__main__.CheckoutRules.test_dhaka_order_of_2000_gets_free_delivery) ... FAIL
test_plus_member_outside_dhaka_pays_60_taka (__main__.CheckoutRules.test_plus_member_outside_dhaka_pays_60_taka) ... ok

======================================================================
FAIL: test_dhaka_order_of_2000_gets_free_delivery (__main__.CheckoutRules.test_dhaka_order_of_2000_gets_free_delivery)
----------------------------------------------------------------------
Traceback (most recent call last):
  …
    self.assertEqual(total, 1800)
AssertionError: 1860 != 1800

----------------------------------------------------------------------
Ran 4 tests in …

FAILED (failures=1)

চারটি test, তিনটি ok, একটি FAIL, আর লাল লাইনের নাম নিজেই bug report-এর শিরোনামের মতো: ঢাকায় ২০০০ টাকার অর্ডারে ফ্রি delivery হচ্ছে না। বার্তায় 1860 != 1800: পার্থক্য ঠিক ৬০, অর্থাৎ delivery-র টাকা। ১৯৯৯-এর test পাস করেছে, কারণ সেখানে সঠিক আর ভুল কোড একই উত্তর দেয় (১৮৬০); সীমার ঠিক নিচের মানটি নিশ্চিত করে যে ভুলটি শুধু সীমার এক পাশে। আরেকটি জিনিস খেয়াল করুন: unittest test-গুলো নামের বর্ণানুক্রমে চালায়, তাই রিপোর্টের ক্রম কোডের ক্রম নয়। ভালো test ক্রমের ওপর নির্ভর করে না (§৮).

দুটি test file-এর পার্থক্য এক বাক্যে: প্রথমটি কোড যা করে তা আবার হিসাব করেছে, দ্বিতীয়টি কোড যা করা উচিত তা লিখেছে। প্রথম ধরনের test-কে কখনো বলা হয় “tautological test”, অর্থাৎ যে test সংজ্ঞা অনুযায়ীই সবসময় পাস করে। পর্ব ১৬-এ হাতে লেখা test case-এর জন্য একই নিয়ম দেখেছেন: expected result চালানোর আগে requirement থেকে লেখা হয়।

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

একই দুই ধরনের test একটি আসল project-এ: uv দিয়ে বানানো ~/bazarghar-qa, ভেতরে bazarghar/pricing.py (একই seeded defect), tests/test_smelly.py আর tests/test_checkout.py. pytest-এ test হলো সাধারণ function আর সাধারণ assert; unittest-এর class লাগে না। শেষ test-টি ইচ্ছা করে একটি দুর্বল assertion দিয়ে লেখা, তুলনার জন্য। pytest MIT licence-এর। সত্যিকারের run, Python 3.12, pytest 9.2.0; শুরুর platform আর path-এর লাইন বাদ দেওয়া হয়েছে:

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

tests/test_checkout.py::test_coupon_is_capped_at_300_taka PASSED         [ 16%]
tests/test_checkout.py::test_plus_member_outside_dhaka_pays_60_taka_delivery PASSED [ 33%]
tests/test_checkout.py::test_dhaka_order_of_1999_pays_60_taka_delivery PASSED [ 50%]
tests/test_checkout.py::test_dhaka_order_of_2000_gets_free_delivery_before_coupon FAILED [ 66%]
tests/test_checkout.py::test_vague_assertion_hides_the_numbers FAILED    [ 83%]
tests/test_smelly.py::test_checkout PASSED                               [100%]

================================== FAILURES ===================================
__________ test_dhaka_order_of_2000_gets_free_delivery_before_coupon __________

    def test_dhaka_order_of_2000_gets_free_delivery_before_coupon():
        # Arrange
        amount, district = 2000, "Dhaka"
        # Act
        total = checkout_total(amount, district)
        # Assert: 2000 - 200 coupon + 0 delivery
>       assert total == 1800
E       assert 1860 == 1800

tests\test_checkout.py:22: AssertionError
___________________ test_vague_assertion_hides_the_numbers ____________________

    def test_vague_assertion_hides_the_numbers():
        ok = checkout_total(2000, "Dhaka") == 1800
>       assert ok
E       assert False

tests\test_checkout.py:27: AssertionError
=========================== short test summary info ===========================
FAILED tests/test_checkout.py::test_dhaka_order_of_2000_gets_free_delivery_before_coupon
FAILED tests/test_checkout.py::test_vague_assertion_hides_the_numbers - asser...
========================= 2 failed, 4 passed in 0.04s =========================

তিনটি জিনিস পড়ুন। প্রথম, -v-এর তালিকা: test_smelly.py::test_checkout PASSED, ঠিক in-page run-এর মতো; ফাইলের নাম আর একটি function-এর নাম ছাড়া এই লাইন কিছুই বলে না। বাকি নামগুলো একসাথে পড়লে বাজারঘরের দামের নিয়মের তালিকা। দ্বিতীয়, pytest-এর assertion rewriting: pytest import-এর সময় assert বাক্যটি নতুন করে লেখে, তাই ব্যর্থ হলে দুই পাশের আসল মান দেখায়: assert 1860 == 1800. তৃতীয়, শেষ test-এ একই ভুল, কিন্তু বার্তা শুধু assert False. তুলনাটি আগেই একটি bool-এ পরিণত হয়েছিল, তাই pytest-এর আর দেখানোর মতো কিছু ছিল না। Assertion কেমন করে লেখেন, ব্যর্থতার বার্তার মান তার ওপর নির্ভর করে, যা পরের অংশের বিষয়।

৭ · Assertion-এর মান — নির্দিষ্ট, বার্তাসহ, সঠিক জিনিসের ওপর

একটি test দুইবার কাজে লাগে: যখন সে ভুল ধরে, আর যখন ব্যর্থতার বার্তা দিয়ে বলে দেয় ভুলটি কী। দ্বিতীয় কাজের মান পুরোটাই assertion-এর ওপর নির্ভর করে। নিচের block-এ একটি buggy রসিদের ওপর চারটি ভিন্ন ধরনের assertion; চারটিই ব্যর্থ হবে, কিন্তু বার্তাগুলো তুলনা করুন।

import sys, unittest

# what the buggy build returned for a 2000-taka order in Dhaka
receipt = {"amount": 2000, "discount": 200, "delivery": 60, "total": 1860}

class AssertionStyles(unittest.TestCase):
    def test_1_vague(self):
        self.assertTrue(receipt["total"] == 1800)

    def test_2_roulette(self):
        self.assertEqual(receipt["discount"], 200)
        self.assertEqual(receipt["delivery"], 0)
        self.assertEqual(receipt["total"], 1800)

    def test_3_specific_with_message(self):
        self.assertEqual(receipt["delivery"], 0,
                         "2000 in Dhaka: free (threshold before coupon)")

    def test_4_whole_breakdown(self):
        got = {k: receipt[k] for k in ("discount", "delivery", "total")}
        self.assertEqual(got, {"discount": 200, "delivery": 0, "total": 1800})

unittest.TextTestRunner(stream=sys.stdout, verbosity=1).run(
    unittest.defaultTestLoader.loadTestsFromTestCase(AssertionStyles))

আসল আউটপুট (ব্রাউজারের Python, traceback-এর লাইন “…” দিয়ে ছোট করা):

FFFF
======================================================================
FAIL: test_1_vague (__main__.AssertionStyles.test_1_vague)
…
AssertionError: False is not true

======================================================================
FAIL: test_2_roulette (__main__.AssertionStyles.test_2_roulette)
…
    self.assertEqual(receipt["delivery"], 0)
AssertionError: 60 != 0

======================================================================
FAIL: test_3_specific_with_message (__main__.AssertionStyles.test_3_specific_with_message)
…
AssertionError: 60 != 0 : 2000 in Dhaka: free (threshold before coupon)

======================================================================
FAIL: test_4_whole_breakdown (__main__.AssertionStyles.test_4_whole_breakdown)
…
AssertionError: {'discount': 200, 'delivery': 60, 'total': 1860} != {'discount': 200, 'delivery': 0, 'total': 1800}
- {'delivery': 60, 'discount': 200, 'total': 1860}
?              -                               ^

+ {'delivery': 0, 'discount': 200, 'total': 1800}
?                                             ^

----------------------------------------------------------------------
Ran 4 tests in …

FAILED (failures=4)

চারটি বার্তা চার মানের। test_1: False is not true; জানা গেল না মোট কত এসেছে। assertTrue(a == b) তুলনাটি আগেই bool-এ বদলে ফেলে, ঠিক pytest-এর assert ok-এর মতো। test_2: 60 != 0, কিন্তু কোন field? Traceback-এর লাইন দেখে বুঝতে হয় delivery; আর মোটের assertion কখনো চলেনি। test_3: একই তুলনা, সাথে বার্তা যা নিয়মটি বলে দেয়; CI-র log পড়েই product owner বুঝবেন। test_4: পুরো ভাঙন একটি তুলনায়, আর unittest-এর diff একসাথে দুটি ভুল দেখায়, delivery (৬০ বনাম ০) আর মোট (১৮৬০ বনাম ১৮০০). একই আচরণের কয়েকটি দিক এভাবে এক assertion-এ রাখা যায়, roulette ছাড়াই।

ভালো assertion বাছাইয়ের কয়েকটি নিয়ম:

  • সবচেয়ে নির্দিষ্ট assertion: assertEqual, assertIn, assertIsNone, assertRaises; শুধু শেষ উপায় হিসেবে assertTrue. নির্দিষ্ট assertion ব্যর্থ হলে দুই পাশের মান দেখায়।
  • যথেষ্ট কড়া: assertTrue(total > 0) প্রায় কিছুই ধরে না। নিয়ম যদি নির্দিষ্ট সংখ্যা বলে, নির্দিষ্ট সংখ্যা যাচাই করুন। ভগ্নাংশের দামে assertAlmostEqual বা pytest-এর approx, কিন্তু টাকার হিসাবে পূর্ণ সংখ্যা বা Decimal-এ সঠিক মান।
  • ঠিক জিনিসের ওপর: রিভিউ জমা দেওয়ার test-এ “বার্তা দেখাল” যথেষ্ট নয়, অবস্থাও যাচাই করুন (রিভিউ সংখ্যা)। Exception-এর test-এ শুধু ধরন নয়, দরকারে বার্তার অংশ: assertRaisesRegex(ValueError, "stars").
  • অতিরিক্ত কড়া নয়: পুরো রসিদের লেখা অক্ষরে অক্ষরে মেলালে নকশা বদলালেই test ভাঙে, অথচ আচরণ ঠিক; এটি fragile test (§৮).
  • যুক্তির ক্রম: unittest-এর assertEqual(first, second) ক্রম নির্দিষ্ট করে না, তবে Python দলে প্রচলিত (actual, expected); JUnit-এর assertEquals(expected, actual) উল্টো। একটি project-এ একটি ক্রম মানুন, নইলে বার্তা পড়ে বিভ্রান্তি।

এখন CI-তে একটি assertion roulette ব্যর্থতা পেলে কীভাবে কারণ খুঁজবেন, ধাপে ধাপে দেখি। এখানে test-এর নাম test_receipt, আর বাজারঘরের checkout_receipt() একটি dict দেয়।

1def test_receipt(self):2    r = checkout_receipt(2000, "Dhaka")3    self.assertEqual(r["discount"], 200)4    self.assertEqual(r["delivery"], 0)5    self.assertEqual(r["total"], 1800)
যা জানা গেল
discount
delivery
total
  1. CI লাল। শুধু দেখা যাচ্ছে test_receipt ব্যর্থ, বার্তা 60 != 0. নাম কোনো আচরণ বলে না, আর বার্তায় কোনো field-এর নাম নেই। তিনটি assertion-এর যেকোনোটি হতে পারে।
  2. Traceback-এর লাইন। Traceback বলে ব্যর্থতা লাইন ৪-এ, অর্থাৎ delivery. unittest আর pytest লাইন দেখায় বলে আধুনিক roulette আগের দিনের মতো অন্ধ নয়, কিন্তু খুঁজতে হলো কোড খুলে।
  3. কোনটি actual? Python-এর প্রচলিত ক্রমে বাঁয়ে actual: কোড delivery ৬০ দিয়েছে, নিয়ম বলে ০. লাইন ৩ আগে পাস করেছে, তাই discount ২০০ ঠিক।
  4. যা চলেনি। লাইন ৫ কখনো চলেনি। মোটও কি ভুল, নাকি শুধু delivery-র field? এই test থেকে জানার উপায় নেই। Assertion roulette-এর আসল ক্ষতি এখানে: একটি ব্যর্থতা বাকি তথ্য লুকিয়ে রাখে।
  5. সারানো। তিনটি field একটি dict তুলনায় আনা হলো (বা প্রতিটিতে বার্তা)। এখন এক run-এই দেখা যায় delivery ৬০ বনাম ০ আর মোট ১৮৬০ বনাম ১৮০০; অর্থাৎ মোটের ভুল delivery থেকেই এসেছে।
  6. মূল কারণ। ২০০০ টাকায় delivery ফ্রি হওয়ার কথা, কিন্তু কোড ৬০ নিয়েছে। ২০০ ছাড়ের পরে দাম ১৮০০, যা ২০০০-এর কম। সন্দেহ: সীমা ছাড়ের পরের দামে মাপা হচ্ছে। Bug report-এর শিরোনাম তৈরি, আর test-টির নতুন নাম test_dhaka_order_of_2000_gets_free_delivery.

৮ · Test smell-এর তালিকা আর FIRST

Production কোডের code smell-এর মতো test কোডেরও নিজস্ব test smell আছে: এমন লক্ষণ যা দেখে সন্দেহ হয় test পড়তে, বিশ্বাস করতে বা বদলাতে কঠিন হবে। শব্দটির প্রথম তালিকা Arie van Deursen ও সহকর্মীদের ২০০১ সালের প্রবন্ধে, আর সবচেয়ে বিস্তারিত ক্যাটালগ Gerard Meszaros-এর xUnit Test Patterns (২০০৭) বইয়ে, এমনটাই সাধারণত বলা হয়। “Sleepy test”-এর মতো কিছু নাম পরে smell খোঁজার tool-এর গবেষণা থেকে এসেছে। Smell মানে নিশ্চিত ভুল নয়, একটি সংকেত; প্রতিটি ক্ষেত্রে বিচার করতে হয়।

Smellলক্ষণ (বাজারঘরে)ক্ষতিসারানো
Eager testএকটি test-এ coupon, delivery আর মোটপ্রথম ব্যর্থতায় বাকি যাচাই থামে; নাম কিছু বলে নাপ্রতি আচরণে একটি test (§৩)
Mystery guestload("fixtures/order_17.json"); অর্ডারের মান test-এ দেখা যায় নাকেন ১৮০০ প্রত্যাশিত, বোঝা যায় না; কেউ ফাইল বদলালে অচেনা test ভাঙেপ্রাসঙ্গিক মান test-এর ভেতরে বা builder-এ
Assertion rouletteবার্তা ছাড়া একাধিক assertionকোনটি ভাঙল খুঁজতে হয়; পরেরগুলো চলে নাএক আচরণে এক test, বার্তা, বা পুরো ফল একটি তুলনায় (§৭)
Conditional test logicTest-এ if, loop, প্রত্যাশা হিসাবকিছু পথে কিছুই যাচাই হয় না; কোডের ভুল test-এ নকল হয়আক্ষরিক মান, parameterized test (§৬)
Sleepy testtime.sleep(2) দিয়ে অপেক্ষাধীর; যন্ত্র ধীর হলে ব্যর্থ, তাই flakyসময় বাইরে থেকে দেওয়া, শর্তের জন্য অপেক্ষা (পর্ব ২৫, ৪০)
Fragile testরসিদের পুরো লেখা অক্ষরে অক্ষরে মেলানো; ভেতরের function ডাকার সংখ্যা যাচাইআচরণ ঠিক থাকলেও refactoring-এ ভাঙে; দল test-এ আস্থা হারায়প্রকাশ্য আচরণ আর চুক্তির অংশ যাচাই
Obscure test৪০ লাইনের Arrange, ব্যাখ্যাহীন সংখ্যা, helper-এর ভেতরে assertionপড়ে বোঝা যায় না কী যাচাই হচ্ছেDAMP, builder, নামে আচরণ (§৫)

Smell-গুলো প্রায়ই একসাথে আসে, যেমন §৬-এর প্রথম test-এ পাঁচটি। Smell খোঁজার কাজ অনেকটা যন্ত্রে করা যায়: test ফাইলের abstract syntax tree পড়ে test-এর ভেতরে if, for, time.sleep বা পাঁচটির বেশি assertion খুঁজে বের করা সহজ, ঠিক যেমন পর্ব ০৬-এ linter production কোডে করে। কিন্তু “প্রত্যাশা কোডের সূত্র থেকে এসেছে” ধরনের smell শুধু মানুষের review-এ ধরা পড়ে, কারণ কোনটি requirement আর কোনটি কোডের হিসাব, যন্ত্র জানে না।

FIRST — ভালো unit test-এর পাঁচ গুণ

Smell বলে কী এড়াতে হবে; FIRST বলে কী চাই। সংক্ষেপটি Tim Ottinger ও Brett Schuchert-এর নামে প্রচলিত, আর Robert C. Martin-এর Clean Code (২০০৮) বইয়ে ব্যাপক পরিচিতি পায়; অক্ষরগুলোর ব্যাখ্যা উৎসভেদে সামান্য আলাদা।

অক্ষরঅর্থভাঙে যখন
Fastহাজার unit test কয়েক সেকেন্ডে; §৬-এর pytest run ০.০৪ সেকেন্ডে শেষsleep, আসল network বা database
Independentযেকোনো ক্রমে, একা বা একসাথে, একই ফল (test isolation)Test-গুলোর মধ্যে ভাগ করা পরিবর্তনশীল অবস্থা
Repeatableল্যাপটপে, CI-তে, রাত ২টায়, একই ফল (deterministic)আজকের তারিখ, এলোমেলো সংখ্যা, time zone, ইন্টারনেট
Self-validatingনিজেই পাস বা ফেল বলেprint করে চোখে মেলানো
Timelyকোডের সাথে বা আগে লেখামাস পরে লেখা test, যা প্রায়ই বর্তমান আচরণ নকল করে

“I” সবচেয়ে বেশি ভাঙে, আর ভাঙলে খুঁজে পাওয়া কঠিন, কারণ প্রতিটি test একা চালালে পাস করে। নিচের block-এ একটি cart-এর দুই test, একবার module-এর একটি ভাগ করা list নিয়ে, একবার প্রতিটি test-এর আগে নতুন list নিয়ে। প্রতিটি ধরন চারভাবে চালানো হলো: একা একা, আর দুই ক্রমে একসাথে।

import io, unittest

CART = []                                   # one list shared by all tests

def add_item(cart, name, price):
    cart.append((name, price))
    return sum(p for _, p in cart)

class SharedCart(unittest.TestCase):
    def test_rice(self):
        self.assertEqual(add_item(CART, "rice", 650), 650)
    def test_oil(self):
        self.assertEqual(add_item(CART, "oil", 190), 190)

class FreshCart(unittest.TestCase):
    def setUp(self):
        self.cart = []                      # new list before every test
    def test_rice(self):
        self.assertEqual(add_item(self.cart, "rice", 650), 650)
    def test_oil(self):
        self.assertEqual(add_item(self.cart, "oil", 190), 190)

def run(cls, names):
    CART.clear()
    suite = unittest.TestSuite(cls(n) for n in names)
    r = unittest.TextTestRunner(stream=io.StringIO()).run(suite)
    bad = [str(t).split()[0] + ": " + str(e).splitlines()[-1]
           for t, e in r.failures]
    print(f"{cls.__name__:10} {' + '.join(names):22} ->",
          "OK" if r.wasSuccessful() else bad)

for cls in (SharedCart, FreshCart):
    for names in (["test_rice"], ["test_oil"], ["test_rice", "test_oil"],
                  ["test_oil", "test_rice"]):
        run(cls, names)

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

SharedCart test_rice              -> OK
SharedCart test_oil               -> OK
SharedCart test_rice + test_oil   -> ['test_oil: AssertionError: 840 != 190']
SharedCart test_oil + test_rice   -> ['test_rice: AssertionError: 840 != 650']
FreshCart  test_rice              -> OK
FreshCart  test_oil               -> OK
FreshCart  test_rice + test_oil   -> OK
FreshCart  test_oil + test_rice   -> OK

SharedCart-এর দুটি test একা পাস করে, একসাথে চালালে যেটি পরে চলে সেটি ব্যর্থ: আগের test-এর পণ্য list-এ রয়ে গেছে, তাই যোগফল ৬৫০ + ১৯০ = ৮৪০. ক্রম বদলালে ব্যর্থ test-ও বদলায়, যা দেখে নতুনরা প্রায়ই ভাবেন test “এলোমেলোভাবে” ভাঙছে। আসলে এলোমেলো কিছু নেই; ফল ক্রমের ওপর নির্ভর করছে। FreshCart-এ setUp প্রতিটি test-এর আগে নতুন list দেয়, তাই চার রকমেই OK. বড় suite-এ ক্রমের এই নির্ভরতা খুঁজতে দলগুলো test এলোমেলো ক্রমে চালায় (যেমন pytest-এর plugin দিয়ে); fixture-এর scope আর ভাগ করা অবস্থার ফাঁদ বিস্তারিত পর্ব ২৩-এ, আর flaky test পর্ব ৪০-এ।

আরও গভীরে: Test smell নিয়ে empirical গবেষণা প্রায় দুই দশকের। আমাদের জানামতে Bavota ও সহকর্মীদের ২০১২ সালের দিকের গবেষণায় open-source project-এ test smell ব্যাপক পাওয়া যায়, আর নিয়ন্ত্রিত পরীক্ষায় smell-যুক্ত test বোঝা ও বদলানো কঠিন ছিল; Spadini ও সহকর্মীদের ২০১৮ সালের একটি গবেষণায় smell-যুক্ত test বেশি বদলাতে হয় আর তাদের production কোডে defect বেশি থাকার সম্পর্ক দেখা যায় বলে জানা যায়। তবে পরে কিছু গবেষক দেখান, tool যে smell ধরে তার অনেকগুলোকে developer-রা সমস্যা মনে করেন না। শিক্ষা: smell-এর তালিকা review-এর প্রশ্ন জোগায়, কিন্তু সিদ্ধান্ত নেয় প্রেক্ষাপট। “Test কতটা ভালো” মাপার আরও সরাসরি উপায় mutation testing, যা পর্ব ৫৯-এ।

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

  • AAA কী, আর Given-When-Then-এর সাথে সম্পর্ক? — Arrange (অবস্থা সাজানো), Act (একটি কাজ একবার), Assert (ফল মেলানো); Given, When, Then একই তিন অংশ ব্যবসার ভাষায়।
  • “এক test-এ একটি assertion” কি ঠিক নিয়ম? — আসল নিয়ম এক test-এ একটি আচরণ; একই আচরণের কয়েকটি দিক এক test-এ থাকতে পারে, বিশেষত পুরো ফল একটি তুলনায়।
  • তিনটি test smell-এর নাম ও সমাধান বলুন। — Eager test (আচরণ ধরে ভাঙা), mystery guest (প্রাসঙ্গিক data test-এ আনা), assertion roulette (বার্তা দেওয়া বা আলাদা test বানানো)।
  • FIRST কী? — Fast, Independent, Repeatable, Self-validating, Timely.
  • একটি test buggy কোডেও পাস করছে; সম্ভাব্য কারণ? — প্রত্যাশিত মান কোডের সূত্র থেকে হিসাব করা, test-এ if/loop, সীমা থেকে দূরের মান, বা দুর্বল assertion.

৯ · AI-এর যুগে unit test-এর গঠন

AI assistant-কে pricing.py দিয়ে “এর unit test লিখে দিন” বললে কয়েক সেকেন্ডে পরিচ্ছন্ন দেখতে একটি ফাইল আসে, আর প্রায়ই তাতে এই পর্বের প্রতিটি smell থাকে। সবচেয়ে বড় ঝুঁকি §৬-এর ফাঁদ: AI কোড পড়ে কোড যা করে সেটাই প্রত্যাশা হিসেবে লেখে। Seeded defect-সহ checkout_total দিলে সে আনন্দের সাথে লিখতে পারে assertEqual(checkout_total(2000, "Dhaka"), 1860), যা ভুলকে নিয়ম বানিয়ে পাহারা দেয়। এর বাইরে চেনা ধরন: শুধু happy path (happy path), সীমা বাদ (৫০০, ১৫০০, ২৫০০-এর মতো “গোল” সংখ্যা), test_checkout_total_1, _2 ধরনের নাম, এক test-এ দশটি assertion, অপেক্ষার জন্য sleep, এত mock যে কিছুই আসল চলে না, অস্তিত্বহীন assertion method বা pytest option, আর চালানো ছাড়াই “সব test পাস করবে” দাবি।

AI-কে requirement দিন, আর গঠনের নিয়ম স্পষ্ট করে বলুন:

নিচের বাজারঘরের দামের নিয়ম থেকে Python unittest লেখো। কোড দেখে expected value ঠিক করবে না; প্রতিটি প্রত্যাশিত মান নিয়ম থেকে হাতে হিসাব করে আক্ষরিক সংখ্যা হিসেবে লিখবে, পাশে ছোট মন্তব্যে হিসাবটি দেবে। [এখানে coupon, delivery আর মোটের নিয়ম পুরো লেখা] ১. প্রতিটি test একটি আচরণ; নাম সেই আচরণ, যেমন test_dhaka_order_of_2000_gets_free_delivery. ২. প্রতিটি test-এ Arrange, Act, Assert ফাঁকা লাইনে আলাদা। Test-এর ভেতরে if, for বা production function দিয়ে প্রত্যাশা হিসাব করবে না। ৩. সীমার মান রাখবে: 1000, 1001, 1999, 2000, 3000, 3010; ঢাকার বাইরে Plus আর সাধারণ ক্রেতা। ৪. assertTrue-এর বদলে নির্দিষ্ট assertion; দরকারে বার্তা। ৫. শেষে একটি তালিকা দাও: কোন test কোন নিয়মের কোন অংশ যাচাই করে। Test চালিয়েছ বলে দাবি করবে না।

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

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

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

প্র ০১“এক test-এ একটিই assertion” নিয়মটি কোথা থেকে এল, আর আক্ষরিকভাবে মানলে কী হয়?

নিয়মটি ২০০০-এর দশকের মাঝামাঝি TDD আর BDD-র আলোচনায় জনপ্রিয় হয়; Dave Astels-এর একটি লেখাকে প্রায়ই এর উৎস বলা হয় (আমাদের জানামতে ২০০৬ সালের দিকে)। প্রেক্ষাপটটি জরুরি। তখনকার xUnit framework-এ প্রথম ব্যর্থ assertion-এ test থেমে যেত আর বার্তা প্রায়ই দুর্বল ছিল, তাই একটি test-এ দশটি assertion মানে লাল হলে লম্বা খোঁজাখুঁজি। “একটিই assertion” ছিল সেই কষ্ট থেকে বাঁচার একটি কড়া, সহজে মনে রাখার মতো নিয়ম। পাশাপাশি এটি developer-কে একটি প্রশ্ন করতে বাধ্য করত: এই test আসলে কোন আচরণের?

আক্ষরিকভাবে মানলে দুই রকম ক্ষতি দেখা যায়। প্রথম, একই Arrange আর Act পাঁচবার লিখতে হয়, শুধু পাঁচটি field আলাদাভাবে যাচাই করতে; test ফাইল লম্বা হয়, আর পাঠক বোঝেন না পাঁচটি test আসলে একটিই প্রতিশ্রুতি। দ্বিতীয়, কেউ কেউ নিয়ম মানতে একটি বড় assertTrue(a == 1 and b == 2 and c == 3) লেখেন: আক্ষরিকভাবে একটি assertion, কিন্তু ব্যর্থ হলে False is not true ছাড়া কিছু বলে না। নিয়মের অক্ষর মানা হলো, উদ্দেশ্য হারাল।

এখন টুলও বদলেছে। pytest-এর assertion rewriting দুই পাশের মান দেখায়, unittest-এর assertEqual dict আর list-এ diff দেখায়, subTest একটি সারি ব্যর্থ হলেও বাকিগুলো চালায়, আর JUnit 5-এর assertAll কয়েকটি যাচাই একসাথে চালিয়ে সব ব্যর্থতা একবারে রিপোর্ট করে। তাই আজকের প্রচলিত সূত্র Roy Osherove-সহ অনেকের লেখায় যেমন পাওয়া যায়: এক test-এ একটি আচরণ, একটি “ধারণাগত” assertion. §৭-এর test_4_whole_breakdown তার উদাহরণ: রসিদের তিনটি field একটি তুলনায়, ব্যর্থ হলে diff সবগুলো ভুল একসাথে দেখায়।

তবু পুরোনো নিয়মের মূল প্রশ্নটি মূল্যবান। একটি test-এ যদি এমন দুটি assertion থাকে যাদের জন্য আলাদা নাম লাগে, তাহলে সেগুলো আলাদা আচরণ। নাম লেখার পরীক্ষাটি (“আর” শব্দ লাগে কি না) প্রায় সবসময় ঠিক উত্তর দেয়।

মূল উপলব্ধি: নিয়মটির লক্ষ্য ছিল ব্যর্থ হওয়ার কারণ একটি রাখা। Assertion গোনা নয়, আচরণ গোনাই আসল কাজ।

প্র ০২Test code-ও কোড। তাহলে production কোডের মতো DRY আর abstraction-এর নিয়ম test-এ কেন পুরোপুরি খাটে না?

পার্থক্যটি পাঠকের অবস্থায়। Production কোড পড়া হয় তার পুরো প্রেক্ষাপট মাথায় নিয়ে: একজন developer একটি module-এ কাজ করছেন, helper আর abstraction তাঁর চেনা। Test পড়া হয় সাধারণত একটি জরুরি মুহূর্তে: CI লাল, release আটকে, আর যিনি পড়ছেন তিনি হয়তো এই module কখনো দেখেননি। তাঁর একটাই প্রশ্ন, “এই test কী আশা করছিল, আর কেন?” উত্তরটি যদি তিনটি helper আর একটি data ফাইল ঘুরে খুঁজতে হয়, test তার প্রধান কাজে ব্যর্থ।

দ্বিতীয় পার্থক্য: test-এর নিজের কোনো test নেই। Production কোডের একটি জটিল helper-এর ভুল test ধরে। কিন্তু test-এর helper-এর ভুল, যেমন একটি শর্তে assertion এড়িয়ে যাওয়া, কেউ ধরে না; বরং সেটি বারোটি test-কে একসাথে নিঃশব্দে অকেজো করে দেয়। তাই test-এ যত কম logic, তত কম জায়গায় test নিজে ভুল হতে পারে। এই যুক্তিতেই Meszaros “conditional test logic”-কে smell বলেছেন, আর অনেক দল test-এ এমনকি ছোট হিসাবও (2000 - 200) code হিসেবে না রেখে মন্তব্যে রাখে।

তৃতীয়, DRY-এর মূল কথা “একটি জ্ঞানের একটি জায়গা”, আর test-এ জ্ঞানটি হলো প্রত্যাশা। Production কোডের constant import করে test-এ বসালে প্রত্যাশা আর বাস্তবায়ন একই জায়গা থেকে আসে; ভুল constant-এর বিরুদ্ধে আর কোনো স্বাধীন যাচাই থাকে না। Requirement-এর একটি সংখ্যা test-এ আলাদা করে লেখা আসলে পুনরাবৃত্তি নয়, দ্বিতীয় একটি স্বাধীন সাক্ষী।

তবে DAMP মানে কপি-পেস্টের অনুমতি নয়। যে প্রস্তুতি আচরণের সাথে সম্পর্কহীন (একটি বৈধ ক্রেতা, ঠিকানা, সংযোগ), তা fixture বা builder-এ সরানোই ঠিক, কারণ সেখানে পুনরাবৃত্তি আসল মানগুলোকে ঢেকে দেয়। Google-এর testing blog-এর পরিচিত পরামর্শও প্রায় এমন বলে জানা যায়: প্রাসঙ্গিক তথ্য test-এ, অপ্রাসঙ্গিক তথ্য আড়ালে।

মূল উপলব্ধি: Production কোড পুনর্ব্যবহারের জন্য, test পড়ার জন্য। Test-এ DRY খাটান প্রস্তুতিতে, কখনো প্রত্যাশায় নয়।

প্র ০৩Test smell-এর ধারণা কীভাবে এল, আর গবেষণা কি দেখায় smell সত্যিই ক্ষতিকর?

“Code smell” শব্দটি Kent Beck আর Martin Fowler-এর Refactoring (১৯৯৯) বইয়ের মাধ্যমে ছড়ায়। দুই বছর পরে, ২০০১ সালে, Arie van Deursen, Leon Moonen ও সহকর্মীরা XP সম্মেলনের জন্য “Refactoring Test Code” প্রবন্ধে প্রথমবার test কোডের জন্য আলাদা smell-এর তালিকা দেন। Mystery guest, eager test, assertion roulette, general fixture-এর মতো নামগুলো সেখান থেকেই এসেছে বলে সাধারণত উল্লেখ করা হয়। প্রবন্ধটি একটি বাস্তব পর্যবেক্ষণ থেকে লেখা: Extreme Programming দলে test কোড production কোডের সমান বড় হয়ে উঠছিল, আর তার মান কেউ দেখছিল না।

২০০৭ সালে Gerard Meszaros-এর xUnit Test Patterns বইটি এই কাজকে একটি বিস্তৃত ভাষায় রূপ দেয়: smell-গুলোকে কোড-স্তর (obscure test, conditional test logic), আচরণ-স্তর (fragile test, erratic test, slow tests) আর project-স্তর (buggy tests, developers not writing tests) ভাগ করে, প্রতিটির কারণ আর সমাধান-pattern দেন। Test double-এর পরিচিত নামগুলো (dummy, stub, spy, mock, fake) এই বইয়ের মাধ্যমেই ছড়ায়, যা পর্ব ২৪-এ আসবে।

গবেষণার ফল মিশ্র, আর সেটি জানা জরুরি। আমাদের জানামতে ২০১০-এর দশকের কয়েকটি empirical গবেষণা (যেমন Bavota ও সহকর্মীদের কাজ) দেখায় smell ব্যাপকভাবে ছড়ানো, আর নিয়ন্ত্রিত পরীক্ষায় smell-যুক্ত test বুঝতে বেশি সময় লাগে; পরের একটি গবেষণা (Spadini ও সহকর্মী, ২০১৮) smell-যুক্ত test-এর সাথে বেশি পরিবর্তন আর defect-এর সম্পর্ক পায়। অন্যদিকে ২০২০-এর দশকের কিছু কাজ দেখায়, smell ধরার tool অনেক false positive দেয়, আর developer-রা tool-এর চিহ্নিত অনেক smell-কে সমস্যা মনে করেন না। সম্পর্ক মানেই কারণ নয়: জটিল production কোডের test হয়তো স্বভাবতই জটিল আর smell-যুক্ত।

ব্যবহারিক শিক্ষা হলো smell-কে review-এর প্রশ্ন হিসেবে ব্যবহার করা, শাস্তির নিয়ম হিসেবে নয়। “এখানে if কেন?” প্রশ্নের একটি ভালো উত্তর থাকতে পারে; কিন্তু §৬-এর মতো “প্রত্যাশা কোডের সূত্র থেকে” smell-এর ক্ষেত্রে প্রায় কখনো থাকে না।

মূল উপলব্ধি: Smell-এর তালিকা অভিজ্ঞতার সংক্ষেপ, প্রমাণিত আইন নয়। প্রতিটি smell একটি প্রশ্ন তোলে; উত্তর দেয় প্রেক্ষাপট।

প্র ০৪Test-এর নামকে “executable specification” বলা হয়। Agiledox থেকে BDD পর্যন্ত এই ধারণা কীভাবে বড় হলো, আর এর সীমা কোথায়?

২০০০-এর দশকের শুরুতে JUnit-এ test method-এর নাম test দিয়ে শুরু হতে হতো, আর বেশিরভাগ নাম ছিল testCalculate ধরনের। ThoughtWorks-এর Chris Stevenson একটি ছোট tool বানান, agiledox, যা test class-এর method নামগুলো থেকে “test” বাদ দিয়ে camelCase ভেঙে বাক্যের তালিকা বানাত। ফলাফল ছিল একটি সহজ পর্যবেক্ষণ: যে দলের নাম আচরণ বলে, তাদের তালিকা পড়লে class-এর একটি ছোট নথি পাওয়া যায়; যাদের নাম method-এর, তাদের তালিকা অর্থহীন।

Dan North তাঁর “Introducing BDD” লেখায় (২০০৬ সালে প্রকাশিত বলে জানা যায়) বর্ণনা করেন, এই অভিজ্ঞতা থেকেই তিনি “test” শব্দের বদলে “behaviour” আর “should” দিয়ে ভাবা শুরু করেন, কারণ “test” শব্দ developer-দের যাচাইয়ের দিকে ঠেলে দিত, আচরণের বর্ণনার দিকে নয়। পরে Chris Matts-এর সাথে তিনি Given-When-Then ছাঁচ দাঁড় করান, যা Cucumber-এর Gherkin ভাষার মাধ্যমে ব্যাপক ছড়ায় (পর্ব ৪৩)। আজ Jest আর Vitest-এর describe/it এই ধারার সরাসরি উত্তরাধিকার।

সীমাও আছে। প্রথম, নাম মিথ্যা বলতে পারে: test_plus_member_pays_60 নামের ভেতরে কেউ সাধারণ ক্রেতার ১২০ যাচাই করলে কোনো tool তা ধরবে না। নাম আর assertion মেলানো review-এর কাজ। দ্বিতীয়, test-এর তালিকা শুধু উদাহরণ দেয়, সাধারণ নিয়ম নয়: “২০০০-এ ফ্রি” আর “১৯৯৯-এ ৬০” থেকে পাঠক অনুমান করেন সীমা ২০০০, কিন্তু ২০০০ আর ২২২১-এর মধ্যে কী হয়, তা কোনো নাম বলে না। Property-based testing (পর্ব ৫৮) এই ফাঁকটি পূরণের একটি চেষ্টা। তৃতীয়, নথি হিসেবে test-এর পাঠক মূলত developer আর tester; product owner-এর জন্য Gherkin-এর মতো আলাদা স্তর লাগে।

তবু শুধু নাম ঠিক করার খরচ প্রায় শূন্য, আর লাভ প্রতিদিনের: CI-র প্রতিটি লাল লাইন একটি ছোট bug report-এর শিরোনাম হয়ে যায়।

মূল উপলব্ধি: ভালো নামের তালিকা একটি জীবন্ত নথি, কিন্তু নথিটি ততটুকুই সত্য যতটুকু নাম আর assertion মেলে।

প্র ০৫Test-কে কে test করে? একটি test যে সত্যিই ভুল ধরতে পারে, তা নিশ্চিত হওয়ার উপায় কী?

§৬-এর প্রথম test বছরের পর বছর CI-তে সবুজ থাকতে পারত। Coverage tool-ও তাকে ভালো নম্বর দিত, কারণ সে checkout_total-এর প্রায় প্রতিটি লাইন চালায়। পর্ব ১৩-এ দেখেছেন, coverage বলে কোন লাইন চলেছে, কিন্তু চলার পরে কেউ ফল যাচাই করেছে কি না, তা বলে না। একটি test যে assertion ছাড়াই সব লাইন চালায়, তার coverage ১০০%, ভুল ধরার ক্ষমতা শূন্য।

সবচেয়ে সরল উত্তর TDD-র অভ্যাসে: test আগে লিখে তাকে লাল হতে দেখা। Kent Beck-এর Test-Driven Development: By Example (২০০২) বইয়ের red-green চক্রের একটি উদ্দেশ্যই এটা: যে test কখনো লাল হয়নি, সে আদৌ কিছু যাচাই করে কি না জানা যায় না (পর্ব ২৭)। পরে test লিখলেও একই কাজ করা যায় হাতে: কোডে ইচ্ছা করে একটি ভুল ঢুকিয়ে (>=-কে >, বা সীমা ছাড়ের পরে মাপা) দেখুন test লাল হয় কি না, তারপর ফিরিয়ে আনুন।

এই হাতের কাজটিকে পদ্ধতিতে রূপ দেয় mutation testing. ধারণাটি ১৯৭০-এর দশকের; DeMillo, Lipton আর Sayward-এর ১৯৭৮ সালের প্রবন্ধকে প্রায়ই এর ভিত্তি বলা হয়। একটি tool কোডে শত শত ছোট পরিবর্তন (mutant) বানায়, প্রতিটিতে suite চালায়, আর গোনে কতগুলো mutant কোনো test ধরেছে। §৬-এর smelly test প্রায় কোনো mutant ধরত না, কারণ তার প্রত্যাশা কোডের সাথে সাথে বদলায়। বিস্তারিত পর্ব ৫৯-এ।

তৃতীয় স্তর মানুষের review: প্রতিটি assertion-এর প্রত্যাশিত মান requirement-এর কোন বাক্য থেকে এল, তা মিলিয়ে দেখা। AI-এর লেখা test-এর যুগে এটি আরও জরুরি, কারণ AI কোড পড়ে কোডের আচরণকেই প্রত্যাশা বানাতে পারে।

মূল উপলব্ধি: যে test কখনো লাল হতে দেখেননি, তাকে বিশ্বাস করবেন না। Test-এর ক্ষমতা যাচাই হয় ভুল ধরা দেখে, সবুজ থাকা দেখে নয়।

অনুশীলন

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

  1. Spec থেকে test (test design): বাজারঘরের রিভিউ feature-এর AC5: পণ্যের গড় rating এক দশমিক ঘরে দেখানো হয়, ঠিক মাঝখানে হলে ওপরে (half up, ৪.২৫ → ৪.৩). Function average_rating(stars) একটি list নেয়। (ক) চারটি test-এর আচরণভিত্তিক নাম আর আক্ষরিক প্রত্যাশিত মান লিখুন। (খ) একটি test AAA-তে পুরো লিখুন। (গ) কোন একটি case Python-এর round() দিয়ে লেখা ভুল বাস্তবায়ন ধরবে?

    (ক) উদাহরণ: test_average_of_5_4_4_4_rounds_half_up_to_4_3 → 4.3 (গড় ৪.২৫); test_average_of_1_2_2_2_is_1_8 → 1.8 (গড় ১.৭৫); test_average_of_4_4_5_is_4_3 → 4.3 (গড় ৪.৩৩…, নিচে নামে); test_single_five_star_review_shows_5_0 → 5.0. খালি list-এ কী দেখাবে, তা AC-তে নেই; এটি product owner-এর প্রশ্ন, test-এ নিজে অনুমান করে বসাবেন না। (খ)

    def test_average_of_5_4_4_4_rounds_half_up_to_4_3(self):
        stars = [5, 4, 4, 4]
    
        shown = average_rating(stars)
    
        self.assertEqual(shown, Decimal("4.3"))  # 17/4 = 4.25

    (গ) [৫, ৪, ৪, ৪]. Python-এ round(4.25, 1) দেয় 4.2, কারণ 4.25 float-এ হুবহু রাখা যায়, আর round ঠিক মাঝখানের মানকে জোড় অঙ্কের দিকে নেয় (banker's rounding), half-up নয়; script দিয়ে যাচাই করা। [১, ২, ২, ২]-এর ১.৭৫-এ জোড় অঙ্কটি ৮, তাই round কাকতালীয়ভাবে 1.8 দেয়, তাই সেটি এই ভুল ধরে না। এটিই সীমার মান বাছাইয়ের শিক্ষা: “ঠিক মাঝখানে” case একাধিক রাখুন।

  2. আউটপুট অনুমান করুন (read the failure): Seeded defect-সহ checkout_total (delivery-র ২০০০ টাকার সীমা ছাড়ের পরের দামে মাপা) নিয়ে দুটি test:
    CASES = [(1999, 1860), (2000, 1800), (2100, 1890)]
    
    def test_loop(self):
        for amount, want in CASES:
            self.assertEqual(checkout_total(amount, "Dhaka"), want)
    
    def test_sub(self):
        for amount, want in CASES:
            with self.subTest(amount=amount):
                self.assertEqual(checkout_total(amount, "Dhaka"), want)
    কোন test কয়টি ব্যর্থতা দেখাবে, আর বার্তাগুলো কী? কোন তথ্য একটিতে হারিয়ে যায়?

    Buggy কোডে ১৯৯৯ → ১৮৬০ (ঠিক), ২০০০ → ১৮৬০ (প্রত্যাশা ১৮০০), ২১০০ → ১৯৫০ (প্রত্যাশা ২১০০ − ২১০ + ০ = ১৮৯০). test_loop একটি ব্যর্থতা দেখায়: AssertionError: 1860 != 1800, তারপর থামে; ২১০০-এর ভুল কখনো যাচাই হয় না, আর বার্তায় কোন amount তাও নেই। test_sub দুটি ব্যর্থ subTest দেখায়: (amount=2000) সাথে 1860 != 1800, আর (amount=2100) সাথে 1950 != 1890. দুটি ব্যর্থতাই ৬০ বেশি, যা একটি ধরন দেখায়: সমস্যা delivery-তে। ফলাফল script-এ চালিয়ে মেলানো।

  3. Test-এর ভুল খুঁজুন (find the bug): একজন সহকর্মীর লেখা:
    def test_plus(self):
        order = load_order("fixtures/order_17.json")
        total = checkout_total(order.amount, order.district, plus=True)
        if order.district != "Dhaka":
            self.assertTrue(total < order.amount + 120)
        time.sleep(1)  # wait for the price service
    কয়টি smell পান? ফাইলে অর্ডারটি ৮০০ টাকার, Sylhet. সারানো test লিখুন।

    অন্তত পাঁচটি। ১. Mystery guest: অর্ডারের মান JSON ফাইলে, test পড়ে দেখা যায় না। ২. Conditional test logic: ফাইলে কেউ district বদলে Dhaka করলে কোনো assertion চলবে না, আর test নিঃশব্দে সবুজ থাকবে। ৩. দুর্বল assertion: < amount + 120 মানে delivery ১২০-এর কম যেকোনো কিছু, ১ টাকাও; নিয়ম বলে ঠিক ৬০. ৪. Sleepy test: sleep(1) কোনো কাজে আসে না (দামের হিসাব সরাসরি function-এ) আর প্রতি run-এ এক সেকেন্ড নষ্ট করে। ৫. অস্পষ্ট নাম: test_plus. সারানো রূপ:

    def test_plus_member_outside_dhaka_pays_60_taka_delivery(self):
        amount, district = 800, "Sylhet"
    
        total = checkout_total(amount, district, plus=True)
    
        self.assertEqual(total, 860)  # 800, no coupon, + 60

    ৮০০ টাকা ১০০০-এর কম, তাই ছাড় নেই; Plus সদস্য ঢাকার বাইরে ৬০ দেন: মোট ৮৬০ (সাধারণ ক্রেতা হলে ৯২০)। দুটি সংখ্যাই script দিয়ে মেলানো।

  4. DAMP না DRY (ভেবে দেখুন): একটি test ফাইলে বারোটি test এমন: def test_case_7(self): self.check(2000, "Dhaka", False, 1800). check ভেতরে checkout_total ডেকে assertEqual করে। দলের একজন বলছেন, “এটাই সবচেয়ে পরিচ্ছন্ন, কোনো পুনরাবৃত্তি নেই।” আপনি কী বদলাবেন, আর কেন?

    সমস্যা তিনটি: নাম (test_case_7) কোনো আচরণ বলে না; False আর ১৮০০-এর অর্থ পড়ে বোঝা যায় না (positional যুক্তি, magic number); আর assertion লুকানো helper-এ। দুটি ভালো পথ। প্রথম, এগুলো আসলে একই আচরণের কয়েকটি উদাহরণ হলে একটি parameterized test: সারিগুলো নাম দেওয়া field-সহ একটি টেবিলে, যেমন dict(amount=2000, district="Dhaka", plus=False, total=1800, why="free at 2000, coupon 200"), আর subTest(**row) বা pytest-এর parametrize ও ids দিয়ে প্রতিটি সারি নামসহ রিপোর্ট হবে। দ্বিতীয়, ভিন্ন নিয়মের case হলে আলাদা আচরণের নামে test, প্রত্যেকটি AAA-তে। দুই পথেই প্রত্যাশিত মান আর তার কারণ test-এর ভেতরে চোখের সামনে থাকে; শুধু একঘেয়ে প্রস্তুতি helper-এ যেতে পারে। Helper রাখলে নাম দিন assert_total_is, আর keyword যুক্তি ব্যবহার করুন।

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

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

ক্রমএকটি eager test-কে আলাদা test-এ ভাঙার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. প্রতিটি assertion কোন আচরণ বা নিয়ম যাচাই করে, তা পাশে লেখা
  2. প্রতিটি আচরণের জন্য একটি নতুন test, নাম সেই আচরণ
  3. প্রত্যাশিত মান requirement থেকে আক্ষরিক সংখ্যায় বসানো, AAA-তে সাজানো
  4. নতুন test-গুলো বর্তমান কোডে চালানো
  5. কোডে ইচ্ছা করে ভুল ঢুকিয়ে দেখা প্রতিটি test লাল হয় কি না
  6. পুরোনো eager test মুছে ফেলা

একটি unit test-এ Arrange, Act আর Assert অংশের কাজ কোনটি সঠিকভাবে বলে?

  • প্রথমে প্রত্যাশা লেখা, তারপর কাজটি কয়েকবার ডাকা, শেষে অবস্থা সাজানো
  • অবস্থা ও input তৈরি, যাচাইয়ের কাজটি একবার ডাকা, ফল প্রত্যাশার সাথে মেলানো
  • Test data মুছে ফেলা, production কোড লেখা, রিপোর্ট ছাপা
  • Mock বানানো, log পড়া, CI চালানো

একটি test: for a in [500, 1500, 2500]: self.assertEqual(total(a), a - discount(a) + delivery(a - discount(a))). Production কোডে delivery-র সীমা ভুলভাবে ছাড়ের পরের দামে মাপা হয়। Test-টি কেন সবুজ থাকতে পারে?

  • Loop-এর ভেতরে assertion কখনো চলে না
  • assertEqual পূর্ণ সংখ্যা তুলনা করতে পারে না
  • Test-গুলোর চালানোর ক্রম এলোমেলো
  • প্রত্যাশিত মান কোডের ভুল সূত্র দিয়েই হিসাব করা, আর মানগুলো সীমা থেকে দূরে

CI-তে একটি test ব্যর্থ: AssertionError: False is not true. Test-এর কোন লেখার ধরন এই অস্পষ্ট বার্তার সবচেয়ে সম্ভাব্য কারণ?

  • self.assertTrue(total == 1800)
  • self.assertEqual(total, 1800)
  • self.assertRaises(ValueError, f)
  • self.assertIn("rice", items)

দুটি test আলাদাভাবে চালালে পাস করে, একসাথে চালালে যেটি পরে চলে সেটি ব্যর্থ হয়, আর ক্রম বদলালে ব্যর্থ test-ও বদলায়। FIRST-এর কোন গুণ ভাঙছে?

  • Fast
  • Self-validating
  • Independent
  • Timely

একটি test ফাইল থেকে অর্ডারের মান পড়ে (load("fixtures/order_17.json")), আর test-এর কোডে সেই মানগুলো দেখা যায় না। এই smell-এর নাম কী?

  • Eager test
  • Mystery guest
  • Sleepy test
  • Assertion roulette

নিয়ম: “ঢাকার বাইরে delivery ১২০ টাকা, Plus সদস্যদের ৬০ টাকা।” কোন test-এর নাম সবচেয়ে ভালো?

  • test_delivery_charge_2
  • test_sylhet
  • test_plus_member_outside_dhaka_pays_60_taka
  • test_outside_dhaka_120_and_plus_60_and_dhaka_60

Test-এ প্রত্যাশিত মানের জন্য production কোডের constant FREE_DELIVERY_LIMIT import করে ব্যবহার করা নিয়ে কোন কথাটি সবচেয়ে ঠিক?

  • সবসময় ভালো, কারণ DRY মানা হয়
  • এতে test ধীর হয়ে যায়
  • unittest অন্য module থেকে import করতে দেয় না
  • ঝুঁকিপূর্ণ, কারণ constant ভুল হলে test-ও একই ভুল নিয়ে সবুজ থাকবে

শব্দকোষ

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

মনে রাখুন

  1. Arrange, Act, Assert: অবস্থা সাজানো, কাজ একবার, ফল মেলানো; Given-When-Then একই কাঠামো, আর অংশগুলো ফাঁকা লাইনে আলাদা।
  2. এক test, এক আচরণ: ব্যর্থ হওয়ার কারণ একটি। নামে “আর” লাগলে সম্ভবত দুটি test.
  3. নামে আচরণ, method নয়: লাল তালিকা পড়েই বোঝা যাক কোন নিয়ম ভাঙল।
  4. প্রত্যাশা requirement থেকে, আক্ষরিক মানে; test-এ if, loop বা কোডের সূত্র নয়, নইলে test buggy কোডেও সবুজ থাকে।
  5. নির্দিষ্ট assertion আর FIRST: ব্যর্থতার বার্তা কারণ বলে; test দ্রুত, স্বাধীন, পুনরাবৃত্তিযোগ্য, নিজেই রায় দেয়, সময়মতো লেখা।

পরের পর্বে: Test-এর Arrange অংশ যখন বড় হয়ে ওঠে: pytest fixture-এর scope, yield দিয়ে teardown, factory fixture, test data builder আর object mother, আর ভাগ করা অবস্থার ফাঁদ। পর্ব ২৩ (Fixture আর test data — scope, factory আর builder).

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

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