Favor unit tests

CLAUDE.md

@@ -49,8 +49,9 @@ tests/
 │   │   ├── test_ada_converter_agent.py     # Unit tests for AdaConverterAgent
 │   │   ├── test_unit_test_generator_agent.py  # Unit tests for UnitTestGeneratorAgent
 │   │   └── tictactoe.ads                    # Sample Ada file for testing
-│   └── tools/
-│       └── test_project_handler.py         # Unit tests for project handler
+│   ├── tools/
+│   │   └── test_project_handler.py         # Unit tests for project handler
+│   └── test_ui.py                           # Unit tests for UI file selection logic
 ├── integration/
 │   └── test_e2e_ada_analysis.py        # End-to-end tests with Playwright
 ├── test_data/
@@ -85,17 +86,19 @@ uv.lock                    # UV lockfile for reproducible dependencies
     * Handles error conditions and provides fallback responses for generation failures
 
 ## Testing Strategy
-  * **Unit Tests**: Test individual agents and utilities in isolation
-    * Located in `tests/unit/agents/` and `tests/unit/tools/`
+  * **Unit Tests**: Test individual agents, utilities, and UI components in isolation
+    * Located in `tests/unit/agents/`, `tests/unit/tools/`, and `tests/unit/test_ui.py`
     * Use mock LLM models to avoid external dependencies
-    * Fast execution (~0.15s for 11 tests)
+    * Comprehensive error handling and edge case coverage
+    * Fast execution (~0.94s for 19 tests)
     * Run with: `uv run pytest tests/unit/ -v`
   
   * **Integration Tests**: Test complete user workflows end-to-end
     * Located in `tests/integration/`
     * Use Playwright for browser automation with Chromium
-    * Test zip upload, file extraction, file selection, and UI workflows
+    * Focus on core workflow: zip upload, file extraction, file selection, and analysis display
     * Requires Ollama running for local development
+    * Streamlined to 1 comprehensive test (~27s execution)
     * Run with: `uv run pytest tests/integration/ --browser chromium`
   
   * **Test Configuration**: 

README.md

@@ -123,8 +123,9 @@ tests/
 │   │   ├── test_ada_converter_agent.py
 │   │   ├── test_unit_test_generator_agent.py
 │   │   └── tictactoe.ads       # Test Ada file
-│   └── tools/
-│       └── test_project_handler.py
+│   ├── tools/
+│   │   └── test_project_handler.py
+│   └── test_ui.py              # UI file selection logic tests
 ├── integration/                # E2E tests (browser automation)
 │   └── test_e2e_ada_analysis.py
 ├── test_data/                  # Sample test files

tests/integration/test_e2e_ada_analysis.py

@@ -1,12 +1,9 @@
 """End-to-end integration tests for Ada Assistant using Playwright."""
 
-import os
 import time
 import pytest
 from playwright.sync_api import Page, expect
 import subprocess
-import tempfile
-import shutil
 
 
 pytestmark = [pytest.mark.integration, pytest.mark.e2e]
@@ -121,75 +118,4 @@ def test_ada_project_upload_and_analysis(page: Page, gradio_app, test_zip_path):
     print("✓ Integration test passed: File upload, extraction, and selection workflow completed")
 
 
-def test_non_ada_file_selection(page: Page, gradio_app):
-    """Test that non-Ada files don't trigger analysis."""
-    _ = gradio_app  # Suppress unused parameter warning
-    
-    # Create a temporary zip with non-Ada files
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Create a Python file
-        python_file = os.path.join(temp_dir, "test.py")
-        with open(python_file, "w") as f:
-            f.write("print('Hello World')")
-        
-        # Create zip file
-        zip_path = os.path.join(temp_dir, "non_ada_project.zip")
-        shutil.make_archive(zip_path[:-4], 'zip', temp_dir, "test.py")
-        
-        # Navigate to the app
-        page.goto("http://localhost:7860")
-        page.wait_for_selector("text=Ada Assistant - Project Analyzer", timeout=30000)
-        
-        # Upload the non-Ada zip file
-        file_input = page.locator('[data-testid="file-upload"]')
-        file_input.set_input_files(zip_path)
-        
-        # Wait for processing
-        try:
-            page.wait_for_selector("text=Project extracted to:", timeout=10000)
-        except:
-            time.sleep(5)  # Fallback wait
-        
-        # Click on the Python file
-        python_file_element = page.locator("text=test.py").first
-        if python_file_element.is_visible():
-            python_file_element.click()
-            time.sleep(2)
-            
-            # Verify that analysis sections remain unchanged (should still show default message)
-            # Check if the default message is still visible (meaning no analysis was triggered)
-            select_file_text = page.locator("text=Select file to view analysis")
-            expect(select_file_text).to_be_visible()
-
 
