চূড়ান্ত প্রকল্প — একটি সম্পূর্ণ টেস্ট স্যুট ডিজাইন ও ইমপ্লিমেন্ট করা

# ========== মডিউল ১: shopping_cart কোর ফাংশন + ইউনিট টেস্ট ==========
import unittest

def new_cart():
    return {"items": [], "coupon": None}

def add_item(cart, item, price, qty=1):
    cart["items"].append({"item": item, "price": price, "qty": qty})
    return cart

def apply_coupon(cart, coupon_code):
    cart["coupon"] = coupon_code
    return cart

def calculate_total(cart):
    subtotal = sum(i["price"] * i["qty"] for i in cart["items"])
    coupon = cart.get("coupon")
    rate = 0.0
    if coupon == "SAVE10":
        if subtotal >= 5000:
            rate = 0.15
        elif subtotal >= 2000:
            rate = 0.10
        elif subtotal >= 500:
            rate = 0.05
    return round(subtotal * (1 - rate), 2)


class ShoppingCartCoreTests(unittest.TestCase):
    def test_add_single_item(self):
        cart = new_cart()
        add_item(cart, "Bluetooth Speaker", 1500, 1)
        self.assertEqual(calculate_total(cart), 1500)

    def test_add_multiple_items_multiplies_qty(self):
        cart = new_cart()
        add_item(cart, "Notebook", 60, 3)
        add_item(cart, "Pen", 20, 2)
        # 60*3 + 20*2 = 180 + 40 = 220
        self.assertEqual(calculate_total(cart), 220)

    def test_apply_coupon_below_threshold_no_discount(self):
        cart = new_cart()
        add_item(cart, "Hair Oil", 280, 1)
        apply_coupon(cart, "SAVE10")
        self.assertEqual(calculate_total(cart), 280)

    def test_apply_coupon_mid_tier_discount(self):
        cart = new_cart()
        add_item(cart, "Rice Cooker", 3200, 1)
        apply_coupon(cart, "SAVE10")
        # 3200 * (1 - 0.10) = 2880.0
        self.assertEqual(calculate_total(cart), 2880.0)

    def test_invalid_coupon_code_ignored(self):
        cart = new_cart()
        add_item(cart, "Rice Cooker", 3200, 1)
        apply_coupon(cart, "NOT-A-REAL-CODE")
        self.assertEqual(calculate_total(cart), 3200)


def make_suite1():
    # প্রতিবার একটি নতুন TestSuite তৈরি করা হচ্ছে -- unittest.TestSuite.run() ডিফল্টভাবে
    # প্রতিটি টেস্ট চলার পর তার রেফারেন্স None দিয়ে বদলে দেয় (মেমরি বাঁচাতে), তাই একই suite
    # instance দ্বিতীয়বার .run() করলে "'NoneType' object is not callable" এরর দেয়। এই
    # ফাংশনটি পরের মডিউলগুলোতেও (কভারেজ, মিউটেশন, চূড়ান্ত সারাংশ) পুনরায় কল করা হবে যাতে
    # প্রতিবারই একটি genuinely তাজা suite পাওয়া যায়।
    return unittest.TestLoader().loadTestsFromTestCase(ShoppingCartCoreTests)

unittest.TextTestRunner(verbosity=2).run(make_suite1())

# ========== মডিউল ২: checkout() + payment gateway টেস্ট ডাবল (unittest.mock) ==========
from unittest.mock import Mock

def checkout(cart, payment_gateway):
    total = calculate_total(cart)
    if total <= 0:
        raise ValueError("খালি বা শূন্য-মূল্যের কার্ট চেকআউট করা যাবে না")
    result = payment_gateway.charge(total)
    if result.get("status") != "success":
        raise RuntimeError("পেমেন্ট ব্যর্থ হয়েছে")
    return {
        "status": "confirmed",
        "amount_charged": total,
        "transaction_id": result.get("transaction_id"),
    }


