xiaobai-review/tests/test_realtime_dashboard.py

from __future__ import annotations

import unittest
from datetime import datetime, timedelta, timezone

from backend.data.providers.tushare_client import TushareClient
from backend.data.providers.tushare_helpers import calendar_is_open
from backend.data.providers.tushare_transport import TushareError
from backend.data.realtime import (
    RealtimeAggregateError,
    _normalize_eastmoney_quote,
    _parse_tencent_stock_quote,
)


class FakeRealtimeClient(TushareClient):
    def query(self, api_name, params=None, fields=""):
        params = params or {}
        if api_name == "trade_cal":
            return [
                {
                    "cal_date": "20260720",
                    "is_open": 1,
                    "pretrade_date": "20260717",
                }
            ]
        if api_name == "stock_basic":
            return [
                {"ts_code": "000001.SZ", "name": "甲", "industry": "银行"},
                {"ts_code": "000002.SZ", "name": "乙", "industry": "地产"},
                {"ts_code": "000003.SZ", "name": "丙", "industry": "元器件"},
            ]
        if api_name == "stk_limit":
            return [
                {"ts_code": "000001.SZ", "up_limit": 11.0, "down_limit": 9.0},
                {"ts_code": "000002.SZ", "up_limit": 22.0, "down_limit": 18.0},
                {"ts_code": "000003.SZ", "up_limit": 33.0, "down_limit": 27.0},
            ]
        if api_name == "daily_basic":
            requested_code = str(params.get("ts_code") or "")
            rows = [
                {"ts_code": "000001.SZ", "trade_date": "20260717", "float_share": 1000},
                {"ts_code": "000002.SZ", "trade_date": "20260717", "float_share": 2000},
                {"ts_code": "000003.SZ", "trade_date": "20260717", "float_share": 3000},
            ]
            return [row for row in rows if not requested_code or row["ts_code"] == requested_code]
        if api_name == "daily":
            return [
                {"ts_code": params.get("ts_code"), "trade_date": "20260713", "vol": 1000, "amount": 1},
                {"ts_code": params.get("ts_code"), "trade_date": "20260714", "vol": 1000, "amount": 1},
                {"ts_code": params.get("ts_code"), "trade_date": "20260715", "vol": 1000, "amount": 1},
                {"ts_code": params.get("ts_code"), "trade_date": "20260716", "vol": 1000, "amount": 1},
                {"ts_code": params.get("ts_code"), "trade_date": "20260717", "vol": 1000, "amount": 1},
            ]
        if api_name == "limit_list_d":
            return [
                {
                    "ts_code": "000001.SZ",
                    "name": "甲",
                    "industry": "银行",
                    "close": 10.0,
                    "pct_chg": 10.0,
                    "amount": 100000000,
                    "limit_times": 2,
                }
            ]
        if api_name == "rt_k":
            rows = [
                {
                    "ts_code": "000001.SZ", "name": "甲", "pre_close": 10.0,
                    "open": 10.1, "high": 11.0, "low": 10.0, "close": 11.0,
                    "vol": 1000, "amount": 100000000, "num": 10,
                },
                {
                    "ts_code": "000002.SZ", "name": "乙", "pre_close": 20.0,
                    "open": 19.5, "high": 20.0, "low": 18.0, "close": 18.0,
                    "vol": 2000, "amount": 200000000, "num": 20,
                },
                {
                    "ts_code": "000003.SZ", "name": "丙", "pre_close": 30.0,
                    "open": 31.0, "high": 33.0, "low": 30.0, "close": 32.0,
                    "vol": 3000, "amount": 300000000, "num": 30,
                },
            ]
            requested = {
                code for code in str(params.get("ts_code") or "").split(",") if code
            }
            return [row for row in rows if row["ts_code"] in requested]
        raise AssertionError(f"Unexpected API call: {api_name} {params}")


FREE_QUOTES = [
    {
        "ts_code": "000001.SZ", "name": "甲", "pre_close": 10.0,
        "open": 10.1, "high": 11.0, "low": 10.0, "close": 11.0,
        "vol": 1000, "amount": 100000000, "num": 10,
        "quote_date": "20260720",
    },
    {
        "ts_code": "000002.SZ", "name": "乙", "pre_close": 20.0,
        "open": 19.5, "high": 20.0, "low": 18.0, "close": 18.0,
        "vol": 2000, "amount": 200000000, "num": 20,
        "quote_date": "20260720",
    },
    {
        "ts_code": "000003.SZ", "name": "丙", "pre_close": 30.0,
        "open": 31.0, "high": 33.0, "low": 30.0, "close": 32.0,
        "vol": 3000, "amount": 300000000, "num": 30,
        "quote_date": "20260720",
    },
]


