xparse-client 0.2.19__py3-none-any.whl → 0.3.0b3__py3-none-any.whl

tests/unit/api/test_local.py

@@ -0,0 +1,231 @@
+"""测试 Local API"""
+
+import httpx
+import pytest
+
+from xparse_client import XParseClient
+from xparse_client.connectors import LocalDestination, LocalSource
+from xparse_client.exceptions import APIError
+from xparse_client.models import ParseConfig, ParseStage
+
+
+@pytest.fixture
+def mock_client(respx_mock):
+    """创建带 mock 的客户端"""
+    client = XParseClient(
+        app_id="test-app-id",
+        secret_code="test-secret"
+    )
+    return client
+
+
+def test_local_api_exists(mock_client):
+    """测试 client.local 属性存在"""
+    assert hasattr(mock_client, 'local')
+    local_api = mock_client.local
+    assert local_api is not None
+
+
+def test_local_api_has_run_workflow(mock_client):
+    """测试 local.run_workflow 方法存在"""
+    local_api = mock_client.local
+    assert hasattr(local_api, 'run_workflow')
+    assert callable(local_api.run_workflow)
+
+
+def test_run_workflow_requires_source(mock_client):
+    """测试 run_workflow 需要 source 参数"""
+    with pytest.raises(TypeError):
+        mock_client.local.run_workflow(
+            destination=LocalDestination(directory="./output"),
+            stages=[]
+        )
+
+
+def test_run_workflow_requires_destination(mock_client):
+    """测试 run_workflow 需要 destination 参数"""
+    with pytest.raises(TypeError):
+        mock_client.local.run_workflow(
+            source=LocalSource(directory="./docs"),
+            stages=[]
+        )
+
+
+def test_run_workflow_requires_stages(mock_client):
+    """测试 run_workflow 需要 stages 参数"""
+    with pytest.raises(TypeError):
+        mock_client.local.run_workflow(
+            source=LocalSource(directory="./docs"),
+            destination=LocalDestination(directory="./output")
+        )
+
+
+def test_run_workflow_single_file_success(mock_client, respx_mock, tmp_path):
+    """测试单文件工作流执行成功"""
+    # 创建测试文件
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
+    test_file = source_dir / "test.txt"
+    test_file.write_text("test content")
+
+    dest_dir = tmp_path / "dest"
+    dest_dir.mkdir()
+
+    # Mock pipeline API
+    respx_mock.post("https://api.textin.com/api/xparse/pipeline").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "elements": [{"element_id": "elem_1", "type": "text", "text": "parsed"}],
+                "record_id": "rec_123",
+            },
+            headers={"x-request-id": "req_123"}
+        )
+    )
+
+    # 执行工作流
+    result = mock_client.local.run_workflow(
+        source=LocalSource(directory=str(source_dir)),
+        destination=LocalDestination(output_dir=str(dest_dir)),
+        stages=[ParseStage(config=ParseConfig(provider="textin"))]
+    )
+
+    # 验证结果
+    assert result.total == 1
+    assert result.success == 1
+    assert result.failed == 0
+    assert len(result.failed_files) == 0
+    assert result.duration > 0
+
+
+def test_run_workflow_multiple_files(mock_client, respx_mock, tmp_path):
+    """测试多文件工作流执行"""
+    # 创建多个测试文件
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
+    for i in range(3):
+        (source_dir / f"test{i}.txt").write_text(f"content {i}")
+
+    dest_dir = tmp_path / "dest"
+    dest_dir.mkdir()
+
+    # Mock pipeline API
+    respx_mock.post("https://api.textin.com/api/xparse/pipeline").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "elements": [{"element_id": "elem_1", "type": "text", "text": "parsed"}],
+                "record_id": "rec_123",
+            }
+        )
+    )
+
+    result = mock_client.local.run_workflow(
+        source=LocalSource(directory=str(source_dir)),
+        destination=LocalDestination(output_dir=str(dest_dir)),
+        stages=[ParseStage(config=ParseConfig(provider="textin"))]
+    )
+
+    assert result.total == 3
+    assert result.success == 3
+    assert result.failed == 0
+
+
+def test_run_workflow_with_api_error_stop(mock_client, respx_mock, tmp_path):
+    """测试 API 错误时停止策略"""
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
+    (source_dir / "test1.txt").write_text("content 1")
+    (source_dir / "test2.txt").write_text("content 2")
+
+    dest_dir = tmp_path / "dest"
+    dest_dir.mkdir()
+
+    # 第一个文件失败
+    respx_mock.post("https://api.textin.com/api/xparse/pipeline").mock(
+        return_value=httpx.Response(500, json={"error": "Server error"})
+    )
+
+    with pytest.raises(APIError):
+        mock_client.local.run_workflow(
+            source=LocalSource(directory=str(source_dir)),
+            destination=LocalDestination(output_dir=str(dest_dir)),
+            stages=[ParseStage(config=ParseConfig(provider="textin"))],
+            on_error="stop"
+        )
+
+
+def test_run_workflow_with_api_error_continue(mock_client, respx_mock, tmp_path):
+    """测试 API 错误时继续策略"""
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
+    (source_dir / "test1.txt").write_text("content 1")
+    (source_dir / "test2.txt").write_text("content 2")
+
+    dest_dir = tmp_path / "dest"
+    dest_dir.mkdir()
+
+    # 第一个文件成功，第二个失败
+    # 注意：HTTP客户端会自动重试，所以我们需要mock足够多的响应
+    responses = [
+        httpx.Response(200, json={
+            "elements": [{"element_id": "elem_1", "type": "text", "text": "parsed"}],
+            "record_id": "rec_123"
+        }),
+        httpx.Response(500, json={"error": "Server error"}),
+        httpx.Response(500, json={"error": "Server error"}),
+        httpx.Response(500, json={"error": "Server error"}),
+        httpx.Response(500, json={"error": "Server error"}),  # 重试3次都失败
+    ]
+    respx_mock.post("https://api.textin.com/api/xparse/pipeline").mock(side_effect=responses)
+
+    result = mock_client.local.run_workflow(
+        source=LocalSource(directory=str(source_dir)),
+        destination=LocalDestination(output_dir=str(dest_dir)),
+        stages=[ParseStage(config=ParseConfig(provider="textin"))],
+        on_error="continue"
+    )
+
+    assert result.total == 2
+    assert result.success == 1
+    assert result.failed == 1
+    assert len(result.failed_files) == 1
+    # 检查失败的是test2
+    assert result.failed_files[0].file_path == "test2.txt"
+    assert "Server error" in result.failed_files[0].error or "500" in result.failed_files[0].error
+
+
+def test_run_workflow_progress_callback(mock_client, respx_mock, tmp_path):
+    """测试进度回调"""
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
+    for i in range(2):
+        (source_dir / f"test{i}.txt").write_text(f"content {i}")
+
+    dest_dir = tmp_path / "dest"
+    dest_dir.mkdir()
+
+    respx_mock.post("https://api.textin.com/api/xparse/pipeline").mock(
+        return_value=httpx.Response(
+            200,
+            json={"elements": [{"element_id": "elem_1", "type": "text", "text": ""}], "record_id": "rec_123"}
+        )
+    )
+
+    # 记录进度回调
+    progress_calls = []
+    def on_progress(current, total, message):
+        progress_calls.append((current, total, message))
+
+    mock_client.local.run_workflow(
+        source=LocalSource(directory=str(source_dir)),
+        destination=LocalDestination(output_dir=str(dest_dir)),
+        stages=[ParseStage(config=ParseConfig(provider="textin"))],
+        progress_callback=on_progress
+    )
+
+    # 验证回调被调用
+    assert len(progress_calls) >= 2
+    assert progress_calls[0][1] == 2  # total
+    assert progress_calls[-1][0] == 2  # 最后一个是 current=2
+

