test_pyread.py

#!/usr/bin/env python3
"""
Simple tests for PyRead functionality.
Run with: python test_pyread.py
"""

import sys
from pathlib import Path
import tempfile
import shutil

# Add parent directory to path
sys.path.insert(0, str(Path(__file__).parent))

from pyread import (
    TextCleaner,
    FormatDetector,
    FileFormat,
    TxtExtractor,
    OutputManager,
)


def test_text_cleaner():
    """Test text cleaning and normalization"""
    print("Testing TextCleaner...")
    
    # Test basic cleaning
    dirty_text = "  Hello   World  \n\n\n\n  Test  "
    clean = TextCleaner.clean(dirty_text)
    assert "Hello World" in clean
    assert clean.count('\n') <= 2
    print("  ✓ Basic cleaning")
    
    # Test NFKC normalization
    unicode_text = "fi ①"  # ligature and circled digit
    clean = TextCleaner.clean(unicode_text)
    assert "fi" in clean or "1" in clean  # Should normalize
    print("  ✓ NFKC normalization")
    
    # Test control character removal
    control_text = "Hello\x00\x01World"
    clean = TextCleaner.clean(control_text)
    assert '\x00' not in clean
    assert '\x01' not in clean
    print("  ✓ Control character removal")
    
    # Test ASCII forcing
    unicode_text = "Hello 世界 World"
    clean = TextCleaner.clean(unicode_text, force_ascii=True)
    assert all(ord(c) < 128 for c in clean)
    print("  ✓ ASCII forcing")
    
    print("✅ TextCleaner tests passed\n")


def test_format_detector():
    """Test format detection"""
    print("Testing FormatDetector...")
    
    # Test extension-based detection
    assert FormatDetector.detect(Path("test.pdf")) == FileFormat.PDF
    assert FormatDetector.detect(Path("test.txt")) == FileFormat.TXT
    assert FormatDetector.detect(Path("test.epub")) == FileFormat.EPUB
    assert FormatDetector.detect(Path("test.html")) == FileFormat.HTML
    print("  ✓ Extension-based detection")
    
    print("✅ FormatDetector tests passed\n")


def test_txt_extractor():
    """Test text file extraction"""
    print("Testing TxtExtractor...")
    
    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False, encoding='utf-8') as f:
        f.write("Hello, World!\nThis is a test.")
        temp_path = Path(f.name)
    
    try:
        result = TxtExtractor.extract(temp_path)
        assert result.success
        assert "Hello, World!" in result.text
        assert "test" in result.text
        print("  ✓ UTF-8 text extraction")
    finally:
        temp_path.unlink()
    
    print("✅ TxtExtractor tests passed\n")


def test_output_manager():
    """Test output path generation and versioning"""
    print("Testing OutputManager...")
    
    # Test same directory output
    input_path = Path("/home/user/docs/file.pdf")
    output_path = OutputManager.get_output_path(input_path)
    assert output_path.name == "file.txt"
    assert output_path.parent == input_path.parent
    print("  ✓ Same directory output")
    
    # Test custom output directory
    output_dir = Path("/home/user/output")
    output_path = OutputManager.get_output_path(input_path, output_dir)
    assert output_path.name == "file.txt"
    assert output_path.parent == output_dir
    print("  ✓ Custom output directory")
    
    # Test structure preservation
    base_dir = Path("/home/user/docs")
    nested_input = Path("/home/user/docs/subdir/file.pdf")
    output_path = OutputManager.get_output_path(nested_input, output_dir, base_dir)
    assert output_path == output_dir / "subdir" / "file.txt"
    print("  ✓ Directory structure preservation")
    
    # Test versioning
    with tempfile.TemporaryDirectory() as tmpdir:
        tmpdir = Path(tmpdir)
        
        # Create first file
        test_file = tmpdir / "test.txt"
        test_file.write_text("version 1")
        
        # Test get_versioned_path
        versioned = OutputManager.get_versioned_path(test_file)
        assert versioned.name == "test_v2.txt"
        print("  ✓ Versioned path generation")
        
        # Create v2 and test again
        versioned.write_text("version 2")
        versioned_3 = OutputManager.get_versioned_path(test_file)
        assert versioned_3.name == "test_v3.txt"
        print("  ✓ Multiple version handling")
        
        # Test write_text with auto_version
        success, error, actual_path = OutputManager.write_text(
            test_file, "new content", overwrite=False, auto_version=True
        )
        assert success
        assert actual_path.name == "test_v3.txt"
        assert actual_path.exists()
        print("  ✓ Auto-versioning on write")
        
        # Test write_text with overwrite
        original_content = test_file.read_text()
        success, error, actual_path = OutputManager.write_text(
            test_file, "overwritten", overwrite=True, auto_version=False
        )
        assert success
        assert actual_path == test_file
        assert test_file.read_text() == "overwritten"
        print("  ✓ Overwrite mode")
    
    print("✅ OutputManager tests passed\n")


def test_write_and_read():
    """Test end-to-end write and read"""
    print("Testing end-to-end processing...")
    
    with tempfile.TemporaryDirectory() as tmpdir:
        tmpdir = Path(tmpdir)
        
        # Create test input file
        input_file = tmpdir / "test.txt"
        input_file.write_text("Hello, World!\n\nThis is a test.", encoding='utf-8')
        
        # Process it
        from pyread import process_file
        
        output_file = tmpdir / "test_output.txt"
        success, message = process_file(
            input_file,
            output_dir=tmpdir.parent,
            base_dir=tmpdir,
            force_ascii=False,
            use_ocr=False,
            overwrite=True
        )
        
        if success:
            print(f"  ✓ Processing succeeded: {message}")
        else:
            print(f"  ✗ Processing failed: {message}")
    
    print("✅ End-to-end test completed\n")


def run_all_tests():
    """Run all tests"""
    # Ensure UTF-8 output on Windows
    import io
    if hasattr(sys.stdout, 'reconfigure'):
        sys.stdout.reconfigure(encoding='utf-8')
    
    print("=" * 60)
    print("Running PyRead Tests")
    print("=" * 60 + "\n")
    
    try:
        test_text_cleaner()
        test_format_detector()
        test_txt_extractor()
        test_output_manager()
        test_write_and_read()
        
        print("=" * 60)
        print("✅ All tests passed!")
        print("=" * 60)
        return True
        
    except AssertionError as e:
        print(f"\n❌ Test failed: {e}")
        return False
    except Exception as e:
        print(f"\n❌ Unexpected error: {e}")
        import traceback
        traceback.print_exc()
        return False


if __name__ == "__main__":
    success = run_all_tests()
    sys.exit(0 if success else 1)