class CheckoutMockTests(unittest.TestCase):
    def test_checkout_calls_gateway_with_correct_amount(self):
        cart = new_cart()
        add_item(cart, "Electric Kettle", 1200, 1)
        mock_gateway = Mock()
        mock_gateway.charge.return_value = {"status": "success", "transaction_id": "TXN-001"}

        result = checkout(cart, mock_gateway)

        mock_gateway.charge.assert_called_once_with(1200)
        self.assertEqual(result["status"], "confirmed")
        self.assertEqual(result["transaction_id"], "TXN-001")

    def test_checkout_raises_when_gateway_declines(self):
        cart = new_cart()
        add_item(cart, "Electric Kettle", 1200, 1)
        mock_gateway = Mock()
        mock_gateway.charge.return_value = {"status": "declined"}

        with self.assertRaises(RuntimeError):
            checkout(cart, mock_gateway)

    def test_checkout_rejects_empty_cart_without_calling_gateway(self):
        cart = new_cart()
        mock_gateway = Mock()

        with self.assertRaises(ValueError):
            checkout(cart, mock_gateway)

        mock_gateway.charge.assert_not_called()


def make_suite2():
    # (একই কারণে -- দেখুন মডিউল ১-এর make_suite1()-এর কমেন্ট) প্রতিবার একটি নতুন suite তৈরি করা হচ্ছে
    return unittest.TestLoader().loadTestsFromTestCase(CheckoutMockTests)

unittest.TextTestRunner(verbosity=2).run(make_suite2())

# ========== মডিউল ৩: কুপন ডিসকাউন্ট -- বাউন্ডারি ও ইকুইভ্যালেন্স টেস্ট ==========
BOUNDARY_AND_EQUIVALENCE_CASES = [
    # (subtotal, expected_discount_rate, description)
    (250,  0.00, "ইকুইভ্যালেন্স: প্রথম রেঞ্জ থেকে প্রতিনিধি মান"),
    (499,  0.00, "বাউন্ডারি: প্রথম থ্রেশহোল্ডের ঠিক নিচে"),
    (500,  0.05, "বাউন্ডারি: প্রথম থ্রেশহোল্ডে ঠিক"),
    (501,  0.05, "বাউন্ডারি: প্রথম থ্রেশহোল্ডের ঠিক উপরে"),
    (1250, 0.05, "ইকুইভ্যালেন্স: দ্বিতীয় রেঞ্জ থেকে প্রতিনিধি মান"),
    (1999, 0.05, "বাউন্ডারি: দ্বিতীয় থ্রেশহোল্ডের ঠিক নিচে"),
    (2000, 0.10, "বাউন্ডারি: দ্বিতীয় থ্রেশহোল্ডে ঠিক"),
    (2001, 0.10, "বাউন্ডারি: দ্বিতীয় থ্রেশহোল্ডের ঠিক উপরে"),
    (3500, 0.10, "ইকুইভ্যালেন্স: তৃতীয় রেঞ্জ থেকে প্রতিনিধি মান"),
    (4999, 0.10, "বাউন্ডারি: তৃতীয় থ্রেশহোল্ডের ঠিক নিচে"),
    (5000, 0.15, "বাউন্ডারি: তৃতীয় থ্রেশহোল্ডে ঠিক"),
    (5001, 0.15, "বাউন্ডারি: তৃতীয় থ্রেশহোল্ডের ঠিক উপরে"),
]

class CouponBoundaryTests(unittest.TestCase):
    def test_discount_rate_across_boundaries_and_partitions(self):
        for subtotal, expected_rate, description in BOUNDARY_AND_EQUIVALENCE_CASES:
            with self.subTest(subtotal=subtotal, desc=description):
                cart = new_cart()
                add_item(cart, "BoundaryTestItem", subtotal, 1)
                apply_coupon(cart, "SAVE10")
                expected_total = round(subtotal * (1 - expected_rate), 2)
                self.assertEqual(
                    calculate_total(cart), expected_total,
                    f"{description}: subtotal={subtotal} হলে {expected_rate*100:.0f}% ছাড় প্রত্যাশিত ছিল",
                )