class FakeFreeAggregator:
    def __init__(self, quotes=None, fail=False):
        self.quotes = list(quotes if quotes is not None else FREE_QUOTES)
        self.fail = fail
        self.calls = 0

    def eastmoney_market_quotes(self, expected_date=""):
        self.calls += 1
        if self.fail:
            raise RealtimeAggregateError("eastmoney down")
        if expected_date and self.quotes:
            dated = [
                row for row in self.quotes
                if str(row.get("quote_date") or "") == str(expected_date).replace("-", "")
            ]
            if dated:
                return dated
        return list(self.quotes)

    def tencent_market_quotes(self, codes, expected_date=""):
        return self.eastmoney_market_quotes(expected_date)

    def eastmoney_indices(self):
        return [
            {
                "code": "000001",
                "name": "上证指数",
                "price": 3800.12,
                "change": 0.85,
                "previous_close": 3768.0,
                "amount_billion": 4200.5,
                "quote_time": "2026-07-20T10:05:00+08:00",
                "source": "eastmoney_push2",
            }
        ]


class RealtimeDashboardTests(unittest.TestCase):
    def setUp(self):
        TushareClient._realtime_reference_cache.clear()
        TushareClient._capital_cache.clear()
        TushareClient._latest_realtime_market.clear()
        TushareClient._stock_activity_cache.clear()
        self.client = FakeRealtimeClient("test-token")

    def test_realtime_dashboard_classifies_pools_and_units(self):
        dashboard = self.client._realtime_dashboard("20260720", "20260720", "20260717")

        self.assertTrue(dashboard["meta"]["realtime"])
        self.assertEqual(dashboard["meta"]["quote_count"], 3)
        self.assertEqual(dashboard["overview"]["limit_up_count"], 1)
        self.assertEqual(dashboard["overview"]["limit_down_count"], 1)
        self.assertEqual(dashboard["overview"]["broken_count"], 1)
        self.assertEqual(dashboard["overview"]["amount_billion"], 6.0)
        self.assertEqual(dashboard["limits"][0]["streak"], 3)
        self.assertEqual(dashboard["limits"][0]["amount_billion"], 1.0)

    def test_realtime_stock_quote_uses_cached_industry(self):
        self.client._load_realtime_reference("20260720", "20260717")
        quote = self.client.realtime_stock_quote("000003.SZ")

        self.assertEqual(quote["name"], "丙")
        self.assertEqual(quote["sector"], "元器件")
        self.assertAlmostEqual(quote["change"], 6.6667)
        self.assertEqual(quote["amount_billion"], 3.0)
        self.assertAlmostEqual(quote["turnover_rate"], 0.01)

    def test_close_dashboard_marks_official_limit_data(self):
        dashboard = self.client.dashboard("20260720")

        self.assertEqual(dashboard["meta"]["limit_data_source"], "official")

    def test_close_dashboard_marks_derived_limit_data_as_incomplete(self):
        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "limit_list_d":
                return []
            return original_query(api_name, params, fields)

        self.client.query = query
        dashboard = self.client.dashboard("20260720")

        self.assertEqual(dashboard["meta"]["limit_data_source"], "derived")
        self.assertIn("日线数据推算", dashboard["meta"]["notice"])

    def test_calendar_open_flag_accepts_string_and_bool(self):
        self.assertTrue(calendar_is_open(1))
        self.assertTrue(calendar_is_open("1"))
        self.assertTrue(calendar_is_open(True))
        self.assertFalse(calendar_is_open(0))
        self.assertFalse(calendar_is_open("0"))
        self.assertFalse(calendar_is_open(False))

        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "trade_cal":
                return [
                    {
                        "cal_date": params.get("start_date"),
                        "is_open": "1",
                        "pretrade_date": "20260907",
                    }
                ]
            return original_query(api_name, params, fields)

        self.client.query = query
        trade_date, previous = self.client.resolve_trade_context("20260908")
        self.assertEqual(trade_date, "20260908")
        self.assertEqual(previous, "20260907")

    def test_session_clock_uses_realtime_until_official_window(self):
        today = "20260908"
        self.client.clock = lambda: datetime(
            2026, 9, 8, 10, 5, tzinfo=timezone(timedelta(hours=8))
        )
        self.assertTrue(self.client.should_use_realtime(today, today))
        self.client.clock = lambda: datetime(
            2026, 9, 8, 16, 10, tzinfo=timezone(timedelta(hours=8))
        )
        self.assertFalse(self.client.should_use_realtime(today, today))

    def test_realtime_dashboard_survives_missing_limit_table(self):
        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "stk_limit":
                return []
            return original_query(api_name, params, fields)

        self.client.query = query
        TushareClient._realtime_reference_cache.clear()
        dashboard = self.client._realtime_dashboard("20260720", "20260720", "20260717")
        self.assertTrue(dashboard["meta"]["realtime"])
        self.assertEqual(dashboard["meta"]["quote_count"], 3)
        self.assertEqual(dashboard["overview"]["limit_up_count"], 0)

    def test_rt_k_permission_error_falls_back_to_free_quotes(self):
        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "rt_k":
                raise TushareError("没有接口访问权限")
            return original_query(api_name, params, fields)

        self.client.query = query
        self.client.realtime_aggregator = FakeFreeAggregator()
        TushareClient._realtime_reference_cache.clear()
        dashboard = self.client._realtime_dashboard("20260720", "20260720", "20260717")

        self.assertTrue(dashboard["meta"]["realtime"])
        self.assertEqual(dashboard["meta"]["quote_source"], "eastmoney_clist")
        self.assertEqual(dashboard["meta"]["trade_date"], "2026-07-20")
        self.assertEqual(dashboard["meta"]["quote_count"], 3)
        self.assertEqual(dashboard["overview"]["limit_up_count"], 1)
        self.assertEqual(dashboard["overview"]["limit_down_count"], 1)
        self.assertEqual(dashboard["overview"]["amount_billion"], 6.0)
        self.assertIn("东财免费实时", dashboard["meta"]["notice"])
        self.assertEqual(dashboard["meta"]["indices"][0]["price"], 3800.12)

    def test_rt_k_empty_result_falls_back_to_free_quotes(self):
        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "rt_k":
                return []
            return original_query(api_name, params, fields)

        self.client.query = query
        self.client.realtime_aggregator = FakeFreeAggregator()
        TushareClient._realtime_reference_cache.clear()
        dashboard = self.client._realtime_dashboard("20260720", "20260720", "20260717")
        self.assertEqual(dashboard["meta"]["quote_source"], "eastmoney_clist")
        self.assertEqual(str(dashboard["meta"]["trade_date"]).replace("-", ""), "20260720")

    def test_rt_k_and_free_source_failure_keeps_today_error(self):
        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "rt_k":
                raise TushareError("没有接口访问权限")
            return original_query(api_name, params, fields)

        self.client.query = query
        self.client.realtime_aggregator = FakeFreeAggregator(fail=True)
        TushareClient._realtime_reference_cache.clear()
        with self.assertRaises(TushareError) as ctx:
            self.client._realtime_dashboard("20260720", "20260720", "20260717")
        self.assertIn("当天盘中实时行情不可用", str(ctx.exception))
        self.assertIn("没有接口访问权限", str(ctx.exception))

    def test_rt_k_and_eastmoney_failure_falls_back_to_tencent(self):
        original_query = self.client.query

        def query(api_name, params=None, fields=""):
            if api_name == "rt_k":
                raise TushareError("没有接口访问权限")
            return original_query(api_name, params, fields)

        class TencentOnlyAggregator(FakeFreeAggregator):
            def eastmoney_market_quotes(self, expected_date=""):
                raise RealtimeAggregateError("eastmoney blocked")

            def tencent_market_quotes(self, codes, expected_date=""):
                return list(FREE_QUOTES)

        self.client.query = query
        self.client.realtime_aggregator = TencentOnlyAggregator()
        TushareClient._realtime_reference_cache.clear()
        dashboard = self.client._realtime_dashboard("20260720", "20260720", "20260717")
        self.assertEqual(dashboard["meta"]["quote_source"], "tencent_qt")
        self.assertEqual(str(dashboard["meta"]["trade_date"]).replace("-", ""), "20260720")
        self.assertIn("腾讯免费实时", dashboard["meta"]["notice"])
        self.assertEqual(dashboard["overview"]["amount_billion"], 6.0)

    def test_normalize_eastmoney_quote_maps_units_and_exchange(self):
        quote = _normalize_eastmoney_quote(
            {
                "f12": "600000",
                "f13": 1,
                "f14": "浦发银行",
                "f2": 10.5,
                "f5": 12.0,
                "f6": 200000000,
                "f15": 10.8,
                "f16": 10.2,
                "f17": 10.3,
                "f18": 10.0,
                "f124": 1752986700,
            }
        )
        self.assertEqual(quote["ts_code"], "600000.SH")
        self.assertEqual(quote["vol"], 1200)
        self.assertEqual(quote["close"], 10.5)
        self.assertEqual(quote["pre_close"], 10.0)
        self.assertEqual(quote["source"], "eastmoney_clist")

    def test_parse_tencent_stock_quote_keeps_today_and_units(self):
        line = (
            'v_sz000001="51~平安银行~000001~11.73~11.70~11.66~346232~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~0~'
            '~20260720100500~0.03~0.26~11.79~11.65~11.73/346232/406045563~346232~40605~0.18~5.24~~11.79~11.65~1.20~'
            '2276.29~2276.31~0.49~12.87~10.53~0.95~-3076~11.73~4.43~5.34~~~0.18~40604.5563~0.0000~0~";'
        )
        quote = _parse_tencent_stock_quote(line)
        self.assertEqual(quote["ts_code"], "000001.SZ")
        self.assertEqual(quote["quote_date"], "20260720")
        self.assertEqual(quote["close"], 11.73)
        self.assertEqual(quote["pre_close"], 11.70)
        self.assertEqual(quote["vol"], 34623200)
        self.assertEqual(quote["amount"], 406050000)
        self.assertEqual(quote["source"], "tencent_qt")

    def test_datahub_market_quotes_used_before_legacy(self):
        calls = []

        def try_market_quotes(trade_date):
            calls.append(trade_date)
            return list(FREE_QUOTES)

        self.client.try_market_quotes = try_market_quotes
        self.client.realtime_aggregator = FakeFreeAggregator(fail=True)
        TushareClient._realtime_reference_cache.clear()
        dashboard = self.client._realtime_dashboard("20260720", "20260720", "20260717")
        self.assertEqual(calls, ["20260720"])
        self.assertEqual(dashboard["meta"]["quote_source"], "datahub")
        self.assertEqual(dashboard["meta"]["source"], "datahub")
        self.assertEqual(dashboard["meta"]["quote_count"], 3)
        self.assertIn("数据中枢", dashboard["meta"]["notice"])

    def test_gateway_dashboard_uses_bound_market_quotes(self) -> None:
        from backend.data import build_data_gateway
        from backend.data.datahub.client import DatahubResponse
        from backend.data.datahub.settings import DATASETS, DatahubSettings, DatasetFlags
        from backend.data.gateway import DataGateway
        from backend.data.providers.tushare import TushareProvider

        quotes = [
            {
                "ts_code": item["ts_code"],
                "name": item["name"],
                "pre_close": item["pre_close"],
                "open": item["open"],
                "high": item["high"],
                "low": item["low"],
                "close": item["close"],
                "vol": item["vol"],
                "amount": item["amount"],
                "quote_date": "20260720",
            }
            for item in FREE_QUOTES
        ]
        extras = [
            {
                "ts_code": f"{index:06d}.SZ",
                "name": f"X{index}",
                "pre_close": 10.0,
                "open": 10.0,
                "high": 10.2,
                "low": 9.8,
                "close": 10.1,
                "vol": 100.0,
                "amount": 1000.0,
                "quote_date": "20260720",
            }
            for index in range(10, 230)
        ]

        class QuoteHub:
            def __init__(self):
                self.calls = []

            def quotes_latest(self, **params):
                return self.get("/v1/quotes/latest", params)

            def get(self, path, params=None):
                self.calls.append(path)
                if path == "/v1/quotes/latest":
                    return DatahubResponse(
                        data=quotes + extras,
                        meta={"stale": False, "staleness_seconds": 0, "source": "eastmoney_clist"},
                    )
                raise AssertionError(path)

        datasets = {name: DatasetFlags(name) for name in DATASETS}
        datasets["quotes"] = DatasetFlags("quotes", read=True, shadow=False)
        settings = DatahubSettings(base_url="http://127.0.0.1:9", token="tok", datasets=datasets)
        base = build_data_gateway({"tushare_token": "tok"}, datahub_settings=settings)
        gateway = DataGateway(
            policy=base.policy,
            quality=base.quality,
            tushare_provider=TushareProvider(
                lambda: "tok",
                client_factory=lambda token: FakeRealtimeClient(token),
            ),
            ifind_provider=base.ifind_provider,
            chart_data=base.chart_data,
            realtime_observer=base.realtime_observer,
            datahub=base.datahub,
        )
        gateway.datahub.client = QuoteHub()
        wrapped = gateway.tushare()
        inner = wrapped._legacy
        inner.clock = lambda: datetime(2026, 7, 20, 10, 30, tzinfo=timezone(timedelta(hours=8)))
        inner.realtime_aggregator = FakeFreeAggregator(fail=True)
        TushareClient._realtime_reference_cache.clear()
        dashboard = wrapped.dashboard("20260720")
        self.assertEqual(dashboard["meta"]["quote_source"], "datahub")
        self.assertIn("/v1/quotes/latest", gateway.datahub.client.calls)
        self.assertTrue(callable(getattr(inner, "try_market_quotes", None)))
        self.assertFalse(hasattr(type(inner), "try_market_quotes"))


if __name__ == "__main__":
    unittest.main()