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

scitex/writer/tests/test_writer.py

@@ -1,361 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Comprehensive tests for Writer class initialization and git strategy handling.
-
-Tests cover:
-- Writer initialization
-- Git strategy handling (child, parent, None)
-- Project creation and attachment
-- Project structure verification
-- Child git removal when parent git found
-"""
-
-import shutil
-import tempfile
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from scitex.writer import Writer
-
-
-class TestWriterInitialization:
-    """Test Writer class initialization."""
-
-    @pytest.fixture
-    def temp_project_dir(self):
-        """Create temporary project directory."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_test_")
-        yield Path(temp_dir)
-        # Cleanup
-        if Path(temp_dir).exists():
-            shutil.rmtree(temp_dir)
-
-    @pytest.fixture
-    def valid_project_structure(self, temp_project_dir):
-        """Create a valid project structure."""
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (temp_project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-        return temp_project_dir
-
-    def test_writer_creation_with_project_name(self):
-        """Test Writer initialization stores project name correctly."""
-        # This test is covered by test_writer_integration.py which tests the actual behavior
-        # Placeholder for future detailed unit tests if needed
-        pass
-
-    def test_writer_project_name_from_parameter(self):
-        """Test Writer stores explicit project name."""
-        assert True  # Placeholder - needs full environment setup
-
-    def test_writer_project_name_from_directory(self):
-        """Test Writer derives project name from directory path."""
-        assert True  # Placeholder - needs full environment setup
-
-
-class TestProjectAttachment:
-    """Test attaching to existing projects."""
-
-    @pytest.fixture
-    def valid_project(self):
-        """Create a valid project structure."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_valid_")
-        project_dir = Path(temp_dir)
-
-        # Create required structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        yield project_dir
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    @pytest.fixture
-    def invalid_project(self):
-        """Create invalid project structure (missing directories)."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_invalid_")
-        project_dir = Path(temp_dir)
-
-        # Only create one directory
-        (project_dir / "01_manuscript").mkdir(parents=True, exist_ok=True)
-
-        yield project_dir
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    def test_attach_to_valid_project(self, valid_project):
-        """Test attaching to existing valid project."""
-        # This would require full environment setup
-        assert valid_project.exists()
-        assert (valid_project / "01_manuscript").exists()
-        assert (valid_project / "02_supplementary").exists()
-        assert (valid_project / "03_revision").exists()
-
-    def test_attach_to_invalid_project_raises_error(self, invalid_project):
-        """Test attaching to invalid project raises RuntimeError."""
-        # Structure validation should fail
-        assert (invalid_project / "01_manuscript").exists()
-        assert not (invalid_project / "02_supplementary").exists()
-
-
-class TestGitStrategyChild:
-    """Test 'child' git strategy (isolated repository)."""
-
-    def test_child_strategy_creates_isolated_git(self):
-        """Test child strategy creates git repo in project directory."""
-        # Expected behavior:
-        # 1. Project directory created
-        # 2. .git/ created in project_dir
-        # 3. self.git_root = project_dir
-        assert True  # Placeholder
-
-    def test_child_strategy_with_existing_project(self):
-        """Test child strategy initializes git in existing project."""
-        assert True  # Placeholder
-
-    def test_child_strategy_initial_commit(self):
-        """Test child strategy makes initial commit."""
-        assert True  # Placeholder
-
-
-class TestGitStrategyParent:
-    """Test 'parent' git strategy (shared repository)."""
-
-    def test_parent_strategy_finds_parent_git(self):
-        """Test parent strategy finds parent git repository."""
-        assert True  # Placeholder
-
-    def test_parent_strategy_removes_child_git(self):
-        """Test parent strategy removes project's child .git folder."""
-        # Expected behavior:
-        # 1. _clone_writer_project creates project with .git
-        # 2. Parent git found
-        # 3. _remove_child_git() called
-        # 4. Project .git removed
-        # 5. self.git_root = parent_git
-        assert True  # Placeholder
-
-    def test_parent_strategy_no_child_git(self):
-        """Test parent strategy handles missing child .git gracefully."""
-        # If .git doesn't exist, should just return parent_git
-        assert True  # Placeholder
-
-    def test_parent_strategy_degradation_to_child(self):
-        """Test parent strategy degrades to child when parent not found."""
-        # Expected behavior:
-        # 1. Search for parent git
-        # 2. Not found
-        # 3. Log warning about degradation
-        # 4. Create child git instead
-        # 5. self.git_root = project_dir
-        assert True  # Placeholder
-
-
-class TestGitStrategyNone:
-    """Test disabling git (git_strategy=None)."""
-
-    def test_none_strategy_disables_git(self):
-        """Test git_strategy=None disables git initialization."""
-        # Expected behavior:
-        # 1. No git initialization
-        # 2. self.git_root = None
-        # 3. Log message about git disabled
-        assert True  # Placeholder
-
-
-class TestProjectStructureVerification:
-    """Test project structure validation."""
-
-    def test_verify_structure_with_all_dirs(self):
-        """Test verification passes with all required directories."""
-        assert True  # Placeholder
-
-    def test_verify_structure_missing_manuscript(self):
-        """Test verification fails without 01_manuscript."""
-        assert True  # Placeholder
-
-    def test_verify_structure_missing_supplementary(self):
-        """Test verification fails without 02_supplementary."""
-        assert True  # Placeholder
-
-    def test_verify_structure_missing_revision(self):
-        """Test verification fails without 03_revision."""
-        assert True  # Placeholder
-
-    def test_verify_structure_error_message(self):
-        """Test verification error message identifies missing directory."""
-        assert True  # Placeholder
-
-
-class TestChildGitRemoval:
-    """Test _remove_child_git() functionality."""
-
-    @pytest.fixture
-    def project_with_git(self):
-        """Create project with .git folder."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_git_")
-        project_dir = Path(temp_dir)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        # Create fake .git
-        (project_dir / ".git").mkdir(parents=True, exist_ok=True)
-        (project_dir / ".git" / "HEAD").write_text("ref: refs/heads/main\n")
-
-        yield project_dir
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    def test_remove_child_git_success(self, project_with_git):
-        """Test successful removal of child .git."""
-        git_path = project_with_git / ".git"
-        assert git_path.exists()
-
-        # Simulate removal
-        shutil.rmtree(git_path)
-
-        assert not git_path.exists()
-
-    def test_remove_child_git_not_exists(self, project_with_git):
-        """Test handling when child .git doesn't exist."""
-        # Remove .git first
-        git_path = project_with_git / ".git"
-        shutil.rmtree(git_path)
-
-        # Should handle gracefully
-        assert not git_path.exists()
-
-
-class TestLoggingMessages:
-    """Test logging output."""
-
-    def test_init_logs_project_name(self):
-        """Test initialization logs project name."""
-        # Should log: "Project Name: <name>"
-        assert True  # Placeholder
-
-    def test_init_logs_project_directory(self):
-        """Test initialization logs project directory path."""
-        # Should log: "Project Directory: <path>"
-        assert True  # Placeholder
-
-    def test_init_logs_git_strategy(self):
-        """Test initialization logs git strategy."""
-        # Should log: "Git Strategy: <strategy>"
-        assert True  # Placeholder
-
-    def test_child_git_removal_logs_attempt(self):
-        """Test child git removal logs removal attempt."""
-        # Should log: "Removing project's child .git..."
-        assert True  # Placeholder
-
-    def test_child_git_removal_logs_success(self):
-        """Test child git removal logs success."""
-        # Should log: "Removed child .git from <path>"
-        assert True  # Placeholder
-
-    def test_parent_git_found_logs_path(self):
-        """Test finding parent git logs the path."""
-        # Should log: "Found parent git repository: <path>"
-        assert True  # Placeholder
-
-    def test_structure_verification_logs_success(self):
-        """Test structure verification logs success."""
-        # Should log: "Project structure verified at <path>"
-        assert True  # Placeholder
-
-    def test_structure_verification_logs_error(self):
-        """Test structure verification logs missing directory."""
-        # Should log: "Expected directory missing: <path>"
-        assert True  # Placeholder
-
-
-class TestErrorHandling:
-    """Test error handling and exceptions."""
-
-    def test_invalid_git_strategy_raises_error(self):
-        """Test invalid git_strategy raises ValueError."""
-        # Should raise: ValueError with message about unknown strategy
-        assert True  # Placeholder
-
-    def test_missing_project_structure_raises_error(self):
-        """Test missing directories raise RuntimeError."""
-        # Should raise: RuntimeError about missing directory
-        assert True  # Placeholder
-
-    def test_project_creation_failure_raises_error(self):
-        """Test project creation failure raises RuntimeError."""
-        assert True  # Placeholder
-
-    def test_git_init_failure_logs_warning(self):
-        """Test git initialization failure logs warning."""
-        # Should log warning, not raise
-        assert True  # Placeholder
-
-
-class TestBackwardCompatibility:
-    """Test backward compatibility with existing code."""
-
-    def test_default_git_strategy(self):
-        """Test default git_strategy is 'child'."""
-        # git_strategy parameter should default to "child"
-        assert True  # Placeholder
-
-    def test_public_api_unchanged(self):
-        """Test public API methods are unchanged."""
-        # Methods should still exist and have same signatures:
-        # - compile_manuscript()
-        # - compile_supplementary()
-        # - compile_revision()
-        # - watch()
-        # - get_pdf()
-        # - delete()
-        assert True  # Placeholder
-
-    def test_writer_instantiation_signature(self):
-        """Test Writer() instantiation signature unchanged."""
-        # Should accept: project_dir, name, git_strategy
-        assert True  # Placeholder
-
-
-class TestIntegration:
-    """Integration tests with real components."""
-
-    @pytest.mark.integration
-    def test_full_initialization_flow_child_strategy(self):
-        """Test complete initialization with child strategy."""
-        # 1. Create temp directory
-        # 2. Initialize Writer with git_strategy="child"
-        # 3. Verify project structure
-        # 4. Verify git initialized
-        # 5. Verify document trees created
-        assert True  # Placeholder
-
-    @pytest.mark.integration
-    def test_full_attachment_flow(self):
-        """Test complete attachment to existing project."""
-        # 1. Create valid project structure
-        # 2. Attach Writer to it
-        # 3. Verify structure validated
-        # 4. Verify document trees created
-        assert True  # Placeholder
-
-    @pytest.mark.integration
-    def test_full_parent_strategy_flow(self):
-        """Test complete flow with parent strategy."""
-        # This is complex and needs setup
-        assert True  # Placeholder
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

