tigeropen 3.7.0__tar.gz → 3.7.2__tar.gz

{tigeropen-3.7.0/tigeropen.egg-info → tigeropen-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: tigeropen
-Version: 3.7.0
+Version: 3.7.2
 Summary: TigerBrokers Open API Python SDK
 Author-email: TigerBrokers <openapi@itiger.com>
 License: Apache-2.0
@@ -187,6 +187,51 @@ status = client.get_market_status(Market.US)
 print(status)
 ```
 
+### 逐笔成交 `cond` 字段说明
+
+`trade_tick` 接口和 push 层返回的 `cond` 字段已由 SDK 转换为可读字符串，含义如下：
+
+**美股（US）**
+
+| 值 | 含义 |
+|----|------|
+| `US_REGULAR_SALE` | 常规交易（Regular Sale） |
+| `US_BUNCHED_TRADE` | 批量交易（Bunched Trade） |
+| `US_CASH_TRADE` | 现金交易（Cash Trade） |
+| `US_INTERMARKET_SWEEP` | 跨市场交易（Intermarket Sweep） |
+| `US_BUNCHED_SOLD_TRADE` | 批量卖出（Bunched Sold Trade） |
+| `US_PRICE_VARIATION_TRADE` | 离价交易（Price Variation Trade） |
+| `US_ODD_LOT_TRADE` | 碎股交易（Odd Lot Trade） |
+| `US_RULE_127_OR_155_TRADE` | 纽交所第 127/155 条交易 |
+| `US_SOLD_LAST` | 延迟交易（Sold Last） |
+| `US_MARKET_CENTER_CLOSE_PRICE` | 中央收市价（Market Center Close Price） |
+| `US_NEXT_DAY_TRADE` | 隔日交易（Next Day Trade） |
+| `US_MARKET_CENTER_OPENING_TRADE` | 中央开盘价交易（Market Center Opening Trade） |
+| `US_PRIOR_REFERENCE_PRICE` | 前参考价（Prior Reference Price） |
+| `US_MARKET_CENTER_OPEN_PRICE` | 中央开盘价（Market Center Open Price） |
+| `US_SELLER` | 卖方（Seller） |
+| `US_FORM_T` | 盘前盘后交易（Form T） |
+| `US_EXTENDED_TRADING_HOURS` | 延长交易时段（Extended Trading Hours） |
+| `US_CONTINGENT_TRADE` | 合单交易（Contingent Trade） |
+| `US_AVERAGE_PRICE_TRADE` | 均价交易（Average Price Trade） |
+| `US_CROSS_TRADE` | 跨市场交易（Cross Trade） |
+| `US_SOLD_OUT_OF_SEQUENCE` | 场外售出（Sold Out of Sequence） |
+| `US_DERIVATIVELY_PRICED` | 衍生工具定价（Derivatively Priced） |
+| `US_QUALIFIED_CONTINGENT_TRADE` | 合单交易（Qualified Contingent Trade） |
+
+**港股（HK）**
+
+| 值 | 含义 |
+|----|------|
+| `HK_AUTOMATCH_NORMAL` | 自动对盘（Automatch Normal） |
+| `HK_ODD_LOT_TRADE` | 碎股交易（Odd Lot Trade） |
+| `HK_AUCTION_TRADE` | 竞价交易（Auction Trade） |
+| `HK_OVERSEAS_TRADE` | 场外交易（Overseas Trade） |
+| `HK_LATE_TRADE_OFF_EXCHG` | 开市前成交（Late Trade Off Exchange） |
+| `HK_NON_DIRECT_OFF_EXCHG_TRADE` | 非自动对盘（Non-Direct Off Exchange Trade） |
+| `HK_DIRECT_OFF_EXCHG_TRADE` | 同券商自动对盘（Direct Off Exchange Trade） |
+| `HK_AUTOMATIC_INTERNALIZED` | 同券商非自动对盘（Automatic Internalized） |
+
 ### 4. 下单交易
 
 ```python

{tigeropen-3.7.0 → tigeropen-3.7.2}/README.md

@@ -140,6 +140,51 @@ status = client.get_market_status(Market.US)
 print(status)
 ```
 
+### 逐笔成交 `cond` 字段说明
+
+`trade_tick` 接口和 push 层返回的 `cond` 字段已由 SDK 转换为可读字符串，含义如下：
+
+**美股（US）**
+
+| 值 | 含义 |
+|----|------|
+| `US_REGULAR_SALE` | 常规交易（Regular Sale） |
+| `US_BUNCHED_TRADE` | 批量交易（Bunched Trade） |
+| `US_CASH_TRADE` | 现金交易（Cash Trade） |
+| `US_INTERMARKET_SWEEP` | 跨市场交易（Intermarket Sweep） |
+| `US_BUNCHED_SOLD_TRADE` | 批量卖出（Bunched Sold Trade） |
+| `US_PRICE_VARIATION_TRADE` | 离价交易（Price Variation Trade） |
+| `US_ODD_LOT_TRADE` | 碎股交易（Odd Lot Trade） |
+| `US_RULE_127_OR_155_TRADE` | 纽交所第 127/155 条交易 |
+| `US_SOLD_LAST` | 延迟交易（Sold Last） |
+| `US_MARKET_CENTER_CLOSE_PRICE` | 中央收市价（Market Center Close Price） |
+| `US_NEXT_DAY_TRADE` | 隔日交易（Next Day Trade） |
+| `US_MARKET_CENTER_OPENING_TRADE` | 中央开盘价交易（Market Center Opening Trade） |
+| `US_PRIOR_REFERENCE_PRICE` | 前参考价（Prior Reference Price） |
+| `US_MARKET_CENTER_OPEN_PRICE` | 中央开盘价（Market Center Open Price） |
+| `US_SELLER` | 卖方（Seller） |
+| `US_FORM_T` | 盘前盘后交易（Form T） |
+| `US_EXTENDED_TRADING_HOURS` | 延长交易时段（Extended Trading Hours） |
+| `US_CONTINGENT_TRADE` | 合单交易（Contingent Trade） |
+| `US_AVERAGE_PRICE_TRADE` | 均价交易（Average Price Trade） |
+| `US_CROSS_TRADE` | 跨市场交易（Cross Trade） |
+| `US_SOLD_OUT_OF_SEQUENCE` | 场外售出（Sold Out of Sequence） |
+| `US_DERIVATIVELY_PRICED` | 衍生工具定价（Derivatively Priced） |
+| `US_QUALIFIED_CONTINGENT_TRADE` | 合单交易（Qualified Contingent Trade） |
+
+**港股（HK）**
+
+| 值 | 含义 |
+|----|------|
+| `HK_AUTOMATCH_NORMAL` | 自动对盘（Automatch Normal） |
+| `HK_ODD_LOT_TRADE` | 碎股交易（Odd Lot Trade） |
+| `HK_AUCTION_TRADE` | 竞价交易（Auction Trade） |
+| `HK_OVERSEAS_TRADE` | 场外交易（Overseas Trade） |
+| `HK_LATE_TRADE_OFF_EXCHG` | 开市前成交（Late Trade Off Exchange） |
+| `HK_NON_DIRECT_OFF_EXCHG_TRADE` | 非自动对盘（Non-Direct Off Exchange Trade） |
+| `HK_DIRECT_OFF_EXCHG_TRADE` | 同券商自动对盘（Direct Off Exchange Trade） |
+| `HK_AUTOMATIC_INTERNALIZED` | 同券商非自动对盘（Automatic Internalized） |
+
 ### 4. 下单交易
 
 ```python

{tigeropen-3.7.0 → tigeropen-3.7.2}/pyproject.toml

@@ -68,3 +68,12 @@ exclude = ["tests", "tests.*"]
 
 [tool.setuptools.package-data]
 "*" = ["*.*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# marker 语义是「这个用例需要什么」，不是「它属于哪一层」。分层由 TIGER_RUN_INTEG 决定，
+# 完整说明见 tests/conftest.py
+markers = [
+    "unit: 永远不碰真实接口的用例（纯函数、序列化、配置解析等）",
+    "integ: 涉及写操作的真实接口用例，只应手动或定时触发",
+]

tigeropen-3.7.2/scripts/push_latency_monitor.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""
+行情推送延迟监控脚本
+
+参考 tigeropen/examples/push_client_demo.py，订阅指定标的的最优报价(BBO)推送，
+记录每次收到的 askTimestamp / bidTimestamp、本机接收时的系统时间，以及两者差值
+(即推送延迟)，写入日志文件；运行结束后打印延迟统计(min/max/avg/p50/p95/p99)。
+
+配置来源：TIGER_CONFIG_PATH 环境变量指向的目录(含 tiger_openapi_config.properties)。
+不在代码中硬编码任何账号路径，运行时通过环境变量指定。
+
+用法示例:
+    TIGER_CONFIG_PATH=~/.tigeropen/<profile> .venv/bin/python scripts/push_latency_monitor.py
+"""
+import logging
+import os
+import statistics
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+from tigeropen.push.pb.QuoteBBOData_pb2 import QuoteBBOData
+from tigeropen.push.push_client import PushClient
+from tigeropen.tiger_open_config import TigerOpenClientConfig
+
+# ---- 配置 ----
+SYMBOLS = ['01810', '02513']
+RUN_DURATION_SECONDS = 10 * 60  # 持续运行 10 分钟
+
+LOG_DIR = Path(__file__).resolve().parent / 'logs'
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / f'push_latency_{time.strftime("%Y%m%d_%H%M%S")}.log'
+
+logger = logging.getLogger('push_latency_monitor')
+logger.setLevel(logging.INFO)
+_formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname)s %(message)s')
+_file_handler = logging.FileHandler(LOG_FILE, encoding='utf-8')
+_file_handler.setFormatter(_formatter)
+_console_handler = logging.StreamHandler()
+_console_handler.setFormatter(_formatter)
+logger.addHandler(_file_handler)
+logger.addHandler(_console_handler)
+
+
+class LatencyStats:
+    """线程安全的延迟采样收集器 (回调可能在线程池的不同线程中并发触发)"""
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._data = {}  # (symbol, 'ask'/'bid') -> [delay_ms, ...]
+
+    def add(self, symbol, kind, delay_ms):
+        with self._lock:
+            self._data.setdefault((symbol, kind), []).append(delay_ms)
+
+    def report(self):
+        with self._lock:
+            snapshot = {k: list(v) for k, v in self._data.items()}
+        if not snapshot:
+            return '(未收到任何 BBO 推送数据)'
+        lines = []
+        for (symbol, kind) in sorted(snapshot.keys()):
+            values = sorted(snapshot[(symbol, kind)])
+            n = len(values)
+            if n == 0:
+                continue
+
+            def pct(p):
+                return values[min(int(n * p), n - 1)]
+
+            over_250 = sum(1 for v in values if v > 250)
+            over_250_pct = 100 * over_250 / n
+
+            lines.append(
+                f'{symbol} {kind}: n={n} '
+                f'min={values[0]} p50={pct(0.5)} p90={pct(0.9)} p95={pct(0.95)} p99={pct(0.99)} max={values[-1]} '
+                f'avg={statistics.mean(values):.1f} >250ms={over_250_pct:.1f}%'
+            )
+        return '\n'.join(lines)
+
+
+stats = LatencyStats()
+
+
+def on_quote_bbo_changed(frame: QuoteBBOData):
+    """最优报价推送回调：按用户方式 latency = recv_time - min(askTimestamp, bidTimestamp)"""
+    recv_ts_ms = int(time.time() * 1000)
+    local_time_str = datetime.now().strftime('%H:%M:%S.%f')[:-3]
+    symbol = frame.symbol
+
+    # frame.timestamp 是推送数据本身的时间戳（服务端打的）
+    data_ts = frame.timestamp
+    data_delay = recv_ts_ms - data_ts if data_ts else None
+    if data_delay is not None:
+        stats.add(symbol, 'server_ts', data_delay)
+
+    # 收集 ask/bid timestamp
+    ask_ts = frame.askTimestamp if (frame.HasField('askTimestamp') and frame.askTimestamp) else None
+    bid_ts = frame.bidTimestamp if (frame.HasField('bidTimestamp') and frame.bidTimestamp) else None
+
+    # 分别统计
+    if ask_ts:
+        stats.add(symbol, 'ask', recv_ts_ms - ask_ts)
+    if bid_ts:
+        stats.add(symbol, 'bid', recv_ts_ms - bid_ts)
+
+    # 用户方式: min(askTimestamp, bidTimestamp)
+    ts_candidates = [t for t in (ask_ts, bid_ts) if t]
+    if ts_candidates:
+        min_ts = min(ts_candidates)
+        max_ts = max(ts_candidates)
+        latency_min = recv_ts_ms - min_ts  # 用户方式（取最旧的 → 延迟偏大）
+        latency_max = recv_ts_ms - max_ts  # 取最新的 → 更接近真实推送延迟
+        stats.add(symbol, 'user_method(min)', latency_min)
+        stats.add(symbol, 'fresh_method(max)', latency_max)
+
+    # 日志详情
+    parts = [f'symbol={symbol}', f'local_time={local_time_str}', f'recv={recv_ts_ms}']
+    if data_ts:
+        parts.append(f'svrTs={data_ts} svrDelay={data_delay}')
+    if ask_ts:
+        ask_time_str = datetime.fromtimestamp(ask_ts / 1000).strftime('%H:%M:%S.%f')[:-3]
+        parts.append(f'ask={ask_ts}({ask_time_str}) d={recv_ts_ms - ask_ts}ms p={frame.askPrice}')
+    if bid_ts:
+        bid_time_str = datetime.fromtimestamp(bid_ts / 1000).strftime('%H:%M:%S.%f')[:-3]
+        parts.append(f'bid={bid_ts}({bid_time_str}) d={recv_ts_ms - bid_ts}ms p={frame.bidPrice}')
+    if ts_candidates:
+        parts.append(f'user_latency(min)={latency_min}ms fresh(max)={latency_max}ms')
+
+    logger.info(' '.join(parts))
+
+
+def query_subscribed_callback(data):
+    logger.info(f'subscribed data: {data}')
+
+
+def subscribe_callback(frame):
+    logger.info(f'subscribe callback: {frame}')
+
+
+def error_callback(frame):
+    logger.error(f'push error: {frame}')
+
+
+def connect_callback(frame):
+    logger.info('connected')
+
+
+def disconnect_callback():
+    """连接断开回调，参考 demo 的重连逻辑"""
+    for t in range(1, 200):
+        try:
+            logger.warning('disconnected, reconnecting')
+            push_client.connect(client_config.tiger_id, client_config.private_key)
+        except Exception:
+            logger.exception('connect failed, retry')
+            time.sleep(t)
+        else:
+            logger.info('reconnect success')
+            return
+    logger.error('reconnect failed, please check your network')
+
+
+if __name__ == '__main__':
+    props_path = os.environ.get('TIGER_CONFIG_PATH', os.path.expanduser('~/.tigeropen/'))
+    client_config = TigerOpenClientConfig(props_path=props_path)
+    protocol, host, port = client_config.socket_host_port
+    push_client = PushClient(host, port, use_ssl=(protocol == 'ssl'))
+
+    push_client.quote_bbo_changed = on_quote_bbo_changed
+    push_client.query_subscribed_callback = query_subscribed_callback
+    push_client.subscribe_callback = subscribe_callback
+    push_client.error_callback = error_callback
+
+    push_client.connect(client_config.tiger_id, client_config.private_key)
+    push_client.disconnect_callback = disconnect_callback
+
+    logger.info(f'socket={protocol}://{host}:{port} symbols={SYMBOLS} '
+               f'duration={RUN_DURATION_SECONDS}s log_file={LOG_FILE}')
+    push_client.subscribe_quote(SYMBOLS)
+
+    try:
+        time.sleep(RUN_DURATION_SECONDS)
+    except KeyboardInterrupt:
+        logger.info('收到中断信号，提前结束')
+    finally:
+        push_client.disconnect()
+        logger.info('已断开连接')
+        summary = stats.report()
+        # 打印本地系统时间信息
+        local_now = datetime.now()
+        logger.info(f'本地系统时间: {local_now.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]}')
+        logger.info('==== 延迟统计汇总 ====\n' + summary)
+        logger.info('注: dataDelay = recv_time(本地系统时间) - timestamp(服务端时间)，'
+                   '负值说明本地时钟慢于服务端时钟')
+        print(f'\n本地系统时间: {local_now.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]}')
+        print('\n==== 延迟统计汇总 ====')
+        print(summary)
+        print('\n注: dataDelay = recv_time(本地系统时间) - timestamp(服务端时间)')
+        print('    负值说明本地时钟慢于服务端；askDelay/bidDelay = recv_time - ask/bidTimestamp(交易所报价时间)')
+        print(f'详细日志: {LOG_FILE}')

tigeropen-3.7.2/tests/test_api_registry.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""本仓自查测试：wire method 注册表与契约覆盖完整性。."""
+import ast
+import re
+from pathlib import Path
+
+import pytest
+
+# 纯静态分析，不碰真实接口
+pytestmark = pytest.mark.unit
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+_TESTS_DIR = Path(__file__).resolve().parent
+
+# 所有会构造 OpenApiRequest 的模块
+_CLIENT_SOURCES = (
+    'tigeropen/quote/quote_client.py',
+    'tigeropen/trade/trade_client.py',
+    'tigeropen/tiger_open_client.py',
+)
+_SERVICE_TYPES = 'tigeropen/common/consts/service_types.py'
+
+# 公开但不发起 wire 调用的方法。加新条目前先确认它真的只是本地封装。
+_LOCAL_ONLY_PUBLIC_METHODS = frozenset({
+    'execute',                    # 泛用发送入口，method 由调用方给
+    'get_bars_by_page',           # 分页封装，内部循环调 get_bars
+    'get_future_bars_by_page',    # 分页封装，内部循环调 get_future_bars
+    'refresh_token',              # 内部调 query_token
+    'run',                        # 定时器线程的 run，不是 API 方法
+})
+
+# 棘轮清单：当前还没有任何用例覆盖的 wire method。
+# 只允许变短。补齐一个用例就从这里删掉一行，否则 test_wire_method_is_exercised_by_test 会红。
+_WIRE_METHODS_WITHOUT_TEST = frozenset({
+})
+
+# 测试里持有 client 的变量名
+_CLIENT_ATTR_NAMES = frozenset({'client', 'quote_client', 'trade_client'})
+
+
+def _openapi_request_constants(func_node):
+    """取出一个函数体里 OpenApiRequest(...) 用到的常量名。
+
+    两种写法都要认：OpenApiRequest(MARKET_STATE, biz_model=params) 和
+    OpenApiRequest(method=USER_LICENSE)。
+    """
+    constants = set()
+    for node in ast.walk(func_node):
+        if not (isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Name)
+                and node.func.id == 'OpenApiRequest'):
+            continue
+        candidates = list(node.args)
+        candidates += [kw.value for kw in node.keywords if kw.arg == 'method']
+        for arg in candidates:
+            if isinstance(arg, ast.Name):
+                constants.add(arg.id)
+    return constants
+
+
+def _scan_clients():
+    """返回 (方法名 -> wire 常量名集合, 公开方法名集合)。"""
+    method_to_wire = {}
+    public_methods = set()
+    for rel_path in _CLIENT_SOURCES:
+        tree = ast.parse((_REPO_ROOT / rel_path).read_text())
+        for class_node in (n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)):
+            for func in (n for n in class_node.body
+                         if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))):
+                if not func.name.startswith('_'):
+                    public_methods.add(func.name)
+                constants = _openapi_request_constants(func)
+                if constants:
+                    method_to_wire.setdefault(func.name, set()).update(constants)
+    return method_to_wire, public_methods
+
+
+def _wire_method_constants():
+    """service_types.py 里声明的所有常量名。"""
+    source = (_REPO_ROOT / _SERVICE_TYPES).read_text()
+    pattern = re.compile(r'^([A-Z][A-Z0-9_]*)\s*=\s*[\'"][a-z0-9_]+[\'"]', re.M)
+    return {m.group(1) for m in pattern.finditer(source)}
+
+
+def _client_methods_called_in_tests():
+    """测试里通过 client 调用过的方法名。
+
+    识别 ``self.client.xxx()`` / ``client.xxx()`` / ``self.quote_client.xxx()`` 这几种写法。
+    """
+    called = set()
+    for path in sorted(_TESTS_DIR.rglob('test_*.py')):
+        for node in ast.walk(ast.parse(path.read_text())):
+            if not (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)):
+                continue
+            owner = node.func.value
+            if isinstance(owner, ast.Attribute) and owner.attr in _CLIENT_ATTR_NAMES:
+                called.add(node.func.attr)
+            elif isinstance(owner, ast.Name) and owner.id in _CLIENT_ATTR_NAMES:
+                called.add(node.func.attr)
+    return called
+
+
+def test_no_dangling_wire_method_constant():
+    """No dangling constants in service_types.py."""
+    method_to_wire, _ = _scan_clients()
+    declared = _wire_method_constants()
+    referenced = set().union(*method_to_wire.values())
+
+    dangling = sorted(declared - referenced)
+    assert not dangling, (
+        f'service_types.py 里有 {len(dangling)} 个常量没有任何 client 方法引用：{dangling}。'
+        f'要么补上对应的 client 方法，要么删掉常量。')
+
+    unknown = sorted(referenced - declared)
+    assert not unknown, f'client 引用了 service_types.py 里不存在的常量：{unknown}'
+
+
+def test_public_client_method_has_wire_method():
+    """Public methods must either make a wire call or be in the local-only list."""
+    method_to_wire, public_methods = _scan_clients()
+
+    without_wire = {m for m in public_methods if m not in method_to_wire}
+    unexpected = sorted(without_wire - _LOCAL_ONLY_PUBLIC_METHODS)
+    assert not unexpected, (
+        f'这些公开方法既不发起 wire 调用，也不在本地封装允许清单里：{unexpected}。'
+        f'如果确实只是本地封装，加进 _LOCAL_ONLY_PUBLIC_METHODS 并写明理由。')
+
+    stale = sorted(_LOCAL_ONLY_PUBLIC_METHODS - without_wire)
+    assert not stale, (
+        f'_LOCAL_ONLY_PUBLIC_METHODS 里这些条目已经不需要了（方法已发 wire 调用或已删除）：'
+        f'{stale}，请从清单里移除。')
+
+
+def test_wire_method_is_exercised_by_test():
+    """Every wire method must be exercised by at least one test."""
+    method_to_wire, _ = _scan_clients()
+    referenced = set().union(*method_to_wire.values())
+    called_methods = _client_methods_called_in_tests()
+
+    covered = set()
+    for method in called_methods:
+        covered |= method_to_wire.get(method, set())
+    uncovered = referenced - covered
+
+    newly_uncovered = sorted(uncovered - _WIRE_METHODS_WITHOUT_TEST)
+    assert not newly_uncovered, (
+        f'这些 wire method 没有任何用例覆盖：{newly_uncovered}。'
+        f'新增接口必须同时补用例，不要往 _WIRE_METHODS_WITHOUT_TEST 里加条目。')
+
+    now_covered = sorted(_WIRE_METHODS_WITHOUT_TEST - uncovered)
+    assert not now_covered, (
+        f'这些 wire method 已经有用例覆盖了：{now_covered}，'
+        f'请从 _WIRE_METHODS_WITHOUT_TEST 里删掉，让棘轮往前走一格。')

