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

TDD হাতে-কলমে — red-green-refactor, kata আর outside-in

TDD in Practice — Red-Green-Refactor, Katas and Outside-In

Taught in Bangla, this lesson builds the Bazarghar review average rating, one decimal rounded half up, in a 16-step TDD kata where every red and green is real pytest 9.2.0 output. It shows test lists, fake it, triangulation, where 4.25 let a wrong solution pass and 4.35 exposed a float trap, and the transformation priority premise. In-page Python replays the kata and compares classic and mockist tests under a refactor, and an outside-in double loop starts from a failing acceptance test.

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

  • Requirement থেকে test list বানানো আর কোন item আগে নেবেন, তার যুক্তি
  • Red, green, refactor প্রতিটি ধাপে pytest-এর আউটপুট পড়ে পরের সিদ্ধান্ত নেওয়া
  • Fake it, triangulation আর obvious implementation-এর মধ্যে গিয়ার বদলানো; transformation priority premise
  • Classic (Detroit) আর mockist (London) ধারার test-এর পার্থক্য, সত্যিকারের ফল দেখে
  • Outside-in-এর double loop, আর কখন TDD কাজে লাগে, কখন লাগে না

১ · TDD আবার — এবার হাতে-কলমে

রাঁধুনি ভাত চড়ানোর আগেই জানেন “হয়ে গেছে” কীভাবে বুঝবেন: একটি দানা টিপে দেখবেন, ভেতরে শক্ত থাকবে না। যাচাইয়ের উপায় আগে ঠিক, রান্না পরে। Test-driven development (TDD)-এর মূল কথাও এটুকু: কোড লেখার আগে একটি ছোট test লিখুন, সেটিকে ব্যর্থ হতে দেখুন, তারপর পাস করানোর মতো ন্যূনতম কোড লিখুন, শেষে test সবুজ রেখে কোড গোছান। এই তিন ধাপের নাম red-green-refactor.

ধারণাটির পরিচয়, ইতিহাস আর একটি ছোট kata আছে সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৮-এ। এই পর্ব সেখান থেকে অনেক দূর যায়। আমরা বাজারঘরের একটি আসল নিয়ম ধরে পুরো kata করব, আর প্রতিটি লাল আর সবুজে সত্যিকারের pytest চালিয়ে আউটপুট পড়ব। তারপর দেখব দুটি ধারা (classic আর mockist) একই কোডে কীভাবে আলাদা আচরণ করে, আর outside-in-এ acceptance test থেকে কীভাবে ভেতরের নকশা বেরিয়ে আসে। pytest-এর flag আর রিপোর্ট পড়া পর্ব ২১-এ, test-এর গঠন পর্ব ২২-এ, আর mock পর্ব ২৪-এ শিখেছেন; এখানে সেগুলো একসাথে কাজে লাগবে।

Kent Beck ১৯৯০-এর দশকে Extreme Programming-এর “test-first” চর্চা থেকে পদ্ধতিটি সাজান, আর ২০০২ সালে Test-Driven Development: By Example বইয়ে লেখেন। Beck নিজে বলেছেন তিনি এটি “আবিষ্কার” নয়, “পুনরাবিষ্কার” করেছেন, কারণ পুরোনো প্রোগ্রামিং বইয়ে আগে প্রত্যাশিত আউটপুট লিখে রাখার কথা ছিল। Robert C. Martin পরে কড়া রূপে TDD-র তিন সূত্র লেখেন। ২০২৩ সালের শেষ দিকে Beck “Canon TDD” নামের লেখায় আবার মূল ধাপগুলো গুছিয়ে বলেন, কারণ তাঁর মতে অনেকে TDD-র নামে অন্য কিছু করছিলেন।

Tester হিসেবে আপনি হয়তো ভাবছেন, এটা তো developer-এর কাজ। কিন্তু TDD-র প্রতিটি চক্রের কেন্দ্রে একটি প্রশ্ন: “পরের উদাহরণ কোনটি?” এর উত্তর আসে partition, boundary আর error guessing থেকে, অর্থাৎ মডিউল ২-এর দক্ষতা থেকে। SDET বা automation-এর কাজে আপনি নিজেও helper, fixture আর test framework-এর কোড লিখবেন; সেখানে TDD সরাসরি কাজে লাগে। আর developer-এর সাথে জোড়ায় বসে (pairing) test list বানানো এখন অনেক agile দলে QA-র প্রতিদিনের কাজ।

Canon TDD — পাঁচ ধাপ

  1. যে আচরণগুলো যাচাই করতে চান, তার একটি test list লিখুন। এটি কোড নয়, কাগজের তালিকা।
  2. তালিকা থেকে ঠিক একটি item নিয়ে চালানো যায় এমন test লিখুন।
  3. Test চালান, লাল দেখুন; তারপর কোড বদলান যাতে এই test আর আগের সব test পাস করে। নতুন ভাবনা এলে তালিকায় যোগ করুন।
  4. দরকার হলে refactor করুন, test সবুজ রেখে।
  5. তালিকা খালি না হওয়া পর্যন্ত ধাপ ২-এ ফিরুন।

Beck দুটি সাধারণ ভুলের কথা বিশেষভাবে বলেন: assertion ছাড়া test লেখা শুধু coverage বাড়াতে, আর পুরো test list একবারে test-এ বদলে তারপর একটি একটি করে পাস করানো। দ্বিতীয়টি নিরীহ মনে হয়, কিন্তু তাতে প্রথম test পাস করানোর সময় যা শিখলেন, তা বাকি test-এ আর কাজে লাগে না; সব আগেই লেখা।

লাল দেখাটাই প্রথম যাচাই

নতুন test আগে লাল না দেখলে আপনি জানেন না যে test-টি আদৌ ব্যর্থ হতে পারে। আর লাল দেখলেও কারণ পড়ুন: import না হওয়া, ভুল assertion, নাকি test-এর নিজের typo? Tester-এর চোখে TDD-র সবচেয়ে বড় উপহার এটিই: প্রতিটি test অন্তত একবার নিজের কাজ করে দেখিয়েছে।

২ · Kata-র প্রস্তুতি — AC5, test list আর প্রকল্প

Code kata হলো বারবার করার মতো ছোট অনুশীলন, যেমন কারাতের kata. আজকের kata-র বিষয় বাজারঘরের “রিভিউ আর রেটিং” ফিচারের একটি acceptance criterion, যা পর্ব ১৫-এ স্থির হয়েছিল:

AC5: পণ্যের পাতায় গড় rating দেখানো হবে এক দশমিক পর্যন্ত, half up; ৪.২৫ হবে ৪.৩, banker's rounding নয়। AC2: star আবশ্যক, ১ থেকে ৫-এর পূর্ণসংখ্যা।

Function-এর নাম আর রূপ ঠিক করি test-এর দিক থেকে, ব্যবহারকারীর চোখে: average_label(stars), star-এর তালিকা নেবে আর দেখানোর লেখা ফেরত দেবে, যেমন "4.3". লেখা ফেরত দেওয়ায় float তুলনার ঝামেলা থাকে না, আর "5.0"-এর শেষের শূন্যও যাচাই করা যায়। কোনো review না থাকলে None; পাতাটি তখন “এখনো রিভিউ নেই” দেখাবে।

Kata-র উদ্দেশ্য সমাধান পাওয়া নয়, হাতের অভ্যাস তৈরি। তাই একই kata কয়েকবার করুন: প্রতিবার আধা ঘণ্টার মতো সময় বেঁধে, শেষে কোড মুছে ফেলে, পরের বার অন্য ক্রমে test নিয়ে বা অন্য কৌশলে। দ্বিতীয়-তৃতীয়বারে চোখে পড়বে কোন ধাপ বড় ছিল, কোথায় লাল দেখা বাদ পড়েছিল।

Test list — আর ক্রমের যুক্তি

#Itemকেন এই ক্রমে
1review নেই → Noneসবচেয়ে সরল, শুধু function-এর অস্তিত্ব আর রূপ ঠিক করে
2[5] → "5.0"একটি মান; ফরম্যাট (এক দশমিক) ঠিক হয়
3[4, 5] → "4.5"দ্বিতীয় উদাহরণ, গড়ের নিয়মে বাধ্য করে
4[4, 4, 5] → "4.3"অসীম দশমিক কেটে এক ঘর
5[4, 4, 5, 4] → "4.3"ঠিক মাঝের মান ৪.২৫, half up-এর সীমা
6star ০ বা ৬ → ValueErrorAC2; মূল নিয়মের পরে

খেয়াল করুন, তালিকাটি পর্ব ০৮-এর ভাবনায় তৈরি: ঠিক মাঝের ৪.২৫ একটি সীমার মান, আর ০ ও ৬ star-এর বৈধ সীমার ঠিক বাইরে। TDD test design-কে বাদ দেয় না; কোন উদাহরণ নেবেন, তা আগের মডিউলের কৌশল থেকেই আসে। চলার পথে তালিকায় একটি নতুন item যোগ হবে, যা আমরা শুরুতে ভাবিনি; §৪-এ দেখবেন।

প্রকল্প পর্ব ২১-এর মতো, uv দিয়ে, Python 3.12.13 আর pytest 9.2.0 (MIT লাইসেন্স):

uv init --vcs none --author-from none bazarghar-qa
cd bazarghar-qa && uv add pytest
mkdir bazarghar tests && touch bazarghar/__init__.py
# pyproject.toml: [tool.pytest.ini_options]
#   testpaths = ["tests"]   pythonpath = ["."]

৩ · Kata, চক্র ১ থেকে ৪ — fake it থেকে প্রথম সাধারণ নিয়ম

নিচের প্রতিটি আউটপুট এই কোর্স লেখার সময় একটি Windows ডেস্কটপে সত্যিকারভাবে চালানো, ক্রম অনুযায়ী। Path নিরপেক্ষ (~/bazarghar-qa) করা, আর traceback-এর যে লাইনে কম্পিউটারের Python-এর পূর্ণ ঠিকানা ছিল তা “…” দিয়ে ছাঁটা।