tests/unit/api/test_parse.py

@@ -0,0 +1,374 @@
+"""Parse API 测试"""
+
+from unittest.mock import patch
+
+import httpx
+import pytest
+import respx
+
+from xparse_client import XParseClient
+from xparse_client.exceptions import APIError, RequestTimeoutError
+from xparse_client.models import ParseConfig, ParseResponse
+
+
+class TestParseAPI:
+    """Parse API 测试"""
+
+    @pytest.fixture
+    def client(self, app_id, secret_code, server_url):
+        """创建测试客户端"""
+        return XParseClient(
+            app_id=app_id,
+            secret_code=secret_code,
+            server_url=server_url,
+        )
+
+    @respx.mock
+    def test_partition_success(self, client, sample_pdf_bytes, sample_response_data):
+        """测试同步解析成功"""
+        respx.post(f"{client.config.server_url}/api/xparse/parse/sync").mock(
+            return_value=httpx.Response(200, json=sample_response_data)
+        )
+
+        result = client.parse.partition(
+            file=sample_pdf_bytes,
+            filename="test.pdf",
+        )
+
+        assert isinstance(result, ParseResponse)
+        assert len(result.elements) == 1
+        assert result.elements[0].element_id == "elem_001"
+        assert result.elements[0].type == "text"
+
+    @respx.mock
+    def test_partition_with_config(self, client, sample_pdf_bytes, sample_response_data):
+        """测试带配置的同步解析"""
+        respx.post(f"{client.config.server_url}/api/xparse/parse/sync").mock(
+            return_value=httpx.Response(200, json=sample_response_data)
+        )
+
+        result = client.parse.partition(
+            file=sample_pdf_bytes,
+            filename="test.pdf",
+            config=ParseConfig(provider="textin"),
+        )
+
+        assert isinstance(result, ParseResponse)
+
+    @respx.mock
+    def test_create_async_job(self, client, sample_pdf_bytes):
+        """测试创建异步任务"""
+        respx.post(f"{client.config.server_url}/api/xparse/parse/async").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {"job_id": "job_123"},
+            })
+        )
+
+        result = client.parse.create_async_job(
+            file=sample_pdf_bytes,
+            filename="test.pdf",
+        )
+
+        assert result.job_id == "job_123"
+
+    @respx.mock
+    def test_create_async_job_with_config(self, client, sample_pdf_bytes):
+        """测试创建异步任务（带配置）"""
+        respx.post(f"{client.config.server_url}/api/xparse/parse/async").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {"job_id": "job_456"},
+            })
+        )
+
+        result = client.parse.create_async_job(
+            file=sample_pdf_bytes,
+            filename="test.pdf",
+            config=ParseConfig(provider="textin"),
+        )
+
+        assert result.job_id == "job_456"
+
+    @respx.mock
+    def test_create_async_job_with_webhook(self, client, sample_pdf_bytes):
+        """测试创建异步任务（带 webhook）"""
+        respx.post(f"{client.config.server_url}/api/xparse/parse/async").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {"job_id": "job_789"},
+            })
+        )
+
+        result = client.parse.create_async_job(
+            file=sample_pdf_bytes,
+            filename="test.pdf",
+            webhook="https://example.com/callback",
+        )
+
+        assert result.job_id == "job_789"
+
+    @respx.mock
+    def test_get_result_completed(self, client):
+        """测试获取已完成的任务结果"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "file_id": "file_456",
+                    "status": "completed",
+                    "result_url": "https://example.com/result.json",
+                    "elements": [
+                        {"element_id": "elem_001", "type": "text", "text": "test"}
+                    ],
+                },
+            })
+        )
+
+        result = client.parse.get_result(job_id="job_123")
+
+        assert result.job_id == "job_123"
+        assert result.file_id == "file_456"
+        assert result.status == "completed"
+        assert result.result_url == "https://example.com/result.json"
+        assert result.is_completed
+        assert not result.is_failed
+        assert not result.is_running
+        assert len(result.elements) == 1
+
+    @respx.mock
+    def test_get_result_in_progress(self, client):
+        """测试获取进行中的任务"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "in_progress",
+                },
+            })
+        )
+
+        result = client.parse.get_result(job_id="job_123")
+
+        assert result.status == "in_progress"
+        assert result.is_running
+        assert not result.is_completed
+        assert not result.is_failed
+
+    @respx.mock
+    def test_get_result_scheduled(self, client):
+        """测试获取已调度但未开始的任务"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "scheduled",
+                },
+            })
+        )
+
+        result = client.parse.get_result(job_id="job_123")
+
+        assert result.status == "scheduled"
+        assert result.is_running
+        assert not result.is_completed
+
+    @respx.mock
+    def test_get_result_failed(self, client):
+        """测试获取失败的任务"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "failed",
+                    "error_message": "处理失败",
+                },
+            })
+        )
+
+        result = client.parse.get_result(job_id="job_123")
+
+        assert result.status == "failed"
+        assert result.is_failed
+        assert not result.is_running
+        assert result.error_message == "处理失败"
+
+    @respx.mock
+    @patch('time.sleep')
+    def test_wait_for_result_success(self, mock_sleep, client):
+        """测试等待任务完成（成功）"""
+        # 第一次查询: 进行中
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            side_effect=[
+                httpx.Response(200, json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "in_progress",
+                    },
+                }),
+                httpx.Response(200, json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "completed",
+                        "elements": [
+                            {"element_id": "elem_001", "type": "text", "text": "test"}
+                        ],
+                    },
+                }),
+            ]
+        )
+
+        result = client.parse.wait_for_result(
+            job_id="job_123",
+            poll_interval_seconds=1,
+        )
+
+        assert result.is_completed
+        assert len(result.elements) == 1
+        # 验证 sleep 被调用了一次
+        assert mock_sleep.call_count == 1
+        mock_sleep.assert_called_with(1)
+
+    @respx.mock
+    @patch('time.sleep')
+    def test_wait_for_result_immediate_completion(self, mock_sleep, client):
+        """测试等待任务完成（立即完成）"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "completed",
+                    "elements": [],
+                },
+            })
+        )
+
+        result = client.parse.wait_for_result(job_id="job_123")
+
+        assert result.is_completed
+        # 不应该 sleep
+        assert mock_sleep.call_count == 0
+
+    @respx.mock
+    @patch('time.sleep')
+    def test_wait_for_result_task_failed(self, mock_sleep, client):
+        """测试等待任务完成（任务失败）"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "failed",
+                    "error_message": "文件格式不支持",
+                },
+            })
+        )
+
+        with pytest.raises(APIError) as exc_info:
+            client.parse.wait_for_result(job_id="job_123")
+
+        assert "解析任务失败" in str(exc_info.value)
+        assert "文件格式不支持" in str(exc_info.value)
+
+    @respx.mock
+    @patch('time.time')
+    @patch('time.sleep')
+    def test_wait_for_result_timeout(self, mock_sleep, mock_time, client):
+        """测试等待任务超时"""
+        # Mock time.time() 返回递增的时间
+        mock_time.side_effect = [0, 5, 11]  # 第一次0秒，第二次5秒，第三次11秒
+
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "in_progress",
+                },
+            })
+        )
+
+        with pytest.raises(RequestTimeoutError) as exc_info:
+            client.parse.wait_for_result(
+                job_id="job_123",
+                timeout_seconds=10,
+                poll_interval_seconds=5,
+            )
+
+        assert "等待解析任务超时" in str(exc_info.value)
+        assert "job_123" in str(exc_info.value)
+
+    @respx.mock
+    @patch('time.sleep')
+    def test_wait_for_result_multiple_polls(self, mock_sleep, client):
+        """测试多次轮询后完成"""
+        # 模拟 3 次轮询: scheduled -> in_progress -> completed
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            side_effect=[
+                httpx.Response(200, json={
+                    "code": 200,
+                    "data": {"job_id": "job_123", "status": "scheduled"},
+                }),
+                httpx.Response(200, json={
+                    "code": 200,
+                    "data": {"job_id": "job_123", "status": "in_progress"},
+                }),
+                httpx.Response(200, json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "completed",
+                        "elements": [],
+                    },
+                }),
+            ]
+        )
+
+        result = client.parse.wait_for_result(
+            job_id="job_123",
+            poll_interval_seconds=2,
+        )
+
+        assert result.is_completed
+        # 应该 sleep 2 次（前两次轮询后）
+        assert mock_sleep.call_count == 2
+
+    @respx.mock
+    def test_wait_for_result_custom_intervals(self, client):
+        """测试自定义轮询参数"""
+        respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
+            return_value=httpx.Response(200, json={
+                "code": 200,
+                "data": {
+                    "job_id": "job_123",
+                    "status": "completed",
+                    "elements": [],
+                },
+            })
+        )
+
+        result = client.parse.wait_for_result(
+            job_id="job_123",
+            timeout_seconds=300,
+            poll_interval_seconds=10,
+        )
+
+        assert result.is_completed
+
+    def test_partition_async_removed(self, client):
+        """测试 partition_async 方法已被移除"""
+        assert not hasattr(client.parse, 'partition_async')
+
+    def test_async_job_methods_still_exist(self, client):
+        """测试服务端异步任务方法仍然存在"""
+        assert hasattr(client.parse, 'create_async_job')
+        assert hasattr(client.parse, 'get_result')
+        assert hasattr(client.parse, 'wait_for_result')
+