scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/writer/tests/test_document_section.py

@@ -1,311 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Comprehensive tests for DocumentSection class.
-
-Tests cover:
-- File read/write operations
-- Git operations (commit, history, diff, checkout)
-- Error handling and edge cases
-- Integration with git repository
-"""
-
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-
-class TestDocumentSectionReadWrite:
-    """Test file read/write operations."""
-
-    @pytest.fixture
-    def temp_file(self):
-        """Create temporary file."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_doc_")
-        temp_file = Path(temp_dir) / "test.tex"
-        temp_file.write_text("Initial content\n")
-
-        yield temp_file
-
-        # Cleanup
-        if Path(temp_dir).exists():
-            shutil.rmtree(temp_dir)
-
-    def test_read_existing_file(self, temp_file):
-        """Test reading existing file."""
-        section = DocumentSection(temp_file)
-        content = section.read()
-
-        assert content is not None
-        assert "Initial content" in str(content)
-
-    def test_read_nonexistent_file(self):
-        """Test reading non-existent file returns None."""
-        section = DocumentSection(Path("/nonexistent/file.tex"))
-        content = section.read()
-
-        assert content is None
-
-    def test_write_file(self, temp_file):
-        """Test writing to file."""
-        section = DocumentSection(temp_file)
-        result = section.write("New content\n")
-
-        assert result is True
-        assert temp_file.read_text() == "New content\n"
-
-    def test_write_with_list(self, temp_file):
-        """Test writing list of lines."""
-        section = DocumentSection(temp_file)
-        result = section.write(["Line 1", "Line 2", "Line 3"])
-
-        assert result is True
-        content = temp_file.read_text()
-        assert "Line 1\nLine 2\nLine 3" in content
-
-    def test_write_nonexistent_directory(self):
-        """Test writing to non-existent directory fails gracefully."""
-        section = DocumentSection(Path("/nonexistent/dir/file.tex"))
-        result = section.write("content")
-
-        assert result is False
-
-    def test_read_write_roundtrip(self, temp_file):
-        """Test reading and writing back same content."""
-        section = DocumentSection(temp_file)
-        original = section.read()
-
-        section.write(original)
-        readback = section.read()
-
-        assert original == readback
-
-
-class TestDocumentSectionGitOperations:
-    """Test git-based operations."""
-
-    @pytest.fixture
-    def git_repo_with_file(self):
-        """Create git repository with test file."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_git_")
-        repo_path = Path(temp_dir)
-
-        # Initialize git repo
-        subprocess.run(
-            ["git", "init"],
-            cwd=repo_path,
-            capture_output=True,
-            check=True,
-        )
-
-        # Configure git
-        subprocess.run(
-            ["git", "config", "user.email", "test@example.com"],
-            cwd=repo_path,
-            capture_output=True,
-            check=True,
-        )
-        subprocess.run(
-            ["git", "config", "user.name", "Test User"],
-            cwd=repo_path,
-            capture_output=True,
-            check=True,
-        )
-
-        # Create test file
-        test_file = repo_path / "test.tex"
-        test_file.write_text("Initial content\n")
-
-        # Initial commit
-        subprocess.run(
-            ["git", "add", "test.tex"],
-            cwd=repo_path,
-            capture_output=True,
-            check=True,
-        )
-        subprocess.run(
-            ["git", "commit", "-m", "Initial commit"],
-            cwd=repo_path,
-            capture_output=True,
-            check=True,
-        )
-
-        yield test_file, repo_path
-
-        # Cleanup
-        if repo_path.exists():
-            shutil.rmtree(repo_path)
-
-    def test_commit_file(self, git_repo_with_file):
-        """Test committing file to git."""
-        test_file, repo_path = git_repo_with_file
-
-        section = DocumentSection(test_file, git_root=repo_path)
-        section.write("Updated content\n")
-        result = section.commit("Update test file")
-
-        assert result is True
-
-        # Verify commit was made
-        log_result = subprocess.run(
-            ["git", "log", "--oneline"],
-            cwd=repo_path,
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        assert "Update test file" in log_result.stdout
-
-    def test_history_shows_commits(self, git_repo_with_file):
-        """Test getting file history."""
-        test_file, repo_path = git_repo_with_file
-
-        section = DocumentSection(test_file, git_root=repo_path)
-        section.write("Update 1\n")
-        section.commit("Commit 1")
-        section.write("Update 2\n")
-        section.commit("Commit 2")
-
-        history = section.history()
-
-        assert len(history) >= 2
-        assert any("Commit 1" in h for h in history)
-        assert any("Commit 2" in h for h in history)
-
-    def test_diff_shows_changes(self, git_repo_with_file):
-        """Test getting diff of changes."""
-        test_file, repo_path = git_repo_with_file
-
-        section = DocumentSection(test_file, git_root=repo_path)
-        section.write("Changed content\n")
-
-        diff = section.diff()
-
-        assert len(diff) > 0
-        assert "Changed content" in diff or "-" in diff
-
-    def test_checkout_restores_file(self, git_repo_with_file):
-        """Test checking out file from git."""
-        test_file, repo_path = git_repo_with_file
-
-        section = DocumentSection(test_file, git_root=repo_path)
-
-        # Modify file
-        section.write("Modified content\n")
-        modified = section.read()
-
-        # Restore from HEAD
-        result = section.checkout("HEAD")
-
-        assert result is True
-        restored = section.read()
-        assert restored != modified
-        assert "Initial content" in str(restored)
-
-    def test_history_empty_without_git(self):
-        """Test history returns empty list without git repo."""
-        temp_file = Path(tempfile.mktemp(suffix=".tex"))
-        temp_file.write_text("content\n")
-
-        section = DocumentSection(temp_file)
-        history = section.history()
-
-        assert history == []
-
-        # Cleanup
-        temp_file.unlink()
-
-    def test_diff_empty_without_git(self):
-        """Test diff returns empty string without git repo."""
-        temp_file = Path(tempfile.mktemp(suffix=".tex"))
-        temp_file.write_text("content\n")
-
-        section = DocumentSection(temp_file)
-        diff = section.diff()
-
-        assert diff == ""
-
-        # Cleanup
-        temp_file.unlink()
-
-    def test_commit_fails_without_git(self):
-        """Test commit returns False without git repo."""
-        temp_file = Path(tempfile.mktemp(suffix=".tex"))
-        temp_file.write_text("content\n")
-
-        section = DocumentSection(temp_file)
-        result = section.commit("test message")
-
-        assert result is False
-
-        # Cleanup
-        temp_file.unlink()
-
-
-class TestDocumentSectionRepresentation:
-    """Test string representation."""
-
-    def test_repr(self):
-        """Test __repr__ shows filename."""
-        section = DocumentSection(Path("/path/to/introduction.tex"))
-        repr_str = repr(section)
-
-        assert "DocumentSection" in repr_str
-        assert "introduction.tex" in repr_str
-
-
-class TestDocumentSectionPathHandling:
-    """Test path handling."""
-
-    def test_path_attribute(self):
-        """Test path attribute is stored."""
-        path = Path("/path/to/file.tex")
-        section = DocumentSection(path)
-
-        assert section.path == path
-
-    def test_git_root_passed_explicitly(self):
-        """Test git_root is stored when passed."""
-        git_root = Path("/path/to/git")
-        section = DocumentSection(Path("/path/to/file.tex"), git_root=git_root)
-
-        assert section.git_root == git_root
-
-
-class TestDocumentSectionErrorHandling:
-    """Test error handling."""
-
-    def test_read_unicode_fallback(self):
-        """Test read handles encoding errors gracefully."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_enc_")
-        temp_file = Path(temp_dir) / "test.tex"
-
-        # Write with UTF-8
-        temp_file.write_text("Valid UTF-8 content\n", encoding="utf-8")
-
-        section = DocumentSection(temp_file)
-        content = section.read()
-
-        assert content is not None
-        assert "Valid UTF-8 content" in str(content)
-
-        # Cleanup
-        shutil.rmtree(temp_dir)
-
-    def test_write_handles_exceptions(self):
-        """Test write handles exceptions gracefully."""
-        # Use a path that will fail to write
-        section = DocumentSection(Path("/root/impossible/path/file.tex"))
-        result = section.write("content")
-
-        assert result is False
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