চক্র ১ — লাল: function-ই নেই

প্রথম test, tests/test_reviews.py-এ:

from bazarghar.reviews import average_label


def test_no_reviews_gives_no_label():
    assert average_label([]) is None
$ uv run pytest -q
=================================== ERRORS ====================================
___________________ ERROR collecting tests/test_reviews.py ____________________
ImportError while importing test module '~/bazarghar-qa\tests\test_reviews.py'.
…
tests\test_reviews.py:1: in <module>
    from bazarghar.reviews import average_label
E   ModuleNotFoundError: No module named 'bazarghar.reviews'
!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 0.08s

তিন সূত্রের দ্বিতীয়টি বলে “compile না হওয়াও ব্যর্থতা”; Python-এ তার সমতুল্য import error. তবে খেয়াল করুন, এটি F নয়, collection-এর error: test শুরুই হয়নি। এই লাল প্রত্যাশিত, কারণ module সত্যিই নেই। সবুজ করতে ন্যূনতম কোড, bazarghar/reviews.py-এ দুই লাইন: def average_label(stars): return None. ফল: 1 passed in 0.01s.

চক্র ২ — লাল, তারপর fake it

দ্বিতীয় item: assert average_label([5]) == "5.0".

$ uv run pytest -q
.F                                                                       [100%]
================================== FAILURES ===================================
______________________ test_single_review_shows_its_star ______________________

    def test_single_review_shows_its_star():
>       assert average_label([5]) == "5.0"
E       AssertionError: assert None == '5.0'
E        +  where None = average_label([5])

tests\test_reviews.py:9: AssertionError
1 failed, 1 passed in 0.04s

এবার লাল ঠিক কারণে: assertion, আর where লাইন বলছে কোড None দিয়েছে। সবুজের সবচেয়ে ছোট পথ fake it: যা চাওয়া, হুবহু তা-ই ফেরত দিন।

def average_label(stars):
    if not stars:
        return None
    return "5.0"

ফল: 2 passed in 0.01s. হাস্যকর কোড, কিন্তু উদ্দেশ্যমূলক। আমরা জানলাম test দুটি ঠিকভাবে লেখা, function-এর রূপ ঠিক, আর ফাঁকা তালিকার শাখা আলাদা। এখন "5.0" constant-টি একটি দায়: test আর কোডে একই মান দুবার, অর্থাৎ duplication, যা পরের চক্রে দূর হবে।

চক্র ৩ — triangulation: দ্বিতীয় উদাহরণ

$ uv run pytest -q
..F                                                                      [100%]
…
>       assert average_label([4, 5]) == "4.5"
E       AssertionError: assert '5.0' == '4.5'
E
E         - 4.5
E         + 5.0

tests\test_reviews.py:13: AssertionError
1 failed, 2 passed in 0.04s

লেখার তুলনায় pytest একটি ছোট diff দেখায়: - চাওয়া মান, + পাওয়া মান। Triangulation মানে দুটি ভিন্ন উদাহরণ দিয়ে কোডকে সাধারণ নিয়মে বাধ্য করা; এক উদাহরণে constant যথেষ্ট ছিল, দুটিতে আর নয়। সবুজ করতে প্রথম সাধারণ রূপ: return f"{sum(stars) / len(stars):.1f}". ফল: 3 passed in 0.01s.

চক্র ৪ — নতুন test প্রথমবারেই সবুজ

চতুর্থ item [4, 4, 5] → "4.3" লিখে চালালাম: 4 passed in 0.01s. কোনো লাল নেই! তিন সূত্র মানলে এটি সন্দেহজনক: test কি আদৌ কিছু ধরতে পারে? যাচাইয়ের উপায় হলো কোডে ইচ্ছা করে একটি ভুল বসানো, অর্থাৎ একটি mutant: :.1f ফরম্যাট মুছে দিলাম।

$ uv run pytest -q --tb=line
...F                                                                     [100%]
================================== FAILURES ===================================
E   AssertionError: assert '4.333333333333333' == '4.3'
…
FAILED tests/test_reviews.py::test_long_average_keeps_one_decimal - Assertion...
1 failed, 3 passed in 0.01s

শুধু নতুন test-টিই mutant ধরল; আগের তিনটির মান (৫.০, ৪.৫) ফরম্যাট ছাড়াও একই লেখা দেয়। অর্থাৎ test-টির নিজস্ব মূল্য আছে: এটিই “এক দশমিক” নিয়মটি পাহারা দেয়। Mutant সরিয়ে আবার সবুজ। এই কৌশল বড় আকারে mutation testing, পর্ব ৫৯ (Mutation testing — test-এর test, mutmut আর mutation score)-এ।

প্রথম চার চক্র ধাপে ধাপে দেখুন। “পরে” চাপুন:

প্রতিটি pytest run-এর পরে
রং
নতুন test
কোড
pytest
কৌশল
  1. চক্র ১, লাল। Test আছে, module নেই। pytest collection-এই থামে: 1 error, ModuleNotFoundError. এটিও লাল, তবে test চলেনি; তাই কারণটি পড়া জরুরি।
  2. চক্র ১, সবুজ। return None. সবচেয়ে ছোট কোড, আর প্রথম item সত্যিই এটুকুই চায়। 1 passed.
  3. চক্র ২, লাল। [5]-এ "5.0" চাই; কোড দিল None. এবার আসল assertion-এর ব্যর্থতা: 1 failed, 1 passed.
  4. চক্র ২, সবুজ (fake it). খালি তালিকায় None, নইলে constant "5.0". দুটি test পাস; constant-টি পরের চক্রের জন্য একটি খোলা দায়।
  5. চক্র ৩, লাল (triangulation). [4, 5] → "4.5"; fake দিল '5.0'. দ্বিতীয় উদাহরণ constant-কে আর টিকতে দেয় না।
  6. চক্র ৩, সবুজ। গড় আর :.1f ফরম্যাট। তিনটি test পাস, constant বিদায়।
  7. চক্র ৪, শুরুতেই সবুজ। [4, 4, 5] → "4.3" প্রথমবারেই পাস (৪টি)। ফরম্যাট মুছে mutant বানালে শুধু এই test লাল হলো, তাই এটি রাখার যোগ্য।

৪ · Triangulation গভীরে — ৪.২৫ যথেষ্ট নয়, চাই ৪.৩৫

চক্র ৫ — half up-এর সীমা

পঞ্চম item, ঠিক মাঝের মান: [4, 4, 5, 4], যোগফল ১৭, গড় ৪.২৫, চাই "4.3".

$ uv run pytest -q
....F                                                                    [100%]
…
>       assert average_label([4, 4, 5, 4]) == "4.3"
E       AssertionError: assert '4.2' == '4.3'
…
1 failed, 4 passed in 0.04s

Python-এর ফরম্যাট আর round দুটিই ঠিক মাঝের মানকে জোড় অঙ্কের দিকে নেয়: banker's rounding. AC5 ঠিক এটাই নিষেধ করেছে। এবার developer একটি পরিচিত সমাধান লিখলেন: Decimal-এ নিয়ে ROUND_HALF_UP.

from decimal import ROUND_HALF_UP, Decimal


def average_label(stars):
    if not stars:
        return None
    average = Decimal(sum(stars) / len(stars))
    return str(average.quantize(Decimal("0.1"), rounding=ROUND_HALF_UP))

ফল: 5 passed in 0.01s. সবুজ। Kata কি শেষ? Test list-এর মূল item সব পাস। কিন্তু refactor ধাপে কোড পড়তে গিয়ে একটি প্রশ্ন জাগে: sum(stars) / len(stars) একটি float, আর float অনেক দশমিক মান ঠিকঠাক রাখতে পারে না। ৪.২৫ binary-তে ঠিক প্রকাশ করা যায় (৪ + ¼), তাই পাস করেছে। যে মাঝের মান binary-তে ঠিক প্রকাশ করা যায় না, তার কী হবে? প্রশ্নটি test list-এ নতুন item হলো, Canon TDD-র ৩ নম্বর ধাপ মেনে।

চক্র ৬ — দ্বিতীয় সীমার উদাহরণ

২০টি review: ৭টি পাঁচ star, ১৩টি চার star; যোগফল ৮৭, গড় ঠিক ৪.৩৫, চাই "4.4".

$ uv run pytest -q
.....F                                                                   [100%]
…
        stars = [5] * 7 + [4] * 13          # 87 / 20 = 4.35 exactly
>       assert average_label(stars) == "4.4"
E       AssertionError: assert '4.3' == '4.4'
…
1 failed, 5 passed in 0.04s

ধরা পড়ল। 87 / 20-এর float আসলে ৪.৩৪৯৯৯৯৯৯৯৯৯৯৯৯৯৬৪…, ৪.৩৫-এর একটু কম; Decimal সেই ভুল মানটিই হুবহু নেয়, তাই half up-এর আগেই ক্ষতি হয়ে গেছে। সমাধান এক জায়গায়: ভাগটি float-এ নয়, Decimal-এ করা: Decimal(sum(stars)) / len(stars). ফল: 6 passed in 0.01s.

শিক্ষাটি tester-এর জন্য বড়। একটি সীমার উদাহরণে (৪.২৫) একটি ভুল সাধারণ সমাধানও পাস করেছিল। Triangulation শুধু constant তাড়ানোর কৌশল নয়; একই ধরনের দ্বিতীয় উদাহরণ নেওয়া, যা সমাধানের অনুমানকে অন্য দিক থেকে পরীক্ষা করে। নিচে পাঁচটি সম্ভাব্য কোড আর উদাহরণ বাড়ার সাথে কে টিকে থাকে:

