scitex 2.7.3__py3-none-any.whl → 2.10.0__py3-none-any.whl

scitex/writer/tests/test_document_section.py

@@ -0,0 +1,311 @@
+#!/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

@@ -0,0 +1,393 @@
+#!/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"])