@@ -0,0 +1,541 @@
|
||||
"""
|
||||
Test file for document layouter functionality.
|
||||
|
||||
This test focuses on verifying that the document layouter properly
|
||||
integrates word spacing constraints from the style system.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from unittest.mock import Mock, MagicMock, patch
|
||||
from typing import List, Optional
|
||||
|
||||
from pyWebLayout.layout.document_layouter import paragraph_layouter, DocumentLayouter
|
||||
from pyWebLayout.style.abstract_style import AbstractStyle
|
||||
from pyWebLayout.style.concrete_style import ConcreteStyle, StyleResolver, RenderingContext
|
||||
|
||||
|
||||
class TestDocumentLayouter:
|
||||
"""Test cases for document layouter functionality."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures before each test method."""
|
||||
# Create mock objects
|
||||
self.mock_page = Mock()
|
||||
self.mock_page.border_size = 20
|
||||
self.mock_page._current_y_offset = 50
|
||||
self.mock_page.available_width = 400
|
||||
self.mock_page.draw = Mock()
|
||||
self.mock_page.can_fit_line = Mock(return_value=True)
|
||||
self.mock_page.add_child = Mock()
|
||||
|
||||
# Create mock style resolver
|
||||
self.mock_style_resolver = Mock()
|
||||
self.mock_page.style_resolver = self.mock_style_resolver
|
||||
|
||||
# Create mock paragraph
|
||||
self.mock_paragraph = Mock()
|
||||
self.mock_paragraph.line_height = 20
|
||||
self.mock_paragraph.style = AbstractStyle()
|
||||
|
||||
# Create mock words
|
||||
self.mock_words = []
|
||||
for i in range(5):
|
||||
word = Mock()
|
||||
word.text = f"word{i}"
|
||||
self.mock_words.append(word)
|
||||
self.mock_paragraph.words = self.mock_words
|
||||
|
||||
# Create mock concrete style with word spacing constraints
|
||||
self.mock_concrete_style = Mock()
|
||||
self.mock_concrete_style.word_spacing_min = 2.0
|
||||
self.mock_concrete_style.word_spacing_max = 8.0
|
||||
self.mock_concrete_style.text_align = "left"
|
||||
self.mock_concrete_style.create_font = Mock()
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry')
|
||||
@patch('pyWebLayout.layout.document_layouter.Line')
|
||||
def test_paragraph_layouter_basic_flow(self, mock_line_class, mock_style_registry_class):
|
||||
"""Test basic paragraph layouter functionality."""
|
||||
# Setup mocks
|
||||
mock_style_registry = Mock()
|
||||
mock_style_registry_class.return_value = mock_style_registry
|
||||
mock_style_registry.get_concrete_style.return_value = self.mock_concrete_style
|
||||
|
||||
mock_line = Mock()
|
||||
mock_line_class.return_value = mock_line
|
||||
mock_line.add_word.return_value = (True, None) # All words fit successfully
|
||||
|
||||
# Call function
|
||||
result = paragraph_layouter(self.mock_paragraph, self.mock_page)
|
||||
|
||||
# Verify results
|
||||
success, failed_word_index, remaining_pretext = result
|
||||
assert success is True
|
||||
assert failed_word_index is None
|
||||
assert remaining_pretext is None
|
||||
|
||||
# Verify style registry was used correctly
|
||||
mock_style_registry_class.assert_called_once_with(self.mock_page.style_resolver)
|
||||
mock_style_registry.get_concrete_style.assert_called_once_with(self.mock_paragraph.style)
|
||||
|
||||
# Verify Line was created with correct spacing constraints
|
||||
expected_spacing = (2, 8) # From mock_concrete_style
|
||||
mock_line_class.assert_called_once()
|
||||
call_args = mock_line_class.call_args
|
||||
assert call_args[1]['spacing'] == expected_spacing
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry')
|
||||
@patch('pyWebLayout.layout.document_layouter.Line')
|
||||
def test_paragraph_layouter_word_spacing_constraints_extraction(self, mock_line_class, mock_style_registry_class):
|
||||
"""Test that word spacing constraints are correctly extracted from style."""
|
||||
# Create concrete style with specific constraints
|
||||
concrete_style = Mock()
|
||||
concrete_style.word_spacing_min = 5.5
|
||||
concrete_style.word_spacing_max = 15.2
|
||||
concrete_style.text_align = "justify"
|
||||
concrete_style.create_font = Mock()
|
||||
|
||||
mock_style_registry = Mock()
|
||||
mock_style_registry_class.return_value = mock_style_registry
|
||||
mock_style_registry.get_concrete_style.return_value = concrete_style
|
||||
|
||||
mock_line = Mock()
|
||||
mock_line_class.return_value = mock_line
|
||||
mock_line.add_word.return_value = (True, None)
|
||||
|
||||
# Call function
|
||||
paragraph_layouter(self.mock_paragraph, self.mock_page)
|
||||
|
||||
# Verify spacing constraints were extracted correctly (converted to int)
|
||||
expected_spacing = (5, 15) # int() conversion of 5.5 and 15.2
|
||||
call_args = mock_line_class.call_args
|
||||
assert call_args[1]['spacing'] == expected_spacing
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry')
|
||||
@patch('pyWebLayout.layout.document_layouter.Line')
|
||||
def test_paragraph_layouter_line_overflow(self, mock_line_class, mock_style_registry_class):
|
||||
"""Test handling of line overflow when words don't fit."""
|
||||
# Setup mocks
|
||||
mock_style_registry = Mock()
|
||||
mock_style_registry_class.return_value = mock_style_registry
|
||||
mock_style_registry.get_concrete_style.return_value = self.mock_concrete_style
|
||||
|
||||
# Create two mock lines
|
||||
mock_line1 = Mock()
|
||||
mock_line2 = Mock()
|
||||
mock_line_class.side_effect = [mock_line1, mock_line2]
|
||||
|
||||
# First line: first 2 words fit, third doesn't
|
||||
# Second line: remaining words fit
|
||||
mock_line1.add_word.side_effect = [
|
||||
(True, None), # word0 fits
|
||||
(True, None), # word1 fits
|
||||
(False, None), # word2 doesn't fit
|
||||
]
|
||||
mock_line2.add_word.side_effect = [
|
||||
(True, None), # word2 fits on new line
|
||||
(True, None), # word3 fits
|
||||
(True, None), # word4 fits
|
||||
]
|
||||
|
||||
# Call function
|
||||
result = paragraph_layouter(self.mock_paragraph, self.mock_page)
|
||||
|
||||
# Verify results
|
||||
success, failed_word_index, remaining_pretext = result
|
||||
assert success is True
|
||||
assert failed_word_index is None
|
||||
assert remaining_pretext is None
|
||||
|
||||
# Verify two lines were created
|
||||
assert mock_line_class.call_count == 2
|
||||
assert self.mock_page.add_child.call_count == 2
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry')
|
||||
@patch('pyWebLayout.layout.document_layouter.Line')
|
||||
def test_paragraph_layouter_page_full(self, mock_line_class, mock_style_registry_class):
|
||||
"""Test handling when page runs out of space."""
|
||||
# Setup mocks
|
||||
mock_style_registry = Mock()
|
||||
mock_style_registry_class.return_value = mock_style_registry
|
||||
mock_style_registry.get_concrete_style.return_value = self.mock_concrete_style
|
||||
|
||||
# Page can fit first line but not second
|
||||
self.mock_page.can_fit_line.side_effect = [True, False]
|
||||
|
||||
mock_line = Mock()
|
||||
mock_line_class.return_value = mock_line
|
||||
mock_line.add_word.side_effect = [
|
||||
(True, None), # word0 fits
|
||||
(False, None), # word1 doesn't fit, need new line
|
||||
]
|
||||
|
||||
# Call function
|
||||
result = paragraph_layouter(self.mock_paragraph, self.mock_page)
|
||||
|
||||
# Verify results indicate page is full
|
||||
success, failed_word_index, remaining_pretext = result
|
||||
assert success is False
|
||||
assert failed_word_index == 1 # word1 didn't fit
|
||||
assert remaining_pretext is None
|
||||
|
||||
def test_paragraph_layouter_empty_paragraph(self):
|
||||
"""Test handling of empty paragraph."""
|
||||
empty_paragraph = Mock()
|
||||
empty_paragraph.words = []
|
||||
|
||||
result = paragraph_layouter(empty_paragraph, self.mock_page)
|
||||
|
||||
success, failed_word_index, remaining_pretext = result
|
||||
assert success is True
|
||||
assert failed_word_index is None
|
||||
assert remaining_pretext is None
|
||||
|
||||
def test_paragraph_layouter_invalid_start_word(self):
|
||||
"""Test handling of invalid start_word index."""
|
||||
result = paragraph_layouter(self.mock_paragraph, self.mock_page, start_word=10)
|
||||
|
||||
success, failed_word_index, remaining_pretext = result
|
||||
assert success is True
|
||||
assert failed_word_index is None
|
||||
assert remaining_pretext is None
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry')
|
||||
def test_document_layouter_class(self, mock_style_registry_class):
|
||||
"""Test DocumentLayouter class functionality."""
|
||||
# Setup mock
|
||||
mock_style_registry = Mock()
|
||||
mock_style_registry_class.return_value = mock_style_registry
|
||||
|
||||
# Create layouter
|
||||
layouter = DocumentLayouter(self.mock_page)
|
||||
|
||||
# Verify initialization
|
||||
assert layouter.page == self.mock_page
|
||||
mock_style_registry_class.assert_called_once_with(self.mock_page.style_resolver)
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.paragraph_layouter')
|
||||
def test_document_layouter_layout_paragraph(self, mock_paragraph_layouter):
|
||||
"""Test DocumentLayouter.layout_paragraph method."""
|
||||
mock_paragraph_layouter.return_value = (True, None, None)
|
||||
|
||||
with patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry'):
|
||||
layouter = DocumentLayouter(self.mock_page)
|
||||
|
||||
result = layouter.layout_paragraph(self.mock_paragraph, start_word=2, pretext="test")
|
||||
|
||||
# Verify the function was called correctly
|
||||
mock_paragraph_layouter.assert_called_once_with(
|
||||
self.mock_paragraph, self.mock_page, 2, "test"
|
||||
)
|
||||
assert result == (True, None, None)
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.paragraph_layouter')
|
||||
def test_document_layouter_layout_document_success(self, mock_paragraph_layouter):
|
||||
"""Test DocumentLayouter.layout_document with successful layout."""
|
||||
mock_paragraph_layouter.return_value = (True, None, None)
|
||||
|
||||
paragraphs = [self.mock_paragraph, Mock(), Mock()]
|
||||
|
||||
with patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry'):
|
||||
layouter = DocumentLayouter(self.mock_page)
|
||||
|
||||
result = layouter.layout_document(paragraphs)
|
||||
|
||||
assert result is True
|
||||
assert mock_paragraph_layouter.call_count == 3
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.paragraph_layouter')
|
||||
def test_document_layouter_layout_document_failure(self, mock_paragraph_layouter):
|
||||
"""Test DocumentLayouter.layout_document with layout failure."""
|
||||
# First paragraph succeeds, second fails
|
||||
mock_paragraph_layouter.side_effect = [
|
||||
(True, None, None), # First paragraph succeeds
|
||||
(False, 3, None), # Second paragraph fails
|
||||
]
|
||||
|
||||
paragraphs = [self.mock_paragraph, Mock()]
|
||||
|
||||
with patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry'):
|
||||
layouter = DocumentLayouter(self.mock_page)
|
||||
|
||||
result = layouter.layout_document(paragraphs)
|
||||
|
||||
assert result is False
|
||||
assert mock_paragraph_layouter.call_count == 2
|
||||
|
||||
def test_real_style_integration(self):
|
||||
"""Test integration with real style system."""
|
||||
# Create real style objects
|
||||
context = RenderingContext(base_font_size=16)
|
||||
resolver = StyleResolver(context)
|
||||
|
||||
abstract_style = AbstractStyle(
|
||||
word_spacing=4.0,
|
||||
word_spacing_min=2.0,
|
||||
word_spacing_max=10.0
|
||||
)
|
||||
|
||||
concrete_style = resolver.resolve_style(abstract_style)
|
||||
|
||||
# Verify constraints are resolved correctly
|
||||
assert concrete_style.word_spacing_min == 2.0
|
||||
assert concrete_style.word_spacing_max == 10.0
|
||||
|
||||
# This demonstrates the integration works end-to-end
|
||||
|
||||
|
||||
class TestWordSpacingConstraintsInLayout:
|
||||
"""Specific tests for word spacing constraints in layout context."""
|
||||
|
||||
def test_different_spacing_scenarios(self):
|
||||
"""Test various word spacing constraint scenarios."""
|
||||
context = RenderingContext(base_font_size=16)
|
||||
resolver = StyleResolver(context)
|
||||
|
||||
test_cases = [
|
||||
# (word_spacing, word_spacing_min, word_spacing_max, expected_min, expected_max)
|
||||
(None, None, None, 2.0, 8.0), # Default case
|
||||
(5.0, None, None, 5.0, 10.0), # Only base specified
|
||||
(4.0, 2.0, 8.0, 2.0, 8.0), # All specified
|
||||
(3.0, 1.0, None, 1.0, 3.0), # Min specified, max = max(word_spacing, min*2) = max(3.0, 2.0) = 3.0
|
||||
(6.0, None, 12.0, 6.0, 12.0), # Max specified, min from base
|
||||
]
|
||||
|
||||
for word_spacing, min_spacing, max_spacing, expected_min, expected_max in test_cases:
|
||||
style_kwargs = {}
|
||||
if word_spacing is not None:
|
||||
style_kwargs['word_spacing'] = word_spacing
|
||||
if min_spacing is not None:
|
||||
style_kwargs['word_spacing_min'] = min_spacing
|
||||
if max_spacing is not None:
|
||||
style_kwargs['word_spacing_max'] = max_spacing
|
||||
|
||||
abstract_style = AbstractStyle(**style_kwargs)
|
||||
concrete_style = resolver.resolve_style(abstract_style)
|
||||
|
||||
assert concrete_style.word_spacing_min == expected_min, f"Failed for case: {style_kwargs}"
|
||||
assert concrete_style.word_spacing_max == expected_max, f"Failed for case: {style_kwargs}"
|
||||
|
||||
|
||||
class TestMultiPageLayout:
|
||||
"""Test cases for multi-page document layout scenarios."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures for multi-page tests."""
|
||||
# Create multiple mock pages
|
||||
self.mock_pages = []
|
||||
for i in range(3):
|
||||
page = Mock()
|
||||
page.page_number = i + 1
|
||||
page.border_size = 20
|
||||
page._current_y_offset = 50
|
||||
page.available_width = 400
|
||||
page.available_height = 600
|
||||
page.draw = Mock()
|
||||
page.add_child = Mock()
|
||||
page.style_resolver = Mock()
|
||||
self.mock_pages.append(page)
|
||||
|
||||
# Create a long paragraph that will span multiple pages
|
||||
self.long_paragraph = Mock()
|
||||
self.long_paragraph.line_height = 25
|
||||
self.long_paragraph.style = AbstractStyle()
|
||||
|
||||
# Create many words to ensure page overflow
|
||||
self.long_paragraph.words = []
|
||||
for i in range(50): # 50 words should definitely overflow a page
|
||||
word = Mock()
|
||||
word.text = f"word_{i:02d}"
|
||||
self.long_paragraph.words.append(word)
|
||||
|
||||
# Create mock concrete style
|
||||
self.mock_concrete_style = Mock()
|
||||
self.mock_concrete_style.word_spacing_min = 3.0
|
||||
self.mock_concrete_style.word_spacing_max = 12.0
|
||||
self.mock_concrete_style.text_align = "justify"
|
||||
self.mock_concrete_style.create_font = Mock()
|
||||
|
||||
|
||||
@patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry')
|
||||
def test_document_layouter_multi_page_scenario(self, mock_style_registry_class):
|
||||
"""Test DocumentLayouter handling multiple pages with continuation."""
|
||||
# Setup style registry
|
||||
mock_style_registry = Mock()
|
||||
mock_style_registry_class.return_value = mock_style_registry
|
||||
mock_style_registry.get_concrete_style.return_value = self.mock_concrete_style
|
||||
|
||||
# Create a multi-page document layouter
|
||||
class MultiPageDocumentLayouter(DocumentLayouter):
|
||||
def __init__(self, pages):
|
||||
self.pages = pages
|
||||
self.current_page_index = 0
|
||||
self.page = pages[0]
|
||||
self.style_registry = Mock()
|
||||
|
||||
def get_next_page(self):
|
||||
"""Get the next available page."""
|
||||
if self.current_page_index + 1 < len(self.pages):
|
||||
self.current_page_index += 1
|
||||
self.page = self.pages[self.current_page_index]
|
||||
return self.page
|
||||
return None
|
||||
|
||||
def layout_document_with_pagination(self, paragraphs):
|
||||
"""Layout document with automatic pagination."""
|
||||
for paragraph in paragraphs:
|
||||
start_word = 0
|
||||
pretext = None
|
||||
|
||||
while start_word < len(paragraph.words):
|
||||
complete, next_word, remaining_pretext = self.layout_paragraph(
|
||||
paragraph, start_word, pretext
|
||||
)
|
||||
|
||||
if complete:
|
||||
# Paragraph finished
|
||||
break
|
||||
|
||||
if next_word is None:
|
||||
# Error condition
|
||||
return False, f"Failed to layout paragraph at word {start_word}"
|
||||
|
||||
# Try to get next page
|
||||
next_page = self.get_next_page()
|
||||
if not next_page:
|
||||
return False, f"Ran out of pages at word {next_word}"
|
||||
|
||||
# Continue with remaining words on next page
|
||||
start_word = next_word
|
||||
pretext = remaining_pretext
|
||||
|
||||
return True, "All paragraphs laid out successfully"
|
||||
|
||||
# Create layouter with multiple pages
|
||||
layouter = MultiPageDocumentLayouter(self.mock_pages)
|
||||
|
||||
# Mock the layout_paragraph method to simulate page filling
|
||||
original_layout_paragraph = layouter.layout_paragraph
|
||||
call_count = [0]
|
||||
|
||||
def mock_layout_paragraph(paragraph, start_word=0, pretext=None):
|
||||
call_count[0] += 1
|
||||
|
||||
# Simulate different scenarios based on call count
|
||||
if call_count[0] == 1:
|
||||
# First page: can fit words 0-19, fails at word 20
|
||||
return (False, 20, None)
|
||||
elif call_count[0] == 2:
|
||||
# Second page: can fit words 20-39, fails at word 40
|
||||
return (False, 40, None)
|
||||
elif call_count[0] == 3:
|
||||
# Third page: can fit remaining words 40-49
|
||||
return (True, None, None)
|
||||
else:
|
||||
return (False, start_word, None)
|
||||
|
||||
layouter.layout_paragraph = mock_layout_paragraph
|
||||
|
||||
# Test multi-page layout
|
||||
success, message = layouter.layout_document_with_pagination([self.long_paragraph])
|
||||
|
||||
# Verify results
|
||||
assert success is True
|
||||
assert "successfully" in message
|
||||
assert call_count[0] == 3 # Should have made 3 layout attempts
|
||||
assert layouter.current_page_index == 2 # Should end on page 3 (index 2)
|
||||
|
||||
|
||||
def test_realistic_multi_page_scenario(self):
|
||||
"""Test a realistic scenario with actual content and page constraints."""
|
||||
# Create realistic paragraph with varied content
|
||||
realistic_paragraph = Mock()
|
||||
realistic_paragraph.line_height = 20
|
||||
realistic_paragraph.style = AbstractStyle(
|
||||
word_spacing=4.0,
|
||||
word_spacing_min=2.0,
|
||||
word_spacing_max=8.0,
|
||||
text_align="justify"
|
||||
)
|
||||
|
||||
# Create words of varying lengths (realistic text)
|
||||
words = [
|
||||
"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog.",
|
||||
"This", "sentence", "contains", "words", "of", "varying", "lengths",
|
||||
"to", "simulate", "realistic", "text", "content", "that", "would",
|
||||
"require", "proper", "word", "spacing", "calculations", "and",
|
||||
"potentially", "multiple", "pages", "for", "layout.", "Each",
|
||||
"word", "represents", "a", "challenge", "for", "the", "layouter",
|
||||
"system", "to", "handle", "appropriately", "with", "the", "given",
|
||||
"constraints", "and", "spacing", "requirements."
|
||||
]
|
||||
|
||||
realistic_paragraph.words = []
|
||||
for word_text in words:
|
||||
word = Mock()
|
||||
word.text = word_text
|
||||
realistic_paragraph.words.append(word)
|
||||
|
||||
# Create page with realistic constraints
|
||||
realistic_page = Mock()
|
||||
realistic_page.border_size = 30
|
||||
realistic_page._current_y_offset = 100
|
||||
realistic_page.available_width = 350 # Narrower page
|
||||
realistic_page.available_height = 500
|
||||
realistic_page.draw = Mock()
|
||||
realistic_page.add_child = Mock()
|
||||
realistic_page.style_resolver = Mock()
|
||||
|
||||
# Simulate page that can fit approximately 20 lines
|
||||
lines_fitted = [0]
|
||||
max_lines = 20
|
||||
|
||||
def realistic_can_fit_line(line_height):
|
||||
lines_fitted[0] += 1
|
||||
return lines_fitted[0] <= max_lines
|
||||
|
||||
realistic_page.can_fit_line = realistic_can_fit_line
|
||||
|
||||
# Test with real style system
|
||||
context = RenderingContext(base_font_size=14)
|
||||
resolver = StyleResolver(context)
|
||||
concrete_style = resolver.resolve_style(realistic_paragraph.style)
|
||||
|
||||
# Verify realistic constraints were calculated
|
||||
assert concrete_style.word_spacing == 4.0
|
||||
assert concrete_style.word_spacing_min == 2.0
|
||||
assert concrete_style.word_spacing_max == 8.0
|
||||
|
||||
# This test demonstrates the integration without mocking everything
|
||||
# In a real scenario, this would interface with actual Line and Text objects
|
||||
print(f"✓ Realistic scenario test completed")
|
||||
print(f" - Words to layout: {len(realistic_paragraph.words)}")
|
||||
print(f" - Page width: {realistic_page.available_width}px")
|
||||
print(f" - Word spacing constraints: {concrete_style.word_spacing_min}-{concrete_style.word_spacing_max}px")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Run specific tests for debugging
|
||||
test = TestDocumentLayouter()
|
||||
test.setup_method()
|
||||
|
||||
# Run a simple test
|
||||
with patch('pyWebLayout.layout.document_layouter.ConcreteStyleRegistry') as mock_registry:
|
||||
with patch('pyWebLayout.layout.document_layouter.Line') as mock_line:
|
||||
mock_style_registry = Mock()
|
||||
mock_registry.return_value = mock_style_registry
|
||||
mock_style_registry.get_concrete_style.return_value = test.mock_concrete_style
|
||||
|
||||
mock_line_instance = Mock()
|
||||
mock_line.return_value = mock_line_instance
|
||||
mock_line_instance.add_word.return_value = (True, None)
|
||||
|
||||
result = paragraph_layouter(test.mock_paragraph, test.mock_page)
|
||||
print(f"Test result: {result}")
|
||||
|
||||
# Run multi-page tests
|
||||
multi_test = TestMultiPageLayout()
|
||||
multi_test.setup_method()
|
||||
multi_test.test_realistic_multi_page_scenario()
|
||||
|
||||
print("Document layouter tests completed!")
|
||||
Reference in New Issue
Block a user