-def test_upload_invalid_file(page: Page, gradio_app):
-    """Test handling of invalid file upload."""
-    _ = gradio_app  # Suppress unused parameter warning
-    
-    # Create a temporary text file (not a zip)
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
-        temp_file.write("This is not a zip file")
-        temp_path = temp_file.name
-    
-    try:
-        # Navigate to the app
-        page.goto("http://localhost:7860")
-        page.wait_for_selector("text=Ada Assistant - Project Analyzer", timeout=30000)
-        
-        # Try to upload the text file
-        file_input = page.locator('[data-testid="file-upload"]')
-        file_input.set_input_files(temp_path)
-        
-        # Wait a moment to see if error handling occurs
-        time.sleep(3)
-        
-        # Check for error message in project status
-        project_status = page.locator('label:has-text("Project Status")')
-        if project_status.is_visible():
-            # For invalid files, the project status should either show an error or remain unchanged
-            # We just verify the status area is present
-            expect(project_status).to_be_visible()
-    
-    finally:
-        # Cleanup
-        os.unlink(temp_path)

tests/unit/test_ui.py

@@ -0,0 +1,145 @@
+"""Unit tests for UI components and logic."""
+
+import unittest.mock as mock
+import tempfile
+import os
+from src.ui import create_file_selection_handler, handle_zip_upload
+
+
+class TestFileSelectionHandler:
+    """Test cases for file selection handler logic."""
+    
+    def test_handle_non_ada_file_returns_empty_results(self):
+        """Test that non-Ada files return empty results and hidden components."""
+        # Create mock agents
+        mock_analyzer = mock.Mock()
+        mock_converter = mock.Mock()
+        mock_test_generator = mock.Mock()
+        
+        # Create the handler
+        handler = create_file_selection_handler(mock_analyzer, mock_converter, mock_test_generator)
+        
+        # Test with Python file
+        result = handler("test.py")
+        
+        # Should return empty strings and False visibility for all components
+        analysis_result, python_code, unit_tests, analysis_visible, python_visible, tests_visible = result
+        
+        assert analysis_result == ""
+        assert python_code == ""  
+        assert unit_tests == ""
+        assert analysis_visible.visible == False
+        assert python_visible.visible == False
+        assert tests_visible.visible == False
+        
+        # Ensure no agents were called
+        mock_analyzer.extract_business_logic.assert_not_called()
+        mock_converter.convert_to_python.assert_not_called()
+        mock_test_generator.generate_unit_tests.assert_not_called()
+    
+    def test_handle_empty_file_selection_returns_empty_results(self):
+        """Test that empty file selection returns empty results."""
+        # Create mock agents
+        mock_analyzer = mock.Mock()
+        mock_converter = mock.Mock()
+        mock_test_generator = mock.Mock()
+        
+        # Create the handler
+        handler = create_file_selection_handler(mock_analyzer, mock_converter, mock_test_generator)
+        
+        # Test with None/empty selection
+        result = handler(None)
+        
+        # Should return empty strings and False visibility for all components
+        analysis_result, python_code, unit_tests, analysis_visible, python_visible, tests_visible = result
+        
+        assert analysis_result == ""
+        assert python_code == ""
+        assert unit_tests == ""
+        assert analysis_visible.visible == False
+        assert python_visible.visible == False
+        assert tests_visible.visible == False
+        
+        # Ensure no agents were called
+        mock_analyzer.extract_business_logic.assert_not_called()
+        mock_converter.convert_to_python.assert_not_called()
+        mock_test_generator.generate_unit_tests.assert_not_called()
+        
+    def test_handle_various_non_ada_file_extensions(self):
+        """Test that various non-Ada file extensions are properly rejected."""
+        # Create mock agents
+        mock_analyzer = mock.Mock()
+        mock_converter = mock.Mock()
+        mock_test_generator = mock.Mock()
+        
+        # Create the handler
+        handler = create_file_selection_handler(mock_analyzer, mock_converter, mock_test_generator)
+        
+        # Test various non-Ada file types
+        non_ada_files = ["test.py", "main.c", "config.txt", "data.json", "readme.md", "script.sh"]
+        
+        for file_path in non_ada_files:
+            result = handler(file_path)
+            analysis_result, python_code, unit_tests, analysis_visible, python_visible, tests_visible = result
+            
+            # All should return empty results
+            assert analysis_result == "", f"Failed for {file_path}"
+            assert python_code == "", f"Failed for {file_path}"
+            assert unit_tests == "", f"Failed for {file_path}"
+            assert analysis_visible.visible == False, f"Failed for {file_path}"
+            assert python_visible.visible == False, f"Failed for {file_path}"
+            assert tests_visible.visible == False, f"Failed for {file_path}"
+        
+        # Ensure no agents were called for any file
+        mock_analyzer.extract_business_logic.assert_not_called()
+        mock_converter.convert_to_python.assert_not_called()
+        mock_test_generator.generate_unit_tests.assert_not_called()
+
+
+class TestZipUploadHandler:
+    """Test cases for zip upload handler logic."""
+    
+    def test_handle_zip_upload_with_none_file(self):
+        """Test that None file upload returns appropriate message."""
+        result = handle_zip_upload(None)
+        
+        # Should return None path and error message
+        extracted_path, message = result
+        assert extracted_path is None
+        assert message == "No zip file uploaded"
+    
+    def test_handle_zip_upload_with_invalid_file(self):
+        """Test that invalid zip file returns error message."""
+        # Create a mock file object with a non-zip file
+        mock_file = mock.Mock()
+        
+        # Create a temporary text file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+            temp_file.write("This is not a zip file")
+            mock_file.name = temp_file.name
+        
+        try:
+            result = handle_zip_upload(mock_file)
+            
+            # Current behavior: extract_project returns error string, handle_zip_upload treats it as path
+            extracted_path, message = result
+            assert "Error processing file:" in extracted_path
+            assert "Project extracted to:" in message
+            assert "Error processing file:" in message
+        finally:
+            # Cleanup
+            os.unlink(mock_file.name)
+    
+    def test_handle_zip_upload_with_nonexistent_file(self):
+        """Test that non-existent file returns error message."""
+        # Create a mock file object with non-existent path
+        mock_file = mock.Mock()
+        mock_file.name = "/path/that/does/not/exist.zip"
+        
+        result = handle_zip_upload(mock_file)
+        
+        # Current behavior: extract_project returns error string, handle_zip_upload treats it as path
+        extracted_path, message = result
+        assert "Error processing file:" in extracted_path
+        assert "Project extracted to:" in message
+        assert "Error processing file:" in message

tests/unit/tools/test_project_handler.py

@@ -60,6 +60,29 @@ class TestUnzipProject:
                 finally:
                     # Cleanup
                     os.unlink(temp_zip.name)
+    
+    def test_unzip_project_with_invalid_zip_file(self):
+        """Test unzip_project raises exception for invalid ZIP files."""
+        # Create a text file that's not a ZIP
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+            temp_file.write("This is not a zip file")
+            temp_path = temp_file.name
+        
+        try:
+            # Should raise an exception when trying to unzip invalid file
+            with pytest.raises(zipfile.BadZipFile):
+                unzip_project(temp_path)
+        finally:
+            # Cleanup
+            os.unlink(temp_path)
+    
+    def test_unzip_project_with_nonexistent_file(self):
+        """Test unzip_project raises exception for non-existent files."""
+        nonexistent_path = "/path/that/does/not/exist.zip"
+        
+        # Should raise FileNotFoundError for non-existent file
+        with pytest.raises(FileNotFoundError):
+            unzip_project(nonexistent_path)
 
 
 class TestBuildDirectoryTree: