auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/terminal_paste/tests/test_paste_handler.py

@@ -0,0 +1,182 @@
+"""Tests for paste_handler functionality."""
+
+import unittest
+from unittest.mock import Mock, patch, MagicMock
+from autocoder.common.terminal_paste.paste_handler import (
+    register_paste_handler,
+    resolve_paste_placeholders,
+    get_paste_manager,
+    PLACEHOLDER_PATTERN
+)
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.clipboard import ClipboardData
+
+
+class TestPasteHandler(unittest.TestCase):
+    """Test cases for paste handler functionality."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        # Reset global paste manager
+        import autocoder.common.terminal_paste.paste_handler
+        autocoder.common.terminal_paste.paste_handler._paste_manager = None
+    
+    def test_register_paste_handler_no_error(self):
+        """Test that register_paste_handler runs without error."""
+        kb = KeyBindings()
+        # This should not raise any exception
+        register_paste_handler(kb)
+        
+        # Verify that a key binding was registered
+        self.assertTrue(len(kb.bindings) > 0)
+        
+        # Check that the binding is for 'c-p'
+        binding_found = False
+        for binding in kb.bindings:
+            if binding.keys == ('c-p',):
+                binding_found = True
+                break
+        self.assertTrue(binding_found, "Ctrl+P binding not found")
+    
+    def test_paste_handler_single_line(self):
+        """Test paste handler with single-line content."""
+        kb = KeyBindings()
+        register_paste_handler(kb)
+        
+        # Create mock event
+        mock_event = Mock()
+        mock_app = Mock()
+        mock_buffer = Mock()
+        mock_clipboard_data = Mock()
+        mock_clipboard_data.text = "single line text"
+        
+        mock_event.app = mock_app
+        mock_event.current_buffer = mock_buffer
+        mock_app.clipboard.get_data.return_value = mock_clipboard_data
+        
+        # Find and execute the paste handler
+        paste_handler = None
+        for binding in kb.bindings:
+            if binding.keys == ('c-p',):
+                paste_handler = binding.handler
+                break
+        
+        self.assertIsNotNone(paste_handler)
+        
+        # Execute the handler (we know it's not None due to assertion above)
+        if paste_handler:
+            paste_handler(mock_event)
+        
+        # Verify single line was pasted normally
+        mock_buffer.insert_text.assert_called_once_with("single line text")
+    
+    def test_paste_handler_multi_line(self):
+        """Test paste handler with multi-line content."""
+        kb = KeyBindings()
+        register_paste_handler(kb)
+        
+        # Create mock event
+        mock_event = Mock()
+        mock_app = Mock()
+        mock_buffer = Mock()
+        mock_clipboard_data = Mock()
+        mock_clipboard_data.text = "line 1\nline 2\nline 3"
+        
+        mock_event.app = mock_app
+        mock_event.current_buffer = mock_buffer
+        mock_app.clipboard.get_data.return_value = mock_clipboard_data
+        
+        # Mock the paste manager
+        with patch('autocoder.common.terminal_paste.paste_handler.get_paste_manager') as mock_get_paste_manager:
+            mock_paste_manager = Mock()
+            mock_paste_manager.save_paste.return_value = "pasted-abc123def45678901234567890123456"
+            mock_get_paste_manager.return_value = mock_paste_manager
+            
+            # Find and execute the paste handler
+            paste_handler = None
+            for binding in kb.bindings:
+                if binding.keys == ('c-p',):
+                    paste_handler = binding.handler
+                    break
+            
+            self.assertIsNotNone(paste_handler)
+            
+            # Execute the handler (we know it's not None due to assertion above)
+            if paste_handler:
+                paste_handler(mock_event)
+            
+            # Verify multi-line content was saved and placeholder inserted
+            mock_paste_manager.save_paste.assert_called_once_with("line 1\nline 2\nline 3")
+            mock_buffer.insert_text.assert_called_once_with("[pasted-abc123def45678901234567890123456]")
+    
+    def test_get_paste_manager(self):
+        """Test that get_paste_manager returns a PasteManager instance."""
+        manager = get_paste_manager()
+        self.assertIsNotNone(manager)
+        
+        # Test that it returns the same instance on subsequent calls
+        manager2 = get_paste_manager()
+        self.assertIs(manager, manager2)
+    
+    def test_resolve_paste_placeholders_no_placeholders(self):
+        """Test resolving text without placeholders."""
+        text = "This is normal text without placeholders"
+        result = resolve_paste_placeholders(text)
+        self.assertEqual(result, text)
+    
+    def test_resolve_paste_placeholders_with_placeholder(self):
+        """Test resolving text with placeholders."""
+        with patch('autocoder.common.terminal_paste.paste_handler.get_paste_manager') as mock_get_paste_manager:
+            mock_paste_manager = Mock()
+            mock_paste_manager.read_paste.return_value = "Hello World"
+            mock_get_paste_manager.return_value = mock_paste_manager
+            
+            text_with_placeholder = "Say [pasted-abc123def45678901234567890123456]"
+            result = resolve_paste_placeholders(text_with_placeholder)
+            
+            expected = "Say Hello World"
+            self.assertEqual(result, expected)
+            mock_paste_manager.read_paste.assert_called_once_with("pasted-abc123def45678901234567890123456")
+    
+    def test_resolve_multiple_placeholders(self):
+        """Test resolving multiple placeholders in one text."""
+        with patch('autocoder.common.terminal_paste.paste_handler.get_paste_manager') as mock_get_paste_manager:
+            mock_paste_manager = Mock()
+            # The resolve function calls read_paste with "pasted-" + file_id
+            mock_paste_manager.read_paste.side_effect = lambda file_id: {
+                "pasted-abc123def45678901234567890123456": "Hello",
+                "pasted-def456abc78901234567890123456abc": "World"
+            }.get(file_id, "Not found")
+            mock_get_paste_manager.return_value = mock_paste_manager
+            
+            # Test with multiple placeholders (both 32 chars)
+            text_with_placeholders = "Say [pasted-abc123def45678901234567890123456] [pasted-def456abc78901234567890123456abc]!"
+            result = resolve_paste_placeholders(text_with_placeholders)
+            
+            expected = "Say Hello World!"
+            self.assertEqual(result, expected)
+    
+    def test_placeholder_pattern_regex(self):
+        """Test that the placeholder pattern matches correctly."""
+        # Test valid placeholder
+        valid_placeholder = "[pasted-abc123def45678901234567890123456]"
+        match = PLACEHOLDER_PATTERN.search(valid_placeholder)
+        self.assertIsNotNone(match)
+        if match:  # Fix linter error by checking match is not None
+            self.assertEqual(match.group(1), "abc123def45678901234567890123456")
+        
+        # Test invalid placeholders
+        invalid_placeholders = [
+            "[pasted-short]",  # Too short
+            "[pasted-abc123def45678901234567890123456extra]",  # Too long
+            "[pasted-abc123def45678901234567890123456X]",  # Contains invalid character
+            "pasted-abc123def45678901234567890123456",  # Missing brackets
+        ]
+        
+        for invalid in invalid_placeholders:
+            match = PLACEHOLDER_PATTERN.search(invalid)
+            self.assertIsNone(match, f"Pattern should not match: {invalid}")
+
+
+if __name__ == '__main__':
+    unittest.main() 

autocoder/common/terminal_paste/tests/test_paste_manager.py

@@ -0,0 +1,126 @@
+"""Tests for PasteManager."""
+
+import os
+import tempfile
+import shutil
+import unittest
+from unittest.mock import patch
+from autocoder.common.terminal_paste.paste_manager import PasteManager
+
+
+class TestPasteManager(unittest.TestCase):
+    """Test cases for PasteManager."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.paste_manager = PasteManager(self.temp_dir)
+    
+    def tearDown(self):
+        """Clean up test environment."""
+        shutil.rmtree(self.temp_dir)
+    
+    def test_initialization(self):
+        """Test PasteManager initialization."""
+        # Test with custom directory
+        manager = PasteManager(self.temp_dir)
+        expected_paste_dir = os.path.join(self.temp_dir, ".auto-coder", "pastes")
+        self.assertEqual(manager.paste_dir, expected_paste_dir)
+        self.assertTrue(os.path.exists(expected_paste_dir))
+        
+        # Test with default directory (current working directory)
+        with patch('os.getcwd', return_value=self.temp_dir):
+            manager = PasteManager()
+            self.assertEqual(manager.paste_dir, expected_paste_dir)
+    
+    def test_save_paste(self):
+        """Test saving paste content."""
+        content = "Hello, World!\nThis is a test paste."
+        file_id = self.paste_manager.save_paste(content)
+        
+        # Check file ID format
+        self.assertTrue(file_id.startswith("pasted-"))
+        self.assertEqual(len(file_id), 39)  # "pasted-" + 32 hex chars
+        
+        # Check file exists and content is correct
+        file_path = os.path.join(self.paste_manager.paste_dir, file_id)
+        self.assertTrue(os.path.exists(file_path))
+        
+        with open(file_path, "r", encoding="utf-8") as f:
+            saved_content = f.read()
+        self.assertEqual(saved_content, content)
+    
+    def test_read_paste(self):
+        """Test reading paste content."""
+        content = "Test content for reading"
+        file_id = self.paste_manager.save_paste(content)
+        
+        # Test reading with full file ID
+        read_content = self.paste_manager.read_paste(file_id)
+        self.assertEqual(read_content, content)
+        
+        # Test reading with UUID only (without "pasted-" prefix)
+        uuid_only = file_id[7:]  # Remove "pasted-" prefix
+        read_content = self.paste_manager.read_paste(uuid_only)
+        self.assertEqual(read_content, content)
+        
+        # Test reading non-existent file
+        non_existent = self.paste_manager.read_paste("pasted-nonexistent")
+        self.assertIsNone(non_existent)
+    
+    def test_list_pastes(self):
+        """Test listing paste files."""
+        # Initially empty
+        pastes = self.paste_manager.list_pastes()
+        self.assertEqual(len(pastes), 0)
+        
+        # Add some pastes
+        content1 = "First paste"
+        content2 = "Second paste"
+        file_id1 = self.paste_manager.save_paste(content1)
+        file_id2 = self.paste_manager.save_paste(content2)
+        
+        pastes = self.paste_manager.list_pastes()
+        self.assertEqual(len(pastes), 2)
+        self.assertIn(file_id1, pastes)
+        self.assertIn(file_id2, pastes)
+        
+        # Check sorting
+        self.assertEqual(pastes, sorted(pastes))
+    
+    def test_cleanup_old_pastes(self):
+        """Test cleaning up old paste files."""
+        # Create some paste files
+        content = "Test content"
+        file_id1 = self.paste_manager.save_paste(content)
+        file_id2 = self.paste_manager.save_paste(content)
+        
+        # Initially no cleanup (files are new)
+        cleaned = self.paste_manager.cleanup_old_pastes(max_age_hours=24)
+        self.assertEqual(cleaned, 0)
+        
+        # Mock old files by setting max_age_hours to 0
+        cleaned = self.paste_manager.cleanup_old_pastes(max_age_hours=0)
+        self.assertEqual(cleaned, 2)
+        
+        # Verify files are gone
+        pastes = self.paste_manager.list_pastes()
+        self.assertEqual(len(pastes), 0)
+    
+    def test_error_handling(self):
+        """Test error handling in PasteManager."""
+        # Test save_paste with invalid directory
+        with patch('builtins.open', side_effect=PermissionError("Permission denied")):
+            with self.assertRaises(RuntimeError) as context:
+                self.paste_manager.save_paste("test")
+            self.assertIn("Failed to save paste content", str(context.exception))
+        
+        # Test read_paste with invalid file
+        with patch('builtins.open', side_effect=PermissionError("Permission denied")):
+            with self.assertRaises(RuntimeError) as context:
+                self.paste_manager.read_paste("pasted-test")
+            self.assertIn("Failed to read paste file", str(context.exception))
+
+
+if __name__ == "__main__":
+    unittest.main() 

autocoder/common/terminal_paste/utils.py

@@ -0,0 +1,163 @@
+"""Utility functions for terminal paste module."""
+
+import os
+import re
+from typing import Optional, Tuple
+from datetime import datetime, timedelta
+
+
+def is_valid_paste_id(paste_id: str) -> bool:
+    """Check if a paste ID is valid.
+    
+    Args:
+        paste_id: Paste ID to validate
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    if not paste_id:
+        return False
+        
+    # Handle both "pasted-<uuid>" and just "<uuid>" formats
+    if paste_id.startswith("pasted-"):
+        uuid_part = paste_id[7:]  # Remove "pasted-" prefix
+    else:
+        uuid_part = paste_id
+        
+    # Check if it's a valid 32-character hex string (UUID without dashes)
+    return bool(re.match(r"^[0-9a-f]{32}$", uuid_part))
+
+
+def format_paste_info(paste_id: str, paste_dir: str) -> Optional[dict]:
+    """Get formatted information about a paste file.
+    
+    Args:
+        paste_id: Paste file ID
+        paste_dir: Directory containing paste files
+        
+    Returns:
+        Dictionary with paste information or None if file not found
+    """
+    if not is_valid_paste_id(paste_id):
+        return None
+        
+    # Ensure paste_id has proper format
+    if not paste_id.startswith("pasted-"):
+        paste_id = f"pasted-{paste_id}"
+        
+    file_path = os.path.join(paste_dir, paste_id)
+    
+    if not os.path.exists(file_path):
+        return None
+        
+    try:
+        stat = os.stat(file_path)
+        created_time = datetime.fromtimestamp(stat.st_ctime)
+        modified_time = datetime.fromtimestamp(stat.st_mtime)
+        file_size = stat.st_size
+        
+        # Read first few lines for preview
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            lines = content.splitlines()
+            preview = "\n".join(lines[:3])
+            if len(lines) > 3:
+                preview += f"\n... ({len(lines) - 3} more lines)"
+                
+        return {
+            "id": paste_id,
+            "path": file_path,
+            "size": file_size,
+            "created": created_time,
+            "modified": modified_time,
+            "line_count": len(lines),
+            "preview": preview[:200] + "..." if len(preview) > 200 else preview
+        }
+        
+    except Exception:
+        return None
+
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format.
+    
+    Args:
+        size_bytes: Size in bytes
+        
+    Returns:
+        Formatted size string
+    """
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+    else:
+        return f"{size_bytes / (1024 * 1024 * 1024):.1f} GB"
+
+
+def format_time_ago(timestamp: datetime) -> str:
+    """Format timestamp as time ago string.
+    
+    Args:
+        timestamp: Timestamp to format
+        
+    Returns:
+        Human-readable time ago string
+    """
+    now = datetime.now()
+    diff = now - timestamp
+    
+    if diff.days > 0:
+        return f"{diff.days} day{'s' if diff.days > 1 else ''} ago"
+    elif diff.seconds > 3600:
+        hours = diff.seconds // 3600
+        return f"{hours} hour{'s' if hours > 1 else ''} ago"
+    elif diff.seconds > 60:
+        minutes = diff.seconds // 60
+        return f"{minutes} minute{'s' if minutes > 1 else ''} ago"
+    else:
+        return "just now"
+
+
+def extract_placeholder_ids(text: str) -> list[str]:
+    """Extract all paste placeholder IDs from text.
+    
+    Args:
+        text: Text to search for placeholders
+        
+    Returns:
+        List of paste IDs found in text
+    """
+    if not text:
+        return []
+        
+    pattern = re.compile(r"\[pasted-([0-9a-f]{32})\]")
+    matches = pattern.findall(text)
+    return [f"pasted-{match}" for match in matches]
+
+
+def validate_paste_directory(paste_dir: str) -> Tuple[bool, str]:
+    """Validate paste directory and return status.
+    
+    Args:
+        paste_dir: Directory path to validate
+        
+    Returns:
+        Tuple of (is_valid, message)
+    """
+    try:
+        if not os.path.exists(paste_dir):
+            return False, f"Directory does not exist: {paste_dir}"
+            
+        if not os.path.isdir(paste_dir):
+            return False, f"Path is not a directory: {paste_dir}"
+            
+        if not os.access(paste_dir, os.R_OK | os.W_OK):
+            return False, f"Directory is not readable/writable: {paste_dir}"
+            
+        return True, "Directory is valid"
+        
+    except Exception as e:
+        return False, f"Error validating directory: {e}"