def make_suite3():
    # (একই কারণে -- দেখুন মডিউল ১-এর make_suite1()-এর কমেন্ট) প্রতিবার একটি নতুন suite তৈরি করা হচ্ছে
    return unittest.TestLoader().loadTestsFromTestCase(CouponBoundaryTests)

unittest.TextTestRunner(verbosity=2).run(make_suite3())

# ========== মডিউল ৪: calculate_total-এর কভারেজ পরিমাপ -- sys.settrace() ==========
import sys

# calculate_total-এর বডিতে (def লাইন বাদে) ঠিক ১১টি নন-ব্ল্যাংক executable স্টেটমেন্ট-লাইন আছে --
# ম্যানুয়ালি গোনা টোটাল ব্যবহার করা হচ্ছে (CLAUDE.md-এর অনুমোদিত সরলীকরণ)
TOTAL_EXECUTABLE_LINES = 11

_executed_lines = set()

def _trace_calls(frame, event, arg):
    if frame.f_code is calculate_total.__code__:
        return _trace_lines
    return None

def _trace_lines(frame, event, arg):
    if event == "line":
        _executed_lines.add(frame.f_lineno)
    return _trace_lines

sys.settrace(_trace_calls)
try:
    _cov_r1 = unittest.TestResult(); make_suite1().run(_cov_r1)
    _cov_r2 = unittest.TestResult(); make_suite2().run(_cov_r2)
    _cov_r3 = unittest.TestResult(); make_suite3().run(_cov_r3)
finally:
    sys.settrace(None)  # ট্রেসিং বন্ধ করা আবশ্যক, নাহলে পরের সব কোড লাইন-বাই-লাইন ট্রেস হতে থাকবে

lines_hit = len(_executed_lines)
coverage_percent = round(100 * lines_hit / TOTAL_EXECUTABLE_LINES, 1)

tests_replayed = _cov_r1.testsRun + _cov_r2.testsRun + _cov_r3.testsRun
replay_bad = (len(_cov_r1.failures) + len(_cov_r1.errors) +
              len(_cov_r2.failures) + len(_cov_r2.errors) +
              len(_cov_r3.failures) + len(_cov_r3.errors))

print(f"কভারেজ পরিমাপের জন্য {tests_replayed}টি টেস্ট আবার চালানো হলো (ব্যর্থ/এরর: {replay_bad})")
print(f"calculate_total-এ ট্রেস করে পাওয়া ইউনিক এক্সিকিউটেড লাইন সংখ্যা: {lines_hit}")
print(f"স্টেটমেন্ট কভারেজ: {lines_hit}/{TOTAL_EXECUTABLE_LINES} = {coverage_percent}%")

# ========== মডিউল ৫: মিউটেশন টেস্টিং -- একটি বাউন্ডারি-বাগ মিউট্যান্ট ==========
def calculate_total_mutant_boundary(cart):
    # মিউটেশন: তৃতীয় শাখার >= কে > দিয়ে বদলানো হয়েছে (ক্লাসিক বাউন্ডারি বাগ, L06-এর ধাঁচে)
    subtotal = sum(i["price"] * i["qty"] for i in cart["items"])
    coupon = cart.get("coupon")
    rate = 0.0
    if coupon == "SAVE10":
        if subtotal >= 5000:
            rate = 0.15
        elif subtotal >= 2000:
            rate = 0.10
        elif subtotal > 500:          # মিউটেশন এখানে -- মূল কোডে ছিল >=
            rate = 0.05
    return round(subtotal * (1 - rate), 2)


def _run_and_count(suite):
    result = unittest.TestResult()
    suite.run(result)
    bad = len(result.failures) + len(result.errors)
    passed = result.testsRun - bad
    return result.testsRun, passed, bad