{tigeropen-3.7.0 → tigeropen-3.7.2}/tests/test_client_config.py

@@ -17,6 +17,12 @@ from tigeropen.tiger_open_config import (
     SANDBOX_TIGER_PUBLIC_KEY, TIGER_PUBLIC_KEY,
 )
 
+import pytest
+
+
+# 纯单测：永远不碰真实接口，contract / integ job 会跳过
+pytestmark = pytest.mark.unit
+
 
 def make_config(**kwargs) -> TigerOpenClientConfig:
     """构造一个不触发 query_domains 的 config 实例"""
@@ -292,8 +298,11 @@ class TestRefreshServerInfo(unittest.TestCase):
     }
 
     def test_refresh_server_info(self):
-        config = TigerOpenClientConfig()
+        # 构造时先关掉动态域名，避免 __init__ 里的 query_domains() 发真实请求；
+        # 随后再打开并注入 mock 的域名表，验证的是 refresh_server_info 本身的逻辑
+        config = TigerOpenClientConfig(enable_dynamic_domain=False)
         config.query_domains = MagicMock(name='query_domains', return_value=self.domain_map)
+        config.enable_dynamic_domain = True
         config.domain_conf = config.query_domains()
 
         self.assertEqual('https://openapi.tigerfintech.com' + GATEWAY_SUFFIX, config.server_url)