wop-python-sdk 0.1.0__tar.gz → 0.1.1__tar.gz

{wop_python_sdk-0.1.0/src/wop_python_sdk.egg-info → wop_python_sdk-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wop-python-sdk
-Version: 0.1.0
+Version: 0.1.1
 Summary: WOP 商户侧官方 Python SDK：协议核心（签名/摘要/数字信封/验签解密）+ 可插拔 HTTP 适配层
 Author: wop-platform
 License: MIT

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wop-python-sdk"
-version = "0.1.0"
+version = "0.1.1"
 description = "WOP 商户侧官方 Python SDK：协议核心（签名/摘要/数字信封/验签解密）+ 可插拔 HTTP 适配层"
 readme = "README.md"
 license = { text = "MIT" }

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1/src/wop_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wop-python-sdk
-Version: 0.1.0
+Version: 0.1.1
 Summary: WOP 商户侧官方 Python SDK：协议核心（签名/摘要/数字信封/验签解密）+ 可插拔 HTTP 适配层
 Author: wop-platform
 License: MIT

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/__init__.py

@@ -17,7 +17,7 @@ from .errors import (
 )
 from .suites import Suite, parse_suite
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 __all__ = [
     "WopClient",

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/encoding.py

@@ -10,6 +10,14 @@ from typing import Optional
 
 _B64URL_ALPHABET = re.compile(r"^[A-Za-z0-9_-]+$")
 
+# b64url 字符 → 6bit 索引（RFC 4648 §4 字母表：A-Z=0-25, a-z=26-51, 0-9=52-61, '-'=62, '_'=63）
+_B64URL_INDEX = {
+    ch: i
+    for i, ch in enumerate(
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+    )
+}
+
 # Java URLEncoder 的保留集：字母数字与 . - * _（空格单独处理为 %20）
 _SAFE_CHARS = frozenset(
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._*-"
@@ -24,11 +32,13 @@ def b64url_encode(data: bytes) -> str:
 def b64url_decode(text: str) -> bytes:
     """base64url 无填充字符串 → 字节。
 
-    严格模式（F7/D10）：
+    严格模式（F7/D10，语义锚 = Go base64.RawURLEncoding.Strict()，RFC 4648 §3.5）：
     - 拒绝空串；
     - 拒绝 '=' 填充字符；
     - 拒绝字母表外字符（含 '+' '/' 空白等）；
-    - 拒绝长度 % 4 == 1（不可能的 base64 长度）。
+    - 拒绝长度 % 4 == 1（不可能的 base64 长度）；
+    - 拒绝非 canonical 尾随位：len % 4 == 2 时尾字符低 4 位须为零，
+      len % 4 == 3 时尾字符低 2 位须为零（宽容解码会静默丢位，须显式拒绝）。
     """
     if not text:
         raise ValueError("base64url 输入为空")
@@ -36,8 +46,14 @@ def b64url_decode(text: str) -> bytes:
         raise ValueError("base64url 严格模式：拒绝 '=' 填充")
     if not _B64URL_ALPHABET.match(text):
         raise ValueError("base64url 字母表外字符")
-    if len(text) % 4 == 1:
+    rem = len(text) % 4
+    if rem == 1:
         raise ValueError("base64url 长度非法（% 4 == 1）")
+    # RFC 4648 §3.5：尾字符低位是"丢弃位"，非零即非 canonical 编码
+    if rem == 2 and _B64URL_INDEX[text[-1]] & 0xF:
+        raise ValueError("base64url 尾随位非 canonical（len % 4 == 2，尾字符低 4 位须为零）")
+    if rem == 3 and _B64URL_INDEX[text[-1]] & 0x3:
+        raise ValueError("base64url 尾随位非 canonical（len % 4 == 3，尾字符低 2 位须为零）")
     return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
 
 

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/envelope.py

@@ -151,7 +151,11 @@ def open_l2(suite: Suite, wrap_priv: KeyMaterial, wire_body: bytes, dek_b64u: st
         wrapped = b64url_decode(dek_b64u)
     except ValueError:
         raise DecryptError() from None
-    payload = unwrap_dek(suite, wrap_priv, wrapped).decode("utf-8", errors="strict")
+    try:
+        payload = unwrap_dek(suite, wrap_priv, wrapped).decode("utf-8", errors="strict")
+    except UnicodeDecodeError:
+        # 解包成功但载荷非 UTF-8 → 与解包失败同归模糊（I7），不得向商户层逃逸
+        raise DecryptError() from None
     key, iv = parse_dek_payload(suite, payload)
     try:
         obj = json.loads(wire_body)

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/transports/__init__.py

@@ -3,14 +3,37 @@
 
 - ``Transport``：协议接口，商户自带栈时可直接实现或消费 RequestDraft；
 - ``send_draft``：RequestDraft → Transport（URL 拼接归此，适配器只面对完整请求）；
+- ``MAX_RESPONSE_BYTES`` / ``read_capped``：响应体 11MB 上限，流式读取中生效；
 - stdlib urllib 适配器随主包；httpx / requests 适配器为 peer 依赖（extras）。
 """
 from dataclasses import dataclass
-from typing import Dict, Optional, Protocol, runtime_checkable
+from typing import Dict, Iterable, Optional, Protocol, runtime_checkable
 
 from ..client import RequestDraft
-
-__all__ = ["HttpResponse", "Transport", "UrllibTransport", "send_draft"]
+from ..errors import ProtocolFormatError
+
+__all__ = ["HttpResponse", "MAX_RESPONSE_BYTES", "Transport", "UrllibTransport", "read_capped", "send_draft"]
+
+# 响应体上限 11MB：与网关 maxContentLength 及各语言 SDK（dotnet/Go 11<<20）对齐；
+# 必须在读取过程中生效（流式计数），而非整体缓冲后检查
+MAX_RESPONSE_BYTES = 11 << 20
+_READ_CHUNK = 1 << 16
+
+
+def read_capped(chunks: Iterable[bytes]) -> bytes:
+    """流式消费响应体分块并累计；累计越上限即刻抛 ProtocolFormatError。
+
+    逐块检查（读取过程中生效）：任何一 chunk 使累计超过 MAX_RESPONSE_BYTES 即中断，
+    不再把无限/超大响应整体缓冲进内存。
+    """
+    buf = bytearray()
+    for chunk in chunks:
+        buf += chunk
+        if len(buf) > MAX_RESPONSE_BYTES:
+            raise ProtocolFormatError(
+                "响应体超过传输层上限 %d 字节" % MAX_RESPONSE_BYTES
+            )
+    return bytes(buf)
 
 
 @dataclass

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/transports/httpx_transport.py

@@ -2,11 +2,15 @@
 """httpx peer 适配器（extras：``pip install 'wop-sdk[httpx]'``）。"""
 from typing import Dict, Optional
 
-from . import HttpResponse
+from . import HttpResponse, _READ_CHUNK, read_capped
 
 
 class HttpxTransport:
-    """httpx.Client 适配器；惰性导入，未安装时给出安装指引。"""
+    """httpx.Client 适配器；惰性导入，未安装时给出安装指引。
+
+    响应走 ``Client.stream`` + ``iter_bytes`` 流式读取，累计超
+    MAX_RESPONSE_BYTES（11MB）时即刻中断，不整体缓冲。
+    """
 
     def __init__(self, client=None):
         try:
@@ -20,12 +24,15 @@ class HttpxTransport:
     def send(
         self, method: str, url: str, headers: Dict[str, str], body: Optional[bytes]
     ) -> HttpResponse:
-        resp = self._client.request(method, url, headers=headers, content=body)
-        return HttpResponse(
-            resp.status_code,
-            {k.lower(): v for k, v in resp.headers.items()},
-            resp.content,
-        )
+        with self._client.stream(
+            method, url, headers=headers, content=body
+        ) as resp:
+            data = read_capped(resp.iter_bytes(_READ_CHUNK))
+            return HttpResponse(
+                resp.status_code,
+                {k.lower(): v for k, v in resp.headers.items()},
+                data,
+            )
 
     def close(self) -> None:
         self._client.close()

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/transports/requests_transport.py

@@ -2,11 +2,15 @@
 """requests peer 适配器（extras：``pip install 'wop-sdk[requests]'``）。"""
 from typing import Dict, Optional
 
-from . import HttpResponse
+from . import HttpResponse, _READ_CHUNK, read_capped
 
 
 class RequestsTransport:
-    """requests 适配器；惰性导入，未安装时给出安装指引。"""
+    """requests 适配器；惰性导入，未安装时给出安装指引。
+
+    请求带 ``stream=True``，响应经 ``iter_content`` 流式读取，累计超
+    MAX_RESPONSE_BYTES（11MB）时即刻中断，不整体缓冲。
+    """
 
     def __init__(self, session=None):
         try:
@@ -20,11 +24,17 @@ class RequestsTransport:
     def send(
         self, method: str, url: str, headers: Dict[str, str], body: Optional[bytes]
     ) -> HttpResponse:
-        resp = self._session.request(method, url, headers=headers, data=body)
+        resp = self._session.request(
+            method, url, headers=headers, data=body, stream=True
+        )
+        try:
+            data = read_capped(resp.iter_content(_READ_CHUNK))
+        finally:
+            resp.close()
         return HttpResponse(
             resp.status_code,
             {k.lower(): v for k, v in resp.headers.items()},
-            resp.content,
+            data,
         )
 
     def close(self) -> None:

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/src/wop_sdk/transports/urllib_transport.py

@@ -2,13 +2,25 @@
 """stdlib urllib 适配器（零依赖，随主包交付）。"""
 import urllib.error
 import urllib.request
-from typing import Dict, Optional
+from typing import Dict, Iterator, Optional
 
-from . import HttpResponse
+from . import HttpResponse, _READ_CHUNK, read_capped
+
+
+def _urllib_chunks(resp) -> Iterator[bytes]:
+    """resp.read(n) 循环取块，直至 EOF；配合 read_capped 流式限量。"""
+    while True:
+        chunk = resp.read(_READ_CHUNK)
+        if not chunk:
+            break
+        yield chunk
 
 
 class UrllibTransport:
-    """urllib.request 适配器；4xx/5xx 返回响应体而非抛异常（协议错误也在 body 里）。"""
+    """urllib.request 适配器；4xx/5xx 返回响应体而非抛异常（协议错误也在 body 里）。
+
+    响应体按块流式读取并在累计超 MAX_RESPONSE_BYTES（11MB）时即刻中断。
+    """
 
     def send(
         self, method: str, url: str, headers: Dict[str, str], body: Optional[bytes]
@@ -21,9 +33,11 @@ class UrllibTransport:
                 return HttpResponse(
                     resp.status,
                     {k.lower(): v for k, v in resp.headers.items()},
-                    resp.read(),
+                    read_capped(_urllib_chunks(resp)),
                 )
         except urllib.error.HTTPError as exc:
             return HttpResponse(
-                exc.code, {k.lower(): v for k, v in exc.headers.items()}, exc.read()
+                exc.code,
+                {k.lower(): v for k, v in exc.headers.items()},
+                read_capped(_urllib_chunks(exc)),
             )

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/tests/test_digest.py

@@ -2,6 +2,7 @@
 """摘要测试：D2 格式钉（恰一空格/小写 hex/跨族拒绝/长度）、向量字节级、formatRules 全套。"""
 import pytest
 
+import conftest
 from wop_sdk.digest import (
     build_digest_header,
     check_digest_header,
@@ -41,29 +42,31 @@ class TestBuildHeader:
 
 
 class TestFormatRules:
-    """formatRules 全套（spec:A2/F8）：accept = 格式层接受；reject = 拒绝。"""
-
-    @pytest.mark.parametrize("rule_id", ["header-rsa-ok", "header-sm2-ok"])
-    def test_accept_format(self, vectors, rule_id):
-        rule = next(r for r in vectors["formatRules"] if r["id"] == rule_id)
-        check_digest_header(parse_suite(rule["suite"]), rule["value"])
-
-    @pytest.mark.parametrize(
-        "rule_id",
-        [
-            "header-crossfamily",  # spec:I5 跨族
-            "header-double-space",  # spec:D2 恰一空格
-            "header-uppercase-hex",  # spec:F5 小写
-            "header-wrong-hex-len",  # 必须 64 hex
-            "b64url-with-padding",
-            "b64url-illegal-char",
-        ],
-    )
-    def test_reject(self, vectors, rule_id):
-        rule = next(r for r in vectors["formatRules"] if r["id"] == rule_id)
-        suite = parse_suite(rule.get("suite", "WOP-RSA3072-SHA256"))
-        with pytest.raises((ProtocolFormatError, UnsupportedSuiteError, ValueError)):
-            check_digest_header(suite, rule["value"])
+    """formatRules 三件套消费（spec:A2/F8）：循环全量 + 未知 id 哨兵 + 条数哨兵。
+
+    本类消费 header-* 子集（check_digest_header 格式层：accept = 格式层接受；
+    reject = 拒绝）；b64url-* 子集由 test_encoding.py 消费（b64url_decode）。
+    """
+
+    def test_sentinels(self, vectors):  # spec:A2 条数哨兵 + 未知 id 哨兵
+        rules = vectors["formatRules"]
+        assert len(rules) == conftest.FORMAT_RULES_COUNT  # 真源向量增删即炸
+        ids = {r["id"] for r in rules}
+        assert ids == conftest.ALL_FORMAT_RULE_IDS  # 新增 id 未显式接入即炸
+
+    def test_header_rules_full_loop(self, vectors):  # spec:A2 全量循环
+        seen = set()
+        for rule in vectors["formatRules"]:  # 循环真源全量，禁止按 id 点名消费
+            if rule["id"] not in conftest.HEADER_RULE_IDS:
+                continue
+            seen.add(rule["id"])
+            suite = parse_suite(rule.get("suite", "WOP-RSA3072-SHA256"))
+            if rule["expect"] == "accept":
+                check_digest_header(suite, rule["value"])  # 正向断言：格式层通过
+            else:
+                with pytest.raises((ProtocolFormatError, UnsupportedSuiteError)):
+                    check_digest_header(suite, rule["value"])
+        assert seen == conftest.HEADER_RULE_IDS  # 子集完备：header-* 一条不漏
 
     def test_crossfamily_is_support_error(self):
         # 跨族标签（I5）单独归为支持类语义（明确拒绝）

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/tests/test_encoding.py

@@ -2,6 +2,7 @@
 """编码层测试：base64url 严格无填充（F7/F6）、小写 hex（F5）、Java URLEncoder 语义（F2）。"""
 import pytest
 
+import conftest
 from wop_sdk.encoding import b64url_decode, b64url_encode, hex_lower, java_urlencode, trimall
 
 
@@ -20,13 +21,6 @@ class TestB64urlStrict:
     def test_encode_uses_url_alphabet(self):
         # 0xFB 0xFF 0xBF → 标准字母表出 "+/+"/，URL 字母表必须是 "-_-_"
         assert b64url_encode(b"\xfb\xff\xbf") == "-_-_"
-    def test_reject_padding_char(self):  # spec:F7 formatRules:b64url-with-padding
-        with pytest.raises(ValueError):
-            b64url_decode("abc=")
-
-    def test_reject_standard_alphabet_plus(self):  # spec:F7 formatRules:b64url-illegal-char
-        with pytest.raises(ValueError):
-            b64url_decode("ab+c")
 
     def test_reject_standard_alphabet_slash(self):
         with pytest.raises(ValueError):
@@ -97,3 +91,35 @@ class TestTrimall:
 
     def test_tabs_newlines_collapse(self):
         assert trimall("a\t\n b") == "a b"
+
+
+class TestFormatRulesB64url:
+    """formatRules b64url 子集三件套消费（spec:A2/F7/D10）：
+    循环全量 + 未知 id 哨兵 + 条数哨兵；语义锚 = Go base64.RawURLEncoding.Strict()
+    （RFC 4648 §3.5 尾随位 canonical）。header-* 子集由 test_digest.py 消费。
+    """
+
+    # accept 向量的正向字节断言（真源 note 标注的解码结果）
+    _ACCEPT_BYTES = {
+        "b64url-trailing-bits-canonical-2": b"\x00",  # AA → 1 字节 0x00
+        "b64url-trailing-bits-canonical-3": b"Ma",  # TWE → 2 字节 0x4D 0x61
+    }
+
+    def test_sentinels(self, vectors):  # spec:A2 条数哨兵 + 未知 id 哨兵
+        rules = vectors["formatRules"]
+        assert len(rules) == conftest.FORMAT_RULES_COUNT  # 真源向量增删即炸
+        ids = {r["id"] for r in rules}
+        assert ids == conftest.ALL_FORMAT_RULE_IDS  # 新增 id 未显式接入即炸
+
+    def test_b64url_rules_full_loop(self, vectors):  # spec:A2 全量循环
+        seen = set()
+        for rule in vectors["formatRules"]:  # 循环真源全量，禁止按 id 点名消费
+            if rule["id"] not in conftest.B64URL_RULE_IDS:
+                continue
+            seen.add(rule["id"])
+            if rule["expect"] == "accept":
+                assert b64url_decode(rule["value"]) == self._ACCEPT_BYTES[rule["id"]]
+            else:
+                with pytest.raises(ValueError):
+                    b64url_decode(rule["value"])
+        assert seen == conftest.B64URL_RULE_IDS  # 子集完备：b64url-* 一条不漏

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/tests/test_envelope.py

@@ -259,6 +259,15 @@ class TestSealOpenL2:
         with pytest.raises(DecryptError):
             open_l2(RSA3072, rsa_pair[1], wire, "abc=")  # F7 严格无填充
 
+    def test_open_dek_payload_invalid_utf8_blurred(self, rsa_pair):
+        # I7：解包成功但 DEK 载荷非 UTF-8 → 与解包失败同归模糊，不得向商户层逃逸
+        dek_b64u = b64url_encode(
+            wrap_dek(RSA3072, rsa_pair[0], b"\xff\xfe\x80", csprng=lambda n: b"\xab" * n)
+        )
+        wire = json.dumps({"encrypted": b64url_encode(b"x" * 48)}).encode()
+        with pytest.raises(DecryptError):
+            open_l2(RSA3072, rsa_pair[1], wire, dek_b64u)
+
     def test_open_cross_family_dek_consistent_error(self, sm2_pair, vectors):
         # RSA 套件 DEK 被塞进 SM 载荷：解包成功、alg 比对在 bulk 解密前明确拒绝
         v = _vec(vectors, "dekPayload", "dek-sm2")

wop_python_sdk-0.1.1/tests/test_transports.py

@@ -0,0 +1,307 @@
+# -*- coding: utf-8 -*-
+"""传输层测试：Transport 协议、urllib 适配器（monkeypatch urlopen）、
+httpx/requests peer 适配器（fake 模块注入）、未装依赖时的清晰报错、
+11MB 响应体上限（边界可过 / 越界即拒 / 流式中断）。"""
+import io
+import sys
+import types
+import urllib.error
+from unittest import mock
+
+import pytest
+
+from wop_sdk.client import RequestDraft
+from wop_sdk.errors import ProtocolFormatError
+from wop_sdk.transports import (
+    MAX_RESPONSE_BYTES,
+    _READ_CHUNK,
+    HttpResponse,
+    UrllibTransport,
+    send_draft,
+)
+from wop_sdk.transports.httpx_transport import HttpxTransport
+from wop_sdk.transports.requests_transport import RequestsTransport
+
+
+class TestSendDraft:
+    def test_url_join_and_pass_through(self):
+        draft = RequestDraft("POST", "/gateway/x", {"x-wop-appkey": "ak"}, b"{}", "L0")
+        captured = {}
+
+        class FakeTransport:
+            def send(self, method, url, headers, body):
+                captured.update(method=method, url=url, headers=headers, body=body)
+                return HttpResponse(200, {}, b"ok")
+
+        resp = send_draft(FakeTransport(), "https://gw.example.com/", draft)
+        assert resp.status == 200 and resp.body == b"ok"
+        assert captured["url"] == "https://gw.example.com/gateway/x"
+        assert captured["method"] == "POST"
+        assert captured["headers"] is draft.headers
+        assert captured["body"] == b"{}"
+
+    def test_no_body_sends_none(self):
+        draft = RequestDraft("GET", "/q", {}, None, "L0")
+
+        class FakeTransport:
+            def send(self, method, url, headers, body):
+                assert body is None
+                return HttpResponse(204, {}, b"")
+
+        send_draft(FakeTransport(), "https://gw", draft)
+
+
+def _ok_response(status=200, body=b'{"ok":1}', headers=None):
+    resp_obj = mock.MagicMock()
+    resp_obj.status = status
+    resp_obj.headers = headers if headers is not None else {}
+    # 流式语义：read(n) 返回至多 n 字节，EOF 返回 b""
+    remaining = memoryview(body)
+
+    def _read(size):
+        nonlocal remaining
+        chunk = bytes(remaining[:size])
+        remaining = remaining[size:]
+        return chunk
+
+    resp_obj.read.side_effect = _read
+    resp_obj.__enter__.return_value = resp_obj
+    resp_obj.__exit__.return_value = False
+    return resp_obj
+
+
+class TestUrllibTransport:
+    def test_success(self):
+        resp_obj = _ok_response(200, b'{"ok":1}', {"Content-Type": "application/json", "X-Wop-Sign": "sig"})
+        with mock.patch("urllib.request.urlopen", return_value=resp_obj):
+            resp = UrllibTransport().send("POST", "https://gw/p", {"a": "b"}, b"body")
+        assert resp.status == 200
+        assert resp.body == b'{"ok":1}'
+        assert resp.headers == {"content-type": "application/json", "x-wop-sign": "sig"}
+
+    def test_http_error_returns_body(self):
+        err = urllib.error.HTTPError(
+            "url", 404, "Not Found", hdrs={"X-E": "1"}, fp=io.BytesIO(b'{"err":1}')
+        )
+        with mock.patch("urllib.request.urlopen", side_effect=err):
+            resp = UrllibTransport().send("GET", "https://gw/p", {}, None)
+        assert resp.status == 404
+        assert resp.body == b'{"err":1}'
+        assert resp.headers == {"x-e": "1"}
+
+    def test_request_headers_and_body_applied(self):
+        resp_obj = _ok_response()
+        with mock.patch("urllib.request.urlopen", return_value=resp_obj) as urlopen:
+            UrllibTransport().send("POST", "https://gw/p", {"x-wop-appkey": "ak"}, b"b")
+        req = urlopen.call_args[0][0]
+        assert req.get_header("X-wop-appkey") == "ak"
+        assert req.data == b"b"
+
+
+class _UrllibLimit:
+    """urllib 上限边界：sized（有限总量）/ endless（无限流）两种 read 侧写。"""
+
+    @staticmethod
+    def _sized_read(total):
+        state = {"remaining": total}
+
+        def read(size):
+            take = min(size, state["remaining"])
+            state["remaining"] -= take
+            return b"x" * take if take else b""
+
+        return read
+
+    @staticmethod
+    def _endless_read(counter):
+        def read(size):
+            counter["count"] += 1
+            return b"x" * size
+
+        return read
+
+
+class TestUrllibTransportLimit:
+    def test_at_limit_passes(self):
+        # 恰 11MB：等于上限不算越界
+        resp_obj = _ok_response(200, b"", {})
+        resp_obj.read.side_effect = _UrllibLimit._sized_read(MAX_RESPONSE_BYTES)
+        with mock.patch("urllib.request.urlopen", return_value=resp_obj):
+            resp = UrllibTransport().send("GET", "https://gw/p", {}, None)
+        assert len(resp.body) == MAX_RESPONSE_BYTES
+
+    def test_over_limit_rejected_immediately(self):
+        reads = {"count": 0}
+        resp_obj = _ok_response(200, b"", {})
+        resp_obj.read.side_effect = _UrllibLimit._endless_read(reads)
+        with mock.patch("urllib.request.urlopen", return_value=resp_obj):
+            with pytest.raises(ProtocolFormatError):
+                UrllibTransport().send("GET", "https://gw/p", {}, None)
+        # 无限流也能返回 → 读取中流式计数生效；恰在累计首次越界的 chunk 处中断
+        assert (reads["count"] - 1) * _READ_CHUNK <= MAX_RESPONSE_BYTES
+        assert reads["count"] * _READ_CHUNK > MAX_RESPONSE_BYTES
+
+
+class _FakeHttpxStream:
+    def __init__(self, status_code=201, headers=None, body=b"resp"):
+        self.status_code = status_code
+        self.headers = headers if headers is not None else {"X-Wop-Sign": "s"}
+        self._body = body
+
+    def iter_bytes(self, chunk_size=None):
+        size = chunk_size or _READ_CHUNK
+        mv = memoryview(self._body)
+        for i in range(0, len(mv), size):
+            yield bytes(mv[i:i + size])
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        return False
+
+
+class _FakeHttpx:
+    def __init__(self):
+        self.calls = []
+
+    def close(self):
+        pass
+
+    def stream(self, method, url, headers=None, content=None):
+        self.calls.append((method, url, headers, content))
+        return _FakeHttpxStream()
+
+
+class TestHttpxTransport:
+    def test_send(self, monkeypatch):
+        fake_mod = types.ModuleType("httpx")
+        fake_client = _FakeHttpx()
+        fake_mod.Client = lambda: fake_client
+        monkeypatch.setitem(sys.modules, "httpx", fake_mod)
+        with HttpxTransport() as t:
+            resp = t.send("POST", "https://gw/p", {"h": "1"}, b"body")
+        assert (resp.status, resp.body, resp.headers) == (201, b"resp", {"x-wop-sign": "s"})
+        assert fake_client.calls[0][2] == {"h": "1"}
+
+    def test_missing_dependency_clear_error(self, monkeypatch):
+        monkeypatch.setitem(sys.modules, "httpx", None)  # import httpx → ImportError
+        with pytest.raises(ImportError, match="httpx"):
+            HttpxTransport()
+
+
+class TestHttpxTransportLimit:
+    def _transport_with(self, monkeypatch, chunks_factory):
+        fake_mod = types.ModuleType("httpx")
+        fake_client = _FakeHttpx()
+        stream = _FakeHttpxStream(body=b"")
+
+        def iter_bytes(chunk_size=None):
+            yield from chunks_factory(chunk_size or _READ_CHUNK)
+
+        stream.iter_bytes = iter_bytes
+        fake_client.stream = lambda *a, **k: stream
+        fake_mod.Client = lambda: fake_client
+        monkeypatch.setitem(sys.modules, "httpx", fake_mod)
+        return HttpxTransport()
+
+    def test_at_limit_passes(self, monkeypatch):
+        t = self._transport_with(monkeypatch, lambda size: [b"x" * MAX_RESPONSE_BYTES])
+        resp = t.send("GET", "https://gw/p", {}, None)
+        assert len(resp.body) == MAX_RESPONSE_BYTES
+
+    def test_over_limit_rejected_immediately(self, monkeypatch):
+        reads = {"count": 0}
+
+        def endless_chunks(size):
+            while True:
+                reads["count"] += 1
+                yield b"x" * size
+
+        t = self._transport_with(monkeypatch, endless_chunks)
+        with pytest.raises(ProtocolFormatError):
+            t.send("GET", "https://gw/p", {}, None)
+        assert (reads["count"] - 1) * _READ_CHUNK <= MAX_RESPONSE_BYTES
+        assert reads["count"] * _READ_CHUNK > MAX_RESPONSE_BYTES
+
+
+class _FakeRequestsResponse:
+    def __init__(self, status_code=200, headers=None, body=b"r"):
+        self.status_code = status_code
+        self.headers = headers if headers is not None else {"X-Wop-Sign": "s"}
+        self._body = body
+        self.closed = False
+
+    def iter_content(self, chunk_size=1):
+        mv = memoryview(self._body)
+        for i in range(0, len(mv), chunk_size):
+            yield bytes(mv[i:i + chunk_size])
+
+    def close(self):
+        self.closed = True
+
+
+class _FakeRequests:
+    def __init__(self, response=None):
+        self.calls = []
+        self.stream_flags = []
+        self._response = response if response is not None else _FakeRequestsResponse()
+
+    def close(self):
+        pass
+
+    def request(self, method, url, headers=None, data=None, stream=False):
+        self.calls.append((method, url, headers, data))
+        self.stream_flags.append(stream)
+        return self._response
+
+
+class TestRequestsTransport:
+    def test_send(self, monkeypatch):
+        fake_mod = types.ModuleType("requests")
+        fake = _FakeRequests()
+        fake_mod.Session = lambda: fake
+        fake_mod.request = fake.request
+        monkeypatch.setitem(sys.modules, "requests", fake_mod)
+        with RequestsTransport() as t:
+            resp = t.send("GET", "https://gw/q", {"h": "1"}, None)
+        assert (resp.status, resp.body) == (200, b"r")
+        assert fake.calls[0][3] is None
+        assert fake.stream_flags == [True]  # 流式拉取，不整体缓冲
+
+    def test_missing_dependency_clear_error(self, monkeypatch):
+        monkeypatch.setitem(sys.modules, "requests", None)
+        with pytest.raises(ImportError, match="requests"):
+            RequestsTransport()
+
+
+class TestRequestsTransportLimit:
+    def test_at_limit_passes(self, monkeypatch):
+        fake_mod = types.ModuleType("requests")
+        fake = _FakeRequests(response=_FakeRequestsResponse(body=b"x" * MAX_RESPONSE_BYTES))
+        fake_mod.Session = lambda: fake
+        monkeypatch.setitem(sys.modules, "requests", fake_mod)
+        with RequestsTransport() as t:
+            resp = t.send("GET", "https://gw/q", {}, None)
+        assert len(resp.body) == MAX_RESPONSE_BYTES
+
+    def test_over_limit_rejected_and_response_closed(self, monkeypatch):
+        reads = {"count": 0}
+
+        def endless_chunks(size):
+            while True:
+                reads["count"] += 1
+                yield b"x" * size
+
+        response = _FakeRequestsResponse()
+        response.iter_content = lambda chunk_size=1: endless_chunks(chunk_size)
+        fake_mod = types.ModuleType("requests")
+        fake = _FakeRequests(response=response)
+        fake_mod.Session = lambda: fake
+        monkeypatch.setitem(sys.modules, "requests", fake_mod)
+        t = RequestsTransport()
+        with pytest.raises(ProtocolFormatError):
+            t.send("GET", "https://gw/q", {}, None)
+        assert response.closed  # 越界中断也释放连接
+        assert (reads["count"] - 1) * _READ_CHUNK <= MAX_RESPONSE_BYTES
+        assert reads["count"] * _READ_CHUNK > MAX_RESPONSE_BYTES

{wop_python_sdk-0.1.0 → wop_python_sdk-0.1.1}/tests/test_transports_real.py

@@ -1,18 +1,21 @@
 # -*- coding: utf-8 -*-
 """真实库 transport 兼容性测试（区别于 test_transports.py 的 fake 模块注入）。
 
-- httpx：真 ``httpx.Client.request`` 全链路，仅以官方 ``MockTransport`` 打桩 socket 层；
-- requests：真 ``Session.request`` → HTTPAdapter.mount 分发，仅覆写 ``HTTPAdapter.send``
-  返回真实 ``requests.models.Response``。
+- httpx：真 ``httpx.Client.stream`` 全链路，仅以官方 ``MockTransport`` 打桩 socket 层；
+- requests：真 ``Session.request(stream=True)`` → HTTPAdapter.mount 分发，仅覆写
+  ``HTTPAdapter.send`` 返回真实 ``requests.models.Response``（raw 提供流式分块）。
 
 被测 API 面 = 适配器实际调用的稳定接口：
-httpx ``Client()/Client.request(method, url, headers=, content=)/close()``（区间 0.24–0.28）；
-requests ``Session()/Session.request(method, url, headers=, data=)/close()``（区间 2.28–最新）。
+httpx ``Client()/Client.stream(method, url, headers=, content=)/Response.iter_bytes(n)/close()``
+（区间 0.24–0.28）；requests ``Session()/Session.request(method, url, headers=, data=,
+stream=)/Response.iter_content(n)/close()``（区间 2.28–最新）。
 CI 覆盖两端：test 矩阵跑最新，oldest-deps 跑下界（httpx 0.24.0 / requests 2.28.0）。
 本地未安装时 importorskip 跳过（fake 模块测试仍兜底结构正确性）。
 """
 import pytest
 
+from wop_sdk.errors import ProtocolFormatError
+from wop_sdk.transports import MAX_RESPONSE_BYTES
 from wop_sdk.transports.httpx_transport import HttpxTransport
 from wop_sdk.transports.requests_transport import RequestsTransport
 
@@ -40,6 +43,16 @@ class TestRealHttpx:
         assert captured["body"] == b"body"
         assert captured["headers"]["x-wop-appkey"] == "ak"  # 真实 Headers 小写键
 
+    def test_over_limit_rejected_while_streaming(self):
+        # 真库 Client.stream + iter_bytes 全链路：11MB+1 的响应在流式读取中被拒
+        def handler(request: httpx.Request) -> httpx.Response:
+            return httpx.Response(200, content=b"x" * (MAX_RESPONSE_BYTES + 1))
+
+        client = httpx.Client(transport=httpx.MockTransport(handler))
+        with HttpxTransport(client=client) as t:
+            with pytest.raises(ProtocolFormatError):
+                t.send("GET", "https://gw/q", {}, None)
+
     def test_get_without_body(self):
         captured = {}
 
@@ -56,13 +69,29 @@ class TestRealHttpx:
 requests_lib = pytest.importorskip("requests", reason="真库测试需要 requests（CI extras 已装）")
 
 
+class _BytesRaw:
+    """urllib3 风格 raw 流：具备 stream()/close() 即可被 requests.iter_content 消费。"""
+
+    def __init__(self, data):
+        self._data = data
+
+    def stream(self, chunk_size, decode_content=False):
+        for i in range(0, len(self._data), chunk_size):
+            yield self._data[i:i + chunk_size]
+
+    def close(self):
+        pass
+
+
 class _StubAdapter(requests_lib.adapters.HTTPAdapter):
     """覆写 send() 返回真实 Response 对象；Session.request 的 headers/data 合并、
-    adapter mount 分发、close() 全部走 requests 真码。"""
+    adapter mount 分发、close() 全部走 requests 真码。响应体经 raw 流式供给
+    （适配器以 stream=True + iter_content 消费）。"""
 
-    def __init__(self, captured):
+    def __init__(self, captured, body=b"r"):
         super().__init__()
         self._captured = captured
+        self._body = body
 
     def send(self, request, **kwargs):
         self._captured["method"] = request.method
@@ -72,7 +101,7 @@ class _StubAdapter(requests_lib.adapters.HTTPAdapter):
         resp = requests_lib.models.Response()
         resp.status_code = 200
         resp.headers["X-Wop-Sign"] = "sig"
-        resp._content = b"r"
+        resp.raw = _BytesRaw(self._body)
         resp.request = request
         return resp
 
@@ -99,3 +128,11 @@ class TestRealRequests:
             resp = t.send("GET", "https://gw/q", {}, None)
         assert resp.status == 200
         assert captured["body"] is None
+
+    def test_over_limit_rejected_while_streaming(self):
+        # 真库 Session.request(stream=True) + iter_content 全链路：越界响应被拒
+        session = requests_lib.Session()
+        session.mount("https://", _StubAdapter({}, body=b"x" * (MAX_RESPONSE_BYTES + 1)))
+        with RequestsTransport(session=session) as t:
+            with pytest.raises(ProtocolFormatError):
+                t.send("GET", "https://gw/q", {}, None)

wop_python_sdk-0.1.0/tests/test_transports.py

@@ -1,144 +0,0 @@
-# -*- coding: utf-8 -*-
-"""传输层测试：Transport 协议、urllib 适配器（monkeypatch urlopen）、
-httpx/requests peer 适配器（fake 模块注入）、未装依赖时的清晰报错。"""
-import io
-import sys
-import types
-import urllib.error
-from unittest import mock
-
-import pytest
-
-from wop_sdk.client import RequestDraft
-from wop_sdk.transports import HttpResponse, UrllibTransport, send_draft
-from wop_sdk.transports.httpx_transport import HttpxTransport
-from wop_sdk.transports.requests_transport import RequestsTransport
-
-
-class TestSendDraft:
-    def test_url_join_and_pass_through(self):
-        draft = RequestDraft("POST", "/gateway/x", {"x-wop-appkey": "ak"}, b"{}", "L0")
-        captured = {}
-
-        class FakeTransport:
-            def send(self, method, url, headers, body):
-                captured.update(method=method, url=url, headers=headers, body=body)
-                return HttpResponse(200, {}, b"ok")
-
-        resp = send_draft(FakeTransport(), "https://gw.example.com/", draft)
-        assert resp.status == 200 and resp.body == b"ok"
-        assert captured["url"] == "https://gw.example.com/gateway/x"
-        assert captured["method"] == "POST"
-        assert captured["headers"] is draft.headers
-        assert captured["body"] == b"{}"
-
-    def test_no_body_sends_none(self):
-        draft = RequestDraft("GET", "/q", {}, None, "L0")
-
-        class FakeTransport:
-            def send(self, method, url, headers, body):
-                assert body is None
-                return HttpResponse(204, {}, b"")
-
-        send_draft(FakeTransport(), "https://gw", draft)
-
-
-def _ok_response(status=200, body=b'{"ok":1}', headers=None):
-    resp_obj = mock.MagicMock()
-    resp_obj.status = status
-    resp_obj.headers = headers if headers is not None else {}
-    resp_obj.read.return_value = body
-    resp_obj.__enter__.return_value = resp_obj
-    resp_obj.__exit__.return_value = False
-    return resp_obj
-
-
-class TestUrllibTransport:
-    def test_success(self):
-        resp_obj = _ok_response(200, b'{"ok":1}', {"Content-Type": "application/json", "X-Wop-Sign": "sig"})
-        with mock.patch("urllib.request.urlopen", return_value=resp_obj):
-            resp = UrllibTransport().send("POST", "https://gw/p", {"a": "b"}, b"body")
-        assert resp.status == 200
-        assert resp.body == b'{"ok":1}'
-        assert resp.headers == {"content-type": "application/json", "x-wop-sign": "sig"}
-
-    def test_http_error_returns_body(self):
-        err = urllib.error.HTTPError(
-            "url", 404, "Not Found", hdrs={"X-E": "1"}, fp=io.BytesIO(b'{"err":1}')
-        )
-        with mock.patch("urllib.request.urlopen", side_effect=err):
-            resp = UrllibTransport().send("GET", "https://gw/p", {}, None)
-        assert resp.status == 404
-        assert resp.body == b'{"err":1}'
-        assert resp.headers == {"x-e": "1"}
-
-    def test_request_headers_and_body_applied(self):
-        resp_obj = _ok_response()
-        with mock.patch("urllib.request.urlopen", return_value=resp_obj) as urlopen:
-            UrllibTransport().send("POST", "https://gw/p", {"x-wop-appkey": "ak"}, b"b")
-        req = urlopen.call_args[0][0]
-        assert req.get_header("X-wop-appkey") == "ak"
-        assert req.data == b"b"
-
-
-class _FakeHttpx:
-    def __init__(self):
-        self.calls = []
-
-    def close(self):
-        pass
-
-    def request(self, method, url, headers=None, content=None):
-        self.calls.append((method, url, headers, content))
-        return types.SimpleNamespace(
-            status_code=201, headers={"X-Wop-Sign": "s"}, content=b"resp"
-        )
-
-
-class TestHttpxTransport:
-    def test_send(self, monkeypatch):
-        fake_mod = types.ModuleType("httpx")
-        fake_client = _FakeHttpx()
-        fake_mod.Client = lambda: fake_client
-        monkeypatch.setitem(sys.modules, "httpx", fake_mod)
-        with HttpxTransport() as t:
-            resp = t.send("POST", "https://gw/p", {"h": "1"}, b"body")
-        assert (resp.status, resp.body, resp.headers) == (201, b"resp", {"x-wop-sign": "s"})
-        assert fake_client.calls[0][2] == {"h": "1"}
-
-    def test_missing_dependency_clear_error(self, monkeypatch):
-        monkeypatch.setitem(sys.modules, "httpx", None)  # import httpx → ImportError
-        with pytest.raises(ImportError, match="httpx"):
-            HttpxTransport()
-
-
-class _FakeRequests:
-    def __init__(self):
-        self.calls = []
-
-    def close(self):
-        pass
-
-    def request(self, method, url, headers=None, data=None):
-        self.calls.append((method, url, headers, data))
-        return types.SimpleNamespace(
-            status_code=200, headers={"X-Wop-Sign": "s"}, content=b"r"
-        )
-
-
-class TestRequestsTransport:
-    def test_send(self, monkeypatch):
-        fake_mod = types.ModuleType("requests")
-        fake = _FakeRequests()
-        fake_mod.Session = lambda: fake
-        fake_mod.request = fake.request
-        monkeypatch.setitem(sys.modules, "requests", fake_mod)
-        with RequestsTransport() as t:
-            resp = t.send("GET", "https://gw/q", {"h": "1"}, None)
-        assert (resp.status, resp.body) == (200, b"r")
-        assert fake.calls[0][3] is None
-
-    def test_missing_dependency_clear_error(self, monkeypatch):
-        monkeypatch.setitem(sys.modules, "requests", None)
-        with pytest.raises(ImportError, match="requests"):
-            RequestsTransport()