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

Snapshot আর approval testing — কখন সুবিধা, কখন ফাঁদ

Snapshot and Approval Testing — Golden Masters, Scrubbers, Diffs and Review Discipline

Taught in Bangla, this lesson shows what snapshot tests can and cannot tell you: they detect change, not correctness. Real runs with syrupy catch a seeded delivery bug as a clean three-line JSON diff, ApprovalTests guards a Bangla receipt, a 32-combination golden master pins two pricing bugs, and inline-snapshot keeps the expectation in the test. It shows scrubbers stabilising times and ids, an over-broad scrubber hiding a real bug, and a blind update turning a wrong value green.

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

  • Snapshot, approval আর golden master test-এর মিল-অমিল, আর এদের oracle আসলে কী
  • Received, approved আর diff-এর চক্র, আর প্রতিটি ব্যর্থতায় “bug, নাকি ইচ্ছাকৃত বদল?” সিদ্ধান্ত
  • সময়, এলোমেলো id আর ক্রমের মতো অস্থির মান চেনা, আর scrubber বা উৎসে নিয়ন্ত্রণ দিয়ে স্থির করা
  • syrupy, ApprovalTests আর inline-snapshot দিয়ে Python-এ সত্যিকারের snapshot test, আর JavaScript-এর সমতুল্য
  • কখন snapshot, কখন assertion, আর pull request-এ snapshot বদল review-এর শৃঙ্খলা

১ · খাতা মিলিয়ে দেখা — snapshot, approval আর golden master

পরীক্ষার খাতা দেখার এক রকম কৌশল ভাবুন। একজন অভিজ্ঞ শিক্ষক একটি আদর্শ উত্তরপত্র একবার মন দিয়ে যাচাই করে রাখলেন। এরপর বাকি খাতাগুলো আর প্রতিটি অঙ্ক নিজে কষে দেখা হয় না; আদর্শ খাতার পাশে রেখে মেলানো হয়, আর যেখানে অমিল, শুধু সেখানে চোখ যায়। কৌশলটি দ্রুত, কিন্তু একটি শর্তে চলে: আদর্শ খাতাটি সত্যিই ঠিক হতে হবে। আদর্শ খাতায় একটি ভুল থাকলে সেই ভুল সব খাতায় “সঠিক” হিসেবে নম্বর পাবে।

সফটওয়্যারে এই কৌশলের নাম snapshot testing. সাধারণ test-এ আপনি নিজে প্রত্যাশিত মান লেখেন: assert coupon(1001) == 100. Snapshot test-এ আপনি লেখেন “এই output আগে যা ছিল, তাই থাকবে”: প্রথম run-এর output একটি ফাইলে রেকর্ড হয়, পরের প্রতিটি run নতুন output সেই ফাইলের সাথে হুবহু মেলায়। মিলে গেলে পাস; না মিললে test ব্যর্থ হয়, আর একটি diff দেখায় ঠিক কোন লাইন বদলেছে।

এই পরিবারের তিনটি নাম প্রায়ই একসাথে আসে। মূল যন্ত্র একই, জোর আলাদা:

নামমূল প্রশ্নসাধারণ ব্যবহার
Golden masterপুরোনো code অনেক input-এ কী দেয়? নতুন code কি হুবহু তাই দেয়?Legacy code refactor-এর আগে আচরণের জাল (পর্ব ২৫-এর characterization test-এর বড় রূপ)
Snapshot testএই output কি গতবারের রেকর্ডের মতোই আছে?UI component, JSON response, error message, রেন্ডার করা HTML
Approval testনতুন output-টি কি একজন মানুষ পড়ে অনুমোদন করেছেন?রসিদ, report, চিঠি, বড় লেখা; অনুমোদনের ধাপটি স্পষ্ট আর ফাইলভিত্তিক

তিনটিরই test oracle, অর্থাৎ “সঠিক উত্তর কোথা থেকে আসে”, একটি পুরোনো output; কোনো লিখিত requirement নয়। এটিই এদের শক্তি আর দুর্বলতা দুটোই। শক্তি: যেখানে প্রত্যাশিত ফল হাতে লেখা কঠিন (৪০ field-এর একটি JSON, ৩০ লাইনের রসিদ), সেখানে এক লাইনে পুরো জিনিসটি পাহারায় চলে আসে। দুর্বলতা: প্রথম রেকর্ডে bug থাকলে test সেই bug-কে চিরকাল পাহারা দেয়। পর্ব ২৫-এ (Testable code) characterization test দিয়ে আমরা legacy code-এর বর্তমান আচরণ রেকর্ড করেছিলাম, আর পর্ব ৪১-এ (Visual regression testing) একই ধারণা ছবির pixel দিয়ে দেখেছি। এই পর্বের বিষয় লেখা আর data: JSON, রসিদের বাংলা লেখা, টেবিল।

“Golden master” শব্দটি এসেছে রেকর্ড আর ছাপার জগৎ থেকে: অনুমোদিত মূল কপি, যা থেকে বাকি কপি বানানো আর মেলানো হতো। সফটওয়্যারে Michael Feathers তাঁর ২০০৪ সালের বই Working Effectively with Legacy Code-এ characterization test-এর ধারণা জনপ্রিয় করেন। ApprovalTests library-র শুরু Llewellyn Falco ও সহকর্মীদের হাতে, ২০০০-এর দশকের শেষ দিকে বলে জানা যায়; পরে এটি Java, C#, Python, C++ সহ অনেক ভাষায় ছড়ায়। JavaScript-এর Jest ২০১৬ সালের দিকে toMatchSnapshot জনপ্রিয় করে, প্রধানত React component-এর রেন্ডার করা output-এর জন্য (সালগুলো আমরা প্রাথমিক উৎস থেকে আলাদা করে যাচাই করিনি)।

২ · চক্রটি — received, approved, diff আর সিদ্ধান্ত

সব snapshot টুলের ভেতরে একই চক্র ঘোরে। এই run-এর output হলো received, যা ApprovalTests একটি received ফাইলে লেখে। আগে অনুমোদিত output হলো approved বা snapshot, যা একটি approved ফাইলে code-এর সাথে repository-তে থাকে। তুলনার আগে একটি scrubber প্রতিবার-বদলানো অংশ (সময়, id) স্থির চিহ্নে বদলায়। তারপর হুবহু তুলনা। নিচের ছবিতে পুরো পথ:

Snapshot আর approval test-এর চক্র

received → scrub → approved-এর সাথে তুলনা → পাস, নাকি মানুষের সিদ্ধান্ত

received → scrubber → তুলনা → PASS, অথবা diff → approve বা code ঠিক করা received এই run-এর output scrubber সময়→<TIME>, id→<TXN> হুবহু তুলনা মিলেছে কি? approved ফাইল, code-এর সাথে রাখা হ্যাঁ → PASS কিছু করার নেই না → FAIL + diff − approved, + received ইচ্ছাকৃত বদল diff পড়ে, requirement মিলিয়ে approve: received → approved bug code ঠিক করুন, approved ফাইল যেমন ছিল তেমনই
ছবি ৬১.১ — যন্ত্র শুধু তুলনা করে। ব্যর্থতার পরের সিদ্ধান্তটি, অর্থাৎ বদলটি ইচ্ছাকৃত নাকি bug, সবসময় মানুষের, আর সেটি নিতে হয় requirement মিলিয়ে।

এই চক্র নিজে হাতে ঘুরিয়ে দেখুন। নিচের code-এ একটি ছোট verify: approved লেখা রাখা হয় একটি dict-এ (আসল টুলে ফাইলে), scrubber দুটি regular expression, আর পার্থক্য দেখায় Python-এর difflib. বাজারঘরের ২০০০ টাকার ঢাকার অর্ডারের রসিদ তিনবার যাচাই হয়: প্রথমবার, অনুমোদনের পরে অন্য সময়ে, আর একটি delivery ভুল ঢোকার পরে।

