@1aboveio/skills 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,520 @@
+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()