348 lines
12 KiB
Python
348 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
import os
|
|
import json
|
|
import uuid
|
|
import time
|
|
import httpx
|
|
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
from tests.logger import get_api_logger
|
|
from framework.core.exceptions import TokenExpiredError, APIError
|
|
|
|
|
|
class APIClient:
|
|
def __init__(
|
|
self,
|
|
base_url: str,
|
|
token: str = None,
|
|
cookie: str = None,
|
|
cookies: dict = None,
|
|
headers: dict = None,
|
|
proxy_url: str = None,
|
|
):
|
|
"""独立的 API 客户端
|
|
|
|
Args:
|
|
base_url: 基础 URL (e.g., "https://cloud-fat.d-robotics.cc")
|
|
token: 认证 token
|
|
cookie: 认证 cookie 字符串(兼容 framework 调用方)
|
|
cookies: cookies 字典
|
|
headers: 自定义 HTTP 头
|
|
proxy_url: 代理 URL
|
|
"""
|
|
_parsed = urlparse(base_url)
|
|
self.base_url = f"{_parsed.scheme}://{_parsed.netloc}"
|
|
self.token = token
|
|
self.cookie = cookie or ""
|
|
self.cookies = cookies or {}
|
|
self.headers = headers or {
|
|
"Content-Type": "application/json",
|
|
"Accept": "application/json",
|
|
"language": "zh-CN",
|
|
"sourceApp": "dataCopilot",
|
|
}
|
|
if token:
|
|
self.headers["Authorization"] = token
|
|
self._proxy_url = proxy_url or (
|
|
os.environ.get("all_proxy")
|
|
or os.environ.get("HTTP_PROXY")
|
|
or os.environ.get("http_proxy")
|
|
or ""
|
|
)
|
|
self.logger = get_api_logger()
|
|
|
|
@classmethod
|
|
def from_page(cls, page) -> "APIClient":
|
|
"""工厂方法:从 Page 创建实例(向后兼容)"""
|
|
from config.settings import config
|
|
|
|
# Strip path from BASE_URL - httpx base_url with path causes wrong URL joining
|
|
_parsed = urlparse(config.BASE_URL)
|
|
base_url = f"{_parsed.scheme}://{_parsed.netloc}"
|
|
|
|
# 提取 cookies
|
|
cookies = {c["name"]: c["value"] for c in page.context.cookies()}
|
|
|
|
# 提取 token
|
|
token = None
|
|
try:
|
|
token = page.evaluate('() => localStorage.getItem("token")')
|
|
except Exception:
|
|
pass
|
|
|
|
# 提取代理
|
|
proxy_url = (
|
|
os.environ.get("all_proxy")
|
|
or os.environ.get("HTTP_PROXY")
|
|
or os.environ.get("http_proxy")
|
|
or ""
|
|
)
|
|
|
|
return cls(base_url=base_url, token=token, cookies=cookies, proxy_url=proxy_url)
|
|
|
|
def _log_request(self, method: str, url: str, **kwargs):
|
|
"""记录 API 请求日志"""
|
|
parts = [f"[请求] {method.upper()} {url}"]
|
|
if kwargs.get("json"):
|
|
parts.append(f"[请求体] {json.dumps(kwargs['json'], ensure_ascii=False)}")
|
|
if kwargs.get("params"):
|
|
parts.append(f"[查询参数] {kwargs['params']}")
|
|
if kwargs.get("data"):
|
|
parts.append(f"[表单数据] {kwargs['data']}")
|
|
self.logger.debug(" | ".join(parts))
|
|
|
|
def _log_response(self, response: httpx.Response, duration_ms: float):
|
|
"""记录 API 响应日志"""
|
|
parts = [
|
|
f"[响应状态] HTTP {response.status_code}",
|
|
f"[响应耗时] {duration_ms:.0f}ms",
|
|
]
|
|
try:
|
|
resp_json = response.json()
|
|
parts.append(
|
|
f"[响应体] {json.dumps(self._redact_sensitive(resp_json), ensure_ascii=False)}"
|
|
)
|
|
except Exception:
|
|
parts.append(f"[响应体] {response.text[:500] if response.text else '(空)'}")
|
|
self.logger.debug(" | ".join(parts))
|
|
|
|
def _redact_sensitive(self, value):
|
|
"""Redact sensitive values before logging API payloads."""
|
|
sensitive_keys = {"password", "token", "authorization", "cookie", "secret"}
|
|
if isinstance(value, dict):
|
|
return {
|
|
k: "***REDACTED***" if k.lower() in sensitive_keys else self._redact_sensitive(v)
|
|
for k, v in value.items()
|
|
}
|
|
if isinstance(value, list):
|
|
return [self._redact_sensitive(item) for item in value]
|
|
return value
|
|
|
|
def _assert_not_auth_error(self, response: httpx.Response) -> None:
|
|
"""Fail fast when the platform returns a business-level auth error."""
|
|
try:
|
|
payload = response.json()
|
|
except Exception:
|
|
return
|
|
message = str(payload.get("message", "")).lower()
|
|
location = str(payload.get("location", "")).lower()
|
|
if (
|
|
payload.get("status") == 10002
|
|
or "token invalid" in message
|
|
or "sso-" in location
|
|
):
|
|
raise AssertionError(
|
|
f"API authentication failed: status={payload.get('status')}, "
|
|
f"message={payload.get('message')}"
|
|
)
|
|
|
|
def get_common_headers(self, referer_path: str = "") -> dict:
|
|
"""构建通用请求头(兼容 framework 调用方)"""
|
|
return {
|
|
"accept": "application/json, text/plain, */*",
|
|
"accept-language": "zh-CN,zh;q=0.9",
|
|
"authorization": self.token or "",
|
|
"cookie": self.cookie,
|
|
"origin": self.base_url,
|
|
"referer": f"{self.base_url}{referer_path}",
|
|
"sourceapp": "artificer",
|
|
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
|
|
"x-request-id": uuid.uuid4().hex[:21],
|
|
}
|
|
|
|
def request(self, method: str, endpoint: str, headers: dict = None, **kwargs) -> dict:
|
|
"""兼容 BaseAPI 调用方式的请求方法,返回解析后的 JSON dict"""
|
|
if headers is None:
|
|
headers = self.get_common_headers()
|
|
response = self._request(method, endpoint, headers=headers, **kwargs)
|
|
return self._check_response(response, endpoint)
|
|
|
|
def _check_response(self, response: httpx.Response, step_name: str) -> dict:
|
|
"""检查 HTTP 状态码和业务状态,返回解析后的 JSON"""
|
|
if response.status_code in (401, 403):
|
|
raise TokenExpiredError(f"[{step_name}] HTTP {response.status_code}: 认证失败")
|
|
if response.status_code < 200 or response.status_code >= 300:
|
|
raise APIError(f"[{step_name}] HTTP {response.status_code}: {response.text}")
|
|
|
|
try:
|
|
data = response.json()
|
|
except Exception:
|
|
raise APIError(f"[{step_name}] 非 JSON 响应: {response.text}")
|
|
|
|
body_status = data.get("status", 0)
|
|
if body_status != 0:
|
|
msg = data.get("message", "")
|
|
if body_status in (401, 403) or "token" in msg.lower():
|
|
raise TokenExpiredError(f"[{step_name}] 认证失效: {msg}")
|
|
raise APIError(f"[{step_name}] 业务错误: {msg}")
|
|
|
|
return data
|
|
|
|
def _client(self, timeout=30.0, upload=False):
|
|
# For multipart uploads, exclude Content-Type so httpx can set it automatically
|
|
if upload:
|
|
headers = {
|
|
k: v for k, v in self.headers.items() if k.lower() != "content-type"
|
|
}
|
|
else:
|
|
headers = self.headers
|
|
opts = dict(
|
|
base_url=self.base_url,
|
|
cookies=self.cookies,
|
|
headers=headers,
|
|
timeout=timeout,
|
|
)
|
|
if self._proxy_url:
|
|
opts["transport"] = httpx.HTTPTransport(
|
|
proxy=httpx.Proxy(url=self._proxy_url)
|
|
)
|
|
return httpx.Client(**opts)
|
|
|
|
def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
|
|
"""通用 HTTP 请求方法
|
|
|
|
Args:
|
|
method: HTTP 方法 (GET/POST/PUT/DELETE)
|
|
path: 请求路径 (相对于 base_url)
|
|
**kwargs: 传递给 httpx 的额外参数
|
|
|
|
Returns:
|
|
httpx.Response: HTTP 响应对象
|
|
"""
|
|
url = f"{self.base_url}{path}"
|
|
self._log_request(method, url, **kwargs)
|
|
start_time = time.time()
|
|
with self._client() as client:
|
|
response = client.request(method, path, **kwargs)
|
|
duration_ms = (time.time() - start_time) * 1000
|
|
self._log_response(response, duration_ms)
|
|
self._assert_not_auth_error(response)
|
|
return response
|
|
|
|
def get(self, path, **kwargs):
|
|
return self._request("GET", path, **kwargs)
|
|
|
|
def post(self, path, **kwargs):
|
|
return self._request("POST", path, **kwargs)
|
|
|
|
def put(self, path, **kwargs):
|
|
return self._request("PUT", path, **kwargs)
|
|
|
|
def delete(self, path, **kwargs):
|
|
return self._request("DELETE", path, **kwargs)
|
|
|
|
def upload_file(
|
|
self, path: str, file_path: str, file_field: str = "file", **kwargs
|
|
):
|
|
file_path_obj = Path(file_path)
|
|
if not file_path_obj.exists():
|
|
raise FileNotFoundError(f"File not found: {file_path}")
|
|
|
|
url = f"{self.base_url}{path}"
|
|
self.logger.debug(
|
|
f"[请求] POST {url} | [上传文件] {file_path_obj.name} ({file_path_obj.stat().st_size} bytes)"
|
|
)
|
|
|
|
start_time = time.time()
|
|
with open(file_path_obj, "rb") as f:
|
|
files = {file_field: (file_path_obj.name, f, "application/octet-stream")}
|
|
headers = {"Accept": "application/json"}
|
|
headers.update(kwargs.pop("headers", {}))
|
|
|
|
with self._client(timeout=60.0, upload=True) as client:
|
|
response = client.post(path, files=files, **kwargs)
|
|
|
|
duration_ms = (time.time() - start_time) * 1000
|
|
self._log_response(response, duration_ms)
|
|
return response
|
|
|
|
def upload_bytes(
|
|
self,
|
|
path: str,
|
|
file_name: str,
|
|
file_bytes: bytes,
|
|
file_field: str = "file",
|
|
**kwargs,
|
|
):
|
|
url = f"{self.base_url}{path}"
|
|
self.logger.debug(
|
|
f"[请求] POST {url} | [上传字节] {file_name} ({len(file_bytes)} bytes)"
|
|
)
|
|
|
|
files = {file_field: (file_name, file_bytes, "application/octet-stream")}
|
|
headers = {"Accept": "application/json"}
|
|
headers.update(kwargs.pop("headers", {}))
|
|
|
|
start_time = time.time()
|
|
with self._client(timeout=60.0, upload=True) as client:
|
|
response = client.post(path, files=files, **kwargs)
|
|
|
|
duration_ms = (time.time() - start_time) * 1000
|
|
self._log_response(response, duration_ms)
|
|
return response
|
|
|
|
def upload_form(
|
|
self,
|
|
path: str,
|
|
file_name: str,
|
|
file_bytes: bytes,
|
|
form_data: dict | None = None,
|
|
file_field: str = "file",
|
|
**kwargs,
|
|
):
|
|
"""Multipart upload with extra form fields (e.g. path).
|
|
Uses upload client (no Content-Type override) so httpx sets multipart boundary correctly.
|
|
"""
|
|
url = f"{self.base_url}{path}"
|
|
parts = [
|
|
f"[请求] POST {url}",
|
|
f"[上传表单] {file_name} ({len(file_bytes)} bytes)",
|
|
]
|
|
if form_data:
|
|
parts.append(f"[表单字段] {json.dumps(form_data, ensure_ascii=False)}")
|
|
self.logger.debug(" | ".join(parts))
|
|
|
|
files: dict = {file_field: (file_name, file_bytes, "text/plain")}
|
|
if form_data:
|
|
for k, v in form_data.items():
|
|
files[k] = (None, v)
|
|
|
|
start_time = time.time()
|
|
with self._client(timeout=60.0, upload=True) as client:
|
|
response = client.post(path, files=files, **kwargs)
|
|
|
|
duration_ms = (time.time() - start_time) * 1000
|
|
self._log_response(response, duration_ms)
|
|
return response
|
|
|
|
|
|
def ensure_auth_token(client: "APIClient", page=None) -> None:
|
|
"""确保 API 客户端拥有有效的 Authorization token。
|
|
|
|
按优先级尝试:
|
|
1. 从 page localStorage 读取 token
|
|
2. 从 .auth/state.json 文件读取 token
|
|
|
|
Args:
|
|
client: APIClient 实例
|
|
page: Playwright Page 对象(可选,优先使用)
|
|
"""
|
|
if client.headers.get("Authorization"):
|
|
return
|
|
# 优先从 page localStorage 获取
|
|
if page is not None:
|
|
try:
|
|
token = page.evaluate('() => localStorage.getItem("token")')
|
|
if token:
|
|
client.headers["Authorization"] = token
|
|
return
|
|
except Exception:
|
|
pass
|
|
# 降级:从 auth state 文件加载
|
|
from tests.conftest_auth import _get_token_from_auth_state
|
|
|
|
token = _get_token_from_auth_state()
|
|
if token:
|
|
client.headers["Authorization"] = token
|