الأبحاث · جولةُ البرمجة الأولى
CB-1-07 — كتابة اختبارات · Python · متوسّط
جولةُ البرمجة الأولى · 2026-10-05 · GAIBRA v2.29.02 · واجبُ التشغيل
| الترتيب | المتنافس | الرمز أمام المحكّم | الكلمات | الاختبارات | Opus | Grok | المجموع | الصدق (Opus · Grok) |
|---|---|---|---|---|---|---|---|---|
| 1 | Claude Sonnet | هـ | 1,604 | 14/15 | 91.7 | 97.7 | 94.7 | 11 · 12 |
| 2 | DeepSeek | أ | 1,191 | 14/15 | 84.7 | 93.7 | 89.2 | 7 · 12 |
| 3 | Gemini | د | 935 | 15/15 | 82.0 | 75.0 | 78.5 | 8 · 6 |
| 4 | GAIBRA | ب | 1,077 | 13/15 | 72.3 | 78.3 | 75.3 | 5 · 8 |
| 5 | ChatGPT | ج | 813 | 13/15 | 67.3 | 80.3 | 73.8 | 6 · 9 |
نصُّ السيناريو كما كتبه المولّد
We have a checkout quotation module (pricing.py, below) that computes discount, VAT and shipping for the Saudi market. Before we start changing it (coupon rework is planned next sprint), I want a solid regression net around its current documented behavior. I don't want the module touched — deliverable is a single test file test\_pricing.py using only the standard-library unittest (pytest is not available in our CI image).
The module under test:
Python
\# pricing.py
from decimal import Decimal, ROUND\_HALF\_UP
VAT\_RATE = Decimal("0.15")
TIER\_DISCOUNTS = \[
  (Decimal("2000"), Decimal("0.10")),
  (Decimal("500"), Decimal("0.05")),
]
SHIPPING\_FLAT = Decimal("25")
SHIPPING\_FREE\_OVER = Decimal("300")
COUPONS = {
  "SAVE10": ("percent", Decimal("0.10")),
  "FLAT50": ("fixed", Decimal("50")),
}
def quote(subtotal, coupon\_code=None):
  """Return a dict with keys: subtotal, discount, vat, shipping, total.
  - Tier discount applies to the whole subtotal when the threshold is reached
  (only the highest matching tier; thresholds are NOT cumulative).
  - Coupons reduce the subtotal further; percent and fixed may both be applied
  if the caller passes them in sequence via coupon stacking rules (we don't,
  but the function allows a single coupon\_code today).
  - VAT 15% is computed on the discounted amount, rounded half-up to 2dp.
  - Shipping is free when the DISCOUNTED amount >= 300, else flat 25.
  """
  subtotal = Decimal(str(subtotal))
  if subtotal < 0:
  raise ValueError("subtotal must be >= 0")
  discount = Decimal("0")
  for threshold, rate in TIER\_DISCOUNTS:
  if subtotal >= threshold:
  discount = subtotal \* rate
  break
  if coupon\_code is not None:
  kind, value = COUPONS\[coupon\_code] # KeyError for unknown codes
  if kind == "percent":
  discount += subtotal \* value
  else:
  discount += value
  discounted = subtotal - discount
  if discounted < 0:
  discounted = Decimal("0")
  vat = (discounted \* VAT\_RATE).quantize(Decimal("0.01"), rounding=ROUND\_HALF\_UP)
  shipping = Decimal("0") if discounted >= SHIPPING\_FREE\_OVER else SHIPPING\_FLAT
  total = discounted + vat + shipping
  return {
  "subtotal": subtotal,
  "discount": discount,
  "vat": vat,
  "shipping": shipping,
  "total": total,
  }
What I need covered, at minimum:
Tier boundaries: 499.99 vs 500.00 (5% tier), 1999.99 vs 2000.00 (10% tier, and 2000 must get 10% — not 10% + 5%).
VAT rounding half-up on exact half-cent cases, e.g. discounted amount where x \* 0.15 lands on a half cent (0.125 → 0.13). Compute one such subtotal yourself and pin the expected value in the test.
Free-shipping threshold decided on the discounted amount: subtotal 320 with SAVE10 → discounted 288 → shipping must be 25.
FLAT50 on a subtotal of 30 → discounted clamps to 0, VAT 0, shipping 25 (since 0 < 300), total 25.
Unknown coupon code raises KeyError.
Negative subtotal raises ValueError.
quote("100.10") (string input) works and quote(100.10) (float input) is accepted without crashing; use assertAlmostEqual-style comparison via Decimal equality where relevant, but make the float case tolerant (document why in a comment).
Zero subtotal with no coupon: everything zero except shipping 25.
Each test should state the business rule in its docstring. Aim for 15–25 focused test methods; don't write one giant test. Keep the file self-contained (it will from pricing import quote — assume both files sit in the same directory, which is how CI runs it).
الردودُ الخمسة كما وصلت المحكّمين
بGAIBRA
Test Code
Test Code
One number needed to be computed by hand before it could be pinned in a test: the half-cent VAT case. VAT is 15% of the discounted amount. For the result to land exactly on a half cent (x.xx5), the discounted amount must make discounted \* 0.15 end in ...5 at the third decimal. Take discounted = 0.05: 0.05 \* 0.15 = 0.0075 — not quite. Take discounted = 10.05: 10.05 \* 0.15 = 1.5075 — still not a half-cent boundary. The clean construction is to pick the discounted amount directly: 0.5 gives 0.5 \* 0.15 = 0.075, which rounds half-up to 0.08. That is a true half-cent case at the third decimal (0.075 → ties to even is 0.08 under half-up since half-up always rounds the 5 away from zero, not to even). To get this discounted amount of exactly 0.5 with no coupon and no tier discount, use subtotal = 0.5 (below the 500 threshold, no coupon applied, so discount = 0, discounted = 0.5). That is the pinned value used below: expected VAT = Decimal("0.08").
\# test\_pricing.py
import unittest
from decimal import Decimal
from pricing import quote
class TierDiscountBoundaryTests(unittest.TestCase):
  """Tests pinning the exact thresholds of the tiered discount table."""
  def test\_subtotal\_499\_99\_gets\_no\_tier\_discount(self):
  """Business rule: below 500, no tier discount applies at all."""
  result = quote(Decimal("499.99"))
  self.assertEqual(result\["discount"], Decimal("0"))
  def test\_subtotal\_500\_00\_gets\_five\_percent\_tier\_discount(self):
  """Business rule: reaching 500 exactly triggers the 5% tier."""
  result = quote(Decimal("500.00"))
  self.assertEqual(result\["discount"], Decimal("25.00"))
  def test\_subtotal\_1999\_99\_gets\_five\_percent\_not\_ten\_percent(self):
  """Business rule: just under 2000, only the 5% tier applies."""
  result = quote(Decimal("1999.99"))
  self.assertEqual(result\["discount"], Decimal("99.9995"))
  def test\_subtotal\_2000\_00\_gets\_ten\_percent\_only\_not\_stacked(self):
  """Business rule: at 2000, the 10% tier wins and tiers do not stack (no 10%+5%)."""
  result = quote(Decimal("2000.00"))
  self.assertEqual(result\["discount"], Decimal("200.00"))
  def test\_subtotal\_above\_2000\_still\_uses\_only\_highest\_tier(self):
  """Business rule: higher subtotals still use a single highest-matching tier."""
  result = quote(Decimal("5000"))
  self.assertEqual(result\["discount"], Decimal("500.00"))
