04fe925891
Add tests for previously untested components and services: - apiKeyService.ts: localStorage operations (14 tests) - ApiKeyModal.tsx: form validation, submission (22 tests) - App.tsx: state transitions, error handling (23 tests) - latexService.ts: API calls, template detection (35 tests) - latex_service.py: LaTeX escaping, compilation (59 tests) - server.py: Flask routes, field mapping (38 tests) Also fix geminiService tests by adding proper apiKeyService mock. Total new test coverage: 173 TypeScript tests, 97 Python tests https://claude.ai/code/session_01D4k6b4nUjwfcHMvectsri2
467 lines
16 KiB
Python
467 lines
16 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Tests for server.py - Flask API for LaTeX Form Generation
|
|
|
|
Run with: pytest tests/server_test.py -v
|
|
"""
|
|
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
import base64
|
|
|
|
import pytest
|
|
|
|
# Add parent directory to path for imports
|
|
sys.path.insert(0, str(Path(__file__).parent.parent))
|
|
|
|
from server import app, normalize_label, map_fields_to_template, G2210_FIELD_MAPPING
|
|
|
|
|
|
@pytest.fixture
|
|
def client():
|
|
"""Create a test client for the Flask app"""
|
|
app.config['TESTING'] = True
|
|
with app.test_client() as client:
|
|
yield client
|
|
|
|
|
|
class TestNormalizeLabel:
|
|
"""Tests for the normalize_label function"""
|
|
|
|
def test_normalize_lowercase(self):
|
|
"""Should convert to lowercase"""
|
|
assert normalize_label('NAME') == 'name'
|
|
|
|
def test_normalize_strip(self):
|
|
"""Should strip whitespace"""
|
|
assert normalize_label(' name ') == 'name'
|
|
|
|
def test_normalize_remove_colon(self):
|
|
"""Should remove colons"""
|
|
assert normalize_label('Name:') == 'name'
|
|
|
|
def test_normalize_replace_underscore(self):
|
|
"""Should replace underscores with spaces"""
|
|
assert normalize_label('first_name') == 'first name'
|
|
|
|
def test_normalize_combined(self):
|
|
"""Should handle combined transformations"""
|
|
assert normalize_label(' First_Name: ') == 'first name'
|
|
|
|
|
|
class TestMapFieldsToTemplate:
|
|
"""Tests for the map_fields_to_template function"""
|
|
|
|
def test_map_direct_match(self):
|
|
"""Should map fields with direct label match"""
|
|
mapping = {
|
|
'template_field': ['label1', 'label2']
|
|
}
|
|
fields = [{'label': 'label1', 'value': 'test_value'}]
|
|
|
|
result = map_fields_to_template(fields, mapping)
|
|
|
|
assert result == {'template_field': 'test_value'}
|
|
|
|
def test_map_case_insensitive(self):
|
|
"""Should match labels case-insensitively"""
|
|
mapping = {
|
|
'name': ['name', 'vorname']
|
|
}
|
|
fields = [{'label': 'NAME', 'value': 'John'}]
|
|
|
|
result = map_fields_to_template(fields, mapping)
|
|
|
|
assert result == {'name': 'John'}
|
|
|
|
def test_map_fuzzy_match(self):
|
|
"""Should fuzzy match when label contains mapping label"""
|
|
mapping = {
|
|
'name': ['name']
|
|
}
|
|
fields = [{'label': 'Patient Name', 'value': 'John'}]
|
|
|
|
result = map_fields_to_template(fields, mapping)
|
|
|
|
assert result == {'name': 'John'}
|
|
|
|
def test_map_empty_fields(self):
|
|
"""Should return empty dict for empty fields"""
|
|
result = map_fields_to_template([], G2210_FIELD_MAPPING)
|
|
assert result == {}
|
|
|
|
def test_map_skip_empty_values(self):
|
|
"""Should skip fields with empty values"""
|
|
mapping = {'field': ['label']}
|
|
fields = [{'label': 'label', 'value': ''}]
|
|
|
|
result = map_fields_to_template(fields, mapping)
|
|
|
|
assert result == {}
|
|
|
|
def test_map_skip_missing_labels(self):
|
|
"""Should skip fields without labels"""
|
|
mapping = {'field': ['label']}
|
|
fields = [{'value': 'test'}]
|
|
|
|
result = map_fields_to_template(fields, mapping)
|
|
|
|
assert result == {}
|
|
|
|
def test_map_multiple_fields(self):
|
|
"""Should map multiple fields correctly"""
|
|
mapping = {
|
|
'name': ['name'],
|
|
'date': ['datum', 'date']
|
|
}
|
|
fields = [
|
|
{'label': 'Name', 'value': 'John'},
|
|
{'label': 'Datum', 'value': '2025-01-28'}
|
|
]
|
|
|
|
result = map_fields_to_template(fields, mapping)
|
|
|
|
assert result == {'name': 'John', 'date': '2025-01-28'}
|
|
|
|
|
|
class TestHealthEndpoint:
|
|
"""Tests for the /api/health endpoint"""
|
|
|
|
def test_health_returns_ok(self, client):
|
|
"""Should return ok status"""
|
|
response = client.get('/api/health')
|
|
|
|
assert response.status_code == 200
|
|
data = json.loads(response.data)
|
|
assert data['status'] == 'ok'
|
|
assert data['service'] == 'latex-form-generator'
|
|
|
|
|
|
class TestTemplatesEndpoint:
|
|
"""Tests for the /api/templates endpoint"""
|
|
|
|
def test_templates_returns_list(self, client):
|
|
"""Should return list of templates"""
|
|
with patch('server.list_templates', return_value=['G2210-11', 'S0051']):
|
|
response = client.get('/api/templates')
|
|
|
|
assert response.status_code == 200
|
|
data = json.loads(response.data)
|
|
assert data['templates'] == ['G2210-11', 'S0051']
|
|
|
|
def test_templates_returns_empty_list(self, client):
|
|
"""Should return empty list when no templates"""
|
|
with patch('server.list_templates', return_value=[]):
|
|
response = client.get('/api/templates')
|
|
|
|
assert response.status_code == 200
|
|
data = json.loads(response.data)
|
|
assert data['templates'] == []
|
|
|
|
|
|
class TestGenerateEndpoint:
|
|
"""Tests for the /api/generate endpoint"""
|
|
|
|
def test_generate_success(self, client):
|
|
"""Should generate PDF and return base64"""
|
|
mock_pdf = b'%PDF-1.4 test content'
|
|
|
|
with patch('server.generate_form', return_value=mock_pdf):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [{'label': 'Name', 'value': 'John'}]
|
|
}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = json.loads(response.data)
|
|
assert data['success'] is True
|
|
assert data['pdf'] == base64.b64encode(mock_pdf).decode('ascii')
|
|
|
|
def test_generate_returns_mapped_fields(self, client):
|
|
"""Should return mapped fields in response"""
|
|
with patch('server.generate_form', return_value=b'pdf'):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [{'label': 'Name, Vorname', 'value': 'Müller, Hans'}]
|
|
}
|
|
)
|
|
|
|
data = json.loads(response.data)
|
|
assert 'mapped_fields' in data
|
|
|
|
def test_generate_no_json_returns_error(self, client):
|
|
"""Should return error for missing JSON"""
|
|
response = client.post('/api/generate')
|
|
|
|
# Server may return 400 or 500 depending on Flask version behavior
|
|
assert response.status_code in [400, 500]
|
|
data = json.loads(response.data)
|
|
assert 'error' in data
|
|
|
|
def test_generate_template_not_found_returns_404(self, client):
|
|
"""Should return 404 for missing template"""
|
|
with patch('server.generate_form', side_effect=FileNotFoundError('Template not found')):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={'template': 'nonexistent', 'fields': []}
|
|
)
|
|
|
|
assert response.status_code == 404
|
|
|
|
def test_generate_error_returns_500(self, client):
|
|
"""Should return 500 for generation errors"""
|
|
with patch('server.generate_form', side_effect=Exception('Compilation failed')):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={'template': 'G2210-11', 'fields': []}
|
|
)
|
|
|
|
assert response.status_code == 500
|
|
data = json.loads(response.data)
|
|
assert 'Compilation failed' in data['error']
|
|
|
|
def test_generate_default_template(self, client):
|
|
"""Should use G2210-11 as default template"""
|
|
with patch('server.generate_form', return_value=b'pdf') as mock_generate:
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={'fields': []}
|
|
)
|
|
|
|
# Check that G2210-11 mapping was used (via generate_form call)
|
|
assert response.status_code == 200
|
|
|
|
def test_generate_file_format(self, client):
|
|
"""Should return file when format=file"""
|
|
mock_pdf = b'%PDF-1.4 test'
|
|
|
|
with patch('server.generate_form', return_value=mock_pdf):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [],
|
|
'format': 'file'
|
|
}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
assert response.content_type == 'application/pdf'
|
|
assert response.data == mock_pdf
|
|
|
|
|
|
class TestPreviewEndpoint:
|
|
"""Tests for the /api/preview endpoint"""
|
|
|
|
def test_preview_success(self, client):
|
|
"""Should return filled LaTeX source"""
|
|
mock_template = r'\documentclass{article}'
|
|
mock_filled = r'\documentclass{article}\n% filled'
|
|
|
|
with patch('server.load_template', return_value=mock_template), \
|
|
patch('server.fill_template', return_value=mock_filled):
|
|
response = client.post(
|
|
'/api/preview',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': []
|
|
}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = json.loads(response.data)
|
|
assert data['success'] is True
|
|
assert data['latex'] == mock_filled
|
|
|
|
def test_preview_returns_mapped_fields(self, client):
|
|
"""Should return mapped fields"""
|
|
with patch('server.load_template', return_value=''), \
|
|
patch('server.fill_template', return_value=''):
|
|
response = client.post(
|
|
'/api/preview',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [{'label': 'Geburtsdatum', 'value': '01.01.1990'}]
|
|
}
|
|
)
|
|
|
|
data = json.loads(response.data)
|
|
assert 'mapped_fields' in data
|
|
|
|
def test_preview_no_json_returns_error(self, client):
|
|
"""Should return error for missing JSON"""
|
|
response = client.post('/api/preview')
|
|
|
|
# Server may return 400 or 500 depending on Flask version behavior
|
|
assert response.status_code in [400, 500]
|
|
|
|
def test_preview_error_returns_500(self, client):
|
|
"""Should return 500 for errors"""
|
|
with patch('server.load_template', side_effect=Exception('Template error')):
|
|
response = client.post(
|
|
'/api/preview',
|
|
json={'template': 'G2210-11', 'fields': []}
|
|
)
|
|
|
|
assert response.status_code == 500
|
|
|
|
|
|
class TestFieldMappingEndpoint:
|
|
"""Tests for the /api/field-mapping/<template_name> endpoint"""
|
|
|
|
def test_field_mapping_g2210(self, client):
|
|
"""Should return field mapping for G2210-11"""
|
|
response = client.get('/api/field-mapping/G2210-11')
|
|
|
|
assert response.status_code == 200
|
|
data = json.loads(response.data)
|
|
assert data['template'] == 'G2210-11'
|
|
assert 'fields' in data
|
|
assert 'mapping' in data
|
|
assert 'versicherungsnummer' in data['fields']
|
|
|
|
def test_field_mapping_unknown_returns_404(self, client):
|
|
"""Should return 404 for unknown template"""
|
|
response = client.get('/api/field-mapping/unknown')
|
|
|
|
assert response.status_code == 404
|
|
data = json.loads(response.data)
|
|
assert 'error' in data
|
|
|
|
|
|
class TestG2210FieldMapping:
|
|
"""Tests for the G2210_FIELD_MAPPING constant"""
|
|
|
|
def test_mapping_has_patient_fields(self):
|
|
"""Should have patient data fields"""
|
|
assert 'versicherungsnummer' in G2210_FIELD_MAPPING
|
|
assert 'name_vorname' in G2210_FIELD_MAPPING
|
|
assert 'geburtsdatum' in G2210_FIELD_MAPPING
|
|
|
|
def test_mapping_has_diagnosis_fields(self):
|
|
"""Should have diagnosis fields"""
|
|
assert 'diagnose_1' in G2210_FIELD_MAPPING
|
|
assert 'diagnose_1_icd' in G2210_FIELD_MAPPING
|
|
|
|
def test_mapping_has_doctor_fields(self):
|
|
"""Should have doctor/signature fields"""
|
|
assert 'arzt_name' in G2210_FIELD_MAPPING
|
|
assert 'bsnr' in G2210_FIELD_MAPPING
|
|
assert 'lanr' in G2210_FIELD_MAPPING
|
|
|
|
def test_mapping_labels_are_lists(self):
|
|
"""All mapping values should be lists of possible labels"""
|
|
for key, value in G2210_FIELD_MAPPING.items():
|
|
assert isinstance(value, list), f'{key} should map to a list'
|
|
assert len(value) > 0, f'{key} should have at least one label'
|
|
|
|
|
|
class TestCORS:
|
|
"""Tests for CORS configuration"""
|
|
|
|
def test_cors_headers_present(self, client):
|
|
"""Should include CORS headers"""
|
|
response = client.get('/api/health')
|
|
|
|
# Flask-CORS adds these headers
|
|
# The exact headers depend on the request
|
|
assert response.status_code == 200
|
|
|
|
|
|
class TestIntegration:
|
|
"""Integration tests"""
|
|
|
|
def test_full_workflow(self, client):
|
|
"""Test complete workflow: health -> templates -> generate"""
|
|
# 1. Check health
|
|
health_response = client.get('/api/health')
|
|
assert health_response.status_code == 200
|
|
|
|
# 2. Get templates
|
|
with patch('server.list_templates', return_value=['G2210-11']):
|
|
templates_response = client.get('/api/templates')
|
|
assert templates_response.status_code == 200
|
|
|
|
# 3. Generate PDF
|
|
with patch('server.generate_form', return_value=b'%PDF-1.4'):
|
|
generate_response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [
|
|
{'label': 'Name, Vorname', 'value': 'Test, User'},
|
|
{'label': 'Geburtsdatum', 'value': '01.01.1990'}
|
|
]
|
|
}
|
|
)
|
|
assert generate_response.status_code == 200
|
|
data = json.loads(generate_response.data)
|
|
assert data['success'] is True
|
|
|
|
|
|
class TestEdgeCases:
|
|
"""Edge case tests"""
|
|
|
|
def test_generate_with_empty_fields_list(self, client):
|
|
"""Should handle empty fields list"""
|
|
with patch('server.generate_form', return_value=b'pdf'):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={'template': 'G2210-11', 'fields': []}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_generate_with_unicode_values(self, client):
|
|
"""Should handle Unicode values"""
|
|
with patch('server.generate_form', return_value=b'pdf'):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [
|
|
{'label': 'Name', 'value': 'Müller'},
|
|
{'label': 'Stadt', 'value': '東京'}
|
|
]
|
|
}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_generate_with_special_characters(self, client):
|
|
"""Should handle special characters in values"""
|
|
with patch('server.generate_form', return_value=b'pdf'):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'G2210-11',
|
|
'fields': [
|
|
{'label': 'Notes', 'value': 'Test & notes with $pecial chars'}
|
|
]
|
|
}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_map_fields_with_unknown_template(self, client):
|
|
"""Should handle unknown template with direct field mapping"""
|
|
with patch('server.generate_form', return_value=b'pdf'):
|
|
response = client.post(
|
|
'/api/generate',
|
|
json={
|
|
'template': 'custom-template',
|
|
'fields': [
|
|
{'label': 'custom_field', 'value': 'custom_value'}
|
|
]
|
|
}
|
|
)
|
|
|
|
# Should still work, just with direct mapping
|
|
assert response.status_code in [200, 404, 500] # Depends on template existence
|