✔ পাস · ✘ ব্যর্থ (কোডের ফল)
নতুন উদাহরণ
fake 5.0
f-string :.1f
round(x, 1)
Decimal(float)
Decimal exact
টিকে আছে
  1. এক উদাহরণ। [5] → "5.0". পাঁচটি সমাধানই পাস, এমনকি constant-ও। এক উদাহরণে নিয়ম আর ভান আলাদা করা যায় না।
  2. দুই উদাহরণ। [4, 5] → "4.5". Fake বাদ; বাকি চারটি গড় ঠিকই হিসাব করে। Kata-র চক্র ৩ এখানে।
  3. তিন উদাহরণ। ঠিক মাঝের ৪.২৫. f-string আর round দুটিই 4.2 দেয় (banker's rounding), বাদ। Decimal-এর দুই রূপই 4.3, টিকে গেল।
  4. চার উদাহরণ। ৮৭/২০ = ৪.৩৫. Float থেকে বানানো Decimal দেয় 4.3, কারণ float-টি ৪.৩৫-এর একটু নিচে। শুধু শুরু থেকেই Decimal-এ ভাগ করা সমাধান টেকে।

এবার নিজে চালান। কোডটি একই পাঁচ সমাধান আর চারটি উদাহরণ নেয়, তারপর উদাহরণের বাইরে যায়: ১ থেকে ২০০টি review-এর সব সম্ভাব্য (মোট star, review সংখ্যা) জোড়ায় প্রতিটি সমাধান সঠিক উত্তর থেকে কতবার আলাদা।

from decimal import Decimal, ROUND_HALF_UP

def half_up(d):                       # one decimal, 0.05 goes up
    return str(d.quantize(Decimal("0.1"), rounding=ROUND_HALF_UP))

CANDIDATES = {                        # t = star total, n = number of reviews
    "fake '5.0'":     lambda t, n: "5.0",
    "f'{x:.1f}'":     lambda t, n: f"{t / n:.1f}",
    "round(x, 1)":    lambda t, n: str(round(t / n, 1)),
    "Decimal(float)": lambda t, n: half_up(Decimal(t / n)),
    "Decimal exact":  lambda t, n: half_up(Decimal(t) / n),
}
EXAMPLES = [([5], "5.0"), ([4, 5], "4.5"), ([4, 4, 5, 4], "4.3"),
            ([5] * 7 + [4] * 13, "4.4")]          # 87 / 20 = 4.35

for k in range(1, len(EXAMPLES) + 1):
    alive = [name for name, f in CANDIDATES.items()
             if all(f(sum(s), len(s)) == want for s, want in EXAMPLES[:k])]
    print(f"{k} example(s): {len(alive)} left -> {', '.join(alive)}")

# Beyond the examples: every possible (t, n) with 1 to 200 reviews
pairs = [(t, n) for n in range(1, 201) for t in range(n, 5 * n + 1)]
exact = CANDIDATES["Decimal exact"]
for name in ["f'{x:.1f}'", "round(x, 1)", "Decimal(float)"]:
    bad = [p for p in pairs if CANDIDATES[name](*p) != exact(*p)]
    print(f"{name:15} wrong for {len(bad):4} of {len(pairs)} pairs, e.g. {bad[:2]}")

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

1 example(s): 5 left -> fake '5.0', f'{x:.1f}', round(x, 1), Decimal(float), Decimal exact
2 example(s): 4 left -> f'{x:.1f}', round(x, 1), Decimal(float), Decimal exact
3 example(s): 2 left -> Decimal(float), Decimal exact
4 example(s): 1 left -> Decimal exact
f'{x:.1f}'      wrong for  360 of 80600 pairs, e.g. [(5, 4), (9, 4)]
round(x, 1)     wrong for  360 of 80600 pairs, e.g. [(5, 4), (9, 4)]
Decimal(float)  wrong for  160 of 80600 pairs, e.g. [(23, 20), (29, 20)]

প্রথম চার লাইন stepper-এর সাথে হুবহু মেলে। পরের তিন লাইন বেশি গুরুত্বপূর্ণ। ৮০,৬০০টি সম্ভাব্য জোড়ার মধ্যে Decimal(float) ভুল মাত্র ১৬০টিতে, প্রায় ০.২%. এমন বিরল ভুল সাধারণ হাতে-বানানো test-এ প্রায় কখনো ধরা পড়ে না; ধরা পড়ে যখন আপনি জেনেবুঝে “binary-তে প্রকাশ করা যায় না এমন মাঝের মান” বেছে নেন। প্রথম ভুল জোড়া (২৩, ২০) মানে ২০টি review-এ মোট ২৩ star, গড় ১.১৫. সব জোড়া এভাবে যাচাই করা property-based testing-এর ভাবনার কাছাকাছি, যা পর্ব ৫৮ (Property-based testing — Hypothesis আর shrinking)-এ আসবে।

সবুজ মানে সঠিক নয়। চক্র ৫-এর শেষে সব test সবুজ ছিল, তবু কোড ভুল ছিল। TDD-র সবুজ শুধু বলে “যেসব উদাহরণ লিখেছেন, সেগুলো পাস”। কোন উদাহরণ লিখবেন, সেই দক্ষতা test design-এর: সীমা, বিশেষ মান, আর প্রতিটি সমাধানের লুকানো অনুমান ভাঙার মতো input.

৫ · Refactor, শেষ চক্র আর ছোট রূপান্তরের ক্রম

Refactoring মানে বাইরের আচরণ না বদলে ভেতরের কাঠামো উন্নত করা। TDD-তে এটি আলাদা ধাপ, আর শুধু কোডের নয়, test-এরও। ছয়টি প্রায় একই রকম test function এখন একটি টেবিলের মতো পড়া উচিত, তাই পর্ব ২১-এর parametrize; কোডে নামহীন Decimal("0.1")-এর বদলে নামসহ constant আর docstring:

@pytest.mark.parametrize(("stars", "label"), [
    pytest.param([5], "5.0", id="one-review"),
    pytest.param([4, 5], "4.5", id="two-reviews"),
    pytest.param([4, 4, 5], "4.3", id="long-decimal"),
    pytest.param([4, 4, 5, 4], "4.3", id="half-up-4.25"),
    pytest.param([5] * 7 + [4] * 13, "4.4", id="half-up-4.35"),
])
def test_average_label(stars, label):
    assert average_label(stars) == label
$ uv run pytest -v
platform win32 -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0
…
collecting ... collected 6 items

tests/test_reviews.py::test_no_reviews_gives_no_label PASSED             [ 16%]
tests/test_reviews.py::test_average_label[one-review] PASSED             [ 33%]
tests/test_reviews.py::test_average_label[two-reviews] PASSED            [ 50%]
tests/test_reviews.py::test_average_label[long-decimal] PASSED           [ 66%]
tests/test_reviews.py::test_average_label[half-up-4.25] PASSED           [ 83%]
tests/test_reviews.py::test_average_label[half-up-4.35] PASSED           [100%]

============================== 6 passed in 0.01s ==============================

Refactor-এর নিয়ম: আগে ছয়টি test, পরেও ছয়টি, সব সবুজ। সংখ্যা মেলানো জরুরি, কারণ refactor-এর সময় একটি test হারিয়ে গেলে কেউ টের পায় না। এবার শেষ item, AC2: star ১–৫-এর বাইরে হলে ValueError. লাল:

$ uv run pytest -q
......FF                                                                 [100%]
___________________ test_star_outside_1_to_5_is_rejected[0] ___________________

bad = 0

    @pytest.mark.parametrize("bad", [0, 6])
    def test_star_outside_1_to_5_is_rejected(bad):
>       with pytest.raises(ValueError, match="1-5"):
E       Failed: DID NOT RAISE ValueError
…
2 failed, 6 passed in 0.04s

তৃতীয় ধরনের লাল: assertion নয়, pytest.raises-এর “DID NOT RAISE”. সবুজের জন্য এক শর্ত যোগ হলো, আর শেষ run:

"""AC5: average star rating shown to one decimal, half up."""
from decimal import ROUND_HALF_UP, Decimal

ONE_DECIMAL = Decimal("0.1")


def average_label(stars):
    """'4.3' for [4, 4, 5, 4]; None when there are no reviews yet."""
    if not stars:
        return None
    if any(s not in range(1, 6) for s in stars):
        raise ValueError("star must be a whole number 1-5")
    average = Decimal(sum(stars)) / len(stars)   # exact, no float
    return str(average.quantize(ONE_DECIMAL, rounding=ROUND_HALF_UP))
$ uv run pytest -q
........                                                                 [100%]
8 passed in 0.01s

মোট ১৬টি pytest run: ছয়টি লাল (একটি mutant-যাচাইসহ), দশটি সবুজ। এখন পুরো kata-টি এই পাতায় আবার চালিয়ে দেখুন। কোডটি প্রতিটি commit-আকারের ধাপে কোড আর test ফাইল নতুন করে লেখে, তারপর Pyodide-এর ভেতরের pytest চালায়; প্রতিটি ধাপের রং আর ব্যর্থতার প্রথম E লাইন আসল ফল।

import os, sys, io, contextlib, importlib, pytest
sys.dont_write_bytecode = True; os.makedirs("/home/pyodide/k27", exist_ok=True)
os.chdir("/home/pyodide/k27"); sys.path.insert(0, os.getcwd())
TESTS = ['def test_none(): assert average_label([]) is None',
         'def test_one(): assert average_label([5]) == "5.0"',
         'def test_two(): assert average_label([4, 5]) == "4.5"',
         'def test_half(): assert average_label([4, 4, 5, 4]) == "4.3"']
CODE = {"-": None, "none": 'return None',
        "fake": 'return None if not s else "5.0"',
        "fstr": 'return None if not s else f"{sum(s) / len(s):.1f}"',
        "exact": 'return None if not s else str((Decimal(sum(s)) / len(s))'
                 '.quantize(Decimal("0.1"), ROUND_HALF_UP))'}
STEPS = [(1, "-"), (1, "none"), (2, "none"), (2, "fake"), (3, "fake"),
         (3, "fstr"), (4, "fstr"), (4, "exact")]     # (tests so far, code)

class Log(list):                  # first "E" line of every failure
    def pytest_runtest_logreport(self, report):
        if report.failed:
            e = [l for l in report.longreprtext.splitlines() if l.startswith("E ")]
            self.append(f"   {report.head_line}: {e[0][1:].strip()}")
    pytest_collectreport = pytest_runtest_logreport; __hash__ = object.__hash__

for n, (k, code) in enumerate(STEPS, 1):
    body = CODE[code]
    if body is None and os.path.exists("rev27.py"): os.remove("rev27.py")
    if body: open("rev27.py", "w").write("from decimal import Decimal, "
              f"ROUND_HALF_UP\ndef average_label(s):\n    {body}\n")
    open("test_k27.py", "w").write("from rev27 import average_label\n"
                                   + "\n".join(TESTS[:k]) + "\n")
    for m in ("rev27", "test_k27"): sys.modules.pop(m, None)
    importlib.invalidate_caches(); log = Log()
    with contextlib.redirect_stdout(io.StringIO()):
        rc = pytest.main(["-q", "-p", "no:cacheprovider", "test_k27.py"], plugins=[log])
    print(f"step {n}: {k} test(s), code={code:5} -> {'GREEN' if rc == 0 else 'RED'}",
          *log, sep="\n")

আসল আউটপুট (Pyodide-এর pytest):

step 1: 1 test(s), code=-     -> RED
   test_k27.py: ModuleNotFoundError: No module named 'rev27'
step 2: 1 test(s), code=none  -> GREEN
step 3: 2 test(s), code=none  -> RED
   test_one: AssertionError: assert None == '5.0'
step 4: 2 test(s), code=fake  -> GREEN
step 5: 3 test(s), code=fake  -> RED
   test_two: AssertionError: assert '5.0' == '4.5'
step 6: 3 test(s), code=fstr  -> GREEN
step 7: 4 test(s), code=fstr  -> RED
   test_half: AssertionError: assert '4.2' == '4.3'
step 8: 4 test(s), code=exact -> GREEN

রং পর্যায়ক্রমে বদলায়: লাল, সবুজ, লাল, সবুজ। এটিই সুস্থ TDD-র ছন্দ; দুটি লাল পরপর এলে বুঝবেন ধাপ বড় হয়ে গেছে। ব্যর্থতার বার্তা ডেস্কটপের সাথে মেলে: প্রথম ধাপে module নেই, পরে None == '5.0', '5.0' == '4.5', '4.2' == '4.3'. ধাপ ৭-৮-এ সংক্ষেপের জন্য সরাসরি সঠিক Decimal রূপে যাওয়া হয়েছে; ডেস্কটপের মাঝের ভুল ধাপটি (Decimal(float)) আপনি নিজে যোগ করে দেখতে পারেন: CODE-এ একটি রূপ আর TESTS-এ ৪.৩৫-এর test.

কোডের Log class একটি ছোট pytest plugin: pytest প্রতিটি test শেষে pytest_runtest_logreport hook ডাকে, আর import-এর ব্যর্থতায় pytest_collectreport; দুটিতেই আমরা রিপোর্টের প্রথম E লাইন তুলে রাখি। pytest plugin-গুলো একটি set-এ রাখে, তাই list থেকে বানানো class-এ __hash__ ফিরিয়ে দিতে হয়েছে; ওই লাইন বাদ দিলে Pyodide-এর pytest 9.0.2 “unhashable type” INTERNALERROR দেয়।

পেছনে তাকিয়ে — transformation priority premise

প্রতিটি সবুজে কোড একটু একটু সাধারণ হয়েছে। Robert C. Martin ২০১৩ সালের দিকে এই ছোট বদলগুলোর নাম দেন transformation, আর প্রস্তাব করেন (তাঁর ভাষায় একটি “premise”, প্রমাণিত সূত্র নয়) যে সরল রূপান্তরকে জটিলটির আগে নিলে TDD-তে কম আটকাতে হয়। এই ধারণার নাম transformation priority premise (TPP). তাঁর তালিকায় এক ডজনের মতো রূপান্তর আছে; আমাদের kata-তে যেগুলো ঘটেছে:

চক্ররূপান্তর (TPP-র নাম)কোডে কী বদলাল
১{} → nilকিছু নেই থেকে return None
২nil → constant; unconditional → if"5.0", আর খালি তালিকার শাখা
৩constant → scalar/expressionconstant-এর জায়গায় input থেকে হিসাব
৫–৬expression → functionসরল ফরম্যাটের জায়গায় Decimal-এর গোল করার algorithm
শেষunconditional → ifAC2-এর যাচাই

ব্যবহারিক মানে সহজ: সবুজে যাওয়ার কয়েকটি পথ থাকলে যেটি সবচেয়ে কম বদল চায়, সেটি নিন। একেই বলে baby steps. আর পথ পরিষ্কার জানা থাকলে সরাসরি আসল কোড লিখুন, Beck-এর ভাষায় obvious implementation; AC2-এর শর্তটি এভাবেই এক ধাপে লেখা হয়েছে। অপ্রত্যাশিত লাল এলে গিয়ার নামান: ধাপ ছোট করুন, প্রয়োজনে আবার fake it.

৬ · Classic (Detroit) বনাম mockist (London) — একই unit, দুই রকম test

এবার এমন কোড, যার একজন collaborator আছে: পণ্যের পাতা review-এর সংখ্যা চায় একটি store থেকে, যা আসলে database. দুটি ধারা এই test দুইভাবে লেখে। নামগুলো আনুষ্ঠানিক নয়; Martin Fowler “Mocks Aren't Stubs” লেখায় (২০০৪, পরে ২০০৭-এ হালনাগাদ) দলগুলোকে classicist আর mockist বলেন।

দিকClassic (Detroit)Mockist (London)
Collaboratorসম্ভব হলে আসল বা হালকা fake objectপ্রায় সবসময় mock
কী যাচাইফল আর অবস্থা (state verification)কাকে কী বলা হলো (behavior verification)
সাধারণ শুরুভেতরের domain থেকে বাইরেবাইরের acceptance test থেকে ভেতরে
ঝুঁকিএকটি bug অনেক test লাল করে; কারণ খুঁজতে হয়Test implementation-এ বাঁধা; refactor-এ ভাঙে

“Detroit” নামটি সাধারণত Chrysler-এর C3 প্রকল্পের সাথে যুক্ত বলা হয়, যেখানে Extreme Programming-এর প্রথম দিকের চর্চা হয়েছিল; “London” নাম এসেছে লন্ডনের XP সম্প্রদায় থেকে, যেখান থেকে mock object-এর ধারণা প্রকাশিত হয় (XP2000 সম্মেলনের “Endo-Testing” লেখা)। দুটি ধারার ফল এই পাতাতেই তুলনা করুন। একই review_count-এর তিনটি রূপ: v1 সাধারণ, v2 একটি refactor (store-এর batch method ব্যবহার; আচরণ একই), v3 একটি ভুল (store-কে দুবার জিজ্ঞাসা, অর্থাৎ database-এ দুটি query).

import os, sys, io, contextlib, importlib, pytest
os.makedirs("/home/pyodide/s27", exist_ok=True); os.chdir("/home/pyodide/s27")
open("store27.py", "w").write('''class ReviewStore(dict):      # in-memory, like the DB
    def add(self, pid, stars): self.setdefault(pid, []).append(stars)
    def stars_for(self, pid): return list(self.get(pid, []))
    def stars_for_many(self, ids): return {p: self.stars_for(p) for p in ids}
''')
open("test_styles.py", "w").write('''from unittest.mock import Mock
from store27 import ReviewStore; from page27 import review_count
def test_classic():               # Detroit: real object, check the result
    store = ReviewStore()
    for s in (4, 5, 3): store.add("P-17", s)
    assert review_count("P-17", store) == 3
def test_mockist():               # London: mock, check the conversation
    store = Mock()
    store.stars_for.return_value = [4, 5, 3]
    assert review_count("P-17", store) == 3
    store.stars_for.assert_called_once_with("P-17")
''')
VERSIONS = {"v1 one call": "len(store.stars_for(p))",
            "v2 refactor, batch": "len(store.stars_for_many([p])[p])",
            "v3 slip, asks twice": "len(store.stars_for(p) and store.stars_for(p))"}
class Log(list):
    __hash__ = object.__hash__                # pytest stores plugins in a set
    def pytest_runtest_logreport(self, report):
        if report.when == "call":
            why = report.longrepr.reprcrash.message.split("\n")[0] if report.failed else ""
            self.append(f"  {report.head_line:13} {report.outcome.upper():7} {why}")
for label, expr in VERSIONS.items():
    open("page27.py", "w").write(f"def review_count(p, store):\n    return {expr}\n")
    for m in ("page27", "test_styles"): sys.modules.pop(m, None)
    importlib.invalidate_caches(); log = Log()
    with contextlib.redirect_stdout(io.StringIO()):
        pytest.main(["-q", "-p", "no:cacheprovider", "test_styles.py"], plugins=[log])
    print(label, *log, sep="\n")

আসল আউটপুট:

v1 one call
  test_classic  PASSED
  test_mockist  PASSED
v2 refactor, batch
  test_classic  PASSED
  test_mockist  FAILED  TypeError: 'Mock' object is not subscriptable
v3 slip, asks twice
  test_classic  PASSED
  test_mockist  FAILED  AssertionError: Expected 'stars_for' to be called once. Called 2 times.

v2: আচরণ একই, তবু mockist test লাল, কারণ Mock-কে stars_for_many-এর উত্তর শেখানো হয়নি। এটি মিথ্যা সতর্কবার্তা (false alarm); এমন test refactor-এ বাধা দেয়, আর পর্ব ২২-এর ভাষায় এটি fragile test. v3: উল্টো ছবি। ফল একই (৩), তাই classic test সবুজ; কিন্তু database-এ দুটি query যাচ্ছে, যা ধীর পাতার কারণ হতে পারে। শুধু mockist test এটি ধরল। সিদ্ধান্তের নিয়মটি তাই এমন: “কতবার ডাকা হলো” যদি নিজেই একটি requirement হয় (query-র সংখ্যা, SMS একবারই যাওয়া, payment একবারই কাটা), তবে interaction যাচাই করুন; নইলে ফল যাচাই করুন। বাজারঘরের mobile-wallet-এর ক্ষেত্রে “টাকা একবারই কাটা” ঠিক এমন requirement, তাই পর্ব ২৪-এ সেখানে mock ব্যবহার হয়েছে।

৭ · Outside-in — আগে acceptance test, তারপর ভেতরের চক্র

Kata-টি ছিল inside-out: একটি বিশুদ্ধ হিসাব, কোনো collaborator নেই। বাস্তব feature শুরু হয় ব্যবহারকারীর দিক থেকে: “পণ্যের পাতায় গ্রাহক গড় rating আর review-এর সংখ্যা দেখবেন”। Outside-in TDD এখান থেকে শুরু করে। প্রথমে একটি acceptance test, যা পুরো feature-কে বাইরে থেকে যাচাই করে আর শুরুতে লাল থাকে। তারপর তাকে সবুজ করতে ভেতরে অনেকগুলো ছোট unit-test চক্র। Steve Freeman আর Nat Pryce-এর Growing Object-Oriented Software, Guided by Tests (২০০৯) বইয়ে এই রূপটির নাম double loop. দল মিলে acceptance criteria থেকে acceptance test লেখার চর্চা ATDD, আর Given-When-Then-এ লেখা রূপ আসবে পর্ব ৪৩ (BDD আর Gherkin — Given-When-Then আর pytest-bdd)-এ।

Double loop — বাইরে acceptance, ভেতরে unit

Outer loop: one failing acceptance test · Inner loop: many red-green-refactor cycles

Double loop TDD: বাইরে acceptance test, ভেতরে unit-এর red-green-refactor বাইরের চক্র · acceptance ১ · ব্যর্থ acceptance test (লাল) ২ · ভেতরের চক্র · unit test লাল red সবুজ green গোছানো refactor বাইরেরটি লাল? আবার ২ ৩ · acceptance সবুজ → পরের story
ছবি ২৭.১ — ভেতরের চক্র কয়েক মিনিটের, বাইরেরটি কয়েক ঘণ্টা বা দিনের। বাইরের test লাল থাকা মানে “feature এখনো শেষ হয়নি”, ব্যর্থতা নয়; তাই অনেক দল এটি দ্রুত suite থেকে আলাদা রাখে।

বাজারঘরে সত্যিকারের run, kata-র একই প্রকল্পে। Acceptance test-এ একটি in-memory store, যা আসল database-এর জায়গা নেয়:

from bazarghar.product_page import product_page
from bazarghar.review_store import InMemoryReviewStore


def test_customer_sees_average_and_count_on_product_page():
    store = InMemoryReviewStore()
    for stars in (4, 4, 5, 4):
        store.add("P-17", stars)
    store.add("P-99", 1)                    # another product
    assert product_page("P-17", store) == {
        "product": "P-17", "average": "4.3", "reviews": 4}

এরপর ভেতরের চক্রে product_page-এর unit test (mockist, কারণ store এখনো নেই আর তার interface আমরা এখনই ঠিক করছি) আর store-এর নিজের unit test (classic). সাতটি run ধাপে ধাপে:

  1. Acceptanceproduct pageবাইরের চক্র
  2. Unitproduct_pagemock store
  3. Unitstoreআবিষ্কৃত
  4. সব সবুজ11 passedপরের story
বাইরে লালpytest tests/acceptance
E ModuleNotFoundError:
  No module named
  'bazarghar.product_page'
1 error in 0.08s
ভেতরে লালpytest tests/unit
store = Mock()
store.stars_for.return_value
  = [4, 5]
…
E ModuleNotFoundError: No module
  named 'bazarghar.product_page'
1 error in 0.11s
ভেতরে সবুজpytest tests/unit
stars = store.stars_for(product_id)
return {"product": …,
  "average": average_label(stars),
  "reviews": len(stars)}
1 passed in 0.04s
বাইরে এখনো লালনতুন কারণ
test_…_acceptance.py:2
E ModuleNotFoundError:
  No module named
  'bazarghar.review_store'
1 error in 0.10s
ভেতরে লালstore-এর test
store.add("P-17", 4)
store.add("P-99", 1)
store.add("P-17", 5)
assert store.stars_for("P-17")
  == [4, 5]
E ModuleNotFoundError … review_store
1 error in 0.12s
ভেতরে সবুজpytest tests/unit
class InMemoryReviewStore:
  add(product_id, stars)
  stars_for(product_id)
2 passed in 0.04s
বাইরে সবুজpytest -v
…acceptance.py::test_customer_
  sees_average_… PASSED
… (kata-র ৮টি PASSED)
…test_page_asks_store_… PASSED
…test_store_keeps_stars_… PASSED
11 passed in 0.06s
  1. বাইরের লাল। Acceptance test লেখা হলো ব্যবহারকারীর ভাষায়: পাতায় পণ্য, গড় ৪.৩ আর ৪টি review; অন্য পণ্যের ১ star যেন না মেশে। কিছুই নেই, তাই প্রথম import-এই error.
  2. ভেতরের লাল। product_page-এর unit test. Store এখনো নেই, তাই Mock; test-এর ভেতরেই ঠিক হলো store-এর কাছে কী চাইব: stars_for(product_id). Interface আবিষ্কার এভাবেই হয়।
  3. ভেতরের সবুজ। তিন লাইনের product_page; kata-র average_label পুনরায় ব্যবহার হলো। Unit test সবুজ, assert_called_once_with("P-17")-সহ।
  4. বাইরে এখনো লাল, তবে এগিয়েছে। এবার error-টি review_store-এ, দ্বিতীয় লাইনে। বাইরের test-এর লাল বদলে যাওয়াই অগ্রগতির চিহ্ন: আগের কারণ মিটেছে, নতুন কারণ সামনে।
  5. ভেতরে store-এর লাল। Store-এর classic test: আসল object, ফল যাচাই। এখানে mock নেই, কারণ store-ই এই test-এর বিষয়।
  6. ভেতরে store-এর সবুজ। defaultdict-ভিত্তিক ছোট class, ঠিক সেই দুটি method যা ধাপ ২-এর mock চেয়েছিল। 2 passed.
  7. বাইরে সবুজ। পুরো suite: acceptance ১টি, kata-র ৮টি, নতুন unit ২টি, মোট ১১টি পাস। Story শেষ; এবার refactor, তারপর পরের story-র acceptance test.

একটি সূক্ষ্ম দিক লক্ষ করুন: ধাপ ২-এর mock আর ধাপ ৬-এর আসল store-এর method একই নামের, কারণ দুটিই একই আলোচনা থেকে এসেছে। পরে কেউ store-এর method-এর নাম বদলালে আর mock না বদলালে, unit test সবুজ থাকবে অথচ আসল কোড ভাঙবে: পর্ব ২৪-এর mock drift. এখানে acceptance test সেই ফাঁক পাহারা দেয়, কারণ সে আসল store দিয়ে চলে। Outside-in-এ বাইরের test শুধু শুরুর দিকনির্দেশ নয়, পরে নিরাপত্তা জালও।

ব্যবহারিক একটি প্রশ্ন: feature শেষ হতে তিন দিন লাগলে, এই তিন দিন acceptance test লাল থাকবে; তাহলে CI কি তিন দিন লাল? প্রচলিত সমাধান দুটি। এক, acceptance test আলাদা ফোল্ডারে (tests/acceptance) রেখে চলমান story-র test-কে CI-র gate থেকে আলাদা রাখা, যতক্ষণ না সেটি সবুজ হয়। দুই, পর্ব ২১-এর xfail(strict=True) দিয়ে “এখনো তৈরি হয়নি” চিহ্নিত করা; সবুজ হওয়ার দিন strict xfail নিজেই FAILED হয়ে মনে করিয়ে দেয় marker সরাতে। দুই পথেই নিয়ম একটি: শেষ হওয়া story-র acceptance test সবসময় gate-এর ভেতরে।

৮ · কখন TDD, কখন নয় — প্রমাণ, bug fix আর পুরোনো কোড

প্রমাণ মিশ্র

সবচেয়ে উদ্ধৃত শিল্প-গবেষণাগুলোর একটি Nagappan, Maximilien, Bhat আর Williams-এর (Empirical Software Engineering, ২০০৮): IBM আর Microsoft-এর চারটি দলের case study. লেখকদের রিপোর্ট অনুযায়ী release-এর আগের defect density উল্লেখযোগ্যভাবে কমেছিল (তাঁদের হিসাবে ৪০% থেকে ৯০%), আর প্রাথমিক উন্নয়ন-সময় বেড়েছিল মোটামুটি ১৫% থেকে ৩৫%. কিন্তু case study নিয়ন্ত্রিত পরীক্ষা নয়। নিয়ন্ত্রিত পরীক্ষার meta-analysis (যেমন Rafique ও Mišić, IEEE TSE, ২০১৩) মানে ছোট উন্নতি আর productivity-তে অস্পষ্ট ফল পেয়েছে। Fucci ও সহকর্মীদের একটি গবেষণা (IEEE TSE, ২০১৭) ইঙ্গিত দেয়, লাভের বড় অংশ হয়তো ছোট আর সমান মাপের ধাপ থেকে আসে, test আগে না পরে লেখা হলো তা থেকে নয়। সৎ উপসংহার: TDD কাজে লাগতে পারে, তবে কতটা, তা দল আর কাজের ধরনের ওপর নির্ভর করে।

ভালো খাটেকম খাটে বা অন্য পথে
নিয়ম আর হিসাব: coupon, delivery, rating-এর গড়অজানা library শেখা: আগে spike, পরে TDD-তে নতুন করে
Bug fix: আগে bug-টি ধরে এমন লাল testUI-র চেহারা আর বিন্যাস খোঁজা
অন্যরা ব্যবহার করবে এমন APIকয়েক দিনে ফেলে দেওয়ার prototype
পুরোনো কোড বদলানো: আগে characterization testশুধু মাপজোকের কাজ (performance tuning)

Bug fix-এ TDD tester-এর সবচেয়ে কাছের অভ্যাস। বাজারঘরের BUG-142 (৪.২৫ থেকে ৪.২) রিপোর্ট হলে প্রথম কাজ: রিপোর্টের উদাহরণটি একটি লাল test-এ বদলানো। লাল দেখা প্রমাণ করে আপনি bug-টি সত্যিই পুনরুৎপাদন করেছেন; সবুজ হলে fix প্রমাণিত; আর test-টি থেকে যায় স্থায়ী regression test হিসেবে। পুরোনো, test-হীন কোডে আগে বর্তমান আচরণ লক করার কৌশল আসবে পর্ব ২৫ (Testable code — dependency injection, seam আর legacy code)-এ।

TDD-র সাধারণ ভুল — tester-এর চোখে

ভুললক্ষণএই পর্বে কোথায় দেখলেন
লাল কখনো দেখা হয়নিকোড আর test একই commit-এ; test ব্যর্থ হতে পারে কি না অজানাচক্র ৪: mutant দিয়ে যাচাই
Expected কোড থেকে নকলtest ভুল কোডেও সবুজঅনুশীলন ৩
বড় ধাপপরপর দুটি লাল run, অনেক লাইন একসাথে বদলReplay-এর ব্যাখ্যায়, §৫
সবুজকে সঠিক ভাবাসীমার দ্বিতীয় উদাহরণ নেইচক্র ৫-এর Decimal(float)
সব জায়গায় mockrefactor করলেই test ভাঙে§৬-এর v2
Refactor বাদপ্রায় একই রকম অনেক test function, নামহীন সংখ্যা§৫-এর parametrize

আরও গভীরে: TDD নিয়ে সবচেয়ে আলোচিত বিতর্কগুলোর একটি ২০১৪ সালের: David Heinemeier Hansson “TDD is dead. Long live testing.” লেখায় বলেন, test-এর খাতিরে কোডে অপ্রয়োজনীয় স্তর আর mock ঢোকে (তিনি নাম দেন “test-induced design damage”); এরপর তিনি, Kent Beck আর Martin Fowler “Is TDD dead?” নামে কয়েকটি আলোচনা করেন। মোটামুটি মিলনবিন্দু ছিল: ছোট ধাপ আর দ্রুত feedback মূল্যবান, কিন্তু অতিরিক্ত mock আর শুধু test-এর জন্য নকশা ক্ষতিকর। একাডেমিক দিকে, test-first-এর প্রভাব আলাদা করে মাপা কঠিন, কারণ অংশগ্রহণকারী প্রায়ই ছাত্র, কাজ ছোট, আর দক্ষতার পার্থক্য বড়।

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

  • TDD-র চক্র আর তিন সূত্র? Red, green, refactor; ব্যর্থ test ছাড়া production কোড নয়, ব্যর্থতার জন্য যতটুকু দরকার তার বেশি test নয়, পাস করানোর জন্য যতটুকু দরকার তার বেশি কোড নয়।
  • Fake it আর triangulation? Fake it প্রত্যাশিত মান হুবহু ফেরত দিয়ে দ্রুত সবুজ; triangulation দ্বিতীয় ভিন্ন উদাহরণ দিয়ে সাধারণ নিয়মে বাধ্য করে।
  • নতুন test প্রথমবারেই সবুজ হলে কী করবেন? কোডে একটি ছোট ভুল বসিয়ে দেখুন test লাল হয় কি না; না হলে test কিছুই যাচাই করছে না।
  • Classic আর mockist-এর পার্থক্য? Classic আসল object দিয়ে ফল যাচাই করে; mockist mock দিয়ে ডাক যাচাই করে, তাই refactor-এ বেশি ভাঙে।
  • Outside-in-এ double loop? বাইরে একটি ব্যর্থ acceptance test, ভেতরে অনেক unit-চক্র; বাইরেরটি সবুজ হলে story শেষ।

৯ · AI-এর যুগে TDD

AI সহকারীর সাথে TDD-র সম্পর্ক দুই দিকে। ভালো দিক: আপনার লেখা test একটি পরিষ্কার নির্দেশ, যা AI-এর লেখা কোড যাচাই করে। ঝুঁকির দিক: AI প্রায়ই কোড আর test একসাথে লেখে, ফলে লাল ধাপটি কখনো ঘটে না; কোডের বর্তমান আচরণ নকল করে expected লেখে (round-এর কোড দেখে লিখবে "4.2"); সীমার মান বাদ দেয় (৪.২৫, ৪.৩৫, ০ আর ৬ star); test সবুজ করতে test-টিই বদলে দেয় বা মুছে ফেলে; অপ্রয়োজনীয় mock বসায়; আর না চালিয়েই “সব test পাস” লেখে। AI agent যখন নিজে test চালিয়ে কোড বদলায়, তখন সবচেয়ে জরুরি নিয়ম: test ফাইল বদলানো আলাদা, review করা ধাপ।

AI-কে TDD-র সঙ্গী বানান, এক ধাপে এক item:

তুমি আমার TDD সঙ্গী। আমরা বাজারঘরের গড় rating-এর নিয়ম বানাচ্ছি: এক দশমিক, half up (৪.২৫ → ৪.৩), review না থাকলে None, star ১–৫-এর বাইরে হলে ValueError. নিয়ম: ১. প্রথমে শুধু একটি test list দাও, ক্রমসহ, প্রতিটি item-এর কারণ লেখো। কোড নয়। ২. আমি একটি item বেছে নেব। তুমি শুধু সেই একটি pytest test লিখবে। Expected মান নিয়ম থেকে হিসাব করবে, কোড থেকে নয়। ৩. আমি test চালিয়ে লাল আউটপুট পেস্ট করব। তুমি তখন সবুজ করার ন্যূনতম কোড দেবে; আগের কোনো test বদলাবে না। ৪. Float-এর মান binary-তে ঠিক প্রকাশ করা যায় না এমন একটি মাঝের মান (যেমন ৪.৩৫) test list-এ আছে কি না, নিজে যাচাই করো। ৫. তুমি কোড চালাতে পারো না; তাই "সব পাস" লিখবে না।

AI-এর সাথে TDD — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১পুরো test list একবারে test-এ বদলে তারপর একে একে পাস করানো Beck কেন ভুল বলেন?

শুনতে দক্ষ মনে হয়: সব test আগে লিখে ফেললাম, এখন শুধু কোড। কিন্তু TDD-র মূল সম্পদ হলো প্রতিটি চক্রে শেখা। আমাদের kata-তে চক্র ৫-এর পরে কোড পড়তে গিয়ে প্রশ্ন জাগল, ৪.২৫ binary-তে ঠিক প্রকাশ করা যায় বলেই কি পাস করল? সেই প্রশ্ন থেকে ৪.৩৫-এর test এলো, যা শুরুর তালিকায় ছিল না। সব test আগে লিখে ফেললে এমন আবিষ্কারের জায়গা থাকে না, কারণ মাথা তখন “লাল থেকে সবুজ” গোনায় ব্যস্ত।

দ্বিতীয় ক্ষতি নকশায়। প্রথম test লেখার সময় আমরা ঠিক করেছি function লেখা ফেরত দেবে, float নয়। ছয়টি test আগে লেখা থাকলে আর এই সিদ্ধান্ত বদলানো কঠিন, কারণ ছয়টি জায়গায় বদলাতে হবে; ফলে প্রথম ভুল সিদ্ধান্ত টিকে যায়। Canon TDD-তে প্রতিটি ধাপে একটি item test-এ বদলায়, তাই interface নিয়ে ভুল ধারণা প্রথম এক-দুই test-এই ধরা পড়ে।

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

Tester-এর জন্য এর মানে: test list কাগজে বড় হোক, কিন্তু কোডে test আসুক একটি একটি করে। Test case লেখার কাজে (পর্ব ১৬) পুরো তালিকা আগে বানানো ঠিক; automation-এ TDD করার সময় তালিকা আর test-এর মধ্যে এই ফাঁক রাখাই উদ্দেশ্য।

মূল উপলব্ধি: Test list পরিকল্পনা, test কোড শেখার ধাপ। একসাথে সব লিখলে পরিকল্পনা থাকে, শেখা হারায়।

প্র ০২২০১৪ সালের “Is TDD dead?” বিতর্ক থেকে একজন QA engineer কী শিখবেন?

২০১৪ সালে Ruby on Rails-এর স্রষ্টা David Heinemeier Hansson একটি বক্তৃতা আর “TDD is dead. Long live testing.” লেখায় বলেন, কঠোর test-first তাঁর অভিজ্ঞতায় নকশার ক্ষতি করেছে। তাঁর উদাহরণ ছিল: শুধু unit test দ্রুত চালানোর জন্য database আলাদা করতে স্তরের পর স্তর, আর সবখানে mock; তিনি এর নাম দেন “test-induced design damage”. এরপর তিনি, Kent Beck আর Martin Fowler কয়েকটি আলোচনায় বিষয়টি নিয়ে খোলাখুলি কথা বলেন, যা “Is TDD dead?” নামে পরিচিত।

আলোচনার মিলের জায়গাগুলো tester-এর জন্য শিক্ষণীয়। প্রথমত, দ্রুত আর নির্ভরযোগ্য feedback সবাই চান; মতভেদ শুধু কীভাবে পাওয়া যায় তা নিয়ে। দ্বিতীয়ত, অতিরিক্ত mock সত্যিই ক্ষতি করে: এই পর্বের v2-এ দেখেছেন, আচরণ না বদলেও mock-ভিত্তিক test ভাঙে। Beck নিজেও বলেছেন তিনি খুব কমই mock ব্যবহার করেন। তৃতীয়ত, সব কাজে একই পদ্ধতি খাটে না; UI-র চেহারা বা অজানা প্রযুক্তিতে TDD-র লাভ কম।

QA-র ভাষায় বিতর্কটি আসলে test-এর স্তর বাছাই নিয়ে। শুধু unit test দিয়ে সব যাচাই করতে চাইলে নকশায় চাপ পড়ে; integration আর acceptance test-কে জায়গা দিলে unit স্তরে এত mock লাগে না। আমাদের outside-in উদাহরণে acceptance test আসল in-memory store দিয়ে চলে, তাই unit-এর mock-এর ভুল সেখানে ধরা পড়ে। Test pyramid-এর আলোচনা (পর্ব ০৫) এখানে কাজে লাগে।

আরেকটি শিক্ষা আলোচনার ধরন থেকে। তিনজন অভিজ্ঞ মানুষ প্রকাশ্যে দ্বিমত করেছেন, উদাহরণ দিয়ে, আর একে অপরের যুক্তি মেনে নিয়েছেন যেখানে মিলেছে। দলের ভেতরে “TDD বাধ্যতামূলক কি না” নিয়ে তর্কে এই ধরন কাজে লাগে: মত নয়, উদাহরণ আর মাপ।

মূল উপলব্ধি: TDD মৃত নয়, একমাত্রও নয়। ছোট ধাপ আর দ্রুত feedback রাখুন; mock আর স্তর যোগ করুন শুধু যেখানে লাভ স্পষ্ট।

প্র ০৩Kata-র ৪.৩৫-এর উদাহরণ কেন একটি boundary value, যদিও সংখ্যারেখায় এটি কোনো সীমা নয়?

পর্ব ০৮-এ boundary value মানে ছিল partition-এর কিনারা: coupon-এ ১০০০ আর ১০০১. সেখানে সীমা নিয়ম থেকে আসে। গোল করার নিয়মেও এমন সীমা আছে: প্রতিটি x.x৫, যেখানে ফল এক ঘর ওপরে বা নিচে যায়। AC5-এর জন্য প্রতিটি ঠিক মাঝের মান একটি সীমা, আর ৪.২৫ সেই ভাবনা থেকেই test list-এ এসেছিল।

কিন্তু কোডের নিজের সীমাও থাকে, যা requirement-এ লেখা নেই। Float binary-তে সংখ্যা রাখে, তাই ০.১, ০.৩৫-এর মতো দশমিক ভগ্নাংশ ঠিকঠাক রাখা যায় না; শুধু যেগুলো দুইয়ের ঘাতের ভগ্নাংশ (½, ¼, ⅛), সেগুলো যায়। ৪.২৫ = ৪ + ¼, তাই এটি “নিরাপদ” মাঝের মান; ৪.৩৫ নয়। অর্থাৎ মাঝের মানগুলো দুই partition-এ ভাগ হয়: binary-তে ঠিক প্রকাশযোগ্য আর অপ্রকাশযোগ্য। দ্বিতীয় partition-এর প্রতিনিধি না নিলে Decimal(float)-এর ভুল ধরা পড়ে না, যা পাতার কোডে ৮০,৬০০ জোড়ার ১৬০টিতে দেখা গেছে।

এ ধরনের লুকানো partition-এর কথা পর্ব ০৭-এ “লুকানো partition” হিসেবে এসেছিল। এগুলো খুঁজে পেতে requirement পড়া যথেষ্ট নয়; বাস্তবায়নের প্রযুক্তি জানতে হয়: float, তারিখের time zone, Unicode-এর code point. White-box ভাবনা (পর্ব ১৩) এখানে black-box-এর পরিপূরক।

টাকার হিসাবেও একই ফাঁদ। বাজারঘরের coupon-এ floor নেওয়া হয় পূর্ণ টাকায়, তাই সমস্যা কম; কিন্তু শতাংশ বা ভাগের হিসাবে float ব্যবহার করলে এক পয়সার এদিক-ওদিক বারবার ঘটে। এজন্যই আর্থিক হিসাবে Decimal বা পূর্ণসংখ্যার পয়সা ব্যবহারের চল আছে।

মূল উপলব্ধি: Boundary শুধু requirement-এর নয়, প্রযুক্তিরও। TDD-র উদাহরণ বাছাইয়ে দুই ধরনের সীমাই খুঁজুন।

প্র ০৪TDD নিয়ে গবেষণার ফল এত মিশ্র কেন, আর দল কীভাবে নিজে মাপবে?

Nagappan ও সহকর্মীদের ২০০৮ সালের case study-তে IBM আর Microsoft-এর দলগুলোর defect density অনেক কমেছিল, সাথে প্রাথমিক সময় বেড়েছিল। কিন্তু case study-তে দলগুলো এলোমেলোভাবে বাছাই হয় না; যে দল TDD বেছে নেয়, তারা হয়তো আগে থেকেই মানের দিকে মনোযোগী। নিয়ন্ত্রিত পরীক্ষায় এই সমস্যা কম, কিন্তু সেখানে অংশগ্রহণকারী প্রায়ই ছাত্র, কাজ কয়েক ঘণ্টার, আর TDD-তে তাঁদের দক্ষতা সীমিত। Rafique ও Mišić-এর ২০১৩ সালের meta-analysis এমন অনেক পরীক্ষা একসাথে দেখে মানে ছোট উন্নতি পেয়েছে, productivity-তে স্পষ্ট দিক পায়নি।

আরেকটি সমস্যা হলো “TDD” আসলে কী মাপা হলো। Fucci ও সহকর্মীদের ২০১৭ সালের গবেষণা প্রক্রিয়াটিকে কয়েকটি মাত্রায় ভাগ করে: ধাপের মাপ (granularity), ধাপের সমতা (uniformity), refactor-এর পরিমাণ আর test আগে না পরে। তাঁদের বিশ্লেষণে ফলের সাথে বেশি সম্পর্ক দেখা গেছে ছোট আর সমান ধাপের, test-first-এর ক্রমের নয়। অর্থাৎ যে দল “test আগে” লেখে কিন্তু বিশাল ধাপে কাজ করে, আর যে দল ছোট ধাপে test-after করে, তাদের ফল অন্য রকম হতে পারে।

দল নিজে মাপতে চাইলে বড় দাবি নয়, ছোট পরিমাপ নিন। কয়েক sprint-এ bug fix-এর সময় “আগে লাল test” নিয়ম মানুন, আর দেখুন একই bug আবার ফিরে আসার হার কমে কি না। চক্রের দৈর্ঘ্য দেখুন: কত মিনিট লাল থাকে। Escaped defect, অর্থাৎ release-এর পরে পাওয়া ভুল, module অনুযায়ী তুলনা করুন। তবে metric-এর ফাঁদ মনে রাখুন (পর্ব ৭৫ আর Goodhart-এর নীতি): test-এর সংখ্যা বা coverage লক্ষ্য হলে assertion-হীন test বাড়ে, Beck যে ভুলের কথা বলেছেন।

মূল উপলব্ধি: গবেষণা বলে TDD কাজে লাগতে পারে, নিশ্চয়তা দেয় না। নিজের দলে ছোট পরীক্ষা করুন, আর মাপুন ফল, অনুষ্ঠান নয়।

প্র ০৫Developer TDD করলে tester-এর কাজ কি কমে যায়? দলে QA-র ভূমিকা কোথায়?

একটি প্রচলিত ভুল ধারণা: “developer নিজেই test লেখেন, তাহলে tester কেন?” এই পর্বের kata উল্টো কথা বলে। TDD-র সবুজ শুধু লেখা উদাহরণের সবুজ। কোন উদাহরণ লেখা হবে, সেটিই আসল প্রশ্ন, আর সেটি test design-এর দক্ষতা: সীমা, লুকানো partition, ভুল input, রাষ্ট্রের ক্রম। চক্র ৫-এ সব সবুজ থাকা অবস্থায় কোড ভুল ছিল; ৪.৩৫-এর উদাহরণটি একজন tester-এর প্রশ্ন।

তাই TDD দলে QA-র কাজ সামনে সরে যায় (shift-left, পর্ব ০৪)। Story শুরুর আগে three amigos আলোচনায় tester উদাহরণ আনেন: “৪.৩৫ হলে কী দেখাবে? কোনো review না থাকলে?” এগুলোই developer-এর test list হয়, আর কিছু হয় acceptance test, যা outside-in-এর বাইরের চক্র চালায়। Tester নিজে acceptance test লিখতে পারেন, বা developer-এর সাথে জোড়ায় বসে (pair testing) unit test review করতে পারেন।

দ্বিতীয় ভূমিকা যাচাইয়ের যাচাই। প্রথমবারেই সবুজ হওয়া test-কে mutant দিয়ে পরীক্ষা, mock কোথায় আসল ঝুঁকি লুকাচ্ছে তা দেখা, আর exploratory testing (পর্ব ২০), যা কোনো script-এ ছিল না এমন ভুল খোঁজে। TDD unit স্তরে ভরসা বাড়ায়, কিন্তু পুরো system-এর আচরণ, ব্যবহারযোগ্যতা, performance বা নিরাপত্তা এর আওতার বাইরে।

AI-এর যুগে এই ভূমিকা আরও জরুরি। AI মিনিটে test আর কোড দুটিই লেখে; কিন্তু expected মান requirement থেকে এলো কি না, লাল কখনো দেখা হলো কি না, AI কোনো test বদলাল কি না, এগুলো যাচাই মানুষের কাজ। Tester-এর প্রশ্ন “এটি কীভাবে ভুল হতে পারে?” কোনো tool এখনো পুরোপুরি নিতে পারেনি।

মূল উপলব্ধি: TDD tester-কে সরায় না, তাঁর প্রশ্নগুলোকে কোড লেখার আগে নিয়ে আসে। ভালো উদাহরণ বাছাই-ই TDD-র মান ঠিক করে।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন। আউটপুটগুলো সত্যিকারের pytest 9.2.0 run থেকে।

  1. Spec থেকে test list: বাজারঘরের delivery charge: ঢাকার ভেতরে ৬০ টাকা, অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি (সীমা coupon-এর আগের টাকায়); বাইরে ১২০ টাকা, Plus সদস্যের ৬০ টাকা। delivery_charge(district, total, member)-এর TDD-র জন্য ক্রমসহ test list লিখুন, আর বলুন কোন item-এ fake it আর কোথায় triangulation ঘটবে।

    একটি যুক্তিসঙ্গত ক্রম: (১) ঢাকা, ৫০০, সদস্য নয় → ৬০; fake it: return 60. (২) Khulna, ৫০০ → ১২০; triangulation, জেলার শর্ত আসে। (৩) ঢাকা, ২০০০ → ০; সীমার ঠিক ওপরের মান, ফ্রির শর্ত আসে। (৪) ঢাকা, ১৯৯৯ → ৬০; সীমার নিচ, > বনাম >=-এর ভুল ধরে (এই test সম্ভবত প্রথমবারেই সবুজ; mutant দিয়ে যাচাই করুন)। (৫) Khulna, ৫০০০ → ১২০; বাইরে কখনো ফ্রি নয়। (৬) Khulna, ৫০০, Plus → ৬০. (৭) ঢাকা, ১৯৯৯, Plus → ৬০; ঢাকায় Plus-এর প্রভাব নেই। সরল থেকে জটিলে, প্রতিটি item একটি নতুন শর্ত বা সীমা আনে; ক্রমটি পর্ব ০৯-এর decision table-এর নিয়মগুলো একে একে খুলে দেয়।

  2. আউটপুট আগে বলুন: চক্র ৩-এর কোড return f"{sum(stars) / len(stars):.1f}"-এর বিরুদ্ধে চারটি parametrize সারি: [2, 3] → "2.5", [3, 3, 4] → "3.3", [1, 1, 1, 2] → "1.3", [5, 5, 5, 4, 4, 4, 4, 4] → "4.4". কয়টি পাস করবে, আর ব্যর্থটির E লাইন কী হবে?

    সত্যিকারের run: 1 failed, 3 passed. ব্যর্থ সারি [1, 1, 1, 2]: গড় ১.২৫, ঠিক মাঝের মান, আর :.1f জোড়ের দিকে নেয়: E AssertionError: assert '1.2' == '1.3'. Node id test_label[stars2-1.3], কারণ id না দিলে pytest list-এর জন্য stars2 বানায়। [5, 5, 5, 4, 4, 4, 4, 4]-এর গড় ৪.৩৭৫, মাঝের মান নয়, তাই "4.4" ঠিকই আসে। ২.৫ আর ৩.৩৩… সাধারণ।

  3. Test-এ ভুল খুঁজুন: একজন সহকর্মী বললেন, “TDD করেছি, সব সবুজ।” তাঁর test ফাইল: def test_average(): assert average_label([4, 4, 5, 4]) == "4.2"; assert average_label([5]) == "5.0"; assert average_label([]) is None, আর কোডে round(avg, 1). Commit-এর ইতিহাসে কোড আর test একই commit-এ। অন্তত তিনটি সমস্যা বলুন।

    (১) Expected মান requirement-বিরুদ্ধ: AC5 বলে ৪.২৫ → "4.3"; "4.2" কোডের বর্তমান ফল নকল করা, তাই test ভুল কোডে পাস করে। (২) কোড আর test একসাথে, তাই লাল কখনো দেখা হয়নি; test ব্যর্থ হতে পারে কি না, অজানা। (৩) এক test-এ তিনটি আচরণ (assertion roulette, পর্ব ২২): প্রথম assert ব্যর্থ হলে বাকি দুটি চলেই না। (৪) সীমার দ্বিতীয় উদাহরণ (৪.৩৫) আর AC2-এর ০/৬ star নেই। সমাধান: AC5 থেকে test list, প্রতিটি item আলাদা test বা parametrize সারি, আর প্রতিটির লাল আগে দেখা।

  4. কোন test লাল হবে: review_count(p, store)-এর দুটি test: classic (আসল in-memory store, ফল ৩ যাচাই) আর mockist (Mock, ফল ৩ আর stars_for.assert_called_once_with("P-17")). তিনটি বদল: (ক) local variable-এর নাম p থেকে pid; (খ) batch method stars_for_many([p])[p]; (গ) একই call দুবার। প্রতিটিতে কোন test লাল?

    (ক) কোনোটিই নয়: ভেতরের নাম বদলে আচরণ বা ডাক কিছুই বদলায় না। (খ) শুধু mockist, TypeError: 'Mock' object is not subscriptable: refactor-এ মিথ্যা সতর্কবার্তা। (গ) শুধু mockist, Expected 'stars_for' to be called once. Called 2 times.: query-র সংখ্যা requirement হলে এটি সত্যিকারের ধরা। (খ) আর (গ)-এর ফল এই পাতার Pyodide কোডে সত্যিকারভাবে চালানো। শিক্ষা: interaction নিজেই requirement হলে mock, নইলে ফল।

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

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

ক্রমএকটি TDD চক্রের কাজগুলো ঘটার ক্রমে সাজান (▲▼ চেপে সরান)

  1. Test list থেকে একটি item বেছে নেওয়া
  2. সেই item-এর জন্য একটি test লেখা
  3. Test চালিয়ে লাল দেখা আর কারণ পড়া
  4. পাস করানোর ন্যূনতম কোড লেখা
  5. সব test চালিয়ে সবুজ দেখা
  6. Test সবুজ রেখে refactor করা

TDD-তে average_label([5]) == "5.0" test-এর জন্য কোড return "5.0" লেখা হলো। এই কৌশলের নাম কী?

  • Triangulation
  • Obvious implementation
  • Fake it
  • Refactoring

TDD-তে একটি নতুন test লিখে চালাতেই প্রথমবারে সবুজ হলো। সবচেয়ে ভালো পরের কাজ কোনটি?

  • কিছু না করে পরের item-এ যাওয়া
  • কোডে ইচ্ছা করে একটি ছোট ভুল বসিয়ে দেখা test লাল হয় কি না
  • Test-টি সঙ্গে সঙ্গে মুছে ফেলা
  • Expected মান বদলে test-কে লাল বানানো

গড় rating এক দশমিকে half up দেখাতে হবে। Python-এ Decimal(87 / 20).quantize(Decimal("0.1"), rounding=ROUND_HALF_UP) কী দেয়?

  • 4.4
  • 4.35
  • 4
  • 4.3

একটি function আগে store.stars_for(pid) ডাকত; refactor করে এখন store.stars_for_many([pid])[pid] ডাকে, ফল একই। কোন test ভাঙার সম্ভাবনা বেশি?

  • Mock দিয়ে stars_for-এর ডাক যাচাই করা test
  • আসল in-memory store দিয়ে ফল যাচাই করা test
  • আসল store-সহ acceptance test
  • কোনোটিই নয়

Outside-in TDD-র double loop-এ বাইরের চক্র কী দিয়ে শুরু হয়?

  • ভেতরের সবচেয়ে ছোট function-এর unit test দিয়ে
  • পুরোনো কোড refactor দিয়ে
  • একটি ব্যর্থ acceptance test দিয়ে
  • পুরো feature-এর কোড আগে লিখে

Kent Beck-এর “Canon TDD”-তে সাধারণ ভুল হিসেবে কোনটির কথা বলা হয়েছে?

  • কাজ শুরুর আগে test list লেখা
  • পুরো test list একবারে test-এ বদলে তারপর একে একে পাস করানো
  • সবুজের পরে refactor করা
  • চলার পথে test list-এ নতুন item যোগ করা

শব্দকোষ

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

মনে রাখুন

  1. Canon TDD: test list কাগজে, test কোডে একটি একটি করে; লাল দেখুন, কারণ পড়ুন, ন্যূনতম কোডে সবুজ, তারপর refactor.
  2. লালের তিন রূপ: import বা collection error, assertion-এর diff, আর DID NOT RAISE; প্রথমবারেই সবুজ হলে mutant দিয়ে যাচাই।
  3. Triangulation: এক উদাহরণে নিয়ম প্রমাণ হয় না; ৪.২৫-এ ভুল সমাধানও টিকেছিল, ৪.৩৫ float-এর ফাঁদ ধরল। উদাহরণ বাছাই test design-এর কাজ।
  4. Classic বনাম mockist: ফল যাচাই refactor-এ টেকে; ডাক যাচাই করুন শুধু যখন ডাকের সংখ্যা বা ক্রম নিজেই requirement.
  5. Outside-in: ব্যর্থ acceptance test থেকে শুরু, ভেতরে unit-চক্র; mock-এর চাওয়া থেকেই collaborator-এর interface, আর বাইরের test mock drift পাহারা দেয়।

পরের পর্বে: মডিউল ৫ শুরু হবে পর্ব ২৮ (Integration testing — কৌশল, test database আর Testcontainers) দিয়ে। Unit-এর একা পরীক্ষা থেকে এবার অংশগুলো জোড়া লাগিয়ে দেখা: in-memory store-এর জায়গায় সত্যিকারের database.

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

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