638 lines
21 KiB
Python
638 lines
21 KiB
Python
"""
|
|
Tool_OCR - Export Service Unit Tests
|
|
Tests for app/services/export_service.py
|
|
"""
|
|
|
|
import pytest
|
|
import json
|
|
import zipfile
|
|
from pathlib import Path
|
|
from unittest.mock import Mock, patch, MagicMock
|
|
from datetime import datetime
|
|
|
|
import pandas as pd
|
|
|
|
from app.services.export_service import ExportService, ExportError
|
|
from app.models.ocr import FileStatus
|
|
|
|
|
|
@pytest.fixture
|
|
def export_service():
|
|
"""Create an ExportService instance"""
|
|
return ExportService()
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_ocr_result(temp_dir):
|
|
"""Create a mock OCRResult with markdown file"""
|
|
# Create mock markdown file
|
|
md_file = temp_dir / "test_result.md"
|
|
md_file.write_text("# Test Document\n\nThis is test content.", encoding="utf-8")
|
|
|
|
# Create mock result
|
|
result = Mock()
|
|
result.id = 1
|
|
result.markdown_path = str(md_file)
|
|
result.json_path = None
|
|
result.detected_language = "zh"
|
|
result.total_text_regions = 10
|
|
result.average_confidence = 0.95
|
|
result.layout_data = {"elements": [{"type": "text"}]}
|
|
result.images_metadata = []
|
|
|
|
# Mock file
|
|
result.file = Mock()
|
|
result.file.id = 1
|
|
result.file.original_filename = "test.png"
|
|
result.file.file_format = "png"
|
|
result.file.file_size = 1024
|
|
result.file.processing_time = 2.5
|
|
|
|
return result
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_db():
|
|
"""Create a mock database session"""
|
|
return Mock()
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExportServiceInit:
|
|
"""Test ExportService initialization"""
|
|
|
|
def test_init(self, export_service):
|
|
"""Test export service initialization"""
|
|
assert export_service is not None
|
|
assert export_service.pdf_generator is not None
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestApplyFilters:
|
|
"""Test filter application"""
|
|
|
|
def test_apply_filters_confidence_threshold(self, export_service):
|
|
"""Test confidence threshold filter"""
|
|
result1 = Mock()
|
|
result1.average_confidence = 0.95
|
|
result1.file = Mock()
|
|
result1.file.original_filename = "test1.png"
|
|
|
|
result2 = Mock()
|
|
result2.average_confidence = 0.75
|
|
result2.file = Mock()
|
|
result2.file.original_filename = "test2.png"
|
|
|
|
result3 = Mock()
|
|
result3.average_confidence = 0.85
|
|
result3.file = Mock()
|
|
result3.file.original_filename = "test3.png"
|
|
|
|
results = [result1, result2, result3]
|
|
filters = {"confidence_threshold": 0.80}
|
|
|
|
filtered = export_service.apply_filters(results, filters)
|
|
|
|
assert len(filtered) == 2
|
|
assert result1 in filtered
|
|
assert result3 in filtered
|
|
assert result2 not in filtered
|
|
|
|
def test_apply_filters_filename_pattern(self, export_service):
|
|
"""Test filename pattern filter"""
|
|
result1 = Mock()
|
|
result1.average_confidence = 0.95
|
|
result1.file = Mock()
|
|
result1.file.original_filename = "invoice_2024.png"
|
|
|
|
result2 = Mock()
|
|
result2.average_confidence = 0.95
|
|
result2.file = Mock()
|
|
result2.file.original_filename = "receipt.png"
|
|
|
|
results = [result1, result2]
|
|
filters = {"filename_pattern": "invoice"}
|
|
|
|
filtered = export_service.apply_filters(results, filters)
|
|
|
|
assert len(filtered) == 1
|
|
assert result1 in filtered
|
|
|
|
def test_apply_filters_language(self, export_service):
|
|
"""Test language filter"""
|
|
result1 = Mock()
|
|
result1.detected_language = "zh"
|
|
result1.average_confidence = 0.95
|
|
result1.file = Mock()
|
|
result1.file.original_filename = "chinese.png"
|
|
|
|
result2 = Mock()
|
|
result2.detected_language = "en"
|
|
result2.average_confidence = 0.95
|
|
result2.file = Mock()
|
|
result2.file.original_filename = "english.png"
|
|
|
|
results = [result1, result2]
|
|
filters = {"language": "zh"}
|
|
|
|
filtered = export_service.apply_filters(results, filters)
|
|
|
|
assert len(filtered) == 1
|
|
assert result1 in filtered
|
|
|
|
def test_apply_filters_combined(self, export_service):
|
|
"""Test multiple filters combined"""
|
|
result1 = Mock()
|
|
result1.detected_language = "zh"
|
|
result1.average_confidence = 0.95
|
|
result1.file = Mock()
|
|
result1.file.original_filename = "invoice_chinese.png"
|
|
|
|
result2 = Mock()
|
|
result2.detected_language = "zh"
|
|
result2.average_confidence = 0.75
|
|
result2.file = Mock()
|
|
result2.file.original_filename = "invoice_low.png"
|
|
|
|
result3 = Mock()
|
|
result3.detected_language = "en"
|
|
result3.average_confidence = 0.95
|
|
result3.file = Mock()
|
|
result3.file.original_filename = "invoice_english.png"
|
|
|
|
results = [result1, result2, result3]
|
|
filters = {
|
|
"confidence_threshold": 0.80,
|
|
"language": "zh",
|
|
"filename_pattern": "invoice"
|
|
}
|
|
|
|
filtered = export_service.apply_filters(results, filters)
|
|
|
|
assert len(filtered) == 1
|
|
assert result1 in filtered
|
|
|
|
def test_apply_filters_no_filters(self, export_service):
|
|
"""Test with no filters applied"""
|
|
results = [Mock(), Mock(), Mock()]
|
|
filtered = export_service.apply_filters(results, {})
|
|
|
|
assert len(filtered) == len(results)
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExportToTXT:
|
|
"""Test TXT export"""
|
|
|
|
def test_export_to_txt_basic(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test basic TXT export"""
|
|
output_path = temp_dir / "output.txt"
|
|
|
|
result_path = export_service.export_to_txt([mock_ocr_result], output_path)
|
|
|
|
assert result_path.exists()
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert "Test Document" in content
|
|
assert "test content" in content
|
|
|
|
def test_export_to_txt_with_line_numbers(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test TXT export with line numbers"""
|
|
output_path = temp_dir / "output.txt"
|
|
formatting = {"add_line_numbers": True}
|
|
|
|
result_path = export_service.export_to_txt(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
formatting=formatting
|
|
)
|
|
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert "|" in content # Line number separator
|
|
|
|
def test_export_to_txt_with_metadata(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test TXT export with metadata headers"""
|
|
output_path = temp_dir / "output.txt"
|
|
formatting = {"include_metadata": True}
|
|
|
|
result_path = export_service.export_to_txt(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
formatting=formatting
|
|
)
|
|
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert "文件:" in content
|
|
assert "test.png" in content
|
|
assert "信心度:" in content
|
|
|
|
def test_export_to_txt_with_grouping(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test TXT export with file grouping"""
|
|
output_path = temp_dir / "output.txt"
|
|
formatting = {"group_by_filename": True}
|
|
|
|
result_path = export_service.export_to_txt(
|
|
[mock_ocr_result, mock_ocr_result],
|
|
output_path,
|
|
formatting=formatting
|
|
)
|
|
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert "-" * 80 in content # Separator
|
|
|
|
def test_export_to_txt_missing_markdown(self, export_service, temp_dir):
|
|
"""Test TXT export with missing markdown file"""
|
|
result = Mock()
|
|
result.id = 1
|
|
result.markdown_path = "/nonexistent/path.md"
|
|
result.file = Mock()
|
|
result.file.original_filename = "test.png"
|
|
|
|
output_path = temp_dir / "output.txt"
|
|
|
|
# Should not fail, just skip the file
|
|
result_path = export_service.export_to_txt([result], output_path)
|
|
assert result_path.exists()
|
|
|
|
def test_export_to_txt_creates_parent_directories(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test that export creates necessary parent directories"""
|
|
output_path = temp_dir / "subdir" / "output.txt"
|
|
|
|
result_path = export_service.export_to_txt([mock_ocr_result], output_path)
|
|
|
|
assert result_path.exists()
|
|
assert result_path.parent.exists()
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExportToJSON:
|
|
"""Test JSON export"""
|
|
|
|
def test_export_to_json_basic(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test basic JSON export"""
|
|
output_path = temp_dir / "output.json"
|
|
|
|
result_path = export_service.export_to_json([mock_ocr_result], output_path)
|
|
|
|
assert result_path.exists()
|
|
data = json.loads(result_path.read_text(encoding="utf-8"))
|
|
|
|
assert "export_time" in data
|
|
assert data["total_files"] == 1
|
|
assert len(data["results"]) == 1
|
|
assert data["results"][0]["filename"] == "test.png"
|
|
assert data["results"][0]["average_confidence"] == 0.95
|
|
|
|
def test_export_to_json_with_layout(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test JSON export with layout data"""
|
|
output_path = temp_dir / "output.json"
|
|
|
|
result_path = export_service.export_to_json(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
include_layout=True
|
|
)
|
|
|
|
data = json.loads(result_path.read_text(encoding="utf-8"))
|
|
assert "layout_data" in data["results"][0]
|
|
|
|
def test_export_to_json_without_layout(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test JSON export without layout data"""
|
|
output_path = temp_dir / "output.json"
|
|
|
|
result_path = export_service.export_to_json(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
include_layout=False
|
|
)
|
|
|
|
data = json.loads(result_path.read_text(encoding="utf-8"))
|
|
assert "layout_data" not in data["results"][0]
|
|
|
|
def test_export_to_json_multiple_results(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test JSON export with multiple results"""
|
|
output_path = temp_dir / "output.json"
|
|
|
|
result_path = export_service.export_to_json(
|
|
[mock_ocr_result, mock_ocr_result],
|
|
output_path
|
|
)
|
|
|
|
data = json.loads(result_path.read_text(encoding="utf-8"))
|
|
assert data["total_files"] == 2
|
|
assert len(data["results"]) == 2
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExportToExcel:
|
|
"""Test Excel export"""
|
|
|
|
def test_export_to_excel_basic(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test basic Excel export"""
|
|
output_path = temp_dir / "output.xlsx"
|
|
|
|
result_path = export_service.export_to_excel([mock_ocr_result], output_path)
|
|
|
|
assert result_path.exists()
|
|
df = pd.read_excel(result_path)
|
|
assert len(df) == 1
|
|
assert "文件名" in df.columns
|
|
assert df.iloc[0]["文件名"] == "test.png"
|
|
|
|
def test_export_to_excel_with_confidence(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test Excel export with confidence scores"""
|
|
output_path = temp_dir / "output.xlsx"
|
|
|
|
result_path = export_service.export_to_excel(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
include_confidence=True
|
|
)
|
|
|
|
df = pd.read_excel(result_path)
|
|
assert "平均信心度" in df.columns
|
|
|
|
def test_export_to_excel_without_processing_time(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test Excel export without processing time"""
|
|
output_path = temp_dir / "output.xlsx"
|
|
|
|
result_path = export_service.export_to_excel(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
include_processing_time=False
|
|
)
|
|
|
|
df = pd.read_excel(result_path)
|
|
assert "處理時間(秒)" not in df.columns
|
|
|
|
def test_export_to_excel_long_content_truncation(self, export_service, temp_dir):
|
|
"""Test that long content is truncated in Excel"""
|
|
# Create result with long content
|
|
md_file = temp_dir / "long.md"
|
|
md_file.write_text("x" * 2000, encoding="utf-8")
|
|
|
|
result = Mock()
|
|
result.id = 1
|
|
result.markdown_path = str(md_file)
|
|
result.detected_language = "zh"
|
|
result.total_text_regions = 10
|
|
result.average_confidence = 0.95
|
|
result.file = Mock()
|
|
result.file.original_filename = "long.png"
|
|
result.file.file_format = "png"
|
|
result.file.file_size = 1024
|
|
result.file.processing_time = 1.0
|
|
|
|
output_path = temp_dir / "output.xlsx"
|
|
result_path = export_service.export_to_excel([result], output_path)
|
|
|
|
df = pd.read_excel(result_path)
|
|
content = df.iloc[0]["提取內容"]
|
|
assert "..." in content
|
|
assert len(content) <= 1004 # 1000 + "..."
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExportToMarkdown:
|
|
"""Test Markdown export"""
|
|
|
|
def test_export_to_markdown_combined(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test combined Markdown export"""
|
|
output_path = temp_dir / "combined.md"
|
|
|
|
result_path = export_service.export_to_markdown(
|
|
[mock_ocr_result],
|
|
output_path,
|
|
combine=True
|
|
)
|
|
|
|
assert result_path.exists()
|
|
assert result_path.is_file()
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert "test.png" in content
|
|
assert "Test Document" in content
|
|
|
|
def test_export_to_markdown_separate(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test separate Markdown export"""
|
|
output_dir = temp_dir / "markdown_files"
|
|
|
|
result_path = export_service.export_to_markdown(
|
|
[mock_ocr_result],
|
|
output_dir,
|
|
combine=False
|
|
)
|
|
|
|
assert result_path.exists()
|
|
assert result_path.is_dir()
|
|
files = list(result_path.glob("*.md"))
|
|
assert len(files) == 1
|
|
|
|
def test_export_to_markdown_multiple_files(self, export_service, mock_ocr_result, temp_dir):
|
|
"""Test Markdown export with multiple files"""
|
|
output_path = temp_dir / "combined.md"
|
|
|
|
result_path = export_service.export_to_markdown(
|
|
[mock_ocr_result, mock_ocr_result],
|
|
output_path,
|
|
combine=True
|
|
)
|
|
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert content.count("---") >= 1 # Separators
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestExportToPDF:
|
|
"""Test PDF export"""
|
|
|
|
@patch.object(ExportService, '__init__', lambda self: None)
|
|
def test_export_to_pdf_success(self, mock_ocr_result, temp_dir):
|
|
"""Test successful PDF export"""
|
|
from app.services.pdf_generator import PDFGenerator
|
|
|
|
service = ExportService()
|
|
service.pdf_generator = Mock(spec=PDFGenerator)
|
|
service.pdf_generator.generate_pdf = Mock(return_value=temp_dir / "output.pdf")
|
|
|
|
output_path = temp_dir / "output.pdf"
|
|
|
|
result_path = service.export_to_pdf(mock_ocr_result, output_path)
|
|
|
|
service.pdf_generator.generate_pdf.assert_called_once()
|
|
call_kwargs = service.pdf_generator.generate_pdf.call_args[1]
|
|
assert call_kwargs["css_template"] == "default"
|
|
|
|
@patch.object(ExportService, '__init__', lambda self: None)
|
|
def test_export_to_pdf_with_custom_template(self, mock_ocr_result, temp_dir):
|
|
"""Test PDF export with custom CSS template"""
|
|
from app.services.pdf_generator import PDFGenerator
|
|
|
|
service = ExportService()
|
|
service.pdf_generator = Mock(spec=PDFGenerator)
|
|
service.pdf_generator.generate_pdf = Mock(return_value=temp_dir / "output.pdf")
|
|
|
|
output_path = temp_dir / "output.pdf"
|
|
|
|
service.export_to_pdf(mock_ocr_result, output_path, css_template="academic")
|
|
|
|
call_kwargs = service.pdf_generator.generate_pdf.call_args[1]
|
|
assert call_kwargs["css_template"] == "academic"
|
|
|
|
@patch.object(ExportService, '__init__', lambda self: None)
|
|
def test_export_to_pdf_missing_markdown(self, temp_dir):
|
|
"""Test PDF export with missing markdown file"""
|
|
from app.services.pdf_generator import PDFGenerator
|
|
|
|
result = Mock()
|
|
result.id = 1
|
|
result.markdown_path = None
|
|
result.file = Mock()
|
|
|
|
service = ExportService()
|
|
service.pdf_generator = Mock(spec=PDFGenerator)
|
|
|
|
output_path = temp_dir / "output.pdf"
|
|
|
|
with pytest.raises(ExportError) as exc_info:
|
|
service.export_to_pdf(result, output_path)
|
|
|
|
assert "not found" in str(exc_info.value).lower()
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestGetExportFormats:
|
|
"""Test getting available export formats"""
|
|
|
|
def test_get_export_formats(self, export_service):
|
|
"""Test getting export formats"""
|
|
formats = export_service.get_export_formats()
|
|
|
|
assert isinstance(formats, dict)
|
|
assert "txt" in formats
|
|
assert "json" in formats
|
|
assert "excel" in formats
|
|
assert "markdown" in formats
|
|
assert "pdf" in formats
|
|
assert "zip" in formats
|
|
|
|
# Check descriptions are in Chinese
|
|
for desc in formats.values():
|
|
assert isinstance(desc, str)
|
|
assert len(desc) > 0
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestApplyExportRule:
|
|
"""Test export rule application"""
|
|
|
|
def test_apply_export_rule_success(self, export_service, mock_db):
|
|
"""Test applying export rule"""
|
|
# Create mock rule
|
|
rule = Mock()
|
|
rule.id = 1
|
|
rule.config_json = {
|
|
"filters": {
|
|
"confidence_threshold": 0.80
|
|
}
|
|
}
|
|
|
|
mock_db.query.return_value.filter.return_value.first.return_value = rule
|
|
|
|
# Create mock results
|
|
result1 = Mock()
|
|
result1.average_confidence = 0.95
|
|
result1.file = Mock()
|
|
result1.file.original_filename = "test1.png"
|
|
|
|
result2 = Mock()
|
|
result2.average_confidence = 0.70
|
|
result2.file = Mock()
|
|
result2.file.original_filename = "test2.png"
|
|
|
|
results = [result1, result2]
|
|
|
|
filtered = export_service.apply_export_rule(mock_db, results, rule_id=1)
|
|
|
|
assert len(filtered) == 1
|
|
assert result1 in filtered
|
|
|
|
def test_apply_export_rule_not_found(self, export_service, mock_db):
|
|
"""Test applying non-existent rule"""
|
|
mock_db.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
with pytest.raises(ExportError) as exc_info:
|
|
export_service.apply_export_rule(mock_db, [], rule_id=999)
|
|
|
|
assert "not found" in str(exc_info.value).lower()
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestEdgeCases:
|
|
"""Test edge cases and error handling"""
|
|
|
|
def test_export_to_txt_empty_results(self, export_service, temp_dir):
|
|
"""Test TXT export with empty results list"""
|
|
output_path = temp_dir / "output.txt"
|
|
|
|
result_path = export_service.export_to_txt([], output_path)
|
|
|
|
assert result_path.exists()
|
|
content = result_path.read_text(encoding="utf-8")
|
|
assert content == ""
|
|
|
|
def test_export_to_json_empty_results(self, export_service, temp_dir):
|
|
"""Test JSON export with empty results list"""
|
|
output_path = temp_dir / "output.json"
|
|
|
|
result_path = export_service.export_to_json([], output_path)
|
|
|
|
data = json.loads(result_path.read_text(encoding="utf-8"))
|
|
assert data["total_files"] == 0
|
|
assert len(data["results"]) == 0
|
|
|
|
def test_export_with_unicode_content(self, export_service, temp_dir):
|
|
"""Test export with Unicode/Chinese content"""
|
|
md_file = temp_dir / "chinese.md"
|
|
md_file.write_text("# 測試文檔\n\n這是中文內容。", encoding="utf-8")
|
|
|
|
result = Mock()
|
|
result.id = 1
|
|
result.markdown_path = str(md_file)
|
|
result.json_path = None
|
|
result.detected_language = "zh"
|
|
result.total_text_regions = 10
|
|
result.average_confidence = 0.95
|
|
result.layout_data = None # Use None instead of Mock for JSON serialization
|
|
result.images_metadata = None # Use None instead of Mock
|
|
result.file = Mock()
|
|
result.file.id = 1
|
|
result.file.original_filename = "中文測試.png"
|
|
result.file.file_format = "png"
|
|
result.file.file_size = 1024
|
|
result.file.processing_time = 1.0
|
|
|
|
# Test TXT export
|
|
txt_path = temp_dir / "output.txt"
|
|
export_service.export_to_txt([result], txt_path)
|
|
assert "測試文檔" in txt_path.read_text(encoding="utf-8")
|
|
|
|
# Test JSON export
|
|
json_path = temp_dir / "output.json"
|
|
export_service.export_to_json([result], json_path)
|
|
data = json.loads(json_path.read_text(encoding="utf-8"))
|
|
assert data["results"][0]["filename"] == "中文測試.png"
|
|
|
|
def test_apply_filters_with_none_values(self, export_service):
|
|
"""Test filters with None values in results"""
|
|
result = Mock()
|
|
result.average_confidence = None
|
|
result.detected_language = None
|
|
result.file = Mock()
|
|
result.file.original_filename = "test.png"
|
|
|
|
filters = {"confidence_threshold": 0.80}
|
|
|
|
filtered = export_service.apply_filters([result], filters)
|
|
|
|
# Should filter out result with None confidence
|
|
assert len(filtered) == 0
|