এই পর্বে যা শিখবেন
- Example-based আর property-based test-এর পার্থক্য, আর requirement থেকে property খুঁজে বের করার ছয়টি ছাঁচ
- Generate, check আর shrink: tool-এর ভেতরের চক্র, পাতাতেই একটি ছোট নিজস্ব সংস্করণ চালিয়ে
- Hypothesis-এর strategy (integers, text, Bangla characters, lists, builds, composite, from_regex),
@given,@example,assume, settings আর example database RuleBasedStateMachineদিয়ে order state machine-এর stateful test, আর ব্যর্থ ক্রম ছোট করা- দুর্বল property, অতিরিক্ত filter, random-এর সীমা আর AI-লেখা property test যাচাই করা
১ · উদাহরণ থেকে নিয়মে
এ পর্যন্ত কোর্সের প্রায় সব test একই ছাঁচের: একটি নির্দিষ্ট input, একটি নির্দিষ্ট প্রত্যাশিত ফল। পর্ব ০৮-এ coupon-এর জন্য ১০০০ → ০, ১০০১ → ১০০, ৩০০০ → ৩০০ বেছেছিলেন; পর্ব ২১-এ সেগুলো parametrize-এর সারি হয়েছিল। এই ধরনকে বলে example-based testing. এটি শক্তিশালী, কারণ প্রতিটি সারির পেছনে একটি চিন্তা আছে। দুর্বলতাও সেখানেই: যে কোণের কথা আপনি ভাবেননি, সেখানে কোনো সারি নেই।
বিয়েবাড়ির রান্নার কথা ভাবুন। বাবুর্চি তিন চামচ চেখে বলেন “ঠিক আছে”; এটি উদাহরণের test. কিন্তু খাদ্য পরিদর্শক অন্যভাবে ভাবেন: “যে হাঁড়ি থেকেই নিই, লবণ নির্দিষ্ট মাত্রার বেশি হবে না, আর মাংস পুরো সেদ্ধ হবে।” তিনি এলোমেলো হাঁড়ি থেকে নমুনা নেন। একটিতে গোলমাল পেলে খোঁজেন কোন ধাপে প্রথম ভুল হলো, আর শেষে রিপোর্টে লেখেন সবচেয়ে সরল ঘটনা। এটিই property-based testing: একটি নিয়ম, অনেক এলোমেলো নমুনা, আর ব্যর্থ নমুনাকে সবচেয়ে সরল রূপে নামিয়ে আনা।
Property-based testing-এ আপনি লেখেন এমন একটি দাবি, যা প্রতিটি বৈধ input-এর জন্য সত্য থাকার কথা। তারপর একটি tool সেই input-এর জগৎ থেকে অনেক নমুনা বানায়, দাবি যাচাই করে, আর ভাঙলে ব্যর্থ নমুনাকে ছোট করে একটি সরল counterexample দেখায়। ধারণাটি জনপ্রিয় হয় Haskell ভাষার QuickCheck থেকে (Koen Claessen আর John Hughes, ২০০০ সালের একটি গবেষণাপত্র); Python-এ এর সবচেয়ে পরিচিত রূপ Hypothesis.
আগে কোথায় দেখেছেন: পাইথন প্রোগ্রামিং কোর্সের পর্ব ৪২ আর সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৭-এ property-based testing-এর প্রথম স্বাদ আছে; এই কোর্সের পর্ব ৩১-এ schemathesis দিয়ে API-তে এর রূপ দেখেছেন। এখানে পুরো পদ্ধতি: property খোঁজা, strategy, shrinking-এর ভেতরের চক্র, stateful test, আর বাজারঘরের seeded bug-এ আসল run.
উদাহরণ থেকে property-তে যাওয়ার পথটি ধাপে ধাপে দেখুন। প্রতিটি ধাপে প্রশ্নটি একই: “এই উত্তরের পেছনের সাধারণ নিয়মটি কী?”
| ধরন | |
| input | |
| দাবি |
- একটি উদাহরণ। ১০০১ টাকার অর্ডারে ছাড় ১০০। ঠিক, কিন্তু মাত্র একটি বিন্দু।
- সীমার কয়েকটি উদাহরণ। পর্ব ০৮-এর BVA থেকে ১০০০, ১০০১ আর ৩০০০। এগুলো জানা ঝুঁকি পাহারা দেয়, আর থাকবে।
- সব input-এর জন্য সত্য দাবি। উত্তর না জেনেও বলা যায়: ছাড় কখনো ঋণাত্মক নয়, ৩০০-এর বেশি নয়, আর অর্ডারের ১০%-এর বেশি নয়। এটি একটি invariant.
- শর্তসাপেক্ষ নিয়ম। Requirement বলে “১০০০-এর বেশি হলে”। তাই ১০০০ বা কম যেকোনো অর্ডারে ছাড় ঠিক ০।
- দুই input-এর সম্পর্ক। কার্টে জিনিস বাড়লে ছাড় কমে না (monotone). এখানে কোনো একক উত্তর লাগে না, শুধু দুটি উত্তরের তুলনা।
- কোডে লেখা। Hypothesis-এ input-এর বর্ণনা একটি strategy, আর দাবিগুলো সাধারণ
assert. - Tool চালায়। ডিফল্টে ১০০টি input বানায়; কোনোটিতে assert ভাঙলে সেটিকে ছোট করে সবচেয়ে সরল ব্যর্থ উদাহরণ দেখায়।
লক্ষ করুন, ধাপ ২-এর সীমার সারিগুলো বাদ যায়নি। Property-based testing উদাহরণের পাশে বসে, তার জায়গায় নয়। কেন, তা §৫-এর আসল run-এ সংখ্যা দিয়ে দেখবেন।
২ · Property কোথায় পাবেন — ছয়টি ছাঁচ
নতুনদের সবচেয়ে বড় বাধা: “আমার কোডের property কী?” বেশিরভাগ property কয়েকটি পরিচিত ছাঁচে পড়ে। নিচের টেবিলে প্রতিটির একটি বাজারঘর-উদাহরণ, কোর্সের নির্দিষ্ট নিয়ম মেনে।
| ছাঁচ | মূল প্রশ্ন | বাজারঘরে |
|---|---|---|
| Invariant | সবসময় কী সত্য? | ছাড় ০ থেকে ৩০০, অর্ডারের ১০%-এর বেশি নয়; রিভিউর গড় ১ থেকে ৫-এর মধ্যে; total = subtotal − ছাড় + delivery |
| Round-trip | এক দিকে গিয়ে ফিরলে আগের জিনিস? | ইংরেজি অঙ্ক → বাংলা অঙ্ক → ইংরেজি অঙ্কে phone number হুবহু ফেরে |
| Oracle / differential | আরেকটি স্বাধীন হিসাবের সাথে মেলে? | দ্রুত coupon function আর Decimal দিয়ে ধীরে লেখা “spec-এর সরাসরি অনুবাদ” একই ফল দেয় |
| Metamorphic | Input বদলালে output কীভাবে বদলানোর কথা? | কার্টে জিনিস বাড়ালে ছাড় কমে না; মোট বিলও কমার কথা নয় (এটি আসলে ভাঙে, নিচে দেখুন) |
| Idempotence | দুবার করলে একবারের মতোই? | phone normalise দুবার চালালে একবারের ফল |
| ক্রম-নিরপেক্ষতা | ক্রম বদলালে ফল একই? | কার্টের লাইনগুলো যে ক্রমেই যোগ হোক, quote একই |
| মডেল / stateful | যেকোনো ঘটনার ক্রমে নিয়ম টেকে? | যে অর্ডার একবার shipped হয়েছে, তা কখনো cancelled বা refunded হয় না |
Requirement পড়ার সময় কয়েকটি প্রশ্ন property খুঁজতে সাহায্য করে। “সর্বোচ্চ”, “কমপক্ষে”, “কখনো না”, “সবসময়” শব্দ দেখলেই একটি invariant লুকিয়ে আছে। কোনো কাজের উল্টো কাজ থাকলে (save আর load, export আর import, বাংলা অঙ্কে রূপান্তর আর ফেরত) round-trip. একই হিসাব অন্যভাবে করা গেলে (পুরোনো system, spreadsheet, ধীর কিন্তু সরল কোড) differential. Input একটু বদলালে ফলের দিক জানা থাকলে metamorphic. আর “আবার চাপলে কী হবে?” প্রশ্নের উত্তর “কিছুই বদলাবে না” হলে idempotence. একটি ব্যবহারিক কৌশল: পর্ব ১৫-এর acceptance criteria-র প্রতিটি লাইনের পাশে লিখুন, “এটি কি প্রতিটি input-এ সত্য, না নির্দিষ্ট বিন্দুতে?” প্রথম ধরনের লাইন property হয়, দ্বিতীয় ধরনের লাইন উদাহরণ।
Oracle-এর ছাঁচে একটি সূক্ষ্মতা আছে। Test oracle হলো প্রত্যাশিত ফলের উৎস। “দ্বিতীয় হিসাব”টি যদি মূল কোড copy করে বানানো হয়, তবে দুটিতে একই ভুল থাকবে আর test সবসময় সবুজ। তাই oracle লিখুন requirement থেকে, অন্য পদ্ধতিতে, যত ধীরই হোক।
এবার ছয়টি ছাঁচ একসাথে চালিয়ে দেখুন। কোডে Hypothesis নেই; একটি seed-বাঁধা random generator প্রতিটি property-র জন্য ২০০০টি input বানায় আর প্রথম ব্যর্থ input ছাপে। “চালান” চাপুন; প্রথমবার ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।
import random, re
from decimal import Decimal
def coupon(s): return min(s // 10, 300) if s > 1000 else 0
def total(s): return s - coupon(s) + (0 if s >= 2000 else 60) # Dhaka
def phone(raw): # the trimmed number, or None
t = raw.strip()
return t if re.fullmatch(r"01[3-9]\d{8}", t, re.ASCII) else None
BN = str.maketrans("0123456789", "০১২৩৪৫৬৭৮৯")
EN = {v: k for k, v in BN.items()}
def oracle(s): # the same spec, written another way
return 0 if s <= 1000 else min(int(Decimal(s) / 10), 300)
rng = random.Random(58)
def num(): return rng.randint(0, 20_000)
def pair(): return num(), rng.randint(0, 200) # (cart, one more item)
def tel():
digits = "".join(rng.choices("0123456789", k=8))
return " 01" + rng.choice("3456789") + digits + " "
checks = [
("invariant 0 <= d <= min(300, 10%)", num,
lambda s: 0 <= coupon(s) <= min(300, s / 10)),
("monotone bigger cart, d not less", pair,
lambda p: coupon(p[0]) <= coupon(sum(p))),
("metamorph bigger cart, total not less", pair,
lambda p: total(p[0]) <= total(sum(p))),
("idempotent phone(phone(x)) == phone(x)", tel,
lambda x: phone(phone(x)) == phone(x)),
("roundtrip en(bn(x)) == x", tel,
lambda x: x.translate(BN).translate(EN) == x),
("oracle coupon(s) == oracle(s)", num,
lambda s: coupon(s) == oracle(s)),
]
for name, gen, prop in checks:
bad = next((x for x in (gen() for _ in range(2000)) if not prop(x)), None)
print(f"{name:39} {'ok' if bad is None else f'FAIL {bad}'}")আসল আউটপুট (ব্রাউজারের Python):
invariant 0 <= d <= min(300, 10%) ok
monotone bigger cart, d not less ok
metamorph bigger cart, total not less FAIL (954, 103)
idempotent phone(phone(x)) == phone(x) ok
roundtrip en(bn(x)) == x ok
oracle coupon(s) == oracle(s) ok
পাঁচটি property টিকে গেল, একটি ভাঙল: ৯৫৪ টাকার কার্টে মোট বিল ৯৫৪ + ৬০ = ১০১৪, কিন্তু ১০৩ টাকার আরেকটি জিনিস যোগ করলে কার্ট ১০৫৭, ছাড় ১০৫, মোট ১০৫৭ − ১০৫ + ৬০ = ১০১২. বেশি কিনে কম টাকা! এখানে কোডের ভুল নেই; কোড requirement হুবহু মানে। ভেঙেছে আমাদের অনুমান, আর সেটিই আবিষ্কার: “১০০০-এর বেশি হলে পুরো ১০%” নিয়মে ১০০০-এর ঠিক ওপরে একটি লাফ আছে। এমন property ভাঙলে bug report নয়, product owner-এর কাছে প্রশ্ন যায়: “এটি কি ইচ্ছাকৃত?” বাকিগুলোর মধ্যে oracle সারিটি ১০% হিসাব দুইভাবে করে মেলায়: integer ভাগ আর Decimal.
৩ · পর্দার পেছনে — generate, check, shrink
সব property-based tool-এর ভেতরে একই চক্র। নিচের ছবিতে বাজারঘরের coupon-এর একটি ভুল সংস্করণ ধরে চক্রটি দেখুন।
Property-based testing-এর চক্র
Generate → run → check; on failure shrink to a minimal counterexample and save it
max_examples পূর্ণ হয় (Hypothesis-এ ডিফল্ট ১০০)। লাল পথ: ভাঙলে shrink-এর নিজের দিকে ফেরা চক্র, তারপর সবচেয়ে ছোট উদাহরণ, যা database-এ জমা থাকে।চক্রটি নিজে লিখলে রহস্য কেটে যায়। নিচের কোডে coupon-এ একটি seeded defect: floor-এর জায়গায় round. Generator ১০০টি এলোমেলো subtotal বানায়; ভাঙলে shrinker সেই সংখ্যার চেয়ে ছোট কিছু প্রার্থী পরীক্ষা করে (০, তারপর অর্ধেক কমানো, তারপর এক-চতুর্থাংশ কমানো…), আর যেটি এখনো ব্যর্থ, সেখানে সরে যায়।
import random
def coupon(subtotal): # seeded defect: round, not floor
return min(round(subtotal / 10), 300) if subtotal > 1000 else 0
def holds(s): # the property, from the spec
d = coupon(s)
return 0 <= d <= 300 and d * 10 <= s # cap 300, never over 10%
def smaller(s): # candidates, simplest first
yield 0
step = s // 2
while step:
yield s - step
step //= 2
rng = random.Random(58)
for run in range(1, 101): # generate: 100 random subtotals
s = rng.randint(0, 20_000)
if not holds(s):
print(f"run {run}: property broken at subtotal={s}")
break
else:
print("100 runs passed")
trail = [s]
while True: # shrink: keep any smaller failure
s2 = next((c for c in smaller(s) if not holds(c)), None)
if s2 is None:
break
s = s2
trail.append(s)
print("shrink:", " -> ".join(map(str, trail)))
print(f"minimal: subtotal={s}, discount={coupon(s)}, 10% = {s / 10}")আসল আউটপুট:
run 21: property broken at subtotal=2406
shrink: 2406 -> 2106 -> 1975 -> 1729 -> 1297 -> 1135 -> 1118 -> 1049 -> 1017 -> 1016 -> 1009 -> 1006
minimal: subtotal=1006, discount=101, 10% = 100.6
২১তম এলোমেলো input-এ property ভাঙল: ২৪০৬-এর ১০% হলো ২৪০.৬, round দেয় ২৪১, অর্থাৎ নিয়মের চেয়ে এক টাকা বেশি ছাড়। কিন্তু “২৪০৬” দেখে ভুলের কারণ সহজে বোঝা যায় না। এগারোটি shrink-লাফের পরে উত্তর দাঁড়াল ১০০৬: ছাড়ের যোগ্য ক্ষুদ্রতম সংখ্যাগুলোর একটি, যেখানে ১০% (১০০.৬) উপরে গোল হয়। ১০০১ থেকে ১০০৫ পর্যন্ত সব ঠিক (১০০.৫-ও Python-এর round-এ জোড় সংখ্যা ১০০-তে নামে)। এখন bug report এক লাইনের: “১০০৬ টাকায় ছাড় ১০১, হওয়ার কথা ১০০।”
Shrinking-এর মাঝের ধাপগুলো দেখুন। প্রতিটি ধাপে shrinker প্রার্থীদের ক্রমে পরীক্ষা করে, আর প্রথম ব্যর্থটিকে নতুন “বর্তমান” বানায়:
| বর্তমান | |
| প্রার্থী | |
| ফল | |
| নতুন বর্তমান |
- শুরু। ২১তম input ২৪০৬-এ ছাড় ২৪১, অথচ ১০% মাত্র ২৪০.৬। এটিই প্রথম counterexample.
- প্রথম চেষ্টা। ০ ঠিক, ১২০৩ ঠিক (ছাড় ১২০), ১৮০৫-ও ঠিক (১৮০.৫ জোড়ে নেমে ১৮০)। ২১০৬-এ ছাড় ২১১, যা ২১০.৬-এর বেশি: ব্যর্থ। নতুন বর্তমান ২১০৬।
- দ্বিতীয় চেষ্টা। ০, ১০৫৩, ১৫৮০, ১৮৪৩ ঠিক; ১৯৭৫-এ ছাড় ১৯৮ (১৯৭.৫ উপরে জোড় ১৯৮-এ): ব্যর্থ। নতুন বর্তমান ১৯৭৫।
- দুটি দ্রুত লাফ। ১৯৭৫ থেকে ১৭২৯, সেখান থেকে ১২৯৭। প্রতিবার আগের কিছু প্রার্থী ঠিক থাকে, একটি ব্যর্থ হয়। বড় লাফ শুরুতে, তাই সংখ্যা দ্রুত নামে।
- ১০০০-এর কাছে। ১২৯৭ থেকে ১১৩৫, ১১১৮, ১০৪৯। এখন ছোট প্রার্থীগুলো (যেমন ৯৯৪) ১০০০-এর নিচে, সেখানে ছাড় ০, তাই ঠিক; শুধু ১০০০-এর ওপরের কাছের সংখ্যাগুলো ব্যর্থ হয়।
- এক এক করে। ১০৪৯ থেকে ১০১৭, ১০১৬, ১০০৯। লাফ এখন কয়েক টাকার।
- থামা। ১০০৯-এর প্রার্থীদের মধ্যে ১০০২ ঠিক, ১০০৬ ব্যর্থ: শেষ লাফ। তারপর ১০০৬-এর দশটি প্রার্থীই ঠিক (১০০৩ আর ১০০৫-এ ছাড় ১০০)। কোনো ছোট ব্যর্থ input নেই, তাই ১০০৬ চূড়ান্ত। মোট এগারোটি লাফ।
“সবচেয়ে ছোট” মানে স্থানীয়ভাবে ছোট। Shrinker শুধু নিজের প্রার্থীগুলো দেখে; এমন জায়গায় থামতে পারে, যার আশেপাশে আর কোনো ছোট ব্যর্থ input নেই, অথচ দূরে আরও ছোট একটি আছে। একই round-ভুলে আসল Hypothesis (seed 58) থামল subtotal=1775-এ, ১০০৬-এ নয়; দুটিই সঠিক counterexample. সংখ্যা যত সরলই আসুক, কারণ খুঁজতে নিজের মাথা লাগবে।
৪ · Hypothesis হাতে-কলমে — strategy আর @given
এবার আসল tool. নিচের সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে সত্যিকারভাবে চালানো হয়েছে: Hypothesis 6.170.15 (লাইসেন্স MPL-2.0) আর pytest 9.2.0 (MIT), Python 3.12-এ। Hypothesis-এর pytest plugin আলাদা install লাগে না। Server লাগেনি: বাজারঘরের pure business rule-এর module rules.py (coupon, delivery, phone, order state, review) copy করে সরাসরি test করা হয়েছে। Seeded bug চালু হয় app-এর মতোই BAZARGHAR_BUGS দিয়ে। Hypothesis কোনো usage data বাইরে পাঠায় না, আর run-গুলোয় কোনো network লাগে না। Path নিরপেক্ষ করা।
mkdir bazarghar-pbt && cd bazarghar-pbt
uv init --vcs none --author-from none
uv add hypothesis pytest
cp ../bazarghar/src/bazarghar/rules.py . # pure rules, no server
uv run pytest tests -v -p no:cacheprovider --hypothesis-seed=58প্রথম ফাইল coupon আর delivery-র property. @given একটি decorator, যা test function-কে Hypothesis-এর হাতে দেয়; তার argument-গুলো strategy, অর্থাৎ input কোথা থেকে আসবে তার বর্ণনা:
import os
from hypothesis import given, strategies as st
from rules import coupon_discount, quote
BUGS = frozenset(b for b in os.environ.get("BAZARGHAR_BUGS", "").split(",") if b)
subtotals = st.integers(min_value=0, max_value=20_000)
districts = st.sampled_from(["Dhaka", "Gazipur", "Sylhet"])
@given(subtotals)
def test_coupon_limits(subtotal):
d = coupon_discount(subtotal, BUGS)
assert 0 <= d <= 300 # never more than the cap
assert d * 10 <= subtotal # never more than 10%
if subtotal <= 1000:
assert d == 0 # only MORE than 1000 qualifies
@given(subtotals, subtotals)
def test_coupon_monotone(a, b):
lo, hi = sorted((a, b))
assert coupon_discount(lo, BUGS) <= coupon_discount(hi, BUGS)
@given(subtotals, districts, st.booleans())
def test_delivery_rules(subtotal, district, plus):
q = quote(subtotal, district, plus, BUGS)
assert q["delivery"] in (0, 60, 120)
if district == "Dhaka" and subtotal >= 2000:
assert q["delivery"] == 0 # threshold uses the price BEFORE coupon
assert q["total"] == subtotal - q["discount"] + q["delivery"]দ্বিতীয় ফাইলে রিভিউ আর phone. এখানে দুটি গুরুত্বপূর্ণ strategy: st.characters(min_codepoint=0x0980, max_codepoint=0x09FF) শুধু বাংলা Unicode block থেকে অক্ষর বানায়, আর | দিয়ে তাকে সাধারণ st.characters()-এর সাথে মেশানো হয়েছে, যেখানে emoji আর অন্য ভাষার অক্ষরও আসে। st.from_regex একটি regex মানে এমন string বানায়, এখানে সামনে-পেছনে whitespace-সহ বৈধ phone number:
bangla = st.characters(min_codepoint=0x0980, max_codepoint=0x09FF)
review_text = st.text(bangla | st.characters(), max_size=520)
@given(st.lists(st.integers(1, 5), min_size=1))
def test_average_in_range(stars):
assert 1 <= average_stars(stars) <= 5
@given(st.integers(1, 5), review_text)
def test_review_length_rule(stars, text):
n = len(text.strip()) # Unicode code points (AC3)
try:
validate_review(stars, text, BUGS)
accepted = True
except ReviewInvalid:
accepted = False
assert accepted == (10 <= n <= 500)
@given(st.from_regex(r"\s*01[3-9][0-9]{8}\s*", fullmatch=True))
def test_phone_normalize_idempotent(raw):
once = normalize_phone(raw)
assert once is not None
assert normalize_phone(once) == onceতৃতীয় ফাইলে নিজের ধরনের data. st.builds একটি class-এর object বানায়, প্রতিটি field-এর জন্য আলাদা strategy দিয়ে; @st.composite দিয়ে কয়েকটি strategy থেকে draw করে নিজের strategy লেখা যায়। st.randoms() Hypothesis-নিয়ন্ত্রিত একটি random object দেয়, যাতে shuffle-ও shrink আর পুনরাবৃত্তিযোগ্য থাকে:
@dataclass
class Line:
name: str
price: int
qty: int
lines = st.builds(Line, name=st.sampled_from(["চাল", "ডাল", "তেল", "দুধ"]),
price=st.integers(10, 2500), qty=st.integers(1, 5))
@st.composite
def carts(draw):
items = draw(st.lists(lines, min_size=1, max_size=6))
district = draw(st.sampled_from(["Dhaka", "Gazipur", "Sylhet"]))
return items, district
@given(carts(), st.randoms())
def test_line_order_does_not_matter(cart, rnd):
items, district = cart
shuffled = items[:]
rnd.shuffle(shuffled)
total = lambda xs: quote(sum(x.price * x.qty for x in xs), district)
assert total(items) == total(shuffled)সাথে §৬-এর stateful test. সব seeded bug বন্ধ রেখে প্রথম run (সত্যিকারের run, path আর platform-এর লাইন ছাঁটা):
hypothesis profile 'default'
plugins: hypothesis-6.170.15
collecting ... collected 8 items
tests/test_pricing_props.py::test_coupon_limits PASSED [ 12%]
tests/test_pricing_props.py::test_coupon_monotone PASSED [ 25%]
tests/test_pricing_props.py::test_delivery_rules PASSED [ 37%]
tests/test_review_phone_props.py::test_average_in_range PASSED [ 50%]
tests/test_review_phone_props.py::test_review_length_rule PASSED [ 62%]
tests/test_review_phone_props.py::test_phone_normalize_idempotent PASSED [ 75%]
tests/test_cart.py::test_line_order_does_not_matter PASSED [ 87%]
tests/test_order_machine.py::TestOrderMachine::runTest PASSED [100%]
============================== 8 passed in 1.63s ==============================
আটটি test, প্রতিটি ডিফল্টে ১০০টি input; দেড় সেকেন্ডের কিছু বেশি। --hypothesis-seed=58 random-কে বাঁধে, ফলে একই কম্পিউটারে একই version-এ প্রতিবার একই input আসে (পর্ব ২৩-এর random seed-এর ধারণা)।
Settings, deadline আর profile
প্রতিটি test-এর আচরণ @settings দিয়ে বদলানো যায়: max_examples (কয়টি input, ডিফল্ট ১০০), আর deadline (একটি input-এ সর্বোচ্চ সময়, ডিফল্ট ২০০ মিলিসেকেন্ড; বেশি লাগলে test ব্যর্থ, কারণ ধীর কোড প্রায়ই নিজেই একটি সমস্যা)। ধীর বা অস্থির পরিবেশে deadline=None দেওয়া যায়, কিন্তু তাতে একটি সংকেত হারায়। পুরো suite-এর জন্য নামওয়ালা profile ভালো। এই lab-এ conftest.py-তে একটি profile:
from hypothesis import settings
settings.register_profile("nightly", max_examples=1000)
# run: uv run pytest --hypothesis-profile=nightly৫ · Seeded bug শিকার — কী ধরা পড়ল, কী পড়ল না
এবার app-এর bug switch একটি একটি করে চালু করা হলো। প্রথমে delivery_after_discount: ঢাকায় ফ্রি delivery-র ২০০০ টাকার সীমা ভুল করে ছাড়ের পরের দামে যাচাই হয় (সত্যিকারের run):
$ BAZARGHAR_BUGS=delivery_after_discount uv run pytest tests/test_pricing_props.py \
-p no:cacheprovider --hypothesis-seed=58 --tb=short
tests\test_pricing_props.py ..F [100%]
================================== FAILURES ===================================
_____________________________ test_delivery_rules _____________________________
tests\test_pricing_props.py:32: in test_delivery_rules
assert q["delivery"] == 0 # threshold uses the price BEFORE coupon
^^^^^^^^^^^^^^^^^^^^^^^^^
E assert 60 == 0
E Failing test case: test_delivery_rules(
E subtotal=2000,
E district='Dhaka',
E plus=False, # or any other generated value
E )
========================= 1 failed, 2 passed in 0.24s =========================
Hypothesis ব্যর্থ input-কে নামিয়ে আনল ঠিক সীমায়: subtotal=2000, ঢাকা। ২০০০ টাকায় ছাড় ২০০, ছাড়ের পরে ১৮০০, তাই ভুল কোড delivery ৬০ নিল। লক্ষ করুন # or any other generated value: Hypothesis-এর “explain” ধাপ যাচাই করে দেখেছে, plus-এর মান বদলালেও ব্যর্থতা থাকে, অর্থাৎ ওই argument কারণ নয়। ভালো bug report-এর অর্ধেক কাজ এখানেই হয়ে গেল (পর্ব ১৮-এর ন্যূনতম পুনরুৎপাদন)।
এবার coupon_ge: > 1000-এর জায়গায় >= 1000, তাই শুধু একটি বিন্দু, ঠিক ১০০০ টাকা, ভুল ছাড় পায়। একই command, একই seed:
$ BAZARGHAR_BUGS=coupon_ge uv run pytest tests/test_pricing_props.py \
-p no:cacheprovider --hypothesis-seed=58
tests\test_pricing_props.py ... [100%]
============================== 3 passed in 0.16s ==============================
সবুজ, অথচ bug আছে। এটি দুর্ঘটনা কি না দেখতে seed ১ থেকে ২০ পর্যন্ত প্রতিটিতে নতুন করে চালানো হলো (প্রতিবার .hypothesis ফোল্ডার মুছে), ডিফল্ট ১০০ আর nightly profile-এর ১০০০ উদাহরণে:
| Seeded bug | ব্যর্থ input-এর ক্ষেত্র | ১০০ উদাহরণ: ২০ seed-এ ধরা | ১০০০ উদাহরণ: ২০ seed-এ ধরা |
|---|---|---|---|
coupon_ge | শুধু 1000 | ১২ | ২০ |
delivery_after_discount | ঢাকা, 2000 থেকে 2221 | ১১ | ২০ |
দুটি শিক্ষা। প্রথমত, ১০০টি উদাহরণে প্রায় অর্ধেক seed-এ দুটি bug-ই পালিয়েছে; random test-এর ফল সম্ভাবনার খেলা। দ্বিতীয়ত, এক বিন্দুর bug ১২ বার ধরা পড়ল কীভাবে? ০ থেকে ২০০০০-এর মধ্যে ১০০টি সমান-সম্ভাবনার এলোমেলো সংখ্যায় ঠিক ১০০০ আসার সম্ভাবনা এক শতাংশেরও কম। কারণ Hypothesis সমান-সম্ভাবনায় সংখ্যা বাছে না। এই version কোডের ভেতরের constant সংগ্রহ করে মাঝে মাঝে input হিসেবে চেষ্টা করে: lab-এর .hypothesis/constants ফাইলে rules.py থেকে তোলা তালিকায় 1000, 2000, 300, 'Dhaka' সবই দেখা গেল (বৈশিষ্ট্যটি সাম্প্রতিক version-গুলোর, আমাদের জানামতে ২০২৫ সালের দিকে যুক্ত)। তবু এটি নিশ্চয়তা নয়।
নিশ্চয়তা আসে @example থেকে: test-এর ওপরে নির্দিষ্ট input লিখে দিলে Hypothesis প্রতিবার সবার আগে সেগুলো চালায়। পর্ব ০৮-এর সীমা এখানে বসে:
@given(subtotals)
@example(1000).via("BVA edge, পর্ব ০৮")
@example(1001).via("BVA edge, পর্ব ০৮")
def test_coupon_edges(subtotal):
d = coupon_discount(subtotal, BUGS)
if subtotal <= 1000:
assert d == 0$ BAZARGHAR_BUGS=coupon_ge uv run pytest tests/test_explore.py::test_coupon_edges \
-p no:cacheprovider --hypothesis-seed=58 --tb=short
E assert 100 == 0
E Failing explicit example: test_coupon_edges(
E subtotal=1000,
E )
============================== 1 failed in 0.14s ==============================
“Failing explicit example”: random-এর অপেক্ষা নয়, প্রথম চালেই ধরা। .via() শুধু রিপোর্টে লেখে উদাহরণটি কোথা থেকে এলো। একই কৌশল regression-এর জন্যও: কোনো property একবার ব্যর্থ হলে shrunk input-টি @example হিসেবে স্থায়ী করুন, যাতে random পরিবর্তন হলেও সেই ঘটনা আর না পালায়।
রিভিউর দৈর্ঘ্য: emoji-র ফাঁদ
review_utf16_length চালু করলে রিভিউর দৈর্ঘ্য Unicode code point-এর বদলে UTF-16 unit-এ গোনা হয় (সত্যিকারের run):
E assert True == (10 <= 8)
E Failing test case: test_review_length_rule(
E stars=1, # or any other generated value
E text='000000𐀀𐀀',
E )
FAILED tests/test_review_phone_props.py::test_review_length_rule - assert Tru...
========================= 1 failed, 2 passed in 1.54s =========================
Shrunk input-টি পড়তে শিখুন। টেক্সটে ৮টি code point: ছয়টি 0 আর দুটি 𐀀 (U+10000, Basic Multilingual Plane-এর বাইরের প্রথম অক্ষর)। AC3 অনুযায়ী ৮ < ১০, তাই প্রত্যাখ্যান হওয়ার কথা; কিন্তু UTF-16-এ প্রতিটি 𐀀 দুটি unit, মোট ১০, তাই ভুল কোড গ্রহণ করল (accepted True). Shrinker অক্ষরকে সরলতম 0-তে নামিয়েছে যেখানে পেরেছে, আর ঠিক দুটি “দুই-unit” অক্ষর রেখেছে, যা ছাড়া ভুল দেখা যায় না। কোনো মানুষ এমন test case হাতে লিখতেন না, অথচ আসল ব্যবহারকারী emoji দিয়ে ঠিক এটাই করেন। (বাংলা অক্ষর সবই BMP-র ভেতরে, তাই এই ভুল বাংলা দিয়ে ধরা পড়ত না।)
Example database আর assume
Hypothesis প্রতিটি ব্যর্থ input প্রকল্পের .hypothesis/examples ফোল্ডারে জমা রাখে; পরের run-এ “reuse” ধাপে সেগুলো সবার আগে চলে। Seed ছাড়া, ১০০০ উদাহরণের profile-এ, পরপর দুবার চালানো হলো (--hypothesis-show-statistics, ছাঁটা):
== run 1
- during generate phase (0.15 seconds):
- 407 passing, 3 failing, and 0 invalid test cases
- during shrink phase (0.01 seconds):
- Tried 8 shrinks of which 2 were successful
== run 2
- during reuse phase (0.00 seconds):
- 0 passing, 1 failing, and 0 invalid test cases
দ্বিতীয় run প্রথম চালেই সেই ব্যর্থ input পেল। একটি পর্যবেক্ষণ: --hypothesis-seed দিয়ে চালানো run-গুলোয় এই lab-এ examples ফোল্ডার তৈরি হয়নি, শুধু constants; database-এর সুবিধা চাইলে seed-বাঁধা run আর সাধারণ run-এর পার্থক্য মাথায় রাখুন। .hypothesis ফোল্ডার সাধারণত version control-এ রাখা হয় না।
শেষ টুকরো: assume. Test-এর ভেতরে assume(subtotal > 1000) লিখলে শর্ত মিথ্যা হলে input বাতিল হয়, ব্যর্থ নয়। সহজ, কিন্তু খরুচে। সত্যিকারের পরিসংখ্যান:
tests/test_explore.py::test_big_order_gets_discount_assume:
- 100 passing, 0 failing, and 107 invalid test cases
* 51.69%, gave up because: failed to satisfy assume() …
tests/test_explore.py::test_small_order_filter:
- 100 passing, 0 failing, and 0 invalid test cases
০ থেকে ২০০০০-এর মধ্যে মাত্র ৫% সংখ্যা ১০০০ বা কম, অথচ বাতিল হলো ১০৭টি, অর্থাৎ অর্ধেকের বেশি input. কারণ আবার সেই একই: Hypothesis ছোট আর “আকর্ষণীয়” সংখ্যার দিকে ঝোঁকে। সমাধান: শর্তটি strategy-তেই বসান, যেমন st.integers(1001, 20_000); তখন বাতিল শূন্য। assume রাখুন সেই শর্তের জন্য, যা strategy-তে প্রকাশ করা কঠিন (যেমন দুটি argument-এর সম্পর্ক), আর .filter()-ও একই সাবধানতায়।
৬ · Stateful testing — ঘটনার এলোমেলো ক্রম
পর্ব ১০-এ order status-এর state table থেকে হাতে test sequence বানিয়েছিলেন। Stateful testing-এ উল্টো পথ: আপনি বলেন কোন কাজগুলো (rule) সম্ভব আর কোন নিয়ম (invariant) সবসময় সত্য; tool নিজে কাজের এলোমেলো ক্রম বানায়, প্রতিটি ধাপের পরে invariant যাচাই করে, আর ভাঙলে ক্রমটিকে shrink করে। এটি model-based testing-এর একটি হালকা রূপ।
from hypothesis.stateful import RuleBasedStateMachine, invariant, rule
from rules import ACTIONS, InvalidTransition, next_status
class OrderMachine(RuleBasedStateMachine):
def __init__(self):
super().__init__()
self.status, self.paid, self.seen = "placed", False, {"placed"}
@rule(action=st.sampled_from(ACTIONS))
def do(self, action):
before = self.status
try:
self.status = next_status(self.status, action, self.paid, BUGS)
except InvalidTransition:
assert self.status == before # a rejected action changes nothing
return
self.paid = self.paid or action == "pay"
self.seen.add(self.status)
@invariant()
def shipped_is_never_cancelled(self):
if "shipped" in self.seen:
assert self.status not in ("cancelled", "refunded")
TestOrderMachine = OrderMachine.TestCasecancel_after_shipped চালু করে (সত্যিকারের run, Hypothesis-এর ভেতরের traceback ছাঁটা):
tests\test_order_machine.py:30: in shipped_is_never_cancelled
assert self.status not in ("cancelled", "refunded")
E AssertionError: assert 'cancelled' not in ('cancelled', 'refunded')
E Failing test case: <state machine>
E state = OrderMachine()
E state.shipped_is_never_cancelled()
E state.do(action='pay')
E state.shipped_is_never_cancelled()
E state.do(action='pack')
E state.shipped_is_never_cancelled()
E state.do(action='ship')
E state.shipped_is_never_cancelled()
E state.do(action='cancel')
E state.shipped_is_never_cancelled()
E state.teardown()
============================== 1 failed in 0.32s ==============================
ব্যর্থ ক্রমটি একটি সম্পূর্ণ, চালানো যায় এমন script: pay, pack, ship, cancel. এর চেয়ে ছোট কোনো ক্রমে এই ভুল দেখা সম্ভব নয়, কারণ shipped-এ পৌঁছাতেই তিনটি ধাপ লাগে। পর্ব ১০-এ এই ঘরটি আপনি state table থেকে হাতে খুঁজেছিলেন; এখানে কেউ ঘরটির কথা বলেনি, শুধু একটি ব্যবসায়িক নিয়ম।
একই ধারণার একটি ছোট নিজস্ব রূপ পাতাতেই চালান। এখানে developer-এর table-এ একটি বাড়তি সারি (("shipped", "cancel")); tester ২০০টি পর্যন্ত এলোমেলো ১২-ধাপের ক্রম চালায়, ব্যর্থ ক্রম পেলে দুই ধাপে shrink করে: ব্যর্থতার পরের অংশ কেটে ফেলা, তারপর এক একটি ধাপ বাদ দিয়ে দেখা ব্যর্থতা থাকে কি না।
import random
NEXT = {("placed", "pay"): "paid", ("paid", "pack"): "packed",
("packed", "ship"): "shipped", ("shipped", "deliver"): "delivered",
("placed", "cancel"): "cancelled", ("paid", "cancel"): "cancelled",
("packed", "cancel"): "cancelled", ("cancelled", "refund"): "refunded",
("shipped", "cancel"): "cancelled"} # seeded defect: extra row
ACTIONS = ["pay", "pack", "ship", "deliver", "cancel", "refund"]
def run(steps): # replay steps; return the broken step or None
status, seen = "placed", {"placed"}
for i, action in enumerate(steps):
status = NEXT.get((status, action), status) # invalid: no change
seen.add(status)
if "shipped" in seen and status in ("cancelled", "refunded"):
return i # invariant broken
return None
rng = random.Random(58)
for attempt in range(1, 201): # 200 random runs, 12 random actions each
steps = rng.choices(ACTIONS, k=12)
if run(steps) is not None:
break
print(f"attempt {attempt}: broken at step {run(steps) + 1} of", steps)
steps = steps[:run(steps) + 1] # shrink 1: cut everything after the failure
i = 0
while i < len(steps): # shrink 2: drop one step if it still fails
shorter = steps[:i] + steps[i + 1:]
if run(shorter) is not None:
steps = shorter
else:
i += 1
print("minimal:", steps)আসল আউটপুট:
attempt 33: broken at step 9 of ['ship', 'ship', 'refund', 'pay', 'pack', 'deliver', 'ship', 'refund', 'cancel', 'ship', 'ship', 'pack']
minimal: ['pay', 'pack', 'ship', 'cancel']
৩২টি এলোমেলো ক্রম নিয়ম ভাঙেনি; ৩৩তম ক্রমের নবম ধাপে ভাঙল। বারো ধাপের ক্রমটি পড়ে কারণ বোঝা কঠিন: অনেক ধাপ অবৈধ (placed অবস্থায় ship) আর কিছুই বদলায় না। Shrink করার পর থাকে চারটি ধাপ, Hypothesis-এর ফলের হুবহু একই। এই কোডে অবৈধ কাজ নীরবে উপেক্ষা হয়; আসল test-এ (ওপরের do) অবৈধ কাজে state অপরিবর্তিত কি না সেটিও assert করা হয়েছে।
1ship2ship3refund4pay5pack6deliver7ship8refund9cancel
| status | |
| shipped দেখা? | |
| invariant |
- ধাপ ১–৩: শুরুর গোলমাল। placed অবস্থায় ship, ship, refund: তিনটিই অবৈধ, status placed-ই থাকে। Invariant ঠিক।
- ধাপ ৪: pay. placed থেকে paid. বৈধ।
- ধাপ ৫: pack. paid থেকে packed.
- ধাপ ৬: deliver. packed অবস্থায় deliver অবৈধ (আগে ship লাগে); status packed থাকে।
- ধাপ ৭: ship. packed থেকে shipped. এখন থেকে নিয়মটি প্রযোজ্য: এই অর্ডার আর কখনো cancelled বা refunded হতে পারবে না।
- ধাপ ৮: refund. shipped অবস্থায় অবৈধ; কিছু বদলায় না।
- ধাপ ৯: cancel. বাড়তি সারির কারণে shipped থেকে cancelled! Invariant ভাঙল; বাকি তিনটি ধাপ আর চালানোর দরকার নেই।
- Shrink. নবম ধাপের পরের অংশ কাটা হলো; তারপর এক একটি ধাপ বাদ দিয়ে দেখা হলো। ধাপ ১, ২, ৩, ৬ আর ৮ (ছবিতে হাইলাইট করা) বাদ দিলেও ভুল থাকে, তাই বাদ। pay, pack, ship আর cancel বাদ দিলে ভুল মিলিয়ে যায়, তাই থাকে। ফল: চার ধাপ।
৭ · ভালো property, ফাঁদ আর CI
সাধারণ ভুলগুলো: (১) কোড হুবহু test-এ আবার লেখা, যেমন assert coupon(s) == min(s // 10, 300) if s >= 1000 else 0; কোডের ভুল test-এও copy হয়ে যায়। (২) এত দুর্বল property যে কিছুই ধরে না, যেমন “ফল একটি int”. (৩) বিস্তৃত strategy-র পরে ভারী assume, যাতে বেশিরভাগ input বাতিল। (৪) জানা সীমা শুধু random-এর ভরসায় রাখা (§৫-এর ৮টি পালানো seed). (৫) ব্যর্থতার shrunk input regression হিসেবে না রাখা। (৬) এমন কোডে property চালানো যা সময়, network বা global state-এর ওপর নির্ভর করে; তখন ব্যর্থতা পুনরুৎপাদন হয় না, আর test flaky হয়ে যায় (পর্ব ৪০)।
কোন কোডে বেশি কাজের: pure function (দাম, কর, ছাড়, রূপান্তর), parser আর serializer (round-trip), validator (দৈর্ঘ্য, Unicode, regex), data structure আর state machine. UI-র পুরো পথ বা ধীর end-to-end test-এ প্রতিটি উদাহরণ সেকেন্ড নেয়, তাই সেখানে কম। API-তে অবশ্য এর রূপটি খুব কাজের: schemathesis OpenAPI থেকে strategy বানায় আর “5xx নেই”, “document মানা” জাতীয় property যাচাই করে (পর্ব ৩১); ভেতরে Hypothesis-ই চলে। Business-এর property (ছাড় ৩০০-এর বেশি নয়) অবশ্য আপনাকেই লিখতে হয়।
CI-তে: প্রতিটি push-এ ডিফল্ট ১০০ উদাহরণের দ্রুত run, রাতে বড় profile (এই lab-এর nightly). Pull request-এ একই input বারবার চাইলে seed বা derandomize=True; তখন নতুন input খোঁজার ক্ষমতা কমে, তাই রাতের random run রাখুন। CI-তে কোনো property লাল হলে লগের “Failing test case” অংশ থেকে input তুলে @example বানান, ঠিক করুন, তারপর সবুজ দেখুন। আর মনে রাখুন, সবুজ property suite প্রমাণ নয়; এটি “এতগুলো চেষ্টায় ভাঙেনি” মাত্র। Test কতটা শক্ত, তা মাপার পদ্ধতি পর্ব ৫৯-এ (mutation testing); একই এলোমেলো-input-এর ধারণা নিরাপত্তা আর crash খোঁজায় পর্ব ৬০-এ (fuzz testing).
আরও গভীরে: Hypothesis-এর shrinker সরাসরি সংখ্যা বা string ছোট করে না; প্রতিটি input যে “পছন্দের ক্রম” (choice sequence) থেকে তৈরি, সেই ক্রমটিকে ছোট করে, তারপর আবার strategy চালিয়ে input বানায়। ফলে নিজের লেখা composite strategy-ও বাড়তি কোড ছাড়া shrink হয়, আর shrunk input সবসময় strategy-র নিয়ম মানে। David MacIver আর Alastair Donaldson-এর একটি প্রবন্ধে (ECOOP ২০২০, আমাদের জানামতে) এই “integrated shrinking”-এর নকশা আলোচিত। Trade-off: shrinker স্থানীয় সর্বনিম্নে থামতে পারে (১৭৭৫ বনাম ১০০৬), আর জটিল strategy-তে shrink সময় নেয়।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন আসতে পারে:
- Example-based আর property-based test-এর পার্থক্য? — প্রথমটি নির্দিষ্ট input-এর নির্দিষ্ট ফল দেখে; দ্বিতীয়টি সব বৈধ input-এ সত্য একটি নিয়ম অনেক generated input-এ যাচাই করে।
- Shrinking কেন দরকার? — এলোমেলো ব্যর্থ input বড় আর জটিল; shrink করলে সরল counterexample মেলে, যা ডিবাগ আর bug report সহজ করে।
- Sort function-এর তিনটি property? — ফল ক্রমানুসারে; ফল input-এর একটি বিন্যাস (একই উপাদান); দুবার sort করলে একবারের মতো (idempotence).
- Oracle problem-এর একটি সমাধান? — Metamorphic relation: সঠিক উত্তর না জেনেও সম্পর্কিত input-এর ফলের সম্পর্ক যাচাই।
- Property-based testing কি BVA-র বদলি? — না; জানা সীমা
@exampleবা আলাদা test-এ রাখুন, random অংশ অজানা কোণ খোঁজে।
৮ · AI-এর যুগে property-based testing
AI assistant-কে “Hypothesis test লিখে দিন” বললে সাধারণত যা আসে: @given(st.integers()), আর ভেতরে কোডের হুবহু অনুলিপি, যাকে property বলা হয়েছে। এমন test কোডের ভুলসহ পাস করে, কারণ এটি requirement নয়, বর্তমান কোড যা করে তা-ই assert করে। আরও যা দেখা যায়: শুধু happy path-এর property (ছোট বৈধ সংখ্যা); সীমা (১০০০, ২০০০) কোথাও স্পষ্ট নয়; অস্তিত্বহীন strategy বা setting-এর নাম; ধীর হলে deadline=None বসিয়ে সংকেত চাপা দেওয়া; বা time.sleep; সবকিছু mock করে এমন property, যেখানে আসল কোড চলেই না; আর না চালিয়েই “all tests pass” দাবি।
AI-কে কোড নয়, requirement দিন, আর property-র তালিকা আলাদা চান:
AI-লেখা property test হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১QuickCheck-এর মূল ধারণা ছিল “specification-ই test”. এই ধারণা কোথা থেকে এলো, আর বাজারঘরের মতো সাধারণ business app-এ এর মূল্য কী?
Koen Claessen আর John Hughes ২০০০ সালের ICFP সম্মেলনের একটি গবেষণাপত্রে QuickCheck বর্ণনা করেন: Haskell-এর একটি ছোট library, যেখানে programmer function-এর বৈশিষ্ট্য সাধারণ Haskell কোডে লেখেন, আর library type দেখে এলোমেলো input বানায়। Functional programming জগতে তখন formal proof-এর চর্চা ছিল, কিন্তু প্রতিটি function প্রমাণ করা ব্যয়বহুল। QuickCheck মাঝামাঝি পথ দেখাল: প্রমাণের ভাষায় নিয়ম লিখুন, কিন্তু যাচাই করুন পরীক্ষা দিয়ে। পরে Hughes আর তাঁর সহকর্মীরা Erlang-এর জন্য বাণিজ্যিক সংস্করণ বানান, আর গাড়ির software বা database-এর মতো জটিল system-এ stateful সংস্করণের ব্যবহারের অভিজ্ঞতা বিভিন্ন বক্তৃতা ও প্রবন্ধে বর্ণনা করেন।
বাজারঘরের মতো app-এ ধারণাটির মূল্য দুই জায়গায়। প্রথমত, property লিখতে গিয়ে requirement নিয়ে প্রশ্ন ওঠে। §২-এ “বেশি কিনলে মোট বিল কমবে না” লিখতে গিয়ে দেখা গেল নিয়মটি আসলে এমন নয়: ৯৫৪ টাকার কার্টে ১০৩ টাকার জিনিস যোগ করলে বিল ১০১৪ থেকে ১০১২-তে নামে। কোনো উদাহরণ-test এই প্রশ্ন তোলেনি, কারণ প্রতিটি উদাহরণ নিজে ঠিক ছিল। দ্বিতীয়ত, property অনেক উদাহরণ-test-এর সংক্ষিপ্ত রূপ: “ছাড় ৩০০-এর বেশি নয়, ১০%-এর বেশি নয়” একটি লাইনে হাজার সারির কাজ করে, আর নিয়ম বদলালে একটি লাইনই বদলায়।
সীমাও আছে। Property লেখা উদাহরণ লেখার চেয়ে কঠিন; দুর্বল property নিরাপত্তার মিথ্যা অনুভূতি দেয়। আর business rule-এর অনেক অংশ (“১০০০-এর বেশি হলে”) একটি নির্দিষ্ট বিন্দুর ওপর দাঁড়িয়ে, যেখানে উদাহরণই শ্রেষ্ঠ পাহারাদার।
মূল উপলব্ধি: property লেখা আসলে requirement-কে যাচাইযোগ্য ভাষায় অনুবাদ করা; এর সবচেয়ে বড় ফল প্রায়ই test চালানোর আগেই আসে, প্রশ্নের আকারে।
প্র ০২LevelDB-তে একটি “ভূতুড়ে key ফিরে আসা” ভুল stateful testing-এ ধরা পড়েছিল বলে জানা যায়। এমন bug কেন হাতে লেখা test-এ প্রায় ধরা পড়ে না, আর shrinking এখানে কী ভূমিকা রাখে?
LevelDB হলো Google-এর তৈরি একটি key-value storage library. এর issue tracker-এ (issue ৪৪, আমাদের জানামতে ২০১২ সালের দিকে) Joseph Norton একটি রিপোর্ট করেন: Erlang থেকে LevelDB ব্যবহারের একটি মডেল QuickCheck দিয়ে test করতে গিয়ে tool একটি ব্যর্থ ক্রম পায়, যেখানে মুছে ফেলা একটি key database বন্ধ করে আবার খোলার পরে ফিরে আসে। Shrink করার পরও ক্রমটি ছিল ১৭ ধাপের, আর C API দিয়ে আলাদা মডেলে ১৬ ধাপের। রিপোর্টের শিরোনামই ছিল “১৭ ধাপের পরে ফিরে আসা ghost key”.
এমন bug হাতে লেখা test-এ ধরা পড়ে না, কারণ মানুষ ক্রম ভাবে উদ্দেশ্য ধরে: “লিখি, পড়ি, মুছি, পড়ি”। কিন্তু ভুলটি লুকিয়ে ছিল কয়েকটি কাজের এক বিরল মিশ্রণে, বন্ধ আর খোলার নির্দিষ্ট মুহূর্তে। এমন ক্রমের সংখ্যা জ্যামিতিক হারে বাড়ে; ৬টি কাজের ১৭ ধাপে সম্ভাব্য ক্রম কোটি কোটির অনেক বেশি। এলোমেলো generator উদ্দেশ্য ছাড়াই অদ্ভুত মিশ্রণ চেষ্টা করে, আর মডেল (একটি সাধারণ dictionary) প্রতিটি ধাপে বলে দেয় সঠিক ফল কী হওয়ার কথা।
Shrinking এখানে অপরিহার্য। এলোমেলো ব্যর্থ ক্রম হয়তো শত ধাপের, যার বেশিরভাগ অপ্রাসঙ্গিক; তা দেখে developer কিছুই বুঝবেন না। বাজারঘরে একই ঘটনা ছোট আকারে দেখেছেন: ১২ ধাপের এলোমেলো ক্রম থেকে চার ধাপ। LevelDB-র ক্ষেত্রে ১৭ ধাপও দীর্ঘ, কিন্তু এমন একটি ক্রম, যার প্রতিটি ধাপ দরকারি, আর যা developer হাতে চালিয়ে দেখতে পারেন। মনে রাখুন, এই বিবরণ প্রকাশিত issue-র ভিত্তিতে; ভুলের চূড়ান্ত কারণ আর সমাধানের বিস্তারিত এখানে দাবি করা হচ্ছে না।
মূল উপলব্ধি: state-এর ভুল লুকায় ক্রমের মিশ্রণে; এলোমেলো ক্রম সেখানে পৌঁছায়, আর shrinking ফলটিকে মানুষের পড়ার মতো করে।
প্র ০৩Oracle problem কী, আর metamorphic testing কীভাবে সঠিক উত্তর না জেনেও ভুল ধরে? এর সীমা কোথায়?
প্রতিটি test-এর দুটি অংশ: input আর প্রত্যাশিত ফল। Input বানানো সহজ, Hypothesis সেকেন্ডে হাজারটি বানায়। কিন্তু প্রতিটির সঠিক ফল কে বলবে? এটিই oracle problem. বাজারঘরের coupon-এ সমস্যাটি ছোট, কারণ নিয়ম সহজ। কিন্তু search ফলাফলের ক্রম, ছবির আকার বদল, machine learning model-এর ভবিষ্যদ্বাণী বা বৈজ্ঞানিক simulation-এ প্রতিটি input-এর সঠিক উত্তর জানা প্রায় অসম্ভব।
Metamorphic testing-এর ধারণা সাধারণত T. Y. Chen ও সহকর্মীদের ১৯৯৮ সালের একটি technical report-এর সাথে যুক্ত করা হয়। কৌশলটি: একটি উত্তর না জেনে, দুটি সম্পর্কিত input-এর উত্তরের সম্পর্ক যাচাই করা। Search-এ “চাল” খুঁজে ১০টি ফল পেলে “চাল ঢাকা” খুঁজলে ফল বাড়ার কথা নয়। Delivery-র নিয়মে অর্ডারের পরিমাণ বাড়লে ঢাকার delivery charge বাড়ার কথা নয়। বাজারঘরে আমরা “বেশি কিনলে মোট বিল কমে না” সম্পর্কটি চেষ্টা করেছিলাম, আর এটি ভেঙেছিল। সেখানে একটি জরুরি শিক্ষা: metamorphic relation নিজেও একটি দাবি, যা ভুল হতে পারে। ভাঙলে তিনটি সম্ভাবনা: কোডে bug, relation ভুল, বা requirement-এ এমন আচরণ যা কেউ খেয়াল করেনি। শেষেরটি প্রায়ই সবচেয়ে মূল্যবান।
সীমা হলো, relation দুর্বল হলে অনেক ভুল পালায়। “বেশি কিনলে ছাড় কমে না” সত্য, কিন্তু coupon_ge-এর ভুল এতে ধরা পড়ে না, কারণ ১০০০-এ ছাড় ১০০ আর ১০০১-এ ছাড় ১০০ পরস্পরের সাথে সামঞ্জস্যপূর্ণ। তাই metamorphic relation অন্য oracle-এর পরিপূরক: সীমার উদাহরণ, invariant, আর যেখানে সম্ভব একটি স্বাধীন হিসাব।
মূল উপলব্ধি: সঠিক উত্তর অজানা হলেও উত্তরগুলোর পারস্পরিক সম্পর্ক প্রায়ই জানা; সেই সম্পর্কই oracle, তবে সেটিও যাচাই করতে হয়।
প্র ০৪এলোমেলো test কি পরিকল্পিত test-এর চেয়ে দুর্বল? §৫-এর ২০টি seed-এর ফল আর পুরোনো গবেষণা মিলিয়ে উত্তর দিন।
Random testing নিয়ে বিতর্ক পুরোনো। Glenford Myers-এর “The Art of Software Testing” (১৯৭৯) এলোমেলো input-কে দুর্বল পদ্ধতি বলে দেখিয়েছিল, কারণ এটি ঝুঁকিপূর্ণ বিন্দু (সীমা) খুঁজে নেওয়ার নিশ্চয়তা দেয় না। আবার ১৯৮০-র দশকে Joe Duran আর Simeon Ntafos-এর একটি পরিচিত গবেষণা (আমাদের জানামতে ১৯৮৪ সালে প্রকাশিত) দেখিয়েছিল, অনেক ক্ষেত্রে random testing খরচের তুলনায় আশ্চর্য রকম কার্যকর, পরিকল্পিত partition-ভিত্তিক test-এর কাছাকাছি।
আমাদের সংখ্যা দুই দিকই দেখায়। coupon_ge-এর ভুল শুধু একটি বিন্দুতে (১০০০); ১০০টি উদাহরণে ২০টি seed-এর ৮টিতে পালাল। যদি Hypothesis সমান-সম্ভাবনায় সংখ্যা বাছত, প্রায় সবগুলোতেই পালাত; কোডের constant (১০০০) তুলে চেষ্টা করার বৈশিষ্ট্য ছাড়া ১২টি সাফল্যও আসত না। অন্যদিকে, ১০০০টি উদাহরণে ২০টিতেই ধরা পড়ল, আর @example(1000) দিয়ে প্রতিবার, প্রথম চালেই। আবার রিভিউর UTF-16 ভুলটি, যেখানে ব্যর্থ input বিশাল জগৎ জুড়ে ছড়ানো, Hypothesis অনায়াসে ধরল; কোনো BVA তালিকায় “দুটি BMP-বহির্ভূত অক্ষর” সারি থাকত না।
সুতরাং প্রশ্নটি “কোনটি ভালো” নয়, “কোন ধরনের ভুল কোথায় লুকায়”। সংকীর্ণ, জানা বিন্দুর ভুল (off-by-one) পরিকল্পিত test-এর এলাকা; বিস্তৃত, অপ্রত্যাশিত মিশ্রণের ভুল (Unicode, ক্রম, বড় সংখ্যা) এলোমেলো generation-এর এলাকা। Hypothesis নিজেও এই মিশ্রণ করে: সমান-সম্ভাবনার বদলে সীমার কাছের, ছোট আর “বিশেষ” মান বেশি বাছে, যা §৫-এর assume-পরিসংখ্যানেও দেখা গেল।
মূল উপলব্ধি: random আর পরিকল্পিত test প্রতিযোগী নয়; পরিকল্পিত test জানা ঝুঁকি পাহারা দেয়, random test অজানা ঝুঁকি খোঁজে, আর দুটির ফল সংখ্যা দিয়ে মাপা যায়।
প্র ০৫একটি property test CI-তে একদিন লাল, পরদিন সবুজ। এটি কি flaky test? Property-based testing আর পুনরুৎপাদনযোগ্যতার টানাপোড়েন কীভাবে সামলাবেন?
এখানে একটি মৌলিক পার্থক্য আছে। পর্ব ৪০-এর flaky test একই input-এ কখনো পাস, কখনো ফেল করে, কারণ সময়, network বা ক্রমের মতো বাইরের কিছু। Property test-এ দুই দিনের input-ই আলাদা হতে পারে: আজ generator একটি ব্যর্থ input খুঁজে পেয়েছে, কাল পায়নি। সেটি flaky নয়; একটি আসল ভুল, যা কাল লুকিয়ে ছিল। ভুল সিদ্ধান্ত হবে test বন্ধ করা বা “আবার চালাই” বোতাম চাপা।
সঠিক প্রতিক্রিয়া: লগ থেকে “Failing test case” তুলে নেওয়া (Hypothesis এর জন্যই shrunk input স্পষ্ট ছাপে), সেটিকে @example হিসেবে স্থায়ী করা, তারপর ঠিক করা। এখন ভুলটি আর random-এর ভাগ্যে নেই। Hypothesis-এর example database-ও একই কাজ করে, কিন্তু শুধু সেই কম্পিউটারে, যেখানে ফোল্ডারটি আছে; CI-এর প্রতিটি নতুন container খালি database নিয়ে শুরু হয়, তাই স্পষ্ট @example নিরাপদ।
দলগুলো সাধারণত দুই স্তরের নিয়ম রাখে। Pull request-এ দ্রুত আর স্থির run: কম উদাহরণ, প্রয়োজনে seed বা derandomize=True, যাতে কারও কোড অন্যের অসম্পর্কিত ভুলে আটকে না যায়। আর রাতে বড়, এলোমেলো run, যার কাজই নতুন ভুল খোঁজা, আর যার লাল ফল একটি issue তৈরি করে, merge আটকায় না। দুই স্তরেই deadline সাবধানে রাখুন: ধীর CI machine-এ ২০০ মিলিসেকেন্ড পার হওয়া আসলেই flaky আচরণের উৎস হতে পারে।
আর একটি সত্যিকারের flaky উৎস: test-এর কোড যদি নিজে random, সময় বা global state ব্যবহার করে, তবে Hypothesis একই input-এ ভিন্ন ফল দেখে আর জানায় যে test টি deterministic নয়। তখন সমস্যা test-এর নকশায় (পর্ব ২৫-এর testable design).
মূল উপলব্ধি: নতুন input-এ নতুন ব্যর্থতা flaky নয়, তথ্য; সেটিকে স্থায়ী উদাহরণে রূপ দিন, আর দ্রুত-স্থির ও ধীর-অনুসন্ধানী run আলাদা রাখুন।
অনুশীলন
খাতা-কলমে করুন; উত্তর খোলার আগে নিজের উত্তর লিখে রাখুন।
-
Test design, delivery-র নিয়ম থেকে: নিয়ম: ঢাকার ভেতরে delivery ৬০ টাকা, তবে ছাড়ের আগের অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি; ঢাকার বাইরে ১২০, Plus সদস্যদের ৬০। Function:
delivery(district, subtotal, plus). (ক) অন্তত চারটি property লিখুন, প্রতিটির ধরনসহ। (খ) প্রতিটির জন্য strategy কী হবে? (গ) কোন@exampleযোগ করবেন?(ক) (১) Invariant: ফল সবসময় ০, ৬০ বা ১২০-এর একটি। (২) শর্তসাপেক্ষ invariant: ঢাকা আর subtotal ≥ ২০০০ হলে ০; ঢাকা আর < ২০০০ হলে ৬০। (৩) Metamorphic: ঢাকায় subtotal বাড়লে charge বাড়ে না। (৪) বাইরের জেলায় subtotal-এর ওপর ফল নির্ভর করে না: একই জেলা আর plus-এ দুটি ভিন্ন subtotal-এর ফল সমান। (৫) Plus কখনো charge বাড়ায় না:
delivery(d, s, True) ≤ delivery(d, s, False).(খ)
st.integers(0, 20_000)subtotal-এর জন্য; জেলাst.sampled_from(["Dhaka", "Gazipur", "Narayanganj", "Sylhet"])(Gazipur আর Narayanganj বাইরে গণ্য, তাই ইচ্ছা করে রাখা); plusst.booleans(). (৩)-এর জন্য দুটি subtotal নিয়েsorted.(গ) ঢাকায় ১৯৯৯ আর ২০০০ (সীমা; ২০০০-এ ছাড় ২০০, ছাড়ের পরে ১৮০০), ২২২১ (ছাড় ২২২, পরে ১৯৯৯) আর ২২২২ (ছাড় ২২২, পরে ঠিক ২০০০)। এই চারটি উদাহরণ
delivery_after_discount-এর মতো ভুল আর তার অঞ্চলের দুই প্রান্ত প্রতিবার পাহারা দেয়। -
ব্যর্থতা পড়ুন: একটি রিভিউ-validator-এর property test এই ফল দিল:
assert True == (10 <= 8), আরFailing test case: ... text='000000𐀀𐀀'. Test-এর assert ছিলaccepted == (10 <= len(text.strip()) <= 500). (ক)Trueআর8কোথা থেকে এলো? (খ) ভুলটি কী, এক বাক্যে? (গ) এই input-কে স্থায়ী regression test বানাতে কী লিখবেন?(ক) বাঁ পাশের
Trueমানে validator রিভিউটি গ্রহণ করেছে। ডান পাশে ৮ হলো text-এর code point-এর সংখ্যা: ছয়টি0আর দুটি𐀀. নিয়ম অনুযায়ী ৮ < ১০, তাই প্রত্যাশা ছিল False.(খ) Validator দৈর্ঘ্য code point-এ নয়, UTF-16 unit-এ গোনে; BMP-র বাইরের প্রতিটি অক্ষর (যেমন অনেক emoji) দুবার গোনা হয়, তাই ৮ অক্ষরের text ১০ বলে গৃহীত হয়।
(গ) Property-র ওপরে
@example(stars=1, text="000000𐀀𐀀"), অথবা আলাদা একটি সাধারণ test যা এই text-এReviewInvalidআশা করে। সাথে উল্টো দিকের একটি উদাহরণ: ৫০০টি emoji (৫০০ code point) গ্রহণযোগ্য হওয়া উচিত। -
Test-এর ভুল খুঁজুন: একজন সহকর্মী লিখেছেন:
তিনি বলছেন, “১০০টি input-এ সবুজ, coupon নিরাপদ।” অন্তত তিনটি সমস্যা চিহ্নিত করুন।@given(st.integers()) def test_coupon(s): assume(s > 1000) assert coupon_discount(s) == min(s // 10, 300)- কোডের অনুলিপি: assert-এর ডান পাশ কোডের হিসাবই আবার লিখেছে। কোডে যে ভুল থাকে (যেমন cap ৩০০ না হয়ে ৩৫০), সহকর্মী কোড দেখে লিখলে test-এও তা-ই থাকবে।
- সীমার অংশ বাদ:
assume(s > 1000)১০০০ বা কম সব input বাতিল করে, তাই “১০০০-এ ছাড় ০” কখনো যাচাই হয় না;coupon_geধরা অসম্ভব। - অপচয়ী strategy:
st.integers()ঋণাত্মক আর ছোট সংখ্যা প্রচুর বানায়; বেশিরভাগ বাতিল হবে। শর্তটি strategy-তে দিন:st.integers(1001, 20_000), আর ১০০০-এর নিচের জন্য আলাদা property. - ঋণাত্মক input-এর আচরণ অজানা: নিয়ম বলে subtotal ঋণাত্মক হলে
ValueError; সেটি আলাদা test-এ দেখা উচিত। - দাবি ভুল: “১০০টি input-এ সবুজ” মানে নিরাপদ নয়, শুধু ভাঙেনি; সীমা
@example-এ রাখতে হবে।
-
হিসাব আর সিদ্ধান্ত: ঢাকার একটি কার্টের জন্য property “বেশি কিনলে মোট বিল কমে না” ভাঙল। নিয়ম: ১০০০-এর বেশি হলে ১০% ছাড় (floor, সর্বোচ্চ ৩০০), delivery ৬০, ২০০০ বা বেশি হলে ফ্রি। (ক) ৯০২ আর ১০০১ টাকার কার্টের মোট বিল হিসাব করুন। (খ) ১৯৯৯ আর ২০০০ টাকার? (গ) এটি কি bug report, না অন্য কিছু?
(ক) ৯০২: ছাড় ০, মোট ৯০২ + ৬০ = ৯৬২. ১০০১: ছাড় ১০০, মোট ১০০১ − ১০০ + ৬০ = ৯৬১. ৯৯ টাকা বেশি কিনে এক টাকা কম। (Hypothesis-এর আসল run এই জোড়াটিই দিয়েছিল:
subtotal=902, extra=99,assert 962 <= 961.)(খ) ১৯৯৯: ছাড় ১৯৯, delivery ৬০, মোট ১৮৬০. ২০০০: ছাড় ২০০, delivery ০, মোট ১৮০০. এক টাকা বেশি কিনে ৬০ টাকা কম।
(গ) কোড requirement হুবহু মানে, তাই এটি defect নয়। এটি requirement-এর একটি অস্বাভাবিকতা, যা product owner-কে প্রশ্ন হিসেবে জানানো উচিত: ক্রেতা ছোট জিনিস যোগ করে কম টাকা দিতে পারেন; এটি কি ইচ্ছাকৃত (উৎসাহ দেওয়ার কৌশল), না সংশোধন দরকার? উত্তর যাই হোক, property-টি সেই অনুযায়ী বদলান (যেমন সীমার বাইরের অঞ্চলে সীমিত), আর সিদ্ধান্তটি লিখে রাখুন।
নিজেকে যাচাই করুন
উত্তর বাছুন; সাথে সাথে ব্যাখ্যা দেখাবে।
ক্রমProperty-based testing-এর কাজের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Requirement থেকে এমন নিয়ম খোঁজা, যা প্রতিটি বৈধ input-এ সত্য
- Input-এর জগৎ বর্ণনা করে strategy বাছাই, শর্তসহ
- জানা সীমাগুলো স্পষ্ট উদাহরণ হিসেবে যোগ করা
- Tool দিয়ে অনেক input বানিয়ে property যাচাই করা
- ব্যর্থ হলে shrink করা সরল counterexample পড়ে কারণ খোঁজা
- সেই counterexample স্থায়ী regression উদাহরণ বানিয়ে ভুল ঠিক করা
Property-based testing-এ shrinking সম্পর্কে কোন বক্তব্যটি সঠিক?
- Shrinking ব্যর্থ test-কে স্বয়ংক্রিয়ভাবে পাস করায়
- এটি ব্যর্থতা বজায় রেখে input সরল করে; ফলটি স্থানীয়ভাবে ছোট, সবসময় সর্বনিম্ন নয়
- এটি input বানানোর আগে strategy ছোট করে
- এটি শুধু সময় বাঁচাতে test-এর সংখ্যা কমায়
একটি function phone number-এর সামনে-পেছনের ফাঁকা জায়গা ছেঁটে বৈধ number ফেরত দেয়। Property: “function-টি তার নিজের ফলের ওপর আবার চালালে ফল বদলায় না।” এটি কোন ধরনের property?
- Round-trip
- ক্রম-নিরপেক্ষতা (commutativity)
- Idempotence
- Differential (oracle)
একটি coupon function-এ ভুল শুধু ঠিক একটি মানে (subtotal = 1000) দেখা দেয়। Hypothesis-এর property test (st.integers(0, 20000), ১০০টি উদাহরণ) কয়েকটি seed-এ ভুলটি ধরে, কয়েকটিতে ধরে না। প্রতিবার ধরার সবচেয়ে নির্ভরযোগ্য উপায় কী?
- Test-এ
@example(1000)যোগ করা - একটি নির্দিষ্ট seed বাঁধা
deadline=Noneদেওয়া- শুধু
max_examplesবাড়িয়ে ১০০০ করা
একটি Hypothesis test st.integers(0, 20000) থেকে input নেয় আর ভেতরে assume(x > 1000) লেখে। Statistics-এ দেখা গেল ১০০টি পাস আর ১০৭টি invalid. সবচেয়ে ভালো উন্নতি কোনটি?
- কিছু করার নেই, invalid input ক্ষতিকর নয়
- assume মুছে দেওয়া
- assume-এর বদলে strategy-তে
.filter(lambda x: x > 1000)বসানো - Strategy বদলে
st.integers(1001, 20000)করা
একটি অর্ডারের state machine-এর stateful property test-এ invariant: “যে অর্ডার একবার shipped হয়েছে, তা কখনো cancelled হবে না।” Shrink-এর পরে ব্যর্থ ক্রম: pay, pack, ship, cancel. এ থেকে সবচেয়ে সঠিক সিদ্ধান্ত কোনটি?
- pay-এর কোডে ভুল, কারণ ক্রমটি pay দিয়ে শুরু
- Shipped অবস্থায় cancel-এর অবৈধ পথ খোলা আছে
- ভুলটি তিন ধাপেই ঘটে, চতুর্থ ধাপ অপ্রাসঙ্গিক
- Test টি flaky, তাই আবার চালানো উচিত
একটি AI assistant coupon-এর এই property test লিখে দিল: assert coupon(s) == (min(s // 10, 300) if s >= 1000 else 0). Requirement বলে “১০০০ টাকার বেশি হলে ১০% ছাড়, সর্বোচ্চ ৩০০”। Test সবুজ। মূল সমস্যা কী?
- Test requirement নয়, বর্তমান কোডের হিসাব নকল করেছে (
>=), তাই ভুল কোডেও পাস করে - ভাগে
//ব্যবহার ভুল - Cap ৩০০ ভুল লেখা
- একটি test-এ একটির বেশি assert থাকা উচিত
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Property = প্রতিটি বৈধ input-এ সত্য একটি নিয়ম; tool অনেক input বানিয়ে ভাঙার চেষ্টা করে, আর ভাঙলে shrink করে সরল counterexample দেখায়।
- Property-র ছাঁচ: invariant, round-trip, oracle, metamorphic, idempotence, ক্রম-নিরপেক্ষতা, stateful. Oracle requirement থেকে লিখুন, কোড থেকে নয়।
- Hypothesis:
@given+ strategy; শর্ত strategy-তে,assumeকম;@exampleজানা সীমার জন্য;max_examples,deadline, profile; ব্যর্থ input database-এ জমা থাকে। - Random সম্ভাবনার খেলা:
coupon_ge১০০ উদাহরণে ২০ seed-এর ৮টিতে পালাল। এক বিন্দুর ভুল উদাহরণে ধরুন, বিস্তৃত ভুল (Unicode, ক্রম) property-তে। - Stateful test কাজের এলোমেলো ক্রমে invariant যাচাই করে আর ক্রম ছোট করে: বাজারঘরে pay, pack, ship, cancel.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৫৯ · Mutation testing — test-এর test, mutmut আর mutation scoreপরবর্তী পর্বইচ্ছে করে ছোট bug বসিয়ে দেখা, আপনার test সেটি ধরে কি না।
- সফটওয়্যার টেস্টিং ও QA · কোর্স হোম৮২টি পর্ব১৪টি মডিউলের পুরো রোডম্যাপ।
- পর্ব ৩১ · Code দিয়ে API testingআগের ধাপSchemathesis: OpenAPI থেকে Hypothesis-চালিত API test.
- পাইথন প্রোগ্রামিং · পর্ব ৪২পাশের ট্র্যাকpytest-এর ভিত্তি আর property-based testing-এর প্রথম স্বাদ।
- ডিসক্রিট ম্যাথ · পর্ব ৭৭গভীরে যানTest-এর বাইরে: SAT/SMT দিয়ে নিয়ম প্রমাণ করা।