_original_calculate_total = calculate_total
_SUITE_FACTORIES_TO_CHECK = [
    ("মডিউল ১ (কোর ইউনিট টেস্ট)", make_suite1),
    ("মডিউল ২ (checkout mock টেস্ট)", make_suite2),
    ("মডিউল ৩ (বাউন্ডারি টেস্ট)", make_suite3),
]

print("--- বেসলাইন: আসল calculate_total-এর বিরুদ্ধে পুরো টেস্ট স্যুট ---")
calculate_total = _original_calculate_total
for label, make_suite in _SUITE_FACTORIES_TO_CHECK:
    run, passed, bad = _run_and_count(make_suite())
    print(f"  {label}: {passed}/{run} পাস, {bad} ব্যর্থ/এরর")

print("\n--- মিউট্যান্ট: subtotal > 500 (মূলে ছিল >= 500) দিয়ে একই টেস্ট স্যুট আবার চালানো হলো ---")
calculate_total = calculate_total_mutant_boundary
mutant_bad_total = 0
for label, make_suite in _SUITE_FACTORIES_TO_CHECK:
    run, passed, bad = _run_and_count(make_suite())
    mutant_bad_total += bad
    print(f"  {label}: {passed}/{run} পাস, {bad} ব্যর্থ/এরর")

calculate_total = _original_calculate_total   # আসল ফাংশন পুনরুদ্ধার -- পরবর্তী সব কোডের জন্য জরুরি

mutant_killed = mutant_bad_total > 0
mutation_score = 1.0 if mutant_killed else 0.0
print(f"\nমিউট্যান্ট killed? {'হ্যাঁ' if mutant_killed else 'না'}  (মোট ব্যর্থ/এরর টেস্ট: {mutant_bad_total})")
print(f"মিউটেশন স্কোর: {mutation_score * 100:.0f}% (1/1 মিউট্যান্ট killed)")

# ========== মডিউল ৬: চূড়ান্ত টেস্ট-স্যুট কোয়ালিটি সারাংশ ==========
_final_r1 = unittest.TestResult(); make_suite1().run(_final_r1)
_final_r2 = unittest.TestResult(); make_suite2().run(_final_r2)
_final_r3 = unittest.TestResult(); make_suite3().run(_final_r3)

final_tests_run = _final_r1.testsRun + _final_r2.testsRun + _final_r3.testsRun
final_bad = (len(_final_r1.failures) + len(_final_r1.errors) +
             len(_final_r2.failures) + len(_final_r2.errors) +
             len(_final_r3.failures) + len(_final_r3.errors))
final_passed = final_tests_run - final_bad

print(f"ইউনিট + মক + বাউন্ডারি টেস্ট (৩টি TestCase ক্লাস মিলিয়ে): {final_passed}/{final_tests_run} পাস")
print(f"calculate_total-এর স্টেটমেন্ট কভারেজ: {coverage_percent}% ({lines_hit}/{TOTAL_EXECUTABLE_LINES} লাইন)")
print(f"বাউন্ডারি-বাগ মিউট্যান্ট: {'killed (ধরা পড়েছে)' if mutant_killed else 'survived (ধরা পড়েনি)'}, মিউটেশন স্কোর {mutation_score * 100:.0f}%")

overall_healthy = (final_bad == 0) and (coverage_percent == 100.0) and mutant_killed
print("\n" + "=" * 70)
print(
    f"চূড়ান্ত সারাংশ: {final_passed}/{final_tests_run} ইউনিট টেস্ট পাস, "
    f"{coverage_percent}% স্টেটমেন্ট কভারেজ, মিউট্যান্ট killed: {'হ্যাঁ' if mutant_killed else 'না'} "
    f"-- টেস্ট স্যুট {'স্বাস্থ্যকর' if overall_healthy else 'পর্যালোচনা প্রয়োজন'}"
)