""" Comprehensive tests for the ereader layout system. Tests the complete ereader functionality including position tracking, font scaling, chapter navigation, and page buffering. """ import unittest import tempfile import shutil from pathlib import Path from pyWebLayout.abstract.block import Paragraph, Heading, HeadingLevel from pyWebLayout.abstract.inline import Word from pyWebLayout.style import Font from pyWebLayout.style.page_style import PageStyle from pyWebLayout.layout.ereader_layout import RenderingPosition, ChapterNavigator, FontScaler, BidirectionalLayouter from pyWebLayout.layout.ereader_manager import EreaderLayoutManager, BookmarkManager, create_ereader_manager class TestRenderingPosition(unittest.TestCase): """Test the RenderingPosition class""" def test_position_creation(self): """Test creating a rendering position""" pos = RenderingPosition( chapter_index=1, block_index=5, word_index=10, table_row=2, table_col=3 ) self.assertEqual(pos.chapter_index, 1) self.assertEqual(pos.block_index, 5) self.assertEqual(pos.word_index, 10) self.assertEqual(pos.table_row, 2) self.assertEqual(pos.table_col, 3) def test_position_serialization(self): """Test position serialization and deserialization""" pos = RenderingPosition( chapter_index=1, block_index=5, word_index=10, remaining_pretext="test" ) # Serialize to dict pos_dict = pos.to_dict() self.assertIsInstance(pos_dict, dict) self.assertEqual(pos_dict['chapter_index'], 1) self.assertEqual(pos_dict['remaining_pretext'], "test") # Deserialize from dict pos2 = RenderingPosition.from_dict(pos_dict) self.assertEqual(pos, pos2) def test_position_copy(self): """Test position copying""" pos = RenderingPosition(chapter_index=1, block_index=5) pos_copy = pos.copy() self.assertEqual(pos, pos_copy) self.assertIsNot(pos, pos_copy) # Different objects # Modify copy pos_copy.word_index = 10 self.assertNotEqual(pos, pos_copy) def test_position_equality_and_hashing(self): """Test position equality and hashing""" pos1 = RenderingPosition(chapter_index=1, block_index=5) pos2 = RenderingPosition(chapter_index=1, block_index=5) pos3 = RenderingPosition(chapter_index=1, block_index=6) self.assertEqual(pos1, pos2) self.assertNotEqual(pos1, pos3) # Test hashing (for use as dict keys) pos_dict = {pos1: "test"} self.assertEqual(pos_dict[pos2], "test") # Should work due to equality class TestChapterNavigator(unittest.TestCase): """Test the ChapterNavigator class""" def setUp(self): """Set up test data""" self.font = Font() # Create test blocks with headings self.blocks = [ Paragraph(self.font), # Block 0 Heading(HeadingLevel.H1, self.font), # Block 1 - Chapter 1 Paragraph(self.font), # Block 2 Heading(HeadingLevel.H2, self.font), # Block 3 - Subsection Paragraph(self.font), # Block 4 Heading(HeadingLevel.H1, self.font), # Block 5 - Chapter 2 Paragraph(self.font), # Block 6 ] # Add text to headings self.blocks[1].add_word(Word("Chapter", self.font)) self.blocks[1].add_word(Word("One", self.font)) self.blocks[3].add_word(Word("Subsection", self.font)) self.blocks[3].add_word(Word("A", self.font)) self.blocks[5].add_word(Word("Chapter", self.font)) self.blocks[5].add_word(Word("Two", self.font)) def test_chapter_detection(self): """Test that chapters are detected correctly""" navigator = ChapterNavigator(self.blocks) self.assertEqual(len(navigator.chapters), 3) # 2 H1s + 1 H2 # Check chapter titles titles = [chapter.title for chapter in navigator.chapters] self.assertIn("Chapter One", titles) self.assertIn("Subsection A", titles) self.assertIn("Chapter Two", titles) def test_table_of_contents(self): """Test table of contents generation""" navigator = ChapterNavigator(self.blocks) toc = navigator.get_table_of_contents() self.assertEqual(len(toc), 3) # Check first entry title, level, position = toc[0] self.assertEqual(title, "Chapter One") self.assertEqual(level, HeadingLevel.H1) self.assertIsInstance(position, RenderingPosition) def test_chapter_position_lookup(self): """Test looking up chapter positions""" navigator = ChapterNavigator(self.blocks) pos = navigator.get_chapter_position("Chapter One") self.assertIsNotNone(pos) self.assertEqual(pos.chapter_index, 0) pos = navigator.get_chapter_position("Nonexistent Chapter") self.assertIsNone(pos) def test_current_chapter_detection(self): """Test detecting current chapter from position""" navigator = ChapterNavigator(self.blocks) # Position in first chapter pos = RenderingPosition(chapter_index=0, block_index=2) chapter = navigator.get_current_chapter(pos) self.assertIsNotNone(chapter) self.assertEqual(chapter.title, "Chapter One") class TestFontScaler(unittest.TestCase): """Test the FontScaler class""" def test_font_scaling(self): """Test font scaling functionality""" original_font = Font(font_size=12) # Test no scaling scaled_font = FontScaler.scale_font(original_font, 1.0) self.assertEqual(scaled_font.font_size, 12) # Test 2x scaling scaled_font = FontScaler.scale_font(original_font, 2.0) self.assertEqual(scaled_font.font_size, 24) # Test 0.5x scaling scaled_font = FontScaler.scale_font(original_font, 0.5) self.assertEqual(scaled_font.font_size, 6) # Test minimum size constraint scaled_font = FontScaler.scale_font(original_font, 0.01) self.assertGreaterEqual(scaled_font.font_size, 1) def test_word_spacing_scaling(self): """Test word spacing scaling""" original_spacing = (5, 15) # Test no scaling scaled_spacing = FontScaler.scale_word_spacing(original_spacing, 1.0) self.assertEqual(scaled_spacing, (5, 15)) # Test 2x scaling scaled_spacing = FontScaler.scale_word_spacing(original_spacing, 2.0) self.assertEqual(scaled_spacing, (10, 30)) # Test minimum constraints scaled_spacing = FontScaler.scale_word_spacing(original_spacing, 0.1) self.assertGreaterEqual(scaled_spacing[0], 1) self.assertGreaterEqual(scaled_spacing[1], 2) class TestBookmarkManager(unittest.TestCase): """Test the BookmarkManager class""" def setUp(self): """Set up test environment""" self.temp_dir = tempfile.mkdtemp() self.document_id = "test_document" self.bookmark_manager = BookmarkManager(self.document_id, self.temp_dir) def tearDown(self): """Clean up test environment""" shutil.rmtree(self.temp_dir) def test_bookmark_operations(self): """Test bookmark add/remove/get operations""" pos = RenderingPosition(chapter_index=1, block_index=5) # Add bookmark self.bookmark_manager.add_bookmark("test_bookmark", pos) # Get bookmark retrieved_pos = self.bookmark_manager.get_bookmark("test_bookmark") self.assertEqual(retrieved_pos, pos) # List bookmarks bookmarks = self.bookmark_manager.list_bookmarks() self.assertEqual(len(bookmarks), 1) self.assertEqual(bookmarks[0][0], "test_bookmark") self.assertEqual(bookmarks[0][1], pos) # Remove bookmark success = self.bookmark_manager.remove_bookmark("test_bookmark") self.assertTrue(success) # Verify removal retrieved_pos = self.bookmark_manager.get_bookmark("test_bookmark") self.assertIsNone(retrieved_pos) def test_reading_position_persistence(self): """Test saving and loading reading position""" pos = RenderingPosition(chapter_index=2, block_index=10, word_index=5) # Save position self.bookmark_manager.save_reading_position(pos) # Create new manager instance (simulates app restart) new_manager = BookmarkManager(self.document_id, self.temp_dir) # Load position loaded_pos = new_manager.load_reading_position() self.assertEqual(loaded_pos, pos) def test_bookmark_persistence(self): """Test that bookmarks persist across manager instances""" pos = RenderingPosition(chapter_index=1, block_index=5) # Add bookmark self.bookmark_manager.add_bookmark("persistent_bookmark", pos) # Create new manager instance new_manager = BookmarkManager(self.document_id, self.temp_dir) # Verify bookmark exists retrieved_pos = new_manager.get_bookmark("persistent_bookmark") self.assertEqual(retrieved_pos, pos) class TestEreaderLayoutManager(unittest.TestCase): """Test the complete EreaderLayoutManager""" def setUp(self): """Set up test data""" self.temp_dir = tempfile.mkdtemp() self.font = Font() # Create test document with multiple paragraphs and headings self.blocks = [] # Add a heading heading = Heading(HeadingLevel.H1, self.font) heading.add_word(Word("Test", self.font)) heading.add_word(Word("Chapter", self.font)) self.blocks.append(heading) # Add several paragraphs with multiple words for i in range(3): paragraph = Paragraph(self.font) for j in range(20): # 20 words per paragraph paragraph.add_word(Word(f"Word{i}_{j}", self.font)) self.blocks.append(paragraph) self.page_size = (400, 600) self.document_id = "test_document" def tearDown(self): """Clean up test environment""" shutil.rmtree(self.temp_dir) def test_manager_initialization(self): """Test ereader manager initialization""" # Change to temp directory for bookmarks original_cwd = Path.cwd() try: import os os.chdir(self.temp_dir) manager = EreaderLayoutManager( self.blocks, self.page_size, self.document_id ) self.assertEqual(manager.page_size, self.page_size) self.assertEqual(manager.document_id, self.document_id) self.assertEqual(manager.font_scale, 1.0) self.assertIsInstance(manager.current_position, RenderingPosition) manager.shutdown() finally: os.chdir(original_cwd) def test_font_scaling(self): """Test font scaling functionality""" original_cwd = Path.cwd() try: import os os.chdir(self.temp_dir) manager = EreaderLayoutManager( self.blocks, self.page_size, self.document_id ) # Test initial scale self.assertEqual(manager.get_font_scale(), 1.0) # Test scaling page = manager.set_font_scale(1.5) self.assertEqual(manager.get_font_scale(), 1.5) self.assertIsNotNone(page) manager.shutdown() finally: os.chdir(original_cwd) def test_table_of_contents(self): """Test table of contents functionality""" original_cwd = Path.cwd() try: import os os.chdir(self.temp_dir) manager = EreaderLayoutManager( self.blocks, self.page_size, self.document_id ) toc = manager.get_table_of_contents() self.assertGreater(len(toc), 0) # Check first entry title, level, position = toc[0] self.assertEqual(title, "Test Chapter") self.assertEqual(level, HeadingLevel.H1) manager.shutdown() finally: os.chdir(original_cwd) def test_bookmark_functionality(self): """Test bookmark functionality""" original_cwd = Path.cwd() try: import os os.chdir(self.temp_dir) manager = EreaderLayoutManager( self.blocks, self.page_size, self.document_id ) # Add bookmark success = manager.add_bookmark("test_bookmark") self.assertTrue(success) # List bookmarks bookmarks = manager.list_bookmarks() self.assertEqual(len(bookmarks), 1) self.assertEqual(bookmarks[0][0], "test_bookmark") # Jump to bookmark (should work even though it's the same position) page = manager.jump_to_bookmark("test_bookmark") self.assertIsNotNone(page) # Remove bookmark success = manager.remove_bookmark("test_bookmark") self.assertTrue(success) manager.shutdown() finally: os.chdir(original_cwd) def test_progress_tracking(self): """Test reading progress tracking""" original_cwd = Path.cwd() try: import os os.chdir(self.temp_dir) manager = EreaderLayoutManager( self.blocks, self.page_size, self.document_id ) # Initial progress should be 0 progress = manager.get_reading_progress() self.assertGreaterEqual(progress, 0.0) self.assertLessEqual(progress, 1.0) # Get position info info = manager.get_position_info() self.assertIn('position', info) self.assertIn('progress', info) self.assertIn('font_scale', info) manager.shutdown() finally: os.chdir(original_cwd) def test_convenience_function(self): """Test the convenience function""" original_cwd = Path.cwd() try: import os os.chdir(self.temp_dir) manager = create_ereader_manager( self.blocks, self.page_size, self.document_id ) self.assertIsInstance(manager, EreaderLayoutManager) self.assertEqual(manager.page_size, self.page_size) manager.shutdown() finally: os.chdir(original_cwd) if __name__ == '__main__': unittest.main()