303 lines
10 KiB
Python
303 lines
10 KiB
Python
"""
|
|
Tests for pyWebLayout.io.readers.base module.
|
|
|
|
Tests the base reader classes and their functionality.
|
|
"""
|
|
|
|
import pytest
|
|
from pyWebLayout.io.readers.base import (
|
|
BaseReader,
|
|
MetadataReader,
|
|
StructureReader,
|
|
ContentReader,
|
|
ResourceReader,
|
|
CompositeReader
|
|
)
|
|
from pyWebLayout.abstract.document import Document
|
|
|
|
|
|
# Concrete implementations for testing
|
|
|
|
class ConcreteBaseReader(BaseReader):
|
|
"""Test implementation of BaseReader."""
|
|
|
|
def can_read(self, source):
|
|
return isinstance(source, str) and source.endswith('.test')
|
|
|
|
def read(self, source, **options):
|
|
doc = Document()
|
|
doc.set_metadata('source', source)
|
|
return doc
|
|
|
|
|
|
class ConcreteMetadataReader(MetadataReader):
|
|
"""Test implementation of MetadataReader."""
|
|
|
|
def extract_metadata(self, source, document):
|
|
metadata = {
|
|
'title': 'Test Title',
|
|
'author': 'Test Author'
|
|
}
|
|
document.set_metadata('title', metadata['title'])
|
|
document.set_metadata('author', metadata['author'])
|
|
return metadata
|
|
|
|
|
|
class ConcreteStructureReader(StructureReader):
|
|
"""Test implementation of StructureReader."""
|
|
|
|
def extract_structure(self, source, document):
|
|
return ['heading1', 'heading2']
|
|
|
|
|
|
class ConcreteContentReader(ContentReader):
|
|
"""Test implementation of ContentReader."""
|
|
|
|
def extract_content(self, source, document):
|
|
return "Test content"
|
|
|
|
|
|
class ConcreteResourceReader(ResourceReader):
|
|
"""Test implementation of ResourceReader."""
|
|
|
|
def extract_resources(self, source, document):
|
|
resources = {
|
|
'image1.png': b'fake image data',
|
|
'style.css': 'fake css'
|
|
}
|
|
for name, data in resources.items():
|
|
document.add_resource(name, data)
|
|
return resources
|
|
|
|
|
|
class ConcreteCompositeReader(CompositeReader):
|
|
"""Test implementation of CompositeReader."""
|
|
|
|
def can_read(self, source):
|
|
return True
|
|
|
|
|
|
# Test Cases
|
|
|
|
class TestBaseReaderOptions:
|
|
"""Test BaseReader options functionality."""
|
|
|
|
def test_set_and_get_option(self):
|
|
"""Test setting and getting options."""
|
|
reader = ConcreteBaseReader()
|
|
reader.set_option('font_size', 12)
|
|
assert reader.get_option('font_size') == 12
|
|
|
|
def test_get_option_with_default(self):
|
|
"""Test getting option with default value."""
|
|
reader = ConcreteBaseReader()
|
|
assert reader.get_option('nonexistent', 'default_value') == 'default_value'
|
|
|
|
def test_get_option_without_default(self):
|
|
"""Test getting nonexistent option without default."""
|
|
reader = ConcreteBaseReader()
|
|
assert reader.get_option('nonexistent') is None
|
|
|
|
def test_multiple_options(self):
|
|
"""Test setting multiple options."""
|
|
reader = ConcreteBaseReader()
|
|
reader.set_option('font_size', 12)
|
|
reader.set_option('line_height', 1.5)
|
|
reader.set_option('color', 'black')
|
|
|
|
assert reader.get_option('font_size') == 12
|
|
assert reader.get_option('line_height') == 1.5
|
|
assert reader.get_option('color') == 'black'
|
|
|
|
|
|
class TestBaseReaderConcrete:
|
|
"""Test concrete BaseReader implementation."""
|
|
|
|
def test_can_read_valid_source(self):
|
|
"""Test can_read with valid source."""
|
|
reader = ConcreteBaseReader()
|
|
assert reader.can_read('document.test') is True
|
|
|
|
def test_can_read_invalid_source(self):
|
|
"""Test can_read with invalid source."""
|
|
reader = ConcreteBaseReader()
|
|
assert reader.can_read('document.html') is False
|
|
|
|
def test_read_creates_document(self):
|
|
"""Test read creates a Document."""
|
|
reader = ConcreteBaseReader()
|
|
doc = reader.read('test.test')
|
|
assert isinstance(doc, Document)
|
|
assert doc.get_metadata('source') == 'test.test'
|
|
|
|
|
|
class TestMetadataReaderConcrete:
|
|
"""Test concrete MetadataReader implementation."""
|
|
|
|
def test_extract_metadata(self):
|
|
"""Test metadata extraction."""
|
|
reader = ConcreteMetadataReader()
|
|
doc = Document()
|
|
metadata = reader.extract_metadata('source', doc)
|
|
|
|
assert metadata['title'] == 'Test Title'
|
|
assert metadata['author'] == 'Test Author'
|
|
assert doc.get_metadata('title') == 'Test Title'
|
|
assert doc.get_metadata('author') == 'Test Author'
|
|
|
|
|
|
class TestStructureReaderConcrete:
|
|
"""Test concrete StructureReader implementation."""
|
|
|
|
def test_extract_structure(self):
|
|
"""Test structure extraction."""
|
|
reader = ConcreteStructureReader()
|
|
doc = Document()
|
|
structure = reader.extract_structure('source', doc)
|
|
|
|
assert isinstance(structure, list)
|
|
assert len(structure) == 2
|
|
assert structure[0] == 'heading1'
|
|
assert structure[1] == 'heading2'
|
|
|
|
|
|
class TestContentReaderConcrete:
|
|
"""Test concrete ContentReader implementation."""
|
|
|
|
def test_extract_content(self):
|
|
"""Test content extraction."""
|
|
reader = ConcreteContentReader()
|
|
doc = Document()
|
|
content = reader.extract_content('source', doc)
|
|
|
|
assert content == "Test content"
|
|
|
|
|
|
class TestResourceReaderConcrete:
|
|
"""Test concrete ResourceReader implementation."""
|
|
|
|
def test_extract_resources(self):
|
|
"""Test resource extraction."""
|
|
reader = ConcreteResourceReader()
|
|
doc = Document()
|
|
resources = reader.extract_resources('source', doc)
|
|
|
|
assert isinstance(resources, dict)
|
|
assert 'image1.png' in resources
|
|
assert 'style.css' in resources
|
|
assert doc.get_resource('image1.png') == b'fake image data'
|
|
assert doc.get_resource('style.css') == 'fake css'
|
|
|
|
|
|
class TestCompositeReader:
|
|
"""Test CompositeReader functionality."""
|
|
|
|
def test_initialization(self):
|
|
"""Test composite reader initialization."""
|
|
reader = ConcreteCompositeReader()
|
|
assert reader._metadata_reader is None
|
|
assert reader._structure_reader is None
|
|
assert reader._content_reader is None
|
|
assert reader._resource_reader is None
|
|
|
|
def test_set_metadata_reader(self):
|
|
"""Test setting metadata reader."""
|
|
reader = ConcreteCompositeReader()
|
|
metadata_reader = ConcreteMetadataReader()
|
|
reader.set_metadata_reader(metadata_reader)
|
|
assert reader._metadata_reader is metadata_reader
|
|
|
|
def test_set_structure_reader(self):
|
|
"""Test setting structure reader."""
|
|
reader = ConcreteCompositeReader()
|
|
structure_reader = ConcreteStructureReader()
|
|
reader.set_structure_reader(structure_reader)
|
|
assert reader._structure_reader is structure_reader
|
|
|
|
def test_set_content_reader(self):
|
|
"""Test setting content reader."""
|
|
reader = ConcreteCompositeReader()
|
|
content_reader = ConcreteContentReader()
|
|
reader.set_content_reader(content_reader)
|
|
assert reader._content_reader is content_reader
|
|
|
|
def test_set_resource_reader(self):
|
|
"""Test setting resource reader."""
|
|
reader = ConcreteCompositeReader()
|
|
resource_reader = ConcreteResourceReader()
|
|
reader.set_resource_reader(resource_reader)
|
|
assert reader._resource_reader is resource_reader
|
|
|
|
def test_read_with_all_readers(self):
|
|
"""Test reading with all readers configured."""
|
|
reader = ConcreteCompositeReader()
|
|
reader.set_metadata_reader(ConcreteMetadataReader())
|
|
reader.set_structure_reader(ConcreteStructureReader())
|
|
reader.set_content_reader(ConcreteContentReader())
|
|
reader.set_resource_reader(ConcreteResourceReader())
|
|
|
|
doc = reader.read('test_source')
|
|
|
|
# Verify metadata was extracted
|
|
assert doc.get_metadata('title') == 'Test Title'
|
|
assert doc.get_metadata('author') == 'Test Author'
|
|
|
|
# Verify resources were extracted
|
|
assert doc.get_resource('image1.png') == b'fake image data'
|
|
assert doc.get_resource('style.css') == 'fake css'
|
|
|
|
def test_read_with_no_readers(self):
|
|
"""Test reading with no readers configured."""
|
|
reader = ConcreteCompositeReader()
|
|
doc = reader.read('test_source')
|
|
|
|
# Should create an empty document
|
|
assert isinstance(doc, Document)
|
|
|
|
def test_read_with_only_metadata_reader(self):
|
|
"""Test reading with only metadata reader."""
|
|
reader = ConcreteCompositeReader()
|
|
reader.set_metadata_reader(ConcreteMetadataReader())
|
|
|
|
doc = reader.read('test_source')
|
|
assert doc.get_metadata('title') == 'Test Title'
|
|
|
|
def test_read_with_options(self):
|
|
"""Test reading with options."""
|
|
reader = ConcreteCompositeReader()
|
|
reader.set_metadata_reader(ConcreteMetadataReader())
|
|
|
|
doc = reader.read('test_source', font_size=14, encoding='utf-8')
|
|
|
|
# Verify options were stored
|
|
assert reader.get_option('font_size') == 14
|
|
assert reader.get_option('encoding') == 'utf-8'
|
|
|
|
def test_can_read_implemented(self):
|
|
"""Test that can_read is implemented in ConcreteCompositeReader."""
|
|
reader = ConcreteCompositeReader()
|
|
assert reader.can_read('test_source') is True
|
|
|
|
|
|
class TestCompositeReaderIntegration:
|
|
"""Integration tests for CompositeReader."""
|
|
|
|
def test_full_document_reading_workflow(self):
|
|
"""Test complete document reading workflow."""
|
|
# Create and configure composite reader
|
|
reader = ConcreteCompositeReader()
|
|
reader.set_metadata_reader(ConcreteMetadataReader())
|
|
reader.set_structure_reader(ConcreteStructureReader())
|
|
reader.set_content_reader(ConcreteContentReader())
|
|
reader.set_resource_reader(ConcreteResourceReader())
|
|
|
|
# Read document with options
|
|
doc = reader.read('complex_document.test', font_size=16, page_width=800)
|
|
|
|
# Verify all components worked together
|
|
assert doc.get_metadata('title') == 'Test Title'
|
|
assert doc.get_metadata('author') == 'Test Author'
|
|
assert doc.get_resource('image1.png') is not None
|
|
assert reader.get_option('font_size') == 16
|
|
assert reader.get_option('page_width') == 800
|