scitex/writer/tests/test_document_workflow.py

@@ -1,393 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-End-to-end workflow tests for Writer document operations.
-
-Tests complete workflows:
-- Create project → access section → read/write/commit
-- Multi-section editing
-- Document tree navigation
-- Git history tracking
-"""
-
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-from scitex.writer.Writer import Writer
-
-
-class TestWriterDocumentWorkflow:
-    """Test complete document editing workflows."""
-
-    @pytest.fixture
-    def valid_project_dir(self):
-        """Create a valid project structure."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_workflow_")
-        project_dir = Path(temp_dir)
-
-        # Create required structure with contents subdirectory
-        (project_dir / "01_manuscript" / "contents").mkdir(parents=True, exist_ok=True)
-        (project_dir / "02_supplementary").mkdir(parents=True, exist_ok=True)
-        (project_dir / "03_revision").mkdir(parents=True, exist_ok=True)
-
-        # Create manuscript files
-        (project_dir / "01_manuscript" / "base.tex").write_text("\\documentclass{article}\n")
-        (project_dir / "01_manuscript" / "README.md").write_text("# Manuscript\n")
-
-        # Create manuscript content files
-        (project_dir / "01_manuscript" / "contents" / "abstract.tex").write_text("Abstract content\n")
-        (project_dir / "01_manuscript" / "contents" / "introduction.tex").write_text("Introduction content\n")
-        (project_dir / "01_manuscript" / "contents" / "methods.tex").write_text("Methods content\n")
-        (project_dir / "01_manuscript" / "contents" / "results.tex").write_text("Results content\n")
-        (project_dir / "01_manuscript" / "contents" / "discussion.tex").write_text("Discussion content\n")
-
-        # Create directories for figures and tables
-        (project_dir / "01_manuscript" / "contents" / "figures").mkdir(exist_ok=True)
-        (project_dir / "01_manuscript" / "contents" / "tables").mkdir(exist_ok=True)
-
-        # Initialize git repo
-        subprocess.run(
-            ["git", "init"],
-            cwd=project_dir,
-            capture_output=True,
-            check=True,
-        )
-        subprocess.run(
-            ["git", "config", "user.email", "test@example.com"],
-            cwd=project_dir,
-            capture_output=True,
-            check=True,
-        )
-        subprocess.run(
-            ["git", "config", "user.name", "Test User"],
-            cwd=project_dir,
-            capture_output=True,
-            check=True,
-        )
-        subprocess.run(
-            ["git", "add", "."],
-            cwd=project_dir,
-            capture_output=True,
-            check=True,
-        )
-        subprocess.run(
-            ["git", "commit", "-m", "Initial commit"],
-            cwd=project_dir,
-            capture_output=True,
-            check=True,
-        )
-
-        yield project_dir
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    def test_access_manuscript_introduction(self, valid_project_dir):
-        """Test accessing manuscript introduction section."""
-        from scitex.writer.dataclasses.tree._ManuscriptTree import ManuscriptTree
-
-        # Create actual tree without mocking
-        tree = ManuscriptTree(
-            valid_project_dir / "01_manuscript",
-            git_root=valid_project_dir,
-        )
-
-        # Access introduction through contents
-        intro = tree.contents.introduction
-        assert intro is not None
-        assert intro.path.name == "introduction.tex"
-
-    def test_read_section_content(self, valid_project_dir):
-        """Test reading section content."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        content = section.read()
-        assert content is not None
-        assert "Introduction content" in str(content)
-
-    def test_write_section_content(self, valid_project_dir):
-        """Test writing to section."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        new_content = "Updated introduction with new content\n"
-        result = section.write(new_content)
-
-        assert result is True
-        assert intro_path.read_text() == new_content
-
-    def test_commit_section_changes(self, valid_project_dir):
-        """Test committing changes to section."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        # Modify and commit
-        section.write("Updated introduction\n")
-        result = section.commit("Update introduction section")
-
-        assert result is True
-
-        # Verify commit exists
-        log = subprocess.run(
-            ["git", "log", "--oneline"],
-            cwd=valid_project_dir,
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        assert "Update introduction section" in log.stdout
-
-    def test_access_multiple_sections(self, valid_project_dir):
-        """Test accessing multiple sections."""
-        from scitex.writer.dataclasses.contents._ManuscriptContents import (
-            ManuscriptContents,
-        )
-
-        contents = ManuscriptContents(
-            valid_project_dir / "01_manuscript" / "contents",
-            git_root=valid_project_dir,
-        )
-
-        # Access different sections
-        assert contents.abstract is not None
-        assert contents.introduction is not None
-        assert contents.methods is not None
-        assert contents.results is not None
-        assert contents.discussion is not None
-
-        # All should be DocumentSection instances
-        assert hasattr(contents.abstract, "read")
-        assert hasattr(contents.introduction, "commit")
-
-    def test_read_write_commit_workflow(self, valid_project_dir):
-        """Test complete read-write-commit workflow."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        # Read initial
-        original = section.read()
-        assert original is not None
-
-        # Modify
-        modified = "Completely new introduction\n"
-        section.write(modified)
-
-        # Verify modification (read returns what scitex.io gives us - could be list or string)
-        readback = section.read()
-        if isinstance(readback, list):
-            assert any("Completely new introduction" in line for line in readback)
-        else:
-            assert "Completely new introduction" in str(readback)
-
-        # Commit
-        commit_result = section.commit("Rewrite introduction")
-        assert commit_result is True
-
-        # Check history shows both commits
-        history = section.history()
-        assert len(history) >= 1
-        assert any("Rewrite introduction" in h for h in history)
-
-    def test_diff_shows_changes(self, valid_project_dir):
-        """Test diff operation shows changes."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        # Modify file
-        section.write("Modified introduction\n")
-
-        # Get diff
-        diff = section.diff()
-
-        assert len(diff) > 0
-
-    def test_checkout_reverts_changes(self, valid_project_dir):
-        """Test checking out file reverts to previous version."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        original = section.read()
-
-        # Modify
-        section.write("New content\n")
-        modified = section.read()
-        assert modified != original
-
-        # Checkout HEAD (revert)
-        result = section.checkout("HEAD")
-        assert result is True
-
-        # Verify reverted
-        reverted = section.read()
-        assert reverted == original
-
-    def test_history_tracks_commits(self, valid_project_dir):
-        """Test history tracks multiple commits."""
-        from scitex.writer.dataclasses.core._DocumentSection import DocumentSection
-
-        intro_path = valid_project_dir / "01_manuscript" / "contents" / "introduction.tex"
-        section = DocumentSection(intro_path, git_root=valid_project_dir)
-
-        # Make multiple commits
-        section.write("Version 1\n")
-        section.commit("Version 1")
-
-        section.write("Version 2\n")
-        section.commit("Version 2")
-
-        section.write("Version 3\n")
-        section.commit("Version 3")
-
-        # Check history
-        history = section.history()
-        assert len(history) >= 3
-        assert any("Version 1" in h for h in history)
-        assert any("Version 2" in h for h in history)
-        assert any("Version 3" in h for h in history)
-
-    def test_tree_structure_verification(self, valid_project_dir):
-        """Test verifying manuscript tree structure."""
-        from scitex.writer.dataclasses.tree._ManuscriptTree import ManuscriptTree
-
-        tree = ManuscriptTree(
-            valid_project_dir / "01_manuscript",
-            git_root=valid_project_dir,
-        )
-
-        is_valid, missing = tree.verify_structure()
-        assert is_valid is True
-        assert len(missing) == 0
-
-
-class TestManuscriptContentsAccess:
-    """Test accessing all manuscript content sections."""
-
-    @pytest.fixture
-    def manuscript_contents_dir(self):
-        """Create manuscript contents directory with all files."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_contents_")
-        contents_dir = Path(temp_dir)
-
-        # Create all section files
-        sections = [
-            "abstract.tex",
-            "introduction.tex",
-            "methods.tex",
-            "results.tex",
-            "discussion.tex",
-            "title.tex",
-            "authors.tex",
-            "keywords.tex",
-            "journal_name.tex",
-            "graphical_abstract.tex",
-            "highlights.tex",
-            "data_availability.tex",
-            "additional_info.tex",
-            "wordcount.tex",
-            "bibliography.bib",
-        ]
-
-        for section in sections:
-            (contents_dir / section).write_text(f"{section} content\n")
-
-        # Create directories
-        (contents_dir / "figures").mkdir(exist_ok=True)
-        (contents_dir / "tables").mkdir(exist_ok=True)
-        (contents_dir / "latex_styles").mkdir(exist_ok=True)
-
-        yield contents_dir
-
-        # Cleanup
-        if contents_dir.exists():
-            shutil.rmtree(contents_dir)
-
-    def test_access_all_core_sections(self, manuscript_contents_dir):
-        """Test accessing all core manuscript sections."""
-        from scitex.writer.dataclasses.contents._ManuscriptContents import (
-            ManuscriptContents,
-        )
-
-        contents = ManuscriptContents(manuscript_contents_dir)
-
-        # Core sections
-        assert contents.abstract is not None
-        assert contents.introduction is not None
-        assert contents.methods is not None
-        assert contents.results is not None
-        assert contents.discussion is not None
-
-        # Read from each
-        assert "abstract.tex content" in str(contents.abstract.read())
-        assert "introduction.tex content" in str(contents.introduction.read())
-
-    def test_access_all_metadata_sections(self, manuscript_contents_dir):
-        """Test accessing metadata sections."""
-        from scitex.writer.dataclasses.contents._ManuscriptContents import (
-            ManuscriptContents,
-        )
-
-        contents = ManuscriptContents(manuscript_contents_dir)
-
-        assert contents.title is not None
-        assert contents.authors is not None
-        assert contents.keywords is not None
-        assert contents.journal_name is not None
-
-    def test_access_optional_sections(self, manuscript_contents_dir):
-        """Test accessing optional sections."""
-        from scitex.writer.dataclasses.contents._ManuscriptContents import (
-            ManuscriptContents,
-        )
-
-        contents = ManuscriptContents(manuscript_contents_dir)
-
-        assert contents.graphical_abstract is not None
-        assert contents.highlights is not None
-        assert contents.data_availability is not None
-
-    def test_access_bibliography(self, manuscript_contents_dir):
-        """Test accessing bibliography file."""
-        from scitex.writer.dataclasses.contents._ManuscriptContents import (
-            ManuscriptContents,
-        )
-
-        contents = ManuscriptContents(manuscript_contents_dir)
-
-        assert contents.bibliography is not None
-        assert contents.bibliography.path.name == "bibliography.bib"
-
-    def test_access_directories(self, manuscript_contents_dir):
-        """Test accessing figure and table directories."""
-        from scitex.writer.dataclasses.contents._ManuscriptContents import (
-            ManuscriptContents,
-        )
-
-        contents = ManuscriptContents(manuscript_contents_dir)
-
-        assert contents.figures is not None
-        assert contents.figures.exists()
-        assert contents.tables is not None
-        assert contents.tables.exists()
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])