@1aboveio/skills 1.0.8 → 1.0.10

package/skills/risk-compliance/tld-detection/tests/test_detect_streams.py

@@ -1,520 +0,0 @@
-import csv
-from copy import deepcopy
-import importlib.util
-import json
-from pathlib import Path
-import random
-import subprocess
-import sys
-import tempfile
-from types import SimpleNamespace
-import unittest
-
-
-sys.dont_write_bytecode = True
-SCRIPT = Path(__file__).parents[1] / "scripts" / "detect_streams.py"
-SPEC = importlib.util.spec_from_file_location("detect_streams", SCRIPT)
-MODULE = importlib.util.module_from_spec(SPEC)
-assert SPEC.loader is not None
-sys.modules[SPEC.name] = MODULE
-SPEC.loader.exec_module(MODULE)
-
-DAYS = [f"2026-08-{d:02d}" for d in range(1, 21)]
-FIELDS = ["amount", "currency", "ts", "descriptor", "country", "response", "account", "card_type", "avs", "auth"]
-
-
-def rates_cache() -> dict:
-    """USD base; EUR drifts 1.15 -> 1.17, AUD 0.70 -> 0.72 over the window (quoted as units per USD)."""
-    rates = {}
-    for i, day in enumerate(DAYS):
-        eur = 1.15 + 0.001 * i
-        aud = 0.70 + 0.001 * i
-        rates[day] = {"EUR": 1 / eur, "AUD": 1 / aud, "GBP": 1 / 1.34, "JPY": 147.0}
-    return {"base": "USD", "rates": rates}
-
-
-def synthetic_rows() -> list[dict]:
-    rng = random.Random(3)
-    rates = rates_cache()["rates"]
-    rows = []
-    acc = 0
-
-    def row(amount, day, ctry, resp="A001", account=None, card="Debit", avs="Postal code not checked", auth="None", desc="HLP*shop", hour=None):
-        nonlocal acc
-        acc += 1
-        h = hour if hour is not None else rng.randint(0, 23)
-        return {"amount": f"{amount:.2f}", "currency": "USD", "ts": f"{day} {h:02d}:{rng.randint(0, 59):02d}:{rng.randint(0, 59):02d}",
-                "descriptor": desc, "country": ctry, "response": resp, "account": account or f"4{acc:05d}******{acc % 9999:04d}",
-                "card_type": card, "avs": avs, "auth": auth}
-
-    # Euro-wallet players (Germany): presets 10/20/50 at live rate with 0-1% markup, some retries
-    for _ in range(400):
-        day = rng.choice(DAYS)
-        preset = rng.choice([10, 10, 10, 20, 20, 50])
-        usd = preset / rates[day]["EUR"] * (1 + rng.uniform(0, 0.01))
-        rows.append(row(usd, day, "Germany", resp=rng.choice(["A001", "A001", "D102"])))
-    # Australian players: A$30 / A$50 live
-    for _ in range(300):
-        day = rng.choice(DAYS)
-        preset = rng.choice([30, 30, 50])
-        usd = preset / rates[day]["AUD"] * (1 + rng.uniform(0, 0.01))
-        rows.append(row(usd, day, "Australia"))
-    # US cards: euro presets 24/48 at ONE frozen rate for six days, one attempt per card, lunchtime
-    frozen = 1.1679
-    for _ in range(300):
-        day = rng.choice(DAYS[10:16])
-        preset = rng.choice([24, 24, 48])
-        rows.append(row(round(preset * frozen, 2), day, "United States of America", resp=rng.choice(["A001", "D102"]), avs="Postal code matched", hour=rng.choice([16, 17, 18])))
-    # Canada: retail list x 1.06 with US-style billing address
-    for _ in range(250):
-        day = rng.choice(DAYS)
-        price = rng.choice([79.99, 84.99, 89.99, 134.99, 59.95, 239.98, 25.98, 63.98, 137.99, 199.99])
-        rows.append(row(round(price * 1.06, 2), day, "Canada", avs="Postal code matched", card="Credit"))
-    # Japan: off-menu typed amounts
-    for _ in range(200):
-        day = rng.choice(DAYS)
-        rows.append(row(rng.uniform(15, 400), day, "Japan"))
-    return rows
-
-
-class RatesTest(unittest.TestCase):
-    def test_lookup_uses_query_date_and_bounded_prior_day_carry(self):
-        cache = {"base": "USD", "rates": {
-            "2026-08-01": {"EUR": 0.8},
-            "2026-08-04": {"EUR": 0.82},
-        }}
-        cases = [
-            ("before_cache", "2026-07-31", 7, None, {}),
-            ("exact_first", "2026-08-01", 7, 0.8, {}),
-            ("gap", "2026-08-03", 7, 0.8, {"EUR": 1}),
-            ("exact_last", "2026-08-04", 7, 0.82, {}),
-            ("after_cache", "2026-08-05", 7, 0.82, {"EUR": 1}),
-            ("max_carry", "2026-08-11", 7, 0.82, {"EUR": 1}),
-            ("beyond_carry", "2026-08-12", 7, None, {}),
-            ("far_after_cache", "2027-08-04", 7, None, {}),
-            ("configured_limit", "2026-08-06", 1, None, {}),
-            ("no_carry_missing", "2026-08-05", 0, None, {}),
-            ("no_carry_exact", "2026-08-04", 0, 0.82, {}),
-        ]
-        for name, day, carry, expected, carried in cases:
-            with self.subTest(name=name):
-                rates = MODULE.Rates(cache, carry=carry)
-                self.assertEqual(rates.rate(day, "EUR"), expected)
-                self.assertEqual(dict(rates.carried), carried)
-
-    def test_missing_currency_searches_prior_quotes_not_just_cache_dates(self):
-        rates = MODULE.Rates({"base": "USD", "rates": {
-            "2026-08-01": {"EUR": 0.8},
-            "2026-08-08": {"GBP": 0.6},
-        }}, carry=7)
-        self.assertEqual(rates.rate("2026-08-08", "EUR"), 0.8)
-        self.assertIsNone(rates.rate("2026-08-09", "EUR"))
-        self.assertIsNone(rates.rate("2026-08-08", "CHF"))
-        self.assertEqual(dict(rates.carried), {"EUR": 1})
-
-    def test_identity_and_usd_pegs_do_not_require_dated_quotes(self):
-        rates = MODULE.Rates({"base": "USD", "rates": {}}, carry=0)
-        self.assertEqual(rates.rate("2026-08-01", "USD"), 1.0)
-        self.assertEqual(rates.rate("2026-08-01", "SAR"), 3.75)
-        self.assertIsNone(rates.rate("2026-08-01", "EUR"))
-        self.assertEqual(dict(rates.carried), {})
-
-
-class RateConsistencyTest(unittest.TestCase):
-    def setUp(self):
-        self.opt = SimpleNamespace(peak_tol=0.012, frozen_days=4,
-                                   frozen_min_per_day=3, frozen_market_move=0.001)
-
-    def consistency(self, quotes, charges, wallet="EUR", center=24):
-        cache = {"base": "USD", "rates": dict(zip(DAYS, quotes))}
-        rows = [
-            {"day": day, "currency": currency, "amount": amount}
-            for day, daily_charges in zip(DAYS, charges)
-            for currency, amount, count in daily_charges
-            for _ in range(count)
-        ]
-        return MODULE.rate_consistency(rows, MODULE.Rates(cache), wallet,
-                                       [(center, len(rows))], self.opt)
-
-    def test_non_usd_source_freezes_when_cross_rate_moves_but_wallet_quote_does_not(self):
-        quotes = [{"EUR": 0.8, "GBP": gbp} for gbp in (0.6, 0.6012, 0.6024, 0.6036)]
-        result = self.consistency(quotes, [[("GBP", 18, 3)]] * 4)
-        self.assertEqual(result["frozen_attempts"], 12)
-        self.assertEqual(result["tested_attempts"], 12)
-        self.assertEqual(result["frozen_peaks"], 1)
-        self.assertTrue(result["detail"][0]["frozen"])
-        # EUR per GBP changes from 4/3 to 2000/1509, about 0.5964%.
-        self.assertEqual(result["detail"][0]["market_move"], 0.006)
-
-    def test_matching_source_and_wallet_is_not_frozen_by_usd_quote_movement(self):
-        quotes = [{"EUR": eur} for eur in (0.8, 0.804, 0.808, 0.812)]
-        result = self.consistency(quotes, [[("EUR", 24, 3)]] * 4)
-        self.assertEqual(result["frozen_attempts"], 0)
-        self.assertEqual(result["tested_attempts"], 12)
-        self.assertEqual(result["live_peaks"], 1)
-        self.assertFalse(result["detail"][0]["frozen"])
-        self.assertEqual(result["detail"][0]["market_move"], 0.0)
-
-    def test_parallel_source_and_wallet_quotes_have_no_cross_rate_movement(self):
-        quotes = [{"EUR": eur, "GBP": gbp} for eur, gbp in
-                  ((0.8, 0.6), (0.804, 0.603), (0.808, 0.606), (0.812, 0.609))]
-        result = self.consistency(quotes, [[("GBP", 18, 3)]] * 4)
-        self.assertEqual(result["frozen_attempts"], 0)
-        self.assertEqual(result["tested_attempts"], 12)
-        self.assertFalse(result["detail"][0]["frozen"])
-        self.assertEqual(result["detail"][0]["market_move"], 0.0)
-
-    def test_live_non_usd_source_tracks_cross_rate(self):
-        quotes = [{"EUR": 0.8, "GBP": gbp} for gbp in (0.6, 0.6012, 0.6024, 0.6036)]
-        charges = [[("GBP", amount, 3)] for amount in (18, 18.036, 18.072, 18.108)]
-        result = self.consistency(quotes, charges)
-        self.assertEqual(result["frozen_attempts"], 0)
-        self.assertEqual(result["tested_attempts"], 12)
-        self.assertFalse(result["detail"][0]["frozen"])
-        self.assertEqual(result["detail"][0]["market_move"], 0.006)
-
-    def test_base_currency_wallet_can_freeze_against_non_base_source(self):
-        quotes = [{"EUR": eur} for eur in (0.8, 0.8016, 0.8032, 0.8048)]
-        result = self.consistency(quotes, [[("EUR", 24, 3)]] * 4, wallet="USD", center=30)
-        self.assertEqual(result["frozen_attempts"], 12)
-        self.assertEqual(result["tested_attempts"], 12)
-        self.assertTrue(result["detail"][0]["frozen"])
-        self.assertEqual(result["detail"][0]["market_move"], 0.006)
-
-    def test_mixed_sources_keep_modes_movements_and_attempts_separate(self):
-        quotes = [{"EUR": 0.8, "GBP": gbp} for gbp in (0.6, 0.6012, 0.6024, 0.6036)]
-        result = self.consistency(quotes, [[("EUR", 24, 6), ("GBP", 18, 3)]] * 4)
-        self.assertEqual(result["tested_attempts"], 36)
-        self.assertEqual(result["frozen_attempts"], 12)
-        self.assertEqual(result["frozen_peaks"], 1)
-        self.assertEqual(result["live_peaks"], 1)
-        self.assertEqual(len(result["detail"]), 2)
-        details = {d["source_currency"]: d for d in result["detail"]}
-        self.assertFalse(details["EUR"]["frozen"])
-        self.assertEqual(details["EUR"]["modal_amounts"], [24])
-        self.assertEqual(details["EUR"]["market_move"], 0.0)
-        self.assertEqual(details["EUR"]["attempts"], 24)
-        self.assertTrue(details["GBP"]["frozen"])
-        self.assertEqual(details["GBP"]["modal_amounts"], [18])
-        self.assertEqual(details["GBP"]["market_move"], 0.006)
-        self.assertEqual(details["GBP"]["attempts"], 12)
-
-    def test_mixed_sources_cannot_pool_days_or_daily_minimum_for_testing(self):
-        quotes = [{"EUR": 0.8, "GBP": 0.6}] * 4
-        cases = [
-            [[("EUR", 24, 2), ("GBP", 18, 2)]] * 4,
-            [[("EUR", 24, 3)]] * 2 + [[("GBP", 18, 3)]] * 2,
-        ]
-        for charges in cases:
-            with self.subTest(charges=charges):
-                result = self.consistency(quotes, charges)
-                self.assertEqual(result["tested_attempts"], 0)
-                self.assertEqual(result["frozen_attempts"], 0)
-                self.assertEqual(result["detail"], [])
-
-
-class PaymentPatternPresentationTest(unittest.TestCase):
-    def run_cli(self, rows, candidates=("EUR",), cache=None, extra=()):
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            csv_path = root / "auth.csv"
-            with csv_path.open("w", newline="") as fh:
-                writer = csv.DictWriter(fh, fieldnames=FIELDS)
-                writer.writeheader()
-                writer.writerows(rows)
-            rates_path = root / "rates.json"
-            rates_path.write_text(json.dumps(cache or rates_cache()))
-            markdown_path = root / "streams.md"
-            cmd = [sys.executable, str(SCRIPT), str(csv_path), "--rates", str(rates_path),
-                   "--amount-column", "amount", "--currency-column", "currency", "--date-column", "ts",
-                   "--descriptor-column", "descriptor", "--bin-country-column", "country",
-                   "--candidate-currencies", *candidates, "--markdown", str(markdown_path), *extra]
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            self.assertEqual(result.returncode, 0, result.stderr)
-            report = json.loads(result.stdout)
-            markdown = markdown_path.read_text()
-        before = deepcopy(report)
-        self.assertEqual(MODULE.to_markdown(report), markdown)
-        self.assertEqual(report, before)
-        descriptor = report["descriptors"][0]
-        self.assertEqual(descriptor["attempts"], len(rows))
-        self.assertEqual(sum(s["attempts"] for s in descriptor["streams"]), len(rows))
-        for stream in descriptor["streams"] + [s for g in descriptor["groups"] for s in g["substreams"]]:
-            p = stream["presentation"]
-            self.assertEqual(sum(p["pattern_counts"].values()), stream["attempts"])
-            self.assertEqual(sum(p["charge_currencies"].values()), stream["attempts"])
-            self.assertEqual(sum(part["attempts"] for part in p["by_charge_currency"]), stream["attempts"])
-        return descriptor, markdown
-
-    def rows(self, charges, country="United Kingdom"):
-        return [{"amount": f"{amount:.2f}", "currency": currency, "ts": f"{day} 12:00:00",
-                 "descriptor": "pattern-fixture", "country": country}
-                for day, daily in zip(DAYS, charges)
-                for currency, amount, count in daily
-                for _ in range(count)]
-
-    def markdown_row(self, markdown, raw, country=None):
-        prefix = f"| {raw} |" if country is None else f"| {country} |"
-        matches = [line for line in markdown.splitlines() if line.startswith(prefix) and f"| {raw} |" in line]
-        self.assertEqual(len(matches), 1, matches)
-        return [cell.strip() for cell in matches[0].split("|")[1:-1]]
-
-    def test_direct_usd_and_eur_are_based_on_charge_currency_not_legal_tender(self):
-        for currency in ("USD", "EUR"):
-            with self.subTest(currency=currency):
-                rows = self.rows([[(currency, 24, 20)]] * 4)
-                descriptor, markdown = self.run_cli(rows, candidates=(currency,))
-                group = descriptor["groups"][0]
-                stream = group["substreams"][0]
-                self.assertEqual(group["legal_tender"], "GBP")
-                self.assertEqual(stream["stream"], f"{currency} menu-12 live")
-                self.assertEqual(stream["attempts"], 80)
-                p = stream["presentation"]
-                self.assertEqual(p["pattern_counts"], {"Direct top-up pattern": 80})
-                self.assertEqual(p["charge_currencies"], {currency: 80})
-                self.assertEqual(p["inferred_top_up_currencies"], [currency])
-                self.assertEqual(p["pricing_characteristics"], ["fixed amount"])
-                self.assertEqual(p["by_charge_currency"][0]["frozen_fx_attempts"], 0)
-                cells = self.markdown_row(markdown, stream["stream"], group["country"])
-                self.assertIn(f"Direct top-up pattern: 80 [{currency}: 80]", cells[3])
-                self.assertEqual(cells[4:7], [currency, f"{currency}: 80", "fixed amount"])
-                self.assertNotIn("frozen FX", cells[3])
-                self.assertNotIn("floating", cells[3])
-
-    def test_fx_currency_and_no_frozen_qualifier_without_positive_cross_rate_test(self):
-        rows = self.rows([[('USD', 24 / rates_cache()["rates"][day]["EUR"], 20)] for day in DAYS[:4]])
-        descriptor, markdown = self.run_cli(rows)
-        stream = descriptor["groups"][0]["substreams"][0]
-        self.assertEqual(stream["stream"], "EUR menu-12 live")
-        self.assertEqual(stream["presentation"]["pattern_counts"], {"FX-converted top-up pattern": 80})
-        self.assertEqual(stream["presentation"]["charge_currencies"], {"USD": 80})
-        self.assertEqual(stream["presentation"]["pricing_characteristics"], [])
-        cells = self.markdown_row(markdown, stream["stream"])
-        self.assertIn("FX-converted top-up pattern: 80 [USD: 80]", cells[1])
-        self.assertEqual(cells[2:4], ["EUR", "USD: 80"])
-        self.assertEqual(cells[4], "n/a")
-        self.assertNotIn("frozen FX", cells[1])
-        self.assertNotIn("floating", cells[1])
-
-    def test_repetition_without_cross_rate_tests_has_no_frozen_qualifier(self):
-        charge = 24 / rates_cache()["rates"][DAYS[0]]["EUR"]
-        rows = self.rows([[('USD', charge, 80)]])
-        descriptor, markdown = self.run_cli(rows)
-        stream = descriptor["groups"][0]["substreams"][0]
-        self.assertEqual(stream["stream"], "EUR menu-12 live")
-        self.assertEqual(stream["rate_consistency"]["tested_attempts"], 0)
-        self.assertEqual(stream["rate_consistency"]["detail"], [])
-        self.assertEqual(stream["presentation"]["by_charge_currency"][0]["frozen_fx_attempts"], 0)
-        cells = self.markdown_row(markdown, stream["stream"])
-        self.assertIn("FX-converted top-up pattern: 80 [USD: 80]", cells[1])
-        self.assertEqual(cells[4], "n/a")
-        self.assertNotIn("frozen", cells[1])
-        self.assertNotIn("floating", cells[1])
-
-    def test_mixed_sources_show_both_types_and_only_tested_source_is_frozen(self):
-        cache = {"base": "USD", "rates": {day: {"EUR": 0.8, "GBP": 0.6 + i * 0.0012}
-                                             for i, day in enumerate(DAYS[:4])}}
-        rows = self.rows([[('EUR', 24, 12), ('GBP', 18, 8)]] * 4)
-        descriptor, markdown = self.run_cli(rows, cache=cache)
-        stream = descriptor["groups"][0]["substreams"][0]
-        self.assertEqual(stream["stream"], "EUR menu-12 live")
-        self.assertEqual(len(descriptor["streams"]), 1)
-        self.assertEqual(len(descriptor["groups"][0]["substreams"]), 1)
-        p = stream["presentation"]
-        self.assertEqual(p["pattern_counts"], {"Direct top-up pattern": 48, "FX-converted top-up pattern": 32})
-        self.assertEqual(p["charge_currencies"], {"EUR": 48, "GBP": 32})
-        parts = {part["charge_currency"]: part for part in p["by_charge_currency"]}
-        self.assertEqual(parts["EUR"]["frozen_fx_attempts"], 0)
-        self.assertEqual(parts["GBP"]["frozen_fx_attempts"], 32)
-        self.assertEqual(parts["EUR"]["inferred_top_up_currency"], "EUR")
-        self.assertEqual(parts["GBP"]["inferred_top_up_currency"], "EUR")
-        cells = self.markdown_row(markdown, stream["stream"], "United Kingdom")
-        self.assertIn("Direct top-up pattern: 48 [EUR: 48]", cells[3])
-        self.assertIn("FX-converted top-up pattern: 32 [GBP: 32 (32 frozen FX tested attempts)]", cells[3])
-        self.assertEqual(cells[4:6], ["EUR", "EUR: 48, GBP: 32"])
-        self.assertEqual(descriptor["streams"][0]["presentation"], p)
-
-    def test_summary_aggregates_same_raw_stream_without_splitting_payment_patterns(self):
-        direct = self.rows([[('EUR', 24, 20)]] * 4, country="Germany")
-        fx = self.rows([[('USD', 24 / rates_cache()["rates"][day]["EUR"], 20)] for day in DAYS[:4]])
-        descriptor, markdown = self.run_cli(direct + fx)
-        self.assertEqual(len(descriptor["groups"]), 2)
-        self.assertEqual(len(descriptor["streams"]), 1)
-        stream = descriptor["streams"][0]
-        self.assertEqual(stream["stream"], "EUR menu-12 live")
-        self.assertEqual(stream["attempts"], 160)
-        self.assertEqual(stream["share_of_descriptor"], 1.0)
-        self.assertEqual(stream["presentation"]["pattern_counts"], {"Direct top-up pattern": 80, "FX-converted top-up pattern": 80})
-        self.assertEqual(stream["presentation"]["charge_currencies"], {"EUR": 80, "USD": 80})
-        cells = self.markdown_row(markdown, stream["stream"])
-        self.assertIn("Direct top-up pattern: 80 [EUR: 80]", cells[1])
-        self.assertIn("FX-converted top-up pattern: 80 [USD: 80]", cells[1])
-
-    def test_summary_detects_fixed_charges_across_country_dates(self):
-        germany = self.rows([[('EUR', 24, 80)]], country="Germany")
-        uk = self.rows([[], [('EUR', 24, 80)]], country="United Kingdom")
-        descriptor, markdown = self.run_cli(germany + uk, candidates=("EUR",))
-        self.assertEqual(len(descriptor["streams"]), 1)
-        summary = descriptor["streams"][0]
-        self.assertEqual(summary["attempts"], 160)
-        self.assertEqual(summary["presentation"]["pattern_counts"], {"Direct top-up pattern": 160})
-        self.assertEqual(summary["presentation"]["pricing_characteristics"], ["fixed amount"])
-        for group in descriptor["groups"]:
-            self.assertEqual(group["substreams"][0]["presentation"]["pricing_characteristics"], [])
-        self.assertEqual(self.markdown_row(markdown, summary["stream"])[4], "fixed amount")
-
-    def test_menu_none_is_other_repeated_amount_not_inferred_top_up(self):
-        rows = self.rows([[('EUR', 17.37, 20)]] * 4, country="UNKNOWN")
-        descriptor, markdown = self.run_cli(rows)
-        stream = descriptor["groups"][0]["substreams"][0]
-        self.assertEqual(stream["stream"], "EUR menu-none live")
-        self.assertEqual(stream["wallet"], "EUR")
-        p = stream["presentation"]
-        self.assertEqual(p["pattern_counts"], {"Other pattern": 80})
-        self.assertEqual(p["inferred_top_up_currencies"], [])
-        self.assertIsNone(p["by_charge_currency"][0]["inferred_top_up_currency"])
-        cells = self.markdown_row(markdown, stream["stream"], "UNKNOWN")
-        self.assertIn("Other pattern: 80 [EUR: 80]", cells[3])
-        self.assertIn("unidentified repeated-amount pattern", cells[3])
-        self.assertEqual(cells[4:7], ["n/a", "EUR: 80", "fixed amount"])
-
-    def test_off_menu_and_small_groups_render_other_with_real_charge_currencies(self):
-        for count, extra, raw in ((20, ("--max-substreams", "0"), "off-menu"), (2, (), "small groups")):
-            with self.subTest(raw=raw):
-                rows = self.rows([[('EUR', 24, count), ('USD', 30, count)]] * 4)
-                descriptor, markdown = self.run_cli(rows, extra=extra)
-                stream = descriptor["streams"][0]
-                self.assertEqual(stream["stream"], raw)
-                self.assertEqual(stream["presentation"]["pattern_counts"], {"Other pattern": len(rows)})
-                self.assertEqual(stream["presentation"]["inferred_top_up_currencies"], [])
-                self.assertEqual(stream["presentation"]["charge_currencies"], {"EUR": count * 4, "USD": count * 4})
-                cells = self.markdown_row(markdown, raw)
-                self.assertIn(f"Other pattern: {len(rows)}", cells[1])
-                self.assertEqual(cells[2], "n/a")
-                self.assertEqual(cells[3], f"EUR: {count * 4}, USD: {count * 4}")
-                self.assertNotIn("top-up pattern", cells[1])
-
-    def test_retail_renders_ecommerce_without_tax_fee_or_wallet_claim(self):
-        rows = [r for r in synthetic_rows() if r["country"] == "Canada"]
-        descriptor, markdown = self.run_cli(rows)
-        stream = descriptor["groups"][0]["substreams"][0]
-        self.assertTrue(stream["stream"].startswith("retail x"))
-        self.assertAlmostEqual(stream["retail"]["constant"], 1.06, places=3)
-        p = stream["presentation"]
-        self.assertEqual(p["pattern_counts"], {"E-commerce pattern": stream["attempts"]})
-        self.assertEqual(p["inferred_top_up_currencies"], [])
-        self.assertEqual(p["charge_currencies"], {"USD": stream["attempts"]})
-        cells = self.markdown_row(markdown, stream["stream"], "Canada")
-        self.assertIn(f"E-commerce pattern: {stream['attempts']} [USD: {stream['attempts']}]", cells[3])
-        self.assertEqual(cells[4], "n/a")
-        self.assertNotIn("tax", markdown.lower())
-        self.assertNotIn("fee", markdown.lower())
-
-
-class DetectStreamsTest(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.tmp = tempfile.TemporaryDirectory()
-        root = Path(cls.tmp.name)
-        cls.csv = root / "auth.csv"
-        with cls.csv.open("w", newline="") as fh:
-            w = csv.DictWriter(fh, fieldnames=FIELDS)
-            w.writeheader()
-            w.writerows(synthetic_rows())
-        cls.rates = root / "rates.json"
-        cls.rates.write_text(json.dumps(rates_cache()))
-        cls.out = root / "streams.json"
-        cmd = [sys.executable, str(SCRIPT), str(cls.csv), "--rates", str(cls.rates), "--amount-column", "amount", "--currency-column", "currency",
-               "--date-column", "ts", "--descriptor-column", "descriptor", "--bin-country-column", "country", "--response-column", "response",
-               "--account-column", "account", "--card-type-column", "card_type", "--avs-column", "avs", "--auth-column", "auth",
-               "--output", str(cls.out), "--markdown", str(root / "streams.md")]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        assert result.returncode == 0, result.stderr
-        cls.report = json.loads(cls.out.read_text())
-        cls.groups = {g["country"]: g for g in cls.report["descriptors"][0]["groups"]}
-
-    @classmethod
-    def main_sub(cls, country):
-        return max(cls.groups[country]["substreams"], key=lambda s: s["attempts"])
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.tmp.cleanup()
-
-    def test_euro_wallet_inferred_for_germany_with_10_scheme_live(self):
-        g = self.main_sub("Germany")
-        self.assertEqual(g["wallet"], "EUR")
-        self.assertEqual(g["scheme"], "10")
-        self.assertFalse(g["frozen"])
-        peaks = [c for c, _ in g["peaks"][:3]]
-        self.assertTrue(all(any(abs(c - m) <= 0.012 * m for m in (10, 20, 50)) for c in peaks), peaks)
-
-    def test_aud_wallet_inferred_for_australia(self):
-        g = self.main_sub("Australia")
-        self.assertEqual(g["wallet"], "AUD")
-        self.assertTrue(any(abs(c - 30) <= 0.4 for c, _ in g["peaks"]))
-
-    def test_us_cards_on_euro_menu_are_flagged_frozen(self):
-        g = self.main_sub("United States of America")
-        self.assertEqual(g["wallet"], "EUR")
-        self.assertEqual(g["scheme"], "12")
-        self.assertTrue(g["frozen"], g["rate_consistency"])
-        self.assertIn("frozen", g["stream"])
-        self.assertLess(g["behaviour"]["repeat_card_share"], 0.05)
-
-    def test_retail_constant_detected_for_canada(self):
-        g = self.main_sub("Canada")
-        self.assertTrue(g["stream"].startswith("retail"), g["stream"])
-        self.assertAlmostEqual(g["retail"]["constant"], 1.06, places=3)
-
-    def test_japan_is_off_menu(self):
-        self.assertEqual(self.main_sub("Japan")["stream"], "off-menu")
-
-    def test_streams_summarised_per_descriptor(self):
-        labels = {s["stream"] for s in self.report["descriptors"][0]["streams"]}
-        self.assertTrue(any(l.startswith("EUR menu-10 live") for l in labels), labels)
-        self.assertTrue(any(l.startswith("EUR menu-12 frozen") for l in labels), labels)
-        self.assertTrue(any(l.startswith("retail") for l in labels), labels)
-
-    def test_same_currency_charges_produce_live_stream_through_cli(self):
-        rows = [
-            {"amount": "24.00", "currency": "EUR", "ts": f"{day} 12:00:00",
-             "descriptor": "EUR-only", "country": "Germany"}
-            for day in DAYS[:4]
-            for _ in range(20)
-        ]
-        with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
-            csv_path = root / "auth.csv"
-            with csv_path.open("w", newline="") as fh:
-                writer = csv.DictWriter(fh, fieldnames=FIELDS)
-                writer.writeheader()
-                writer.writerows(rows)
-            rates_path = root / "rates.json"
-            rates_path.write_text(json.dumps(rates_cache()))
-            cmd = [sys.executable, str(SCRIPT), str(csv_path), "--rates", str(rates_path),
-                   "--amount-column", "amount", "--currency-column", "currency", "--date-column", "ts",
-                   "--descriptor-column", "descriptor", "--bin-country-column", "country",
-                   "--candidate-currencies", "EUR"]
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            self.assertEqual(result.returncode, 0, result.stderr)
-            report = json.loads(result.stdout)
-        descriptor = report["descriptors"][0]
-        self.assertEqual(descriptor["streams"][0]["stream"], "EUR menu-12 live")
-        stream = descriptor["groups"][0]["substreams"][0]
-        self.assertEqual(stream["attempts"], len(rows))
-        self.assertFalse(stream["frozen"])
-        self.assertEqual(stream["rate_consistency"]["tested_attempts"], len(rows))
-        self.assertEqual(stream["rate_consistency"]["frozen_attempts"], 0)
-        self.assertEqual(stream["rate_consistency"]["detail"][0]["market_move"], 0.0)
-
-    def test_peaks_disappear_under_jitter_control(self):
-        vals = [10.0] * 50 + [20.0] * 30
-        cov, _ = MODULE.coverage(vals, 0.012, 0.02, 10)
-        self.assertGreater(cov, 0.99)
-        ctrl = MODULE.coverage_against(MODULE.jitter(vals, random.Random(1), 0.02, 0.05), [10.0, 20.0], 0.012)
-        self.assertLess(ctrl, 0.05)
-
-
-if __name__ == "__main__":
-    unittest.main()