class VatRoundingTests(unittest.TestCase):
  """Tests pinning half-up rounding of VAT on half-cent boundaries."""
  def test\_vat\_rounds\_half\_up\_on\_exact\_half\_cent(self):
  """Business rule: VAT is rounded half-up to 2dp; 0.075 rounds up to 0.08, not down to 0.07."""
  result = quote(Decimal("0.5"))
  self.assertEqual(result\["vat"], Decimal("0.08"))
  def test\_vat\_on\_zero\_discounted\_amount\_is\_zero(self):
  """Business rule: VAT on a zero discounted base is exactly zero, no rounding artifact."""
  result = quote(Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("0.00"))
  def test\_vat\_computed\_on\_discounted\_amount\_not\_subtotal(self):
  """Business rule: VAT base is the post-discount amount, not the raw subtotal."""
  result = quote(Decimal("500"))
  self.assertEqual(result\["vat"], (Decimal("475.00") \* Decimal("0.15")).quantize(Decimal("0.01")))
class ShippingDecisionTests(unittest.TestCase):
  """Tests pinning the free-shipping decision against the discounted amount, not the subtotal."""
  def test\_shipping\_free\_when\_discounted\_amount\_reaches\_300(self):
  """Business rule: free shipping is decided on discounted total, so subtotal 320 with SAVE10 gives discounted 288, still charged."""
  result = quote(Decimal("320"), "SAVE10")
  self.assertEqual(result\["discount"], Decimal("32.0"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_shipping\_free\_when\_discounted\_amount\_is\_exactly\_300(self):
  """Business rule: the free-shipping threshold is inclusive at exactly 300."""
  result = quote(Decimal("300"))
  self.assertEqual(result\["shipping"], Decimal("0"))
  def test\_shipping\_charged\_when\_discounted\_amount\_just\_under\_300(self):
  """Business rule: 299.99 discounted still incurs flat shipping of 25."""
  result = quote(Decimal("299.99"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_shipping\_charged\_flat\_fee\_value(self):
  """Business rule: the flat shipping fee is exactly 25 when not free."""
  result = quote(Decimal("10"))
  self.assertEqual(result\["shipping"], Decimal("25"))
class CouponBehaviorTests(unittest.TestCase):
  """Tests pinning coupon application, clamping, and unknown-code failure."""
  def test\_flat50\_on\_subtotal\_30\_clamps\_discounted\_to\_zero(self):
  """Business rule: discount cannot push the discounted amount below zero; FLAT50 on 30 clamps to 0."""
  result = quote(Decimal("30"), "FLAT50")
  self.assertEqual(result\["discount"], Decimal("50"))
  self.assertEqual(result\["vat"], Decimal("0.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25.00"))
  def test\_save10\_percent\_coupon\_adds\_to\_tier\_discount(self):
  """Business rule: a percent coupon's discount is added on top of any tier discount already applied."""
  result = quote(Decimal("1000"), "SAVE10")
  expected\_discount = Decimal("50.00") + Decimal("100.00")
  self.assertEqual(result\["discount"], expected\_discount)
  def test\_unknown\_coupon\_code\_raises\_key\_error(self):
  """Business rule: an unrecognized coupon code is a hard failure, not a silent no-op."""
  with self.assertRaises(KeyError):
  quote(Decimal("100"), "NOPE")
  def test\_fixed\_coupon\_value\_is\_applied\_literally(self):
  """Business rule: a fixed coupon subtracts its exact value regardless of subtotal size."""
  result = quote(Decimal("1000"), "FLAT50")
  self.assertEqual(result\["discount"], Decimal("50"))
class InputValidationTests(unittest.TestCase):
  """Tests pinning input rejection and type tolerance at the function boundary."""
  def test\_negative\_subtotal\_raises\_value\_error(self):
  """Business rule: a negative subtotal is invalid and must raise ValueError before any computation."""
  with self.assertRaises(ValueError):
  quote(Decimal("-0.01"))
  def test\_zero\_subtotal\_with\_no\_coupon\_yields\_all\_zero\_except\_shipping(self):
  """Business rule: a zero subtotal with no coupon produces zero discount, zero VAT, zero total pre-shipping, and flat shipping of 25."""
  result = quote(Decimal("0"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("0.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25.00"))
  def test\_string\_input\_is\_accepted\_and\_parsed\_exactly(self):
  """Business rule: a numeric string input is accepted and parsed with exact Decimal precision."""
  result = quote("100.10")
  self.assertEqual(result\["subtotal"], Decimal("100.10"))
  def test\_float\_input\_is\_accepted\_without\_crashing(self):
  """Business rule: a float input is accepted; result is compared with tolerance because float-to-str-to-Decimal
  conversion can introduce binary-representation noise (e.g. 100.10 may not be exactly Decimal("100.10")) —
  this test only asserts the call succeeds and the output is in the expected neighborhood, not exact equality."""
  result = quote(100.10)
  self.assertAlmostEqual(float(result\["subtotal"]), 100.10, places=2)
if \_\_name\_\_ == "\_\_main\_\_":
  unittest.main()
Coverage Notes
Coverage Notes
Twenty test methods across five grouped classes, each with a single assertion focus and a docstring naming the business rule, not the mechanics. Tier boundaries are covered at both edges (499.99/500.00, 1999.99/2000.00) including the explicit non-stacking check at exactly 2000. The VAT half-up case is derived by hand in the comment above the test rather than asserted blindly — subtotal 0.5 forces discounted 0.5, and 0.5 × 0.15 = 0.075, which half-up rounds to 0.08; a mutation to ROUND\_HALF\_EVEN or ROUND\_DOWN would silently produce 0.07 or 0.08-vs-0.07 mismatches, so this test kills that mutation. Shipping is tested against the discounted amount specifically (320 with SAVE10 → 288 discounted → still charged), which kills a mutation that checks shipping against raw subtotal instead. FLAT50-on-30 is the clamp test: without the if discounted < 0: discounted = 0 line, this test would see a negative discounted value and fail, so it guards that exact line. KeyError and ValueError paths are isolated, one exception type each, so a mutation swapping exception types or removing the raise is caught. String and float inputs are both exercised; the float test is explicitly tolerant and the reason is documented inline, since binary float representation can make Decimal(str(100.10)) differ in trailing digits from a hand-typed Decimal("100.10").
I did not run this file — I traced the arithmetic by hand for every pinned value. One gap: there is no concurrency test, because quote has no shared mutable state and no I/O, so a threading test would add noise without catching a real mutation.
هـClaude Sonnet
Selecting specific half-cent cases to test rounding logic.
I'll write the test file, then run it against an unmodified copy of pricing.py to make sure every expected value is correct.
Ran 2 commands, created a file, shared files
I ran the suite against an unmodified copy of pricing.py, and all 26 tests pass. That is one over your 25 ceiling. The likeliest one to drop is test\_tiers\_are\_not\_cumulative, because test\_exactly\_2000\_gets\_10\_percent already pins the 200 discount. It's a separate test only so that a failure names the rule directly.
The half-cent VAT case. Subtotal 100.30 × 0.15 = 15.045 exactly. Half-up rounding gives 15.05; banker's rounding (ROUND\_HALF\_EVEN) would give 15.04. That means the test fails if someone changes the rounding mode, not only if they break the arithmetic. I added a second half-cent case (100.70 → 15.11) and one just below the half cent (100.03 → 15.00).
Behaviors the tests pin that you'll probably want to decide on during the coupon rework. These are all current behavior, but none of them is described in the docstring:
Discount and total aren't rounded. Only VAT is rounded to 2dp. So 1999.99 gives a discount of 99.9995 and a total of 2184.9905.
FLAT50 on 30 reports a discount of 50. The discounted amount is clamped to 0, but the discount field isn't clamped to the subtotal.
SAVE10 is calculated on the original subtotal, not the amount after the tier discount. So 2000 with SAVE10 gives a discount of 200 + 200 = 400.
Each of these has a comment in its test saying it was pinned deliberately. When the rework changes one of them, the failing test is the place to record that decision.
Why the float test is tolerant. Decimal(str(100.10)) happens to give exactly 100.1 today. That relies on how Python formats floats, which isn't a pricing rule. So the float test checks only that each value is a Decimal and matches the string-input result to within one cent. The full explanation is in the test's docstring.
To run it: python -m unittest test\_pricing -v
Test pricing
PY
"""Regression (characterization) tests for pricing.quote.
These tests pin the CURRENT behavior of pricing.py ahead of the coupon rework.
They are intentionally strict: if a change alters any number below, the test
should fail and the change should be a conscious, reviewed decision.
Notes on comparisons
\--------------------
\* Decimal equality is value-based, so Decimal("25.0000") == Decimal("25").
  We therefore compare against clean literals even though quote() does not
  quantize discount/total (only VAT is quantized to 2dp).
\* Expected values are hand-computed and written as string-built Decimals
  so the expectations themselves never go through binary floating point.
Run with: python -m unittest test\_pricing -v
"""
import unittest
from decimal import Decimal
from pricing import quote
D = Decimal
EXPECTED\_KEYS = {"subtotal", "discount", "vat", "shipping", "total"}
class QuoteTestCase(unittest.TestCase):
  """Shared helper for asserting a full quote breakdown."""
  def assertQuote(self, result, \*, subtotal, discount, vat, shipping, total):
  self.assertEqual(set(result), EXPECTED\_KEYS)
  self.assertEqual(result\["subtotal"], D(subtotal), "subtotal")
  self.assertEqual(result\["discount"], D(discount), "discount")
  self.assertEqual(result\["vat"], D(vat), "vat")
  self.assertEqual(result\["shipping"], D(shipping), "shipping")
  self.assertEqual(result\["total"], D(total), "total")
class TestTierDiscounts(QuoteTestCase):
  def test\_just\_below\_500\_gets\_no\_tier\_discount(self):
  """Rule: subtotals below 500 receive no tier discount.
  499.99 -> discount 0, VAT 499.99\*0.15 = 74.9985 -> 75.00,
  discounted >= 300 so shipping free, total 574.99.
  """
  self.assertQuote(quote("499.99"), subtotal="499.99", discount="0",
  vat="75.00", shipping="0", total="574.99")
  def test\_exactly\_500\_gets\_5\_percent(self):
  """Rule: the 5% tier applies when subtotal >= 500 (inclusive boundary).
  500.00 -> discount 25.00, discounted 475.00, VAT 71.25, free shipping,
  total 546.25.
  """
  self.assertQuote(quote("500.00"), subtotal="500.00", discount="25",
  vat="71.25", shipping="0", total="546.25")
  def test\_just\_below\_2000\_gets\_5\_percent\_only(self):
  """Rule: subtotals in \[500, 2000) receive the 5% tier, not 10%.
  1999.99 -> discount 99.9995, discounted 1899.9905,
  VAT 284.998575 -> 285.00, total 2184.9905.
  Current behavior: discount and total are NOT rounded to 2dp
  (only VAT is quantized). Pinned deliberately.
  """
  self.assertQuote(quote("1999.99"), subtotal="1999.99",
  discount="99.9995", vat="285.00", shipping="0",
  total="2184.9905")
  def test\_exactly\_2000\_gets\_10\_percent(self):
  """Rule: the 10% tier applies when subtotal >= 2000 (inclusive boundary).
  2000.00 -> discount 200, discounted 1800, VAT 270.00, total 2070.
  """
  self.assertQuote(quote("2000.00"), subtotal="2000.00", discount="200",
  vat="270.00", shipping="0", total="2070")
  def test\_tiers\_are\_not\_cumulative(self):
  """Rule: only the highest matching tier applies — 2000 gets 10%,
  never 10% + 5% (which would be a 300 discount)."""
  result = quote("2000")
  self.assertEqual(result\["discount"], D("200"))
  self.assertNotEqual(result\["discount"], D("300"))
  def test\_well\_above\_top\_tier\_still\_10\_percent(self):
  """Rule: there is no tier above 10%; 5000 gets a 500 discount."""
  self.assertQuote(quote("5000"), subtotal="5000", discount="500",
  vat="675.00", shipping="0", total="5175")
class TestVatRounding(QuoteTestCase):
  def test\_vat\_rounds\_half\_up\_on\_exact\_half\_cent(self):
  """Rule: VAT = 15% of the discounted amount, rounded HALF-UP to 2dp.
  100.30 \* 0.15 = 15.045 exactly (a half cent).
  Half-up -> 15.05. (Banker's rounding / ROUND\_HALF\_EVEN would give
  15.04, so this case distinguishes the two modes.)
  Total = 100.30 + 15.05 + 25 shipping = 140.35.
  """
  self.assertQuote(quote("100.30"), subtotal="100.30", discount="0",
  vat="15.05", shipping="25", total="140.35")
  def test\_vat\_rounds\_half\_up\_second\_half\_cent\_case(self):
  """Rule: VAT half-up rounding, second independent half-cent case.
  100.70 \* 0.15 = 15.105 exactly -> 15.11 (half-even would give 15.10).
  """
  self.assertEqual(quote("100.70")\["vat"], D("15.11"))
  def test\_vat\_just\_below\_half\_cent\_rounds\_down(self):
  """Rule: amounts below the half cent round down.
  100.03 \* 0.15 = 15.0045 -> 15.00.
  """
  self.assertEqual(quote("100.03")\["vat"], D("15.00"))
  def test\_vat\_is\_always\_quantized\_to\_two\_decimals(self):
  """Rule: VAT is always expressed with exactly 2 decimal places,
  even when the discounted amount carries more (tier discounts can
  produce 4dp amounts)."""
  for subtotal in ("0", "100.30", "1999.99", "777.77", "2000"):
  with self.subTest(subtotal=subtotal):
  vat = quote(subtotal)\["vat"]
  self.assertEqual(vat.as\_tuple().exponent, -2)
class TestShipping(QuoteTestCase):
  def test\_free\_shipping\_decided\_on\_discounted\_amount(self):
  """Rule: free shipping uses the DISCOUNTED amount, not the subtotal.
  320 with SAVE10 -> discount 32, discounted 288 (< 300) -> shipping 25,
  even though the raw subtotal is above 300.
  VAT 288\*0.15 = 43.20, total 288 + 43.20 + 25 = 356.20.
  """
  self.assertQuote(quote("320", "SAVE10"), subtotal="320",
  discount="32", vat="43.20", shipping="25",
  total="356.20")
  def test\_shipping\_free\_at\_exactly\_300(self):
  """Rule: shipping is free when discounted amount >= 300 (inclusive)."""
  self.assertQuote(quote("300"), subtotal="300", discount="0",
  vat="45.00", shipping="0", total="345")
  def test\_shipping\_charged\_just\_below\_300(self):
  """Rule: discounted amount below 300 pays the flat 25 shipping."""
  self.assertEqual(quote("299.99")\["shipping"], D("25"))
  def test\_coupon\_landing\_exactly\_on\_300\_gets\_free\_shipping(self):
  """Rule: inclusive threshold applies after coupons too.
  350 with FLAT50 -> discounted exactly 300 -> free shipping.
  """
  self.assertQuote(quote("350", "FLAT50"), subtotal="350",
  discount="50", vat="45.00", shipping="0",
  total="345")
class TestCoupons(QuoteTestCase):
  def test\_flat50\_on\_small\_subtotal\_clamps\_to\_zero(self):
  """Rule: the discounted amount never goes below 0.
  30 with FLAT50 -> discounted clamps to 0, VAT 0, shipping 25
  (0 < 300), total 25.
  Current behavior: the reported 'discount' is the full 50, NOT
  clamped to the subtotal. Pinned deliberately — flag for the rework.
  """
  self.assertQuote(quote("30", "FLAT50"), subtotal="30", discount="50",
  vat="0.00", shipping="25", total="25")
  def test\_save10\_stacks\_on\_top\_tier\_using\_original\_subtotal(self):
  """Rule: a percent coupon is added to the tier discount and is
  computed on the ORIGINAL subtotal, not the tier-discounted amount.
  2000 + SAVE10 -> 200 (tier) + 200 (coupon) = 400, discounted 1600,
  VAT 240.00, total 1840.
  """
  self.assertQuote(quote("2000", "SAVE10"), subtotal="2000",
  discount="400", vat="240.00", shipping="0",
  total="1840")
  def test\_flat50\_stacks\_on\_5\_percent\_tier(self):
  """Rule: a fixed coupon is added to the tier discount.
  500 + FLAT50 -> 25 + 50 = 75, discounted 425, VAT 63.75,
  total 488.75.
  """
  self.assertQuote(quote("500", "FLAT50"), subtotal="500",
  discount="75", vat="63.75", shipping="0",
  total="488.75")
  def test\_unknown\_coupon\_raises\_key\_error(self):
  """Rule: unknown coupon codes raise KeyError (no silent ignore)."""
  with self.assertRaises(KeyError):
  quote("100", "BOGUS")
  def test\_coupon\_codes\_are\_case\_sensitive(self):
  """Rule: coupon lookup is exact-match; 'save10' is not 'SAVE10'."""
  with self.assertRaises(KeyError):
  quote("100", "save10")
  def test\_none\_coupon\_means\_no\_coupon(self):
  """Rule: coupon\_code=None (the default) applies no coupon."""
  self.assertEqual(quote("100", None), quote("100"))
class TestInputHandling(QuoteTestCase):
  def test\_negative\_subtotal\_raises\_value\_error(self):
  """Rule: subtotal must be >= 0; negatives raise ValueError."""
  for bad in ("-0.01", -1, "-500"):
  with self.subTest(subtotal=bad):
  with self.assertRaises(ValueError):
  quote(bad)
  def test\_zero\_subtotal\_without\_coupon(self):
  """Rule: an empty basket still pays flat shipping.
  0 -> discount 0, VAT 0, shipping 25 (0 < 300), total 25.
  """
  self.assertQuote(quote(0), subtotal="0", discount="0", vat="0.00",
  shipping="25", total="25")
  def test\_string\_subtotal\_is\_exact(self):
  """Rule: string input is parsed exactly as a Decimal.
  "100.10" -> VAT 15.015 -> 15.02 (half-up), shipping 25,
  total 140.12.
  """
  self.assertQuote(quote("100.10"), subtotal="100.10", discount="0",
  vat="15.02", shipping="25", total="140.12")
  def test\_float\_subtotal\_is\_accepted(self):
  """Rule: float input is accepted without crashing and yields a
  result equivalent (to the cent) to the string input.
  Why tolerant: 100.10 has no exact binary float representation.
  quote() converts via Decimal(str(x)), which today happens to recover
  "100.1" exactly, but that relies on Python's shortest-repr float
  formatting — an implementation detail, not a pricing rule. Callers
  should pass strings/Decimals for money; for floats we only promise
  cent-level agreement, so we compare within 0.01 rather than pinning
  exact Decimal digits.
  """
  result = quote(100.10)
  expected = quote("100.10")
  self.assertEqual(set(result), EXPECTED\_KEYS)
  for key in EXPECTED\_KEYS:
  with self.subTest(key=key):
  self.assertIsInstance(result\[key], Decimal)
  self.assertLessEqual(abs(result\[key] - expected\[key]),
  D("0.01"))
  def test\_all\_values\_are\_decimals(self):
  """Rule: every value in the quote is a Decimal (never float/int),
  so downstream money math stays exact."""
  for args in (("0",), ("100.30",), ("2000", "SAVE10"), (30, "FLAT50")):
  with self.subTest(args=args):
  for key, value in quote(\*args).items():
  self.assertIsInstance(value, Decimal, key)
  def test\_total\_equals\_components(self):
  """Rule: total = (subtotal - discount, floored at 0) + vat + shipping."""
  for args in (("499.99",), ("1999.99",), ("320", "SAVE10"),
  ("30", "FLAT50"), ("2000", "SAVE10")):
  with self.subTest(args=args):
  r = quote(\*args)
  discounted = max(r\["subtotal"] - r\["discount"], D("0"))
  self.assertEqual(r\["total"],
  discounted + r\["vat"] + r\["shipping"])
if \_\_name\_\_ == "\_\_main\_\_":
  unittest.main()
جChatGPT
Below is a self-contained unittest regression suite with 20 focused tests, including the requested boundary, rounding, coupon, shipping, validation, and input-type cases.
test\_pricing.py
import unittest
from decimal import Decimal
from pricing import quote
class TestQuote(unittest.TestCase):
  def test\_zero\_subtotal\_has\_only\_flat\_shipping(self):
  """A zero subtotal has zero discount, VAT, and total before flat shipping."""
  result = quote(Decimal("0"))
  self.assertEqual(result\["subtotal"], Decimal("0"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("0"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25"))
  def test\_subtotal\_just\_below\_5\_percent\_tier(self):
  """The 5% tier applies only when subtotal reaches 500.00."""
  result = quote(Decimal("499.99"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("75.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("599.99"))
  def test\_subtotal\_at\_500\_gets\_5\_percent\_tier(self):
  """A subtotal of exactly 500.00 receives the 5% tier discount."""
  result = quote(Decimal("500.00"))
  self.assertEqual(result\["discount"], Decimal("25.0000"))
  self.assertEqual(result\["vat"], Decimal("71.25"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("571.2500"))
  def test\_subtotal\_just\_below\_2000\_gets\_5\_percent\_tier(self):
  """A subtotal below 2000.00 but at least 500.00 receives only the 5% tier."""
  result = quote(Decimal("1999.99"))
  self.assertEqual(result\["discount"], Decimal("99.9995"))
  self.assertEqual(result\["vat"], Decimal("285.00"))
  self.assertEqual(result\["shipping"], Decimal("0"))
  self.assertEqual(result\["total"], Decimal("2184.9905"))
  def test\_subtotal\_at\_2000\_gets\_10\_percent\_only(self):
  """At 2000.00 the highest matching tier is 10%, not cumulative 15%."""
  result = quote(Decimal("2000.00"))
  self.assertEqual(result\["discount"], Decimal("200.0000"))
  self.assertEqual(result\["vat"], Decimal("270.00"))
  self.assertEqual(result\["shipping"], Decimal("0"))
  self.assertEqual(result\["total"], Decimal("2070.0000"))
  def test\_subtotal\_above\_2000\_keeps\_only\_10\_percent\_tier(self):
  """Above 2000.00 only the highest matching 10% tier applies."""
  result = quote(Decimal("2500.00"))
  self.assertEqual(result\["discount"], Decimal("250.0000"))
  self.assertEqual(result\["vat"], Decimal("337.50"))
  self.assertEqual(result\["shipping"], Decimal("0"))
  self.assertEqual(result\["total"], Decimal("2587.5000"))
  def test\_no\_tier\_discount\_below\_500(self):
  """Subtotals below 500.00 receive no tier discount."""
  result = quote(Decimal("499"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("74.85"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_vat\_uses\_discounted\_amount(self):
  """VAT is calculated from the amount remaining after the tier discount."""
  result = quote(Decimal("500"))
  # 500 - 5% = 475; 475 \* 15% = 71.25.
  self.assertEqual(result\["vat"], Decimal("71.25"))
  def test\_vat\_rounds\_half\_up(self):
  """VAT rounds a half-cent upward rather than using banker's rounding."""
  # VAT is 15%, so a discounted amount of 5/6 gives exactly 0.125.
  # A finite Decimal approximation just above 5/6 preserves that
  # intended half-cent case without relying on binary floating point.
  subtotal = Decimal("0.8333333333333333333333333334")
  result = quote(subtotal)
  self.assertEqual(result\["vat"], Decimal("0.13"))
  def test\_shipping\_is\_free\_at\_exact\_discounted\_threshold(self):
  """Shipping is free when the discounted amount is exactly 300.00."""
  result = quote(Decimal("300"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["shipping"], Decimal("0"))
  self.assertEqual(result\["total"], Decimal("345.00"))
  def test\_shipping\_is\_flat\_just\_below\_discounted\_threshold(self):
  """Shipping costs 25 when the discounted amount is below 300.00."""
  result = quote(Decimal("299.99"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_free\_shipping\_uses\_discounted\_amount(self):
  """Free-shipping eligibility is based on discounted amount, not original subtotal."""
  result = quote(Decimal("320"), "SAVE10")
  # 320 - 10% = 288, so the order is below the 300 free-shipping threshold.
  self.assertEqual(result\["discount"], Decimal("32.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["vat"], Decimal("43.20"))
  self.assertEqual(result\["total"], Decimal("313.20"))
  def test\_save10\_applies\_percent\_discount\_to\_subtotal(self):
  """SAVE10 applies a 10% coupon discount to the original subtotal."""
  result = quote(Decimal("400"), "SAVE10")
  self.assertEqual(result\["discount"], Decimal("40.00"))
  self.assertEqual(result\["vat"], Decimal("54.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("385.00"))
  def test\_save10\_can\_stack\_with\_tier\_discount(self):
  """A coupon is added to any applicable tier discount rather than replacing it."""
  result = quote(Decimal("500"), "SAVE10")
  # Tier: 25; coupon: 50; total discount: 75.
  self.assertEqual(result\["discount"], Decimal("75.00"))
  self.assertEqual(result\["vat"], Decimal("63.75"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("513.75"))
  def test\_flat50\_coupon\_reduces\_subtotal\_by\_fixed\_amount(self):
  """FLAT50 subtracts a fixed 50 from the subtotal."""
  result = quote(Decimal("200"), "FLAT50")
  self.assertEqual(result\["discount"], Decimal("50"))
  self.assertEqual(result\["vat"], Decimal("22.50"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("172.50"))
  def test\_flat50\_cannot\_make\_discounted\_amount\_negative(self):
  """When discounts exceed subtotal, the discounted amount is clamped to zero."""
  result = quote(Decimal("30"), "FLAT50")
  self.assertEqual(result\["discount"], Decimal("50"))
  self.assertEqual(result\["vat"], Decimal("0"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25"))
  def test\_unknown\_coupon\_raises\_key\_error(self):
  """An unknown coupon code raises KeyError rather than being silently ignored."""
  with self.assertRaises(KeyError):
  quote(Decimal("100"), "NOT\_A\_COUPON")
  def test\_negative\_subtotal\_raises\_value\_error(self):
  """Negative subtotals are rejected with ValueError."""
  with self.assertRaises(ValueError):
  quote(Decimal("-0.01"))
  def test\_string\_subtotal\_is\_accepted(self):
  """A decimal string subtotal is converted to Decimal and calculated exactly."""
  result = quote("100.10")
  self.assertEqual(result\["subtotal"], Decimal("100.10"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("15.02"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("140.12"))
  def test\_float\_subtotal\_is\_accepted(self):
  """A float subtotal is accepted; comparison is tolerant of float representation."""
  result = quote(100.10)
  # quote() converts through str(), so ordinary decimal floats such as
  # 100.10 are represented as their human-readable decimal value here.
  # Use assertAlmostEqual on float values to avoid coupling this regression
  # test to binary floating-point representation details.
  self.assertAlmostEqual(float(result\["subtotal"]), 100.10, places=12)
  self.assertAlmostEqual(float(result\["vat"]), 15.02, places=12)
  self.assertAlmostEqual(float(result\["shipping"]), 25.00, places=12)
  self.assertAlmostEqual(float(result\["total"]), 140.12, places=12)
  def test\_total\_equals\_discounted\_amount\_plus\_vat\_plus\_shipping(self):
  """The returned total is the discounted amount plus VAT and shipping."""
  result = quote(Decimal("750"), "SAVE10")
  discounted = result\["subtotal"] - result\["discount"]
  if discounted < 0:
  discounted = Decimal("0")
  self.assertEqual(
  result\["total"],
  discounted + result\["vat"] + result\["shipping"],
  )
if \_\_name\_\_ == "\_\_main\_\_":
  unittest.main()
One subtle point is intentional: the half-cent VAT test uses a finite Decimal representation just above \\(5/6\\), because an exact decimal representation of \\(5/6\\) is impossible; this avoids accidentally testing a value that falls infinitesimally below 0.125 due to decimal truncation.
أDeepSeek
Below is a self-contained test\_pricing.py using only the standard library's unittest. It imports the frozen pricing module and pins the documented behavior, including the boundary, rounding, shipping, coupon, and input-coercion rules you called out. Each test method states the business rule in its docstring.
python
\# test\_pricing.py
"""
Regression net for pricing.quote().
These tests document the CURRENT, frozen behavior of pricing.py.
They are intentionally written against the public quote() API only.
The module under test must not be modified to satisfy these tests.
Run with: python -m unittest test\_pricing.py
"""
import unittest
from decimal import Decimal
from pricing import quote
class TierDiscountBoundaryTests(unittest.TestCase):
  """Rules for the highest-matching, non-cumulative tier discount."""
  def test\_below\_500\_gets\_no\_tier\_discount(self):
  """499.99 is below the 500 threshold, so no tier discount applies."""
  result = quote("499.99")
  self.assertEqual(result\["discount"], Decimal("0"))
  def test\_500\_gets\_five\_percent\_tier(self):
  """500.00 reaches the 500 threshold, so the 5% tier applies to the whole subtotal."""
  result = quote("500.00")
  self.assertEqual(result\["discount"], Decimal("25.00"))
  def test\_just\_below\_2000\_keeps\_five\_percent\_tier(self):
  """1999.99 is still under 2000, so only the 5% tier applies (not 10%)."""
  result = quote("1999.99")
  # 5% of 1999.99
  self.assertEqual(result\["discount"], Decimal("1999.99") \* Decimal("0.05"))
  def test\_2000\_gets\_ten\_percent\_tier\_not\_ten\_plus\_five(self):
  """2000.00 must get the 10% tier only; tiers are not cumulative."""
  result = quote("2000.00")
  self.assertEqual(result\["discount"], Decimal("200.00"))
  # Explicitly rule out the buggy 10% + 5% = 300 outcome.
  self.assertNotEqual(result\["discount"], Decimal("300.00"))
  def test\_tier\_discount\_uses\_highest\_matching\_tier(self):
  """A very large subtotal still uses only the 10% tier, not both tiers."""
  result = quote("5000.00")
  self.assertEqual(result\["discount"], Decimal("500.00"))
class VatRoundingTests(unittest.TestCase):
  """VAT is 15% of the discounted amount, rounded half-up to 2dp."""
  def test\_vat\_half\_cent\_rounds\_up(self):
  """
  Pick a discounted amount whose 15% lands exactly on a half cent:
  0.90 \* 0.15 = 0.135 -> half-up to 0.14.
  Subtotal 0.90 has no tier and no coupon, so discounted == 0.90.
  """
  result = quote("0.90")
  self.assertEqual(result\["vat"], Decimal("0.14"))
  def test\_vat\_rounds\_half\_up\_on\_another\_half\_cent(self):
  """
  Another exact half-cent case: 0.50 \* 0.15 = 0.075 -> half-up to 0.08.
  This pins that ROUND\_HALF\_UP is used rather than banker's rounding.
  """
  result = quote("0.50")
  self.assertEqual(result\["vat"], Decimal("0.08"))
  def test\_vat\_is\_computed\_on\_discounted\_amount(self):
  """VAT applies after the tier discount, not to the raw subtotal."""
  # 500 - 5% = 475.00; 475.00 \* 0.15 = 71.25
  result = quote("500.00")
  self.assertEqual(result\["vat"], Decimal("71.25"))
  def test\_vat\_is\_zero\_when\_discounted\_is\_zero(self):
  """When the discounted amount clamps to 0, VAT must be 0.00."""
  result = quote("30", coupon\_code="FLAT50")
  self.assertEqual(result\["vat"], Decimal("0.00"))
class ShippingThresholdTests(unittest.TestCase):
  """Free shipping is decided on the DISCOUNTED amount >= 300."""
  def test\_free\_shipping\_when\_discounted\_meets\_threshold(self):
  """Discounted amount of exactly 300.00 earns free shipping."""
  result = quote("300.00")
  self.assertEqual(result\["shipping"], Decimal("0"))
  def test\_shipping\_charged\_when\_subtotal\_meets\_300\_but\_discount\_drops\_below(self):
  """
  Subtotal 320 with SAVE10 -> discounted 288, which is below 300,
  so shipping must be the flat 25 even though the raw subtotal >= 300.
  """
  result = quote("320", coupon\_code="SAVE10")
  self.assertEqual(result\["discount"], Decimal("32.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_shipping\_charged\_just\_below\_threshold(self):
  """Discounted amount of 299.99 is below 300, so flat shipping applies."""
  result = quote("299.99")
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_free\_shipping\_just\_above\_threshold(self):
  """Discounted amount of 300.01 is above 300, so shipping is free."""
  result = quote("300.01")
  self.assertEqual(result\["shipping"], Decimal("0"))
class CouponTests(unittest.TestCase):
  """Single-coupon behavior for percent and fixed coupons."""
  def test\_percent\_coupon\_adds\_to\_tier\_discount(self):
  """SAVE10 adds 10% of the subtotal on top of any tier discount."""
  # 500 tier discount = 25.00; SAVE10 = 50.00; total discount = 75.00
  result = quote("500.00", coupon\_code="SAVE10")
  self.assertEqual(result\["discount"], Decimal("75.00"))
  def test\_fixed\_coupon\_adds\_to\_tier\_discount(self):
  """FLAT50 adds a flat 50 on top of any tier discount."""
  # 500 tier discount = 25.00; FLAT50 = 50.00; total discount = 75.00
  result = quote("500.00", coupon\_code="FLAT50")
  self.assertEqual(result\["discount"], Decimal("75.00"))
  def test\_fixed\_coupon\_clamps\_discounted\_to\_zero(self):
  """
  FLAT50 on a subtotal of 30 -> discounted clamps to 0, VAT 0,
  shipping 25 (since 0 < 300), total 25.
  """
  result = quote("30", coupon\_code="FLAT50")
  self.assertEqual(result\["discount"], Decimal("50"))
  self.assertEqual(result\["vat"], Decimal("0.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25"))
  def test\_unknown\_coupon\_raises\_key\_error(self):
  """An unrecognized coupon code must raise KeyError (current contract)."""
  with self.assertRaises(KeyError):
  quote("100", coupon\_code="NOPE")
class InputValidationTests(unittest.TestCase):
  """Subtotal must be non-negative and is coerced via Decimal(str(...))."""
  def test\_negative\_subtotal\_raises\_value\_error(self):
  """A negative subtotal is invalid and must raise ValueError."""
  with self.assertRaises(ValueError):
  quote("-0.01")
  def test\_zero\_subtotal\_no\_coupon(self):
  """Zero subtotal: everything zero except flat shipping of 25."""
  result = quote("0")
  self.assertEqual(result\["subtotal"], Decimal("0"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("0.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25"))
  def test\_string\_input\_is\_accepted(self):
  """quote('100.10') accepts a string subtotal and preserves the value."""
  result = quote("100.10")
  self.assertEqual(result\["subtotal"], Decimal("100.10"))
  def test\_float\_input\_is\_accepted\_without\_crashing(self):
  """
  quote(100.10) must be accepted without crashing.
  Decimal(str(100.10)) == Decimal('100.1'), which is the documented
  coercion path. We use Decimal equality on the coerced value rather
  than comparing the float directly, because binary floats are not
  exact and Decimal(float) would expose representation noise.
  """
  result = quote(100.10)
  self.assertEqual(result\["subtotal"], Decimal("100.1"))
  # The returned dict must still contain Decimal values, not floats.
  self.assertIsInstance(result\["subtotal"], Decimal)
  self.assertIsInstance(result\["discount"], Decimal)
  self.assertIsInstance(result\["vat"], Decimal)
  self.assertIsInstance(result\["shipping"], Decimal)
  self.assertIsInstance(result\["total"], Decimal)
  def test\_float\_and\_string\_inputs\_agree\_after\_coercion(self):
  """
  The documented coercion path Decimal(str(x)) makes quote(100.10)
  and quote('100.10') produce the same subtotal.
  """
  from\_float = quote(100.10)\["subtotal"]
  from\_string = quote("100.10")\["subtotal"]
  self.assertEqual(from\_float, from\_string)
class TotalCompositionTests(unittest.TestCase):
  """Total is discounted + VAT + shipping, with all components consistent."""
  def test\_total\_composition\_no\_coupon(self):
  """A plain mid-range order composes total from its four components."""
  result = quote("100")
  self.assertEqual(result\["subtotal"], Decimal("100"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("15.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("140.00"))
  def test\_total\_composition\_with\_tier\_and\_free\_shipping(self):
  """A 10%-tier order above the discounted threshold gets free shipping."""
  # 2000 - 200 = 1800; VAT 270.00; shipping 0; total 2070.00
  result = quote("2000.00")
  self.assertEqual(result\["discount"], Decimal("200.00"))
  self.assertEqual(result\["vat"], Decimal("270.00"))
  self.assertEqual(result\["shipping"], Decimal("0"))
  self.assertEqual(result\["total"], Decimal("2070.00"))
  def test\_returned\_dict\_has\_exactly\_the\_documented\_keys(self):
  """The quote() contract exposes exactly these five keys."""
  result = quote("100")
  self.assertEqual(
  set(result.keys()),
  {"subtotal", "discount", "vat", "shipping", "total"},
  )
if \_\_name\_\_ == "\_\_main\_\_":
  unittest.main()
Key choices worth flagging:
Boundary pins use assertEqual, not assertAlmostEqual, because quote() returns Decimal and the documented contract is exact decimal arithmetic. assertAlmostEqual is only relevant when comparing floats; for the float-input case I compare the coerced Decimal value instead, which is the actual documented behavior (Decimal(str(subtotal))).
The half-cent VAT cases are computed from first principles in the docstrings (0.90 \* 0.15 = 0.135 → 0.14, 0.50 \* 0.15 = 0.075 → 0.08) so a future reader can verify the pin without re-deriving it.
The 2000 tier test includes a negative assertion (assertNotEqual(... Decimal("300.00"))) so the non-cumulative rule fails loudly if someone "fixes" it into stacking.
The shipping-on-discounted test asserts both the discount and the shipping, because the whole point is that 320 qualifies for free shipping on the raw subtotal but not on the discounted one.
The float test asserts the returned components are Decimal instances, guarding the "no float leakage into the money type" contract.
21 test methods, grouped into 6 focused TestCase classes so the regression net reads as a spec of the module rather than a wall of asserts.
دGemini
The standard-library test suite below covers all boundary conditions, mathematical edge cases, and error paths for pricing.py.
Save this code directly into test\_pricing.py in the same directory as pricing.py.
Python
\# test\_pricing.py
from decimal import Decimal
import unittest
from pricing import quote
class TestPricingQuote(unittest.TestCase):
  """Regression test suite for checkout quotation calculations in pricing.py."""
  # -------------------------------------------------------------------------
  # Subtotal Input Handling \& Edge Cases
  # -------------------------------------------------------------------------
  def test\_zero\_subtotal(self):
  """Zero subtotal results in 0 discount and VAT, with standard flat shipping applied."""
  result = quote(0)
  self.assertEqual(result\["subtotal"], Decimal("0"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("0.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("25.00"))
  def test\_negative\_subtotal\_raises\_value\_error(self):
  """Negative subtotal values must raise a ValueError."""
  with self.assertRaises(ValueError):
  quote("-0.01")
  def test\_string\_subtotal\_accepted(self):
  """String representation of exact decimal subtotal is parsed accurately."""
  result = quote("100.10")
  self.assertEqual(result\["subtotal"], Decimal("100.10"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("15.02")) # 100.10 \* 0.15 = 15.015 -> 15.02
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("140.12"))
  def test\_float\_subtotal\_accepted(self):
  """Float input is converted to string internally to avoid IEEE 754 precision issues."""
  # Note: str(100.10) in Python yields "100.1", which Decimal converts cleanly to Decimal('100.1').
  # We assert equality with Decimal since quote() converts float via str(subtotal).
  result = quote(100.10)
  self.assertEqual(result\["subtotal"], Decimal("100.1"))
  self.assertEqual(result\["discount"], Decimal("0"))
  self.assertEqual(result\["vat"], Decimal("15.02"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  self.assertEqual(result\["total"], Decimal("140.12"))
  # -------------------------------------------------------------------------
  # Tier Discount Boundaries
  # -------------------------------------------------------------------------
  def test\_tier\_5\_percent\_just\_below\_threshold(self):
  """Subtotal of 499.99 is below the 500 threshold and receives no tier discount."""
  result = quote("499.99")
  self.assertEqual(result\["discount"], Decimal("0"))
  def test\_tier\_5\_percent\_at\_threshold(self):
  """Subtotal of 500.00 hits the 5% tier threshold and gets a 5% discount."""
  result = quote("500.00")
  self.assertEqual(result\["discount"], Decimal("25.00")) # 500 \* 0.05
  def test\_tier\_10\_percent\_just\_below\_threshold(self):
  """Subtotal of 1999.99 is below the 2000 threshold and receives only the 5% tier discount."""
  result = quote("1999.99")
  self.assertEqual(result\["discount"], Decimal("99.9995")) # 1999.99 \* 0.05
  def test\_tier\_10\_percent\_at\_threshold\_not\_cumulative(self):
  """Subtotal of 2000.00 receives only the highest matching 10% tier discount, not 10% + 5%."""
  result = quote("2000.00")
  self.assertEqual(result\["discount"], Decimal("200.00")) # 2000 \* 0.10 (not 2000 \* 0.15)
  # -------------------------------------------------------------------------
  # Coupon Functionality \& Edge Cases
  # -------------------------------------------------------------------------
  def test\_percentage\_coupon\_without\_tier\_discount(self):
  """SAVE10 applies a 10% discount on subtotals below tier thresholds."""
  result = quote("100.00", coupon\_code="SAVE10")
  self.assertEqual(result\["discount"], Decimal("10.00"))
  def test\_fixed\_coupon\_without\_tier\_discount(self):
  """FLAT50 applies a fixed 50 SAR discount on subtotals below tier thresholds."""
  result = quote("100.00", coupon\_code="FLAT50")
  self.assertEqual(result\["discount"], Decimal("50.00"))
  def test\_coupon\_stacks\_with\_tier\_discount(self):
  """Coupons combine additively with tier discounts when both apply."""
  # Subtotal 500 gets 5% tier (25) + SAVE10 10% (50) = 75 discount
  result = quote("500.00", coupon\_code="SAVE10")
  self.assertEqual(result\["discount"], Decimal("75.00"))
  def test\_fixed\_coupon\_exceeds\_subtotal\_clamps\_discounted\_amount(self):
  """FLAT50 on a subtotal of 30 clamps discounted amount to 0, resulting in 0 VAT and standard shipping."""
  result = quote("30.00", coupon\_code="FLAT50")
  self.assertEqual(result\["subtotal"], Decimal("30.00"))
  self.assertEqual(result\["discount"], Decimal("50.00")) # Raw discount recorded
  self.assertEqual(result\["vat"], Decimal("0.00"))
  self.assertEqual(result\["shipping"], Decimal("25")) # 0 < 300
  self.assertEqual(result\["total"], Decimal("25.00"))
  def test\_unknown\_coupon\_code\_raises\_key\_error(self):
  """Passing an unrecognized coupon code raises a KeyError."""
  with self.assertRaises(KeyError):
  quote("100.00", coupon\_code="INVALID\_CODE")
  # -------------------------------------------------------------------------
  # Free Shipping Thresholds
  # -------------------------------------------------------------------------
  def test\_free\_shipping\_at\_discounted\_threshold(self):
  """Shipping is free when the discounted subtotal is exactly 300 SAR."""
  result = quote("300.00")
  self.assertEqual(result\["shipping"], Decimal("0"))
  def test\_shipping\_charged\_when\_discount\_pulls\_amount\_below\_300(self):
  """Subtotal of 320 with SAVE10 results in 288 discounted amount, triggering flat shipping of 25."""
  # Subtotal 320 - SAVE10 (32) = Discounted 288 (< 300)
  result = quote("320.00", coupon\_code="SAVE10")
  self.assertEqual(result\["discount"], Decimal("32.00"))
  self.assertEqual(result\["shipping"], Decimal("25"))
  def test\_free\_shipping\_retained\_when\_discounted\_amount\_above\_300(self):
  """Shipping remains free if the discounted amount stays at or above 300 SAR after coupons."""
  # Subtotal 400 - SAVE10 (40) = Discounted 360 (>= 300)
  result = quote("400.00", coupon\_code="SAVE10")
  self.assertEqual(result\["shipping"], Decimal("0"))
  # -------------------------------------------------------------------------
  # VAT Rounding Mechanics (15% ROUND\_HALF\_UP)
  # -------------------------------------------------------------------------
  def test\_vat\_rounding\_exact\_half\_cent\_rounds\_up(self):
  """VAT calculation rounds exact half-cent fractions up (ROUND\_HALF\_UP: 0.125 -> 0.13)."""
  # Subtotal 0.83 \* 0.15 = 0.1245 (not half cent)
  # Subtotal 0.83333... \* 0.15 = 0.125
  # 0.8333333333... is hard to express exactly, but subtotal 0.8333... isn't standard currency.
  # Clean exact half-cent calculation:
  # Discounted amount = 0.83333... -> Let's use subtotal 0.83 + no coupon = 0.83 \* 0.15 = 0.1245 -> 0.12
  # Let's use discounted amount of 0.8333 -> 0.8333 \* 0.15 = 0.124995
  # To get exact half cent (e.g. 0.005, 0.015, 0.025... ending in .xxx5):
  # Discounted 0.8333333... \* 0.15 = 0.125
  # Exact fraction: 0.83 \* 0.15 = 0.1245 -> rounds to 0.12
  # Exact 0.125 VAT occurs when discounted amount = 0.125 / 0.15 = 0.833333...
  # Let's pick exact decimal subtotal 1.83: 1.83 \* 0.15 = 0.2745 -> rounds to 0.27
  # Subtotal 0.833... -> using string subtotal "0.8333333333333333333333333333":
  # Better: subtotal "0.83333333333333333333" \* 0.15 = 0.124999...
  # Simple exact fraction: Subtotal "0.03" \* 0.15 = 0.0045 -> 0.00
  # Subtotal "0.17" \* 0.15 = 0.0255 -> 0.03
  # Subtotal "0.83333333333" -> Let's test 0.8333333333333333333333333333:
  # For discounted = Decimal("0.8333333333333333333333333333"), VAT = 0.125 -> 0.13
  # Standard decimal exact half-cent check:
  # Subtotal 0.8333333333333333333333333333 \* 0.15 = Decimal('0.12500000000000000000000000000') -> 0.13
  subtotal = Decimal("0.8333333333333333333333333333")
  result = quote(subtotal)
  self.assertEqual(result\["vat"], Decimal("0.13"))
  def test\_vat\_rounding\_down\_below\_half\_cent(self):
  """VAT calculation rounds down when fraction is strictly less than half a cent."""
  # Discounted 0.83 \* 0.15 = 0.1245 -> 0.12
  result = quote("0.83")
  self.assertEqual(result\["vat"], Decimal("0.12"))
if \_\_name\_\_ == "\_\_main\_\_":
  unittest.main()
To run the test suite:
Bash
python -m unittest test\_pricing.py