import difflib, re
APPROVED = {}                       # name -> approved text (like an .approved.txt file)
SCRUBBERS = [(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\+06:00", "<TIME>"),
             (r"FAKE-[0-9A-F]{12}", "<TXN>")]

def scrub(text):
    for pattern, label in SCRUBBERS:
        text = re.sub(pattern, label, text)
    return text

def verify(name, received):
    received = scrub(received)
    approved = APPROVED.get(name, "")
    if received == approved:
        return "PASS"
    diff = difflib.unified_diff(approved.splitlines(), received.splitlines(),
                                "approved", "received", lineterm="", n=1)
    print("\n".join(diff))
    return "FAIL: received != approved"

def receipt(delivery, total, when, txn):
    return (f"অর্ডার #8 · {when}\nপণ্যের দাম: 2000\nকুপন ছাড়: -200\n"
            f"ডেলিভারি (Dhaka): {delivery}\nমোট: {total} টাকা\nপেমেন্ট: {txn}\n")

r1 = receipt(0, 1800, "2026-11-16T10:00:01+06:00", "FAKE-0A1B2C3D4E5F")
print("run 1:", verify("receipt", r1))
APPROVED["receipt"] = scrub(r1)     # a person read it line by line, then approved
r2 = receipt(0, 1800, "2026-11-16T10:05:09+06:00", "FAKE-99AA88BB77CC")
print("run 2:", verify("receipt", r2))
r3 = receipt(60, 1860, "2026-11-16T10:09:30+06:00", "FAKE-1234567890AB")
print("run 3:", verify("receipt", r3))

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

--- approved
+++ received
@@ -0,0 +1,6 @@
+অর্ডার #8 · <TIME>
+পণ্যের দাম: 2000
+কুপন ছাড়: -200
+ডেলিভারি (Dhaka): 0
+মোট: 1800 টাকা
+পেমেন্ট: <TXN>
run 1: FAIL: received != approved
run 2: PASS
--- approved
+++ received
@@ -3,4 +3,4 @@
 কুপন ছাড়: -200
-ডেলিভারি (Dhaka): 0
-মোট: 1800 টাকা
+ডেলিভারি (Dhaka): 60
+মোট: 1860 টাকা
 পেমেন্ট: <TXN>
run 3: FAIL: received != approved

Run ১: approved বলে কিছু নেই, তাই পুরো রসিদ + চিহ্নে, ব্যর্থ। সত্যিকারের ApprovalTests-ও ঠিক এটাই করে (অংশ ৫)। এই মুহূর্তটিই সবচেয়ে গুরুত্বপূর্ণ: কেউ রসিদটি লাইন ধরে পড়বেন। নিয়ম মিলিয়ে দেখা যায় ২০০০ টাকায় ছাড় ২০০, ঢাকায় ২০০০ বা বেশি হলে delivery ফ্রি, মোট ১৮০০: ঠিক। তারপরই অনুমোদন। Run ২: সময় আর লেনদেন id আলাদা, কিন্তু scrubber দুটিকেই চিহ্নে বদলেছে, তাই PASS. Run ৩: diff-এ - মানে approved-এ ছিল, + মানে এখন এসেছে। শুধু দুটি লাইন বদলেছে, আর @@ -3,4 +3,4 @@ বলছে তৃতীয় লাইন থেকে চার লাইনের একটি টুকরো দেখানো হচ্ছে। এটিই snapshot-এর সবচেয়ে বড় উপহার: ৩০ লাইনের output-এ কোথায় কী বদলেছে, এক নজরে।

  1. প্রথম runনেইFAIL
  2. পড়ে approve.ambrরেকর্ড
  3. Diff0 → 60FAIL
  4. সিদ্ধান্তbug?মানুষ
quote টেবিল · ঢাকা ২০০০ টাকার সারি
code
snapshot
ফল
  1. প্রথম run. syrupy-তে snapshot না থাকলে test নিজে থেকে কিছু লেখে না, ব্যর্থ হয়: Snapshot 'test_quote_table' does not exist! নতুন snapshot তৈরি একটি সচেতন কাজ, দুর্ঘটনা নয়।
  2. পড়ে approve. --snapshot-update দিয়ে .ambr ফাইল তৈরি হলো। ফাইলটি খুলে চারটি সারি নিয়ম মিলিয়ে পড়া হলো: ঢাকায় ২০০০ টাকায় ছাড় ২০০, delivery ০, মোট ১৮০০. পড়া শেষ হলেই এটি সত্যিকারের অনুমোদিত snapshot.
  3. আবার run. কিছু না বদলে PASS. প্রথম যাচাই এটাই: test নিজের সাথে মেলে কি না।
  4. বদল, diff. App-এর delivery_after_discount ভুল চালু: ফ্রি delivery-র সীমা ছাড়ের পরের দামে মাপা হচ্ছে। diff-এ শুধু দুটি মান: delivery ০ থেকে ৬০, মোট ১৮০০ থেকে ১৮৬০. বাকি তিনটি সারি অপরিবর্তিত, তাই diff সেগুলো ... দিয়ে লুকিয়েছে।
  5. সিদ্ধান্ত: bug. Requirement বলে ২০০০ টাকার সীমা ছাড়ের আগের দামে। তাই snapshot যেমন ছিল তেমনই, code ঠিক করা হলো, আর test আবার PASS.
  6. ভুল পথ, সত্যিকারের run-এ. ভুল থাকা অবস্থায় কেউ --snapshot-update চালালেন: 1 snapshot updated, test সবুজ। পরে developer code ঠিক করলেন, আর এবার test লাল, কারণ snapshot এখন ভুল মান পাহারা দিচ্ছে। এর নাম blind approval.

৩ · সত্যিকারের run ১ — syrupy দিয়ে API-র JSON

এবার আসল টুল, আসল app. এই অংশ আর পরের দুটি অংশের সব run এই কোর্স লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো হয়েছে: Python 3.12.13, pytest 9.2.0 (MIT), syrupy 7.0.2 (MIT), approvaltests 20.0.1 (Apache-2.0) আর inline-snapshot 0.36.2 (MIT). Project বানানো হয়েছে uv দিয়ে, ~/bazarghar-qa-তে। App হলো বাজারঘরের একটি কপি, FastAPI-র TestClient দিয়ে test-এর একই process-এ চালানো, কোনো network port খোলা হয়নি; প্রতিটি test পায় নতুন করে seed করা নিজের SQLite ফাইল। এই টুলগুলোতে usage data পাঠানোর কোনো ব্যবস্থা আমাদের চোখে পড়েনি, তবু সাবধানতা হিসেবে DO_NOT_TRACK=1 রাখা হয়েছিল। Path নিরপেক্ষ করা।

লাইসেন্সের একটি সংশোধন: কিছু জায়গায় syrupy-কে Apache-2.0 বলা হয়। আমরা install করা package-এর নিজস্ব লাইসেন্স ফাইল খুলে দেখেছি: syrupy 7.0.2 হলো MIT. যেকোনো টুলের লাইসেন্স অন্যের লেখা থেকে না নিয়ে package-এর ফাইল বা তার repository থেকে দেখে নিন।

প্রথম test-টি বাজারঘরের pricing API (/api/pricing/quote) থেকে চারটি সীমার মানে quote নিয়ে পুরো টেবিলটিকে একটি snapshot-এ রাখে। মানগুলো এসেছে পর্ব ০৮-এর (Boundary value analysis) সীমা থেকে। syrupy একটি snapshot fixture দেয়; ==-এর ডানে বসালেই তুলনা:

CASES = [(1000, "Dhaka"), (1001, "Dhaka"), (2000, "Dhaka"), (3010, "Rajshahi")]


def test_quote_table(client, snapshot):
    table = [client.get("/api/pricing/quote", params={"subtotal": s, "district": d}).json()
             for s, d in CASES]
    assert table == snapshot

প্রথম run, তারপর snapshot তৈরি। সত্যিকারের আউটপুট (অংশবিশেষ):

$ uv run pytest tests/test_quote_snapshot.py
E         Snapshot 'test_quote_table' does not exist!
1 snapshot failed.
1 failed in 0.22s
$ uv run pytest tests/test_quote_snapshot.py --snapshot-update
1 snapshot generated.
1 passed in 0.11s

syrupy snapshot রাখে tests/__snapshots__/test_quote_snapshot.ambr ফাইলে, নিজস্ব “amber” ফরম্যাটে, যা মানুষ পড়তে পারে। ফাইলের শুরু আর ঢাকার ২০০০ টাকার সারিটি:

# serializer version: 1
# name: test_quote_table
  list([
    dict({
      'delivery': 60,
      'discount': 0,
      'district': 'Dhaka',
      'plus': False,
      'subtotal': 1000,
      'total': 1060,
    }),
    …
    dict({
      'delivery': 0,
      'discount': 200,
      'district': 'Dhaka',
      'plus': False,
      'subtotal': 2000,
      'total': 1800,
    }),
    …

লক্ষ করুন, dict-এর key-গুলো বর্ণক্রমে সাজানো। এটি serializer-এর কাজ: একই data সবসময় একই লেখায় রূপ নেয়, তাই key-এর ক্রম বদলালেও snapshot বদলায় না। এবার app-এর delivery_after_discount ভুলটি চালু করে একই test, -vv দিয়ে পুরো diff:

$ BAZARGHAR_BUGS=delivery_after_discount uv run pytest tests/test_quote_snapshot.py -vv
E       AssertionError: assert [+ received] == [- snapshot]
E           list([
E            ...
E             dict({
E         -     'delivery': 0,
E         +     'delivery': 60,
E               'discount': 200,
E               ...
E               'subtotal': 2000,
E         -     'total': 1800,
E         +     'total': 1860,
E             }),
E            ...
E           ])
FAILED tests/test_quote_snapshot.py::test_quote_table
1 failed in 0.21s

এই diff-টি একটি ভালো bug report-এর অর্ধেক: কোন input (subtotal ২০০০, ঢাকা), কোন field, আগে কী, এখন কী। পাশের 'discount': 200 লাইনটি প্রসঙ্গ হিসেবে দেখানো হয়েছে, যাতে পাঠক বোঝেন কোন সারি। এরপর stepper-এর ষষ্ঠ ধাপের অন্ধ update-টিও সত্যিই চালানো হয়েছিল; তার আউটপুট:

$ BAZARGHAR_BUGS=delivery_after_discount uv run pytest tests/test_quote_snapshot.py --snapshot-update
1 snapshot updated.
1 passed in 0.11s
$ uv run pytest tests/test_quote_snapshot.py          # code ঠিক করার পরে
1 snapshot failed.
FAILED tests/test_quote_snapshot.py::test_quote_table - AssertionError: asser...

যে snapshot-এর আর মালিক নেই

Test মুছে ফেললে বা নাম বদলালে তার পুরোনো snapshot ফাইলে থেকে যায়। syrupy এটি ধরে। একটি test মুছে দেওয়ার পরের সত্যিকারের run:

$ uv run pytest tests/test_quote_snapshot.py tests/test_order_snapshot.py
…
tests\test_quote_snapshot.py .                                           [ 50%]
tests\test_order_snapshot.py .                                           [100%]

--------------------------- snapshot report summary ---------------------------
2 snapshots passed. 1 snapshot unused.

Re-run pytest with --snapshot-update to delete unused snapshots.
============================== 2 passed in 0.26s ==============================
# exit code: 1

দুটি test-ই পাস, তবু pytest-এর exit code ১, অর্থাৎ CI-তে এই job ব্যর্থ। প্রথমবার দেখলে অবাক লাগে, কিন্তু নিয়মটি যুক্তিসঙ্গত: মালিকহীন snapshot ভবিষ্যতে বিভ্রান্তি ছড়ায়, আর অনেক সময় এটি বোঝায় কেউ ভুল করে একটি test মুছে দিয়েছেন। এই আচরণ বদলানোর option আছে (--snapshot-warn-unused), কিন্তু default-টিই নিরাপদ।

৪ · অস্থির মান — scrubber আর উৎসে নিয়ন্ত্রণ

রান্নার স্বাদ চেখে মেলাতে গেলে আগে নিশ্চিত হতে হয়, একই চামচে একই সময়ে চাখছেন; নইলে গরম আর ঠান্ডা ডালের স্বাদ আলাদা লাগবে, অথচ ডাল একই। Snapshot-এর ক্ষেত্রেও তাই। এবার পুরো অর্ডারের JSON: মিতু তেল আর আলু কিনলেন (১০০১ টাকা), ঢাকা, mobile-wallet-এ টাকা দিলেন। Fixture অর্ডারটি বানায়, একটি নির্দিষ্ট Idempotency-Key দিয়ে pay করে, তারপর GET /api/orders/8-এর JSON ফেরত দেয়। প্রথম চেষ্টায় কোনো scrubber নেই:

def test_order_raw(paid_order, snapshot):          # no scrubber
    assert paid_order == snapshot

Snapshot তৈরির কয়েক সেকেন্ড পরে কিছু না বদলে আবার চালানো হলো। সত্যিকারের আউটপুট:

E           dict({
E            ...
E         -   'created_at': '2026-11-16T19:57:42+06:00',
E         +   'created_at': '2026-11-16T19:57:49+06:00',
E             'customer_id': 2,
E              ...
E         -       'at': '2026-11-16T19:57:42+06:00',
E         +       'at': '2026-11-16T19:57:49+06:00',
E                 'status': 'placed',
E                ...
E         -       'at': '2026-11-16T19:57:42+06:00',
E         +       'at': '2026-11-16T19:57:49+06:00',
E                 'status': 'paid',
E                ...
E         -     'paid_at': '2026-11-16T19:57:42+06:00',
E         +     'paid_at': '2026-11-16T19:57:49+06:00',
E         -     'txn_id': 'FAKE-12DC313B3788',
E         +     'txn_id': 'FAKE-4469A5F649B9',
1 snapshot failed. 2 snapshots passed.

Code-এ কোনো ভুল নেই, তবু FAIL. পাঁচটি মান বদলেছে: চারটি সময় (অর্ডার তৈরি, ইতিহাসের দুটি ধাপ, টাকা দেওয়া) আর fake gateway-এর এলোমেলো লেনদেন id. এমন test হয় প্রতিবার ব্যর্থ হবে, নয়তো একই সেকেন্ডে চললে কদাচিৎ পাস করবে, অর্থাৎ একটি flaky test (পর্ব ৪০, Flaky test). মজার বিষয়, অর্ডার id 8 বদলায়নি: প্রতিটি test নতুন seed করা database পায়, তাই id নির্ধারিত। এটিই প্রথম শিক্ষা: non-determinism-এর অনেক উৎস test-এর setup-এই বন্ধ করা যায় (পর্ব ২৩, Fixture আর test data).

Scrubber — কিন্তু আকৃতি যাচাই করে

যেগুলো setup-এ স্থির করা যায় না, সেগুলোর জন্য scrubber. syrupy-তে এর নাম property matcher: snapshot-এ লেখার আগে নির্দিষ্ট path-এর মান বদলায়। নিচের matcher দুটি কাজ একসাথে করে। Path মিললে মানটির আকৃতি যাচাই করে (সময় কি YYYY-MM-DDTHH:MM:SS+06:00? id কি FAKE- আর ১২টি hex অক্ষর?), মিললে স্থির চিহ্ন বসায়, না মিললে আসল মানটাই রেখে দেয়, যাতে snapshot ব্যর্থ হয়:

from syrupy.matchers import compose_matchers, path_value

TIME = r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\+06:00"
scrub = compose_matchers(
    path_value({r"created_at|payment\.paid_at|history\.\d+\.at": TIME},
               types=(str,), regex=True,
               replacer=lambda v, m: "<TIME>" if m else v),
    path_value({r"payment\.txn_id": r"FAKE-[0-9A-F]{12}"},
               types=(str,), regex=True,
               replacer=lambda v, m: "<TXN>" if m else v),
)


def test_order_scrubbed(paid_order, snapshot):
    assert paid_order == snapshot(matcher=scrub)

Snapshot ফাইলে এখন 'created_at': '<TIME>', 'txn_id': '<TXN>', আর বাকি সব আসল মান: দাম, পণ্যের বাংলা নাম, ফোন, allowed_actions. পরপর কয়েকটি run-এ এই test প্রতিবার পাস করেছে। কেন শুধু <TIME> নয়, আকৃতির যাচাইও? কারণ কেউ ভুল করে সময় UTC-তে (Z দিয়ে) পাঠাতে শুরু করলে, বা লেনদেন id ফাঁকা আসলে, একটি অন্ধ scrubber সেটিও <TIME> বানিয়ে লুকিয়ে ফেলত। আকৃতি-যাচাইকারী scrubber মানটি রেখে দেবে, আর snapshot ব্যর্থ হবে। (এই শেষ আচরণটি code-এর যুক্তি থেকে বলা; সময়ের ফরম্যাট বদলে আমরা আলাদা run করিনি।)

অর্ডার #8-এর JSON, কিছু না বদলে দুবার
created_at
txn_id
id, দাম
ফল
  1. কাঁচা snapshot. Scrubber ছাড়া অর্ডারের পুরো JSON রেকর্ড হলো, সময়সহ (এখানে শুধু সময়ের শেষ অংশ দেখানো)।
  2. কিছু না বদলে আবার। সাত সেকেন্ড পরে run: চারটি সময় আর লেনদেন id আলাদা, পাঁচটি -/+ জোড়া, FAIL. Code ঠিক আছে; ভুল test-এর নকশায়।
  3. উৎস চেনা। চারটি সময়ের field (created_at, ইতিহাসের দুটি at, paid_at) আর একটি এলোমেলো id. অর্ডার id আর সব দাম স্থির, কারণ প্রতিটি test নতুন seed পায়।
  4. আকৃতি-যাচাইকারী scrubber. path_value দিয়ে শুধু ওই পাঁচটি path, আর শুধু ঠিক আকৃতির মান <TIME> বা <TXN> হয়। পরপর run-এ PASS.
  5. যা পাহারায় থাকল। Scrubber-এর বাইরের সব কিছু, দাম, delivery, মোট, পণ্যের নাম, এখনো হুবহু যাচাই হয়। নিচের code দেখাবে, scrubber চওড়া হলে ঠিক এই পাহারাটুকুই হারায়।

Scrubber লেখার সময় সবচেয়ে বড় প্রলোভন হলো যেকোনো উপায়ে test সবুজ করা। নিচের code-এ দুটি scrubber: precise শুধু সময় আর id ধরে; greedy অঙ্ক আছে এমন প্রতিটি শব্দ মুছে দেয়, যা দ্রুত সব flaky ব্যর্থতা থামায়। চতুর্থ test-টি জিজ্ঞেস করে, delivery-র ভুলটি greedy scrubber-এর পরেও কি দেখা যায়:

import re, sys, unittest

def receipt(delivery, total, when, txn):
    return f"{when}\nডেলিভারি: {delivery}\nমোট: {total} টাকা\nপেমেন্ট: {txn}"

def precise(text):                   # only the parts that really change
    text = re.sub(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\+06:00", "<TIME>", text)
    return re.sub(r"FAKE-[0-9A-F]{12}", "<TXN>", text)

def greedy(text):                    # "make it green": any word with a digit
    return re.sub(r"\S*\d\S*", "<X>", text)

MON = receipt(0, 1800, "2026-11-16T10:00:01+06:00", "FAKE-0A1B2C3D4E5F")
TUE = receipt(0, 1800, "2026-11-17T09:12:44+06:00", "FAKE-99AA88BB77CC")
BUG = receipt(60, 1860, "2026-11-17T09:13:02+06:00", "FAKE-1234567890AB")

class ScrubberTest(unittest.TestCase):
    def test_1_raw_runs_differ(self):
        self.assertNotEqual(MON, TUE)
    def test_2_precise_makes_runs_equal(self):
        self.assertEqual(precise(MON), precise(TUE))
    def test_3_precise_still_sees_bug(self):
        self.assertNotEqual(precise(MON), precise(BUG))
    def test_4_greedy_still_sees_bug(self):
        self.assertNotEqual(greedy(MON), greedy(BUG))

print(precise(BUG).replace("\n", " | "))
print(greedy(BUG).replace("\n", " | "))
suite = unittest.defaultTestLoader.loadTestsFromTestCase(ScrubberTest)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)

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

<TIME> | ডেলিভারি: 60 | মোট: 1860 টাকা | পেমেন্ট: <TXN>
<X> | ডেলিভারি: <X> | মোট: <X> টাকা | পেমেন্ট: <X>
test_1_raw_runs_differ (__main__.ScrubberTest.test_1_raw_runs_differ) ... ok
test_2_precise_makes_runs_equal (__main__.ScrubberTest.test_2_precise_makes_runs_equal) ... ok
test_3_precise_still_sees_bug (__main__.ScrubberTest.test_3_precise_still_sees_bug) ... ok
test_4_greedy_still_sees_bug (__main__.ScrubberTest.test_4_greedy_still_sees_bug) ... FAIL

======================================================================
FAIL: test_4_greedy_still_sees_bug (__main__.ScrubberTest.test_4_greedy_still_sees_bug)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 25, in test_4_greedy_still_sees_bug
    self.assertNotEqual(greedy(MON), greedy(BUG))
    ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: '<X>\nডেলিভারি: <X>\nমোট: <X> টাকা\nপেমেন্ট: <X>' == '<X>\nডেলিভারি: <X>\nমোট: <X> টাকা\nপেমেন্ট: <X>'

----------------------------------------------------------------------
Ran 4 tests in 0.001s

FAILED (failures=1)

প্রথম তিনটি test বলে precise ঠিক কাজ করছে: কাঁচা দুই দিনের রসিদ আলাদা, scrub করার পরে এক, আর delivery-র ভুল তখনও ধরা পড়ে (প্রথম ছাপা লাইনে 60 আর 1860 স্পষ্ট)। চতুর্থটি ইচ্ছা করে লেখা প্রশ্ন, আর ব্যর্থতাটাই উত্তর: greedy scrubber-এর পরে সঠিক আর ভুল রসিদ হুবহু এক লেখা। এই scrubber লাগানো snapshot test ১৮০০ আর ১৮৬০ টাকার পার্থক্য কখনো ধরবে না, অথচ test প্রতিবার সবুজ থাকবে। নিয়ম: scrubber যত সরু সম্ভব, প্রতিটির জন্য “এটি ঠিক কোন মান মোছে” প্রশ্নের উত্তর জানা থাকা, আর একটি জানা ভুল ঢুকিয়ে দেখা যে snapshot তবুও ব্যর্থ হয়।

Scrubber-এর আগে: উৎসেই নিয়ন্ত্রণ

Scrubber হলো ব্যান্ডেজ। ভালো সমাধান অনেক সময় অস্থিরতার উৎসটিকেই test-এর হাতে আনা:

উৎসউৎসে নিয়ন্ত্রণনা পারলে
এখনকার সময়ঘড়ি বাইরে থেকে দেওয়া, test-এ fake clock (পর্ব ২৪, Test double আর mocking)আকৃতি-যাচাইকারী scrubber
এলোমেলো id, tokenনির্দিষ্ট seed, বা id তৈরির function test-এ বদলে দেওয়াক্রমিক চিহ্ন (<txn_0>, <txn_1>), যাতে “একই id দুবার” তথ্যটি থাকে
Database-এর id, ক্রমপ্রতিটি test-এ নতুন seed; query-তে ORDER BYতুলনার আগে sort
Python set-এর ক্রমSnapshot-এর আগে sorted()—
দশমিক সংখ্যাটাকা পূর্ণসংখ্যায় বা Decimal-এ (পর্ব ০৮-এর floating point)নির্দিষ্ট ঘর পর্যন্ত গোল করে লেখা
Machine-এর path, locale, time zoneTest-এ path আপেক্ষিক, locale আর TZ নির্দিষ্ট (বাংলাদেশ UTC+6)Path scrubber

ApprovalTests-এর ক্রমিক চিহ্নের ধারণাটি সূক্ষ্ম কিন্তু কাজের। একই id রসিদে দুবার এলে দুটিই <txn_0> হয়; দুটি আলাদা id হলে <txn_0> আর <txn_1>. ফলে “একই অর্ডারে দুবার charge” ধরনের bug, যা পর্ব ৩৭-এ (Playwright-এর উন্নত কৌশল) wallet-এর timeout-এর পরে দেখা গিয়েছিল, scrub করার পরেও snapshot-এ দৃশ্যমান থাকে।

৫ · সত্যিকারের run ২ — ApprovalTests দিয়ে বাংলা রসিদ

বাজারঘরের কপিতে একটি ছোট render_receipt function যোগ করা হলো (মূল shared app অপরিবর্তিত): অর্ডারের JSON থেকে একটি বাংলা লেখার রসিদ, যা গ্রাহক SMS বা প্রিন্টে পাবেন। এমন output-এ approval test সবচেয়ে মানায়: লম্বা, মানুষের পড়ার জন্য, আর প্রতিটি লাইনের প্রত্যাশা হাতে লেখা বিরক্তিকর। ApprovalTests-এর Python সংস্করণে test:

from approvaltests import Options, verify
from approvaltests.reporters import PythonNativeReporter
from approvaltests.scrubbers import combine_scrubbers, create_regex_scrubber

from receipt import render_receipt

scrubber = combine_scrubbers(
    create_regex_scrubber(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\+06:00", lambda n: f"<time_{n}>"),
    create_regex_scrubber(r"FAKE-[0-9A-F]{12}", lambda n: f"<txn_{n}>"),
)


def test_receipt(paid_order):
    verify(render_receipt(paid_order),
           options=Options().with_scrubber(scrubber).with_reporter(PythonNativeReporter()))

Reporter ঠিক করে ব্যর্থ হলে পার্থক্য কীভাবে দেখাবে। Default-এ ApprovalTests কম্পিউটারে ইনস্টল করা একটি diff টুল খোঁজে আর খোলে; PythonNativeReporter সোজা console-এ unified diff ছাপে, যা CI-র জন্য ঠিক। প্রথম run-এর সত্যিকারের আউটপুট (path ছোট করা):

$ uv run pytest tests/test_receipt_approval.py -s
approved_path check …/tests/test_receipt_approval.test_receipt.approved.txt
--- test_receipt_approval.test_receipt.approved.txt
+++ test_receipt_approval.test_receipt.received.txt
@@ -0,0 +1,11 @@
+বাজারঘর · রসিদ
+অর্ডার #8 · <time_0>
+------------------------------
+সয়াবিন তেল ৫ লিটার: 1 × 880 = 880
+আলু ২ কেজি: 1 × 121 = 121
+------------------------------
+পণ্যের দাম: 1001
+কুপন ছাড়: -100
+ডেলিভারি (Dhaka): 60
+মোট: 961 টাকা
+পেমেন্ট: mobile-wallet · <txn_0>

to approve this result:

move "…\test_receipt_approval.test_receipt.received.txt" "…\test_receipt_approval.test_receipt.approved.txt"
…
E       approvaltests.approval_exception.ApprovalException: Approval Mismatch, received != approved
1 failed in 1.00s

তিনটি জিনিস দেখার মতো। প্রথমত, approved ফাইল ছিল না, তাই reporter একটি খালি approved ফাইল বানিয়ে তার সাথে তুলনা করেছে; সব লাইন +. দ্বিতীয়ত, received ফাইলটি test ফাইলের পাশে রয়ে গেছে, পরীক্ষা করার জন্য। তৃতীয়ত, approve করার উপায়টি আক্ষরিক অর্থেই একটি ফাইল সরানো: received-কে approved নামে রাখা। কোনো জাদু নেই, আর এজন্যই প্রক্রিয়াটি স্বচ্ছ: approved ফাইল code-এর মতোই commit হয়, review হয়। (প্রথম approved_path check … লাইনটি library নিজে ছাপে।)

রসিদটি পড়ে হিসাব মেলানো হলো: ৮৮০ + ১২১ = ১০০১, ১০০০-এর বেশি তাই ছাড় ১০০ (১০০.১ থেকে ভগ্নাংশ বাদ), ঢাকায় ২০০০-এর কম তাই delivery ৬০, মোট ১০০১ − ১০০ + ৬০ = ৯৬১. ঠিক। Approve করে কয়েক সেকেন্ডের ব্যবধানে দুবার run: দুবারই 1 passed, আর পাস করলে received ফাইল আপনা থেকে মুছে যায়।

একটি ইচ্ছাকৃত বদল

নতুন requirement: রসিদে গ্রাহকের ফোন নম্বর থাকবে, কিন্তু শুধু প্রথম ৩টি আর শেষ ৪টি অঙ্ক দেখা যাবে, মাঝের অঙ্কগুলো লুকানো। Developer render_receipt-এ একটি লাইন যোগ করলেন। সত্যিকারের run:

--- test_receipt_approval.test_receipt.approved.txt
+++ test_receipt_approval.test_receipt.received.txt
@@ -1,5 +1,6 @@
 বাজারঘর · রসিদ
 অর্ডার #8 · <time_0>
+ফোন: 017****5678
 ------------------------------
 সয়াবিন তেল ৫ লিটার: 1 × 880 = 880
 আলু ২ কেজি: 1 × 121 = 121

Diff-এ ঠিক একটি + লাইন, বাকি সব অপরিবর্তিত। Reviewer requirement মিলিয়ে দেখেন: 01712345678-এর প্রথম তিন অঙ্ক 017, শেষ চার 5678, মাঝে চারটি তারা, কারণ লুকানো অঙ্কও চারটি (1234). নিয়ম মিলেছে, আর শুধু এটুকু নিশ্চিত হয়েই approve. এখানে একটি ভাবনার বিষয়ও আছে: নম্বর কম অঙ্কের হলে কী হবে? Approval test একটি নির্দিষ্ট অর্ডারের রসিদ দেখে; ১১ অঙ্কের বাইরের নম্বরের আচরণ তার কাছে অদৃশ্য। সেটির জন্য আলাদা ছোট assertion লাগবে।

tests/ ফোল্ডারে test_receipt-এর ফাইল
.approved.txt
.received.txt
diff
ফল
  1. প্রথম verify. Approved ফাইল নেই। Library একটি খালি approved ফাইল বানায়, এই run-এর ১১ লাইনের রসিদ received-এ লেখে, আর FAIL.
  2. পড়ে অনুমোদন। একজন মানুষ received ফাইল পড়ে নিয়ম মেলান (১০০১, ছাড় ১০০, delivery ৬০, মোট ৯৬১), তারপর ফাইলটি approved নামে সরান।
  3. পরপর দুটি run. সময় আর লেনদেন id আলাদা, কিন্তু scrubber-এর পরে লেখা হুবহু এক: দুবারই PASS, আর received ফাইল মুছে যায়।
  4. ইচ্ছাকৃত বদল। ফোনের লাইন যোগ হলো। Diff-এ শুধু +ফোন: 017****5678, FAIL. এই FAIL খারাপ খবর নয়; test জানাচ্ছে যে output বদলেছে, আর অনুমোদন চাইছে।
  5. Requirement মিলিয়ে approve. Mask-এর নিয়ম মিলেছে, তাই received আবার approved হলো, এখন ১২ লাইন। এই বদল একটি আলাদা commit-এ, কারণসহ, যাতে review-তে বোঝা যায় রসিদ কেন বদলাল।

বাংলা লেখার snapshot-এ বাড়তি সাবধানতা

  • Encoding: Approved ফাইল UTF-8-এ লেখা আর পড়া নিশ্চিত করুন। Windows-এর পুরোনো default encoding-এ বাংলা ভেঙে যায়, তখন প্রতিটি অক্ষরেই diff. এই run-এ library নিজেই UTF-8 ব্যবহার করেছে।
  • চোখে এক, ভেতরে আলাদা: “য়” একটি code point (U+09DF) হিসেবেও লেখা যায়, আবার য + ় দুটি code point হিসেবেও। Snapshot হুবহু তুলনা করে, তাই চোখে একই লাইনেও diff আসতে পারে, যা diff-এ দেখে বোঝা প্রায় অসম্ভব। বাজারঘরের search-এ এই Unicode normalization-এর একটি সত্যিকারের finding পর্ব ৫৬-এ (Localization testing) এসেছে। বাংলা output-এর snapshot-এ লেখাকে আগে NFC-তে আনা ভালো অভ্যাস।
  • অঙ্ক: রসিদে টাকার অঙ্ক Latin না বাংলা হবে, তা একটি product সিদ্ধান্ত। Snapshot সেই সিদ্ধান্তকে পাহারা দেয়, কিন্তু নিজে সিদ্ধান্ত নেয় না।

৬ · Golden master, inline snapshot আর অন্য ভাষার টুল

৩২টি সমন্বয়ের golden master

Legacy pricing code refactor করার আগে হাজারো input-এ তার আচরণ এক ফাইলে রাখতে চাইলে ApprovalTests-এর combination approvals কাজে লাগে। Coupon আর delivery-র সীমা থেকে ৮টি subtotal (৯৯৯, ১০০০, ১০০১, ১৯৯৯, ২০০০, ২০০১, ৩০০৯, ৩০১০), ২টি জেলা (ঢাকা, রাজশাহী) আর Plus সদস্য কি না (২টি মান): মোট ৮ × ২ × ২ = ৩২টি সমন্বয়, প্রতিটির quote একটি লাইনে:

def test_quote_golden_master():
    verify_all_combinations(
        lambda s, d, plus: quote(s, d, plus, bugs=BUGS),
        [[999, 1000, 1001, 1999, 2000, 2001, 3009, 3010], ["Dhaka", "Rajshahi"], [False, True]],
        options=Options().with_reporter(PythonNativeReporter()))

ফাইলটি অনুমোদনের পরে app-এর দুটি pricing ভুল একে একে চালু করে চালানো হলো। সত্যিকারের diff, লাইন ছোট করা ({…}-এর ভেতরে শুধু বদলানো মান):

# coupon_ge: "> 1000"-এর জায়গায় ">= 1000"
-args: (1000, 'Dhaka', False) => {… 'discount': 0, … 'total': 1060}
+args: (1000, 'Dhaka', False) => {… 'discount': 100, … 'total': 960}
   … একই রকম আরও ৩টি জোড়া: (1000, 'Dhaka', True), (1000, 'Rajshahi', False/True)

# delivery_after_discount
-args: (2000, 'Dhaka', False) => {… 'delivery': 0, 'total': 1800}
+args: (2000, 'Dhaka', False) => {… 'delivery': 60, 'total': 1860}
-args: (2001, 'Dhaka', False) => {… 'delivery': 0, 'total': 1801}
+args: (2001, 'Dhaka', False) => {… 'delivery': 60, 'total': 1861}
   … আর একই দুটি, Plus সদস্যের জন্য (True)

প্রতিটি ভুল ৩২টির মধ্যে ঠিক ৪টি লাইনে ধরা পড়েছে, আর ঠিক যেখানে পড়ার কথা: coupon ভুল শুধু ১০০০-এ, delivery ভুল ঢাকার ২০০০ আর ২০০১-এ। কিন্তু খেয়াল করুন, golden master ততটুকুই রক্ষা করে যতটুকু input তালিকায় আছে। Input-গুলো এসেছে পর্ব ০৮-এর সীমা থেকে; এলোমেলো input নিলে ১০০০ বাদ পড়তেই পারত। ৩২টি সমন্বয় কম, কিন্তু বেশি factor হলে সমন্বয় দ্রুত বাড়ে; তখন পর্ব ১১-এর (Pairwise আর combinatorial testing) কৌশল কাজে আসে, আর approvaltests-এ pairwise ধরনের একটি function-ও আছে (verify_best_covering_pairs). Golden master-টি কত ভালো, তা মাপার একটি পদ্ধতি হলো ইচ্ছা করে ভুল বসিয়ে দেখা, ধরা পড়ে কি না: ঠিক এটাই পর্ব ৫৯-এর (Mutation testing) বিষয়।

Inline snapshot — প্রত্যাশা test-এর ভেতরেই

আলাদা ফাইলের snapshot-এর একটি অসুবিধা: test পড়ার সময় প্রত্যাশা চোখে পড়ে না, review-তে আরেকটি ফাইল খুলতে হয়। Inline snapshot মানটি test-এর code-এর ভেতরেই লিখে দেয়। Python-এর inline-snapshot package-এ test শুরু হয় ফাঁকা snapshot() দিয়ে:

def test_quote_2000_dhaka(client):
    q = client.get("/api/pricing/quote", params={"subtotal": 2000, "district": "Dhaka"}).json()
    assert q == snapshot()

--inline-snapshot=create দিয়ে run করার পরে টুলটি নিজেই test ফাইলের শেষ লাইন বদলে দিয়েছে (সত্যিকারের ফল):

    assert q == snapshot({'subtotal': 2000, 'discount': 200, 'delivery': 0, 'total': 1800, 'district': 'Dhaka', 'plus': False})

এই run-এ একটি অপ্রত্যাশিত জিনিসও দেখা গেছে: ফাঁকা snapshot()-এ সাধারণ run দিলে test নিজে পাস হয়, কিন্তু teardown-এ একটি ERROR আসে (your snapshot is missing one value), তাই CI ব্যর্থ হয়। আর টুলটি সতর্ক করেছে যে code সাজানোর (format) টুল না থাকায় বদলানো লাইনটি সাজানো যায়নি; সেজন্যই লাইনটি এত লম্বা। এবার delivery ভুল চালু করে:

E       AssertionError: assert {'subtotal': ...l': 1860, ...} == {'subtotal': ...l': 1800, ...}
E         Omitting 4 identical items, use -vv to show
E         Differing items:
E         {'total': 1860} != {'total': 1800}
E         {'delivery': 60} != {'delivery': 0}
FAILED tests/test_quote_inline.py::test_quote_2000_dhaka - AssertionError: as...

এক শব্দে বিপদ, fix: inline-snapshot-এর --inline-snapshot=fix ব্যর্থ মানগুলো test ফাইলে নতুন মান দিয়ে বসিয়ে দেয়। সত্যিকারের run-এ ভুল চালু রেখে fix দেওয়া হলো, আর test ফাইলের লাইনটি হয়ে গেল 'delivery': 60, 'total': 1860, test সবুজ। Source code বদলায় বলে বদলটি অন্তত code review-তে দেখা যায়, কিন্তু test সারানোর তাড়ায় কেউ এটি চালালে bug এখন test ফাইলেই লেখা। এরপর আসল test ফাইল ফিরিয়ে আনা হয়েছে।

অন্য ভাষায় একই ধারণা

ভাষাটুল বা APIহালনাগাদের আদেশ
Pythonsyrupy, inline-snapshot, approvaltests--snapshot-update, --inline-snapshot=…, ফাইল সরানো
JavaScriptJest আর Vitest-এর toMatchSnapshot, toMatchInlineSnapshot-u
Java, C#ApprovalTests-এর সংস্করণ; .NET-এ Verify নামের একটি জনপ্রিয় libraryফাইল approve করা
Goঅনেক project-এ testdata/*.golden golden file আর একটি -update flag-এর প্রচলননিজেদের flag

JavaScript দিকটি আগেই এসেছে: JavaScript কোর্সের পর্ব ৪৮ আর Full-Stack কোর্সের পর্ব ৭৩-এ Vitest-এর snapshot আর তার অন্ধ অনুমোদনের বিপদ। এখানে সেগুলো আবার শেখানো হলো না; ধারণা আর ফাঁদ সব ভাষায় একই।

৭ · কখন snapshot, কখন assertion — আর review-এর শৃঙ্খলা

Snapshot আর assertion প্রতিযোগী নয়, দুটি আলাদা প্রশ্নের উত্তর। Assertion বলে “এটা এমন হওয়া উচিত”, তাই তার oracle requirement. Snapshot বলে “এটা আগের মতোই আছে”, তাই তার oracle অতীত। দুটির পার্থক্য সবচেয়ে স্পষ্ট হয় যখন code-এ শুরু থেকেই ভুল থাকে। নিচের pytest run-এ coupon-এ পর্ব ০৮-এর সেই off-by-one ভুল (>=), আর snapshot রেকর্ড করা হয়েছে এই ভুল build থেকেই, যেভাবে প্রথম দিন অনেক দল করে:

import os, sys, pytest
os.makedirs("/home/pyodide/p61", exist_ok=True)
os.chdir("/home/pyodide/p61"); sys.path.insert(0, os.getcwd())
for m in ("pricing61", "test_coupon61"):
    sys.modules.pop(m, None)             # re-run after you edit the code

open("pricing61.py", "w").write('''
def coupon(subtotal):                    # seeded defect: >= instead of >
    return min(subtotal // 10, 300) if subtotal >= 1000 else 0
''')
open("test_coupon61.py", "w").write('''
import pytest
from pricing61 import coupon

# recorded by running THIS build once and saving whatever came out
SNAPSHOT = {999: 0, 1000: 100, 1001: 100, 3010: 300}

def test_matches_snapshot():
    assert {s: coupon(s) for s in SNAPSHOT} == SNAPSHOT

# written from the requirement: "more than 1000 -> 10 %, at most 300"
@pytest.mark.parametrize(("subtotal", "expected"),
                         [(1000, 0), (1001, 100), (3010, 300)])
def test_requirement(subtotal, expected):
    assert coupon(subtotal) == expected
''')
pytest.main(["-q", "--no-header", "-p", "no:cacheprovider", "test_coupon61.py"])

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

.F..                                                                     [100%]
=================================== FAILURES ===================================
___________________________ test_requirement[1000-0] ___________________________

subtotal = 1000, expected = 0

    @pytest.mark.parametrize(("subtotal", "expected"),
                             [(1000, 0), (1001, 100), (3010, 300)])
    def test_requirement(subtotal, expected):
>       assert coupon(subtotal) == expected
E       assert 100 == 0
E        +  where 100 = coupon(1000)

test_coupon61.py:15: AssertionError
=========================== short test summary info ============================
FAILED test_coupon61.py::test_requirement[1000-0] - assert 100 == 0
1 failed, 3 passed in 0.02s

চারটি test-এর তিনটি পাস। Snapshot test পাস, কারণ snapshot ভুল build থেকেই রেকর্ড করা: 1000: 100 এখন “সত্য”। Requirement থেকে লেখা parametrize করা test-এর তিনটি সারির একটি ব্যর্থ: ১০০০ টাকায় ছাড় হওয়া উচিত ০, পাওয়া গেছে ১০০. সীমার ভুল ধরল সেই test, যার প্রত্যাশা requirement থেকে এসেছে। Snapshot কাজে আসত শুধু পরে, যদি কেউ এই আচরণ বদলাত; তার আগের ভুলের ব্যাপারে সে অন্ধ। (সময়ের সংখ্যাটি প্রতিবার সামান্য আলাদা হতে পারে।)

প্রশ্ন: প্রত্যাশা কি এক বাক্যে লেখা যায়? output কি বড় আর স্থির?
পরিস্থিতি
প্রত্যাশা
বাছাই
  1. এক বাক্যের নিয়ম: assertion. “১০০০ টাকার বেশি হলে ছাড়” requirement-এ লেখা, প্রত্যাশা এক লাইনের। এখানে snapshot ভুল build থেকে রেকর্ড হলে ভুলটিই পাহারা পায়, যা ওপরের run-এ দেখা গেল।
  2. বড় JSON: দুটোই। ২০টির বেশি field হাতে লেখা বিরক্তিকর আর ভুলপ্রবণ। Scrub করা snapshot অপ্রত্যাশিত বদল ধরে; আর মোট টাকার মতো ব্যবসার মূল field-এ একটি আলাদা assertion রাখুন, যাতে সেটির ব্যর্থতা একটি নামওয়ালা test-এ আসে।
  3. মানুষের পড়ার লেখা: approval. রসিদ, চিঠি, report-এ “ঠিক কি না” বিচার করেন মানুষ। Approved ফাইল সেই বিচারকে স্থায়ী করে, আর diff ভবিষ্যতের প্রতিটি বদল দেখায়।
  4. অজানা পুরোনো আচরণ: golden master. কী হওয়া উচিত কেউ নিশ্চিত নন, কিন্তু refactor-এ আচরণ যেন না বদলায়। অনেক input-এ রেকর্ড, refactor, তারপর ধীরে ধীরে requirement-ভিত্তিক test দিয়ে প্রতিস্থাপন। পর্ব ২৫-এর characterization test-এর ধারণা এটাই।
  5. অস্থির output: আগে উৎস। Snapshot-এর আগে ঘড়ি, seed, ক্রম test-এর হাতে আনুন। যা বাকি থাকে, শুধু তার জন্য সরু, আকৃতি-যাচাইকারী scrubber.

Snapshot-এর গন্ধ — কখন বুঝবেন গোলমাল

  • বিশাল snapshot: শত শত লাইনের ফাইল কেউ পড়েন না। Snapshot হোক ছোট আর একটি বিষয়ের; পুরো পাতার HTML-এর বদলে দরকারি অংশটুকু।
  • প্রতিটি PR-এ snapshot বদল: তাহলে snapshot implementation-এর খুঁটিনাটিতে বাঁধা, অর্থাৎ একটি brittle test. ঘনঘন বদল মানুষকে না পড়ে approve করতে শেখায়।
  • নামহীন snapshot: এক test-এ পাঁচটি snapshot, ব্যর্থ হলে বোঝা যায় না কোনটি কী বোঝায়। প্রতিটির অর্থপূর্ণ নাম দিন।
  • Snapshot-ই একমাত্র test: তাহলে requirement কোথাও লেখা নেই। Snapshot হোক জালের একটি স্তর, পুরো জাল নয়।

Pull request-এ snapshot বদলের review

  • CI কখনো update করবে না। CI শুধু তুলনা করে আর diff রিপোর্টে রাখে। syrupy নিজে থেকে নতুন snapshot লেখে না, যা এই run-এ দেখা গেল; Jest-এর --ci flag-ও নতুন snapshot লেখা বন্ধ রাখে বলে তার নথিতে বলা আছে।
  • Snapshot বদল আলাদা commit-এ, কারণসহ: “রসিদে mask করা ফোন যোগ, ticket অনুযায়ী”. Code-এর বদল আর snapshot-এর বদল একসাথে মিশলে reviewer বুঝতে পারেন না কোনটি কারণ, কোনটি ফল।
  • Diff পড়ার সময় একটি প্রশ্ন: প্রতিটি -/+ জোড়ার জন্য, “এই বদল কি এই PR-এর উদ্দেশ্যের অংশ?” না হলে সেটি একটি পার্শ্বপ্রতিক্রিয়া, সম্ভবত bug.
  • Received ফাইল commit নয়: ApprovalTests-এর received ফাইল repository-তে ঢোকানো উচিত নয়; অনেক দল এজন্য *.received.* ignore-তালিকায় রাখে।
  • পরিবর্তন ছোট রাখা: একসাথে ৫০টি snapshot বদলালে (একটি formatter-এর update) আলাদা PR করুন, আর কয়েকটি নমুনা সত্যিই পড়ুন; বাকিগুলোর diff একই ধরনের কি না মিলিয়ে নিন।

এই নিয়মগুলো পর্ব ৪১-এর baseline ছবির approve-এর নিয়মের মতোই, শুধু ছবির জায়গায় লেখা। Code review-এর সাধারণ নিয়ম পর্ব ০৬-এ (Static testing), আর CI-তে test-এর stage আর gate পর্ব ৬৪ (CI-তে test pipeline — stage, parallel, gate আর দ্রুত feedback)-এ আসবে।

আরও গভীরে: Testing গবেষণায় “oracle problem” হলো সঠিক উত্তর কীভাবে জানা যাবে সেই প্রশ্ন। Barr, Harman ও সহকর্মীদের ২০১৫ সালের IEEE TSE-র একটি সমীক্ষা প্রবন্ধ oracle-গুলোকে ভাগ করে: নির্দিষ্ট (specification থেকে), উদ্ভূত (derived: আগের সংস্করণ, অন্য implementation থেকে), আর অন্তর্নিহিত (implicit: crash না হওয়া)। Snapshot আর golden master উদ্ভূত oracle-এর একটি রূপ, regression oracle. এর সীমা তাই মৌলিক: আগের সংস্করণ যত ঠিক, snapshot তত ঠিক। Property-based testing (পর্ব ৫৮, Property-based testing) এই সমস্যা আরেক দিক থেকে ধরে, নির্দিষ্ট মানের বদলে সব input-এ সত্য থাকা নিয়ম যাচাই করে।

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

  • Snapshot test আর assertion-এর মূল পার্থক্য? Snapshot-এর oracle আগের output, assertion-এর oracle requirement; snapshot বদল ধরে, সঠিকতা নয়।
  • Golden master কখন? Test-হীন legacy code refactor-এর আগে, অনেক input-এ বর্তমান আচরণ রেকর্ড করতে।
  • Snapshot flaky হয় কেন? সময়, এলোমেলো id, ক্রম, locale বা path-এর মতো অস্থির মান; সমাধান উৎসে নিয়ন্ত্রণ, তারপর সরু scrubber.
  • Snapshot update-এর ঝুঁকি? Diff না পড়ে update করলে ভুল output অনুমোদিত হয়; CI-তে update নিষেধ, বদল review-তে আলাদা commit-এ।
  • Scrubber কতটা চওড়া হবে? যত সরু সম্ভব; চওড়া scrubber আসল bug-ও মুছে দেয়, একটি জানা ভুল বসিয়ে যাচাই করুন।

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

AI সহকারীকে একটি failing test সারিয়ে দিতে বললে snapshot-এর ক্ষেত্রে সবচেয়ে সহজ পথটি প্রায়ই update-এর আদেশ। টেস্ট সবুজ হয়, আর কেউ জানতেও পারেন না যে একটি bug এইমাত্র অনুমোদিত হলো। AI-এর লেখা test-এর সাধারণ দুর্বলতাগুলো এখানে বিশেষ রূপ নেয়:

AI-এর ভুলSnapshot-এ যা দেখায়যাচাই
বর্তমান আচরণকেই প্রত্যাশা ধরাভুল build থেকে snapshot রেকর্ড করে “সব test পাস”প্রথম snapshot নিজে পড়ে requirement মেলানো
ব্যর্থ test “ঠিক” করা--snapshot-update, -u বা fix চালানোর পরামর্শDiff-এর প্রতিটি লাইনের কারণ জিজ্ঞেস করা
অতিরিক্ত চওড়া scrubber\d+ বা পুরো লাইন মুছে দেওয়াএকটি জানা ভুল বসিয়ে snapshot ব্যর্থ হয় কি না দেখা
বিশাল snapshotপুরো পাতার HTML বা পুরো database dumpদরকারি অংশে ছোট করা
টুলের option বানানোনেই এমন flag বা matcherpytest --help আর টুলের নিজস্ব নথি
না চালিয়ে “pass” দাবিSnapshot ফাইলই তৈরি হয়নিনিজে চালানো, ফাইল আর diff দেখা

AI-কে snapshot test লিখতে বললে প্রশ্নটি এভাবে বাঁধুন, যাতে requirement আর snapshot-এর ভূমিকা আলাদা থাকে, আর update-এর সিদ্ধান্ত আপনার হাতে থাকে:

আমি pytest আর syrupy দিয়ে একটি অনলাইন দোকানের অর্ডারের JSON-এর snapshot test লিখছি। JSON-এ created_at, paid_at আর txn_id প্রতিবার বদলায়। নিয়ম: ১০০০ টাকার বেশি অর্ডারে ১০% ছাড়, সর্বোচ্চ ৩০০, ভগ্নাংশ বাদ; ঢাকায় delivery ৬০, ছাড়ের আগের দাম ২০০০ বা বেশি হলে ফ্রি। ১. syrupy-র path_value দিয়ে শুধু ওই তিন ধরনের field-এর জন্য scrubber লেখো, যা মানের আকৃতিও যাচাই করে। ২. ছাড় আর delivery-র নিয়মের জন্য snapshot নয়, আলাদা parametrize করা assertion দাও, সীমার মানসহ। ৩. কোনো অবস্থায় --snapshot-update চালাতে বলবে না; ব্যর্থ হলে diff-এর প্রতিটি লাইন requirement-এর সাথে মিলিয়ে ব্যাখ্যা করবে। ৪. যে option বা function ব্যবহার করবে, তার নাম syrupy-র কোন নথিতে আছে বলো।

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

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

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

প্র ০১Snapshot test কি আসলে “test”? যে test সঠিক উত্তর জানে না, সে কী প্রমাণ করে?

প্রশ্নটি testing-এর একটি পুরোনো সমস্যায় পৌঁছায়, যাকে বলে oracle problem. Elaine Weyuker ১৯৮২ সালের একটি প্রবন্ধে “non-testable” program নিয়ে লেখেন: এমন program, যার সঠিক output আগে থেকে জানা কঠিন বা অসম্ভব, যেমন জটিল বৈজ্ঞানিক হিসাব। তাঁর একটি পরামর্শ ছিল আংশিক oracle ব্যবহার, অর্থাৎ পুরো উত্তর না জেনেও কিছু অংশ যাচাই করা। পরে Barr, Harman ও সহকর্মীদের ২০১৫ সালের সমীক্ষায় oracle-কে কয়েক ভাগে দেখানো হয়, যার একটি উদ্ভূত oracle: আগের সংস্করণ বা অন্য implementation থেকে পাওয়া উত্তর।

Snapshot ঠিক এই উদ্ভূত oracle. সে প্রমাণ করে না যে output ঠিক; প্রমাণ করে যে output বদলায়নি। এটি দুর্বল দাবি মনে হতে পারে, কিন্তু refactoring-এ ঠিক এই দাবিটিই দরকার: “আমি গঠন বদলেছি, আচরণ নয়।” Martin Fowler-এর সংজ্ঞায় refactoring মানেই বাইরের আচরণ না বদলে ভেতরের গঠন বদলানো, আর snapshot সেই “না বদলানো”-র যাচাই।

সমস্যা শুরু হয় যখন দল এই দুই দাবি গুলিয়ে ফেলে। ওপরের pytest run-এ snapshot test পাস করেছে, অথচ code-এ সীমার ভুল ছিল, কারণ snapshot ভুল build থেকেই রেকর্ড করা। Snapshot-কে তখন “সঠিকতার প্রমাণ” ভাবলে ভুল নিশ্চিন্ততা আসে। এজন্যই প্রথম snapshot-এর অনুমোদন সবচেয়ে গুরুত্বপূর্ণ ধাপ: সেই মুহূর্তে একজন মানুষ নির্দিষ্ট oracle-এর কাজ করেন, requirement মিলিয়ে, আর তারপর থেকে snapshot সেই মানুষের বিচারকে পাহারা দেয়।

মূল উপলব্ধি: Snapshot test একটি সত্যিকারের test, কিন্তু অন্য প্রশ্নের: “বদলেছে কি?” “ঠিক কি?” প্রশ্নের উত্তর আসে requirement-ভিত্তিক assertion বা প্রথম অনুমোদনের সময় মানুষের সাবধান পড়া থেকে।

প্র ০২দলে শত শত snapshot, প্রতিটি PR-এ কয়েকটি বদলায়, আর সবাই না পড়ে update করে। সমস্যাটি কোথায়, আর কীভাবে সারাবেন?

এটি snapshot testing-এর সবচেয়ে পরিচিত ব্যর্থতা, যাকে অনেকে “approval fatigue” বা অনুমোদনের ক্লান্তি বলেন। কারণটি মানুষের মনোবিজ্ঞানে: একটি সতর্কবার্তা বারবার মিথ্যা অ্যালার্ম দিলে মানুষ তাকে উপেক্ষা করতে শেখে। হাসপাতালের যন্ত্রের অ্যালার্ম নিয়ে গবেষণায় একে “alarm fatigue” বলা হয়, আর snapshot-এর ক্ষেত্রেও একই জিনিস ঘটে। যদি দশটির মধ্যে নয়টি snapshot বদল নিরীহ হয় (একটি CSS class-এর নাম, একটি নতুন field), তবে দশমটি, যেটি আসল bug, সেটিও একই অভ্যাসে update হয়ে যায়। Test এখন উল্টো কাজ করছে: সময় নিচ্ছে, কিন্তু নিরাপত্তা দিচ্ছে না।

মূল কারণ সাধারণত তিনটি। এক, snapshot বড়: পুরো পাতার HTML বা পুরো API response, ফলে যেকোনো ছোট বদলে diff আসে। দুই, snapshot implementation-এ বাঁধা: ভেতরের class নাম, key-এর ক্রম, অপ্রাসঙ্গিক field. তিন, update খুব সহজ: একটি flag, কোনো বাধা নেই।

সমাধানও তিন স্তরে। নকশায়: snapshot ছোট আর একটি বিষয়ের, শুধু দরকারি field (যেমন pricing অংশটুকু), অপ্রাসঙ্গিক অংশ বাদ বা সরু scrubber দিয়ে স্থির। প্রক্রিয়ায়: snapshot বদল আলাদা commit-এ, CI কখনো update করবে না, আর reviewer-এর জন্য নিয়ম “প্রতিটি -/+ জোড়ার কারণ PR-এর বিবরণে”. মাপে: কতগুলো snapshot প্রতি মাসে বদলায় আর কতবার একটি snapshot ব্যর্থতা সত্যিকারের bug ধরেছে, তা গুনে দেখা। যে snapshot কখনো bug ধরেনি অথচ প্রতি সপ্তাহে বদলায়, সেটি মুছে একটি ছোট assertion লেখাই ভালো।

মূল উপলব্ধি: Snapshot-এর মূল্য নির্ভর করে diff-এর একটি লাইন একজন মানুষ সত্যিই পড়েন কি না তার ওপর। যে নকশা পড়া কঠিন করে, তা test-এর মূল্যই শেষ করে দেয়।

প্র ০৩Test নেই এমন একটি পুরোনো pricing module ঠিক করতে হবে। Golden master দিয়ে কীভাবে শুরু করবেন, আর কখন থামবেন?

Michael Feathers ২০০৪ সালের বইয়ে legacy code-কে সংজ্ঞায়িত করেন “test ছাড়া code” হিসেবে, আর তার সমস্যাকে বলেন একটি দুষ্টচক্র: বদলাতে test দরকার, test বসাতে বদল দরকার। Golden master এই চক্র ভাঙার একটি কৌশল। এই কৌশল শেখানোর জন্য Gilded Rose নামের একটি কাল্পনিক দোকানের code-অনুশীলন (kata) প্রচলিত, যা Emily Bache-এর হাতে অনেক ভাষায় ছড়িয়েছে বলে জানা যায়; সেখানেও প্রথম ধাপ সাধারণত পুরো output রেকর্ড করা।

বাজারঘরে ধাপগুলো এমন। প্রথমে input বাছাই: এলোমেলো নয়, সীমা থেকে। Coupon-এর ১০০০/১০০১, delivery-র ২০০০, cap-এর ৩০০৯/৩০১০, প্রতিটি জেলার ধরন আর Plus সদস্যপদ। দ্বিতীয়ত সব সমন্বয় একটি approved ফাইলে (এই পর্বে ৩২টি)। তৃতীয়ত golden master-এর শক্তি যাচাই: ইচ্ছা করে কয়েকটি ভুল বসানো, যেমন >-কে >=; এই পর্বের run-এ দুটি ভুলই ৪টি করে লাইনে ধরা পড়েছে। কোনো ভুল ধরা না পড়লে input বাড়াতে হবে; এটিই mutation testing-এর মূল ধারণা। চতুর্থত ছোট ধাপে refactor, প্রতিটি ধাপের পরে golden master সবুজ।

কখন থামবেন? Golden master সারাজীবনের জন্য নয়। এটি আজকের আচরণ পাহারা দেয়, ভুলসহ। Refactor শেষে code পড়ার মতো হলে প্রতিটি নিয়মের জন্য requirement থেকে নামওয়ালা test লিখুন। পুরোনো আচরণে ভুল পেলে (যেমন পর্ব ২৫-এ ছোট হাতের “dhaka”) সেটি আলাদা সিদ্ধান্ত, product owner-এর সম্মতিতে, আলাদা commit-এ। শেষে golden master মুছে দেওয়া যায়, বা ছোট একটি smoke-স্তর হিসেবে রাখা যায়।

মূল উপলব্ধি: Golden master হলো ভারা, দালান নয়। এটি নিরাপদে refactor করতে দেয়; refactor শেষে তার জায়গা নেয় requirement-ভিত্তিক test.

প্র ০৪একটি snapshot আপনার ল্যাপটপে প্রতিবার পাস করে, কিন্তু CI-তে মাঝে মাঝে ব্যর্থ হয়। কোথায় খুঁজবেন?

এটি non-determinism-এর ক্লাসিক লক্ষণ, আর কারণ প্রায়ই পরিবেশের পার্থক্যে। খোঁজার একটি তালিকা:

  • Set-এর ক্রম: Python 3.3 থেকে string-এর hash প্রতিটি process-এ এলোমেলো seed নেয় (hash randomization), তাই string-এর একটি set এক run-এ এক ক্রমে, অন্য run-এ অন্য ক্রমে বের হতে পারে। dict Python 3.7 থেকে যোগ করার ক্রম রাখে, কিন্তু set রাখে না। সমাধান: snapshot-এর আগে sorted().
  • Time zone আর তারিখ: ল্যাপটপ ঢাকার সময়ে (UTC+6), CI server হয়তো UTC-তে। রাত বারোটার কাছাকাছি “আজকের তারিখ” দুই জায়গায় আলাদা। সমাধান: ঘড়ি test-এর হাতে, আর time zone নির্দিষ্ট।
  • Locale: সংখ্যা বা তারিখ সাজানোর নিয়ম locale-ভেদে আলাদা।
  • Path আর line ending: Windows-এ \, Linux-এ /; লাইনের শেষ CRLF বনাম LF. Snapshot-এ path থাকলে তা আপেক্ষিক করুন।
  • Test-এর ক্রম আর shared state: CI হয়তো test parallel-এ বা অন্য ক্রমে চালায়, ফলে database-এর id বদলায়। প্রতিটি test-এর নিজস্ব seed করা data দরকার।
  • Library-র version: Serializer বা দশমিক ছাপার নিয়ম version-ভেদে বদলাতে পারে। Lockfile দিয়ে version স্থির রাখুন।

খোঁজার কৌশল: CI-র diff-টি পড়ুন; কোন field বদলেছে সেটিই উৎসের ইঙ্গিত। তারপর স্থানীয়ভাবে সেই অবস্থা তৈরি করুন: PYTHONHASHSEED বদলে, TZ=UTC দিয়ে, test-এর ক্রম উল্টে। পর্ব ৪০-এর flaky test খোঁজার পদ্ধতি এখানে হুবহু খাটে।

মূল উপলব্ধি: Snapshot হুবহু তুলনা করে বলে পরিবেশের প্রতিটি পার্থক্যে সংবেদনশীল। এই সংবেদনশীলতা দুর্বলতা নয়; এটি লুকানো অস্থিরতা খুঁজে বের করার একটি যন্ত্র, যদি আপনি diff পড়েন।

প্র ০৫API response-এর জন্য snapshot, JSON Schema আর contract test — তিনটির কাজ কি একই?

না, তিনটি তিন রকম প্রশ্নের উত্তর দেয়, আর শক্তিশালী API test-এ প্রায়ই তিনটিই থাকে।

  • JSON Schema (পর্ব ৩১): গঠন যাচাই করে: কোন field আছে, কোন type, কোন সীমা। total একটি পূর্ণসংখ্যা কি না দেখে, কিন্তু ৯৬১ নাকি ১০৬১, তা দেখে না। Schema drift ধরে, মানের ভুল ধরে না।
  • Snapshot: নির্দিষ্ট একটি input-এ পুরো মান যাচাই করে, প্রতিটি সংখ্যা আর লেখাসহ। এই পর্বে delivery-র ভুল ধরেছে ঠিক মানের পার্থক্যে। কিন্তু নির্দিষ্ট input-এর বাইরে অন্ধ, আর বৈধ নতুন field যোগ হলেও ব্যর্থ হয়।
  • Contract test (পর্ব ৩২): জিজ্ঞেস করে, যে consumer এই API ব্যবহার করে, তার দরকারি অংশটুকু কি এখনো আছে? Consumer-এর দৃষ্টিকোণ থেকে লেখা, তাই নতুন field যোগ হলে ব্যর্থ হয় না, শুধু ব্যবহৃত অংশ ভাঙলে হয়।

একটি বাস্তব উদাহরণ: বাজারঘরের অর্ডার API-তে একটি নতুন field estimated_delivery যোগ হলো। Schema test পাস (অতিরিক্ত field অনুমোদিত হলে), contract test পাস (mobile app এই field ব্যবহার করে না), snapshot ব্যর্থ, আর reviewer-কে approve করতে হবে। উল্টো দিকে, total-এ হিসাবের ভুল হলে schema আর contract দুটোই পাস করতে পারে (type ঠিক আছে), কিন্তু snapshot ধরবে, যদি সেই input snapshot-এ থাকে।

তাই বাছাই নির্ভর করে কোন ঝুঁকি বড় তার ওপর। অনেক consumer থাকলে contract, গঠনের স্থিতিশীলতা জরুরি হলে schema, হিসাবের সূক্ষ্মতা জরুরি হলে কয়েকটি সীমার input-এ scrub করা snapshot, আর মূল নিয়মে assertion.

মূল উপলব্ধি: প্রতিটি কৌশল একটি নির্দিষ্ট ধরনের ভুলের জন্য জাল। কোন ভুল কোন জালে আটকায় না, সেটি জানাই একজন পরিণত tester-এর লক্ষণ।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মিলিয়ে নিন।

  1. Test design — রসিদের কোন অংশ কীভাবে: Spec: “অর্ডার শেষে গ্রাহক একটি বাংলা রসিদ পাবেন: অর্ডার নম্বর, তৈরির সময়, mask করা ফোন (প্রথম ৩ আর শেষ ৪ অঙ্ক), প্রতিটি পণ্যের লাইন, পণ্যের দাম, কুপন ছাড়, delivery, মোট, আর পেমেন্টের লেনদেন id.” এর জন্য একটি test পরিকল্পনা করুন: কী approval file-এ, কী আলাদা assertion-এ, কোন scrubber, আর কোন কোন অর্ডার দিয়ে।

    Approval file: পুরো রসিদের লেখা ও বিন্যাস, প্রতিটি নির্বাচিত অর্ডারের জন্য একটি নামওয়ালা approved ফাইল। Scrubber: শুধু তৈরির সময় (আকৃতি-যাচাইসহ) আর লেনদেন id (ক্রমিক চিহ্ন <txn_0>); অর্ডার নম্বর seed থেকে স্থির, তাই scrub নয়।

    আলাদা assertion: (১) মোট = দাম − ছাড় + delivery, (২) ছাড় আর delivery-র নিয়ম সীমায়, (৩) ফোনের mask: ১১ অঙ্কে প্রথম ৩ আর শেষ ৪ দেখা যায়, মাঝে কোনো অঙ্ক নেই। এগুলো requirement-এর নিয়ম, তাই snapshot-এর ওপর ছাড়া যাবে না।

    অর্ডার বাছাই (পর্ব ০৮-এর সীমা থেকে): ১০০০ টাকা ঢাকা (ছাড় ০, delivery ৬০), ১০০১ ঢাকা (ছাড় ১০০), ২০০০ ঢাকা (delivery ফ্রি), ৩০১০ রাজশাহী Plus সদস্য (cap ৩০০, delivery ৬০), আর দুটি লাইনের একটি বাংলা-নামের অর্ডার। প্রতিটি approved ফাইল প্রথমবার হাতে হিসাব মিলিয়ে অনুমোদন।

  2. Failure পড়ুন: একটি PR-এর CI-তে syrupy এই diff দিল (নমুনা আউটপুট, অনুশীলনের জন্য বানানো)। PR-এর শিরোনাম “checkout পাতার বোতামের রং বদল”। (ক) কী বদলেছে? (খ) Snapshot update করবেন কি?
    E             dict({
    E               'delivery': 120,
    E         -     'discount': 300,
    E         +     'discount': 301,
    E               'district': 'Rajshahi',
    E               ...
    E               'subtotal': 3010,
    E         -     'total': 2830,
    E         +     'total': 2829,

    (ক) ৩০১০ টাকার রাজশাহীর অর্ডারে ছাড় ৩০০ থেকে ৩০১ হয়েছে, তাই মোট ১ টাকা কমেছে (৩০১০ − ৩০১ + ১২০ = ২৮২৯). অর্থাৎ ৩০০ টাকার সর্বোচ্চ সীমা (cap) আর কাজ করছে না: min(..., 300) হারিয়েছে বা বদলেছে।

    (খ) না। PR-এর উদ্দেশ্য বোতামের রং; pricing-এর বদল তার অংশ নয়, তাই এটি একটি পার্শ্বপ্রতিক্রিয়া, প্রায় নিশ্চিতভাবে bug. Requirement বলে সর্বোচ্চ ৩০০. Snapshot অপরিবর্তিত রেখে PR-এ মন্তব্য, আর pricing code-এর বদল খোঁজা। “PR-এর উদ্দেশ্যের সাথে diff মেলে কি?” প্রশ্নটিই এখানে bug ধরল।

  3. এই test-এ ভুল খুঁজুন: একজন সহকর্মী flaky snapshot “সারিয়ে” নিচের test পাঠালেন। CI-র script-এ আছে pytest --snapshot-update. অন্তত তিনটি সমস্যা বলুন।
    def test_order(paid_order, snapshot):
        text = json.dumps(paid_order, ensure_ascii=False)
        text = re.sub(r"[0-9]+", "N", text)
        tags = {"fresh", "dhaka", "wallet"}
        assert (text, list(tags)) == snapshot
    • Greedy scrubber: [0-9]+ সব অঙ্ক মুছে দেয়: দাম, ছাড়, delivery, মোট, ফোন, অর্ডার id. Pricing-এর যেকোনো bug এখন অদৃশ্য; শুধু সময় আর লেনদেন id-র জন্য সরু scrubber দরকার।
    • Set-এর ক্রম: list(tags)-এর ক্রম string hash-এর এলোমেলো seed-এর ওপর নির্ভর করে, তাই test নিজেই নতুন flakiness আনল। sorted(tags) দরকার।
    • CI-তে update: --snapshot-update থাকলে CI প্রতিবার নতুন output-কেই snapshot বানায়; test কখনো ব্যর্থ হবে না, অর্থাৎ test আর কিছুই যাচাই করে না। CI-তে শুধু তুলনা।
    • JSON-কে লেখা বানানো: পুরো JSON এক লাইনের string হলে diff হবে একটি বিশাল লাইনের; কোন field বদলেছে পড়া কঠিন। syrupy-কে dict দিন, matcher দিয়ে scrub করুন।
  4. পাতায় চালিয়ে দেখুন: অংশ ২-এর approval_check.py-তে দুটি বদল করুন: (ক) SCRUBBERS থেকে লেনদেন id-র নিয়মটি মুছে run ২-এর ফল অনুমান করুন, তারপর চালান। (খ) নিয়মটি ফিরিয়ে এনে run ৩-এর রসিদে delivery ঠিক রেখে (০, ১৮০০) শুধু "অর্ডার #8"-কে "অর্ডার #9" করুন। কী দেখবেন, আর এটি কি bug?

    (ক) run ২ এখন FAIL: diff-এ শুধু পেমেন্টের লাইন, -পেমেন্ট: FAKE-0A1B2C3D4E5F আর +পেমেন্ট: FAKE-99AA88BB77CC. সময় তখনও scrub হচ্ছে, তাই সেই লাইন মেলে। এটি দেখায় প্রতিটি অস্থির মানের নিজস্ব scrubber লাগে।

    (খ) Diff-এ প্রথম লাইন বদল: -অর্ডার #8 · <TIME>, +অর্ডার #9 · <TIME>. Bug কি না তা snapshot বলতে পারে না। যদি test-এর setup বদলে এখন আরেকটি অর্ডার আগে তৈরি হয়, তাহলে এটি test data-র বদল, approve বা setup ঠিক করা দরকার। যদি একই setup-এ id বদলায়, তাহলে seed বা id তৈরির নিয়মে কিছু বদলেছে, খুঁজে দেখা দরকার। সিদ্ধান্তের জন্য diff-এর সাথে প্রসঙ্গ লাগে।

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

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

ক্রমএকটি নতুন approval test-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Test লিখে প্রথম run: approved নেই, তাই FAIL আর received ফাইল তৈরি
  2. Received ফাইল লাইন ধরে পড়ে requirement-এর সাথে মেলানো
  3. Received-কে approved হিসেবে রাখা আর commit করা
  4. কিছু না বদলে আবার run করে নিশ্চিত হওয়া যে test স্থির
  5. Code বদলের পরে diff এলে ইচ্ছাকৃত কি না বিচার করা

Snapshot test-এর oracle, অর্থাৎ প্রত্যাশিত ফলের উৎস, কোনটি?

  • লিখিত requirement
  • আগে রেকর্ড করা ও অনুমোদিত output
  • Test framework-এর ভেতরের নিয়ম
  • শুধু program crash না হওয়া

একটি অর্ডারের JSON-এর snapshot কিছু না বদলালেও প্রতিবার ব্যর্থ হয়; diff-এ শুধু created_at আর txn_id. সবচেয়ে ভালো সমাধান কোনটি?

  • প্রতিটি run-এর আগে snapshot update করা
  • সব সংখ্যা ও অঙ্ক একটি চিহ্নে বদলে দেওয়া
  • ঘড়ি ও id উৎসে নিয়ন্ত্রণ, না পারলে শুধু ওই field-এ আকৃতি যাচাইসহ scrubber
  • Snapshot test মুছে দেওয়া

Coupon-এ ভুল আছে: ১০০০ টাকায় ছাড় ১০০ হয় (হওয়ার কথা ০)। এই ভুল build থেকেই snapshot রেকর্ড করা হলো। এরপর কোন test এই ভুল ধরবে?

  • Requirement থেকে লেখা assertion: coupon(1000) == 0
  • একই snapshot test, আবার চালালে
  • Snapshot update করে আবার চালানো
  • Snapshot-এ একটি scrubber যোগ করা

syrupy-তে একটি test মুছে দেওয়ার পরে বাকি সব test পাস, কিন্তু রিপোর্টে “1 snapshot unused”. pytest-এর exit code কী হবে, আর কেন?

  • ০, কারণ সব test পাস
  • ০, কারণ syrupy নিজে থেকে snapshot মুছে দেয়
  • ১, কারণ মুছে দেওয়া test-টি এখনো চলছে
  • ১, কারণ মালিকহীন snapshot default-এ ব্যর্থতা গণ্য হয়

ApprovalTests-এ একটি নতুন test প্রথমবার চালানো হলো। এরপর কোন কাজটি একটি approval-এর আসল অর্থ বহন করে?

  • Reporter-কে বদলে দেওয়া
  • Received ফাইল পড়ে নিয়ম মিলিয়ে, তারপর approved হিসেবে রাখা
  • Received ফাইল সরাসরি commit করা
  • Scrubber যোগ করে আবার চালানো

৮টি subtotal, ২টি জেলা আর Plus সদস্য কি না (২টি মান) মিলিয়ে একটি golden master বানানো হলো। এতে কতগুলো সমন্বয়, আর এর বড় সীমা কী?

  • ৩২টি; শুধু তালিকার input-গুলোর আচরণ রক্ষা করে
  • ১২টি; সব input-এর আচরণ রক্ষা করে
  • ৩২টি; প্রমাণ করে যে pricing নিয়ম সঠিক
  • ১৬টি; Plus সদস্যের পার্থক্য দেখে না

শব্দকোষ

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

মনে রাখুন

  1. Snapshot, approval আর golden master-এর oracle আগের output; এরা বদল ধরে, সঠিকতা নয়।
  2. প্রথম অনুমোদনই সবচেয়ে জরুরি ধাপ: পড়ে, requirement মিলিয়ে তারপর approve.
  3. অস্থির মান আগে উৎসে নিয়ন্ত্রণ, তারপর সরু, আকৃতি-যাচাইকারী scrubber; চওড়া scrubber bug মুছে দেয়।
  4. অন্ধ update নয়, CI-তে update নয়; snapshot বদল আলাদা commit-এ, কারণসহ, review-তে।
  5. ব্যবসার নিয়ম assertion-এ; বড়, স্থির output আর legacy আচরণ snapshot বা approval-এ।

পরের পর্বে: একসাথে দুজন ক্রেতা শেষ তিনটি গুঁড়া দুধের প্যাকেট কিনতে চাইলে কী হয়? পর্ব ৬২ (Concurrency আর async testing — race, সময় আর determinism)-এ race condition, interleaving আর async code-এর test.

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

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