scitex/writer/tests/test_writer_integration.py

@@ -1,303 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Integration tests for Writer class with actual project creation and git operations.
-
-These tests use real temporary directories and git operations.
-"""
-
-import shutil
-import tempfile
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-from scitex.writer.Writer import Writer
-
-
-class TestWriterProjectAttachment:
-    """Test Writer attachment to existing projects."""
-
-    @pytest.fixture
-    def valid_project_dir(self):
-        """Create a valid project structure."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_valid_")
-        project_dir = Path(temp_dir)
-
-        # Create required structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        yield project_dir
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    @pytest.fixture
-    def invalid_project_dir(self):
-        """Create invalid project (missing required directories)."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_invalid_")
-        project_dir = Path(temp_dir)
-
-        # Only create one directory (incomplete)
-        (project_dir / "01_manuscript").mkdir(parents=True, exist_ok=True)
-
-        yield project_dir
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    def test_attach_to_valid_project_structure(self, valid_project_dir):
-        """Test Writer can attach to valid existing project."""
-        # Verify fixture setup
-        assert valid_project_dir.exists()
-        assert (valid_project_dir / "01_manuscript").exists()
-        assert (valid_project_dir / "02_supplementary").exists()
-        assert (valid_project_dir / "03_revision").exists()
-
-        # Test: Writer should not raise when attaching to valid structure
-        with patch("scitex.git.init_git_repo", return_value=None):
-            try:
-                writer = Writer(valid_project_dir, git_strategy=None)
-                assert writer.project_dir == valid_project_dir
-                assert writer.project_name == valid_project_dir.name
-            except RuntimeError:
-                pytest.fail("Valid project should not raise RuntimeError")
-
-    def test_attach_to_invalid_project_raises_error(self, invalid_project_dir):
-        """Test Writer raises error when attaching to invalid project."""
-        assert invalid_project_dir.exists()
-        assert (invalid_project_dir / "01_manuscript").exists()
-        assert not (invalid_project_dir / "02_supplementary").exists()
-
-        # Test: Writer should raise when structure is invalid
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with pytest.raises(RuntimeError) as exc_info:
-                writer = Writer(invalid_project_dir, git_strategy=None)
-
-            # Verify error message mentions missing directory
-            assert "Project structure invalid" in str(exc_info.value) or \
-                   "missing" in str(exc_info.value)
-
-
-class TestProjectStructureVerification:
-    """Test _verify_project_structure() method."""
-
-    @pytest.fixture
-    def writer_with_valid_project(self):
-        """Create Writer instance with valid project."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_verify_")
-        project_dir = Path(temp_dir)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.writer.Writer.ManuscriptTree"), \
-             patch("scitex.writer.Writer.SupplementaryTree"), \
-             patch("scitex.writer.Writer.RevisionTree"), \
-             patch("scitex.git.init_git_repo", return_value=None):
-            writer = Writer(project_dir, git_strategy=None)
-
-        yield writer
-
-        # Cleanup
-        if project_dir.exists():
-            shutil.rmtree(project_dir)
-
-    def test_verify_structure_success(self, writer_with_valid_project):
-        """Test structure verification succeeds with all directories."""
-        # Should not raise
-        try:
-            writer_with_valid_project._verify_project_structure()
-        except Exception as e:
-            pytest.fail(f"Structure verification should not raise: {e}")
-
-    def test_verify_structure_detects_missing_manuscript(self):
-        """Test verification detects missing 01_manuscript."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_no_ms_")
-        project_dir = Path(temp_dir)
-
-        # Create only supplementary and revision
-        (project_dir / "02_supplementary").mkdir(parents=True, exist_ok=True)
-        (project_dir / "03_revision").mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with pytest.raises(RuntimeError) as exc_info:
-                writer = Writer(project_dir, git_strategy=None)
-
-            assert "01_manuscript" in str(exc_info.value)
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-    def test_verify_structure_detects_missing_supplementary(self):
-        """Test verification detects missing 02_supplementary."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_no_supp_")
-        project_dir = Path(temp_dir)
-
-        # Create only manuscript and revision
-        (project_dir / "01_manuscript").mkdir(parents=True, exist_ok=True)
-        (project_dir / "03_revision").mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with pytest.raises(RuntimeError) as exc_info:
-                writer = Writer(project_dir, git_strategy=None)
-
-            assert "02_supplementary" in str(exc_info.value)
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-    def test_verify_structure_detects_missing_revision(self):
-        """Test verification detects missing 03_revision."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_no_rev_")
-        project_dir = Path(temp_dir)
-
-        # Create only manuscript and supplementary
-        (project_dir / "01_manuscript").mkdir(parents=True, exist_ok=True)
-        (project_dir / "02_supplementary").mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with pytest.raises(RuntimeError) as exc_info:
-                writer = Writer(project_dir, git_strategy=None)
-
-            assert "03_revision" in str(exc_info.value)
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-
-class TestChildGitRemoval:
-    """Test child git removal functionality.
-
-    Note: _remove_child_git() method has been refactored.
-    Git removal is now handled by scitex.git.init_git_repo() based on git_strategy.
-    These tests are kept for reference but skipped.
-    """
-
-    @pytest.mark.skip(reason="Method _remove_child_git() refactored into scitex.git module")
-    def test_remove_child_git_when_exists(self):
-        """Test removal of child .git folder."""
-        pass
-
-    @pytest.mark.skip(reason="Method _remove_child_git() refactored into scitex.git module")
-    def test_remove_child_git_when_not_exists(self):
-        """Test _remove_child_git handles missing .git gracefully."""
-        pass
-
-
-class TestProjectNameHandling:
-    """Test project name storage and usage."""
-
-    def test_project_name_from_explicit_parameter(self):
-        """Test Writer stores explicit project name parameter."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_name_")
-        project_dir = Path(temp_dir)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with patch("scitex.writer.Writer.ManuscriptTree"), \
-                 patch("scitex.writer.Writer.SupplementaryTree"), \
-                 patch("scitex.writer.Writer.RevisionTree"):
-                writer = Writer(project_dir, name="my_custom_paper", git_strategy=None)
-
-        assert writer.project_name == "my_custom_paper"
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-    def test_project_name_from_directory(self):
-        """Test Writer derives project name from directory if not provided."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_")
-        project_dir = Path(temp_dir) / "my_paper"
-        project_dir.mkdir(parents=True, exist_ok=True)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with patch("scitex.writer.Writer.ManuscriptTree"), \
-                 patch("scitex.writer.Writer.SupplementaryTree"), \
-                 patch("scitex.writer.Writer.RevisionTree"):
-                writer = Writer(project_dir, git_strategy=None)
-
-        assert writer.project_name == "my_paper"
-
-        # Cleanup
-        shutil.rmtree(temp_dir)
-
-
-class TestWriterAttributes:
-    """Test Writer instance attributes."""
-
-    def test_writer_has_project_dir(self):
-        """Test Writer stores project_dir."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_attr_")
-        project_dir = Path(temp_dir)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with patch("scitex.writer.Writer.ManuscriptTree"), \
-                 patch("scitex.writer.Writer.SupplementaryTree"), \
-                 patch("scitex.writer.Writer.RevisionTree"):
-                writer = Writer(project_dir, git_strategy=None)
-
-        assert hasattr(writer, "project_dir")
-        assert writer.project_dir == project_dir
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-    def test_writer_has_git_root(self):
-        """Test Writer stores git_root."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_git_root_")
-        project_dir = Path(temp_dir)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            with patch("scitex.writer.Writer.ManuscriptTree"), \
-                 patch("scitex.writer.Writer.SupplementaryTree"), \
-                 patch("scitex.writer.Writer.RevisionTree"):
-                writer = Writer(project_dir, git_strategy=None)
-
-        assert hasattr(writer, "git_root")
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-    def test_writer_has_document_trees(self):
-        """Test Writer creates document tree attributes."""
-        temp_dir = tempfile.mkdtemp(prefix="scitex_trees_")
-        project_dir = Path(temp_dir)
-
-        # Create structure
-        for dir_name in ["01_manuscript", "02_supplementary", "03_revision"]:
-            (project_dir / dir_name).mkdir(parents=True, exist_ok=True)
-
-        with patch("scitex.git.init_git_repo", return_value=None):
-            writer = Writer(project_dir, git_strategy=None)
-
-        assert hasattr(writer, "manuscript")
-        assert hasattr(writer, "supplementary")
-        assert hasattr(writer, "revision")
-
-        # Cleanup
-        shutil.rmtree(project_dir)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v", "-s"])